1 概述
1.1 引入泛型方法
在某些情况下，一个类型中可能只有少数方法成员用到了类型参数，这时就未必需要将整个类型都定义成为泛型。例如在下面的代码中，泛型类GC<T>定义了一个静态方法Contain，用于判断一个元素是否存在于一个数组之中：
public class GC<T> { //静态字段 static readonly double PI=3.14; //方法 public static bool Contain(T[] ts,T tp) { foreach(T t1 in ts) { if(t1.Equals(tp)) return true; } return false; } }
在每次调用该方法时，需要指定该泛型类的一个封闭的构造类型：
short[] sArray = new short[] {1,3,15,255}; bool b1 = GC<short>.Contain(sArray,short.MaxValue);//false int [] iArray = new int[]{1,3,15,255,65535}; bool b2=GC<int>.Contain(iArray,ushort.MaxValue);//true
泛型类GC<T>中定义了一个静态字段PI。由于静态成员属于泛型类的构造类型所有，所以对于每一个构造类型，都为该字段分配了存储空间。
而下面的程序将类型参数从类的定义中转移到方法的定义中，这就是泛型方法：
class GenericsMethodSample { static void Main() { short[] sArray = new short[] { 1, 3, 15, 255 }; Console.WriteLine(C.Contain<short>(sArray, short.MaxValue));//false int[] iArray = new int[] { 1, 3, 15, 255, 65535 }; Console.WriteLine(C.Contain<int>(iArray, ushort.MaxValue));//true } } /// <summary> /// 泛型方法类 /// </summary> public class C { //静态字段 static readonly double PI = 3.14; //泛型方法 public static bool Contain<T>(T[] ts, T tp) { foreach (T t1 in ts) { if (t1.Equals(tp)) return true; } return false; } }
上面程序中，两次方法的调用都是通过同一个类进行的，静态字段PI在内存中只会占用一个存储。
1.2 泛型方法的定义
定义泛型方法也是在方法名之后将类型参数包含在一对分隔符<>中。如果有多个类型参数，则相互间用“,”号分割。之后，所定义的类型参数既可以作为方法的参数类型和返回类型，也可以用来在方法的执行代码中定义局部变量。除此之外，泛型方法的定义规则与普通方法的定义规则相同。
如果在同一个类型中定义了多个泛型方法，它们的类型参数是互不相关的。
如果泛型方法属于一个泛型类型，而二者又定义了相同的类型参数，那么类型参数的使用也服从“屏蔽规则”，即泛型方法中出现的类型参数属于该方法的定义，而在类型的其它成员中出现的类型参数属于类的定义。例如：
public class GArith<T> { private T[] m_list; public static void Swap<T>(ref T tp1,ref T tp2) { ... } }
这时为泛型类GArith<T>创建任何一个构造类型的实例，其私有有字段m_list类型都被替换为相应的封闭类型，但不会影响到泛型方法Swap<T>的参数类型。同样，指定给方法的封闭类型也和类的构造类型无关。例如：
int x=2; int y=5; GArith<string>.Swap<int>(ref x,ref y);//correct Garith<int>.Swap<string>(ref x,ref y);//error:传递类型与实际类型不同
所以，为了提高程序的可读性，应尽量避免为泛型类型及其泛型的成员方法定义同名的类型参数。
在泛型方法中同样可以对类型参数进行限制，限制方式和泛型类的相同
public static T Max<T>(T tp1,T tp2) where T : IComparable<T> { if(tp1.CompareTo(tp2) > 0) return tp1; else return tp2; }
泛型方法既可以属于普通类型，也可以属于泛型类型（泛型类、泛型结构、泛型接口）。
C#中不允许定义泛型的属性、事件、索引函数和操作符。？？？
1.3 调用泛型方法
调用泛型方法有两种方式：
一是在调用时显式指定方法的类型参数列表，前面的例子就是这这种方式。
Console.WriteLine(C.Contain<short>(sArray,short.MaxValue));
二是在调用时省略方法的类型参数列表：
Console.WrtiteLine(C.Contain(sArray,short.MaxValue));
由于传递给泛型方法的两个参数类型分别是short[]和short，调用的过程和结果与完整调用是一样的。
在采用简写调用方式时，编译器需要检查每个参数的类型，并试图由此推断出每个类型参数最终被哪个封闭类型所取代。这个过程称为类型推断。如果推断成功，则会将简写调用代码映射到对应的完整调用代码；否则编译就会失败。
编译器进行类型推断的算法较为复杂，简单的理解是：在泛型方法的声明中出现相同的类型参数的地方，调用时必须以相同的封闭类型去替换这些类型参数，否则类型推断就会失败，例如下面的代码就是错误的：
Console.WriteLine(C.Contain(iArray,ushort.MaxValue));
因为方法的第一个参数，T被替换成int;而对于第二个参数则被替换成ushort，所以转换失败。如果仍要采用简写方式，则应首先进行类型转换：
int x = ushort.MaxValue; Console.WriteLine(C.Contain(iArray,x));
或者合并为下面的形式（尽管ushort类型可以隐式转换到int类型，但在简写调用泛型方法时仍然需要对参数采用显式转换的格式。这一点和调用普通方法以及完整调用泛型方法是不同的）：
Console.WriteLine(C.Contain(iArray,(int)ushort.MaxValue));
1.4 惟一性规则
如果泛型方法的名称相同，那么通过指定不同的类型参数能否使方法具有不同的标识呢？可以分几种情况来讨论：
(1)有无类型参数以及以及类型参数的不同个数，足以区分不同的方法
public class C
{
public void F(){} public void F<T>(){} public void F<T,S>(){}
}
(2)仅仅是类型参数的名称不同，不足以区分不同的方法：
public class C
{
public void F<T>(T t1){} public void S<S>(S s1){}//error
}
(3)类型参数作为传递给方法的参数类型时，不同的参数类型足以区分不同的方法，但在调用时，因为类型参数的替换出现了多个可能，在调用时就可能是错误。
public class C
{
public static void F<R,S>(R r1,S s1){} public static void F<R,S>(S s1,R r1){}
}
对于以上定义，下面的第一次调用是合法的，而第二次调用会出现错误
int x=2; int y=3; string s="hello"; C.F<string,int>(s,x); C.F<int,int>(x,y);//error
(4)如果泛型方法属于泛型类型所有，而外部类型的类型参数在方法中出现。这种情况较为复杂，但判断规则和第3种情况相同，即不同的参数类型足以区分不同的方法，而在调用时不允许出现歧义。例如下面的定义都是合法的：
public class GA<T> { } public class GC<T> { public static void F<S>(T t1,S s1){} public static void F<S>(S s1,T t1){} public static void F<R,S>(GA<R> a,GA<S> b){} public static void F<R,S>(GA<S> a,GA<R> b){} }
但在下面的调用代码中，最后两行是错误的，它们会引起歧义：
int x=2; int y=3; string s="hello"; GC<string>.F<int>(s,x); GC<string>.F<int,double>(new GA<int>(),new GA<double>()); GC<int>.F<int>(x,y);//error：与方法一和方法二存在歧义 GC<string>.F<int,int>(new GA<int>(),new GA<int>());//error：与方法三和方法四存在歧义
（5）泛型方法的类型限制不是方法标识的一部分，不同的限制不足以区分不同的方法。例如下面的方法定义都是重复的：
public class C { public static void F<T>() where T : IComparable {} public static void F<T>() where T : IComparable<T> {} public static void F<T>() where T : IComparer<T> {} public static void F<U>() {}
}
2 泛型方法的重载
2.1 概述
和普通方法一样，泛型方法也可以被定义成为虚拟方法、重载方法、抽象方法或密封方法。普通方法的继承和多态性的内容同样适用于泛型方法。当泛型方法属于某个泛型类型时，8章中2.3小节中讲的嵌套泛型类的规则和8章中5小节泛型类之间的继承的规则也同样适用。
下面的代码示范了泛型方法的继承及重载
public abstract class GA { public abstract void MethodA<T>(T tp1,T tp2); } public class GB<T> : GA { public override void MethodA<R>(R r1,R r2) {} public virtual void MethoB<S>(S sp,T tp) {} } public class GC<T> : GB<int> { public override void MethodA<R r1,R r2) {} public sealed override void MethodB<S>(S sp,int i2) {} }
和泛型类之间的继承类似，派生类在继承或重载基类中的泛型方法时，同时也继承了基类中对泛型方法的类型限制。不过在泛型方法继承中，不需要在派生类的泛型方法中再明确写出这种限制。但如果在派生类中使用new修饰符对基类中的泛型方法进行了覆盖，那么基类中对泛型方法的类型限制则不再有效。
例如对于下面的类和继承定义，派生类Derived重载了基类的泛型方法Method1<S>，虽然它没有显式地写出对类型参数S的限制，但在方法调用时仍然要满足限制要求：
public class A { } public abstract class Base { public abstract void Method1<S>(S[] ss) where S : IComparable; public virtual void Method2<T>(T tp1,T tp2) where T : IComparable<T>{} } public class Derived : Base { public override void Method1<S>(S[] ss) {} public new void Method2<T>(T tp1,T tp2){} }
下面的代码中，调用Derived对象的Method1<int[]>方法是合法的，而调用其Method1<A[]>则是不合法的，因为类A的定义中并没有说明它继承的接口IComparable:
Derived d1 = new Derived(); int[] iArray = new int[5]; d1.Method1<int>(iArray); A[] array = new A[5]; d1.Method1<A>(array);//error
而对于方法Method2<T>，它在隐藏基类方法的同时也隐藏了对类型限制的要求。下面的代码是完全合法的：
Derived d1 = new Derived(); A a1 = new A(); A a2 = new A(); d1.Method2(a1,a2);
2.2 示例程序：读写器
本节将使用泛型方法来进一步改进管理联系人类型的应用程序。将对联系人内容的输入输出工作抽象出来，放在一个新定义的读写器类中加以管理。而通过读写器类的不同派生类，可以实现不同方式的输入输出，如控制台输入输出、Windows窗体输入输出、文件流输入输出。
2.2.1 读写器定义
/// <summary> /// 抽象类：读写器 /// </summary> public abstract class RW { public abstract bool OpenRead(); public abstract bool OpenWrite(); public abstract void CloseRead(); public abstract void CloseWrite(); public abstract string Read(string sPrompt); public abstract void Write(string sPrompt, string sContent); } /// <summary> /// 派生类：控制台读写器 /// </summary> public class ConsoleRW:RW { public override bool OpenRead() { return true; } public override bool OpenWrite() { return true; } public override void CloseRead() { } public override void CloseWrite() { } public override string Read(string sPrompt) { Console.WriteLine("请输入{0}", sPrompt); return Console.ReadLine(); } public override void Write(string sPrompt, string sContent) { Console.WriteLine("{0}：{1} ", sPrompt, sContent); } } /// <summary> /// 派生类：不带分行的控制台读写器 /// </summary> public class NoBreakConsoleRW:ConsoleRW { public override void Write(string sPrompt, string sContent) { Console.Write("{0}：{1} ", sPrompt, sContent); } }
2.2.2 联系人定义
class GenericsMethodOverrideSample { static void Main() { Contact[] cons = new Contact[100]; ConsoleRW rw = new ConsoleRW(); int iCount = 0; while (rw.Read("继续输入联系人信息？(Y/N)").ToUpper()!="N") { cons[iCount]=new Contact(); cons[iCount].Input(rw); iCount++; if(iCount==100) break; } if(iCount==0) return; if (rw.Read("请选择分块输出(按任意键)或单行输出(S)").ToUpper() == "S") rw = new NoBreakConsoleRW(); for (int i = 0; i < iCount; i++) { cons[i].Output(rw); Console.WriteLine(); } } } /// <summary> /// 基类：联系人Contact /// </summary> public class Contact:IComparable<Contact> { //字段 protected string m_name = "未知"; protected string m_gender = "女"; protected string[] m_phones; //属性 public string Name { get { return m_name; } set { m_name = value; } } public string Gender { get { return m_gender; } set { if (value == "男" || value == "女") m_gender = value; } } //构造函数 public Contact() { m_phones = new string[3]; } public Contact(string sName) { m_name = sName; m_phones = new string[3]; } //方法 public int CompareTo(Contact con) { return this.m_name.CompareTo(con.m_name); } public bool Equals(Contact con) { return this.Name.Equals(con.Name); } public virtual void Input<T>(T tp) where T : RW { m_name = tp.Read("姓名"); Gender = tp.Read("性别"); m_phones[0] = tp.Read("住宅电话"); m_phones[1] = tp.Read("办公电话"); m_phones[2] = tp.Read("手机"); } public virtual void Output<T>(T tp) where T : RW { tp.Write("姓名", m_name); tp.Write("性别", m_gender); tp.Write("住宅电话", m_phones[0]); tp.Write("办公电话", m_phones[1]); tp.Write("手机", m_phones[2]); } } /// <summary> /// 派生类：商务Business /// </summary> public class Business:Contact { //字段 protected string m_company = ""; protected string m_title = ""; //属性 public string Company { get { return m_company; } set { m_company = value; } } public string Title { get { return m_title; } set { m_title = value; } } //构造函数 public Business() { m_phones = new string[4]; } public Business(string sName) { m_name = sName; m_phones = new string[4]; } //重载方法 public override void Input<T>(T tp) { m_name = tp.Read("姓名"); Gender = tp.Read("性别"); m_company = tp.Read("公司"); m_title = tp.Read("职务"); m_phones[0] = tp.Read("办公电话"); m_phones[1] = tp.Read("商务电话"); m_phones[2] = tp.Read("住宅电话"); m_phones[3] = tp.Read("手机"); } public override void Output<T>(T tp) { tp.Write("姓名", m_name); tp.Write("性别", m_gender); tp.Write("公司", m_company); tp.Write("职务", m_title); tp.Write("办公电话", m_phones[0]); tp.Write("商务电话", m_phones[1]); tp.Write("住宅电话", m_phones[2]); tp.Write("手机", m_phones[3]); } } /// <summary> /// 派生类：同学Classmate /// </summary> public class Classmate:Contact { //字段 protected DateTime m_birthday; //属性 public DateTime Birthday { get { return m_birthday; } set { m_birthday = value; } } //构造函数 public Classmate() : base() { } public Classmate(string sName) : base(sName) { } //方法 public override void Input<T>(T tp) { base.Input(tp); m_birthday = DateTime.Parse(tp.Read("生日(yyyy-mm-dd):")); } public override void Output<T>(T tp) { base.Output(tp); tp.Write("生日:", m_birthday.ToShortDateString()); } }
程序通过Contact类中定义的泛型方法进行内容的输入和输出。运行结果如下：
请输入继续输入联系人信息？(Y/N) Y 请输入姓名 张三 请输入性别 男 请输入住宅电话 666666 请输入办公电话 888888 请输入手机 13888888888 请输入继续输入联系人信息？(Y/N) N 请输入请选择分块输出(按任意键)或单行输出(S) 姓名：张三 性别：男 住宅电话：666666 办公电话：888888 手机：13888888888 请按任意键继续. . .
上面的程序将所有的联系人都视为同一种类型。而如果要实现不同类别的联系人的管理功能，对程序进行改进，主要是增加联系人类别的选择功能。
class GenericsReadWriteSample { static void Main() { Contact[] cons = new Contact[100]; ConsoleRW rw = new ConsoleRW(); int iCount = 0; while (rw.Read("继续输入联系人信息？(Y/N)").ToUpper() != "N") { string sType = rw.Read("请选择类别（1.普通 2.商务 3.同学）"); if (sType == "1") cons[iCount] = new Contact(); else if (sType == "2") cons[iCount] = new Business(); else if (sType == "3") cons[iCount] = new Classmate(); else break; cons[iCount].Input(rw); iCount++; if (iCount == 100) break; } if (iCount == 0) return; if (rw.Read("请选择分块输出(按任意键)或单行输出(S)").ToUpper() == "S") rw = new NoBreakConsoleRW(); for (int i = 0; i < iCount; i++) { cons[i].Output(rw); Console.WriteLine(); } } }
程序运行结果：
请输入继续输入联系人信息？(Y/N) y 请输入请选择类别（1.普通 2.商务 3.同学） 1 请输入姓名 张三 请输入性别 男 请输入住宅电话 666666 请输入办公电话 888888 请输入手机 138888888 请输入继续输入联系人信息？(Y/N) Y 请输入请选择类别（1.普通 2.商务 3.同学） 2 请输入姓名 李四 请输入性别 男 请输入公司 Microsoft 请输入职务 经理 请输入办公电话 666666 请输入商务电话 888888 请输入住宅电话 999999 请输入手机 13999999999 请输入继续输入联系人信息？(Y/N) Y 请输入请选择类别（1.普通 2.商务 3.同学） 3 请输入姓名 王五 请输入性别 女 请输入住宅电话 666666 请输入办公电话 888888 请输入手机 13777777777 请输入生日(yyyy-mm-dd): 1981-12-01 请输入继续输入联系人信息？(Y/N) N 请输入请选择分块输出(按任意键)或单行输出(S) S 姓名：张三 性别：男 住宅电话：666666 办公电话：888888 手机：138888888 姓名：李四 性别：男 公司：Microsoft 职务：经理 办公电话：666666 商务电话：888888 住宅电话：999999 手机：13999999999 姓名：王五 性别：女 住宅电话：666666 办公电话：888888 手机：13777777777 生日:：1 981-12-1 请按任意键继续. . .
4 小结
泛型的概念不只适用于类型，也适用于类型的方法成员。泛型方法通过类型参数对普通方法进行了抽象，只需要一次定义就可以扩展到多种类型。和普通方法一样，泛型方法需要满足惟一性规则，也可以在类的继承层次中进行重载，还可以通过代表来封装和调用。使用泛型方法的关键是把握类型参数及其封闭类型之间的关系。