.NET学习笔记（一）----泛型的引入、优势、设计思想、原理、应用

类:

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

public class People2
{
	//带参构造函数
	public People2(int id)
	{
	}
	public int Id { get; set; }
    public string Name { get; set; }
}

public class Chinese : People , ISports
{
	public void Tradition()
    {
    	Console.WriteLine("仁义礼智信，温良恭俭让");
    }
    public void SayHi()
   	{
       Console.WriteLine("吃了么？");
    }

    public void Pingpang()
    {
  		Console.WriteLine("打乒乓球...");
    }

    public void Work()
    {
    	Console.WriteLine("Work...");
    }
}

接口:

public interface ISports
{
    void Pingpang();
}

1、基类约束

①.where后面指定类为参数类型
②.可以传递指定类与其子类
③.因为约束的存在，只要能成功传入参数，就一定没问题，所以不会存在类型安全问题。

展示用的方法:

//把类型参数当做People
public static void Show(T tParameter) where T:People
{
	Console.WriteLine($"People.Id = {tParameter.Id}")
}

调用：

People people = new People()
{
	Id = 123，
	Name = "张三"
};
Show(people);

Chinese chinese = new Chinese()
{
	Id = 123,
	Name = "李四"
};
Show(chinses);

2、接口约束

①.where后面指定接口为参数类型
②.只能传递指定接口或者是实现过这个接口的类
③.接口约束可以获取、增加接口中的功能

展示用的方法:

public static void ShowInterface(T tParameter) where T:ISports
{
	//调用接口中的功能
	tParameter.Pingpang();
}

调用:

Chinese chinese = new Chinese()
{
	Id = 123,
	Name = "李四"
};
ShowInterface(chinses);

3、引用类型约束

①.就只能传递引用类型，比如where后指定class就只能传递类

展示用的方法:

public static void ShowClass(T tParameter) where T:class
{
}

调用：

People people = new People()
{
	Id = 123，
	Name = "张三"
};
ShowClass(people);

Chinese chinese = new Chinese()
{
	Id = 123,
	Name = "李四"
};
ShowClass(chinses);

4、值类型约束

①.就只能传递值类型，比如int、DateTime

展示用的方法:

public static void ShowStruct(T tParameter) where T:struct
{
}

调用：

ShowStruct(123);
ShowStruct(DateTime.Now);

5、无参数构造函数约束

----没有有参数构造函数约束

①.必须有一个无参数构造函数才能当做参数传入

展示用的方法:

public static void ShowNew(T tParameter) where T:new()
{
	T t = new T();
}

调用：

People people = new People()
{
	Id = 123，
	Name = "张三"
};
ShowNew(people);

//报错
People2 people2 = new People2()
{
	Id = 123，
	Name = "张三"
};
ShowNew(people2);

6、枚举约束

①.必须是枚举才能传入

展示用的方法:

public static void ShowEnum(T tParameter) where T:Enum
{
	T t = new T();
}

调用：

public Enum UserType
{
	Chinese = 1,
	Japanese = 2
}
ShowEnum(User.Chinese);

7、其他补充

①、要么是父子关系，要么是同一个类型

展示用的方法:

public static void ShowParent(T tParameter , S sParameter) where T:S
{
}

调用：

People people = new People()
{
	Id = 123，
	Name = "张三"
};

Chinese chinese = new Chinese()
{
	Id = 123,
	Name = "李四"
};

//父子关系调用
//子类在前，父类在后
ShowParent(chinese , people);

//同类型调用
ShowParent(chinese , chinese);

----泛型缓存的本质是泛型类

泛型缓存:

//泛型缓存--可以根据不同的类型生成一个新的类的副本，几种类型就会生成几个副本；
for (int i = 0; i < 5; i++)
{
    Console.WriteLine(GenericCache.GetCache()); //GenericCacheInt
    Thread.Sleep(10);
    Console.WriteLine(GenericCache.GetCache());// GenericCachelong
    Thread.Sleep(10);
    Console.WriteLine(GenericCache.GetCache());
    Thread.Sleep(10);
    Console.WriteLine(GenericCache.GetCache());
    Thread.Sleep(10);
    Console.WriteLine(GenericCache.GetCache());
    Thread.Sleep(10);
}

/// 

