泛型 Generic

什么是泛型

1. 就是在 声明的时候,带上一个<>,指定类型参数,调用的时候指定类型调用--泛型

2. 泛型方法:一个方法满足了不同类型的需求:

3. 泛型类:一个类满足了不同类的需求

4. 泛型接口:一个接口满足了不同接口的需求

5. 泛型委托:一个委托满足了不同委托的需求

   public static void ShowObject (string s){
   Console.WriteLine("this is {typeof(s).Name}");
   }
   public static void ShowObject (int i){
   Console.WriteLine("this is {typeof(i).Name}");
   }
   ///Object类型的方法
   ///为什么可以传入Int  String Datetime
   ///1.Object是所有类型的基类
   ///2.(任何父类出现的地方都可以使用子类来代替)里氏替换原则
   public static void  ShowObject (Object o){
      Console.WriteLine("this is {typeof(o).Name}"); 
   }
   ///泛型的方法
   public static  void show<T>(T t){
       Console.WriteLine("this is {typeof(t).Name)");
   }

   泛型方法:在生命的时候,指定参数 T,T是什么类型

   在调用的时候确定参数类型

   延迟声明:在开发中,延迟一起可以延迟的处理,能晚点做,就尽量晚点做

   泛型在编译之后,泛型参数会生成占位符`

   最终会根据调用生成不同的普通方法:

   泛型在.NetFramework2已经出来了;

   泛型不是语法糖

   使用的时候需要确定类型
   

   泛型约束，泛型缓存

   泛型约束

   [泛型支持的几种约束类型]

   泛型类的五大约束 1. where T：struct 限定当前参数类型必须是值类型 2. where T：class 限定当前类型参数类型必须是引用类型 3. where T：new（） 限定当前参数类型必须有一个无参构造器 4. where T：<base class name> 限定当前参数类型 必须是当前类 或者当前类为基类的类父类名 5. where T：<interface name>限定当前参数类型必须实现指定接口

   约束	说明
   where T:struct	对于结构约束，类型T必须是值类型
   where T:class	类约束指定类型T必须是引用类型
   where T:IFoo	指定类型T必须实现接口IFoo
   where T:Foo	指定类型T必须派生自基类Foo
   where T:new()	这是一个构造函数约束，指定类型T必须有一个默认构造函数
   where T1:T2	这个约束也可以指定，类型T1派生自泛型类型T2

   
   

     /// <summary>
           /// 增加 了约束,相当于获取了便利;同时也需要付出成本
           /// 约束
           /// 基类约束: 约束这个T  就是People ,就约束只能传递People或者Peoplede的子类
           /// 接口约束:  
           ///     可以调用接口中的方法--权利
           ///     调用的时候只能传递实现过这个接口的类进入 --义务
           /// </summary>
           /// <typeparam name="T"></typeparam>
           /// <param name="TParamter"></param>
           public static void Show<T>(T TParamter) where T : People
           {
               Console.WriteLine($"{TParamter.ID}");
               Console.WriteLine($"{TParamter.Name}");
           }
           public class People
           {
               public int ID { get; set; }
               public string Name { get; set; }
           }

   缓存就是一个暂存区; 字典缓存:静态属性常驻内存

   /// <summary>
       /// 字典缓存:静态属性常驻内存
       /// </summary>
       public class DictionaryCache
       {
           private static Dictionary<Type, string> _TypeTimeDictionart = null;
           /// <summary>
           /// 初始化
           /// </summary>
           static DictionaryCache()
           {
               Console.WriteLine("this  is DictionartCache 静态构造函数");
               _TypeTimeDictionart = new Dictionary<Type, string>();
           }
           public static string GetCache<T>()
           {
               Type type = typeof(T);
               if (!_TypeTimeDictionart.ContainsKey(type))
               {// 没有添加一次
                   _TypeTimeDictionart[type] = $"{typeof(T).FullName}_{DateTime.Now.ToString("yyyyMMddHHmmss.fff")}";
               }
               return _TypeTimeDictionart[type];
           }
       }
   static void Main(){
       
    string s =DictionaryCache.GetCache<string>();
   }

   泛型缓存: 泛型类会很久调用的不用类型生成不同的副本

   /// <summary>
       /// 泛型缓存本质是一个泛型类
       /// </summary>
       /// <typeparam name="T"></typeparam>
       public class GenericCache<T> {
           static GenericCache() {
               Console.WriteLine("this is GenericCache 静态构造函数");
               _TypeTime = $"{typeof(T).FullName}_{DateTime.Now.ToString("yyyyMMddHHmmss.fff")}";
           }
           private static string _TypeTime = "";
           public static string GetCache() {
               return _TypeTime;
           }
       }

   协变

   Out 只能做返回值 ,不能做参数,其实是一种为了避开风险而存在的一种约束
   

   逆变

   In 不能做返回值 ,只能做参数,
   
   协变逆变可以组合使用