C#基础之泛型

时间 2019-12-06

标签 c# 基础栏目 C# 繁體版

原文原文链接

1.泛型的本质安全

　　泛型的好处不用多说，在.NET中我看到有不少技术都是以泛型为基础的，不过由于不懂泛型而只能对那些技术一脸茫然。泛型主要用于集合类，最主要的缘由是它不须要装箱拆箱且类型安全，好比很经常使用的List<T>。对于List<T>我之后还想进行深究，如今我写了一个超简版的MyList<T>集合，以下面第一段代码所示。代码很简单，但在写的过程当中有一个细节，若是我为listInt赋值string类型的变量时编译器会提示报错。编译器很智能，可是从这个现象中你会不会好奇泛型中的T是在什么状况下指定的呢，是生成IL时仍是JIT动态编译时？老方法我将exe放入Reflector工具中，发现IL代码中全是T，这说明在编译时T仅仅只是一个占位符，真真的替换是在运行时动态替换的。但是在写泛型类时代码只有一份，那我为MyList建立int、string类型的对象时这个代码是如何公用的呢？对于值类型集合好比listInt，因为最终须要替换T，那么确定是有一份完整的代码里面T被替换为int。对于引用类型，由于变量只是一个指向堆中的指针，所以代码只有一份。总结起来就是值类型代码有多份而引用类型代码只有一份，另外编写自定义泛型代码时最好使用有意义的T，好比.net中常见的TResult表示返回值，这样可读性较好。ide

class Program
    {
        static void Main(string[] args)
        {
            MyList<int> listInt = new MyList<int>();
            MyList<string> listString = new MyList<string>();
            listInt.Add(24);
            listInt[1] = 5;
            listString[2] = "ha ha";
        }
    }

    public class MyList<T>
    {
        T[] array;
        int current = -1;
        public MyList()
        {
            array = new T[10];
        }

        public void Add(T t)
        {
            current++;
            if (current < 10)
                array[current] = t;
        }

        public T this[int index]
        {
            get
            {
                return array[index];
            }
            set
            {
                array[index] = value;
            }
        }
    }

View Code

2.泛型规范函数

　　这个很重要，主要包括约束和default。.NET是推荐咱们开发者尽量的多使用约束，由于约束越多越能够保证程序不会出错。泛型约束由where指定，六种约束以下所示。这些约束能够单独使用也能够一块儿使用，但也有不能一块儿使用的好比值类型与引用类型约束。关于default的做用咱们能够思考这样一个问题，若是在泛型类中咱们须要初始化一个T变量。由于T既有多是值类型也有多是引用类型，因此不能直接用new或等于0。那如何判断T是值类型仍是引用类型呢？这里就要用到default，对于引用类型default(T)将返回null，对于数值类型default(T)将返回0。这里之因此写数值类型是由于值类型还多是结构体，default会将结构体中的成员初始化为0或null。还有一种特殊状况就是可空值类型，此时将返回Nullable<T>，这样初始变量直接使用T t=default(T)就能够了。虽然泛型类给人带来了神秘感，不过运行时它的本质就是一个普通的类，所以依旧具备类的特性好比继承。这为咱们开发者带来了不少好处，好比我想要有一个int集合类，它除了有List<int>的功能外还有自定义的某些功能，这时候只需MyList : List<int>就能够获得想要的效果了，很是方便。工具

where T : struct 值类型约束，T必须为值类型。学习

where T：class 引用类型约束，T必须为引用类型。ui

where T：new() 构造器约束，T必须拥有公共无参构造函数且new()约束放在最后。this

where T：U 裸类型约束，T必须是U或派生自U。spa

where T：BaseClass 基类约束，T必须为BaseClass类或其子类。.net

where T：Interface 接口约束，T必须为指定的接口或其实现接口。3d

3.反射建立泛型

