泛型的原理、应用、约束、缓存

什么是泛型

泛型是程序设计语言的一种特性。允许程序员在强类型程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须作出指明。各种程序设计语言和其编译器、运行环境对泛型的支持均不一样。将类型参数化以达到代码复用提高软件开发工作效率的一种数据类型。泛型类是引用类型，是堆对象，主要是引入了类型参数这个概念。

.net framework1.0时代，如果有以下需求，需要传递不同类型变量的值，并且打印该变量的值。

• 定义多个不同类型参数的方法：（重复代码量大、开发成本高、难以应对复杂的业务需求，微软考虑到这些问题，在.net framework2.0推出了泛型）

        /// <summary>
        /// 打印个int值
        /// </summary>
        /// <param name="iParameter"></param>
        public static void ShowInt(int iParameter)
        {
            Console.WriteLine("This is {0},parameter={1},value={2}", typeof(CommonMethod).Name, iParameter.GetType().Name, iParameter);
        }
        /// <summary>
        /// 打印个string值
        /// </summary>
        /// <param name="sParameter"></param>
        public static void ShowString(string sParameter)
        {
            Console.WriteLine("This is {0},parameter={1},value={2}", typeof(CommonMethod).Name, sParameter.GetType().Name, sParameter);
        }
        /// <summary>
        /// 打印个DateTime值
        /// </summary>
        /// <param name="oParameter"></param>
        public static void ShowDateTime(DateTime dtParameter)
        {
            Console.WriteLine("This is {0},parameter={1},value={2}", typeof(CommonMethod).Name, dtParameter.GetType().Name, dtParameter);
        }

• 定义一个Object类型（没有约束，任何类型都能传递进来，所以可能不安全）

        /// <summary>
        /// 打印个object值
        /// 1 任何父类出现的地方，都可以用子类来代替，object是一切类型的父类
        /// 2 使用Object产生两个问题：装箱拆箱、类型安全
        /// </summary>
        /// <param name="oParameter"></param>
        public static void ShowObject(object oParameter)
        {
            Console.WriteLine("This is {0},parameter={1},value={2}", typeof(CommonMethod), oParameter.GetType().Name, oParameter);
        }

• object类型参数有两个问题：

1. 装箱拆箱，性能损耗，传入一个int值(栈)，object又在堆里面，如果把int传递进来，就会把值从栈里面copy到堆里，使用的时候，又需要用对象值，又会copy到栈(拆箱)
2. 类型安全问题，可能会有，因为传递的对象是没有限制的

• 使用泛型方法

        /// <summary>
        /// 泛型方法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="tParameter"></param>
        public static void Show<T>(T tParameter)//, T t = default(T
        {
            Console.WriteLine("This is {0},parameter={1},type={2}", typeof(CommonMethod), tParameter.GetType().Name, tParameter);
        }

• 泛型方法：

 　　方法名称后面加上尖括号，<>里面是类型参数，类型参数实际上就是一个不确定类型T声明，声明过后方法就可以用这个不确定类型T了。在声明泛型时，并没有写死类型，T是什么？不知道，T要等着调用的时候才指定。正是因为没有写死，才拥有了无限的可能！！

• 泛型的设计思想：

　　延迟声明：推迟一切可以推迟的，一切能晚点再做的事儿，就晚点再做。深入一下，泛型的原理，泛型在代码编译时，究竟生成了一个什么东西？泛型不是一个简单的语法糖，是框架升级支持的。泛型方法的性能跟普通方法一致，是最好的，而且还能一个方法满足多个不同类型。

泛型的定义主要有以下两种

1.在程序编码中一些包含类型参数的类型，也就是说泛型的参数只可以代表类，不能代表个别对象。（这是当今较常见的定义）

2.在程序编码中一些包含参数的类。其参数可以代表类或对象等等。（人们大多把这称作模板）不论使用哪个定义，泛型的参数在真正使用泛型时都必须作出指明。

一些强类型编程语言支持泛型，其主要目的是加强类型安全及减少类转换的次数，但一些支持泛型的编程语言只能达到部分目的。

.NET Framework 的泛型

泛型是具有占位符（类型参数）的类、结构、接口和方法，这些占位符是类、结构、接口和方法所存储或使用的一个或多个类型的占位符。泛型集合类可以将类型参数用作它所存储的对象的类型的占位符；类型参数作为其字段的类型及其方法的参数类型出现。泛型方法可以将其类型参数用作其返回值的类型或者其某个形参的类型。

