第一课《.net之--泛型》

 

　　今天我来学习泛型，泛型是编程入门学习的基础类型，从.net诞生2.0开始就出现了泛型，今天我们开始学习泛型的语法和使用。

　　什么是泛型?

　　泛型（generic）是c#语言2.0和通用语言运行时（clr）的一个新特性。泛型为.net框架引入了类型参数（type parameters）的概念。类型参数使得设计类和方法时，不必确定一个或多个具体参数，其的具体参数可延迟到客户代码中声明、实现。这意味着使用泛型的类型参数t，写一个类mylist<t>，客户代码可以这样调用：mylist<int>， mylist<string>或 mylist<myclass>。这避免了运行时类型转换或装箱操作的代价和风险。

　　上面是官方腔调，我说人话：泛型就是为了满足不同类型，相同代码的重用！

 

　　为什么要有泛型？

　　下面我们举例子来讲解为什么会要泛型，以下我列举了三个例子来讲解：

　　 我们列举了showint，showstring，showdatatime三个方法，如果我们在程序中每封装一个方法有不同参数，就要像下面这样写一个函数的话，代码会变得很累赘，在调用的时候必须传递吻合的参数，所以不得不写出了3个方法，那有没有好的方法来解决这样的问题呢？答案是当然有，微软是很聪明的，倾听小满哥慢慢来讲。

        /// <summary>
        /// 打印个int值/// </summary>
        /// <param name="iparameter"></param>
        public static void showint(int iparameter)
        {
            console.writeline("this is {0},parameter={1},type={2}",
                typeof(commonmethod).name, iparameter.gettype().name, iparameter);
        }

        /// <summary>
        /// 打印个string值/// </summary>
        /// <param name="sparameter"></param>
        public static void showstring(string sparameter)
        {
            console.writeline("this is {0},parameter={1},type={2}",
                typeof(commonmethod).name, sparameter.gettype().name, sparameter);
        }

        /// <summary>
        /// 打印个datetime值/// </summary>
        /// <param name="oparameter"></param>
        public static void showdatetime(datetime dtparameter)
        {
            console.writeline("this is {0},parameter={1},type={2}",
                typeof(commonmethod).name, dtparameter.gettype().name, dtparameter);
        }
　　　　　
　　　　　定义一些测试变量

　　　　　　int ivalue = 123;
　　　　　　string svalue = "456";
　　　　　　datetime dtvalue = datetime.now;
　　　　　　object ovalue = "789";

　　　　　　普通方式调用演示
　　　　　　showint(ivalue);
　　　　　　showint(svalue);//这样不行类型必须吻合
　　　　　　showstring(svalue);
　　　　　　showdatetime(dtvalue);

　　在.net 1.0的时候微软出现了object这个概念，下面有一个方法showobject,你们就会发现不管参数是int srtring datetime 我们都可以调用showobject来操作实现，那为什么会这样呢？

　　1：object类型是一切类型的父类。

　　2：任何父类出现的地方，都可以用子类来代替。

出现这个基本满足了开发人员的一些需求，在.net1.0和1.1的时候，这个时候还没有泛型就用object代替。

        /// <summary>
        /// 打印个object值
        /// 1 object类型是一切类型的父类
        /// 2 任何父类出现的地方，都可以用子类来代替
        /// .net framework 1.0 1.1
        /// </summary>
        /// <param name="oparameter"></param>
        public static void showobject(object oparameter)
        {
            console.writeline("this is {0},parameter={1},type={2}",
                typeof(commonmethod), oparameter.gettype().name, oparameter);
        } 

　　　　　定义一些测试变量

　　　　　　int ivalue = 123;
　　　　　　string svalue = "456";
　　　　　　datetime dtvalue = datetime.now;
　　　　　　object ovalue = "789";

　　　　　object方式调用演示

　　　　　　showobject(ovalue);
　　　　　　showobject(ivalue);
　　　　　　showobject(svalue);
　　　　　　showobject(dtvalue);

 

　　接着吹牛比，劳动人民的智慧还是很屌的，经过之前的经历在.net2.0的时候，微软让主角登场了"泛型"，当然同时出现的还有“线程池”这个我们先不讲，回到正轨什么是泛型？你们在开发的时候有没有用过list<t>这个集合？这个就是泛型，深化下直接举个栗子吧，下面我写一个例子show<t>(t tparameter)看下泛型的写法：

