抽象方法被混凝土類型覆蓋

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方法將在數據庫中創建一個新條目。由於每個表具有不同的值，因此創建參數也具有。 可以通過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 
    { 
     ... 
    } 
}