C#基础提升系列——C# 泛型

泛型是C#编程语言的一部分，它与程序集中的IL(Intermediate Language，中间语言)代码紧密的集成。通过泛型，我们不必给不同的类型编写功能相同的许多方法和类，而是可以创建独立于被包含类型的一个类或方法。 例如，通过使用泛型类型参数 T，可以编写其他客户端代码能够使用的单个类，而不会产生运行时转换或装箱操作的成本或风险。使用泛型类型可以最大限度地重用代码、保护类型安全性以及提高性能。

泛型的一个主要优点是性能。值类型存储在栈上，引用类型存储在堆上。从值类型转换为引用类型称为装箱；从引用类型转换为值类型称为拆箱。对值类型使用非泛型集合类，常常需要将值类型和引用类型互相转换，进行装箱和拆箱操作，性能损失比较大。而使用了泛型，可以很好的解决这一问题，泛型可以不再进行装箱和拆箱操作。

泛型的另一个特性是类型安全。例如，在泛型类List中，泛型类型T定义了允许使用的类型。假设有一个泛型实例为List，它在添加元素时，就只会添加类型为int的数值到集合中。

泛型允许更好的重用二进制代码，泛型类可以定义一次，使用许多不同的类型实例化。例如，泛型类List可以实例化为List、List、List等。

泛型类的定义会放在程序集 中，所以用特定类型实例化泛型类不会在中间语言（IL）代码中复制这些类。但是，在JIT编译器把泛型类编译为本地代码时，会给每个值类型创建一个新类。而引用类型共享同一个本地类的所有相同的实现代码。这是因为引用类型在实例化泛型类中只需要4个字节的内存地址（32位系统），就可以引用一个引用类型。值类型包含在实例化的泛型类的内存中，同时因为每个值类型对内存的要求都不同，所以要为每个值类型实例化一个新类。

注：【本段文字来自于《C#高级编程（第10版）》中的”不同的特定类型实例化泛型时创建了多少代码“相关描述】

• 泛型类型的名称用字母T作为前缀。
• 如果没有特殊的要求，泛型类型允许用任意类替代，且只使用了一个泛型类型，就可以用字符T作为泛型类型的名称。例如：public class List{}
• 如果泛型类型有特定的要求（例如，它必须实现一个接口或派生自基类），或者使用了两个或多个泛型类型，就应给泛型类型使用描述性的 名称。例如：public class SortedList{}

泛型类型：也被称为泛型类型参数，它是在实例化泛型类的一个变量时，泛型声明中指定的特定类型的占位符，即泛型类中指定的T。

泛型类：定义泛型类型的类，例如List，它无法按原样使用，因为它不是真正的类型；它更像是类型的蓝图。 若要使用 List，客户端代码必须通过指定尖括号内的类型参数来声明并实例化构造类型。

通常，创建泛型类是从现有具体类开始，然后每次逐个将类型更改为类型参数，直到泛化和可用性达到最佳平衡。 在创建泛型类之前，先建立一个简单的普通类，然后再把这个类转化为泛型类。

定义一个一般的、非泛型的简化链表类：

public class linkedListNode
{
    public object Value { get; private set; }
    public linkedListNode(object value)
    {
 Value = value;
    }
    public linkedListNode Prev { get; internal set; }
    public linkedListNode Next { get; internal set; }
}
public class linkedList : IEnumerable
{
    public linkedListNode First { get; private set; }
    public linkedListNode Last { get; private set; }

    //在链表尾部添加一个新元素
    public linkedListNode AddLast(object node)
    {
 var newNode = new linkedListNode(node);
 if (First == null)
 {
     First = newNode;
     Last = First;
 }
 else
 {
     linkedListNode previous = Last;
     Last.Next = newNode;
     Last = newNode;
     Last.Prev = previous;
 }
 return newNode;
    }

    //实现GetEnumerator()方法
    public IEnumerator GetEnumerator()
    {
 linkedListNode current = First;
 while (current != null)
 {
     //使用yield语句创建一个枚举器类型
     yield return current.Value;
     current = current.Next;
 }
    }
}

当调用上述linkedList类的AddLast()方法传入任意类型的值时，会进行一系列的装箱和拆箱的操作

