浅谈c# 泛型类的应用

更新时间：2013年05月31日 11:17:22 作者：

本篇文章是对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>() { }

您可能感兴趣的文章:

C#语法之泛型的多种应用

c#
泛型类

利用lambda表达式树优化反射详解
这篇文章主要给大家介绍了关于如何利用lambda表达式树优化反射的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2018-12-12
C#创建线程带参数的方法
本文给大家介绍C#创建线程带参数的方法，包括无参数线程的创建，带一个参数线程的创建及带两个及以上参数线程的创建，非常不错，具有参考借鉴价值，感兴趣的朋友一起看下吧
2016-07-07
c#哈希算法的实现方法及思路
这篇文章主要介绍了c#哈希算法的实现方法及思路，有需要的朋友可以参考一下
2013-12-12
C#开发webService接口的流程步骤
在C#中,Web Service 接口是一种用于远程程序间的通信机制,它允许客户端通过HTTP协议访问服务器端提供的功能和服务,本文给大家详细介绍了C#开发webService接口的流程步骤,需要的朋友可以参考下
2024-11-11
C#使用Mutex简单实现程序单实例运行的方法
这篇文章主要介绍了C#使用Mutex简单实现程序单实例运行的方法,涉及C#实现单实例程序运行的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
2015-09-09
C# 7.0 使用下划线忽略使用的变量的原因分析
这篇文章主要介绍了C# 7.0 使用下划线忽略使用的变量的原因浅析，本文通过实例代码给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
2018-10-10
C# WPF使用GDI实现截屏功能
这篇文章主要为大家详细介绍了C# WPF如何使用GDI实现截屏功能,文中的示例代码讲解详细,具有一定的借鉴价值,有需要的小伙伴可以跟随小编一起学习一下
2024-03-03
简单对比C#程序中的单线程与多线程设计
这篇文章主要介绍了C#程序中的单线程与多线程设计的简单对比,通过实际的代码演示可以清晰看出多线程并发来避免单线程阻塞问题的特点,需要的朋友可以参考下
2016-04-04
C#创建临时文件的方法
这篇文章主要介绍了C#创建临时文件的方法,涉及C#中Path.GetTempFileName方法获取与操作临时文件的使用技巧,非常具有实用价值,需要的朋友可以参考下
2015-04-04
C#中Equals方法的常见误解
equals方法被用来检测两个对象是否相等，即两个对象的内容是否相等。本文主要介绍的是equals方法，初学者对它几个常见的误解，一起来看。
2015-10-10

浅谈c# 泛型类的应用

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具