C# 泛型

C#中有泛型类、泛型方法、泛型接口、泛型委托。下面先介绍前3种类型。

1.泛型类、泛型方法：

/// <summary>
    /// 泛型类和泛型方法
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class MyClass<T>
    {
        public void Say(T msg)
        {
            Console.WriteLine(msg);
        }
    }

实例化这个类的时候，代码如下：

            MyClass<string> mc1 = new MyClass<string>();
            mc1.Say("yzk");

            MyClass<int> mc2 = new MyClass<int>();
            mc2.Say(20);

可以看到Say()方法中的参数类型早在实例化MyClass时就约束好了。

上面的代码中是把泛型方法写在泛型类中了，也可以把泛型方法写在普通类中。

/// <summary>
    /// 普通类中的泛型方法
    /// </summary>
    class MyClass1
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public void Say<T>(T msg)
        {
            Console.WriteLine(msg);
        }
    }

实例化这个类的时候，代码如下：

            MyClass1 mc1 = new MyClass1();
            mc1.Name = "yzk";
            mc1.Age = 18;
            mc1.Say<int>(10);
            mc1.Say<string>("hello");
            mc1.Say<string>(mc1.Name);

可以看到，在调Say方法的时候，<>中写什么类型，后面的参数就必须是什么类型。

2.泛型接口

class Person:IComparable<Person>
    {
        public string Name { get; set; }
        public int Age { get; set; }

        public int CompareTo(Person other)
        {
            return other.Age - this.Age;
        }
    }

上面的代码，首先让Person类实现了泛型的IComparable接口，可以看到里面的CompareTo方法参数也是Person类型，就不用再转换other了，这是实现泛型接口的好处。与之类似的还有IComparer<T>接口，看下面2个比较器：

class SortByName:IComparer<Person>
    {

        public int Compare(Person x, Person y)
        {
            return y.Name.Length - x.Name.Length;
        }
    }

    class SortByAge:IComparer<Person>
    {

        public int Compare(Person x, Person y)
        {
            return x.Age - y.Age;
        }
    }

泛型中的类型推断，代码如下：

/// <summary>
    /// 普通类中的泛型方法
    /// </summary>
    class MyClass1
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public void Say<T>(T msg)
        {
            Console.WriteLine(msg);
        }
    }

但是在使用的时候，是这个样子的：

            MyClass1 mc1 = new MyClass1();
            mc1.Name = "yzk";
            mc1.Age = 18;
            mc1.Say(10);
            mc1.Say("hello");
            mc1.Say(mc1.Name);

可以看到，虽然Say方法是泛型的，但是调用的时候，不写参数类型，也能自动推断，这就是泛型中的类型推断。

关于泛型方法重载的问题：

class MyClass4
    {
        //如果在MyClass4写了泛型（MyClass4<T>），那么下面的Show方法可以写成这个样子：Show(T msg)，不必要写<T>
        public void Show<T>(T msg)
        {
            Console.WriteLine(msg);
        }

        public void Show(string msg)
        {
            Console.WriteLine(msg);
        }
    }

在实例化上面的类的时候，我们这么写：

            MyClass4 mc4 = new MyClass4();
            mc4.Show("abc");

那么这个Show到底是调用了泛型方法，还是普通方法呢？且看编译器是如何编译的

    new MyClass4().Show("abc");

编译器（遵循简单方便原则）看到有不带泛型的方法就直接调用了。而如果这么写就是调用泛型方法：

mc4.Show<string>("abc");

编译后的代码如下:

  new MyClass4().Show<string>("abc");

泛型约束：

在写泛型的时候，可以约束泛型必须是某个类型或继承至某个类型或者实现某个接口，语法如下：

class MyClass<T,K，V,w,Y,D>
  where T:struct  //约束T必须是值类型；
  where K:class  //约束K必须是引用类型。
  where V:Icomparable  //约束V必须是实现Icomparable接口的类型或其子类类型.
  where w:Person    //约束w必须是Person类型或其子类类型.
  where Y:K     //约束Y必须是K类型或其子类类型。
  where D:new()   //约束参数必须有无参的公共构造函数。放在最后。