　　有个毛用？下面这个方法也可以向上面showobject一样，你们会发现不管参数是int srtring datetime 我们也可以调用show<t>(t tparameter)来操作实现，替换了showobject这个方法的实现，具备了满足了不同参数类型的方法实现，更适用性，泛型方法声明的时候，没有指定类型，而是调用的时候指定，具有延迟声明和延迟思想，这个思想对我们在开发框架的时候灰常有用，不得不说老外这点还是很几把厉害(还是我们被*了？也许吧，我相信等中文编程语言出来估计会更屌，中华文化博大精深嘛)，现在小伙伴们是不是大概了解泛型的基础作用了？

        /// <summary>
        /// 泛型方法声明的时候，没有指定类型，而是调用的时候指定
        /// 延迟声明：把参数类型的声明推迟到调用
        /// 延迟思想：推迟一切可以推迟的
        /// 
        /// 2.0泛型不是语法糖，而是由框架升级提供的功能
        /// 泛型方法性能上和普通方法差不多的/// </summary>
        /// <typeparam name="t"></typeparam>
        /// <param name="tparameter"></param>
        public static void show<t>(t tparameter)
        {
            console.writeline("this is {0},parameter={1},type={2}",
                typeof(genericmethod), tparameter.gettype().name, tparameter.tostring());
        }

　　　　　调用演示

　　　　　　show<object>(ovalue);
　　　　　　show<int>(ivalue);
　　　　　　show(ivalue);//可以去掉，自动推算
　　　　　　show<string>(ivalue);//必须匹配
　　　　　　show<string>(svalue);
　　　　　　show<datetime>(dtvalue);

　　　　那问题来了，既然都可以实现为什么要用这个呢？我们做事凡事都要带着疑问去看待，有些事别人说好，但真的好不好我们要自己亲自试试才知道，我们最关注的的效率问题，下面是测试代码：

　　　　 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 < 100000000; i++)
                    {
                        showint(ivalue);
                    }
                    watch.stop();
                    commonsecond = watch.elapsedmilliseconds;
                }
                {
                    stopwatch watch = new stopwatch();
                    watch.start();
                    for (int i = 0; i < 100000000; i++)
                    {
                        showobject(ivalue);
                    }
                    watch.stop();
                    objectsecond = watch.elapsedmilliseconds;
                }
                {
                    stopwatch watch = new stopwatch();
                    watch.start();
                    for (int i = 0; i < 100000000; i++)
                    {
                        show<int>(ivalue);
                    }
                    watch.stop();
                    genericsecond = watch.elapsedmilliseconds;
                }
                console.writeline("commonsecond={0},objectsecond={1},genericsecond={2}"
                    , commonsecond, objectsecond, genericsecond);
            }
        }

　　结果如下：commonsecond=508,objectsecond=916,genericsecond=452   你会发现普通方法508ms，object方法916ms，泛型是452ms，其中object最慢，为什么最慢呢？因为object会经过一个装箱拆箱的过程，所以性能上会损失一些，但是在我看来这样上亿次这点损耗，算不了什么，但是可以证明泛型和普通类型速度是差不多的，这一点可以认可泛型还是性能挺好的，这个可以推荐使用泛型的理由之一。

　　但泛型仅仅表现在这个层面吗？远远不止，我们用泛型远远不是为了提升刚刚那点性能，为什么要用泛型？答案来了，我们要用泛型就是为了满足不同类型，相同代码的重用，下面我继续举栗子：

　　 泛型的一些用法，泛型只有四种用途，泛型类，泛型接口，泛型委托，泛型方法，如下：

    public class genericclass<t>
    {
        public t property { get; set; }
    }

　　　public interface igenericinterface<t>
　　   {

　　   }

　　　public delegate void donothing<t>();

　　　　调用演示

　　　　list<int> intlist = new list<int>();//原生态list类
　　　　list<string> stringlist = new list<string>();

　　　　genericclass<int> igenericclass = new genericclass<int>();
　　　　igenericclass.property = 1;

　　　　genericclass<string> sgenericclass = new genericclass<string>();
　　　　sgenericclass.property = "1233";

　　　　donothing<int> method = new donothing<int>(() => { });

　　  还有一种，别被吓到：t，s，xiaomange这些语法，只是占位符别怕，你可以自己定义的，在你调用的时候确定类型就ok了，好了差不多能理解泛型了吧？再说一次泛型就是为了满足不同类型，相同代码的重用。

    public class childclassgeneric<t, s, xiaomange> : genericclass<t>, igenericinterface<s>
    {

    }