　　和非泛型类同样，利用反射能够在运行时获取关于泛型类的成员信息。在学习过程我没想到居然还可使用反射建立泛型类，更神奇的是还能够在代码里直接写IL指令，代码以下所示。流程上仍是那个规则，建立程序集-模块-类-字段和方法，其中最主要的就是Builder结尾的一系列方法。有一个很差理解的地方就是为方法添加方法体，正常的逻辑是直接调用ReturnType的有参构造函数建立List<TName1>对象，但是在.NET里并无这样的方法，注意这里ReturnType已是绑定了TName1的List对象而不是普通的List<T>。因此咱们须要拿到List<T>这个类型的有参构造函数，它被封装在cInfo对象里，而后再将咱们的ReturnType和cInfo关联起来获得List<TName1>的构造函数。除了构造函数中的T须要替换为TName1外，参数IEnumerable<T>中的T也要被替换为TName1，体如今代码里是这一句ienumOf.MakeGenericType(TFromListOf)，最后它将随构造函数一块儿与TName1进行关联。在建立Hello方法我将它设置为静态的，本来我是想设置为实例方法而后调试时去看看是否真的添加了这个方法，不过很奇怪我建立的实例o做为Invoke的参数老是报错提示没法找到方法入口，监视o发现里面根本没有Hello方法，在静态方法下调试也没有从o里看到有关方法的信息，若是读者你对此有本身的想法欢迎留言，若有错误还请指出。

    public class BaseClass { }
   public  interface IInterfaceA { }
    public interface IInterfaceB { }
    //做为TName1的类型参数
    public class ClassT1 { }
    //做为TName2的类型参数
    public class ClassT2 :BaseClass,IInterfaceA, IInterfaceB { }

    public class ReflectionT
    {
        public void CreateGeneric()
        {
            //建立一个名为”ReflectionT“的动态程序集，这个程序集能够执行和保存。
            AppDomain myDomain = AppDomain.CurrentDomain;
            AssemblyName assemblyName = new AssemblyName("ReflectionT");
            AssemblyBuilder assemblyBuilder = myDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave);

            //在这个程序集中建立一个与程序集名相同的模块，接着建立一个类MyClass。
            ModuleBuilder moudleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName.Name, assemblyName.Name + ".dll");
            TypeBuilder myType = moudleBuilder.DefineType("MyClass", TypeAttributes.Public);

            //建立类型参数名，将达到这样的效果：public MyClass<TParam1,TParam2>
            string[] tNames = { "TName1", "TName2" };
            GenericTypeParameterBuilder[] gtps = myType.DefineGenericParameters(tNames);
            GenericTypeParameterBuilder tName1 = gtps[0];
            GenericTypeParameterBuilder tName2 = gtps[1];

            //为泛型添加约束，TName1将会被添加构造器约束和引用类型约束
            tName1.SetGenericParameterAttributes(GenericParameterAttributes.DefaultConstructorConstraint | GenericParameterAttributes.ReferenceTypeConstraint);
            //TName2达到的效果将是：where TName2:ValueType,IComparable,IEnumerable
            Type baseType = typeof(BaseClass);
            Type interfaceA = typeof(IInterfaceA);
            Type interfaceB = typeof(IInterfaceA);
            Type[] interfaceTypes = { interfaceA, interfaceB };
            tName2.SetBaseTypeConstraint(baseType);
            tName2.SetInterfaceConstraints(interfaceTypes);

            /*为泛型类MyClass添加字段：
            private string name;
            public TName1 tField1;
             */
            FieldBuilder fieldBuilder = myType.DefineField("name", typeof(string), FieldAttributes.Public);
            FieldBuilder fieldBuilder2 = myType.DefineField("tField1", tName1, FieldAttributes.Public);
            

            //为泛型类添加方法Hello
            Type listType = typeof(List<>);
            Type ReturnType = listType.MakeGenericType(tName1);
            Type[] parameter = { tName1.MakeArrayType() };
            MethodBuilder methodBuilder = myType.DefineMethod(
                "Hello",                               //方法名
                MethodAttributes.Public | MethodAttributes.Static,    //指定方法的属性
                ReturnType,                        //方法的放回类型
                parameter);                         //方法的参数

            //为方法添加方法体
            Type ienumOf = typeof(IEnumerable<>);
            Type TFromListOf = listType.GetGenericArguments()[0];
            Type ienumOfT = ienumOf.MakeGenericType(TFromListOf);
            Type[] ctorArgs = { ienumOfT };
            ConstructorInfo cInfo = listType.GetConstructor(ctorArgs);
            //最终的目的是要调用List<TName1>的构造函数 : new List<TName1>(IEnumerable<TName1>);
            ConstructorInfo ctor = TypeBuilder.GetConstructor(ReturnType, cInfo);
            //设置IL指令
            ILGenerator msil = methodBuilder.GetILGenerator();
            msil.Emit(OpCodes.Ldarg_0);
            msil.Emit(OpCodes.Newobj, ctor);
            msil.Emit(OpCodes.Ret);
            //建立并保存程序集
            Type finished = myType.CreateType();
            assemblyBuilder.Save(assemblyName.Name + ".dll");

            //建立这个MyClass这个类
            Type[] typeArgs = { typeof(ClassT1), typeof(ClassT2) };
            Type constructed = finished.MakeGenericType(typeArgs);
            object o = Activator.CreateInstance(constructed);
            MethodInfo mi = constructed.GetMethod("Hello");
            ClassT1[] inputParameter = { new ClassT1(), new ClassT1() };
            object[] arguments = { inputParameter };
            List<ClassT1> listResult = (List<ClassT1>)mi.Invoke(null, arguments);
            //查看返回结果中的数量和彻底限定名
            Console.WriteLine(listResult.Count);
            Console.WriteLine(listResult[0].GetType().FullName);

            //查看类型参数以及约束
            foreach (Type t in finished.GetGenericArguments())
            {
                Console.WriteLine(t.ToString());
                foreach (Type c in t.GetGenericParameterConstraints())
                {
                    Console.WriteLine("  "+c.ToString());
                }
            }
        }
    }

