10
2017
09

泛型使用和原理、泛型约束、应用

原理:

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

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


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();
        }




版权声明:
作者:真爱无限 出处:http://www.pukuimin.top 本文为博主原创文章版权归作者所有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文链接.
« 上一篇下一篇 »

相关文章:

评论列表:

发表评论:

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。