1.net基础之泛型

泛型的引入:微软在 .net frameWork 2.0 框架引入了泛型。 泛型的引入解决了代码重复了的问题，将公共逻辑抽象化；增加了代码的性能，泛型通过使用类型占位符预编译在实际调用时传递具体类型参数，进而减少值类型和引用类型的相互装箱 / 拆箱。

1. 引入泛型
2. 声明使用泛型
3. 泛型好处对比性能
4. 泛型类，泛型方法，泛型接口，泛型委托
5. 泛型约束
6. 泛型的逆变，协变  out协变covariant 修饰返回值,in 逆变 contravariant 修饰传入值
7. 泛型缓存

泛型的声明在没有使用泛型的情况下编写可以接收多种类型的实现相同逻辑的函数通常有两种方式。1，需要什么类型就定义一个接收固定类型的方法，各自方法实现一遍相同的逻辑。2，定义一个函数接收object类型参数。代码如下

 
    public class CommonMethod
    {
        public static void ShowInt(int iParameter)
        {
            Console.WriteLine("This is {0},parameter {1},type={2}",
                typeof(CommonMethod).Name, iParameter, iParameter.GetType().Name);
        }
        public static void ShowString(string sParameter)
        {
            Console.WriteLine("This is {0},parameter {1},type={2}",
                typeof(CommonMethod).Name, sParameter, sParameter.GetType().Name);
        }
        public static void ShowDateTime(DateTime dtParameter)
        {
            Console.WriteLine("This is {0},parameter {1},type={2}",
                typeof(CommonMethod).Name, dtParameter, dtParameter.GetType().Name);
        }


        /// <summary>
        /// object是所有类型的父类
        /// 通过继承，子类拥有父类一切的属性和行为，任何父类出现的地方都可以用子类来代替
        /// 传递值类型的时候会产生装箱操作
        /// </summary>
        /// <param name="obj"></param>
        public static void ShowObject(object obj) {
            Console.WriteLine("This is {0},parameter {1},type={2}",
              typeof(CommonMethod).Name, obj, obj.GetType().Name);
        }

用第一种方式和第二种方式都可以解决问题。那么他们有各自的缺点。

第一种方式：如果传递十种类型的参数那么就需要定义是个方法,内部逻辑相同这样会产生重复劳动和大量的重复代码。

第二种方式：因为参数为object类型如果传递了值类型就会产生装箱操作，产生程序性能的损耗。

第三种方式：泛型。通过泛型可以解决以上的需求： 传入参数不确定，内部逻辑相同，不会产生性能方面的损耗。

声明使用泛型方法

//泛型方法    ---  有相同逻辑的地方，类型不同或类型不确定的情况下，提高代码重用性
        /// <summary>
        /// 延迟声明，在声明方法的时候没有指定参数类型，在调用的时候再指定
        /// 编译的时候，类型参数编译为占位符
        /// 程序运行的时候jit即时编译的时候编译为真实类型
        /// </summary>
        /// <typeparam name="T">类型参数</typeparam>
        /// <param name="tParameter">实际参数</param>
        public static void Show<T>(T tParameter) {
            Console.WriteLine("This is {0},parameter {1},type={2}",
                typeof(CommonMethod).Name, tParameter, tParameter.GetType().Name);
        }

 

使用泛型方法和普通方法和object方法的性能对比

 public class Monitor
    {
        int iValue = 12345;
        static long commonSeconds = 0; //普通方法运行时间
        static long objectSeconds = 0; //object方法运行时间
        static long genericSeconds = 0; //泛型方法运行时间

        public static void ShowMonitor()
        {
            {

                Stopwatch commonWatch = new Stopwatch();
                commonWatch.Start();
                for (int i = 0; i < 1000000000; i++)
                {
                    commonMethod(i);
                }
                commonWatch.Stop();
                commonSeconds = commonWatch.ElapsedMilliseconds;
            }

            {

                Stopwatch objectWatch = new Stopwatch();
                objectWatch.Start();
                for (int i = 0; i < 1000000000; i++)
                {
                    objectMethod(i);
                }
                objectWatch.Stop();
                objectSeconds = objectWatch.ElapsedMilliseconds;
            }

            {

                Stopwatch genericWatch = new Stopwatch();
                genericWatch.Start();
                for (int i = 0; i < 1000000000; i++)
                {
                    genericMethod(i);
                }
                genericWatch.Stop();
                genericSeconds = genericWatch.ElapsedMilliseconds;
            }
            Console.WriteLine("普通方法的运行时间为：{0},object方法的运行时间为:{1},泛型方法的运行时间为：{2}",commonSeconds,objectSeconds,genericSeconds);
        }


        public static void commonMethod(int iValue) { }
        public static void objectMethod(object objValue) { }

        public static void genericMethod<T>(T tValue) { }
    }

代码中定义三个方法，分别为普通方法，object方法，泛型方法

依次进行十亿次的调用传递值类型参数进行函数调用，然后分别记录下执行时间。通过对比可以看出普通方法和泛型方法的执行时间相近。object方法执行时间几乎为前两者的2倍，这是装箱带来的副作用。

泛型方法在代码整洁度和维护成本上又超过了普通方法。泛型方法应该是同等需求下的最优之选。

泛型的应用，泛型方法，泛型类，泛型接口，泛型委托

  /// <summary>
    /// 泛型类  参考List<> 
    /// 相当于在GenericClass类范围内声明了三个局部类型  A/B/C
    /// </summary>
    /// <typeparam name="A"></typeparam>
    /// <typeparam name="B"></typeparam>
    /// <typeparam name="C"></typeparam>
    public class GenericClass<A,B,C> 
    {
        public void Show(A a) {   //可以直接使用泛型类型

        }
    }

    public interface iInterface<T> {
        void Study(T t);
        T Get(T t);
    }

    public delegate T ShowDelegate<T>(T t);

泛型约束

如果只是定义了一个泛型方法，不对传入的泛型类型参数做约束那么代码就不可控进而会出现不可预期bug。

泛型类型的约束有以下5类：无参数构造函数约束，引用类型约束，值类型约束，基类约束，接口约束。对应代码为(new(),class,struct,基类名，接口名)

以下代码展示以上各种约束。

 public interface iSports
    {
        void Play();
    }
    public class People
    {
        public int ID { get; set; }
        public string Name { get; set; }

        public virtual void Hi() {
            Console.WriteLine("你好");
        }
    }

    public class Chinese : People, iSports
    {
        public void Play()
        {
            Console.WriteLine("打乒乓球。");
        }
        public string tradition = "仁义礼智信，温良恭俭让";

        public override void Hi()
        {
            Console.WriteLine("吃了没");
        }
    }

    public class HuBei : Chinese {
        public void Majiang() {
            Console.WriteLine("打麻将");
        }
    }

    public class Japanese : iSports
    {
        public int ID { get; set; }
        public string Name { get; set; }
        public void Play()
        {
            Console.WriteLine("打乒乓球");
        }
        public void Hi() {
            Console.WriteLine("日本打招呼");
        }
    }

/// <summary>
    /// 泛型约束：积累约束/接口约束/引用类型约束/值类型约束/无参数构造函数约束（new()）
    /// </summary>
   public class Constriant
    {
        public static void Show<T>(T tParameter) where T:People
        {
            Console.WriteLine("This is {0},parameter {1},type={2}",
                typeof(CommonMethod).Name, tParameter, tParameter.GetType().Name);
            Console.WriteLine(tParameter.ID);
            Console.WriteLine(tParameter.Name);
            tParameter.Hi();
        }

        /// <summary>
        /// 接口约束，传递过来的类型参数必须实现了iSports接口
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="tParameter"></param>
        public static void ShowInterface<T>(T tParameter) where T:iSports
        {
            Console.WriteLine("This is {0},parameter {1},type={2}",
                typeof(CommonMethod).Name, tParameter, tParameter.GetType().Name);
            tParameter.Play();
        }

        /// <summary>
        /// 引用类型约束
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static T Get<T>()
            where T:class
        {
            return default(T);
        }
        /// <summary>
        /// 值类型约束
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static T GetStruct<T>()
            where T : struct
        {
            return default(T);
        }

        public static T GetConstructor<T>()
            where T:new() //无参数构造函数约束
        {
            T t = new T();
            return default(T);
        }
    }

 Console.WriteLine("**************泛型约束：基类约束**************");
            People people = new People() {
                ID = 1,
                Name ="zhangsan"
            };
            Chinese chinese = new Chinese() {
                ID = 2,
                Name = "lisi"
            };
            HuBei hubei = new HuBei() {
                ID=3,
                Name = "xl"
            };
            Constriant.Show(people);
            Constriant.Show(chinese);
            Constriant.Show(hubei);   //调用基类约束的泛型方法，传递的类型必须是基类或者子类

            Japanese japanese = new Japanese() {
                ID = 4,
                Name ="小泉"
            };
            //Constriant.Show(japanese);//japanese 没有从people派生，不符合基类约束不能通过编译
            Console.WriteLine("*********泛型约束：接口约束************");
            //Constriant.ShowInterface(people);  people类没有实现iSport接口，不符合接口约束不能通过编译
            Constriant.ShowInterface(chinese);
            Constriant.ShowInterface(hubei);
            Constriant.ShowInterface(japanese);  //japanese实现了iSport接口，可以编译通过

在泛型约束调用时可见，因为japanese没有从people类中派生，所以在调用有泛型类型People基类约束时候会报错，这样在编译时期就能避免类型不对应而导致的错误。

泛型的逆变，协变

泛型缓存