动态加载和使用类型

http://msdn.microsoft.com/zh-cn/library/k3a58006%28v=vs.90%29.aspx

反射提供语言编译器（如 Microsoft Visual Basic 2005 和 JScript）用于实现隐式后期绑定的基础结构。绑定是查找与唯一指定的类型相对应的声明（即实现）的过程。如果此过程是在运行时而不是在编译时发生，则称其为“后期绑定”。利用 Visual Basic 2005，可以在代码中使用隐式后期绑定；Visual Basic 编译器会调用一个帮助器方法，该方法使用反射来获取对象类型。传递给帮助器方法的参数有助于在运行时调用正确的方法。这些参数包括：对其调用方法的实例（对象），被调用方法的名称（字符串），以及传递给被调用方法的参数（对象数组）。

在下面的示例中，Visual Basic 编译器使用反射隐式地对其类型在编译时未知的对象调用方法。HelloWorld 类具有一个PrintHello 方法，它输出与传递给 PrintHello 方法的某些文本串联的“Hello World”。在此示例中调用的PrintHello 方法实际上是 Type.InvokeMember；Visual Basic 代码允许按照对象 (helloObj) 的类型在编译时已知（早期绑定）而不是在运行时已知（后期绑定）的方式来调用PrintHello 方法。

Imports SystemModule Hello    Sub Main()        ' Sets up the variable.        Dim helloObj As Object        ' Creates the object.        helloObj = new HelloWorld()        ' Invokes the print method as if it was early bound        ' even though it is really late bound.        helloObj.PrintHello("Visual Basic Late Bound")    End SubEnd Module

自定义绑定

---

除了由编译器隐式地用来进行后期绑定之外，反射还可以在代码中显式地用来完成后期绑定。

公共语言运行库支持多种编程语言，但这些语言的绑定规则各不相同。在早期绑定的情况下，代码生成器可以完全控制此绑定。但是，当通过反射进行后期绑定时，必须用自定义绑定来控制绑定。Binder 类提供了对成员选择和调用的自定义控制。

利用自定义绑定，您可以在运行时加载程序集，获取有关该程序集中类型的信息，然后对该类型调用方法或访问该类型的字段或属性。如果您在编译时（例如当对象类型依赖于用户输入时）不知道对象的类型，就可以使用这种方法。

下面的示例说明不提供参数类型转换的简单的自定义联编程序。Simple_Type.dll 的代码位于示例主体之前。确保生成Simple_Type.dll，然后在生成时在项目中包括对它的引用。

C#

VB