由于.NET Framework 泛型的类型参数之实际类型在运行时均不会被消除，运行速度会因为类型转换的次数减少而加快。

                Console.WriteLine(typeof(List<>));
                Console.WriteLine(typeof(Dictionary<,>));

打印结果：

.NET泛型的使用：

• 泛型方法：为了一个方法满足不同的类型的需求，为了一个方法满足不同的类型的需求，一个方法完成多实体的查询，一个方法完成不同的类型的数据展示。

        public List<T> GetList<T>(System.Linq.Expressions.Expression<Func<T, bool>> expression) where T : class, new()
        {
            SqlSugarClient ssc = new SugarHelper(ConnectionKey).GetSqlSugarClient();
            List<T> t = ssc.Queryable<T>().Where(expression).ToList();
            if (t != null && t.Count > 0)
            {
                return t;
            }
            return null;
        }

• 泛型类：一个类，满足不同类型的需求
• 泛型接口：一个接口，满足不同类型的需求

    public interface GenericInterface<T>
    {
    }

• 泛型委托：一个委托，满足不同类型的需求，如.Net自带的Action和Fucn
• 任意一个实体，转换成一个JSON字符串。

泛型约束

　　允许对个别泛型的类型参数进行约束，包括以下几种形式（假设 C是泛型的类型参数， 是一般类、泛类，或是泛型的类型参数）：T 是一个类。T 是一个值类型。T 具有无参数的公有建构方法。T 实现接口 I 。T 是 C ，或继承自 C 。

　　没有约束，其实很受局限，自由主义的鼻祖洛克先生说过，有了法律，才有自由，其实自由都是相对的。基类约束：where T:BaseModel可以把T当成基类，T必须是BaseModel或者其子类。为什么要有约束？Eg：红绿灯约束，绿灯行（权利）、红灯停（约束），因为有约束才有绿灯行的权利。

示例：

• 基类约束

      public class People
      {
          public int Id { get; set; }
          public string Name { get; set; }
          public void Hi()
          { }
      }

        /// <summary>
        /// 基类约束,T必须是People或People的子类
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="tParameter"></param>
        public static void Show<T>(T tParameter)where T:People
        {
            Console.WriteLine("This is {0},parameter={1},type={2}",typeof(GenericConstraint), tParameter.GetType().Name, tParameter);
            Console.WriteLine($"{tParameter.Id}  {tParameter.Name}");
            tParameter.Hi();
        }

• 引用类型约束

        /// <summary>
        /// 引用类型约束，T必须是一个引用类型
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public T GetT<T>() where T : class
        {
            return null;
        }

• 值类型约束

        /// <summary>
        /// 值类型约束
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public T ShowT<T>() where T : struct
        {
            return default(T); //default是个关键字，会根据T的类型去获得一个默认值
        }

• 无参数构造函数约束

        /// <summary>
        /// 无参数构造函数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="S"></typeparam>
        /// <returns></returns>
        public T GetT<T, S>() where T : new()
        {
            return new T();
        }

• 多个约束

        /// <summary>
        /// 多个约束
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="S"></typeparam>
        /// <returns></returns>
        public T GetT_<T, S>()
           where T : People, IWork, new()
        {
            return new T();
        }

• 多个参数一致性约束

        /// <summary>
        /// 多个参数一致性约束，表示T和S都必须是People或People的子类
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="S"></typeparam>
        /// <returns></returns>
        public T FindT<T, S>() where T : People where S : T
        {
            return null;
        }

ps：不能使用密封类约束，因为没有意义。

泛型缓存

　　每个不同的T，都会生成一份不同的副本，适合不同类型，需要缓存一份数据的场景，效率高。

    /// <summary>
    /// 每个不同的T，都会生成一份不同的副本，适合不同类型，需要缓存一份数据的场景，效率高。
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class GenericCache<T>
    {
        static GenericCache()
        {
            Console.WriteLine("This is GenericCache 静态构造函数");
            _TypeTime = string.Format("{0}_{1}", typeof(T).FullName, DateTime.Now.ToString("yyyyMMddHHmmss.fff"));
        }
        private static string _TypeTime = "";
        public static string GetCache()
        {
            return _TypeTime;
        }
    }