C# 泛型，泛型约束，泛型接口

C#泛型

    泛型（使用System.Collections.Generic命名空间）是C#语言2.0和通用语言运行时（CLR）的一个新特性。泛型为.NET框架引入了类型参数（type parameters：不必确定一个或多个具体参数，属于同一类即可。这就把类型不同的隐患消灭在编译阶段——如果类型不对，则编译错误。）的概念。泛型的产生其中一个原因就是为了解决原来集合类中元素的装箱和拆箱问题，泛型不仅能用来做容器，还能够提供代码复用的手段。如List<T>。在泛型类型或泛型方法的定义中，类型参数是一个占位符（placeholder），通常为一个大写字母，如T。在代码声明、实例化该类型的变量时，把T替换为指定的数据类型。或者使用泛型的约束条件。

C#泛型的约束条件

    C#的泛型采用“基类、接口、构造器，值类型/引用类型”的约束方式来实现对类型参数的“显示约束”,利用“参数化类型”将类型抽象化，能够参数化的类型越多，代码就会变得越灵活，重用性就越好。通过避免装箱和拆箱操作来达到性能提升的目的.如果存在约束，应对类型参数应用什么约束。一个有用的规则是，应用尽可能最多的约束，但仍使您能够处理需要处理的类型。例如，如果您知道您的泛型类仅用于引用类型，则应用类约束。这可以防止您的类被意外地用于值类型，并允许您对 T 使用 as 运算符以及检查空值。 是否将泛型行为分解为基类和子类。由于泛型类可以作为基类使用，此处适用的设计注意事项与非泛型类相同。有关从泛型基类继承的规则，请参见下面的内容。是否实现一个或多个泛型接口。C#的泛型类型可以应用于强大的反射技术。C#除了可以单独声明泛型类型（包括类与结构）外，也可以在基类中包含泛型类型的声明。但基类如果是泛型类，它的类型要么以实例化，要么来源于子类（同样是泛型类型）声明的类型参数，看如下类型
class C<U,V>
class D:C<string,int>
class E<U,V>:C<U,V>
class F<U,V>:C<string,int>
class G:C<U,V>  //非法
E类型为C类型提供了U、V，也就是上面说的来源于子类
F类型继承于C<string,int>，个人认为可以看成F继承一个非泛型的类
G类型为非法的，因为G类型不是泛型，C是泛型，G无法给C提供泛型的实例化
六种类型的约束：
◆T：结构
类型参数必须是值类型。可以指定除 Nullable 以外的任何值类型。
◆T：类
类型参数必须是引用类型，包括任何类、接口、委托或数组类型。
◆T：new()
类型参数必须具有无参数的公共构造函数。当与其他约束一起使用时，new() 约束必须最后指定。
◆T：<基类名>
类型参数必须是指定的基类或派生自指定的基类。
◆T：<接口名称>
类型参数必须是指定的接口或实现指定的接口。可以指定多个接口约束。约束接口也可以是泛型的。
◆T：U

为 T 提供的类型参数必须是为 U 提供的参数或派生自为 U 提供的参数。这称为裸类型约束。

注：类：修饰符(使用abstract关键字的类是抽象类，这种类不能被实例化，只能被继承；而使用sealed关键字的类是封装类，这种类只能实例化，
不能继)用“：”来继承基类和接口，最多可同时继承一个基类以及很多接口，它们之间需要用“，”隔开。

        析构函数主要用于清理对象classMyClass  {  ~MyClass()  {}} 

        构造函数的执行序列，在实例化一个派生类时，必须先实例化这个派生类的基类，也就要先实例化这个基类的基类，以此类推，就要先实例化object类。base关键字指定.net实例化过程使用基类中匹配指定签名的构造函数。
       说明：as属于运算符，用于在兼容的引用类型之间执行类型转换，类似于强制转换，只是强制转换失败时会引发异常，而as运算符将返回空值，不会引发异常。

        接口：由于接口不包含执行代码，所以也就没有抽象接口的概念，所以在声明接口是一般使用public 和internal，不能使用abstract和sealed。

可将多重接口指定为单个类型上的约束，接口可以如同对象一样被当做参数，返回值使用。如下所示：

C# 泛型接口

