C# 泛型和多态性：矛盾吗？

Question

我只是想确认一下我对 C# 中的泛型的理解。这已经出现在我工作过的几个代码库中，其中通用基类用于创建类型安全的派生实例。我所说的一个非常简单的例子，

public class SomeClass<T>
{
    public virtual void SomeMethod(){ }
}

public class DeriveFrom :SomeClass<string>
{
    public override void SomeMethod()
    {
        base.SomeMethod();
    }
}

当我想以多态方式使用派生实例时，问题就出现了。

public class ClientCode
{
    public void DoSomethingClienty()
    {
        Factory factory = new Factory();
        //Doesn't compile because SomeClass needs a type parameter!
        SomeClass someInstance = factory.Create();

        someInstance.SomeMethod();
    }
}

似乎一旦将 Generic 引入到继承层次结构或接口中，您就不能再以多态方式使用该类族，除非它可能是其内部的。这是真的吗？

Answer 1

我更喜欢使用抽象类作为所有泛型类型的基础。

public abstract class SomeClass 
{
    public abstract void SomeMethod();
}

public class SomeClass<T> : SomeClass
{
    public override void SomeMethod() { }            
}

public class DeriveFrom<String> : SomeClass<String>
{
    public override void SomeMethod() { base.SomeMethod(); }            
}

Answer 2

public Class ReflectionReport<T> 
{
    // This class uses Reflection to produce column-based grids for reporting.  
    // However, you need a type in order to know what the columns are. 
}

... so, in another class you have...

public Class ReflectionReportProject {
    ReflectionReport<Thang> thangReport = new ReflectionReport<Thang>(); 
    ReflectionReport<Thong> thongReport = new ReflectionReport<Thong>(); 



    ... some more stuff ...

    // Now, you want to pass off all of the reports to be processed at one time....
    public ReflectionReport<????>[] ProvideReports() 
    {
        return new ReflectionReport<????>[] { thangReport, thongReport } ;
    }
}

Answer 3

似乎一旦将泛型引入到继承层次结构或接口中，就不能再以多态方式使用该类族

没错，和这种情况很相似：

class StringContainer
{
}

class IntContainer
{
}

StringContainer container = new IntContainer(); // fails to compile

但你可以这样做：

class Container
{
}

class Container<T> : Container
{
}

Container container = new Container<String>(); // OK

Answer 4

我认为您正在寻找的是：

 SomeClass(of someType) someInstance = factory(of someType).Create();
或许
  SomeClass(of someType) someInstance = factory.Create(of someType)();
要么
  SomeClass(of someType) someInstance = factory.Create();

可以有一组工厂类来创建不同的泛型类，或者有一个带有泛型类型参数的工厂来指示它应该创建哪个泛型类型（请注意，在任何一种情况下，类型参数都是类型参数对于泛型类，而不是泛型类本身）。也可以有一个工厂，旨在返回泛型类型的一种特定形式的实例。

Answer 5

我认为您误解了泛型的意义。泛型允许您泛化需要类型的类，但并不特别关心它是什么类型。例如，List<string> 是一个字符串列表，但 List 是什么呢？没有清单是一个相当无用的概念。

每个专门的类（即List<string>）都是它自己独特的类型，编译器会这样对待它。 可能获取泛型类型本身（例如typeof(List<>)），但在大多数情况下它是无用的，而且您当然不能创建它的实例。

Answer 6

据我所知，使用代码不需要泛型类的细节（即，它不取决于 T 是什么）。那么，为什么不引入SomeClass<T> 将实现的接口，并使用该接口的实例。

例如：

public interface ISome
{
    void SomeMethod();
}

public class SomeClass<T>: ISome
{
    public virtual void SomeMethod(){ }
}

public void DoSomethingClienty()
{
    Factory factory = new Factory();
    ISome someInstance = factory.Create();

    someInstance.SomeMethod();
}

现在，SomeClass<T> 的子类可以在不同的Ts 上进行不同的操作，但使用代码不会改变。