C#中使用泛型对照使用通用基础类型效率减少近一倍



C#中使用泛型对照使用通用基础类型效率减少近一倍

以下是測试结果：

CSharp class and generic TotalMilliseconds: 270772.9229
CSharp generic TotalMilliseconds: 269963.3999
CSharp normal TotalMilliseconds: 159716.9094

測试代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static class InsertionSort<T> where T : IComparable
        {
            public static void Sort(T[] a)
            {
                for (var i = 0 + 1; i <= a.Length - 1; i++)
                {
                    var tmp = a[i];
                    int j = i;

                    while (j > 0 && a[j - 1].CompareTo(tmp) > 0)
                        a[j] = a[--j];

                    a[j] = tmp;
                }
            }
        }

        public static void CSharpInsertionSortGeneric<T>(T[] a) where T : IComparable
        {
            for (var i = 0 + 1; i <= a.Length - 1; i++)
            {
                var tmp = a[i];
                int j = i;

                while (j > 0 && a[j - 1].CompareTo(tmp) > 0)
                    a[j] = a[--j];

                a[j] = tmp;
            }
        }

        public static void CSharpInsertionSort(int[] a)
        {
            for (var i = 0 + 1; i <= a.Length - 1; i++)
            {
                var tmp = a[i];
                int j = i;

                while (j > 0 && a[j - 1].CompareTo(tmp) > 0)
                    a[j] = a[--j];

                a[j] = tmp;
            }
        }

        static void Main(string[] args)
        {
            DateTime start = DateTime.Now;
            int[] a = new int[200000];
            for (int i = 0; i < 200000; i++)
            {
                a[i] = 100 - i;
            }
            InsertionSort<int>.Sort(a);
            DateTime end = DateTime.Now;
            Console.WriteLine(string.Format("CSharp class and generic TotalMilliseconds: {0}", (end - start).TotalMilliseconds));

            int[] a2 = new int[200000];
            for (int i = 0; i < 200000; i++)
            {
                a2[i] = 100 - i;
            }
            CSharpInsertionSortGeneric(a2);
            DateTime end2 = DateTime.Now;
            Console.WriteLine(string.Format("CSharp generic TotalMilliseconds: {0}", (end2 - end).TotalMilliseconds));

            int[] a3 = new int[200000];
            for (int i = 0; i < 200000; i++)
            {
                a3[i] = 100 - i;
            }
            CSharpInsertionSort(a3);
            DateTime end3 = DateTime.Now;
            Console.WriteLine(string.Format("CSharp normal TotalMilliseconds: {0}", (end3 - end2).TotalMilliseconds));

            //Console.WriteLine(String.Join(" ", a));
            Console.ReadKey();
        }
    }
}

非常显然，泛型减少了效率但提高了灵活性。

可是从MSDN上https://msdn.microsoft.com/en-us/library/ms172192.aspx 看到泛型有个有长处：

Better performance. Generic collection types generally perform better for storing and manipulating value types because there is no need to box the value types.

性能非常好？非常怀疑这不是每种情况下都是性能非常好。为什么会这样？可能是执行时泛型会做很多其它的内存操作由此产生了效率的减少。