用具体类型覆盖的抽象方法

Question

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

给定以下类定义

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

Weras 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());

AbstractBaseClass 定义的合同使Create 必须与传入的AbstractBaseClass 的任何实现一起工作 - 如果您对可以传入的内容进行限制，则您违反了它定义的合同.

如您所料 - 您可以使用泛型：

// 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!");
    }
}

Answer 2

是的，您可以使用泛型来做到这一点：

public abstract class AbstractBaseClass<T>
    where T : AnotherAbstractClass
{
    public abstract void Create(T param1);
}

public class ConcreteImplementation : AbstractBaseClass<AnotherConcreteImplementation>
{
    public override void Create(AnotherConcreteImplementation param1)
    {
    }
}

Answer 3

泛型确实是这样做的方法。

public abstract class AbstractBaseClass<TDerivedClass> where TDerivedClass : AnotherAbstractClass
{
    public abstract void Create(TDerivedClass param1);
}

然后你可以这样做：

public class ConcreteImplementation : AbstractBaseClass<AnotherConcreteImplementation>
{
    public override void Create(AnotherConcreteImplementation param1) // Works because TDerivedClass = AnotherConcreteImplementation 
    {
        ...
    }
}