泛型類型

• 泛型類

      泛型類封裝不是特定於具體數據類型的操作。 泛型類最常用於集合，如鏈接列表、哈希表、堆棧、隊列、樹等。 像從集合中添加和移除項這樣的操作都以大體上相同的方式執行，與所存儲數據的類型無關。對大多集合類的操作，推薦使用 .NET Framework 類庫中所提供的類。

     （1）泛型類可以繼承具體類、封閉式構造、開放式構造基類。

class BaseNode { }
class BaseNodeGeneric<T> { }

// 繼承具體類
class NodeConcrete<T> : BaseNode { }

//繼承封閉式構造基類
//封閉式構造基類指基類類型參數指定具體類型
class NodeClosed<T> : BaseNodeGeneric<int> { }

//繼承開放式構造基類
//開放式構造基類指基類類型參數未指定
class NodeOpen<T> : BaseNodeGeneric<T> { }

      （2）基類類型參數必須在子類中指定實現。

//正確
class Node1 : BaseNodeGeneric<int> { }

//錯誤
//在子類中未指定父類類型參數實現
class Node2 : BaseNodeGeneric<T> {}

//錯誤
//在子類中未指定父類類型參數實現
class Node3 : T {}

class BaseNodeMultiple<T, U> { }

//正確
class Node4<T> : BaseNodeMultiple<T, int> { }

//正確
class Node5<T, U> : BaseNodeMultiple<T, U> { }

//錯誤
//在子類中未指定父類類型參數實現
class Node6<T> : BaseNodeMultiple<T, U> {} 

      （3）從開放式構造類型繼承的泛型類必須指定約束，這些約束是基類型約束的超集或暗示基類型約束。

class NodeItem<T> where T : System.IComparable<T>, new() { }
class SpecialNodeItem<T> : NodeItem<T> where T : System.IComparable<T>, new() { }

      （4）泛型類型可以使用多個類型參數和約束。

class SuperKeyType<K, V, U>
    where U : System.IComparable<U>
    where V : new()
{ }

      （5）開放式構造類型和封閉式構造類型可以用作方法參數。

void Swap<T>(List<T> list1, List<T> list2)
{ }

void Swap(List<int> list1, List<int> list2)
{ }

•  泛型接口

      （1）泛型類型參數可指定多重接口約束。

class Stack<T> where T : System.IComparable<T>, IEnumerable<T>
{
}

      （2）接口可以定義多個類型參數。

interface IDictionary<K, V>
{
}

      （3）類繼承規則適用接口繼承規則。（參考上面泛型類繼承）

      （4）泛型接口實例

    class GenericInterface
    {
        static void Main()
        {
            SortedList<Person> list = new SortedList<Person>();

            string[] names = new string[]
            {
                "zhang san",
                "li si",
                "wang wu",
                "zhou er",
                "he yi"
            };

            int[] ages = new int[] { 22, 15, 30, 34, 12 };

            for (int x = 0; x < 5; x++)
            {
                list.AddNode(new Person(names[x], ages[x]));
            }

            foreach (Person p in list)
            {
                System.Console.WriteLine(p.ToString());
            }
            Console.WriteLine("------------------排序-----------------------");
            list.BublleSort();

            foreach (Person p in list)
            {
                System.Console.WriteLine(p.ToString());
            }

            Console.Read();
        }
    }

    public class GenericList<T> : System.Collections.Generic.IEnumerable<T>
    {
        public class Node
        {
            private T data;
            public T Data
            {
                get { return data; }
                set { data = value; }
            }

            private Node next;
            public Node Next
            {
                get { return next; }
                set { next = value; }
            }

            private Node last;
            public Node Last
            {
                get { return last; }
                set { last = value; }
            }

            public Node(T t)
            {
                data = t;
                next = null;
            }
        }

        public Node firstNode;
        private Node lastNode;

        public void AddNode(T t)
        {
            Node node = new Node(t);
            node.Last = lastNode;

            if (lastNode != null)
                lastNode.Next = node;

            lastNode = node;

            if (firstNode == null)
                firstNode = node;
        }

        #region IEnumerable<T> 成員

        public IEnumerator<T> GetEnumerator()
        {
            Node current = firstNode;
            while (current != null)
            {
                //yield return表達式以枚舉對象返回
                yield return current.Data;
                current = current.Next;
            }
        }

        #endregion

        #region IEnumerable 成員
         //IEnumerable < T >繼承自IEnumerable,
        //因此這類必須實現泛型和非泛型的版本的GetEnumerator。
        //在大多數情況下,非泛型方法簡單調用泛型方法。
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        #endregion
    }

    public class SortedList<T> : GenericList<T> where T : System.IComparable<T>
    {
        //該方法實現排序
        public void BublleSort()
        {
            if (firstNode == null || firstNode.Next == null)
                return;

            bool swapped;

            do
            {
                Node last = null;
                Node current = firstNode;
                swapped = false;
                while (current.Next != null)
                {
                    if (current.Data.CompareTo(current.Next.Data) > 0)
                    {
                        /* 當前節點大於下一個節點，位置交換*/
                        Node tmp = current.Next;
                        current.Next = current.Next.Next;
                        tmp.Next = current;
                        if (last == null)
                        {
                            firstNode = tmp;
                        }
                        else
                        {
                            last.Next = tmp;
                        }
                        last = tmp;
                        swapped = true;
                    }
                    else
                    {
                        last = current;
                        current = current.Next;
                    }
                }
            }
            while (swapped);
        }
    }
    public class Person : System.IComparable<Person>
    {
        string name;
        int age;

        public Person(string n, int a)
        {
            name = n;
            age = a;
        }

        #region IComparable<Person> 成員

        public int CompareTo(Person p)
        {
            //按年齡排序
            //return age - p.age;

            //按名稱排序
            int a =name.CompareTo(p.name);
            return a;
        }

        #endregion

        public override string ToString()
        {
            return name + ":" + age;
        }
    }

輸出如下：

•  泛型方法

     包含類型參數聲明的方法即為泛型方法。

    （1）泛型類的類型參數與它內部泛型方法的類型參數一致，編譯器將生成警告 CS0693。

class GenericList<T>
{
    // CS0693
    void SampleMethod<T>() { }
}

    （2）泛型方法的類型參數可以進行約束。

    （3）泛型方法可以使用許多類型參數進行重載。

void DoWork() { }
void DoWork<T>() { }
void DoWork<T, U>() { }