一、泛型类型和泛型方法

泛型类型

泛型方法

二、泛型约束

在定义泛型类时，可以对客户端代码能够在实例化类时用于类型参数的类型种类施加限制。如果客户端代码尝试使用某个约束所不允许的类型来实例化类，则会产生编译时错误。这些限制称为约束。约束是使用 where 上下文关键字指定的。

泛型约束

using System;
namespace HHHHHHH
{
   class Program
   {
       static void Main(string[] args)
       {
           test1<string, int>("niha", 123);
           People p = new People();
           test5<People>(p);
           test6<People>(p);
       }
       /* 注意：
        --不可能同时添加struct和class约束
        --不可能添加多个基类约束
        --约束之间是 and 关系，不能添加or关系的约束
        --构造器约束必须最后
        --构造器约束只能指明无参构造器
        --约束不会继承
       */

       //泛型的默认值
       //使用default关键字来获取泛型类型参数的默认值
       static void zap<T>(T[] array) 
       {
           for (int i = 0; i < array.Length; i++)
           {
               //如果T是引用类型，默认值是null；值类型T默认值是0
               array[i] = default(T);
           }
       }
       //泛型方法
       public static void test1<T1, T2>(T1 t1, T2 t2)
       {
           Console.WriteLine($"{t1.ToString()},{t2}");
       }
       //构造函数约束
       //表示T类型必须要有一个无参的构造函数new T()，可以实例化的T类型
       public static void test2<T,T2>(T t,T2 t2) 
           where T  : new()
           where T2 : new()
       {
           Console.WriteLine($"{t.ToString()}");
       }
       //值类型约束 
       //表示T类型必须是值类型(int,bool,double,struct......)，但并不包括可空的值类型
       public static void test3<T>(T t) where T : struct
       {
           Console.WriteLine($"{t.ToString()}");
       }
       //引用类型约束 
       //表示T类型必须是引用类型(类,接口,委托,string,数组......)
       public static void test4<T>(T t) where T : class
       {
           Console.WriteLine($"{t.ToString()}");
       }
       //where T:基类名 ，基类约束 
       //表示类型参数必须是继承自指定的基类，或是基类本身
       public static void test5<T>(T t) where T : People
       {
           Console.WriteLine($"{t.ToString()}");
       }
       //where T:接口名， 接口约束 
       //表示类型参数必须是实现指定接口，或是指定接口
       public static void test6<T>(T t) where T : animal
       {
           Console.WriteLine($"{t.ToString()}");
       }
       //where T : U， 裸类型约束
       //表示为 T 提供的类型参数必须是为 U 提供的参数或派生自为 U 提供的参数
        public static void test7<T>(T t) where T : animal
       {
           Console.WriteLine($"{t.ToString()}");
       }
   class People :animal
   {
       string name;
   }
   class People2
   {
       string name;
   }
   interface animal
   {
   }
}

三、协变和逆变

可变性是以一种类型安全的方式，将一个对象作为另一个对象来使用，可变性有两种类型：
协变(Covariance)：子类隐式转换为父类。
逆变(Contravariance)：父类隐式转换为子类。
“协变”->”和谐的变”->”很自然的变化”->string->object :协变。
“逆变”->”逆常的变”->”不正常的变化”->object->string 逆变。

1、对于协变性，例如：

string str = "test";
object obj = str;

因为字符串肯定是一个object，所以这种变化非常正常，和谐，故称为协变。
2、对于逆变性，在上面的例子中，无法将str和新的object对象划等号，如果强行实现，还是会在运行中报错

string s =(string) new object();

3、使用

    //协变
    //协变的类型参数只能作为返回结果，不能作为参数
    interface Ixieibian<out T> 
    {
        T Create();
    }
    class xiebian<T> : Ixieibian<T>
    {
        public T Create()
        {
            return default(T);
        }
    }

    //逆变
    //T只能做为参数，不能做返回值
    interface Inibian<in T> 
    {
        void Create(T t);
    }
    class nibian<T> : Inibian<T>
    {
        public void Create(T t)  
       {
       }
    }

            //---***---协变和逆变
            Human hu = new Human();
            Chinese ch = new Chinese();
            //因为Chinese是Human的子类, 子类对象赋予父类, 所以声明不会有问题
            Human hu1 = new Chinese();

            //声明list
            List<Human> hl1 = new List<Human>();
            List<Chinese> cl1 = new List<Chinese>();
            //提示无法将List<Chinese>转为List<Human>，
            //这里的Human虽然是Chinese的父类，但是如果将Human，和Chinese当做List类型来用，那么这里的2个List就不再有继承关系，没有继承关系在声明的时候就会出错
            // hl1 = cl1; 

            //这时候就需要使用协变：
            IEnumerable<Human> human = new List<Chinese>();
            Ixieibian<Human> xie = new xiebian<Chinese>();
            //逆变
            Inibian<Chinese> ni =  new nibian<Human>();