真爱无限的知识驿站

原理：

泛型是语法糖，在编译时，会为调用者生成各种类型的方法副本.

也就是说， 不用开发者自己写具体方法，是编译器代劳了这一工作，只是节省了开发者的时间

demo代码：

    public class GenericClass
    {
        /// <summary>
        /// 泛型方法，调用时可不传T类型，可以隐式推断类型
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="parameter"></param>
        public static void Show<T>(T parameter)
        {
            Console.WriteLine("value={0},type={1}", parameter, parameter.GetType());
        }
    }
    public class Common
    {
        public static void ShowInt(int parameter)
        {
            Console.WriteLine("value={0},type={1}", parameter, parameter.GetType());
        }
        public static void ShowString(string parameter)
        {
            Console.WriteLine("value={0},type={1}", parameter, parameter.GetType());
        }
        public static void ShowDouble(double parameter)
        {
            Console.WriteLine("value={0},type={1}", parameter, parameter.GetType());
        }
        /// <summary>
        /// 可以达到目的
        /// 但有拆箱装箱过程，有性能损失
        /// </summary>
        /// <param name="parameter"></param>
        public static void ShowObject(object parameter)
        {
            Console.WriteLine("value={0},type={1}", parameter, parameter.GetType());
        }
    }
    /// <summary>
    /// 泛型约束
    /// 同一个类型的多个约束，用英文逗号分开
    /// 引用类型：where T : class
    /// new约束，可以new一个对象、有一个无参数构造函数: where T : new()
    /// 值类型：where T : struct
    /// 类型约束,必须是约束类型或其子类：where T : demoModel
    /// </summary>
    public class GenericConstraint
    {
        /// <summary>
        /// 限制只能传引用类型、有一个无参数构造函数的类型参数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="parameter"></param>
        public static T Show<T>(T parameter)
            where T : class,new()
        {
            T ret = default(T);
            Console.WriteLine("Show value={0}", ret);
            return ret;
        }
        /// <summary>
        /// 限制只能传值类型参数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="parameter"></param>
        public static T ShowStruct<T>(T parameter)
            where T : struct
        {
            T ret = default(T);
            Console.WriteLine("ShowStruct value={0}", ret);
            return ret;
        }
    }
    public class demoModel
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

调用：

        static void Main(string[] args)
        {
            int iParameter = 123;
            string sParemeter = "test";
            double dParameter = 345.67;
            //自己写具体类型方法，没性能损失，但要自己写这么多方法，重复的工作，浪费时间
            Common.ShowInt(iParameter);
            Common.ShowString(sParemeter);
            Common.ShowDouble(dParameter);
            Common.ShowObject(iParameter);//object是所有类型的父类，可以转换，有性能损失，实际开发中大多需要转换为具体类型，开发起来比较麻烦
            Common.ShowObject(iParameter);
            Common.ShowObject(iParameter);
            /*
            泛型调用
             */
            GenericClass.Show(iParameter);
            GenericClass.Show(sParemeter);
            GenericClass.Show(dParameter);
            //泛型约束，如果参数不满足要求，编译不会通过
            GenericConstraint.Show(new demoModel());
            GenericConstraint.ShowStruct(666);
            Console.ReadKey();
        }