约束说明

定义泛型类时，可以对客户端代码能够在实例化类时用于类型参数的几种类型施加限制。 如果客户端代码尝试使用约束所不允许的类型来实例化类，则会产生编译时错误。 这些限制称为约束。 通过使用 where 上下文关键字指定约束。 下表列出了六种类型的约束：

使用约束的原因

如果要检查泛型列表中的某个项，确定它是否有效，或者将它与其他某个项进行比较，则编译器必须保证它需要调用的运算符或方法将受到客户端代码可能指定的任何类型参数的支持。 通过对泛型类定义应用一个或多个约束获得这种保证。 例如，基类约束告诉编译器，仅此类型的对象或派生自此类型的对象可用作类型参数。 编译器有了此保证后，就能够允许在泛型类中调用该类型的方法。 通过使用 where 上下文关键字应用约束。 以下代码示例演示可通过应用基类约束添加到（泛型介绍中的）GenericList<T>
类的功能。

public class Employee
{
    private string name;
    private int id;

    public Employee(string s, int i)
    {
        name = s;
        id = i;
    }

    public string Name
    {
        get { return name; }
        set { name = value; }
    }

    public int ID
    {
        get { return id; }
        set { id = value; }
    }
}

public class GenericList<T> where T : Employee
{
    private class Node
    {
        private Node next;
        private T data;

        public Node(T t)
        {
            next = null;
            data = t;
        }

        public Node Next
        {
            get { return next; }
            set { next = value; }
        }

        public T Data
        {
            get { return data; }
            set { data = value; }
        }
    }

    private Node head;

    public GenericList() //constructor
    {
        head = null;
    }

    public void AddHead(T t)
    {
        Node n = new Node(t);
        n.Next = head;
        head = n;
    }

    public IEnumerator<T> GetEnumerator()
    {
        Node current = head;

        while (current != null)
        {
            yield return current.Data;
            current = current.Next;
        }
    }

    public T FindFirstOccurrence(string s)
    {
        Node current = head;
        T t = null;

        while (current != null)
        {
            //The constraint enables access to the Name property.
            if (current.Data.Name == s)
            {
                t = current.Data;
                break;
            }
            else
            {
                current = current.Next;
            }
        }
        return t;
    }
}

约束使得泛型类能够使用 Employee.Name 属性，因为类型 T 的所有项都保证是 Employee 对象或是从 Employee 继承的对象。
可以对同一类型参数应用多个约束，并且约束自身可以是泛型类型，如下所示：

public static void OpTest<T>(T s, T t) where T : class
{
    System.Console.WriteLine(s == t);
}
static void Main()
{
    string s1 = "target";
    System.Text.StringBuilder sb = new System.Text.StringBuilder("target");
    string s2 = sb.ToString();
    OpTest<string>(s1, s2);
}

出现这种情况是因为，编译器在编译时仅知道 T 是引用类型，因此必须使用对所有引用类型都有效的默认运算符。 如果必须测试值相等性，建议的方法是同时应用where T : IComparable<T>约束，并在将用于构造泛型类的任何类中实现该接口。

约束多个参数

可以对多个参数应用多个约束，对一个参数应用多个约束，如下例所示：

class Base
{
}
class Test<T, U> where U : struct where T : Base, new()
{
}

未绑定的类型参数

没有约束的类型参数（如公共类 SampleClass<T>{} 中的 T）称为未绑定的类型参数。 未绑定的类型参数具有以下规则：

• 不能使用 != 和 == 运算符，因为无法保证具体的类型参数能支持这些运算符。
• 可以在它们与 System.Object 之间来回转换，或将它们显式转换为任何接口类型。
• 可以将它们与 null 进行比较。 将未绑定的参数与 null 进行比较时，如果类型参数为值类型，则该比较将始终返回 false。

类型参数作为约束

在具有自己类型参数的成员函数必须将该参数约束为包含类型的类型参数时，将泛型类型参数用作约束非常有用，如下例所示：

class List<T>
{ 
  void Add<U>(List<U> items) where U : T
  {
      /*...*/
  }
}

在上述示例中，T 在 Add 方法的上下文中是一个类型约束，而在 List 类的上下文中是一个未绑定的类型参。
类型参数还可在泛型类定义中用作约束。 请注意，必须在尖括号中声明此类型参数以及任何其他类型参数：

//Type parameter V is used as a type constraint. 
public class SampleClass<T, U, V> where T : V
 {
 }

类型参数作为泛型类的约束的作用非常有限，因为编译器除了假设类型参数派生自 System.Object 以外，不会做其他任何假设。 如果要在两个类型参数之间强制继承关系，可以将类型参数用作泛型类的约束。