如何声明具有不同类型和未知类型的泛型列表以及如何使用仅在运行时知道的类型初始化泛型？

Question

这是一个两部分的问题。

首先
我有一个名为 ComponentList 的类，如下所示：

public class ComponentList<T> : List<T> where T : Component
{

}

现在我想创建一个空的无类型 ComponentLists 列表：

List<ComponentList<>> MasterList = new List<ComponentList<>>();

我收到一个错误，因为 ComponentList 想要指定一个泛型类型，即使我还没有尝试初始化任何 ComponentList（只是包含它们的 MasterList）。如何在不初始化任何 ComponentLists 的情况下声明 ComponentLists 的 MasterList（因为我计划在运行时使用仅在运行时知道的类型来初始化它们）？毕竟，MasterList 需要包含不同泛型类型的 ComponentList，而不仅仅是一个。

其次
我知道以前有人问过这个问题，但我似乎无法理解任何提议的解决方案的概念。

如您所知，我有一个名为 MasterList 的List<>，它是一个 ComponentLists 列表（一个自定义类）。 ComponentList 是未定义类型的泛型类（被限制为 Component 的子类型）。

在以下示例中，我尝试检查 ComponentList 泛型类型（从 MasterList 引用）是否与此类（调用代码的类）相同。

if (MasterList[i].GetType() == typeof(ComponentList<this.GetType()>))
{

}

问题是，代码是从未知的子类中自动调用的，而不是从这个父类中调用的。所以 ComponentList 泛型类型需要和子类的类型进行比较，而不是这个基类。因此，“this.GetType”代替了实际基类的硬编码名称。

在 ComponentList 中传递的this.GetType() 类型显然返回“预期类型”错误，因为GetType() 返回编译时类型，而不是运行时类型（这是我需要的）。

那么我怎样才能得到运行时类型呢？如果我做不到，那么完成我想做的事情的最佳选择是什么？ （我听说过一些叫做反射的东西，它可能对我有帮助，但我真的不明白）。

Answer 1

您无法在运行时确定泛型类型。 C#（实际上都是 .Net）是故意这样设计的。编译器对泛型类型的处理方式与显式定义的类型几乎相同。

考虑以下几点：

class MyGenericClass<T>
{
    public static T MyProperty { get; set; }
}

class MyIntClass
{
    public static int MyProperty { get; set; }
}

class UseThem
{
    public void test()
    {
        // both are JIT'ed to be exactly the same machine code
        var foo = MyGenericClass<int>.MyProperty;
        var bar = MyOtherClass.MyProperty;
    }
}

因此，您必须为泛型类提供一个类型，以便 JIT 知道要编译什么。

可能的替代方案 如果最终可能成为泛型类型的所有可能类型都是相似的（从同一基类继承或实现类似的接口），那么您可以使用接口或基类作为泛型类型来实例化泛型类：

List<ComponentList<ComponentBase>> MasterList = new List<ComponentList<ComponentBase>>();
// -OR-
List<ComponentList<IMyComponent>> MasterList = new List<ComponentList<IMyComponent>>();

我有一种预感，您应该能够通过一些创造性的重构来定义一个通用接口或基类。 :)

Answer 2

当我尝试为用 C# 编写的游戏设置实体组件系统时，我也遇到了这个问题。确实没有办法将组件存储为它们的实际类型，您必须将它们全部存储为 Components 并转换它们。

我设置它的方式是作为 Dictionary<Type, List<Component>> 作为 ComponentManager 类的私有成员。添加组件的方法是通用的，并检查它的 Type 是否包含在 Dictionary 中，因此获取IEnumerable<SpecificComponent> 很简单：

public IEnumerable<T> EnumerateComponents<T>()
    where T : Component
{
    foreach (Component c in components[typeof(T)])
        yield return (T)c;
}

（您还需要检查字典是否包含typeof(T)，该位是内置于我的自定义集合中，该集合继承自 Dictionary 以避免在这种情况下出现异常。）

只要字典从未在泛型方法之外修改（并且绝对不能从外部直接访问），类型安全就“得到保证”。不理想，但它足够快，永远不会成为您的瓶颈。

编辑

要探索的可能是 C# 4 的 dynamic 关键字。我没有深入研究它，但是将组件存储为 List<dynamic> 可能会更好（或者它可能会引入太多开销），只是需要考虑一下。

Answer 3

我不认为你的要求是可能的，但也许这就是你需要的。

public class ComponentA : Component { }
public class ComponentB : Component { }
public class Component { }

public class ComponentList<T> : List<T> where T : Component
{

}

class Program
{
    static void Main(string[] args)
    {
        ComponentList<Component> MasterList = new ComponentList<Component>();

        MasterList.Add(new ComponentA());
        MasterList.Add(new ComponentB());

        for (int i = 0; i < MasterList.Count; i++)
        {
            if (MasterList[i] is ComponentA)
            {
            }

        }
    }
}