读书笔记_C#技术内幕_第二十八章（反射）

 

反射（reflection）是审查程序的元数据并收集关于它的类型信息的能力。使用反射就可以学习关于程序的配件、模块、和内部程序元素的所有类型。

反射对于设计工具特别有用。它基于使用的基础类型的元数据派生的用户选择，支持自动建立代码。反射也对后联编的框架提供出色的支持，其中运行环境要求迅速作出选择需要的库或其他功能的决定。

 

发现程序信息：

反射主要用来发现程序的信息。C#的反射的API可以找出关于程序的所有可用的信息。要搜索的程序元素包括配件、模块、类型和类型成员。

class Reflecting

    {

        static void Main(string[] args)

        {

            Reflecting reflect = new Reflecting();

 

            Assembly myAssembly = Assembly.LoadFrom("ConsoleApplication1.exe");

 

            reflect.GetReflectionInfo(myAssembly);

        }

 

        void GetReflectionInfo(Assembly myAssembly)

        {

            Type[] typeArr = myAssembly.GetTypes();

            foreach (Type type in typeArr)

            {

                Console.WriteLine("/nType: {0}/n", type.FullName);

 

                ConstructorInfo[] MyConstructors = type.GetConstructors();

                foreach (ConstructorInfo constructor in MyConstructors)

                {

                    Console.WriteLine("/tConstructor: {0}", constructor.ToString());

                }

                Console.WriteLine();

 

                FieldInfo[] MyFileds = type.GetFields();

                foreach (FieldInfo field in MyFileds)

                {

                    Console.WriteLine("/tFiled: {0}", field.ToString());

                }

                Console.WriteLine();

 

                MethodInfo[] MyMythods = type.GetMethods();

                foreach (MethodInfo method in MyMythods)

                {

                    Console.WriteLine("/tMethod: {0}", method.ToString());

                }

                Console.WriteLine();

 

                PropertyInfo[] MyProperties = type.GetProperties();

                foreach (PropertyInfo property in MyProperties)

                {

                    Console.WriteLine("/tProperty: {0}", property.ToString());

                }

                Console.WriteLine();

 

                EventInfo[] MyEvents = type.GetEvents();

                foreach (EventInfo anEvent in MyEvents)

                {

                    Console.WriteLine("/tEvent: {0}", anEvent.ToString());

                }

                Console.WriteLine();

            }

        }

    }

 

    public class Reflected

    {

        public int MyField;

        protected ArrayList myArray;

 

        public Reflected()

        {

            myArray = new ArrayList();

            myArray.Add("Some ArrayList Entry");

        }

 

        public float MyProperty

        {

            get { return MyEvent(); }

        }

 

        public object this[int index]

        {

            get

            {

                if (index < myArray.Count)

                {

                    return myArray[index];

                }

                else

                {

                    return null;

                }

            }

            set

            {

                myArray.Add(value);

            }

        }

 

        public float MyInstanceMethod()

        {

            Console.WriteLine("Invoke Instance MyMethod");

 

            return 0.02f;

        }

 

        public static float MyStaticMethod()

        {

            Console.WriteLine("Invoke Static MyMethod");

 

            return 0.02f;

        }

 

        public delegate float MyDelegate();

 

        public event MyDelegate MyEvent = new MyDelegate(MyStaticMethod);

 

        public enum MyEnum { valOne, valTwo, valThree };

    }

在上面的程序中，类Reflected通过反射的所有类型的类成员使类可用。

在Main方法中，通过调用Assembly类的静态LoadFrom方法获得一个assembly对象。在GetReflectionInfo方法内，Assembly对象——myAssembly调用他的GetType方法以获得在配件中可用的所有类型的数组。

 

Assembly类型有一个GetModules方法，该方法将获取配件内的模块的数组。从每个模块，可以使用GetTypes来获取要使用的数组类型。简而言之，上面的程序使用了Assembly类型的GetTypes方法来获取属于那个配件的所有模块的所有类型。

 

可以得到的类型包括：构造函数，字段，方法，特性（包括索引器），事件。但是这些类型必须都是public的

 

动态地激活代码：

动态的代码激活是决定运行时刻执行什么代码。这个能力在许多情况下是有用的，其中需要后联编框架。

考虑简单对象访问协议（SOAP）规范，其中传输协议是独立的。虽然SOAP通常与HTTP协议一块使用，建立规范本身是为了在其它协议上实现，例如，简单消息传输协议（SMTP）。使用适当的接口，动态链接库（Dynamic Link Libraries，DLL）能够被构造以便从基础协议中分离SOAP的实现。另外，通过后联编的实现，具有打包到自己的DLL中的适当接口的新协议，也能够在任何时间添加到框架中，而不必重新编译代码。通过协助决定在运行时刻SOAP包中使用什么传输协议，反射的后联编能力能够启用这个方案。下面的例子展示了运行时刻中指定的配件中，怎样通过动态地激活代码来执行后联编操作。