///泛型缓存：
/// 
/// 
public class GenericCache
{
	//每种类型都会执行一次静态方法，且执行一次
    static GenericCache()
    {
        Console.WriteLine("This is GenericCache 静态构造函数");
        //_TypeTime = string.Format("{0}_{1}", typeof(T).FullName, DateTime.Now.ToString("yyyyMMddHHmmss.fff")); 
        _TypeTime = $"{typeof(T).FullName}_{DateTime.Now.ToString("yyyyMMddHHmmss.fff")}";
    }

    private static string _TypeTime = "";

    public static string GetCache()
    {
        return _TypeTime;
    }
｝

普通的字典缓存（用于比较）:

//字典缓存
{
    for (int i = 0; i < 5; i++)
    {
        Console.WriteLine(DictionaryCache.GetCache()); //GenericCacheInt
        Thread.Sleep(10);
        Console.WriteLine(DictionaryCache.GetCache());// GenericCachelong
        Thread.Sleep(10);
        Console.WriteLine(DictionaryCache.GetCache());
        Thread.Sleep(10);
        Console.WriteLine(DictionaryCache.GetCache());
        Thread.Sleep(10);
        Console.WriteLine(DictionaryCache.GetCache());
        Thread.Sleep(10);
    }
}

/// 

/// 字典缓存：静态属性常驻内存
/// 
public class DictionaryCache
{
    private static Dictionary _TypeTimeDictionary = null;

    //静态构造函数在整个进程中，执行且只执行一次；
    static DictionaryCache()
    {
        Console.WriteLine("This is DictionaryCache 静态构造函数");
        _TypeTimeDictionary = new Dictionary();
    }
    public static string GetCache()
    {
        Type type = typeof(T);
        if (!_TypeTimeDictionary.ContainsKey(type))
        {
            _TypeTimeDictionary[type] = $"{typeof(T).FullName}_{DateTime.Now.ToString("yyyyMMddHHmmss.fff")}";
        }
        return _TypeTimeDictionary[type];
    }
}

----协变逆变只针对泛型接口和泛型委托

类:

/// 

/// 动物
/// 
public class Animal
{
    public int Id { get; set; }
}

/// 

/// Cat 猫
/// 
public class Cat : Animal
{
    public string Name { get; set; }
}

1.泛型存在不友好、不协调的地方（list本身就是一个泛型集合）。

//任何子类都可以使用父类来声明
//一只猫可以是一只动物
Animal animal2 = null;
animal2 = new Cat();

//下面的代码会报错:
//一群猫没办法成为一群动物
List animalList2 = null;
// //不能在左边用父类
animalList2 = new List();

普通的解决办法:

List animalList3 = new List().Select(c => (Animal)c).ToList();

2.协变
官方文档中的IEnumerable:

public interface IEnumerable : IEnumerable
{
    new IEnumerator GetEnumerator();
}

IEnumerable的使用:

//IEnumerable 也经常把他当成一个集合来用
//协变:让右边用子类，能让左边用父类
IEnumerable animalList1 = new List();
IEnumerable animalList2 = new List();

OUT：

/// 

/// out 协变 只能是返回结果 ，还是int 也是一种高级约束，避免出现问题
/// 泛型T 就只能做返回值； 不能做参数； 
/// 
/// 
public interface ICustomerListOut
{
    T Get();

    //void Show(T t);
}

public class CustomerListOut : ICustomerListOut
{
    public T Get()
    {
        return default(T);
    }
	
	//public void Show(T t)
    //{
	//
    //}
}

//out:修饰类型参数；就可以让右边用子类，能让左边用父类
ICustomerListOut customerList = new CustomerListOut(); 

3.逆变
IN:

/// 

/// T 就只能做参数  不能做返回值
/// 
/// 
public interface ICustomerListIn
{
    //T Get();

    void Show(T t);
}

public class CustomerListIn : ICustomerListIn
{
    //public T Get()
    //{
    //    return default(T);
    //}

    public void Show(T t)
    {

    }
}

//逆变：就可以让右边用父类；左边用子类
//逆变： In 类型参数只能做参数 ，不能做返回值
ICustomerListIn customerList = new CustomerListIn();

4.协变逆变同时存在

public interface IMyList
{
    void Show(inT t);
    outT Get();
    outT Do(inT t);
}

//协变逆变的存在，就是为了满足常规场景添加一个避开风险的约束； 
{
    IMyList myList1 = new MyList();
    IMyList myList2 = new MyList();//协变 
    IMyList myList3 = new MyList();//逆变 
    IMyList myList4 = new MyList();//协变+逆变
}