Spécification C# 2.0 (Génériques 3)

Suite de Generics 2

20.4 Déclaration de délégué générique

Une déclaration de délégué peut contenir des paramètres de type.

déclaration-délégué :
attributs opt délégués-modificateurs opt t délégué identifiant de type de retour type-parameter-list opt
（formal-parameter-list opt） type-parameter-constraints-clauses opt ;
(Déclaration de délégué : Attributs facultatif modificateur de délégué facultatif délégué type de retour identifiant liste de paramètres de type facultatif (liste de paramètres formels facultatif) déclaration de contrainte de paramètre de type facultatif
Un délégué déclaré à l'aide de paramètres de type est une déclaration de délégué générique. Une déclaration de délégué peut prendre en charge les instructions de contrainte de paramètre de type (§20.7) uniquement si elle prend en charge une liste de paramètres de type. Sauf indication contraire, les déclarations de délégué génériques suivent les mêmes règles que les déclarations de délégué normales. Chaque paramètre de type dans une déclaration a un nom défini dans l'espace de déclaration spécifique. (§3.3) associé au délégué. La portée d'un paramètre de type dans une déclaration de délégué inclut le type de retour, la liste des paramètres formels et l'instruction de contrainte du paramètre de type

Comme les autres déclarations de type génériques, les arguments de type. doit être donné pour former le type délégué construit. Les paramètres et les valeurs de retour du type délégué construit sont remplacés par les paramètres réels correspondant à chaque paramètre de type du type délégué construit dans la déclaration du délégué. sont utilisés pour déterminer quelle méthode est compatible avec le type de délégué construit. Par exemple,

delegate bool Predicate<T>(T value)
class X
{
static bool F(int i){…}
static bool G(string s){…}
static void Main(){
Predicate<int> p1 = F;
Predicate<string> p2=G;
}
}

Notez que les deux affectations de la méthode Main précédente sont équivalentes à la forme plus longue ci-dessous. .

static void Main(){
Predicate<int> p1 = new Predicate<int>(F);
Predicate<string> p2 = new Predicate<string>(G);
}

La forme plus courte est également possible grâce à la conversion de groupe de méthodes, qui est expliquée dans 🎜>20.5 Types construits

Une déclaration de type générique. ne représente pas en soi un type. Au lieu de cela, une déclaration de type générique est utilisée comme « modèle » pour former de nombreux types différents en appliquant des arguments de type écrits entre crochets et immédiatement après le nom de la déclaration de type générique. au moins un argument est appelé type construit. Les types construits peuvent être utilisés partout où les noms de types peuvent apparaître dans la plupart des endroits

Les types construits peuvent également être utilisés dans des expressions comme. des noms simples (§20.9.3) ou pour accéder à un membre (§20.9.4).>

Lorsqu'un espace de noms ou un nom de type est évalué, seuls les types génériques avec le nombre correct de paramètres de type sont pris en compte, donc à condition que les types ont un nombre différent de paramètres de type et sont déclarés dans des espaces de noms différents. Il est possible d'utiliser le même identifiant pour identifier différents types. Ceci est utile pour mélanger des classes génériques et non génériques dans le même programme. les recherches dans le code sont décrites au §20.9. La résolution des ambiguïtés dans ces codes est décrite au §20.6.5.

type-name:（类型名字：）
namespace-or-type-name（命名空间或类型名字）
namespace-or-type-name:（命名空间或类型名字：）
identifier type-argument-list（标识符类型实参列表可选）
namespace-or-type-name. identifier（命名空间或类型名字.标识符）
type-argument-list opt（类型实参列表可选）

Un nom de type peut identifier un type construit même s'il ne spécifie pas directement les paramètres de type. Cette situation se produit lorsqu'un type est imbriqué dans une déclaration de classe générique et que le type d'instance de la déclaration contenant sera utilisé implicitement en raison de la recherche de nom (§20.1.2).

Les types construits ne peuvent pas être utilisés comme types non gérés dans du code non sécurisé (§18.2).

namespace System.Collections
{
class Queue{…}
}
namespace Sysetm.Collections.Generic
{
class Queue<ElementType>{…}
}
namespace MyApplication
{
using System.Collections;
using System.Collections.Generic;
class X
{
Queue q1; //System.Collections.Queue
Queue<int> q2;//System.Collections.Generic.Queue
}
}

20.5.1 Arguments de type

Chaque paramètre réel dans une liste de paramètres de type n'est qu'un type.

class Outer<T>
{
public class Inner{…}
public Inner i; //i的类型是Outer<T>.Inner
}

Les arguments de type peuvent à leur tour être des types construits ou des paramètres de type. Dans le code non sécurisé (§18), les arguments de type ne peuvent pas être des types pointeur. Chaque argument de type doit respecter toutes les contraintes sur le paramètre de type correspondant (§20.7.1).

20.5.2开放和封闭类型

所有类型都可以被分为开放类型（open type）或封闭类型(closed type)。开放类型是包含类型参数的类型。更明确的说法是

类型参数定义了一个开放类型

数组类型只有当其元素是一个开放类型时才是开放类型

构造类型只有当其类型实参中的一个或多个是开放类型时，它才是开放类型


非开放类型都是封闭类型。



在运行时，在泛型类型声明中的所有代码都在一个封闭构造类型的上下文执行，这个封闭构造类型是通过将类型实参应用到泛型声明中创建的。在泛型类型中的每个类型实参被绑定到一个特定运行时类型。所有语句和表达式的运行时处理总是针对封闭类型发生，而开放类型只发生在编译时处理。

每个封闭构造类型都有它自己的一组静态变量，它们并不被其他封闭类型共享。因为在运行时不存在开放类型，所以开放类型没有关联的静态变量。如果两个封闭构造类型是从同一个类型声明构造的，并且对应的类型实参也是相同的类型，那么它们就是相同的类型。

20.5.3构造类型的基类和接口

构造类类型有一个直接基类，就像是一个简单类类型。如果泛型类声明没有指定基类，其基类为object。如果基类在泛型类声明中被指定，构造类型的基类通过将在基类声明中的每个类型参数，替代为构造类型对应类型实参而得到。给定泛型类声明

class B<U , V>{…}
class G<T>:B<string , T[]>{…}

构造类型G的基类将会是B。

相似地，构造类、结构和接口类型有一组显式的基接口。显式基接口通过接受泛型类型声明中的显式基接口声明和某种替代而形成，这种替代是将在基接口声明中的每个类型参数，替代为构造类型的对应类型实参。



一个类型的所有基类和基接口通过递归地得到中间基类和接口的基类与接口而形成。例如，给定泛型类声明

class A {…}
class B<T>:A{…}
class C<T>:B<IComparable<T>>{…}
class D<T>:C<T[]>{…}
D<int>的基类是C<int[]>,B<IComparable<int[]>>,A和object。

20.5.4构造类型的成员

构造类型的非继承成员通过替代成员声明的类型实参，构造类型的对应类型实参而得到。

例如，给定泛型类声明

class Gen<T,U>
{
public T[,],a;
public void G(int i ,T t , Gen<U, T> gt){…}
public U Prop(get{…}) set{…}}
public int H{double d}{…}
}

