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];} 
} 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; 
} } 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); } } 十、泛型方法支持在委托返回值和参数上应用参数类型，这些参数类型同样可以附带合法的约束。泛型方法简介C#泛型机制只支持 "在方法声明上包含类型参数"——即泛型方法C#泛型机制不支持在除方法外的其他成员（包括属性、事件、索引器、构造器、析构器）的声明上包含类型参数，但这些成员本身可以包含在泛型类型中，并使用泛型类型的类型参数泛型方法既可以包含在泛型类型中，也可以包含在非泛型类型中.十一、泛型方法的声明与调用
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; } abstract class Base { public abstract T F<T,U>(T t, U u) where U: T; public abstract T G<T>(T t) where T: IComparable; } class Derived: Base { //合法的重写，约束被默认继承 public override X F<X,Y>(X x, Y y) { } //非法的重写，指定任何约束都是多余的 public override T G<T>(T t) where T: IComparable {} } class A { public void F1() {} } class B { public void F2() {} } class C < S,T > where S: A // S继承自A where T: B // T继承自B { // 可以在类型为S的变量上调用F1， // 可以在类型为T的变量上调用F2 } interface IPrintable { void Print(); } interface IComparable < T > { int CompareTo(T v);} interface IKeyProvider < T > { T GetKey(); } class Dictionary < K,V > where K: IComparable < K > where V: IPrintable, IKeyProvider < K > { // 可以在类型为K的变量上调用CompareTo， // 可以在类型为V的变量上调用Print和GetKey } class A { class B { class C<T> { public A() { } } public B(int i) { } } } C < B > c = new C < B > (); // 错误，B没有无参构造器 where T : new () // 可以在其中使用T t=new T(); . C < A > c = new C < A > (); // 可以，A有无参构造器 public struct A { public class B{ class C<T> where T : struct { } } // T在这里面是一个值类型C<A> c=new C<A>(); //可以，A是一个值类型 } C < B > c = new C < B > (); // 错误，B是一个引用类型