c# 泛型总结

一、泛型概述:

泛型是C# 2.0引入的新特性,泛型为开发者提供了类型的参数化的形式,他带来的最大的好处之一是代码的复用。他是通过运行时类型绑定来实现代码的复用,或者说算法的复用。其次,泛型为我们带来的另一个好处是性能的提升,再次,它提供了编译时类型的安全检查,为程序员减轻了负担。下面将分别通过例子来就这三个方面来做个介绍。

一、算法的复用。

下面我将举一个简单的例子,实现了一个简单的List容器,提供Add元素的方法。

namespace GenericTest
{
    public class SimpleList<TIn> 
    {
        private static TIn[] _element;
        private const int DefaultSize = 5;
        private int _currentIndex = -1;
        private int _allocSize;
        private int _length;
        public SimpleList()
        {
            _element = new TIn[DefaultSize];
            _allocSize = DefaultSize;

        }

        public TIn this[int index] { get { return _element[index]; } set { _element[index] = value; } }
        public void Add(TIn value)
        {

            _currentIndex++;
            if (_currentIndex >= DefaultSize)
            {
                _allocSize = _allocSize * 2;
                TIn[] tmp = _element;
                _element = new TIn[_allocSize];
                tmp.CopyTo(_element, 0);
                
            }
            _element[_currentIndex] = value;
            _length++;
        }
        public int Length { get { return _length; }}

    }
    class Program
    {
        static void Main(string[] args)
        {
            
            SimpleList<int> a = new SimpleList<int>();
            a.Add(1);
            a.Add(2);
            a.Add(3);
           
            for (int i = 0; i < a.Length; i++)
            {
                Console.WriteLine(a[i]);
            }
            SimpleList<float> a1 = new SimpleList<float>();
            a1.Add(2.3f);
            for (int i = 0; i < a1.Length; i++)
            {
                Console.WriteLine(a[i]);
            }
           

        }
    }
}

从代码中我们可以看出我们定义的SimpleList类型Add方法带有泛型参数,表明其可以接受任何类型的元素作为参数,当没有泛型时,我们添加元素时,需要为每种类型都定义一个方法或者定义一个接收object类型参数的方法,运行时执行装箱拆箱操作,进而影响程序的性能,以及不能提供编译时类型的安全检查。通过上面的例子我们可以看出泛型为我们带来的是算法的复用,SimpList这个简单的容器的Add方法能够运用在任何类型的元素的添加上。

二、编译时类型的安全检查。

我们在简单定义一个Student类:

class Student
{
public string Name { get; set; }
public int Age { get; set; }
}

在实例化一个Student of SimpleList 的实例 :SimpleList<Student> st = new SimpleList<Student>(); 当我们向其中添加int元素时 st.Add(2),编译器报错,提示参数类型int不能赋值给参数类型Student,这便是泛型提供的编译时类型检查的好处,我们不能随便向其中添加元素。

三、性能的提升。

下面性能的提升,我们通过c#类库提供的两个容器来说明问题,一个是List,是System.Collections.Generic提供的泛型类型,一个是ArrayList,是System.Collections提供的非泛型类型。分别对值类型和引用类型进行测试:

namespace ListBenchmark
{
    class Program
    {
        static void Main(string[] args)
        {
            ValueTypePerfTest();
            ReferencePerfTest();
        }


        private static void ValueTypePerfTest()
        {
            int count = 10000000;
            using (new OperationTimer("List<Int32>"))
            {
                List<Int32> l = new List<Int32>();
                for (int i = 0; i < count; i++)
                {
                    l.Add(i);       //未装箱
                    Int32 x = l[i]; //未拆箱
                }
                l = null;  //确保垃圾收集器回收
                
            }

            using (new OperationTimer("ArrayList<Int32>"))
            {
                ArrayList a = new ArrayList();

                for (int i = 0; i < count; i++)
                {
                    a.Add(i);       //装箱
                    Int32 x = (int)a[i];//拆箱
                }
                a = null;//确保垃圾收集器回收
                
            }
            
        }

        private static void ReferencePerfTest()
        {
            const int count = 10000000;

            using (new OperationTimer("List<string>"))
            {
                List<string> l = new List<string>();
                for (int i = 0; i < count; i++)
                {
                    l.Add("X"); //引用copy
                    string x = l[i]; // 引用copy
                }
                l = null;
                
            }

            using (new OperationTimer("ArrayList<string>"))
            {
                ArrayList a = new ArrayList();
                for (int i = 0; i < count; i++)
                {
                    a.Add("X"); //引用copy
                    string x = (String)a[i]; //cast check & 引用copy
                }
                a = null;
                
            }

            
        }

    }

    internal sealed class OperationTimer : IDisposable
    {
        private Stopwatch m_stopwatch;
        private string m_text;
        private int m_collectionCount;

        public OperationTimer(string text)
        {
            PrepareForOperation();
            m_text = text;
            m_collectionCount = GC.CollectionCount(0);
            m_stopwatch = Stopwatch.StartNew();

        }

        private static void PrepareForOperation()
        {
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
        }
        public void Dispose()
        {
            Console.WriteLine("{0}(GCs={1,3}) {2}",(m_stopwatch.Elapsed),GC.CollectionCount(0)- m_collectionCount,m_text);
        }
    }
}

程序运行结果:从中可以看出对于值类型,List比ArrayList有很大的性能的提升,主要是List添加元素时不需要进行boxing,获取元素不需要unboxing,同时可以正是由于ArrayList的装箱拆箱操作导致垃圾收集次数比较多。对于引用类型则执行时间相差无几,只是做引用拷贝及获取元素时的类型转换检查。

c# 泛型总结

泛型类型的好处介绍到这,下面简单的介绍一下泛型类型参数的约束。

四、泛型的类型参数约束:

泛型类型参数的约束规定了参数的编译时类型的限制。主要有引用类型约束,引用类型的约束不能使用一下之一:Object,Array,Delegate,MulticastDelegate ,ValueType,Enum,System.Void。例如如下泛型约束:

internal sealed class PrimaryConstratinOfStream<T> where T: Stream{},其中where为类型约束关键词,该类型约束表明了使用PrimaryConstratinOfStream必须指定参数类型T为Stream类型或者派生自Stream类型,如FileStream;其中引用类型约束的两个特殊的约束分别是class和struct,where T:class,表示T必须是引用类型,而where T:struct则表示T必须是值类型。

其次,还有一种泛型类型约束的是接口类型,当指定了接口的约束,在使用对象时对于指定类型参数必须实现该接口。最后一种约束是构造器约束,如:

class ConstructorConstraint<T> where T: new(){},它告诉编译器T必须是带有一个public无参构造器的类型。

 

c# 泛型总结

上一篇:IE11 Windows7下F12 DOC资源管理器不能用Exception in window.onload: Error: An error has ocurredJSPlugin.3005


下一篇:关于嵌入式Windows的总结