一、泛型方法的格式

声明：
public void Swap<T>(ref T x,ref T y) //函数名后要跟表示类型用占位符T代替
{
//函数体
}

使用：
int x=10,y=20;
Swap(ref x,ref y); //自动识别，然后用实际类型替换T

示例：

class Program
{
    public static void Swap<T>(ref T x, ref T y)
    {
        T temp = x;
        x = y;
        y = temp;
    }
    static void Main(string[] args)
    {
        int x = 10, y = 55;
        Console.WriteLine("{0},{1}",x,y);  //输出10，55
        Swap(ref x,ref y);//完整的为Swap<int>(ref x,ref y);<int>可以省
        Console.WriteLine("{0},{1}",x,y);  //输出55，10

        string q = "张三",p = "李四";
        Console.WriteLine(q+p);  //输出张三李四
        Swap(ref q, ref p);
        Console.WriteLine(q+p);  //输出李四张三
        Console.ReadKey();
    }
}

二、泛型的使用范围

只有类型和方法可以引入类型参数T，属性、索引器、时间、字段、构造函数、操作符等都不可以声明类型参数。但是他们可以使用他们所在的泛型类型中的类型参数。

例如：
public Stack<T>(){}; //错误，不能用在构造函数上

public T Pop() //正确，可以使用他们所在泛型类中的类型参数T
{ //方法体};

可以使用的范围有class、struct、interface、delegate。
如：
public struct Nullable<T> //正确，可以用在struct上
{
public T value{get;} //正确，可以使用所示类型的类型参数T
}

三、多个参数的泛型方法使用

泛型类型或方法中可以存在多种泛型参数。如下：`

class Program
{
    public static void Fuc<Tname,Tscore>(Tname i,Tscore j)
    {
        Console.WriteLine("{0}的分数为{1}",i,j);
    }
    static void Main(string[] args)
    {
        string Nam = "王二";
        int Sco = 100;
        //Fuc(Sco,Nam);    //可以省略<string,int>,编译器会按照参数顺序推测，但是这种不健壮
        Fuc<string, int>(Nam,Sco);//建议加上<类型说明>，提高代码健壮性，Nam与Sco不能颠倒否则会报错
        Console.ReadKey();
    }
}

在 C# 语言中泛型方法是指通过泛型来约束方法中的参数类型，也可以理解为对数据类型设置了参数。

如果没有泛型，每次方法中的参数类型都是固定的，不能随意更改。

在使用泛型后，方法中的数据类型则有指定的泛型来约束，即可以根据提供的泛型来传递不同类型的参数。

定义泛型方法需要在方法名和参数列表之间加上<>，并在其中使用 T 来代表参数类型。

当然，也可以使用其他的标识符来代替参数类型， 但通常都使用 T 来表示。下面通过实例来演示泛型方法的使用。

【实例】创建泛型方法，实现对两个数的求和运算。

根据题目要求，代码如下。

class Program
{
    static void Main(string[] args)
    {
        //将T设置为double类型
        Add<double>(3.3, 4);
        //将T设置为int类型
        Add<int>(3, 4);
    }
    //加法运算
    private static void Add<T>(T a, T b)
    {
        double sum = double.Parse(a.ToString()) + double.Parse(b.ToString());
        Console.WriteLine(sum);
    }
}

执行上面的代码，效果如下图所示。

从上面的执行效果可以看出，在调用 Add 方法时能指定不同的参数类型执行加法运算。

如果在调用 Add 方法时，没有按照 <T> 中规定的类型传递参数，则会出现编译错误，这样就可以尽量避免程序在运行时出现异常。

泛型： 允许您延迟编写类或方法中的编程元素的数据类型的规范，直到实际在程序中使用它的时候。换句话说，泛型允许您编写一个可以与任何数据类型一起工作的类或方法。

您可以通过数据类型的替代参数编写类或方法的规范。当编译器遇到类的构造函数或方法的函数调用时，它会生成代码来处理指定的数据类型。下面这个简单的实例将有助于您理解这个概念：

实例：

namespace 博客
{
    public class MyGenericArray<T>
    {
        private T[] array;
        public MyGenericArray(int size)
        {
            array = new T[size + 1];
        }
        public T getItem(int index)
        {
            return array[index];
        }
        public void setItem(int index, T value)
        {
            array[index] = value;
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            // 声明一个整型数组
            MyGenericArray<int> intArray = new MyGenericArray<int>(5);
            // 设置值
            for (int c = 0; c < 5; c++)
            {
                intArray.setItem(c, c * 5);
            }
            // 获取值
            for (int c = 0; c < 5; c++)
            {
                Console.Write(intArray.getItem(c) + " ");
            }
            Console.WriteLine();
            // 声明一个字符数组
            MyGenericArray<char> charArray = new MyGenericArray<char>(5);
            // 设置值
            for (int c = 0; c < 5; c++)
            {
                charArray.setItem(c, (char)(c + 97));
            }
            // 获取值
            for (int c = 0; c < 5; c++)
            {
                Console.Write(charArray.getItem(c) + " ");
            }
            Console.WriteLine();
            Console.ReadKey();

        }
    }
}

 当上面的代码被编译和执行时，它会产生下列结果：

泛型（Generic）的特性

使用泛型是一种增强程序功能的技术，具体表现在以下几个方面：

• 它有助于您最大限度地重用代码、保护类型的安全以及提高性能。
• 您可以创建泛型集合类。.NET 框架类库在 System.Collections.Generic 命名空间中包含了一些新的泛型集合类。您可以使用这些泛型集合类来替代 System.Collections 中的集合类。
• 您可以创建自己的泛型接口、泛型类、泛型方法、泛型事件和泛型委托。
• 您可以对泛型类进行约束以访问特定数据类型的方法。
• 关于泛型数据类型中使用的类型的信息可在运行时通过使用反射获取。

泛型  方法

在上面的实例中，我们已经使用了泛型类，我们可以通过类型参数声明泛型方法。下面的程序说明了这个概念：

实例：

namespace 博客
{
   
    internal class Program
    {
        static void Swap<T>(ref T lhs, ref T rhs)
        {
            T temp;
            temp = lhs;
            lhs = rhs;
            rhs = temp;
        }
        static void Main(string[] args)
        {
            int a, b;
            char c, d;
            a = 10;
            b = 20;
            c = 'I';
            d = 'V';

            // 在交换之前显示值
            Console.WriteLine("Int values before calling swap:");
            Console.WriteLine("a = {0}, b = {1}", a, b);
            Console.WriteLine("Char values before calling swap:");
            Console.WriteLine("c = {0}, d = {1}", c, d);

            // 调用 swap
            Swap<int>(ref a, ref b);
            Swap<char>(ref c, ref d);

            // 在交换之后显示值
            Console.WriteLine("Int values after calling swap:");
            Console.WriteLine("a = {0}, b = {1}", a, b);
            Console.WriteLine("Char values after calling swap:");
            Console.WriteLine("c = {0}, d = {1}", c, d);
            Console.ReadKey();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：