c#语言:泛型，打开/关闭，绑定/未绑定，构造

本文关键字：绑定 关闭 构造 打开 语言 泛型 | 更新日期: 2023-09-27 18:01:30

我在读《c#编程语言》第四版，作者是Anders Hejlsberg等。

有几个定义有点扭曲:

未绑定泛型类型:泛型类型声明本身表示未绑定的泛型类型…

构造类型:包含至少一个类型参数的类型称为构造类型。

open type:开放类型是包含类型形参的类型。

闭类型:闭类型不是开类型。

unbound type:表示非泛型类型或未绑定的泛型类型。

绑定类型:指向非泛型类型或构造类型。[注释]ERIC LIPPERT:是的，非泛型类型被认为是绑定的和未绑定的。

问题1 下面我列出的是正确的吗?

int                     //non-generic, closed, unbound & bound, 
class A<T, U, V>        //generic,     open,   unbound, 
class A<int, U, V>      //generic,     open,   bound, constructed 
class A<int, int, V>    //generic,     open,   bound, constructed
class A<int, int, int>  //generic,     closed, bound, constructed

问题2，书上说未绑定类型指的是由类型声明声明的实体。未绑定泛型类型本身不是类型，不能用作变量、参数或返回值的类型，也不能用作基类型。唯一可以引用未绑定泛型类型的构造是typeof表达式(§7.6.11)。很好，但是下面是一个可以编译的小测试程序:

public class A<W, X> { }
// Q2.1: how come unbounded generic type A<W,X> can be used as a base type?
public class B<W, X> : A<W, X> { } 
public class C<T,U,V>
{
    // Q2.2: how come unbounded generic type Dictionary<T, U> can be used as a return value?
    public Dictionary<T,U> ReturnDictionary() { return new Dictionary<T, U>(); }
    // Q2.3: how come unbounded generic type A<T, U> can be used as a return value?
    public A<T, U> ReturnB() { return new A<T, U>(); }
}

c#语言:泛型，打开/关闭，绑定/未绑定，构造

这些是未绑定泛型类型的示例:

  • List<>
  • Dictionary<,>

它们可以与typeof一起使用，即以下是有效表达式:

  • typeof(List<>)
  • typeof(Dictionary<,>)

这应该回答了你的问题2。关于问题1，请注意类型参数可以是构造类型或类型参数。因此，您的列表应该更新如下:

public class MyClass<T, U> {  // declares the type parameters T and U
    // all of these are
    // - generic,
    // - constructed (since two type arguments are supplied), and
    // - bound (since they are constructed):
    private Dictionary<T, U> var1;     // open (since T and U are type parameters)
    private Dictionary<T, int> var2;   // open (since T is a type parameter)
    private Dictionary<int, int> var3; // closed
}

Jon给出了一个很好的答案。

没有给出技术描述，因为所有的东西都在链接的答案中完美地存在。为了简单地复制它的要点作为这里的答案，它看起来像:

A                             //non generic, bound
A<U, V>                       //generic,     bound,  open,   constructed
A<int, V>                     //generic,     bound,  open,   constructed
A<int, int>                   //generic,     bound,  closed, constructed
A<,> (used like typeof(A<,>)) //generic,     unbound

与Heinzi讨论后编辑

相关文章：