Generic

1.什么是泛型

泛型（generic）特性提供了一种更优雅的方式，可以让多个类型共享一组代码，泛型允许声明类型参数化的代码，可以使用不同的类型进行实例化，在创建类的实例时指明真实类型。泛型类是类型的模板，关系如下图所示：

C#提供了5中泛型：类、结构、接口、委托和方法。前4种是类型，而方法是成员。下图演示了泛型类型如何用于其他类型。

泛型的简单实例如下所示：

class MyStack<T>
{
    int stackPointer = 0;
    T[] stactArray;
    public void Push(T x) {...} public T Pop() {...} } 

泛型的优点如下：

• 保证类型安全
• 减少装箱、拆箱操作，无需从object进行强制类型转换
• 多个类型共享一组代码，提高代码的复用性

命名规范：参数类型形参应包含T前缀。

---

2.构造器的定义

泛型类或结构的构造器不要求类型参数。

public struct Pair<T>
{
    public Pair(T first, T second)
    {
        First = first;
        Second = second; } public T First{ get; set; } public T Second { get; set; } } 

---

3.默认值的指定

public struct Pair<T>
{
    public Pair(T first) // struct需要初始化所有字段 { First = first; Second = default(T); // 不指定default报错 } public T First{ get; set; } public T Second { get; set; } } 

---

4.元组

通过元数的不同来重载类型定义：

public class Tuple {...}
public class Tuple<T1>: ... {...} public class Tuple<T1, T2>: ... {...} public class Tuple<T1, T2, T3>: ... {...} public class Tuple<T1, T2, T3, T4>: ... {...} public class Tuple<T1, T2, T3, T4, T5>: ... {...} public class Tuple<T1, T2, T3, T4, T5, T6>: ... {...} public class Tuple<T1, T2, T3, T4, T5, T6, T7>: ... {...} public class Tuple<T1, T2, T3, T4, T5, T6, T7, TRest>: ... {...} 

class Program
{
    static void Main(string[] args)
    {
        string outparam = ""; int returnvalue = FunOutParamDemo(out outparam); // 使用out拿到多个返回值 Console.WriteLine(returnvalue + " " + outparam); Tuple<int, string> r = FunTupleParamDemo(); // 使用元组拿到多个返回值 Console.WriteLine(r.Item1 + " " + r.Item2); Console.ReadKey(); } public static int FunOutParamDemo(out string o) { o = "returnValue"; return 10; } public static Tuple<int, string> FunTupleParamDemo() { return new Tuple<int, string>(10, "returnValue"); } } 

output

10    returnValue
10    returnValue

public static Tuple<int , int> MinMax(int a, int b) { return new Tuple<int, int>(Math.Min(a, b), Math.Max(a, b)); // Item1:Min, Item2:Max } Main: var r = MinMax(1, 2); Console.WriteLine($"min = {r.Item1}, max = {r.Item2}"); // 通过注释注明项 Item# 的意义 

output

min = 1, max = 2

其中TRest中可以存储另一个Tuple,由此Tuple可以无限大。

var t = Tuple.Create(0, 1, 2, 3, 4, 5, 6, Tuple.Create(7, 8)); Console.WriteLine($"{t.Item1}, {t.Item2}, {t.Item3}, {t.Item4}, {t.Item5}, " + $"{t.Item6}, {t.Item7}, {t.Rest.Item1.Item1}, {t.Rest.Item1.Item2}"); 

使用Tuple的Create()工厂方法:

// 用静态 Tuple 重写 MinMax()
public static Tuple<int , int> MinMax(int a, int b) { return Tuple.Create(Math.Min(a, b), Math.Max(a, b)); } 

Tuple<string, Contact> t1;
t1 = Tuple.Create("123456", new Contact("kyle")); Tuple<string, Contact> t2; t2 = new Tuple<string, Contact>("123456", new Contact("kyle")); 

class Program
{
    static void Main(string[] args)
    {
        Tuple<int> test1 = new Tuple<int>(34); Tuple<string, int> test2 = Tuple.Create("str", 2); Tuple<int, int> test3 = new Tuple<int, int>(2, 2); //8个元素的元组(注意，Tuple<类型...>： 基本"类型"最多7个， 第八个元素类型必须也为元组) Tuple<int, int, int, int, int, int, int, Tuple<int>> test4 = new Tuple<int, int, int, int, int, int, int, Tuple<int>>(1, 2, 3, 4, 5, 6, 7, new Tuple<int>(8)); Console.WriteLine(test1.Item1); Console.WriteLine(test2.Item1 + test2.Item2); Console.WriteLine(test4.Item1 + test4.Item2); Console.WriteLine(test4.Item1 + test4.Item2 + test4.Item3 + test4.Item4 + test4.Item5 + test4.Item6 + test4.Item7 + test4.Rest.Item1); Console.ReadKey(); } } 

output

34
str2
3
36

由此可见，使用Tuple的Create()工厂方法无需指定类型参数。

---

5.泛型类

创建和使用常规非泛型的类有两个步骤：声明类和创建类的实例。而对于泛型类需要先构建实际的类类型，然后才能创建实例。

• 在某些类型上使用占位符来声明一个类
• 为占位符提供真实类型，该类型称为构造类型
• 创建构造类型的实例

泛型类创建流程如下图所示：

---

5.1 声明泛型类

声明一个简单的泛型类和声明普通类差不多，区别如下：

• 在类名之后放一组尖括号
• 在尖括号中用逗号分隔的占位符字符串来表示提供的类型，这叫做类型参数
• 在泛型类声明的主体中使用类型参数来表示应该替代的类型

如下代码声明了一个叫做SomeClass的泛型类。

class SomeClass <T1, T2>
{
    public T1 someVar = new T1(); public T2 otherVar = new T2(); } 

在泛型类型申明中并没有特殊关键字，取而代之的是尖括号中的类型参数列表，它可以区分泛型类与普通类的声明。

---

5.2 创建构造类

一旦创建了泛型类型，就要告诉编译器使用哪些真实类型来替代占位符，替代类型参数的真实类型叫做类型实参。

class SomeClass<T1, T2> {...} // T1，T2是类型参数（开放类型，不可创建实例） SomeClass<short, int> // short，int是类型实参（封闭类型，可创建实例） 

5.3 静态成员

泛型类的静态成员只能在类的一个实例中共享,

public class StaticDemo<T>
{
    public static int x; } StaticDemo<string>.x = 4; StaticDemo<int>.x = 5; Console.WriteLine(StaticDemo<string>.x); 

output

4

---

5.4 创建变量和实例

如下代码所示非泛型类与泛型类创建对象：

MyNonGenClass myNGC = new MyNonGenClass(); // 非泛型类声明对象
SomeClass<short, int> mySc1 = new SomeClass<short, int>(); //泛型类声明对象 var mySc2 = SomeClass<short, int>(); // 匿名对象 

与非泛型类相同，声明和实例可以分开进行:

SomeClass<short, int> mySc1; // 声明
mySc1 = new SomeClass<short, int>(); //实例化 

非泛型类与泛型类直接的区别如下表所示。

	非泛型	泛型
源代码大小	更大：需要为每一种类型编写代码	更小：不管多少类型，只需一个是实现
可执行大小	所有类型的实现代码都会被编译	只会根据提供的类型实参具体实现
写的难易度	易于书写，因为它更具体	比较难写，因为它更抽象
维护的难易度	同一个修改，所有可用类型上都要实现	易于维护，只要修改一处

---

6.类型参数的约束

要让泛型变得更有用，需要提供额外的信息让编译器知晓可以接受哪些类型。
如下代码所示，编译器将会产生一个错误信息。

class Simple<T>
{
    static void bool LessThan(T i1, T i2) { return i1 < i2; // 错误 } } 

可以提供的额外信息叫做约束(constrain)，只有符合约束的类型才可以作为类型实参。

6.1 Where子句

约束使用Where子句列出。

• 每一个有约束的类型参数都有自己的where子句
• 如果类型参数有多个约束，则它们在where子句中使用逗号分隔

where子句的语法如下：

where TypeParam : constrain1, constrain2, ...

有关where子句的要点如下。

• 它们在类型参数列表的关闭尖括号后列出
• 它们不使用逗号或其他符号分隔
• 它们可以以任何次序列出
• where是上下文关键字，所以可以在其他上下文中使用

如下所示，其中T1未绑定，T2、T3具有约束。

class MyCalss <T1, T2, T3> where T2: Customer where T3: IComparable {...} 

6.2 约束类型和次序

共有5种类型的约束，如下表所示：

约束类型	描述
类名	只有这个类型的类或从它继承的类才能用作类型实参
class	任何引用类型，包括类、数组、委托和接口都可以用作类型实参
struct	任何值类型都可以用作类型实参
接口名	只有这个接口或者实现这个接口的类型才能用作类型实参
new()	任何带有无参公共构造函数的类型都可以用作类型实参，这叫做构造函数约束

where子句可以以任何次序列出，但where子句中的约束必须有特定的顺序

• 最多只有一个主约束，如果有则必须放在第一个
• 可以有任意多个接口名约束
• 如果存在构造函数约束，则必须放在最后

约束顺序如下所示：

Primary (0 or 1)	Secondary (0 or more)	Constructor (0 or 1)
ClassName class struct	InterfaceName	new()

---

7.泛型方法

与其他泛型不一样，方法是成员，不是类型。泛型方法可以在泛型类和非泛型类以及结构和接口中声明，如下图所示：

7.1 声明泛型方法

泛型方法具有类型参数列表和可选的约束。

• 泛型方法有两个参数列表
  • 封闭在原括号内的方法参数列表
  • 封闭在见括号内的类型参数列表
• 要声明泛型方法需要：
  • 在方法名称后和方法参数列表前放置类型参数列表
  • 在方法参数列表后放置可选的约束子句

public void PrintData<S, T> (S p, T t) where S: Person {...}

7.2 调用泛型方法

void Do<T1, T2>(T1 t1, T2 t2) { T1 someVar = t1; T2 otherVar = t2; } Do<int, double>(aVal, bVal); 

推断类型 编译器有时可以从方法参数中推断出赋给泛型方法的类型实参，

public void MyMethod<T>(T t){...}
int myInt = 5; MyMethod(myInt) // 由MyMethod<int>(myInt)简化 

但当泛型方法的方法参数列表为空时，则必须在类型参数列表中指明类型参数。

public void MyMethod<T>()
{
    Console.Write(typeof(T));
}
MyMethod<int>();

7.3泛型方法的实例

class Simple
{
    public static void ReverseAndPrint<T>(T[] arr)
    {
        Array.Reverse(arr);
        foreach (T item in arr) Console.Write(item.ToString() + " "); Console.WriteLine(); } } class Program { static void Main() { var intArray = new int[] { 3, 5, 7, 9, 11 }; var stringArray = new string[] { "first", "second", "third" }; var doubleArray = new double[] { 1.23, 2.34, 5.33 }; Simple.ReverseAndPrint<int>(intArray); Simple.ReverseAndPrint(intArray); Simple.ReverseAndPrint(stringArray); Simple.ReverseAndPrint(doubleArray); Console.ReadKey(); } } 

output:

11 9 7 5 3 3 5 7 9 11 third second first 5.33 2.34 1.23 

---

8.扩展方法和泛型类

泛型类的扩展方法需满足以下要求：

• 必须声明为static
• 必须是静态类的成员
• 第一个参数类型中必须有关键字this，后面是扩展的泛型类的名字

static class ExtendHolder
{
    public static void Print<T>(this Holder<T> h) { T[] vals = h.Getvalues(); Console.WriteLine($"{vals[0]}, {vals[1]}, {vals[2]}"); } } class Holder<T> { T[] vals = new T[3]; public Holder(T v0, T v1, T v2) { vals[0] = v0; vals[1] = v1; vals[2] = v2; } public T[] Getvalues() { return vals; } } class Program { static void Main() { var intHolder = new Holder<int>(3, 5, 7); var stringHolder = new Holder<string>("a1", "a2", "a3"); intHolder.Print(); stringHolder.Print(); Console.ReadKey(); } } 

output

3, 5, 7
a1, a2, a3

---

9.泛型结构

与泛型类相似，泛型结构可以有类型参数和约束，其规则与条件也与泛型类相同。

struct PieceOfdata<T>
{
    public PieceOfdata(T value) { data = value; } private T data; public T Data { get { return data; } set { data = value; } } } class Program { static void Main() { var intData = new PieceOfdata<int>(10); var stringData = new PieceOfdata<string>("hello"); Console.WriteLine($"intData = {intData.Data}"); Console.WriteLine($"stringdata = {stringData.Data}"); Console.ReadKey(); } } 

output

intData = 10
stringdata = hello

---

10.泛型委托

• 要声明泛型委托，在委托名称后、委托参数列表前的尖括号中放置类型参数列表
• 有两个参数列表：委托形参列表和类型参数列表
• 类型参数的范围包括：
  • 返回值
  • 形参列表
  • 约束子句

delegate void MyDelegate<T>(T value);
class Simple { static public void PrintString(string s) { Console.WriteLine(s); } static public void PrintUpperString(string s) { Console.WriteLine(s.ToUpper()); } } class Program { static void Main() { var myDel = new MyDelegate<string>(Simple.PrintString); myDel += Simple.PrintUpperString; myDel("hi there"); Console.ReadKey(); } } 

output

hi there
HI THERE

---

11.泛型接口

interface IMyIfc<T> // 泛型接口
{
    T ReturnIt(T inValue);
}
class Simple<S> : IMyIfc<S> // 泛型类 { public S ReturnIt(S inValue) // 实现泛型接口 { return inValue; } } class Program { static void Main() { Simple<int> trivInt = new Simple<int>(); Simple<string> trivString = new Simple<string>(); Console.WriteLine(trivInt.ReturnIt(5)); Console.WriteLine(trivString.ReturnIt("hello")); Console.ReadKey(); } } 

output

5
hello

11.1 使用泛型接口的示例

• 与其他泛型相似，实现不同类型参数的泛型接口是不同的接口
• 可以在非泛型类型中实现泛型接口

interface IMyIfc<T>
{
    T ReturnIt(T inValue);
}
class Simple: IMyIfc<int>, IMyIfc<string> { public int ReturnIt(int inValue) { return inValue; } public string ReturnIt(string inValue) { return inValue; } } class Program { static void Main() { Simple simple = new Simple(); Console.WriteLine(simple.ReturnIt(5)); Console.WriteLine(simple.ReturnIt("hello")); Console.ReadKey(); } } 

output

5
hello

11.2 泛型接口的实现必须唯一

实现泛型类接口时，必须保证类型实参组合不会在类型中产生两个重复的接口。

class Simple<S>: IMyIfc<int>, IMyIfc<S> //错误，存在潜在冲突 { public int ReturnIt(int inValue) { return inValue; } public S ReturnIt(S inValue) // 当S为int时产生冲突 { return inValue; } } 

泛型接口不会与非泛型接口产生冲突，

interface IMyIfc
{
    int ReturnIt(int inValue);
}
interface IMyIfc<T> { T ReturnIt(T inValue); } class Simple<S>: IMyIfc<S>, IMyIfc //无冲突 { public S ReturnIt(S inValue) { return inValue; } public int ReturnIt(int inValue) { return inValue + 10 ; } } class Program { static void Main() { Simple<double> simple1 = new Simple<double>(); // 调用泛型接口 Simple<int> simple2 = new Simple<int>(); // 调用非泛型接口 Console.WriteLine(simple1.ReturnIt(5.1)); Console.WriteLine(simple2.ReturnIt(5)); Console.ReadKey(); } } 

output

5.1
15

---

12.协变与逆变

在.NET中，参数类型是协变的，假定有Shape类和Rectangle类，Rectangle派生自Shape类。现声明Display()方法接受Shape类型的对象作为其参数

public void Display(Shape o) {...}

此时Display的参数可以传入派生自Shape基类的任意对象，

var r = new Rectangle( Width = 5, Length = 10 );
Display(r); 

方法的返回类型是逆变的。当方法返回一个Shape时，不能把它赋予Rectangle，因为Shape不一定是Rectangle，反之可行，

public Rectangle GetRectangle();
Shape s = GetRectangle();

若果要在泛型中实现协变与逆变，则需要out与in关键字标注。
如果泛型类型用out关键字标注，泛型委托（接口）就是协变的，这也意味着返回类型只能是T。

public delegate T Dele<out T>();
public interface IMyIfc<out T>

如果泛型类型用in关键字标注，泛型委托（接口）就是逆变的，委托（接口）只能把泛型类型T用作其方法的输入。

public delegate T Dele<in T>();
public interface IMyIfc<in T>

协变与逆变的不同如下图所示：

12.1 委托的协变与逆变

将派生类的对象实例赋值给基类的变量，叫做赋值兼容性。

class Animal
{
    public int numberOfLegs = 4; } class Dog: Animal { } class Program { static void Main() { Animal a1 = new Animal(); Animal a2 = new Dog(); // 将派生类对象实例赋给基类变量 Console.WriteLine($"number of animal legs: {a1.numberOfLegs}"); Console.WriteLine($"number of dog legs: {a2.numberOfLegs}"); Console.ReadKey(); } } 

output

number of animal legs: 4
number of dog legs: 4 

下面对代码进行扩展，添加一个委托，

class Animal
{
    public int numberOfLegs = 4; } class Dog: Animal { } delegate T Factory<T>(); class Program { static Dog MakeDog() { return new Dog(); } static void Main() { Factory<Dog> dog = MakeDog; // 创建委托对象 Factory<Animal> animal = dog; // 尝试赋值委托对象 Console.WriteLine(animal().numberOfLegs); Console.ReadKey(); } } 

以上使用委托赋值失败，是因为Factory<Dog>与Factory<Animal>都派生自delegate类，两个委托对象是同级关系。
如果派生类只是用于输出值，那么这种结构化的委托有效性之间的常数关系叫做协变，使用关键字out指定类型参数的协变。

delegate T Factory<out T>();

在期望传入基类时允许传入派生对象的特性叫做逆变，可以在类型参数中显式使用in关键字来实现。

delegate T Factory<in T>();

12.2 接口的协变与逆变

class Animal { public string Name; }
class Dog : Animal { } interface IMyIfc<out T> { T GetFirst(); } class SimpleReturn<T> : IMyIfc<T> { public T[] items = new T[2]; public T GetFirst() { return items[0]; } } class Program { static void Do(IMyIfc<Animal> returner) { Console.WriteLine(returner.GetFirst().Name); } static void Main() { SimpleReturn<Dog> dogReturner = new SimpleReturn<Dog>(); dogReturner.items[0] = new Dog() { Name = "Bob" }; IMyIfc<Animal> animalReturner = dogReturner; Do(dogReturner); Console.ReadKey(); } } 

output

Bob