class Reflecting

    {

        static void Main(string[] args)

        {

            Reflecting reflect = new Reflecting();

 

            Assembly myAssembly = Assembly.LoadFrom("ConsoleApplication1.exe");

 

            reflect.DynamicallyInvokeMembers(myAssembly);

        }

 

        void DynamicallyInvokeMembers(Assembly myAssembly)

        {

            Type classType = myAssembly.GetType("ConsoleApplication1.Reflected");

 

            PropertyInfo myProperty = classType.GetProperty("MyProperty");

 

            MethodInfo propGet = myProperty.GetGetMethod();

 

            object reflectedObject = Activator.CreateInstance(classType);

 

            propGet.Invoke(reflectedObject, null);

 

            MethodInfo myMethod = classType.GetMethod("MyInstanceMethod");

 

            myMethod.Invoke(reflectedObject, null);

        }

}

下面是它的输出：

Invoking Static MyMethod.

Invoking Instance MyMethod.

 

DynamicallyInvokeMembers()方法使用Assembly对象Reflected类获得了Type对象。然后，Type对象用于获得MyProperty特性。其次，通过调用PropertyInfo对象的GetGetMethod()方法来获得MethodInfo对象。GetGetMethod()检索特性的get方法的拷贝，这是为了进行反射，像方法一样地对待。

借助GetGetMethod()和GetSetMethod()调用，索引器的get和set访问器可以像特性的get和set访问器一样的获得。

Reflected类是通过使用Activator.CreateInstance()方法实例化的。然后，实例化的对象就作为MethodInfo对象的Invoke()方法的第一个参数。这就标识了哪个对象要调用该方法。Invoke()方法的第二个参数是要发送到方法的参数列表，如果有参数它就会是对象的数组。在这种情况下，没有参数发送到方法，因此Invoke()方法的第二个参数设置为null。

接下来两行展示了怎样动态的调用实例方法。该语法与特性的get访问器的说明一样。然而，用于特性的中间步骤是不必要的，并且用Type对象的GetMethod()方法能够直接获得方法。

Reflection.Emit的API提供了动态地创建新的配件的手段。使用自定义的生成器（builder）并生成Microsoft的中间语言（Microsoft Intermediate Language，MSIL）或者通用中间语言（Common Intermediate Language，CIL）代码，可使程序在运行时创建新的程序。这些配件可以被动态地调用或者保存到文件，在那里它们可以被重新加载和调用，或者被其他程序使用。

对于编译器或脚本引擎的后端工具，例如Web浏览器，动态配件的创建是非常有用的。使用Reflection.Emit的API，任何工具都可以扩展为动态的支持.NET或任何其它的通用语言基础结构（Common Language Infrastructure，CLI）适用系统。下面的程序展示了怎样生成动态配件，并把它保存为控制台程序。

static void Main(string[] args)

        {

            AppDomain myAppDomain = AppDomain.CurrentDomain;

            AssemblyName myAssemblyName = new AssemblyName();

            myAssemblyName.Name = "DynamicAssembly";

 

            AssemblyBuilder myAssemblyBuilder = myAppDomain.DefineDynamicAssembly(myAssemblyName, AssemblyBuilderAccess.RunAndSave);

 

            ModuleBuilder myModuleBuilder = myAssemblyBuilder.DefineDynamicModule("DynamicModule", "emitter.netmodule");

 

            TypeBuilder myTypeBuilder = myModuleBuilder.DefineType("EmitTestClass");

 

            MethodBuilder myMethodBuilder = myTypeBuilder.DefineMethod("Main", MethodAttributes.Public | MethodAttributes.Static, null, null);

 

            ILGenerator myILGenerator = myMethodBuilder.GetILGenerator();

            myILGenerator.EmitWriteLine("/n/tI must emit, reflection is pretty cool!/n");

            myILGenerator.Emit(OpCodes.Ret);

 

            Type myType = myTypeBuilder.CreateType();

            object myObjectInstance = Activator.CreateInstance(myType);

 

            Console.WriteLine("/nDynamic Invocation:");

 

            MethodInfo myMethod = myType.GetMethod("Main");

            myMethod.Invoke(myObjectInstance, null);

 

            myAssemblyBuilder.SetEntryPoint(myMethod);

            myAssemblyBuilder.Save("emitter.exe");

        }

这部分内容还是不太明白。