C# 2.0 Specification(泛型五)
2024-07-21 02:20:01
供稿：网友
接泛型四
20.6.5语法歧义
在§20.9.3和§20.9.4中简单名字（simple-name）和成员访问(member-access)对于表达式来说容易引起语法歧义。例如，语句
f(g<a,b>(7));
可以被解释为对带有两个参数g<a和b>(7)的f的调用[1]。同样，它还能被解释为对带有一个参数的f的调用，这是一个对带有两个类型实参和一个正式参数的泛型方法g的调用。
如果表达式可以被解析为两种不同的有效方法，那么在“>”能被解析作为运算符的所有或一部分时，或者作为一个类型实参列表，那么紧随“>”之后的标记将会被检查。如果它是如下之一：
{ } ] > : ; , . ?
那么“>”被解析作为类型实参列表。否则“>”被解析作为一个运算符。
20.6.6对委托使用泛型方法
委托的实例可通过引用一个泛型方法的声明而创建。委托表达式确切的编译时处理，包括引用泛型方法的委托创建表达式，这在§20.9.6中进行了描述。
当通过委托调用一个泛型方法时，所使用的类型实参将在委托实例化时被确定。类型实参可以通过类型实参列表显式给定，或者通过类型推断（§20.6.4）而确定。如果采用类型推断，委托的参数类型将被用作推断处理过程的实参类型。委托的返回类型不用于推断。下面的例子展示了为一个委托实例化表达式提供类型实参的方法。
delegate int d(string s , int i)
delegate int e();
class x
{
public static t f<t>(string s ,t t){…}
public static t g<t>(){…}
static void main()
{
d d1 = new d(f<int>); //ok,类型实参被显式给定
d d2 = new d(f); //ok,int作为类型实参而被推断
e e1 = new e(g<int>); //ok,类型实参被显式给定
e e2 = new e(g); //错误，不能从返回类型推断
}
}
在先前的例子中，非泛型委托类型使用泛型方法实例化。你也可以使用泛型方法创建一个构造委托类型的实例。在所有情形下，当委托实例被创建时，类型实参被给定或可以被推断，但委托被调用时，可以不用提供类型实参列表（§15.3）。
20.6.7非泛型属性、事件、索引器或运算符
属性、事件、索引器和运算符他们自身可以没有类型实参（尽管他们可以出现在泛型类中，并且可从一个封闭类中使用类型实参）。如果需要一个类似属性泛型的构件，取而代之的是你必须使用一个泛型方法。
20.7约束
泛型类型和方法声明可以可选的指定类型参数约束，这通过在声明中包含类型参数约束语句就可以做到。
type-parameter-constraints-clauses（类型参数约束语句：）
type-parameter-constraints-clause（类型参数约束语句）
type-parameter-constraints-clauses type-parameter-constraints-clause（类型参数约束语句 类型参数约束语句）
type-parameter-constraints-clause:（类型参数约束语句：）
where type-parameter : type-parameter-constraints（where 类型参数：类型参数约束）
type-parameter-constraints:（类型参数约束：）
class-constraint（类约束）
interface-constraints（接口约束）
constructor-constraint（构造函数约束）
class-constraint , interface-constraints（类约束，接口约束）
class-constraint , constructor-constraint（类约束，构造函数约束）
interface-constraints , constructor-constraint（接口约束，构造函数约束）
class-constraint , interface-constraints , constructor-constraint（类约束，接口约束，构造函数约束）
class-constraint:（类约束：）
class-type（类类型）
interface-constraint:（接口约束：）
interface-constraint（接口约束）
interface-constraints , interface-constraints（接口约束，接口约束）
interface-constraints:（接口约束：）
interface-type（接口类型）
constructor-constraint:（构造函数约束：）
new ( )
每个类型参数约束语句由标志where 紧接着类型参数的名字，紧接着冒号和类型参数的约束列表。对每个类型参数只能有一个where 语句，但where语句可以以任何顺序列出。与属性访问器中的get和set标志相似，where 语句不是关键字。
在where语句中给定的约束列表可以以这个顺序包含下列组件：一个单一的类约束、一个或多个接口约和构造函数约束new ()。
如果约束是一个类类型或者接口类型，这个类型指定类型参数必须支持的每个类型实参的最小“基类型”。无论什么时候使用一个构造类型或者泛型方法，在编译时对于类型实参的约束建会被检查。所提供的类型实参必须派生于或者实现那个类型参数个定的所有约束。
被指定作为类约束的类型必须遵循下面的规则。
该类型必须是一个类类型。
该类型必须是密封的（sealed）。
该类型不能是如下的类型：system.array，system.delegate，system.enum,或者system.valuetype类型。
该类型不能是object。由于所有类型派生于object，如果容许的话这种约束将不会有什么作用。
至多，对于给定类型参数的约束可以是一个类类型。
作为接口约束而被指定的类型必须满足如下的规则。
该类型必须是一个接口类型。
在一个给定的where语句中相同的类型不能被指定多次。
在很多情况下，约束可以包含任何关联类型的类型参数或者方法声明作为构造类型的一部分，并且可以包括被声明的类型，但约束不能是一个单一的类型参数。
被指定作为类型参数约束的任何类或者接口类型，作为泛型类型或者被声明的方法，必须至少是可访问的（§10.5.4）。
如果一个类型参数的where 语句包括new()形式的构造函数约束，则使用new 运算符创建该类型（§20.8.2）的实例是可能的。用于带有一个构造函数约束的类型参数的任何类型实参必须有一个无参的构造函数（详细情形参看§20.7）。
下面是可能约束的例子
interface iprintable
{
void print();
}
interface icomparable<t>
{
int compareto(t value);
}
interface ikeyprovider<t>
{
t getkey();
}
class printer<t> where t:iprintable{…}
class sortedlist<t> where t: icomparable<t>{…}
class dictionary<k,v>
where k:icomparable<k>
where: v: iprintable,ikeyprovider<k>,new()
{
…
}
下面的例子是一个错误，因为它试图直接使用一个类型参数作为约束。
class extend<t , u> where u:t{…}//错误
约束的类型参数类型的值可以被用于访问约束暗示的实例成员。在例子
interface iprintable
{
void print();
}
class printer<t> where t:iprintable
{
void printone(t x)
{
x.pint();
}
}
iprintable的方法可以在x上被直接调用，因为t被约束总是实现iprintable。
20.7.1遵循约束
无论什么时候使用构造类型或者引用泛型方法，所提供的类型实参都将针对声明在泛型类型，或者方法中的类型参数约束作出检查。对于每个where 语句，对应于命名的类型参数的类型实参a将按如下每个约束作出检查。
如果约束是一个类类型或者接口类型，让c表示提供类型实参的约束，该类型实参将替代出现在约束中的任何类型参数。为了遵循约束，类型a必须按如下方式可别转化为类型c：
- 同一转换（§6.1.1）
- 隐式引用转换（§6.1.4）
- 装箱转换（§6.1.5）
- 从类型参数a到c（§20.7.4）的隐式转换。
如果约束是new()，类型实参a不能是abstract并，且必须有一个公有的无参的构造函数。如果如下之一是真实的这将可以得到满足。
- a是一个值类型（如§4.1.2中所描述的，所有值类型都有一个公有默认构造函数）。
- a是一个非abstract类，并且 a包含一个无参公有构造函数。
- a是一个非abstract类，并且有一个默认构造函数（§10.10.4）。
如果一个或多个类型参数的约束通过给定的类型实参不能满足，将会出现编译时错误。
因为类型参数不被继承，同样约束也决不被继承。在下面的例子中，d 必须在其类型参数t上指定约束，以满足由基类b<t>所施加的约束。相反，类e不需要指定约束，因为对于任何t，list<t>实现了ienumerable接口。
class b<t> where t: ienumerable{…}
class d<t>:b<t> where t:ienumerable{…}
class e<t>:b<list<t>>{…}
20.7.2 在类型参数上的成员查找
在由类型参数t给定的类型中，成员查找的结果取决于为t所指定的约束（如果有的话）。如果t没有约束或者只有new ()约束，在t上的成员查找，像在object上的成员查找一样，返回一组相同的成员。否则，成员查找的第一个阶段，将考虑t所约束的每个类型的所有成员，结果将会被合并，然后隐藏成员将会从合并结果中删除。
在泛型出现之前，成员查找总是返回在类中唯一声明的一组成员，或者一组在接口中唯一声明的成员， 也可能是object类型。在类型参数上的成员查找做出了一些改变。当一个类型参数有一个类约束和一个或多个接口约束时，成员查找可以返回一组成员，这些成员有一些是在类中声明的，还有一些是在接口中声明的。下面的附加规则处理了这种情况。
在成员查找过程（§20.9.2）中，在除了object之外的类中声明的成员隐藏了在接口中声明的成员。
在方法和索引器的重载决策过程中，如果任何可用成员在一个不同于object的类中声明，那么在接口中声明的所有成员都将从被考虑的成员集合中删除。
这些规则只有在将一个类约束和接口约束绑定到类型参数上时才有效。通俗的说法是，在一个类约束中定义的成员，对于在接口约束的成员来说总是首选。
20.7.3 类型参数和装箱
当一个结构类型重写继承于system.object(equals , gethashcode或tostring)的虚拟方法，通过结构类型的实例调用虚拟方法将不会导致装箱。即使当结构被用作一个类型参数，并且调用通过类型参数类型的实例而发生，情况也是如此。例如
using system;
struct counter
{
int value;
public override string tostring()
{
value++;
return value.tostring();
}
}
class program
{
static void test<t>() where t:new()
{
t x = new t();
console.writeline(x.tostring());
console.writeline(x.tostring());
console.writeline(x.tostring());
}
static void main()
{
test<counter>();
}
}
程序的输出如下
1
2
3
尽管推荐不要让tostring带有附加效果（side effect）[2]，但这个例子说明了对于三次x.tostring()的调用不会发生装箱。
当在一个约束的类型参数上访问一个成员时，装箱决不会隐式地发生。例如，假定一个接口icounter包含了一个方法increment，它可以被用来修改一个值。如果icounter被用作一个约束，increment方法的实现将通过increment在其上调用的变量的引用而被调用，这个变量不是一个装箱拷贝。
using system;
interface icounter
{
void increment();
}
struct counter:icounter
{
int value;
public override string tostring()
{
return value.tostring();
}
void icounter.increment(){
value++;
}
}
class program
{
static void test<t>() where t:new ,icounter{
t x = new t();
console.writeline(x);
x.increment(); //修改x`
console.writeline(x);
((icounter)x).increment(); //修改x的装箱拷贝
console.writeline(x);
}
static void main()
{
test<counter>();
}
}
对变量x的首次调用increment修改了它的值。这与第二次调用increment是不等价的，第二次修改的是x装箱后的拷贝，因此程序的输出如下
20.7.4包含类型参数的转换
在类型参数t上允许的转换，取决于为t所指定的约束。所有约束的或非约束的类型参数，都可以有如下转换。
从t到t的隐式同一转换。
从t到object 的隐式转换。在运行时，如果t是一个值类型，这将通过一个装箱转换进行。否则，它将作为一个隐式地引用转换。
从object到t的隐式转换。在运行时，如果t是一个值类型，这将通过一个取消装箱操作而进行。否则它将作为一个显式地引用转换。
从t到任何接口类型的显式转换。在运行时，如果t是一个值类型，这将通过一个装箱转换而进行。否则，它将通过一个显式地引用转换而进行。
从任何接口类型到t的隐式转换。在运行时，如果t是一个值类型，这将通过一个取消装箱操作而进行。否则，它将作为一个显式引用转换而进行。
如果类型参数t指定一个接口i作为约束，将存在下面的附加转换。
从t到i的隐式转换，以及从t到i的任何基接口类型的转换。在运行时，如果t是一个值类型，这将作为一个装箱转换而进行。否则，它将作为一个隐式地引用转换而进行。
如果类型参数t指定类型c作为约束，将存在下面的附加转换：
从t到c的隐式引用转换，从t到任何c从中派生的类，以及从t到任何从其实现的接口。
从c到t的显式引用转换，从c从中派生的类[3]到t，以及c实现的任何接口到t
如果存在从c 到a的隐式用户定义转换，从t到 a的隐式用户定义转换。
如果存在从a 到c的显式用户定义转换，从a到 t的显式用户定义转换。
从null类型到t的隐式引用转换
一个带有元素类型的数组类型t具有object和system.array之间的相互转换（§6.1.4，§6.2.3）。如果t有作为约束而指定的类类型，将有如下附加规则
从带有元素类型t的数组类型at到带有元素类型u的数组类型au的隐式引用转换，并且如果下列二者成立的话，将存在从au到at显式引用转换：
- at和au 有相同数量的维数。
- u是这些之一：c，c从中派生的类型，c所实现的接口，作为在t上的约束而指定的接口i，或i的基接口。
先前的规则不允许从非约束类型参数到非接口类型的直接隐式转换，这可能有点奇怪。其原因是为了防止混淆，并且使得这种转换的语义更明确。例如，考虑下面的声明。
class x<t>
{
public static long f(t t){
return (long)t; // ok,允许转换
}
}
如果t到int的直接显式转换是允许的，你可能很容易以为x<int>.f(7)将返回7l。但实际不是，因为标准的数值转换只有在类型在编译时是已知的时候才被考虑。为了使语义更清楚，先前的例子必须按如下形式编写。
class x<t>
{
public static long f(t t)
{
return (long)(object)t; //ok;允许转换
}
}
--------------------------------------------------------------------------------
[1] 这种情况下“>”被解释为大于运算符。
[2] 在程序中重写tostring时，一般不推荐添加这种类似的计算逻辑，因为它的这种结果变化不易控制，增加了调试程序的复杂性。
[3] c的基类或其基类的基类等。
网站运营seo文章大全提供全面的站长运营经验及seo技术!
