C# 2.0 泛型

/*--- 
 * 如何 使用 和 继承 泛型类 
---*/ 
using System; 
using System.Collections.Generic; 
 
// 泛型类 
public  class GenericClass<T> 
{ 
         // 返回泛型的具体类型和ToString()后的值 
         public  virtual  string Output(T t) 
        { 
                 return  "类型：" + t.GetType().ToString() +  "；值：" + t.ToString(); 
        } 
} 
 
// 继承自一个泛型类，指定基类的泛型的具体类型 
public  class InheritClass1 : GenericClass< string> 
{ 
 
} 
 
// 继承自一个泛型类，基类和子类都是同一泛型 
public  class InheritClass2<T> : GenericClass<T> 
{ 
         public  override  string Output(T t) 
        { 
                 return  "子类实现-类型：" + t.GetType().ToString() +  "；值：" + t.ToString(); 
        } 
} 
 
// 继承自一个泛型类，指定基类的泛型的具体类型，子类仍然可以是泛型 
public  class InheritClass3<Z> : GenericClass< double> 
{ 
         public  string ChildOutput(Z z) 
        { 
                 return  "子类实现-类型：" + z.GetType().ToString() +  "；值：" + z.ToString(); 
        } 
} 
 
 
public partial  class Generic_Class : System.Web.UI.Page 
{ 
         protected  void Page_Load( object sender, EventArgs e) 
        { 
                GenericClass<DateTime> c =  new GenericClass<DateTime>(); 
                Response.Write(c.Output(DateTime.Now) +  "<br />"); 
 
                InheritClass1 c1 =  new InheritClass1(); 
                Response.Write(c1.Output( "abc") +  "<br />"); 
 
                GenericClass<Guid> c2 =  new InheritClass2<Guid>(); 
                Response.Write(c2.Output( new Guid()) +  "<br />"); 
 
                InheritClass3< int> c3 =  new InheritClass3< int>(); 
                Response.Write(c3.Output(Math.PI) +  " ||| " + c3.ChildOutput(123) +  "<br />"); 
        } 
}

/*--- 
 * 如何 使用 泛型方法    
---*/ 
using System; 
using System.Collections.Generic; 
 
public  class GenericMethod 
{ 
         // 静态 泛型方法 
         public  static  string Output<T>(T t) 
        { 
                 return  "类型：" + t.GetType().ToString() +  "；值：" + t.ToString(); 
        } 
} 
 
 
public partial  class Generic_Method : System.Web.UI.Page 
{ 
         protected  void Page_Load( object sender, EventArgs e) 
        { 
                Response.Write(GenericMethod.Output< int>(23) +  "<br />"); 
                Response.Write(GenericMethod.Output<DateTime>(DateTime.Now) +  "<br />"); 
        } 
}

/*--- 
 * 如何 使用 泛型委托 
---*/ 
using System; 
using System.Collections.Generic; 
 
public  class GenericDelegate 
{ 
         // 声明一个泛型委托 
         public  delegate  string OutputDelegate<T>(T t); 
 
         // 定义一个静态方法 
         public  static  string DelegateFun( string s) 
        { 
                 return String.Format( "Hello, {0}", s); 
        } 
 
         // 定义一个静态方法 
         public  static  string DelegateFun(DateTime dt) 
        { 
                 return String.Format( "Time, {0}", dt.ToString()); 
        } 
} 
 
 
public partial  class Generic_Delegate : System.Web.UI.Page 
{ 
         protected  void Page_Load( object sender, EventArgs e) 
        { 
                 // 使用泛型委托 
                GenericDelegate.OutputDelegate< string> delegate1 
                        =  new GenericDelegate.OutputDelegate< string>(GenericDelegate.DelegateFun); 
 
                Response.Write(delegate1( "aabbcc")); 
                Response.Write( "<br />"); 
 
                 // 使用泛型委托（匿名方法） 
                GenericDelegate.OutputDelegate<DateTime> delegate2 = GenericDelegate.DelegateFun; 
                Response.Write(delegate2(DateTime.Now)); 
        } 
}

/*--- 
 * 如何 使用 和 继承 抽象泛型类    
 * 派生约束 
---*/ 
using System; 
using System.Collections.Generic; 
 
// 泛型抽象类 
public  abstract  class GenericParent 
{ 
         // 泛型抽象方法，返回值为一个泛型，加一个约束使泛型X要继承自泛型Y 
         public  abstract X Output<X, Y>(X x, Y y) where X : Y; 
 
         // 泛型抽象方法，返回值为一个string类型，加一个约束使泛型X要继承自泛型Y 
         public  abstract  string Output2<X>(X x) where X : System.ComponentModel.IListSource; 
} 
 
public  class GenericChild : GenericParent 
{ 
         // 重写抽象类的泛型方法 
         public  override T Output<T, Z>(T t, Z z) 
        { 
                 return t; 
        } 
 
         // 重写抽象类的泛型方法 
         public  override  string Output2<T>(T t) 
        { 
                 return t.GetType().ToString(); 
        } 
} 
 
 
public partial  class Generic_Abstract : System.Web.UI.Page 
{ 
         protected  void Page_Load( object sender, EventArgs e) 
        { 
                GenericChild gc =  new GenericChild(); 
                Response.Write(gc.Output< string, IComparable>( "aaa",  "xxx")); 
                Response.Write( "<br />"); 
 
                Response.Write(gc.Output2<System.Data.DataTable>( new System.Data.DataTable())); 
                Response.Write( "<br />"); 
        } 
}

/*--- 
 * 如何 使用 泛型接口 
 * 派生约束 
 * 构造函数约束（如果实例化的话） 
---*/ 
using System; 
using System.Collections.Generic; 
 
// 泛型接口 
public  interface IGenericInterface<T> 
{ 
        T CreateInstance(); 
} 
 
// 实现上面泛型接口的泛型类 
// 派生约束where T : TI（T要继承自TI） 
// 构造函数约束where T : new()（T可以实例化） 
public  class Factory<T, TI> : IGenericInterface<TI> 
        where T : TI,  new() 
{ 
         public TI CreateInstance() 
        { 
                 return  new T(); 
        } 
} 
 
 
public partial  class Generic_Interface : System.Web.UI.Page 
{ 
         protected  void Page_Load( object sender, EventArgs e) 
        { 
                IGenericInterface<System.ComponentModel.IListSource> factory = 
                         new Factory<System.Data.DataTable, System.ComponentModel.IListSource>(); 
 
                Response.Write(factory.CreateInstance().GetType().ToString()); 
                Response.Write( "<br />"); 
        } 
}

/*--- 
 * 泛型 其它 
---*/ 
using System; 
using System.Collections.Generic; 
 
// 泛型也可以使用别名 
using MyList = System.Collections.Generic.List< string>; 
 
public partial  class Generic_Other : System.Web.UI.Page 
{ 
         protected  void Page_Load( object sender, EventArgs e) 
        { 
                MyList ml =  new MyList(); 
                ml.Add( "aaa"); 
                ml.Add( "bbb"); 
 
                Response.Write(ml[0]); 
                Response.Write( "<br />"); 
                Response.Write(ml[1]); 
 
                 // 其它说明 
                 // 值类型约束 public class MyClass<T> where T : struct { } 
                 // 引用类型约束 public class MyClass<T> where T : class { } 
                 // 没有泛型属性 
        } 
}