从抽象类继承的类是否需要具有相同签名的方法？

Question

I'm a bit confused at some code I recently came across. Here is a snippet. First of the Abstract Class Definition and then of the Class that inherits from it:

public abstract class BaseClass
{
    protected static void MapEntityToModel(string paramOne, List<TypeDef> types)
    {
        // Some Logic Here
    }
    protected static void MapModelToEntity(ModelType model, ResultType result)
    {
        // Some Logic Here
    }
} 

public class BaseExtension : BaseClass
{
    public static ViewModel MapModelToViewModel(Model m)
    {
        var result = new ViewModel();
        // Some Logic Here
        return result;
    }
    public static List<ViewModel> MapModelsToViewModels(List<TModel> models)
    {
        return models.Select(m => MapModelToViewModel(m)).ToList();
    }

    public static Model MapViewModelToModel(ViewModel v)
    {
        var result = new Model();
        // Some Logic Here
        return result;
    }
}

So my understanding and usage of an Abstract Class has always been that any abstract methods within an Abstract Class must be overridden in the inherited Classes. If a method within an Abstract Class is not declared abstract, the derived Class can create an instance of itself within a method and directly call the non-abstract method of the Abstract Class.

But in either case the methods of the Abstract Class are used in the Derived Class. However, given the previous code snippets the Derived Class has no directly mapped signature or usage.

What then is the purpose of the Abstract Class in this particular scenario and why does it compile without error? I obviously am missing some concept of the Abstract Class and its appropriate implementation.

Answer 1

static methods are not part of instances of the class

when you are saying a class is abstract you are saying that you cannot create instances of it.

Abstract on those classes serves no purpose apart from highlighting that creating instances of them is pointless as all methods are static anyway.

Also inheriting from them seems a little pointless as nothing is inherited - all the members are static. You may as well have only the inherited class and make the base class an empty interface and move the static methods in it into the inherited class (an interface is in effect an abstract class with no method implementations - but you would normally have what are in effect abstract method definitions though)

abstract class a
{
    public  abstract string look();

    public static string lookStatic()
    {
        return "look";
    }
}

class b : a
{
    public override string look()
    {
        return "look member";
    }
}

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(b.lookStatic());
        var test = new b();
        Console.WriteLine(test.look());
        var c = (a) test;
        Console.WriteLine(c.look());
        Console.ReadLine();
    }
}

Answer 2

So my understanding and usage of an Abstract Class has always been that any abstract methods within an Abstract Class must be overridden in the inherited Classes

That is true, but the methods are not abstract, they are concrete (and static). Only virtual or abstract instance methods can be overridden.

What then is the purpose of the Abstract Class in this particular scenario and why does it compile without error?

Since the class has no abstract methods or properties I do not see why it is abstract, other than the author doesn't instances created for some reason.