　　接下来我们来聊一聊拓展的一部分，好像泛型很吊的样子感觉什么都能用泛型类型代替，但是天下哪有那么好的事情，双刃剑的道理都懂，所以出现了泛型的约束这个紧箍咒。

　　泛型的约束

　　直接来代码：

　　很简单的一个例子，接口isports，iwork，people类，japanese类等简单继承了一下，目前准备的一些代码。

　　public interface isports
    {
        void pingpang();
    }

    public interface iwork
    {
        void work();
    }

    public class people
    {
        public int id { get; set; }
        public string name { get; set; }

        public void hi()
        { }
    }

    public class chinese : people, isports, iwork
    {
        public void tradition()
        {
            console.writeline("仁义礼智信，温良恭俭让");
        }
        public void sayhi()
        {
            console.writeline("吃了么？");
        }

        public void pingpang()
        {
            console.writeline("打乒乓球...");
        }

        public void work()
        {
            throw new notimplementedexception();
        }
    }

    public class hubei : chinese
    {

        public hubei(int id)
        {
        }
        public string changjiang { get; set; }
        public void majiang()
        {
            console.writeline("打麻将啦。。");
        }
    }

    public class japanese : isports
    {
        public int id { get; set; }
        public string name { get; set; }

        public void pingpang()
        {
            console.writeline("打乒乓球...");
        }
        public void hi()
        { }
    }

　　再来个调用类constraint

 public class constraint
    {
        /// <summary>
        /// 代码编译没问题，执行的时候才报错
        /// 代码安全问题
        /// </summary>
        /// <param name="oparameter"></param>
        public static void showobject(object oparameter)
        {
            console.writeline("this is {0},parameter={1},type={2}",
                typeof(commonmethod), oparameter.gettype().name, oparameter);

            people people = (people)oparameter;

            console.writeline(people.id);//这里就不行了 代码安全问题，调用不到，但编译不会报错。
            console.writeline(people.name);
        }

        /// <summary>
        /// 基类约束：
        /// 1 带来权力，可以使用基类里面的属性和方法
        /// 2 带来义务，类型参数必须是基类或者其子类
        /// </summary>
        /// <typeparam name="t"></typeparam>
        /// <param name="tparameter"></param>
        public static void show<t>(t tparameter)
            where t : people, isports, new()//都是and 关系
        {
            console.writeline("this is {0},parameter={1},type={2}",
                typeof(genericmethod), tparameter.gettype().name, tparameter.tostring());

            console.writeline(tparameter.id);
            console.writeline(tparameter.name);
            tparameter.hi();
            tparameter.pingpang();
            t t = new t();
        }

        public static void showpeople(people tparameter)
        {
            console.writeline("this is {0},parameter={1},type={2}",
                typeof(genericmethod), tparameter.gettype().name, tparameter.tostring());

            console.writeline(tparameter.id);
            console.writeline(tparameter.name);
            tparameter.hi();
            //tparameter.pingpang();
        }

        public static t donothing<t>(t tparameter)
            //where t : isports//接口约束
            //where t : class//引用类型约束
            //where t : struct//值类型约束
            where t : new()//无参数构造函数约束
        {
            //tparameter.pingpang();
            //return null;
            t t = new t();
            return default(t);//会根据t的类型，去产生一个默认值
        }
    }

　　有兴趣的可以测试下，用showobject的方法和泛型show<t>(t tparameter)调用来看差异，如果不加入约束，想调用参数的属性和方法，代码安全问题是调用不了的，会报错，但是加入基类约束之后是可以调用到的，所以泛型约束带来了权利，可以使用基类的属性和方法，但也带来义务，参数只能是基类和子类，又想马儿跑，又想马儿不吃草的事情是没有的，权利和义务是相对的，在享受权利的同时也会带来义务。

　　其次，约束可以多重约束，然后即可作为参数约束也可以作为返回值约束，例如default(t)会根据泛型类型返回一个默认值，如果是无参数构造约束就可以类似这样写返回值t t=new t()。

　　总之，我觉得泛型约束为了更灵活的满足不同条件的需求而产生的，就是我们在写一些固定的需求，约束叠加来完成我们的功能，同时不让泛型肆无忌惮。

　　　　　　　　泛型约束范围如下：