// Code for building SimpleType.dll.using System;namespace Simple_Type{    public class MySimpleClass    {        public void MyMethod(string str, int i)        {            Console.WriteLine("MyMethod parameters: {0}, {1}", str, i);        }        public void MyMethod(string str, int i, int j)        {            Console.WriteLine("MyMethod parameters: {0}, {1}, {2}",                 str, i, j);        }    }}using System;using System.Reflection;using System.Globalization;using Simple_Type;namespace Custom_Binder{    class MyMainClass    {        static void Main()        {            // Get the type of MySimpleClass.            Type myType = typeof(MySimpleClass);            // Get an instance of MySimpleClass.            MySimpleClass myInstance = new MySimpleClass();            MyCustomBinder myCustomBinder = new MyCustomBinder();            // Get the method information for the particular overload             // being sought.            MethodInfo myMethod = myType.GetMethod("MyMethod",                 BindingFlags.Public | BindingFlags.Instance,                myCustomBinder, new Type[] {typeof(string),                     typeof(int)}, null);            Console.WriteLine(myMethod.ToString());                        // Invoke the overload.            myType.InvokeMember("MyMethod", BindingFlags.InvokeMethod,                 myCustomBinder, myInstance,                     new Object[] {"Testing...", (int)32});        }    }    // ****************************************************    //  A simple custom binder that provides no    //  argument type conversion.    // ****************************************************    class MyCustomBinder : Binder    {        public override MethodBase BindToMethod(            BindingFlags bindingAttr,            MethodBase[] match,            ref object[] args,            ParameterModifier[] modifiers,            CultureInfo culture,            string[] names,            out object state)        {            if(match == null)                throw new ArgumentNullException("match");            // Arguments are not being reordered.            state = null;            // Find a parameter match and return the first method with            // parameters that match the request.            foreach(MethodBase mb in match)            {                ParameterInfo[] parameters = mb.GetParameters();                if(ParametersMatch(parameters, args))                    return mb;            }            return null;        }        public override FieldInfo BindToField(BindingFlags bindingAttr,             FieldInfo[] match, object value, CultureInfo culture)        {            if(match == null)                throw new ArgumentNullException("match");            foreach(FieldInfo fi in match)            {                if(fi.GetType() == value.GetType())                    return fi;            }            return null;        }        public override MethodBase SelectMethod(            BindingFlags bindingAttr,            MethodBase[] match,            Type[] types,            ParameterModifier[] modifiers)        {            if(match == null)                throw new ArgumentNullException("match");            // Find a parameter match and return the first method with            // parameters that match the request.            foreach(MethodBase mb in match)            {                ParameterInfo[] parameters = mb.GetParameters();                if(ParametersMatch(parameters, types))                    return mb;            }            return null;        }        public override PropertyInfo SelectProperty(            BindingFlags bindingAttr,            PropertyInfo[] match,            Type returnType,            Type[] indexes,            ParameterModifier[] modifiers)        {            if(match == null)                throw new ArgumentNullException("match");            foreach(PropertyInfo pi in match)            {                if(pi.GetType() == returnType &&                     ParametersMatch(pi.GetIndexParameters(), indexes))                    return pi;            }            return null;        }        public override object ChangeType(            object value,            Type myChangeType,            CultureInfo culture)        {            try            {                object newType;                newType = Convert.ChangeType(value, myChangeType);                return newType;            }            // Throw an InvalidCastException if the conversion cannot            // be done by the Convert.ChangeType method.            catch(InvalidCastException)            {                return null;            }        }        public override void ReorderArgumentArray(ref object[] args,             object state)        {            // No operation is needed here because BindToMethod does not            // reorder the args array. The most common implementation            // of this method is shown below.                        // ((BinderState)state).args.CopyTo(args, 0);        }        // Returns true only if the type of each object in a matches        // the type of each corresponding object in b.        private bool ParametersMatch(ParameterInfo[] a, object[] b)        {            if(a.Length != b.Length)                return false;            for(int i = 0; i < a.Length; i++)            {                if(a[i].ParameterType != b[i].GetType())                    return false;            }            return true;        }        // Returns true only if the type of each object in a matches        // the type of each corresponding entry in b.        private bool ParametersMatch(ParameterInfo[] a, Type[] b)        {            if(a.Length != b.Length)                return false;            for(int i = 0; i < a.Length; i++)            {                if(a[i].ParameterType != b[i])                    return false;            }            return true;        }    }}

InvokeMember 和 CreateInstance

使用 Type.InvokeMember 可调用类型的成员。各个类（如System.Activator 和 System.Reflection.Assembly）的 CreateInstance 方法是 InvokeMember 的特殊形式，它们可新建特定类型的实例。Binder 类用于在这些方法中进行重载决策和参数强制。

下面的示例显示参数强制（类型转换）和成员选择的三种可能的组合。在第 1 种情况中，不需要任何参数强制或成员选择。在第 2 种情况中，只需要成员选择。在第 3 种情况中，只需要参数强制。

C#