var list1 = new linkedList();
list1.AddLast(2);
list1.AddLast(3);
list1.AddLast("4");
foreach (var i in list1)
{
    Console.WriteLine(i);
}

使用泛型定义上述类

public class linkedListNode
{
    public linkedListNode(T value)
    {
 Value = value;
    }

    public linkedListNode Next { get; internal set; }
    public linkedListNode Prev { get; internal set; }
    public T Value { get; private set; }
}

public class linkedList : IEnumerable
{
    public linkedListNode First { get; private set; }
    public linkedListNode Last { get; private set; }

    public linkedListNode AddLast(T node)
    {
 var newNode = new linkedListNode(node);
 if (First == null)
 {
     First = newNode;
     Last = First;
 }
 else
 {
     linkedListNode previous = Last;
     Last.Next = newNode;
     Last = newNode;
     Last.Prev = previous;
 }
 return newNode;
    }

    public IEnumerator GetEnumerator()
    {
 linkedListNode current = First;
 while (current != null)
 {
     yield return current.Value;
     current = current.Next;
 }
    }

    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

泛型类的定义与一般类类似，只是要使用泛型类型声明。声明后的泛型类型可以在类中用作方法或字段成员的参数类型。

调用上述中声明的方法用例如下，此时添加元素和遍历元素时都不用频繁的装箱和拆箱：

var list2 = new linkedList();
list2.AddLast("java");
list2.AddLast("c#");
list2.AddLast("python");
foreach (string i in list2)
{
    Console.WriteLine(i);
}

在创建泛型类时，可以为泛型类型指定默认值、约束、继承和静态成员等。

创建如下一个简单泛型类 ，用于从队列中读写文档。

public class documentManager
{
    private readonly Queue documentQueue = new Queue();

    public bool IsdocumentAvailable => documentQueue.Count > 0;

    public void Adddocument(T doc)
    {
 lock (this)
 {
     documentQueue.Enqueue(doc);
 }
    }
}
//定义一个简单的接口
public interface Idocument
{
    string Title { get; set; }
    string Content { get; set; }
}
//实现该接口
public class document : Idocument
{
    public document(string title, string content)
    {
 this.Title = title;
 this.Content = content;
    }
    public string Content { get; set; }
    public string Title { get; set; }
}

泛型类型默认值

在上述类documentManager中添加如下方法：

public T Getdocument()
{
    //default将泛型类型的值初始化为null或者0，取决于泛型类型是引用类型还是值类型。
    T doc = default(T);
    lock (this)
    {
 doc = documentQueue.Dequeue();
    }
    return doc;
}

该方法直接返回类型T的值，由于不能把null赋予泛型类型，原因是泛型类型可以实例化为值类型，而null只能用于引用类型，因此为了解决这个问题，使用了default关键字来代替T doc=null; 通过default关键字，可以自动的将null赋予引用类型，将0赋予值类型，而不用管T具体是哪种类型。

泛型类型约束

如果泛型类（定义泛型类型的类，如documentManager）需要调用泛型类型（T）中的方法，就必须添加约束。

例如，在泛型类documentManager中添加DisplayAlldocuments()方法用于显示泛型类型T对应的Title值，需要强制进行类型转换，如下：

public void DisplayAlldocuments()
{
    foreach (T doc in documentQueue)
    {
 Console.WriteLine(((Idocument)doc).Title);
    }
}

一旦类型T没有实现Idocument接口，上述类型转换就会存在错误，此时最好的做法就是为泛型类添加一个约束：T必须实现Idocument接口。

public class documentManager where Tdocument : Idocument
{
    private readonly Queue documentQueue = new Queue();

    public bool IsdocumentAvailable => documentQueue.Count > 0;

    public void Adddocument(Tdocument doc)
    {
 lock (this)
 {
     documentQueue.Enqueue(doc);
 }
    }

