泛型

泛型是一种特殊的类型，它把指定类型的工作推迟到客户端代码声明并实例化类或方法的时候进行。

 MSDN:C# 泛型简介

C#泛型演示
class Stack<T> {
private T[] store;
private int size;
public Stack() {
store = new T[10]; size = 0;
}
public void Push(T x) {
store[size++] = x; }
public T Pop() {
return store[--size];
}
}

 

C#泛型简介
Stack<int> x = new Stack<int>();
x.Push(17);
• 所谓泛型，即通过参数化类型来实现在同一份代码上操作多种数据类型。泛型编程是一种编程范
式，它利用“参数化类型”将类型抽象化，从而实现更为灵活的复用。
• 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> { } //非法

C#除可单独声明泛型类型（包括类与结构）外，也可在基类中包含泛型类型的声明。但基类如果
是泛型类，它的类型参数要么已实例化，要么来源于子类（同样是泛型类型）声明的类型参数。

泛型类型的成员
class C<V>{
　　public V f1; //声明字段
　　public D<V> f2; //作为其他泛型类型的参数
　　public C(V x) {
　　this.f1 = x;
　　}
}

泛型类型的成员可以使用泛型类型声明中的类型参数。但类型参数如果没有任何约束，则只能在
该类型上使用从System.Object继承的公有成员。

 

泛型接口
interface IList<T> {
　　T[] GetElements();
}
interface IDictionary<K,V> {
　　void Add(K key, V value);
}
// 泛型接口的类型参数要么已实例化，
// 要么来源于实现类声明的类型参数
class List<T> : IList<T>, IDictionary<int, T> {
　　public T[] GetElements() { return null; }
　　public void Add(int index, T value) { }
}

 

泛型委托
delegate bool Predicate<T>(T value);
　　class X {
　　　　static bool F(int i) {...}
　　　　static bool G(string s) {...}
　　　　static void Main() {
　　　　Predicate<string> p2 = G;
　　　　Predicate<int> p1 = new Predicate<int>(F);
　　}
}
泛型委托支持在委托返回值和参数上应用参数类型，这些参数类型同样可以附带合法的约束。

 

泛型方法的声明与调用
public class Finder {
　　// 泛型方法的声明
　　public static int Find<T> ( T[] items, T item) {
　　　　for(int i=0;i<items.Length;i++){
　　　　　　if (items[i].Equals(item)) { return i; }
　　　　}
　　　　return -1;
　　}
}
// 泛型方法的调用
int i=Finder.Find<int> ( new int[]{1,3,4,5,6,8,9}, 6);

 

泛型方法的重载
class MyClass {
void F1<T>(T[] a, int i); // 不可以构成重载方法
void F1<U>(U[] a, int i);
void F2<T>(int x); //可以构成重载方法
void F2(int x);
void F3<T>(T t) where T : A; //不可以构成重载方法
void F3<T>(T t) where T : B;
}