c# - 用具体类型覆盖抽象方法

Question

也许这是个愚蠢的问题。但是，我不明白我错过了什么。

给定以下类定义

public abstract class AbstractBaseClass
{
    public abstract void Create(AnotherAbstractClass param1);
}

Wheras AnotherAbstractClass 已定义

public abstract class AnotherAbstractClass
{
}

具体实现

public class AnotherConcreteImplementation : AnotherAbstractClass
{
}

我希望能够重写 Create 方法以使用具体类型:

public class ConcreteImplementation : AbstractBaseClass
{
    public override void Create(AnotherConcreteImplementation param1) <-- There is no suitable method for override
    {
        // param1 is an instance of the concrete implementation
    }

    public override void Create(AnotherAbstractClass param1) <-- this is working but I'll have to cast on each implementation
    {
        // param1 is an instance of the abstract class and needs a cast
    }
}

这是根本不可能的，还是有什么我不知道的方法？也许使用泛型？

编辑 #1(添加更多上下文)

我试图实现/强制在具体实现中只有一个参数有效。把它想象成一个数据库层。 Create 方法将在数据库中创建一个新条目。由于每个表都有不同的值，create-parameter也有。内部类型转换的味道(在我看来)可以通过 AnotherAbstractClass 的任何具体实现来调用。

public class AddressTable : AbstractBaseClass
{
    public override void Create(AnotherAbstractClass param1)
    {
        // cast to concrete instance
        var casted = (ConcreteAddressCreate)param1;
    }
}

public class CityTable : AbstractBaseClass
{
    public override void Create(AnotherAbstractClass param1)
    {
        // cast to concrete instance
        var casted = (ConcreteCityCreate)param1;
    }
}

有了 AddressTable 的实例，我可以调用

addressIntance.Create(new ConcreteAddressCreate()); // would be okay

另一方面我可以调用它

addressIntance.Create(new ConcreteCityCreate()); // would be okay but will fail at runtime with InvalidCastException

编辑 #2(附加信息)

以后也应该可以用更多抽象方法扩展AbstractBaseClass 类。因此，对我来说，它更有可能使用通用方法，而不是具体的类实现，每个方法要实现 200 个通用参数。

Answer 1

它违反了 Liskov 替换原则，因此您不能这样做是完全合理的。也就是说，您不能免费“拥有”这样的协方差:

AbstractBaseClass bcl = new ConcreteImplementation();
bcl.Create(new DifferentImplementationWithoutSecondAbstract());

契约(Contract) AbstractBaseClass 定义使得 Create 必须与传入的 AbstractBaseClass 的任何 实现一起工作 - 如果您对什么可以是通过你违反了它定义的契约(Contract)。

就像您假设的那样 - 您可以使用泛型:

// notice the recursive definition, we require the generic parameter
// to be a generic parameter of itself - allowing AbstractBaseClass
// to not be aware of its subclasses like in the other answers.
public abstract class AbstractBaseClass<T> where T : AbstractBaseClass<T>
{
    public abstract void Create(T param1);
}

public class Concrete : AbstractBaseClass<Concrete>
{
    public override void Create(Concrete param1)
    {
        Console.WriteLine("Hello!");
    }
}