泛型

泛型(generic)：framework2.0加入。是一种特殊的算法重用机制。允许程序员在代码中将变量或参数的类型 先用类型占位符来代替，等到运行的时候再根据传入的类来替换。例如：

public class MyList<T>
{
    T[] arr;
    public MyList(T[] arrp)
    {
        arr = arrp;
    }
}
public static void Main(string []arg)
{
    MyList<string>list = new MyList<string>();
}

1.CLR编译时，编译器只为MyList<T>类型产生“泛型版”的IL代码——并不进行泛型的实例化，T在中间只充当占位符。例如：MyList类型元数据中显示的<T>
2.执行的时候，当JIT编译器第一次遇到MyList<string>时，将用string替换“范型版”IL代码与元数据中的T—进行泛型类型的实例化。例如：Main函数中显示的<string>

用法：
1：泛型类
    使用<>
    多个泛型参数用,隔开：<T,K>  

public class List<T,F>
{
}
public static void Main(string []arg)
{
    MyList<string,Person>list = new MyList<string,Person>();

} 

2.泛型-类继承
   继承一个泛型类时，必须为其传递泛型参数！ 

public class Father<K,V>{} //父类

   定义子类时直接为父类泛型参数赋值

public class Son : Father<int,string>

  定义子类时把子类泛型参数赋给父类泛型参数

public class Son<W,Y> : Father<W,Y>

  定义子类时把子类泛型参数，同时为父类泛型参数赋值

public class Son<W,Y> : Father<int,string>

错误：

public class Son : Father<K,V> //K，V不存在

3.泛型约束-基类约束：用来约束 泛型参数 必须是某个类 或 某个类的子类

class Dog
   {
        public void Shout() { }
    }
    class Cat
    {
        public void Walk() { }
    }
    class House<TPet,TPet2> where TPet:Dog  where TPet2:Cat
    {
        public C(TPet p1, TPet2 p2)
        {
            p1.Shout();
            p2.Walk();
        }
    }

注：一个泛型参数不允许多个基类约束
       不能为密封类指定基类约束(string)
       也不能用Nullable<T>

4.泛型约束-接口约束：用来约束泛型参数 必须是某个类 或 某个类的子类

interface IGetReward<T>
{ T GetReward(); }

interface IWalk
{ void Walk(); }

interface ISing<T>
{ T Sing(); }

class MyPetPlay<T, V> where T : IGetReward<T>   where V : IWalk, ISing<V>
{
       public MyClass(T t,V v)
      {
            t.GetReward(); //直接调用接口方法
            v.Walk();
            v.Sing();
      }
}

5.泛型约束-class/struct约束

public struct A{ }
public class B{ }

public class C<T> where T : struct   //值类型
{
}
public class C2<T> where T : class   //引用类型
{
}

6.泛型约束-构造器约束

class Dog
{
    public Dog(){ }
}
class Cat
{
    public Cat(int age){ }
}
class Pet<T> where T : new()   //C#只支持无参数的构造器约束
{
    T t;
    public Pet()
    {
        t = new T();
    }
}
public static void Main(string[]arg)
{
        Pet<Dog> c = new Pet<Dog>();
        Pet<Cat> d = new Pet<Cat>();//异常
}

7.泛型方法-及重载

  public static T GetObject<T>() where T : new()
        {
            return new T();
        } 


        private void btnMethodOverload_Click(object sender, EventArgs e)
        {
            //两个方法 虽然都叫 SayA，并且 参数列表为空，看上去就是一个 “重载”；但实际上是两个方法
            SayA();
            SayA<string>();

            //真正的重载：两个带不同个数的 类型参数 的泛型方法 构成重载
            //*泛型方法的类型参数 和 方法参数列表 都是构成重载的 元素********
            SayB<string>();
            SayB<string, int>();
        }

        //泛型和非泛型方法 其实没有重载
        void SayA<T>()
        {

        }
        void SayA()
        {
 
        }

        //泛型方法的重载
        void SayB<T>()
        { 
        }
        void SayB<T,T2>()
        { 
        }
        void SayB<T>(string strName)
        {
        }

        //泛型类型 约束 不构成重载的条件
        //void SayB<T>() where T : class
        //{ 
        //}