1.0 什么是泛型
泛型是C#2.0和CLR（公共语言运行时）升级的一个新特性，泛型为.NET 框架引入了一个叫 type parameters（类型参数）的概念，type parameters 使得程序在设计的时候，不必设计其具体的参数，其具体的参数可以延迟到需要的时候声明或调用。使用泛型代码运行时避免了类型转换的装箱和拆箱操作。
2.0 泛型的延迟声明：把参数类型的声明推迟到调用，不是语法糖，而是由框架升级提供的功能
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace _20171010Generic
{
/// <summary>
/// 泛型方法相关类
/// </summary>
public class GenericMethod
{
/// <summary>
/// 泛型方法：方法带<>和type parameters（类型参数 T）的
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="tParameters"></param>
public static void Show<T>(T tParameters)
{
Console.WriteLine("{0}方法，parameter={1}参数，type={2}类型", typeof(GenericMethod).Name, tParameters, tParameters.GetType().Name);
}
}
}
如代码所示，在声明泛型方法的时候没有指定具体的参数类型，等到需要调用的时候再指定，这就叫做延迟声明。泛型的设计思想（延迟思想，推迟一切可以推迟的）
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace _20171010Generic
{
class Program
{
static void Main(string[] args)
{ int iValue = ;
string sValue = "TestName";
DateTime dtValue = DateTime.Now;
object oValue = new object(); GenericMethod.Show(iValue);
GenericMethod.Show(sValue);
GenericMethod.Show(oValue);
GenericMethod.Show(dtValue);
Console.WriteLine("———————我是华丽的分割线————————");
GenericMethod.Show<int>(iValue);
GenericMethod.Show<string>(sValue);
GenericMethod.Show<object>(oValue);
GenericMethod.Show<DateTime>(dtValue); Console.WriteLine("———————我是华丽的分割线————————");
Console.WriteLine(typeof(List<int>));
Console.WriteLine(typeof(Dictionary<,>));
Console.WriteLine("———————我是华丽的分割线————————");
}
}
}
泛型方法的调用，第一种 GenericMethod.Show(iValue);调用方法不指定类型参数，在编译的时候编译器自动编译推算(语法糖)，第二种 GenericMethod.Show<int>(iValue);调用方法指定类型参数，类型参数和参数类型须一致，否则编译不通过。VS2017鼠标移上去会提示可以简化方法名称。编译的时候，类型参数编译为占位符，程序运行的时候，JIT(即时编译（Just In-Time compile）即时编译为真实类型。所以使用泛型性能会比使用object作为参数的方法好，(ps:经过测试)。 Console.WriteLine(typeof(List<int>)); 和Console.WriteLine(typeof(Dictionary<,>));的运行结果中有个~1,和~2就表示类型参数的占位符。
3.0 泛型主要的四种：泛型类， 泛型方法，泛型接口，泛型委托
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace _20171010Generic
{
/// <summary>
/// 动物类
/// </summary>
public class AnimalModel
{
public int Id { get; set; }
public String Name { get; set; }
public virtual void Cry()
{ }
}
public interface IEat
{
void Eat();
}
public interface ISleep
{
void Sleep();
} /// <summary>
/// 狗类
/// </summary>
public class Dog:AnimalModel
{
public override void Cry()
{
Console.WriteLine("旺旺旺。。。。。");
}
}
/// <summary>
/// 猫类
/// </summary>
public class Cat : AnimalModel
{
public override void Cry()
{
Console.WriteLine("喵喵瞄。。。。。。。");
}
} /// <summary>
/// 玫瑰花类
/// </summary>
public class Rose
{
public int Id { get; set; }
public string Name { get; set; }
} }
首先先新建了一个AnimalModel类，里面定义了一个动物类，动物类里有个虚方法Cry，一个狗类，狗类继承了动物类，一个猫类，重写了虚方法Cry。一个IEat接口和ISleep接口，
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace _20171010Generic
{
/// <summary>
/// 泛型类
/// </summary>
/// <typeparam name="T">类型参数</typeparam>
/// <typeparam name="S">类型参数</typeparam>
/// <typeparam name="K">类型参数</typeparam>
public class GenericClass<T, S, K>
{
/// <summary>
/// 无返回值的泛型方法
/// </summary>
/// <typeparam name="T"></typeparam>
public void Show(T t)
{ }
/// <summary>
/// 有返回值的泛型方法
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public T Get()
{
return default(T);
}
} /// <summary>
/// 泛型接口
/// </summary>
/// <typeparam name="W"></typeparam>
public interface ISleep<W>
{
W Sleep(W t);
} /// <summary>
/// 有返回值的泛型委托
/// </summary>
/// <typeparam name="Y"></typeparam>
/// <returns></returns>
public delegate Y DlgYFun<Y>(); public delegate int DlgIntFun(); /// <summary>
/// 泛型类
/// </summary>
/// <typeparam name="W"></typeparam>
/// <typeparam name="Y"></typeparam>
/// <typeparam name="M"></typeparam>
public class GenericChild<T, S, K>
//: GenericClass<T, S, K>直接继承泛型类
//: GenericClass<T, S, string>//类型参数可直接指定
//: ISleep<string>
: ISleep<T>//实现泛型接口
{
T ISleep<T>.Sleep(T t)
{
return default(T);
}
} /// <summary>
/// 普通类
/// </summary>
public class Child
// :GenericClass<T,S,K>错误的继承，普通类不能直接继承泛型类
//: GenericClass<string, int, double>//必须指定全部确定的类型参数后可继承泛型
//:ISleep<W>错误的实现泛型接口，普通类不能直接实现泛型接口，
: ISleep<string>
{
public string Sleep(string t)
{
Console.WriteLine("实现了sleep泛型接口，返回参数是：{0}", t);
return t;
}
}
}
泛型类就在普通类名字后面加上<>和多个类型参数，需要注意的是 1.普通类不能直接继承泛型类和泛型接口，因为泛型的类型参数不确定，但是泛型类或泛型接口指定类型后可以继承泛型类或实现泛型接口，2.泛型类可以直接继承泛型类，也可以直接实现泛型接口,其子类的类型参数相当于声明了局部参数。
4.0泛型的约束(基类约束，接口约束，引用类型约束，值类型约束，无参构造函数约束)
回到上面写的那个GenericMethod类里的show方法，new 一个cat对象，Cat cat=new Cat(){ Id=1,Name="小黑猫"}; 然后调用genericMentod.show(cat)方法。但是如果想要在show方法里访问Id,或者Name却不行。T是个不明确类型参数，所以无法访问，如图
使用泛型约束解决方法：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace _20171010Generic
{
/// <summary>
/// 泛型约束
/// </summary>
public class Constraint
{ public static void Show<T>(T tParameter)
//where T: AnimalModel 基类约束，就可以访问该类的方法或属性
where T:Cat //或者该子类
{
Console.WriteLine("泛型约束show方法--------id={0},name={1}",tParameter.Id,tParameter.Name);
} public static void Show(AnimalModel model)
{
Console.WriteLine("普通show方法--------id={0},name={1}", model.Id, model.Name);
} public static void ShowInterface<T>(T tParameter)
//where T: AnimalModel 基类约束，就可以访问该类的方法或属性
where T : Cat,ISleep,IEat//或者该子类约束，多个接口约束 {
Console.WriteLine("泛型约束ShowInterface方法--------id={0},name={1}", tParameter.Id, tParameter.Name);
tParameter.Sleep();//接口的方法
tParameter.Eat();
}
}
Constraint类里的第一个show方法中在后面带个 where关键字 和 约束类型，泛型方法里就能访问Id和Name,第二个show方法是作为对比，虽然第二个方法也能实现同样的效果，但是相对泛型方法不灵活，泛型方法可以同时约束多个，比如第三个方法约束多个接口，和类，多个约束的关系是&&关系
泛型约束除了基类约束和接口约束几种，还有值类型约束，无参构造约束，引用类型约束等这几种。
基类约束:
1带来权利，可以使用基类里面的属性和方法。
2带来义务，类型参数必须是基类或者其子类。
public static T TestFun<T>()
// where T:class //引用类型约束
// where T:struct //值类型约束
where T : new() //无参构造函数约束
{
T t = new T();
return default(T);
}
5.0协变和逆变
out 协变(covariant) 修饰返回值，in 逆变(contravariant) 修饰传入参数。out和in只能放在接口或者泛型委托的的参数前面，类没有协变和逆变。在.NET Framework里面，IEnumerable<T>转到定义去看，其实就是个带out参数的泛型接口，Action<T>转到定义去看就是个带in参数的泛型委托。还有一个逆变+协变的Func<T>。
像平常一样写代码： AnimalModel animal = new AnimalModel();//实例化一个动物。
Dog dog = new Dog();//实例化一个条单身狗
AnimalModel dog2 = new Dog();//实例化一条单身狗（狗继承了动物父类，父类出现的地方都可以用子类代替，对的，狗一定是个动物），左边父类，右边子类。
// Dog dog3 = new AnimalModel();动物不一定是条单身狗，程序编译不通过
new一条单身狗没问题，new 一群单身狗试试看。
List<Dog> dogList = new List<Dog>();//实例化一群单身狗（编译通过）
List<AnimalModel> animalDog = new List<Dog>();//实例化一群单身狗（语法上不通过）
理论上来说第二种实例化一群狗的方式是没毛病的，一群狗也一定是一群动物，但是程序上是不通过是因为Listt<T>是个泛型 List<Dog>不是继承List<AnimalModel>，没有父子关系，程序只认关系。。。
PS:写到这里我就快写不下去了，狗快被我自己玩坏了。
要使上面那句代码编译通过，可以通过lambda表达式转化 List<AnimalModel> animalDog = new List<Dog>().Select(x => (AnimalModel)x).ToList();把每条狗都转换一遍
使用IEnumerable：IEnumerable<AnimalModel> animalDog= new List<Dog>(); //这就叫协变。IEnumerable<out T>在编译的时候就通过转化了，我个人理解为out 是表示转化后的T返回标识。平常在工作中，有用过out 关键字作为标识的返回参数，会用，但是不其所以然。原理明白后自己也可以定义一个协变的泛型接口。
public interface IMyTest<out T>
{ }
public class Test<T> : IMyTest<T>
{ } IMyTest<Animal> test3 = new Test<Dog>();
逆变就和协变相反。逆变的in 的参数只能作为传入值，不能作为返回值。说白了，也是一种约束。协变和逆变的关键作用就是让编译器在运行时不报错。
public interface IMyTest<inT>
{ }
public class Test<T> : IMyTest<T>
{ } IMyTest<Dog> test3 = new Test<Animal>();
为什么要用泛型：泛型就是为了满足不同类型，相同代码的重用
关于泛型的知识点还有很多，比如还有泛型的缓存，这个就有点难理解了。以上知识点是我平常通过各种途径学习总结的几点。如有不对欢迎指正。欢迎转载和分享，转载分享时请注明原创出处：如此拉风的女人