C# 2.0 泛型

[×××]

C# 2.0 泛型

作者：webabcd

介紹

泛型是 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 />");

}

運作結果

類型：System.DateTime；值：2007-2-10 22:56:09

類型：System.String；值：abc

子類實作-類型：System.Guid；值：00000000-0000-0000-0000-000000000000

類型：System.Double；值：3.14159265358979 ||| 子類實作-類型：System.Int32；值：123

泛型方法

* 如何 使用 泛型方法    

public class GenericMethod

        // 靜态 泛型方法

        public static string Output<T>(T t)

public partial class Generic_Method : System.Web.UI.Page

                Response.Write(GenericMethod.Output<int>(23) + "<br />");

                Response.Write(GenericMethod.Output<DateTime>(DateTime.Now) + "<br />");

類型：System.Int32；值：23

類型：System.DateTime；值：2007-2-10 22:57:29

泛型委托

* 如何 使用 泛型委托

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

                // 使用泛型委托

                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));

Hello, aabbcc

Time, 2007-2-10 22:59:26

抽象泛型類，派生限制

* 如何 使用 和 繼承 抽象泛型類    

* 派生限制

// 泛型抽象類

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

                GenericChild gc = new GenericChild();

                Response.Write(gc.Output<string, IComparable>("aaa", "xxx"));

                Response.Write(gc.Output2<System.Data.DataTable>(new System.Data.DataTable()));

aaa

System.Data.DataTable

泛型接口，派生限制，構造函數限制

* 如何 使用 泛型接口

* 構造函數限制（如果執行個體化的話）

// 泛型接口

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

                IGenericInterface<System.ComponentModel.IListSource> factory =

                        new Factory<System.Data.DataTable, System.ComponentModel.IListSource>();

                Response.Write(factory.CreateInstance().GetType().ToString());

其它

* 泛型 其它

// 泛型也可以使用别名

using MyList = System.Collections.Generic.List<string>;

public partial class Generic_Other : System.Web.UI.Page

                MyList ml = new MyList();

                ml.Add("aaa");

                ml.Add("bbb");

                Response.Write(ml[0]);

                Response.Write(ml[1]);

                // 其它說明

                // 值類型限制 public class MyClass<T> where T : struct { }

                // 引用類型限制 public class MyClass<T> where T : class { }

                // 沒有泛型屬性

bbb

OK