接（泛型一）
這篇文章是翻譯的微軟的技術文章.供學習c#的朋友參考，請勿用于商業目的。http://msdn.microsoft.com/vcsharp/team/language/default.aspx
20.1.6泛型類中的靜態構造函數
在泛型類中的靜態構造函數被用于初始化靜態字段，為每個從特定泛型類聲明中創建的不同的封閉構造類型，執行其他初始化。泛型類型聲明的類型參數在作用域之內，可以在靜態構造函數體內被使用。
如果下列情形之一發生，一個新的封閉構造類類型將被首次初始化。
一個封閉構造類型的實例被創建時
封閉構造類型的任何靜態成員被引用時
為了初始化一個新的封閉的構造類類型，首先那個特定封閉類型的一組新靜態字段（§20.1.5）將會被創建。每個靜態字段都被初始化為其默認值（§5.2）。接著，靜態字段初始化器（§10.4.5.1）將為這些靜態字段執行。最后靜態構造函數將被執行。
由于靜態構造函數將為每個封閉構造類類型執行一次，那么在不能通過約束（§20.7）檢查的類型參數上實施運行時檢查，將會很方便。例如，下面的類型使用一個靜態構造函數檢查一個類型參數是否是一個引用類型。
class gen<t>
{
static gen(){
if((object)t.default != null){
throw new argumentexception(“t must be a reference type”);
}
}
}
20.1.7 訪問受保護的成員
在一個泛型類聲明中，對于繼承的受保護的實例成員的訪問是允許的，通過從泛型類構造的任何類型的實例就可以做到。尤其是，用于訪問§3.5.3中指定的protected和protected internal實例成員的規則，對于泛型使用如下的規則進行了擴充。
在一個泛型類g中，對于一個繼承的受保護的實例成員m，使用e.m的基本表達式是允許的，前提是e的類型是一個從g構造的類類型，或繼承于一個從g構造的類類型的類類型。
在例子
class c<t>
{
protected t x;
}
class d<t> :c<t>
{
static void f(){
d<t> dt = new d<t>();
d<int> di = new d<int>();
d<string> ds = new d<string>();
dt.x = t.default;
di.x = 123;
ds.x = “test”;
}
}
三個對x的賦值語句都是允許的，因為它們都通過從泛型構造的類類型的實例發生。
20.1.8在泛型類中重載
在一個泛型類聲明中的方法、構造函數、索引器和運算符可以被重載。但為了避免在構造類中的歧義，這些重載是受約束的。在同一個泛型類聲明中使用相同的名字聲明的兩個函數成員必須具有這樣的參數類型，也就是封閉構造類型中不能出現兩個成員使用相同的名字和簽名。當考慮所有可能的封閉構造類型時，這條規則包含了在當前程序中目前不存在的類型是實參，但它仍然是可能出現的[1]。在類型參數上的類型約束由于這條規則的目的而被忽略了。
下面的例子根據這條規則展示了有效和無效的重載。
nterface i1<t> {…}
interface i2<t>{…}
class g1<u>
{
long f1(u u); //無效重載，g<int>將會有使用相同簽名的兩個成員
int f1(int i);
void f2(u u1, u u2); //有效重載，對于u沒有類型參數
void f2(int i , string s); //可能同時是int和string
void f3(i1<u>a); //有效重載
void f3(i2<u>a);
void f4(u a); //有效重載
void f4(u[] a);}
class g2<u,v>
{
void f5(u u , v v); //無效重載，g2<int , int>將會有兩個簽名相同的成員
void f5(v v, u u);
void f6(u u , i1<v> v);//無效重載，g2<i1<int>,int>將會有兩個簽名相同的成員
void f6(i1<v> v , u u);
void f7(u u1,i1<v> v2);//有效的重載，u不可能同時是v和i1<v>
void f7(v v1 , u u2);
void f8(ref u u); //無效重載
void f8(out v v);
}
class c1{…}
class c2{…}
class g3<u , v> where u:c1 where v:c2
{
void f9(u u); //無效重載，當檢查重載時，在u和v上的約束將被忽略
void f9(v v);
}
20.1.9參數數組方法和類型參數
類型參數可以被用在參數數組的類型中。例如，給定聲明
class c<v>
{
static void f(int x, int y ,params v[] args);
}
方法的擴展形式的如下調用
c<int>.f(10, 20);
c<object>.f(10,20,30,40);
c<string>.f(10,20,”hello”,”goodbye”);
對應于如下形式：
c<int>.f(10,20, new int[]{});
c<object>.f(10,20,new object[]{30,40});
c<string>.f(10,20,new string[](“hello”,”goodbye”));
20.1.10重寫和泛型類
在泛型類中的函數成員可以重寫基類中的函數成員。如果基類是一個非泛型類型或封閉構造類型，那么任何重寫函數成員不能有包含類型參數的組成類型。然而，如果一個基類是一個開放構造類型，那么重寫函數成員可以使用在其聲明中的類型參數。當重寫基類成員時，基類成員必須通過替換類型實參而被確定，如§20.5.4中所描述的。一旦基類的成員被確定，用于重寫的規則和非泛型類是一樣的。
下面的例子演示了對于現有的泛型其重寫規則是如何工作的。
abstract class c<t>
{
public virtual t f(){…}
public virtual c<t> g(){…}
public virtual void h(c<t> x ){…}
}
class d:c<string>
{
public override string f(){…}//ok
public override c<string> g(){…}//ok
public override void h(c<t> x); //錯誤，應該是c<string>
}
class e<t,u>:c<u>
{
public override u f(){…}//ok
public override c<u> g(){…}//ok
public override void h(c<t> x){…}//錯誤，應該是c<u>
}
20.1.11泛型類中的運算符
泛型類聲明可以定義運算符，它遵循和常規類相同的規則。類聲明的實例類型（§20.1.2）必須以一種類似于運算符的常規規則的方式，在運算符聲明中被使用，如下
一元運算符必須接受一個實例類型的單一參數。一元運算符“++”和“—”必須返回實例類型。
至少二元運算符的參數之一必須是實例類型。
轉換運算符的參數類型和返回類型都必須是實例類型。
下面展示了在泛型類中幾個有效的運算符聲明的例子
class x<t>
{
public static x<t> operator ++(x(t) operand){…}
public static int operator *(x<t> op1, int op2){…}
public static explicit operator x<t>(t value){…}
}
對于一個從源類型s到目標類型t的轉換運算符，當應用§10.9.3中的規則時，任何關聯s或t的類型參數被認為是唯一類型，它們與其他類型沒有繼承關系，并且在這些類型參數上的任何約束都將被忽略。
在例子
class c<t>{…}
class d<t>:c<t>
{
public static implicit operator c<int>(d<t> value){…}//ok
public static implicit operator c<t>(d<t> value){…}//錯誤
}
第一個運算符聲明是允許的，由于§10.9.3的原因，t和int被認為是沒有關系的唯一類型。然而，第二個運算符是一個錯誤，因為c<t>是d<t>的基類。
給定先前的例子，為某些類型實參聲明運算符，指定已經作為預定義轉換而存在的轉換是可能的。
struct nullable<t>
{
public static implicit operator nullable<t>(t value){…}
public static explicit operator t(nullable<t> value){…}
}
當類型object作為t的類型實參被指定，第二個運算符聲明了一個已經存在的轉換（從任何類型到object是一個隱式的，也可以是顯式的轉換）。
在兩個類型之間存在預定義的轉換的情形下，在這些類型上的任何用戶定義的轉換都將被忽略。尤其是
如果存在從類型s到類型t的預定義的隱式轉換（§6.1），所有用戶定義的轉換（隱式的或顯式的）都將被忽略。
如果存在從類型s到類型t的預定義的顯式轉換，那么任何用戶定義的從類型s到類型t的顯式轉換都將被忽略。但用戶定義的從s到t的隱式轉換仍會被考慮。
對于所有類型除了object，由nullable<t>類型聲明的運算符都不會與預定義的轉換沖突。例如
void f(int i , nullable<int> n){
i = n; //錯誤
i = (int)n; //用戶定義的顯式轉換
n = i; //用戶定義的隱式轉換
n = (nullable<int>)i; //用戶定義的隱式轉換
}
然而，對于類型object，預定義的轉換在所有情況隱藏了用戶定義轉換,除了一種情況：
void f(object o , nullable<object> n){
o = n; //預定義裝箱轉換
o= (object)n; //預定義裝箱轉換
n= o; //用戶定義隱式轉換
n = (nullable<object>)o; //預定義取消裝箱轉換
}
20.1.12泛型類中的嵌套類型
泛型類聲明可以包含嵌套類型聲明。封閉類的類型參數可以在嵌套類型中使用。嵌套類型聲明可以包含附加的類型參數，它只適用于該嵌套類型。
包含在泛型類聲明中的每個類型聲明是隱式的泛型類型聲明。當編寫一個嵌套在泛型類型內的類型的引用時，包含構造類型，包括它的類型實參，必須被命名。然而，在外部類中，內部類型可以被無限制的使用；當構造一個內部類型時，外部類的實例類型可以被隱式地使用。下面的例子展示了三個不同的引用從inner創建的構造類型的方法，它們都是正確的；前兩個是等價的。
class outer<t>
{
class inner<u>
{
static void f(t t , u u){…}
}
static void f(t t)
{
outer<t>.inner<string >.f(t,”abc”);//這兩個語句有同樣的效果
inner<string>.f(t,”abc”);
outer<int>.inner<string>.f(3,”abc”); //這個類型是不同的
outer.inner<string>.f(t , “abc”); //錯誤，outer需要類型參數
}
}
盡管這是一種不好的編程風格，但嵌套類型中的類型參數可以隱藏一個成員，或在外部類型中聲明的一個類型參數。
class outer<t>
{
class inner<t> //有效，隱藏了 ouer的 t
{
public t t; //引用inner的t
}
}
20.1.13應用程序入口點
應用程序入口點不能在一個泛型類聲明中。
20.2泛型結構聲明
像類聲明一樣，結構聲明可以有可選的類型參數。
struct-declaration:（結構聲明：）
attributes opt struct-modifiers opt struct identifier type-parameter-list opt struct-interfaces opt type-parameter-constraints-clauses opt struct-body ;opt
（特性可選 結構修飾符可選 struct 標識符 類型參數列表可選 結構接口可選 類型參數約束語句可選 結構體;可選）
除了§11.3中為結構聲明而指出的差別之外，泛型類聲明的規則也適用于泛型結構聲明。
20.3泛型接口聲明
接口也可以定義可選的類型參數
interface-declaration:（接口聲明：）
attribute opt interface-modifiers opt interface indentifier type-parameter-list opt
interface-base opt type-parameter-constraints-clause opt interface-body;
（特性可選 接口修飾符可選 interface 標識符 類型參數列表可選 基接口可選 類型參數約束語句可選 接口體；可選）
使用類型參數聲明的接口是一個泛型接口聲明。除了所指出的那些，泛型接口聲明遵循和常規結構聲明相同的規則。
在接口聲明中的每個類型參數在接口的聲明空間定義了一個名字。在一個接口上的類型參數的作用域包括基接口、類型約束語句和接口體。在其作用域之內，一個類型參數可以被用作一個類型。應用到接口上的類型參數和應用到類（§20.1.1）上的類型參數具有相同的限制。
在泛型接口中的方法與泛型類（§20.1.8）中的方法遵循相同的重載規則。
20.3.1實現接口的唯一性
由泛型類型聲明實現的接口必須為所有可能的構造類型保留唯一性。沒有這條規則，將不可能為特定的構造類型確定調用正確的方法。例如，假定一個泛型類聲明允許如下寫法。
interface i<t>
{
void f();
}
class x<u, v>:i<u>,i<v> //錯誤,i<u>和i<v>沖突
{
void i<u>.f(){…}
void i<v>.f(){…}
}
如果允許這么寫，那么下面的情形將無法確定執行那段代碼。
i<int> x = new x<int ,int>();
x.f();
為了確定一個泛型類型聲明的接口列表是有效的，可以按下面的步驟進行。
讓l成為在泛型類、結構或接口聲明 c中指定的接口的列表。
將任何已經在l中的接口的基接口添加到l
從l中刪除任何重復的接口
在類型實參被替換到l后，如果任何從c創建的可能構造類型，導致在l中的兩個接口是同一的，那么c的聲明是無效的。當確定所有可能的構造類型時，約束聲明不予考慮。
在類聲明x之上，接口列表l由i<u>和i<v>組成。該聲明是無效的，因為任何使用相同類型u和v的構造類型，將導致這兩個接口是同一的。
20.3.2顯式接口成員實現
使用構造接口類型的顯式接口成員實現本質上與簡單接口類型方式上是相同的。和以往一樣，顯式接口成員實現必須由一個指明哪個接口被實現的接口類型而限定。該類型可能是一個簡單接口或構造接口，如下例子所示。
interface ilist<t>
{
t[] getelement();
}
interface idictionary<k,v>
{
v this[k key];
void add(k key , v value);
}
class list<t>:ilist<t>,idictionary<int , t>
{
t[] ilist<t>.getelement(){…}
t idictionary<int , t>.this[int index]{…}
void idictionary<int , t>.add(int index , t value){…}
}
--------------------------------------------------------------------------------
[1] 也就是在類型參數被替換成類型實參時，有可能替換后的實參導致出現兩個成員使用相同的名字和簽名。