public class CustomBinderDriver{    public static void Main (string[] arguments)    {    Type t = typeof (CustomBinderDriver);    CustomBinder binder = new CustomBinder();    BindingFlags flags = BindingFlags.InvokeMethod|BindingFlags.Instance|        BindingFlags.Public|BindingFlags.Static;    // Case 1. Neither argument coercion nor member selection is needed.    args = new Object[] {};    t.InvokeMember ("PrintBob", flags, binder, null, args);    // Case 2. Only member selection is needed.    args = new Object[] {42};    t.InvokeMember ("PrintValue", flags, binder, null, args);    // Case 3. Only argument coercion is needed.    args = new Object[] {"5.5"};    t.InvokeMember ("PrintNumber", flags, binder, null, args);    }    public static void PrintBob ()    {        Console.WriteLine ("PrintBob");    }    public static void PrintValue (long value)    {        Console.WriteLine ("PrintValue ({0})", value);    }    public static void PrintValue (String value)    {        Console.WriteLine ("PrintValue\"{0}\")", value);    }       public static void PrintNumber (double value)    {        Console.WriteLine ("PrintNumber ({0})", value);    }}

当多个成员具有相同的名称时，将需要重载决策。Binder.BindToMethod 和Binder.BindToField 方法用于解析与单个成员的绑定。Binder.BindToMethod 还通过get 和 set 属性访问器提供了属性解析。

BindToMethod 返回要调用的 MethodBase；如果无法进行这种调用，则返回 null 引用（在 Visual Basic 中为Nothing）。虽然 MethodBase 返回值通常是 match 参数中所包含的值之一，但它并不必如此。

当存在 ByRef 参数时，调用方可能需要取回这些参数。因此，如果 BindToMethod 已经操作参数数组，Binder会允许客户端将参数数组映射回它的初始形式。为了实现这一目的，必须向调用方保证参数的顺序不会改变。当按名称传递参数时，Binder将重新排列参数数组，这就是调用方所见的参数。有关更多信息，请参见 Binder.ReorderArgumentArray。

可用成员集包括在类型和任何基类型中定义的成员。如果指定 BindingFlags.NonPublic，将返回该成员集中具有任何可访问性的成员。如果未指定 BindingFlags.NonPublic，联编程序就必须强制可访问性规则。当指定Public 或 NonPublic 绑定标志时，还必须指定 Instance 或Static 绑定标志，否则不会返回任何成员。

如果只有一个成员具有给定名称，则不必进行回调，而在该方法上进行绑定。代码示例的第 1 种情况说明了这一点：只有一个 PrintBob 方法可用，因此不需要进行回调。

如果可用集中有多个成员，所有这些方法都将传递给 BindToMethod，它将选择正确的方法并将其返回。在代码示例的第 2 种情况下，有两个名为PrintValue 的方法。对 BindToMethod 的调用将选择正确的方法。

ChangeType 执行参数强制转换（类型转换），以便将实参转换为选定方法的形参的类型。即使类型完全匹配，也会为每个参数调用ChangeType。

在代码示例的第 3 种情况下，将类型为 String 值为“5.5”的实参传递给了具有类型为 Double 的形参的方法。要使调用成功，必须将字符串值“5.5”转换为 double 值。ChangeType 会执行此转换。

ChangeType 仅执行无损或扩大强制，如下表所示。

源类型

目标类型

任何类型

它的基类型

任何类型

它所实现的接口

Char

UInt16、UInt32、Int32、UInt64、Int64、Single、Double

Byte

Char、UInt16、Int16、UInt32、Int32、UInt64、Int64、Single、Double

SByte

Int16、Int32、Int64、Single、Double

UInt16

UInt32、Int32、UInt64、Int64、Single、Double

Int16

Int32、Int64、Single、Double

UInt32

UInt64、Int64、Single、Double

Int32

Int64、Single、Double

UInt64

Single、Double

Int64

Single、Double

Single

Double

非引用类型

引用类型

Type 类具有Get 方法，这些方法使用 Binder 类型的参数来解析对特定成员的引用。Type.GetConstructor、Type.GetMethod 和 Type.GetProperty 通过为当前类型的特定成员提供签名信息来搜索该成员。对Binder.SelectMethod 和Binder.SelectProperty 进行回调以选择相应方法的给定签名信息。