泛型Generic：泛型方法、泛型类集合、泛型接口、泛型委托、泛型缓存字典(性能之王)、协变逆变、Object类、C#编译运行原理

        static void Main(string[] args) 
        {
            void get(object obj) { Console.WriteLine(obj); }
            get(123);
            get("string");
            get(DateTime.Now);
        }  

        static void Main(string[] args)
        {            
            GenericMethod<string>("string");
            GenericMethod<int>(123);
            GenericMethod<DateTime>(DateTime.Now);
        }
        //泛型方法:传入类型不确定       
        public static void GenericMethod<T>(T tParameter)
        {
            Console.WriteLine(tParameter);
        } 

        public class Student //实体类 
        {
            public int ID { get; set; }
            public string Name { get; set; }
        }
        public List<Student> GetList()  //填充数据到集合
        {
            List<Student> studentList = new List<Student>(); //实例化List<Student>集合
            Student student = new Student() { }; //实例化Student实体类
            
            student.ID = 1; //填充数据到实体类
            student.Name = "张三";
            
            studentList.Add(student); //把实体类数据填充到集合中

            return studentList;
        }

        public T GetAll<T,Y,U,I,O,P,A,S>()          //通过where关键字约束
            where T : struct //类型参数必须是不可为 null 的值类型
            where Y : class //类型参数必须是引用类型。 此约束还应用于任何类、接口、委托或数组类型。
            where U : notnull //类型参数必须是不可为 null 的类型
            where I : unmanaged //类型参数必须是不可为 null 的非托管类型
            where O : new() //类型参数必须具有公共无参数构造函数
            where P : <"基类名">   //类型参数必须是指定的基类或派生自指定的基类。
            where A : <"接口名称">   //类型参数必须是指定的接口或实现指定的接口
            where S : U   // T 提供的类型参数必须是为 U 提供的参数或派生自为 U 提供的参数
        {
            return new T();
        }

    public class GenericCacheTest
    {
        public static void Show()
        {
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine(GenericCache<int>.GetCache());
                Thread.Sleep(10);
                Console.WriteLine(GenericCache<long>.GetCache());
                Thread.Sleep(10);
                Console.WriteLine(GenericCache<DateTime>.GetCache());
                Thread.Sleep(10);
                Console.WriteLine(GenericCache<string>.GetCache());
                Thread.Sleep(10);
                Console.WriteLine(GenericCache<GenericCacheTest>.GetCache());
                Thread.Sleep(10);
            }
        }
    }

    /// <summary>
    /// 字典缓存：
    /// 原理：静态属性常驻内存，是key-value的hash存储，每次调用时需要去内存器查找要进行哈希运算
    /// </summary>
    public class DictionaryCache
    {
        private static Dictionary<Type, string> _TypeTimeDictionary = null;
        static DictionaryCache()//静态构造函数
        {
            Console.WriteLine("This is DictionaryCache 静态构造函数");
            _TypeTimeDictionary = new Dictionary<Type, string>();
        }
        public static string GetCache<T>()
        {
            Type type = typeof(Type);
            if (!_TypeTimeDictionary.ContainsKey(type))
            {
                _TypeTimeDictionary[type] = string.Format("{0}_{1}", typeof(T).FullName, DateTime.Now.ToString("yyyyMMddHHmmss.fff"));
            }
            return _TypeTimeDictionary[type];
        }
    }

    /// <summary>
    /// 泛型字典缓存：
    /// 原理：泛型缓存则是直接被JIT编译成一个代码段，是存在寄存器(寄存器是CPU内部用来存放数据的一些小型存储区域)，
    /// 这个代码段又有静态缓存，可以直接用，所以性能比字典高
    /// 
    /// 每个不同的T，都会生成一份不同的副本，适合不同类型，需要缓存一份数据的场景，泛型缓存字典是缓存字典性能的几十倍乃至上百倍
    /// 局限性：只能为某个类型存一个结果，例如为int类型存一个结果，又要为string类型存一个结果
    /// </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;
        }
    }