构造类型Gen>有如下的成员。

public int[,][] a;
public void G(int I , int[] t , Gen<IComparable<string>,int[] gt>){…}
public IComparable<string> Prop{get{…} set{…}}
public int H(double d){…}

注意替代处理是基于类型声明的语义意义的，并不是简单的基于文本的替代。在泛型类声明Gen中的成员a的类型是“T的二维数组” 因此在先前实例化类型中的成员a的类型是“int型的一维数组的二维数组”或int[,][]。

构造类型的继承成员以一种相似的方法得到。首先直接基类的所有成员是已经确定的。如果基类自身是构造类型这可能包括当前规则的递归应用。然后，继承成员的每一个通过将成员声明中的每个类型参数，替代为构造类型对应类型实参而被转换。

class B<U>
{
public U F(long index){…}
}
class D<T>:B<T[]>
{
public T G(string s){…}
}

在先前的例子中，构造类型D的非继承成员public int G(string s)通过替代类型参数T的类型实参int而得到。D也有一个从类声明B而来的继承成员。这个继承成员通过首先确定构造类型B的成员而被确定，B成员的确定是通过将U替换为替换为T[]，产生public T[] F(long index)。然后类型实参int替换了类型参数T，产生继承成员public int[] F(long index)。

20.5.5构造类型的可访问性

当构造类型C的所有部分C，T1,…,TN 可访问时，那么它就是可访问的。例如，如果泛型类型名C是public，并且所有类型参数T1,…,TN也是public ，那么构造类型的可访问性也是public 。如果类型名或类型实参之一是private，那么构造类型的可访问性是private。如果类型实参之一可访问性是protected，另一个是internal，那么构造类型的可访问性仅限于该类，以及本程序集之内的子类。

20.5.6转换

构造类型遵循与非泛型类型相同的规则（§6）。当应用这些规则时，构造类型的基类和接口必须按§20.5.3中所描述的方式确定。

除了那些在§6中所描述的之外，构造引用类型之间不存在特别的转换。尤其是，不像数组类型，构造引用类型不允许“co-variant”转换。也就是说，类型List不能转换到类型List（无论是隐式或显式）即使是B派生于A也是如此。同样，也不存在从List到List