这是可能的：带约束的c#类型集合，还是泛型类型集合？

我试图将类型存储在集合中，以便以后可以实例化集合中类型的对象。但我不知道怎样才能做到最好

到目前为止，我所拥有的：

List<Type> list = new List<Type>();
list.Add(typeof(MyClass));
var obj = (MyClass)Activator.CreateInstance(list[0]);

List List=新列表（）；
添加（类型（MyClass））；
var obj=（MyClass）Activator.CreateInstance（列表[0]）；

我希望对

类型

有一些约束，或者更好的是，只对集合中的泛型类型进行约束，而不是实例化的

类型

对象。这可能吗？

第一种方法（看起来很愚蠢，但很安全）：

---

（在列表| | implement IList上创建包装器）并检查.Add方法中的.Exists（项）。

如果要实现自己的集合，可以使用泛型类型约束：

public class MyList<T> 
    where T : IMyConstraint

公共类MyList
其中T:IMyConstraint

通用集合约束不是这样工作的。

限制哪些类型对实例化泛型类型是合法的。有几种不同类型的约束，但常见的约束将泛型参数限制为继承或作为给定类型的实例，或实现特定接口（或接口集）的类型

另一方面，是一个类，用于描述应用程序或其某个库中类型的相关信息。特定类型的类型不会继承或扩展

类型

——而是每个可用类型都有一个不同的

类型

实例。您不能使用常规约束来控制哪些类型的实例可以添加到集合中

---

如果没有关于如何“约束”集合中的信息的更多细节，就很难说您应该采取什么路线。例如，如果您只想确保存储唯一的类型（没有DUP），则可以使用哈希集（而不是列表）来实现。但是如果您想要更专业化的东西，比如限制可以添加到某些类型子集的

类型

实例，那么您可能需要实现自己的集合，并在Add/Insert方法中实现gaurd逻辑。

在这个特定场景中，我们似乎有一个“工厂”模式，我们将约束调用激活器的方法，例如

private readonly List<Type> _supportedTypes = new List<Type> ();
public void RegisterSupportedType<T> () where T : SomeConstraintType
{
    _supportedTypes.Add (typeof (T));
}

// if we do not know the type, but somehow know an index to type
public object Create (int supportedTypeIndex)
{
    object untyped = Activator.
        CreateInstance (_supportedTypes[supportedTypeIndex]);
    return untyped;
}

// if we know instance type\subtype (eg interface) and know an index
public T Create<T> (int supportedTypeIndex)
{
    T typed = default (T);
    object untyped = Create (supportedTypeIndex);
    if (!(untyped is T))
    {
        // throw meaningful exception :)
    }
    typed = (T)(untyped);
    return typed;
}

乔恩

如果您使用的是CodeContracts，则可能需要许多已知类型。代码分析将用无效类型标记对集合的任何调用

public class TypeCollection : List<Type>
{
    public TypeCollection()
    {
    }

    public new void Add(Type type)
    {
        Contract.Requires(type == typeof(string) || type == typeof(Stream));
        base.Add(type);
    }
}

public class TestCollection
{
    public void Test()
    {
        TypeCollection collection = new TypeCollection();
        // This gets compile time warning:
        collection.Add(typeof(int));
    }
}

公共类类型集合：列表
{
公共类型集合（）
{
}
公共新空添加（类型）
{
Contract.Requires（type==typeof（string）| | type==typeof（Stream））；
添加（类型）；
}
}
公共类TestCollection
{
公开无效测试（）
{
TypeCollection集合=新的TypeCollection（）；
//这将获得编译时警告：
集合。添加（typeof（int））；
}
}

---

但是，如果您事先知道类型，那么在一个枚举中指定所有类型并为您想要支持的类型创建创建一个有效枚举集合可能更有意义。

谢谢！实际上，我想同时做这两件事，没有DUP，只有从指定基类继承的类型。我认为johnny g在下面发布的工厂模式将适合我的需要。我没有使用CodeContracts，也许我应该。就目前而言，我认为约翰尼发布的工厂模式将surfice@Jon，作为参考，您可能还希望调查控制反转[IoC]和依赖注入[DI]。对于相对简单的概念，已经有一些“成熟”的框架实现了上述的通用工厂模式。例如MS的Unity 2.0和Castle project的Castle Windsor容器。非常感谢！事实证明，团结正是我所需要的。我使用它来注册类型，并实例化新对象，同时在列表中跟踪注册的类型。完美的

public class TypeCollection : List<Type>
{
    public TypeCollection()
    {
    }

    public new void Add(Type type)
    {
        Contract.Requires(type == typeof(string) || type == typeof(Stream));
        base.Add(type);
    }
}

public class TestCollection
{
    public void Test()
    {
        TypeCollection collection = new TypeCollection();
        // This gets compile time warning:
        collection.Add(typeof(int));
    }
}