    public Tdocument Getdocument()
    {
 //default将泛型类型的值初始化为null或者0，取决于泛型类型是引用类型还是值类型。
 Tdocument doc = default(Tdocument);
 lock (this)
 {
     doc = documentQueue.Dequeue();
 }
 return doc;
    }
    public void DisplayAlldocuments()
    {
 foreach (Tdocument doc in documentQueue)
 {
     Console.WriteLine(doc.Title);
 }
    }
}

注意：给泛型类型 添加约束时，最好包含泛型参数名称的一些信息，此示例使用Tdocument来代替T。调用上述代码如下：

var dm = new documentManager();
dm.Adddocument(new document("title A", "sample A"));
dm.Adddocument(new document("title B", "sample B"));
dm.DisplayAlldocuments();
if (dm.IsdocumentAvailable)
{
    document d = dm.Getdocument();
    Console.WriteLine(d.Content);
}

泛型类型支持的约束类型

某些约束是互斥的。 所有值类型必须具有可访问的无参数构造函数。 struct 约束包含 new() 约束，且 new() 约束不能与 struct 约束结合使用。 unmanaged 约束包含 struct 约束。 unmanaged 约束不能与 struct 或 new() 约束结合使用。

从 C# 7.3 开始，可使用 unmanaged 约束来指定类型参数必须为“非托管类型”。 “非托管类型”不是引用类型，且任何嵌套级别都不包含引用类型字段。

注意：只能为默认构造函数定义构造函数约束，不能为其他构造函数定义构造函数约束。

使用泛型类型可以合并多个约束：

  public class MyClass
 where T : IFoo, new(){    }

上述声明表示类型T必须实现IFoo接口，且必须有一个默认构造函数。

注意：在C#中，where子句不能定义必须由泛型类型实现的运算符。运算符不能在接口中定义。在where子句中，只能定义基类、接口、和默认构造函数。

泛型类型继承

泛型类型可以实现泛型接口，也可以派生自一个泛型基类，其要求是必须重复基类的泛型类型，或者必须指定基类的类型。

public class base { }
public class Derived : base { }
public class Derived_2 : base { }

派生类（子类）可以是泛型类或非泛型类，例如，可以定义一个抽象的泛型基类，它在派生类中用一个具体的类实现：

public abstract class Calc
{
    public abstract T Add(T x, T y);
    public abstract T Sub(T x, T y);
}

public class IntCalc : Calc
{
    public override int Add(int x, int y) => x + y;
    public override int Sub(int x, int y) => x - y;
}

还可以创建一个部分的特殊操作，如下：

public class Query { }
public class StringQuery : Query { }

上述中StringQuery继承自Query，只定义了一个泛型参数，为基类的TResult指定为string，要实例化StringQuery，只需要提供TRequest的类型。

泛型静态成员

应该减少泛型静态成员的使用，泛型类的静态成员只能在对应的同一个类实例中共享。

public class StaticDemo
{
    public static T x; //此处变量x为T类型
    public static int y;
    //泛型静态成员调用
    StaticDemo.x = "abc";
    StaticDemo.x = 13;
    StaticDemo.y = 2;
    StaticDemo.y = 10;

    Console.WriteLine(StaticDemo.x); //结果：abc
    Console.WriteLine(StaticDemo.x);    //结果：13
    Console.WriteLine(StaticDemo.y); //结果：2
    Console.WriteLine(StaticDemo.y);    //结果：10
}

使用泛型可以定义接口，在接口中定义的方法可以带泛型参数。.NET提供了许多泛型接口，同一个接口常常存在比较老的非泛型版本，建议在实际使用中，优先采用泛型版本去解决问题。

为了更好的解释协变和逆变的概念，我们使用List、IList、IEnumerable三者做一个简单的测验。首先我们定义一个List 实例变量listA，并将listA的值指向IList的变量iListA，同时分别使用IEnumerable去引用这两个变量。

List listA = new List();
IList iListA = listA;
IEnumerable iEnumerableA = listA;
IEnumerable iEnumerableB = iListA;

此时代码不会产生错误，能够正常编译。因为List派生自IList和IEnumerable，IList派生自IEnumerable，父类引用指向子类对象，所以代码可以通过编译。

注意：IEnumerable实际上是一个变体，查看定义的源码如下：

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

特别需要注意的是泛型类型T前面的out关键字，它代表的就是协变。它的作用是什么？

C#中的string派生自Object类型，假设我们也想通过object的集合直接去引用string的List，类似于如下代码：

List