View Code

4.泛型中的out和in

　　在VS查看IEnumerable<T>的定义时会看到在T前面有一个out，与其对应的还有一个in。这就是.NET中的协变与逆变，刚开始笔者对于这2个概念很晕，主要如下4个疑惑，我想若是你解决了的话应该也会有更进一步的认识。

1.为何须要协变和逆变，协变与逆变有什么效果？

2.为何有了协变与逆变就能够类型安全的进行转换，不加out和in就不能够转换？

3.使用协变和逆变须要注意什么？

4.协变与逆变为何只能用于接口和委托？

下面第一段代码解决了第一个问题。对于第二个问题请看第二段代码，里面对无out、in的泛型为何不安全讲得很清楚，从中咱们要注意到若是要当进行协变时Function2是彻底ok的，当进行逆变时Function1又是彻底ok的。因此加out只是让开发者在代码里没法使用in的功能，加in则是让开发者没法使用out的功能。读者能够本身动手试试，在out T的状况下做为输入参数将会报错，一样将in T做为返回参数也会报错，且VS报错时会直接告诉你这样只能在协变或逆变状况下使用。也就是说加了out后，只有Function2可以编译经过，这样o=str将不会受Function1的影响而不安全；加了in后，只有Function1可以编译经过，这样str=o将不会受Function2的影响而不安全。使用out和in要注意它们只能用于接口和委托，且不能做用于值类型。out用于属性时只能用于只读属性，in则是只写属性，进行协变和逆变时这2个类型参数必需要有继承关系，如今为何不能用于值类型你应该懂了吧。对于第四个疑惑我没有找到一个彻底正确的答案，只是发现了我认同的想法。接口和委托，有什么共同点？显然就是方法，在接口或委托中声明的T都将用于方法且只能用于方法，由上面的讨论可知协变和逆变这种状况正是适用于方法这样的成员。对于在抽象类中不可使用的缘由，或许微软是以为在抽象类中再搞一个仅限于方法的限制太麻烦了吧。

        public interface INone<T> { }
        public interface IOut<out T> { }
        public interface IIn<in T> { }
        public class MyClass<T> : INone<T>, IOut<T>, IIn<T> { }
        void hh()
        {
            INone<object> oBase1 = new MyClass<object>();
            INone<string> o1 = new MyClass<string>();
            //下面两句都没法编译经过
            //o1 = oBase1;
            //oBase1 = o1;
            
            //为了可以进行转换，因而出现了协变与逆变
            IOut<object> oBase2 = new MyClass<object>();
            IOut<string> o2 = new MyClass<string>();
            //o2 = oBase2;   编译不经过
            //有了out关键字的话，就能够实现从IOut<string>到IOut<object>的转换-往父类转换
            oBase2 = o2;

            IIn<object> oBase3 = new MyClass<object>();
            IIn<string> o3 = new MyClass<string>();
            //oBase3 = o3;   编译不经过
            //有了in关键字的话，就能够实现从IIn<object>到IOut<string>的转换-往子类转换
            o3 = oBase3;
        }

View Code

    public interface INone<T>
    {
        void Function1(T tParam);
        T Function2();
    }

    class MyClass<T> : INone<T>
    {
        public void Function1(T tParam)
        {
            Console.WriteLine(tParam.ToString());
        }

        public T Function2()
        {
            T t = default(T);
            return t;
        }
    }

    class hhh
    {
        void fangyz()
        {
            INone<object> o = new MyClass<object>();
            INone<string> str = new MyClass<string>();
            //假设str可以转换为o
            //o = str;
            object o1=new object();
            //这样的话就是object类型向string类型转换了，类型不安全
            o.Function1(o1);
            //这样则是string类型向object类型转换了，注意这样是ok的，没什么问题
            object o2=o.Function2();

            //假设str可以转换为o
            //str=o;
            //string对象将转变为object，这样没问题
            str.Function1("haha");
            //这样将是object向string类型的转换，类型不安全。
            string o3=str.Function2();
        }
    }

View Code

声明：本文原创发表于博客园，做者为方小白，若有错误欢迎指出。本文未经做者许可不准转载，不然视为侵权。