究竟什么是“开放泛型"?在.NET 中?

Therefore T, List<T>, and Dictionary<string,T>, and Dictionary<T,U> are all open types (T and U are type arguments) whereas List<int> and Dictionary<string,int> are closed types.

有一个相关的概念:未绑定的泛型类型是具有未指定类型参数的泛型类型.未绑定类型不能在 typeof() 以外的表达式中使用，并且您不能实例化它或调用它的方法.例如，List<> 和 Dictionary<,> 是未绑定的类型.

There's a related concept: An unbound generic type is a generic type with unspecified type arguments. An unbound type can't be used in expressions other than typeof() and you can't instantiate it or call its methods. For instance, List<> and Dictionary<,> are unbound types.

澄清开放类型和未绑定类型之间的细微区别:

To clarify the subtle distinction between an open type and an unbound type:

class Program {
   static void Main() { Test<int>(); }
   static void Test<T>() {
      Console.WriteLine(typeof(List<T>)); // Print out the type name
   }
}

如果您运行此代码段，它将打印出来

If you run this snippet, it'll print out

System.Collections.Generic.List`1[System.Int32]

这是 List 的 CLR 名称.在运行时很明显 type 参数是 System.Int32.这使得 List<T> 成为 bound 开放类型.

which is the CLR name for List<int>. It's clear at runtime that the type argument is System.Int32. This makes List<T> a bound open type.

在运行时，您可以使用反射将类型参数绑定到未绑定泛型类型的未指定类型参数，Type.MakeGenericType 方法:

At runtime, you can use reflection to bind type arguments to unspecified type parameters of unbound generic types with the Type.MakeGenericType method:

Type unboundGenericList = typeof(List<>);
Type listOfInt = unboundGenericList.MakeGenericType(typeof(int));
if (listOfInt == typeof(List<int>))
     Console.WriteLine("Constructed a List<int> type.");

您可以检查一个类型是否是未绑定的泛型类型(泛型类型定义)，您可以使用 Type.IsGenericTypeDefinition 属性:

You can check whether a type is an unbound generic type (generic type definition) from which you can construct bound types with the Type.IsGenericTypeDefinition property:

Console.WriteLine(typeof(Dictionary<,>).IsGenericTypeDefinition); // True
Console.WriteLine(typeof(Dictionary<int,int>).IsGenericTypeDefinition); // False

要在运行时从构造类型中获取未绑定类型，可以使用 Type.GetGenericTypeDefinition 方法.

To get the unbound type from a constructed type at runtime, you can use the Type.GetGenericTypeDefinition method.

Type listOfInt = typeof(List<int>);
Type list = listOfInt.GetGenericTypeDefinition(); // == typeof(List<>)

请注意，对于泛型类型，您可以有一个完全未绑定的类型定义，也可以有一个完全绑定的定义.您不能绑定某些类型参数而让其他类型参数未绑定.例如，您不能使用 Dictionary<int,> 或 Dictionary<,string>.

Note that for a generic type, you can either have a completely unbound type definition, or a completely bound definition. You can't bind some type parameters and leave others unbound. For instance, you can't have Dictionary<int,> or Dictionary<,string>.

这篇关于究竟什么是“开放泛型"?在.NET 中?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持编程学习网！