NET 泛型，详细介绍

今天的文章是由于再给一个朋友讲这个的时候随手记录下整理出来的。说白了就是把前辈们曾经给我吹过的我又吹了出去。

 　　

　　泛型：是C# FrameWork 2.0 时代 加入进来的，能够说对与Net开发人员来讲泛型是无处再也不的，喜欢看源码的同窗，可能会有发现，包括MVC里面基本上也是有不少发泛型，还有不少设计模式也须要搭配泛型来实现，包括项目架构

泛型的存在，是代码利用率复用性都大大的提高了，有时候Object 也是能够起到相同的做用，为何使用泛型 为何不是用Obj ,咱们来看一下：

　　下面咱们列出两个最基础的方法：

        /// <summary>
        /// 返回int
        /// </summary>
        /// <param name="I"></param>
        /// <returns></returns>
        public int ShowInt(int I)
        {
            return I;
        }
        /// <summary>
        /// 返回String
        /// </summary>
        /// <param name="I"></param>
        /// <returns></returns>
        public string  ShowString (string I)
        {
            return I;
        }

　　上面的两个方法自从参数 进来到参数出去的这一个过程当中咱们没有进行参数方面的转换，也就是说单纯的针对的参数类型上面咱们程序代码是没有损失任何的性能的。一位没有存在拆箱装箱的过程。

　　咱们在看两个方法：咱们使用了在C# 1.0 时代就存在的一个类型 是Object
　　

        /// <summary>
        /// 返回int
        /// </summary>
        /// <param name="I"></param>
        /// <returns></returns>
        public int ShowString(object I)
        {
            return Convert.ToInt32(I);
        }
        /// <summary>
        /// 返回String
        /// </summary>
        /// <param name="I"></param>
        /// <returns></returns>
        public string ShowString(object I)
        {
            return I.ToString();
        }

 　　这里咱们使用的阐述类型是Obj ,Object 是引用类型，也是全部类型的父类，能够包容全部的类型，可是就单说处理参数类型的时候咱们须要去转换一下才能进行使用，在这个转换的过程当中咱们已经损失了性能，可是使用Obj 的时候咱们能够和成一个方法减小代码量，提高了代码的复用率。

　　好比：

        /// <summary>
        /// 返回object
        /// </summary>
        /// <param name="I"></param>
        /// <returns></returns>
        public object ShowType(object I)
        {
            return I;
        }

　　如今简写成为这样后，咱们是一个公用的方法：虽说内部不用去转换了可是，在调用后，仍是须要类型的转换一样的须要损失性能。中间性能之因此会损失是由于Obj是引用类型，存放在堆上的，假如说咱们传的参数是int或其余的值类型来使用咱们的公共方法，就会进行一次包装的过程，把存放在栈里面的值类型移动包装成为引用类型存放到堆里面，使参数符合当前方法的类型，这个过成也就是装箱（须要从新分配内存），可是咱们在使用的时候，又须要把他拿出来进行一下装换转换为值类型，这个过程又称为拆箱，

　　咱们在来使用一个方法：使用 2.0时代出现的泛型：

        /// <summary>
        /// 返回 T
        /// </summary>
        /// <param name="Parameter"></param>
        /// <returns></returns>
        public T Show<s>(T Parameter)
        {
            return Parameter;
        }

　　为何会使用泛型 是由于泛型方法再调用的时候有延时声明的功能这里的延时声明式只参数，泛型里面的 T ，其实我们也能够理解为 占位符具体为谁占位的，等到调用的时候才会知道。

　　以下：

    int parameter = 0;
    //在调用的时候声明参数类型
    parameter = new Common().Show<int>(parameter);
    //若是调用的时候不去声明的话，JIT编译的时候野会帮咱们自动计算
    parameter = new Common().Show(parameter);

　　这个时候不会损耗什么性能。延时声明也是我们在进行框架设计的时候经常使用的一种思想，提升框架的性能。泛型不仅是能够声明泛型方法：

　　泛型类：

    /// <summary>
    /// CURD 操做类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ConmonClass<T>
    {
        public void Add(T s) { };
        public void Update(T s) { };
        public void Del(T s) { };
        public void Select(T s) { }; 
    }

　　这样使用的话，在我们真正的项目，咱们能够把某些基础的操做用一个类去搞定，使用的时候调用就是了，减小代码的冗余，增长复用性，重用率。

　　泛型接口：

    /// <summary>
    /// CURD 操做接口类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface ConmonInterface<T>
    {
        T Add(T s);
        T Update(T s);
        T Del(T s);
        T Select(T s);
    }

　　泛型委托：

//泛型委托
public delegate T GetHandler<T>();

　　我想以上的操做在咱们开发项目的时候会常常见到，或使用到

　　以上代码须要咱们注意的时候，泛型类不能被继承，若是想要继承的话须要在继承的时候，给咱们的不肯定参数肯定下参数类型。包括泛型接口也是同样的。

　　以下：

    public class Son : ConmonClass<Common>
    {};
    /// <summary>
    /// 实现泛型接口
    /// </summary>
    public class SonInterface : ConmonInterface<Common>
    {
        public Common Add(Common s)
        {
            throw new NotImplementedException();
        }

        public Common Del(Common s)
        {
            throw new NotImplementedException();
        }

        public Common Select(Common s)
        {
            throw new NotImplementedException();
        }

        public Common Update(Common s)
        {
            throw new NotImplementedException();
        }
     }

　　若是说不指定泛型类型的参数类型式其实咱们同样是能够继承的。需用继承者一样是泛型的。

　　建议：长期使用Net的同窗我想咱们须要增强一下泛型的认识了，由于在NetCore中经常会使用依赖注入，在使用泛型类的时候咱们可能会多少有点麻烦的，泛型方法相对来讲要简单的，若是说要想让咱们的框架实现高度的内聚，你们须要多多理解。

　　泛型的约束，多重约束至关重要，表明咱们是否能很好的利用泛型。

　　泛型的约束类型大概分为以下几种：

引用类型约束：	代表泛型参数只能是引用类型的：
值类型约束：	代表泛型参数只能是值类型的：
无参数构造函数约束：	泛型是能够实例化的。
基类约束	必须知足基类中的某些属性
接口约束	必须知足接口中的某些属性

　　

 

 

 

 

 

 

具体的就不代码了。

　　

有不足之处 但愿你们指出相互学习，

            本文原创：转载请注明出处 谢谢！