using System.Collections.Generic;

 public class CommonClass
     {
         public static void ShowInt(int iValue)
         {
             //typeof(CommonClass) typeof关键字 获取一个类型的类型
             Console.WriteLine(" ShowInt方法 展示{0}，其类型为{1}", iValue, typeof(int));
         }

         public static void ShowLong(long lValue)
         {
             //lValue.GetType() 变量.GetType()  获取一个变量的类型
             Console.WriteLine(" ShowLong方法 展示{0}，其类型为{1}", lValue, lValue.GetType());
         }

         public static void ShowString(string sValue)
         {
             Console.WriteLine(" ShowString方法 展示{0}，其类型为{1}", sValue, sValue.GetType());
         }

         public static void ShowDateTime(DateTime dValue)
         {
             Console.WriteLine(" ShowDateTime方法 展示{0}，其类型为{1}", dValue, dValue.GetType());
         }

         /// <summary>
         /// 1 通过继承，子类拥有父类的一切属性和行为，任何父类出现的地方，子类都可以代替
         /// 2 object 类型是一切类型的父类
         /// </summary>
         /// <param name="oValue"></param>
         public static void ShowObject(object oValue)
         {
             Console.WriteLine(" ShowObject方法 展示{0}，其类型为{1}", oValue, oValue.GetType());
         }
     }

每种方法都需要声明一个，作为一名程序员都知道这样是不对的，效率太低。

但是用object类型则需要多次的装箱和拆箱操作，效率上实在是不太好了。

所以有了泛型，泛型就是先不声明类型，用占位符替代类型的位置，在使用的时候再指定类型。

下面引入泛型：

通过一个方法完成多个不同参数类型的方法-泛型方法

1　　      /// <summary>
         /// 延迟声明：推迟一切可以推迟的东西
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="tValue"></param>
         public static void Show<T>(T tValue)//Show`1   1是泛型类型的个数
         {
             Console.WriteLine(" Show<T>方法 展示{0}，其类型为{1}", tValue, tValue.GetType());
         }

基础类：

    public class BaseModel
     {
         public int Id { get; set; }
         public string Name { get; set; }
     }

     public class People : BaseModel
     {
         public void SayHi()
         {
             Console.WriteLine("{0} 吃了吗", base.Name);
         }
     }

     public class Chinese : People, ISport,IGame
     {
         public string Majiang { get; set; }

         public void Pingpang()
         {
         }

         public void Yumao()
         {
         }

         public void Chess()
         {
         }
     }

     public class Japanese
     {
         public int Id { get; set; }
         public string Name { get; set; }
         public void SayHi()
         {
             Console.WriteLine("{0} ^*^&^&%&", this.Name);
         }
         public string Dongman { get; set; }
     }

     public interface ISport
     {
         void Pingpang();
         void Yumao();
     }

     public class Sporter : ISport
     {

         public void Pingpang()
         {

         }

         public void Yumao()
         {
         }
     }

     public interface IGame
     {
         void Chess();
     }

1         泛型里的<>占位符可以多个,指定占位符后可以在本方法内使用占位符所代表的类型,比如现在参数列表里　　　　　　声明变量,然后再使用(占位符不一定要使用完,就像我有钱，并不一定要花完一样.)  　　   

           private static void Test<T, S, RUANMOU, Eleven>(T tValue, Eleven eleven)//Test`4
         {
             Console.WriteLine(" Show<T>方法 展示{0}，其类型为{1}", tValue, tValue.GetType());
         }

泛型接口：

     public interface IGenericInterface<T, S, W, Ruanmou>
     {
         void Query<X, Y, T, S>();
         void Do(T t);
     }

 　　 public interface IInterface
     {
         void Foo();
     }

声明泛型类的可能遇到的两种情况

1 参数列表要和继承的保持一致,继承者的参数列表可以多但不能比被继承的参数少.

  　　public class ClassFromInterface<T, S, W, Ruanmou,liuyJ> : IInterface, IGenericInterface<T, S, W, Ruanmou>
     {

         public void Foo()
         {
             throw new NotImplementedException();
         }

         public void Query<X, Y, T, S>()
         {
             throw new NotImplementedException();
         }

         public void Do(T t)
         {
             throw new NotImplementedException();
         }
     }

2.在继承的泛型接口里直接指定类型

  public class ClassFromInterfaceCommon : IInterface, IGenericInterface<int, string, DateTime, IInterface>
     {

         public void Foo()
         {
             throw new NotImplementedException();
         }

         public void Query<X, Y, T, S>()
         {
             throw new NotImplementedException();
         }

         public void Do(int t)
         {
             throw new NotImplementedException();
         }
     }

泛型约束：享受约束,拥有权力.

  　　　　/// <summary>
         /// 基类约束是第一个，而且只能有一个People
         /// 接口约束可以多个 ISport,IGame
         /// 值类型和引用类型约束本身不能共存，，而且有了基类约束后，也不需要二者
         /// new只能放在最后面
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="tValue"></param>
         public static void Show<T>(T tValue)
             where T : People, ISport, IGame, new()
         {
             System.Console.WriteLine(tValue.Name);
             System.Console.WriteLine(tValue.Id);
             tValue.SayHi();

             tValue.Pingpang();
             tValue.Yumao();

             tValue.Chess();

             T t = new T();

             Console.WriteLine(" Show<T>方法 展示{0}，其类型为{1}", tValue, tValue.GetType());
         }