C# 泛型接口代码
class Stack﹤T﹥ where T : System.IComparable﹤T﹥, IEnumerable﹤T﹥  
{  
} 
一个接口可定义多个类型参数：
interface IDictionary﹤K, V﹥  
{  
} 
类之间的继承规则同样适用于接口：
interface IMonth﹤T﹥ { }   
interface IJanuary : IMonth﹤int﹥ { }  //No error  
interface IFebruary﹤T﹥ : IMonth﹤int﹥ { }  //No error  
interface IMarch﹤T﹥: IMonth﹤T﹥ { }//No error  
//interface IApril﹤T﹥  : IMonth﹤T, U﹥ {}  //Error
如果泛型接口为逆变的，即仅使用其类型参数作为返回值，则此泛型接口可以从非泛型接口继承。在 .NET Framework 类库中，IEnumerable﹤T


﹥ 从 IEnumerable 继承，因为 IEnumerable﹤T﹥ 仅在 GetEnumerator 的返回值和当前属性 getter 中使用 T。


具体类可以实现已关闭的构造接口，如下所示：


C# 泛型接口代码


interface IBaseInterface﹤T﹥ { }  
 
class SampleClass : IBaseInterface﹤string﹥ { }
泛型类的对象也可以采用强制类型转换转换成另外的泛型类型，不过只有当两者在各个方面兼容时才能这么做。C# 编译器只允许将一般类型


参数隐式强制转换到 Object 或约束指定的类型
一般类型参数的隐式强制类型转换


interface ISomeInterface  
{...}  
class BaseClass  
{...}  
class MyClass where T : BaseClass,ISomeInterface  
{  
   void SomeMethod(T t)  
   {  
      ISomeInterface obj1 = t;  
      BaseClass      obj2 = t;  
      object         obj3 = t;  
   }  
} 
编译器允许您将一般类型参数显式强制转换到其他任何接口，但不能将其转换到类：


interface ISomeInterface  
{...}  
class SomeClass  
{...}  
class MyClass   
{  
   void SomeMethod(T t)  
   {  
      ISomeInterface obj1 = (ISomeInterface)t;//Compiles  
      SomeClass      obj2 = (SomeClass)t;     //Does not compile  
   }  
} 
但是，您可以使用临时的 Object 变量，将一般类型参数强制转换到其他任何类型：


class SomeClass  
{...}  
 
class MyClass   
{  
     
   void SomeMethod(T t)  
     
   {  
      object temp = t;  
      SomeClass obj = (SomeClass)temp;  
     
   }  
} 
不用说，这样的显式强制类型转换是危险的，因为如果为取代一般类型参数而使用的类型实参不是派生自您要显式强制转换到的类型，则可


能在运行时引发异常。要想不冒引发强制类型转换异常的危险，一种更好的办法是使用 is 和 as 运算符，如代码块 6 所示。如果一般类型参数


的类型是所查询的类型，则 is 运算符返回 true；如果这些类型兼容，则 as 将执行强制类型转换，否则将返回 null。您可以对一般类型参数以


及带有特定类型实参的一般类使用 is 和 as。
对一般类型参数使用“is”和“as”运算符


public class MyClass   
{  
   public void SomeMethod(T t)  
   {  
      if(t is int)  
      {...}   
 
      if(t is LinkedList)  
      {...}  
 
      string str = t as string;  
      if(str != null)  
      {...}  
 
      LinkedList list = t as LinkedList;  
      if(list != null)  
      {...}  
   }  
} 

不论是为泛型容器类，还是表示容器中元素的泛型类，定义接口是很有用的。把泛型接口与泛型类结合使用是更好的用法，比如用IComparable<T>而非IComparable，以避免值类型上的装箱和拆箱操作。.NET框架2.0类库定义了几个新的泛型接口，以配合System.Collections.Generic中新容器类的使用。
 
    当一个接口被指定为类型参数的约束时，只有实现该接口的类型可被用作类型参数。下面的示例代码显示了一个从MyList<T>派生的SortedList<T>类。更多信息，请参见泛型概述。SortedList<T>增加了约束where T : IComparable<T>。
这使得SortedList<T>中的BubbleSort方法可以使用表中的元素的IComparable<T>.CompareTo方法。在这个例子中，表中的元素是简单类——实现IComparable<Person>的Person类。
 
using System;
using System.Collections.Generic;
 
