泛型 Generic

什么是泛型：泛型在我们编程时候是无处不在无处不用。在说明之前看一段下面代码：

List<int> intlist = new List<int>(); // 定义一个int类型集合
List<string> stringlist = new List<string>();//定义 string类型的集合

这里先告诉大家这是List一个泛型类，这个List相信大家在开发当中用的很频繁了。  下面看一下官网对泛型的定义，因英语不好只能翻译成中文：

看到这个概念或许会有不理解地方。为了通俗易懂用泛型方法来举例子探究一下究竟什么是泛型。

        static void Main(string[] args)
        {
            int iValue = 717;
            string strValue = "Dolphin";

            ShowInt(iValue);
            ShowString(strValue);

        }
        public static void ShowInt(int iParameter)
        {
            Console.WriteLine($"This is parameter={iParameter.GetType().Name},type={iParameter}");
        }
        public static void ShowString(string sParameter)
        {
            Console.WriteLine($"This is parameter={sParameter.GetType().Name},type={sParameter}");
        }     

 

以上代码两个方法 分别是int,string类型传递参数，但是方法动作都是打印结果。

如果说我要在加一个datetime类型来传递干的事都是一样的话，是不是还得增加一个叫showDatetime的方法呢？ 如果我要在加好几个类型的话只能有增加的方法来解决呢？

在泛型出来之前有关于这种类型的解决方法---object类型。

为什么Object定义的参数可以传递 Int，String参数呢？

         1. object是所有类型的基类。(万物皆Object)

         2.（任何基类出现的地方都可以使用子类来代替）里面氏替换 原则。

        public static void ShowObject(object oParameter)
        {
            Console.WriteLine("This is parameter={0},type={1}",
                 oParameter.GetType().Name, oParameter);
        }

这样刚刚好解决了不同类型的问题，但是还是会出现两个问题：

1.性能问题（装箱拆箱） 其实就是类型换对性能的损耗-----引用类型与值类型之间转换消耗性能。

2.类型不安全。

那该如何解决这方面的问题呢？

这就需要我们今天的主角泛型该登场了。首先看一下定义：

public static void Show<T>(T tParameter)
        {
            Console.WriteLine("This is parameter={0},type={1}",
                  tParameter.GetType().Name, tParameter);
        }

但是为什么泛型就可以解决Object的方式的问题呢？ 先做个如下测试：

        public static void Show()
        {
            Console.WriteLine("****************Monitor******************");
            {
                int iValue = 12345;
                long commonSecond = 0;
                long objectSecond = 0;
                long genericSecond = 0;

                {
                    Stopwatch watch = new Stopwatch();
                    watch.Start();
                    for (int i = 0; i < 100_000_000; i++)
                    {
                        ShowInt(iValue);//直接定义int类型
                    }
                    watch.Stop();
                    commonSecond = watch.ElapsedMilliseconds;
                }
                {
                    Stopwatch watch = new Stopwatch();
                    watch.Start();
                    for (int i = 0; i < 100_000_000; i++)
                    {
                        ShowObject(iValue);//转换成object
                    }
                    watch.Stop();
                    objectSecond = watch.ElapsedMilliseconds;
                }
                {
                    Stopwatch watch = new Stopwatch();
                    watch.Start();
                    for (int i = 0; i < 100_000_000; i++)
                    {
                        Show<int>(iValue);//使用泛型
                    }
                    watch.Stop();
                    genericSecond = watch.ElapsedMilliseconds;
                } 
                Console.WriteLine($"commonSecond={commonSecond},objectSecond={objectSecond},genericSecond={genericSecond}");
            }
        }

        private static void ShowInt(int iParameter)
        {
            //do nothing
        }
        private static void ShowObject(object oParameter)
        {
            //do nothing
        }
        private static void Show<T>(T tParameter)
        {
            //do nothing
        }

 

这里做了测试 一个为普通类型，object，泛型方法来验证性能消耗。

代码逻辑为每个方法循环100_000_000次 每个方法里什么操作都没有做 只是调用输出运行结果。

运行结果：

 由此看普通类型和泛型结果颇为相似，可以证明泛型是解决了object的性能消耗问题。

 

写了一个小时。。。才写了这么点。。明天继续写。。。。。