对比以下两个方法,一个是泛型方法,另一个是去掉泛型<>，直接指定People.

  　　　　public static void ShowPeople<T>(T tValue)
             where T : People
         {
             System.Console.WriteLine(tValue.Name);
             System.Console.WriteLine(tValue.Id);
             tValue.SayHi();

             Console.WriteLine(" Show<T>方法 展示{0}，其类型为{1}", tValue, tValue.GetType());
         }

         public static void ShowPeople(People tValue)
         {
             System.Console.WriteLine(tValue.Name);
             System.Console.WriteLine(tValue.Id);
             tValue.SayHi();

             Console.WriteLine(" Show<T>方法 展示{0}，其类型为{1}", tValue, tValue.GetType());
         }

从这里就看出了约束的作用了,使用它的类型必须是People类型或者它的子类.

任何父类出现的地方都可以用子类来替代.

class和struct约束

        private T Get<T>()
             //where T : class//表示T是引用类型
             //where T : struct//表示T是值类型
             where T : new()//表示T有一个无参数的构造函数
         {
             T t = new T();
             return default(T);
         }

接口约束:

  　　    public static void ShowPeopleInterface<T>(T tValue)
             where T : ISport
         {
             tValue.Yumao();
             tValue.Pingpang();

             Console.WriteLine(" Show<T>方法 展示{0}，其类型为{1}", tValue, tValue.GetType());
         }

协变out--修饰返回值--子到父.   |     逆变in--修饰传入参数值--父到子.

主要用在泛型接口和泛型委托上

基本类,后面会用到:

     public class Parent
     {
         public int Id { get; set; }
     }
     public class Child : Parent
     {
         public string Name { get; set; }
     }

in和out的接口

     public interface ICustomerListIn<in T>
     {
         void Show(T t);//使用传入参数
     }

     public interface ICustomerList<out T>
     {
         T Get();//返回
     }

接口继承:

out

     public interface ICustomerList<out T>
     {
         T Get();
     }

     public class CustomerList<T> : ICustomerList<T>
     {
         public T Get()
         {
             return default(T);
         }
     }

in

     public interface ICustomerListIn<in T>
     {
         void Show(T t);
     }

     public class CustomerListIn<T> : ICustomerListIn<T>
     {
         public void Show(T t)
         {
         }
     }

----------------------------------------------------------那么正题来了-----------------------------------------------------------------------------------------------------------

1. 一般情况下,子类可以初始化基类,但是,基类是不可以初始化子类的.

           {
                 Parent parent1 = new Parent();
                 Parent parent2 = new Child();
                 Child child1 = new Child();
                 //Child child2 = new Parent();---报错了哦!
             }    

儿子以后可以当老子,老子却不能当儿子(这里只说父子,没有爷爷.)

2. 初学者的误区:在List<>里面指定父类和子类

　　　　　　　　比如：Parent和Child有继承和派生的关系,但是,并不代表着List<Parent>和List<Child>有半毛钱的关系.

　　　　　　　　　　　因为List<Parent>和List<Child>分别是新的类型而且是不同的List<泛型集合>类型.

　　　　　　　{
                List<Parent> parentList1 = new List<Parent>();
                //List<Parent> parentList2 = new List<Child>();//ParentList类型和ChildList类型没有父子关系,所以即使Perent和Child有父子关系也不能这么玩
                List<Parent> parentList3 = new List<Child>().Select(c => (Parent)c).ToList();
            }

3.添加有out的就可以咯

 namespace System.Collections.Generic
 {
     // 摘要:
     //     公开枚举数，该枚举数支持在指定类型的集合上进行简单迭代。
     //
     // 类型参数:
     //   T:
     //     要枚举的对象的类型。
     [TypeDependency("System.SZArrayHelper")]
     public interface IEnumerable<out T> : IEnumerable
     {
         // 摘要:
         //     返回一个循环访问集合的枚举器。
         //
         // 返回结果:
         //     可用于循环访问集合的 System.Collections.Generic.IEnumerator<T>。
         IEnumerator<T> GetEnumerator();
     }
 }

系统的协变out

 　　　　　　　{
                 IEnumerable<Parent> parentList1 = new List<Parent>();
                 IEnumerable<Parent> parentList2 = new List<Child>();//ParentList类型和ChildList类型没有父子关系
             }

4. out-子到父-协变

  　　　　　　{
                 ICustomerList<Parent> customerList1 = new CustomerList<Parent>();
                 ICustomerList<Parent> customerList2 = new CustomerList<Child>();
             }
 

5.in-父到子-逆变

 1　　　　　　   {
                 ICustomerListIn<Child> customerList2 = new CustomerListIn<Child>();
                 customerList2.Show(new Child());

                 ICustomerListIn<Child> customerList1 = new CustomerListIn<Parent>();
                 customerList1.Show(new Child());

                 ICustomerListIn<Parent> parentList1 = new CustomerListIn<Parent>();
                 parentList1.Show(new Child());
                 parentList1.Show(new Parent());
             }

6.out和in都有的情况,都可以咯.

    public class MyList<T1, T2> : IMyList<T1, T2>
     {

         public void Show(T1 t)
         {
             Console.WriteLine(t.GetType().Name);
         }

         public T2 Get()
         {
             Console.WriteLine(typeof(T2).Name);
             return default(T2);
         }

         public T2 Do(T1 t)
         {
             Console.WriteLine(t.GetType().Name);
             Console.WriteLine(typeof(T2).Name);
             return default(T2);
         }
     }

     public interface IMyList<in inT, out outT>
     {
         //out 只能是返回值   in只能是参数
         void Show(inT t);
         outT Get();
         outT Do(inT t);
     }

总体来说:  out和in的功能就是告诉编译器不报错.

out，是协变嘛,协助变换,顺向的,就是子类到父类.所以可以返回.

但不能当参数用,因为子类变父类是有限制的.

in,是逆变呗,逆向变换,逆向的,就是父类到子类.只能用在参数里.

讲道理,它是违规的,所以呢,不能返回,当参数运算还是可以得.