C# 泛型

什么是泛型？

泛型就是通过参数化类型来实现在同一份代码上操作多种数据类型。泛型编程是一种编程范式，它利用“参数化类型”将类型抽象化，从而实现更为灵活的复用。

.NET 泛型编程包括：泛型类、泛型方法、泛型委托、泛型约束。

这里只简单说下泛型类、泛型方法、泛型约束，大致相近，不同的只是不同的实现与编程方式

一、泛型约束

如果代码尝试使用某个约束所不允许的类型来实例化类，则会产生编译时错误。这些限制称为约束。

约束是使用 where 上下文关键字指定的。

基本约束

约束	说明
T：struct	类型参数必须是值类型。可以指定除 Nullable 以外的任何值类型。
T：class	类型参数必须是引用类型，包括任何类、接口、委托或数组类型。
T：new()	类型参数必须具有无参数的公共构造函数。当与其他约束一起使用时，new() 约束必须最后指定。
T：<基类名>	类型参数必须是指定的基类或派生自指定的基类。
T：<接口名称>	类型参数必须是指定的接口或实现指定的接口。可以指定多个接口约束。约束接口也可以是泛型的。
T：U	为 T 提供的类型参数必须是为 U 提供的参数或派生自为 U 提供的参数。这称为裸类型约束.

派生约束

1. 常见的

public class MyClass5<T> where T :IComparable { }

2. 约束放在类的实际派生之后

public class B { }
public class MyClass6<T> : B where T : IComparable { }

3. 可以继承一个基类和多个接口，且基类在接口前面

public class B { }
public class MyClass7<T> where T : B, IComparable, ICloneable { }

构造函数约束

1. 常见的

public class MyClass8<T> where T :  new() { }

2. 可以将构造函数约束和派生约束组合起来,前提是构造函数约束出现在约束列表的最后

public class MyClass8<T> where T : IComparable, new() { }

值约束

1. 常见的

public class MyClass9<T> where T : struct { }

2. 与接口约束同时使用，在最前面(不能与基类约束,构造函数约束一起使用)

public class MyClass11<T> where T : struct, IComparable { }

引用约束

1. 常见的

public class MyClass10<T> where T : class { }

多个泛型参数

public class MyClass12<T, U> where T : IComparable  where U : class { }

多个约束条件

public class MyClass12<T> where T : class ,new()

二、泛型方法

泛型方法定义

泛型方法可以定义特定于其执行范围的泛型参数：如下所示

public class MyClass<T>
{
    //指定MyMethod方法用以执行类型为X的参数
    public void MyMethod<X>(X x) 
    {
        //
    }
    //此方法也可不指定方法参数
    public void MyMethod<X>() 
    {
        //
    }
}

即使包含类不适用泛型参数，也可以定义方法特定的泛型参数，如下所示：

public class MyClass
{
    //指定MyMethod方法用以执行类型为X的参数
    public void MyMethod<X>(X x) 
    {
        //
    }
    //此方法也可不指定方法参数
    public void MyMethod<X>() 
    {
        //
    }
}

注意：属性和索引器不能指定自己的泛型参数，它们只能使用所属类中定义的泛型参数进行操作。

调用泛型方法：

MyClass myClass = new MyClass();
myClass.MyMethod<int>(3);

泛型推理：

在调用泛型方法时，C#编译器足够聪明，基于传入的参数类型来推断出正确的类型，并且它允许完全省略类型规范，如下所示：

//泛型推理机制调用泛型方法
MyClass myClass = new MyClass();
myClass.MyMethod(3);

注意：泛型方法无法只根据返回值的类型推断出类型，代码如下：

public GenericMethodDemo()
{        
    MyClass myClass = new MyClass();
    /****************************************************
    无法从用法中推理出方法“GenericMethodDemo.MyClass.MyMethod()”的类型参数。
    请尝试显式指定类型参数。
    ***************************************************/
    int number = myClass.MyMethod();
}
public class MyClass
{
    public T MyMethod<T>() 
    {
        //
    }
}

三、泛型类

上述代码中，已经简单用到过泛型类，下面将讲下泛型类中需要注意的地方

1.无法为类级别的泛型参数提供方法级别的约束

类级别泛型参数的所有约束都必须在类作用范围中定义，代码如下所示

//这是错误的！
public class MyClass<T>
{
    public void MyMethod<X>(X x,T t) where X:IComparable<X> where T:IComparer<T>
    {
        //
    }
}

正确的方式如下：

public class MyClass<T> where T:IComparable<T>
{
    public void MyMethod<X>(X x,T t) where X:IComparable<X> 
    {
        //
    }
}

2.泛型参数虚方法的重写

子类方法必须重新定义该方法特定的泛型参数 ,代码如下：

public class MyBaseClass
{
    public virtual void SomeMethod<T>(T t)
    {
        //
    }
}
public class MyClass :MyBaseClass
{
    public override void SomeMethod<X>(X x)
    {
       // 
    }
}

3.子类中的泛型方法不能重复基类泛型方法的约束

这一点和泛型类中的虚方法重写是有区别的，代码如下:

public class MyBaseClass
{
    public virtual void SomeMethod<T>(T t) where T:new()
    {
        //
    }
}
public class MyClass :MyBaseClass
{
    //正确写法
    public override void SomeMethod<X>(X x)
    {
        //
    }
    ////错误 重写和显式接口实现方法的约束是从基方法继承的，因此不能直接指定这些约束
    //public override void SomeMethod(X x) where X:new()
    //{
		//
    //}
}

4.子类方法调用虚拟方法的基类实现

public class MyBaseClass
{
    public virtual void SomeMethod<T>(T t) where T:new()
    {
        //
    }
}
public class MyClass :MyBaseClass
{
    //正确写法
    public override void SomeMethod<X>(X x)
    {
        base.SomeMethod<X>(x);
        base.SomeMethod(x);
    }
}

---

参考博客：

• C# 泛型编程之泛型类、泛型方法、泛型约束