C#泛型约束

た入场券 2021-06-26 16:06 505阅读 0赞

六种类型的约束：

<table> 
 <thead> 
  <tr> 
   <th align="left">格式</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">T：结构</td> 
   <td align="left">类型参数必须是值类型。可以指定除 Nullable 以外的任何值类型。有关更多信息，请参见使用可空类型（C# 编程指南）。</td> 
  </tr> 
  <tr> 
   <td align="left">T：类</td> 
   <td align="left">类型参数必须是引用类型，包括任何类、接口、委托或数组类型。</td> 
  </tr> 
  <tr> 
   <td align="left">T：new()</td> 
   <td align="left">类型参数必须具有无参数的公共构造函数。当与其他约束一起使用时，new() 约束必须最后指定。</td> 
  </tr> 
  <tr> 
   <td align="left">T：&lt;基类名&gt;</td> 
   <td align="left">类型参数必须是指定的基类或派生自指定的基类。</td> 
  </tr> 
  <tr> 
   <td align="left">T：&lt;接口名称&gt;</td> 
   <td align="left">类型参数必须是指定的接口或实现指定的接口。可以指定多个接口约束。约束接口也可以是泛型的。</td> 
  </tr> 
  <tr> 
   <td align="left">T：U</td> 
   <td align="left">为 T 提供的类型参数必须是为 U 提供的参数或派生自为 U 提供的参数。这称为裸类型约束。</td> 
  </tr> 
 </tbody> 
</table>

例子：

## 1.接口约束。 ##

例如，可以声明一个泛型类 `MyGenericClass`，这样，类型参数 `T` 就可以实现 `IComparable<T>` 接口：

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

## 2.基类约束。 ##

指出某个类型必须将指定的类作为基类（或者就是该类本身），才能用作该泛型类型的类型参数。这样的约束一经使用，就必须出现在该类型参数的所有其他约束之前。

class MyClassy<T, U>
    where T : class
    where U : struct
    {
    }

## 3.构造函数约束。 ##

以使用 `new` 运算符创建类型参数的实例；但类型参数为此必须受构造函数约束`new()` 的约束。`new()` 约束可以让编译器知道：提供的任何类型参数都必须具有可访问的无参数（或默认）构造函数。`new()` 约束出现在 `where` 子句的最后。

public class MyGenericClass <T> where T: IComparable, new()
    {
    // The following line is not possible without new() constraint:
             T item = new T();
    }

**4.对于多个类型参数，每个类型参数都使用一个 `where` 子句。**

interface MyI { }
    class Dictionary<TKey,TVal>
    where TKey: IComparable, IEnumerable
    where TVal: MyI
    {
    public void Add(TKey key, TVal val)
    {
    }
    }

**5.还可以将约束附加到泛型方法的类型参数。**

public bool MyMethod<T>(T t) where T : IMyInterface { }

## 6. 裸类型约束 ##

用作约束的泛型类型参数称为裸类型约束。当具有自己的类型参数的成员函数需要将该参数约束为包含类型的类型参数时，裸类型约束很有用。

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

泛型类的裸类型约束的作用非常有限，因为编译器除了假设某个裸类型约束派生自 `System.Object` 以外，不会做其他任何假设。在希望强制两个类型参数之间的继承关系的情况下，可对泛型类使用裸类型约束。

## 7.`default`关键字 ##

之所以会用到`default`关键字，是因为需要在不知道类型参数为值类型还是引用类型的情况下，为对象实例赋初值。考虑以下代码：

class TestDefault<T>
        {
            public T foo()
            {
                T t = null; //???
                return t;
            }
        }

如果我们用`int`型来绑定泛型参数，那么`T`就是`int`型，那么注释的那一行就变成了 `int t = null；`显然这是无意义的。为了解决这一问题，引入了`default`关键字：

class TestDefault<T>
        {
            public T foo()
            {
                    return default(T);
            }
        }