//Type parameter T in angle brackets.
public class MyList<T>
{
    protected Node head;
    protected Node current = null;
 
// Nested type is also generic on T
    protected class Node         
    {
        public Node next;
//T as private member datatype.
        private T data;         
//T used in non-generic constructor.
        public Node(T t)        
        {
            next = null;
            data = t;
        }
        public Node Next
        {
            get { return next; }
            set { next = value; }
        }
//T as return type of property.
        public T Data           
        {
            get { return data; }
            set { data = value; }
        }
    }
    public MyList()
    {
        head = null;
    }
//T as method parameter type.
    public void AddHead(T t)    
    {
        Node n = new Node(t);
        n.Next = head;
        head = n;   
    }
    // Implement IEnumerator<T> to enable foreach
    // iteration of our list. Note that in C# 2.0
    // you are not required to implment Current and
    // GetNext. The compiler does that for you.
    public IEnumerator<T> GetEnumerator()
    {
        Node current = head;
 
        while (current != null)
        {
            yield return current.Data;
            current = current.Next;
        }
    }
}
 
 
public class SortedList<T> : MyList<T> where T : IComparable<T>
{
    // A simple, unoptimized sort algorithm that
    // orders list elements from lowest to highest:
 
public void BubbleSort()
    {
 
        if (null == head || null == head.Next)
            return;
        bool swapped;
 
        do
        {
            Node previous = null;
            Node current = head;
            swapped = false;
 
            while (current.next != null)
            {
                //  Because we need to call this method, the SortedList
                //  class is constrained on IEnumerable<T>
                if (current.Data.CompareTo(current.next.Data) > 0)
                {
                    Node tmp = current.next;
                    current.next = current.next.next;
                    tmp.next = current;
 
                    if (previous == null)
                    {
                        head = tmp;
                    }
                    else
                    {
                        previous.next = tmp;
                    }
                    previous = tmp;
                    swapped = true;
                }
 
                else
                {
                    previous = current;
                    current = current.next;
                }
 
            }// end while
        } while (swapped);
    }
 
}
 
// A simple class that implements IComparable<T>
// using itself as the type argument. This is a
// common design pattern in objects that are
// stored in generic lists.
public class Person : IComparable<Person>
{
    string name;
    int age;
    public Person(string s, int i)
    {
        name = s;
        age = i;
    }
    // This will cause list elements
    // to be sorted on age values.
    public int CompareTo(Person p)
    {
        return age - p.age;
    }
    public override string ToString()
    {
        return name + ":" + age;
    }
    // Must implement Equals.
    public bool Equals(Person p)
    {
        return (this.age == p.age);
    }
}
 
class Program
{
    static void Main(string[] args)
    {
        //Declare and instantiate a new generic SortedList class.
        //Person is the type argument.
        SortedList<Person> list = new SortedList<Person>();
 
        //Create name and age values to initialize Person objects.
        string[] names = new string[]{"Franscoise", "Bill", "Li", "Sandra", "Gunnar", "Alok", "Hiroyuki", "Maria", "Alessandro", "Raul"};
        int[] ages = new int[]{45, 19, 28, 23, 18, 9, 108, 72, 30, 35};
 
        //Populate the list.
        for (int x = 0; x < 10; x++)
        {
            list.AddHead(new Person(names[x], ages[x]));
        }
        //Print out unsorted list.
        foreach (Person p in list)
        {
            Console.WriteLine(p.ToString());
        }
 
        //Sort the list.
        list.BubbleSort();
 
        //Print out sorted list.
        foreach (Person p in list)
        {
            Console.WriteLine(p.ToString());
        }
 
        Console.WriteLine("Done");
    }
}
 
 
可以在一个类型指定多个接口作为约束，如下:
 
class Stack<T> where T : IComparable<T>, IMyStack1<T>{}
 
 
一个接口可以定义多个类型参数，如下:
 
IDictionary<K,V>
 
接口和类的继承规则相同：
//Okay.
IMyInterface : IBaseInterface<int>
//Okay.
IMyInterface<T> : IBaseInterface<T>
 
//Okay.
IMyInterface<T>: IBaseInterface<int>
//Error.
IMyInterface<T> : IBaseInterface2<T, U>
 
具体类可以实现封闭构造接口，如下:
class MyClass : IBaseInterface<string>
 
泛型类可以实现泛型接口或封闭构造接口，只要类的参数列表提供了接口需要的所有参数，如下:
//Okay.
class MyClass<T> : IBaseInterface<T>
//Okay.
class MyClass<T> : IBaseInterface<T, string>
 
泛型类、泛型结构，泛型接口都具有同样方法重载的规则。详细信息，请参见泛型方法。


 


泛型方法
 
泛型方法是声名了类型参数的方法，如下：
 
void Swap<T>( ref T lhs, ref T rhs)
{
  T temp;
  temp = lhs;
  lhs = rhs;
  rhs = temp;
}
 
 
下面的示例代码显示了一个以int作为类型参数，来调用方法的例子：
 
