浅谈c# 泛型类的应用

泛型类
泛型类封装不是特定于具体数据类型的操作。 泛型类最常用于集合，如链接列表、哈希表、堆栈、队列、树等。 像从集合中添加和移除项这样的操作都以大体上相同的方式执行，与所存储数据的类型无关。对大多集合类的操作，推荐使用 .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>() { }