约束	描述
where t: struct	类型参数必须为值类型。
where t : class	类型参数必须为引用类型。
where t : new()	类型参数必须有一个公有、无参的构造函数。当于其它约束联合使用时,new()约束必须放在最后。
where t : <base class name>	类型参数必须是指定的基类型或是派生自指定的基类型。
where t : <interface name>	类型参数必须是指定的接口或是指定接口的实现。可以指定多个接口约束。接口约束也可以是泛型的。

　　好了泛型的约束的先说到这，继续套底子，了解到的都倒出来。

 

　　逆变和协变

　　逆变和协变不知道有没有小伙伴熟悉的，我开始是不知道这个的，第一次看到也是一脸懵逼，到现在也有点迷糊，能不能讲清楚看造化了，哈哈

　　 继续举栗子：

//协变
public interface ienumerable<out t> : ienumerable
//逆变
public delegate void action<in t>(t obj);

　　这段代码是不是很熟悉？里面有个out t 还有 in t，这里的out 不是我们熟悉的参数返回out，ref的作用，是协变专用的，逆变和协变指出现在接口或者委托泛型前面，

　　in只能作为参数传入，out只能作为参数传出。

　　下面来个代码　　

　　

    public class bird
    {
        public int id { get; set; }
    }
    public class sparrow : bird
    {
        public string name { get; set; }
    }

      调用实例
      ienumerable<int> intlist = new list<int>();
      action<int> iaction = null;
               
       bird bird1 = new bird();
       bird bird2 = new sparrow();//左边是父类  右边是子类
       sparrow sparrow1 = new sparrow();
        //sparrow sparrow2 = new bird();//不是所有的鸟，都是麻雀
        

        list<bird> birdlist1 = new list<bird>();//一群鸟 是一群鸟
        //list<bird> birdlist2 = new list<sparrow>()；//一群麻雀难道不是一群鸟  ？ 不是的，没有父子关系
        list<bird> birdlist3 = new list<sparrow>().select(c => (bird)c).tolist();//这里使用别扭了，明明知道但就是不能这样写

　　以上代码发现问题了吗？很明显出现了一些不和谐的地方，我们换个方式如下： 

 　　/// <summary>
    /// 逆变：只能修饰传入参数
    /// </summary>
    /// <typeparam name="t"></typeparam>
    public interface icustomerlistin<in t>
    {
        //t get();

        void show(t t);
    }

    public class customerlistin<t> : icustomerlistin<t>
    {
        //public t get()
        //{
        //    return default(t);
        //}

        public void show(t t)
        {
        }
    }

    /// <summary>
    /// out 协变 只能是返回结果
    /// </summary>
    /// <typeparam name="t"></typeparam>
    public interface icustomerlistout<out t>
    {
        t get();

        //void show(t t);//不能做参数
    }

    public class customerlistout<t> : icustomerlistout<t>
    {
        public t get()
        {
            return default(t);
        }

        //public void show(t t)
        //{

        //}
    }

 

　　　　　　  {//协变：接口泛型参数加了个out，就是为了解决刚才的不和谐
                ienumerable<bird> birdlist1 = new list<bird>();
                ienumerable<bird> birdlist2 = new list<sparrow>();

                //func<bird> func = new func<sparrow>(() => null);

                icustomerlistout<bird> customerlist1 = new customerlistout<bird>();
                icustomerlistout<bird> customerlist2 = new customerlistout<sparrow>();
            }

            {//逆变
                icustomerlistin<sparrow> customerlist2 = new customerlistin<sparrow>();
                icustomerlistin<sparrow> customerlist1 = new customerlistin<bird>();

                //customerlist1.show()

                icustomerlistin<bird> birdlist1 = new customerlistin<bird>();
                birdlist1.show(new sparrow());
                birdlist1.show(new bird());

                action<sparrow> act = new action<bird>((bird i) => { });
            }

　　这样可以了，协变ienumerable加入协变out 左边是个父类，右边可以是子类，逆变in 左边是个字类，右边也可以是父类，下面这段就更晕了，稍微看下吧。

 　　　　　　{
                imylist<sparrow, bird> mylist1 = new mylist<sparrow, bird>();
                imylist<sparrow, bird> mylist2 = new mylist<sparrow, sparrow>();//协变
                imylist<sparrow, bird> mylist3 = new mylist<bird, bird>();//逆变
                imylist<sparrow, bird> mylist4 = new mylist<bird, sparrow>();//协变+逆变
            }

　　总结下原理：泛型在jit编译时指定具体类型，同一个泛型类，不同的类型参数，其实会变成不用的类型。

　　我走的很慢，但从不后退！