int a = 1;
int b = 2;
//…
Swap<int>(a, b);
 
也可以忽略类型参数，编译器会去推断它。下面调用Swap的代码与上面的例子等价：
Swap(a, b);
 
 
静态方法和实例方法有着同样的类型推断规则。编译器能够根据传入的方法参数来推断类型参数；而无法单独根据约束或返回值来判断。因此类型推断对没有参数的方法是无效的。类型推断发生在编译的时候，且在编译器解析重载方法标志之前。编译器对所有同名的泛型方法应用类型推断逻辑。在决定（resolution）重载的阶段，编译器只包含那些类型推断成功的泛型类。更多信息，请参见C# 2.0规范，20.6.4类型参数推断
 
在泛型方法中，非泛型方法能访问所在类中的类型参数，如下：
class MyClass<T>
{
  //…
  void Swap (ref T lhs, ref T rhs){…}
}
 
[JX1] 定义一个泛型方法，和其所在的类具有相同的类型参数；试图这样做，编译器会产生警告CS0693。
 
class MyList<T>
{
// CS0693
    void MyMethod<T>{...}   
}
 
class MyList<T>
{
//This is okay, but not common.
    void SomeMethod<U>(){...}   
}
 
使用约束可以在方法中使用更多的类型参数的特定方法。这个版本的Swap<T>称为SwapIfGreater<T>，它只能使用实现了IComparable<T>的类型参数。
void SwapIfGreater<T>( ref T lhs, ref T rhs) where T: IComparable<T>
{
  T temp;
  if(lhs.CompareTo(rhs) > 0)
    {
      temp = lhs;
      lhs = rhs;
      rhs = temp;
    }
}
 
泛型方法通过多个类型参数来重载。例如，下面的这些方法可以放在同一个类中：
void DoSomething(){}
void DoSomething<T>(){}
void DoSomething<T,U>(){}
 


 


泛型委托
无论是在类定义内还是类定义外，委托可以定义自己的类型参数。引用泛型委托的代码可以指定类型参数来创建一个封闭构造类型，这和实例化泛型类或调用泛型方法一样，如下例所示：
 
public delegate void MyDelegate<T>(T item);
public void Notify(int i){}
//...
 
MyDelegate<int> m = new MyDelegate<int>(Notify);
 
C#2.0版有个新特性称为方法组转换（method group conversion），具体代理和泛型代理类型都可以使用。用方法组转换可以把上面一行写做简化语法：
MyDelegate<int> m = Notify;
 
在泛型类中定义的委托，可以与类的方法一样地使用泛型类的类型参数。
class Stack<T>
{
T[] items;
      int index
//...
public delegate void StackDelegate(T[] items);
}
 
引用委托的代码必须要指定所在类的类型参数，如下：
 
Stack<float> s = new Stack<float>();
Stack<float>.StackDelegate myDelegate = StackNotify;
 
 
泛型委托在定义基于典型设计模式的事件时特别有用。因为sender[JX2] ，而再也不用与Object相互转换。
public void StackEventHandler<T,U>(T sender, U eventArgs);
class Stack<T>
{
    //…
    public class StackEventArgs : EventArgs{...}
    public event StackEventHandler<Stack<T>, StackEventArgs> stackEvent;
    protected virtual void OnStackChanged(StackEventArgs a)
    {
      stackEvent(this, a);
    }
}
class MyClass
{
  public static void HandleStackChange<T>(Stack<T> stack, StackEventArgs args){...};
}
Stack<double> s = new Stack<double>();
MyClass mc = new MyClass();
s.StackEventHandler += mc.HandleStackChange;
 


 


泛型代码中的 default 关键字
 
在泛型类和泛型方法中会出现的一个问题是，如何把缺省值赋给参数化类型，此时无法预先知道以下两点：
l        T将是值类型还是引用类型
l        如果T是值类型，那么T将是数值还是结构
 
对于一个参数化类型T的变量t，仅当T是引用类型时，t = null语句才是合法的； t = 0只对数值的有效，而对结构则不行。这个问题的解决办法是用default关键字，它对引用类型返回空，对值类型的数值型返回零。而对于结构，它将返回结构每个成员，并根据成员是值类型还是引用类型，返回零或空。下面MyList<T>类的例子显示了如何使用default关键字。更多信息，请参见泛型概述。
 
public class MyList<T>
{
    //...
        public T GetNext()
        {
            T temp = default(T);
            if (current != null)
            {
                temp = current.Data;
                current = current.Next;
            }
            return temp;
        }
}