《CLR via C#》读书笔记 之 程序集加载和反射 明

第二十三章 程序集加载和反射

2013-04-06

23.1 程序集加载
23.2 使用反射构建动态可扩展应用程序
23.3 反射的性能 
  23.3.1 发现程序集中定义的类型
  23.3.2 类型对象的准确含义
  23.3.3 构建Exception派生类型的一个层次结构
  23.3.4 构造类型的实例
23.4 设计支持加载项的应用程序
23.5 使用反射发现类型的成员
  23.5.2 BindingFlags： 帅选返回的成员类型
  23.5.3 发现类型的接口
  23.5.4 调用类型的成员
  23.5.5 一次绑定，多次调用

23.1 程序集加载

---

返回

我们知道，JIT编译器将方法的IL代码编译成本地代码时，会查看IL代码中引用了哪些类型。在运行时，会利用程序集的TypeRef和AssemblyRef元数据表来确定哪一个程序集定义了所有引用类型。

在内部，CLR使用System.Reflection.Assembly类的静态方法Load来加载这个程序集。这个方法是CLR中与Win32 LoadLibrary函数等价的方法。以下是Load方法的几个重载版本：

public class Assembly
{
  public static Assembly Load(AssemblyName assemblyRef);
  public static Assembly Load(String assemblyString);
}

Load导致CLR向程序集应用一个版本绑定重定向策略，并在GAC（全局程序集缓存）中查看程序集。如果没找到，就去应用程序的基目录、私有路径子目录和codebase（参考3.9 高级管理控制）位置查找。如果调用Load时，传递的是一个弱命名的程序集，Load就不会向程序集应用一个版本绑定重定向策略，也不会去GAC中查找程序集。

在内部，CLR使用System.Reflection.Assembly类的另一个静态方法LoadFrom

public class Assembly
{
  public static Assembly LoadFrom(String path);
}

LoadFrom首先会调用System.Reflection.AssemblyName类的静态方法GetAssemblyName。该方法打开指定的文件，查找AssemblyRef元数据表的记录项，提取程序集标识信息，然后返回一个System.Reflection.AssemblyName对象。随后在LoadFrom内部调用上面的Load方法。若能找到，加载；若不能，用实参传递的路径加载程序集。

另外，LoadFrom方法允许传递一个URL作为实参

Assembly a=Assembly.LoadFrom(@"http://Wintellect.com/SomeAssembly.dll");

上面代码，CLR会下载文件，将他安装到用户的下载缓存中，再从那儿下载。

C#反射-Assembly.Load、LoadFrom与LoadFile进阶

23.2 使用反射构建动态可扩展应用程序 

---

 返回

元数据是用一系列表来存储的。生成一个程序集或模块时，编译器会创建一个类型定义表、一个字段定义表、一个方法定义表及其他表。利用System.Reflection命名空间中包含的一些类型，可以写代码来反射（或者说”解析“）这些元数据表。

23.3 反射的性能 

---

 返回

 反射是相当强大的一个机制，它允许在运行时发现并使用编译器还不了解的类型及其成员。但是，它有以下两个缺点：

• 反射回造成编译时无法保证 类型安全性。由于反射严重依赖字符串，所以会丧失编译时类型安全性。如代码 Type.GetType("Jef"); 要求反射在程序集中查找一名为”Jef“的类型，但程序集中实际包含的是”Jeff“，代码编译时可通过，但运行时会出错。
• 反射速度慢。使用反射式，要用字符串标识每个类型及其成员，需要用它们来扫描程序集的元数据。用反射调用一个方法时，首先必须将参数打包成数组，再次将解包数组到线程栈上，此外，还要检验实参数据类型是否正确，最后，要确保调用者有安全权限调用被调用着。

基于上述原因，推荐用接口技术或基类技术代替反射：

• 让类型从一个编译时已知的基类型派生。在运行时，构造派生类型的一个实例，将对它的引用放到基类的一个变量中（利用转型），再调用基类型定义的虚方法。
• 让类型实现一个编译时已知的接口。将对它的引用放到接口的一个变量中（利用转型），再调用接口定义的方法。

在使用这两种技术时，强烈建议在接口或基类型自己的程序集中定义它们，这有助于缓解版本控制的问题。欲知详情，请参见23.4节

23.3.1 发现程序集中定义的类型

internal static class DiscoverTypes {
   public static void Go() {
      String dataAssembly = "System.Data, version=4.0.0.0, " +
         "culture=neutral, PublicKeyToken=b77a5c561934e089";
      LoadAssemAndShowPublicTypes(dataAssembly);
   }

   private static void LoadAssemAndShowPublicTypes(String assemId) {
      // Explicitly load an assembly in to this AppDomain
      Assembly a = Assembly.Load(assemId);

      // Execute this loop once for each Type 
      // publicly-exported from the loaded assembly 
      foreach (Type t in a.GetExportedTypes()) {
         Console.WriteLine(t.FullName);
      }
   }
}

23.3.2 类型对象的准确含义

一个类型在一个AppDomain1中被首次访问时，CLR会构造System.RuntimeType的一个实例，并初始化这个对象的字段，以反映这个类型的信息。我们知道，System.Object定义了一个公共非虚实例方法GetType。调用这个方法是，CLR会判断指定对象的类型，并返回对它的RuntimeType对象的一个引用。由于在一个AppDomain中，每个类型只有一个RuntimeType对象（类型对象，参考4.4 运行时相互关系）。

除了Object的GetType，FCL还提供了获得Type对象的其它方式：

• System.Type类型提供了静态方法GetType的几个重载版本。这个方法所有版本都接受一个String参数（指定类型的全名）。调用时，它首先会检查调用程序集是否有该类型，有，则返回一个恰当的RunTimeType对象的引用；没有，则检查MSCorLib.dll；再没有，返回null或System.TypeLoadException。
• C#还提供操作符typeof来获得对一个类型的引用，通常可用它来将晚期绑定的类型信息与早期绑定（编译时已知）的类型信息比较，如下代码：

private static void SomeMethod(Object o)
{
    //GetType方法在运行时返回对象的类型（晚期绑定）
    //typeof方法返回指定类的类型（早期绑定）
    if(o.GetType()==typeof(FileInfo)){...}
    if(o.GetType()==typeof(DirecotryInfo)){...}
}

23.3.3 构建Exception派生类型的一个层次结构

   public static void Go() {
      // Explicitly load the assemblies that we want to reflect over
      Assembly[] assemblies= LoadAssemblies();

      // Recursively build the class hierarchy as a hyphen-separated string
      Func<Type, String> ClassNameAndBase = null;
      ClassNameAndBase = t => "-" + t.FullName +
          ((t.BaseType != typeof(Object)) ? ClassNameAndBase(t.BaseType) : String.Empty);

      // Define our query to find all the public Exception-derived types in this AppDomain's assemblies
      var exceptionTree =
          (from a in assemblies
           from t in a.GetExportedTypes()
           where t.IsClass && t.IsPublic && typeof(Exception).IsAssignableFrom(t)
           let typeHierarchyTemp = ClassNameAndBase(t).Split('-').Reverse().ToArray()
           let typeHierarchy = String.Join("-", typeHierarchyTemp, 0, typeHierarchyTemp.Length - 1)
           orderby typeHierarchy
           select typeHierarchy).ToArray();

      // Display the Exception tree
      Console.WriteLine("{0} Exception types found.", exceptionTree.Length);
      foreach (String s in exceptionTree) {
         // For this Exception type, split its base types apart
         String[] x = s.Split('-');

         // Indent based on # of base types and show the most-derived type
         Console.WriteLine(new String(' ', 3 * (x.Length - 1)) + x[x.Length - 1]);
      }
   }


   private static Assembly[]  LoadAssemblies() {
      String[] assemblies = {
            "System,                    PublicKeyToken={0}",
            "System.Core,               PublicKeyToken={0}",
            "System.Data,               PublicKeyToken={0}",
            "System.Design,             PublicKeyToken={1}",
            "System.DirectoryServices,  PublicKeyToken={1}",
            "System.Drawing,            PublicKeyToken={1}",
            "System.Drawing.Design,     PublicKeyToken={1}",
            "System.Management,         PublicKeyToken={1}",
            "System.Messaging,          PublicKeyToken={1}",
            "System.Runtime.Remoting,   PublicKeyToken={0}",
            "System.Security,           PublicKeyToken={1}",
            "System.ServiceProcess,     PublicKeyToken={1}",
            "System.Web,                PublicKeyToken={1}",
            "System.Web.RegularExpressions, PublicKeyToken={1}",
            "System.Web.Services,       PublicKeyToken={1}",
            "System.Windows.Forms,      PublicKeyToken={0}",
            "System.Xml,                PublicKeyToken={0}",
         };

      String EcmaPublicKeyToken = "b77a5c561934e089";
      String MSPublicKeyToken = "b03f5f7f11d50a3a";

      // Get the version of the assembly containing System.Object
      // We'll assume the same version for all the other assemblies
      Version version = typeof(System.Object).Assembly.GetName().Version;

      List<Assembly> lassems = new List<Assembly>();

      // Explicitly load the assemblies that we want to reflect over
      foreach (String a in assemblies) 
      {
         String AssemblyIdentity =
            String.Format(a, EcmaPublicKeyToken, MSPublicKeyToken) +
               ", Culture=neutral, Version=" + version;
         lassems.Add(Assembly.Load(AssemblyIdentity));          
      }
      return lassems.ToArray();
   }

23.3.4 构造类型的实例

System.Acitivator的静态方法CreateInstance ，调用该方法可构造类型的实例（除了数组和委托）。数组调用Array的静态方法CreateInstance；委托调用Delegate的静态方法CreateDelegate。

23.4 设计支持加载项的应用程序

---

 返回

构建可扩展的应用程序时，接口是中心。可用基类来代替接口，但接口通常是首选的，因为它允许加载项开发人员选择他们自己的基类。下面描述如何设计加载项应用程序：

• 创建一个“宿主SDK（Host SDK），它定义一个接口，接口的方法作为宿主应用程序域加载项之间的通信机制。一旦搞定接口，可为这个程序集赋予一个强名称（参见第3章），然后打包并部署到合作伙伴那里。一旦发布，就要避免对该程序集中类型做任何重大修改，例如，接口。但对参数或返回值定义了自己的数据类型，可添加。对程序集的任何修改，可能需要使用一个发布策略来部署它（参见第3章）。
• 加载项实现上面“宿主SDK”定义的接口。
• 宿主应用程序通过”宿主SDK“的接口来调用加载项的实现。

代码如下：

1）”宿主SDK“程序集HostSDK.dll代码：

using System;

namespace Wintellect.HostSDK {
   public interface IAddIn {
      String DoSomething(Int32 x);
   }
}

2）加载项AddInTypes.dll引用并实现HostSDK定义的接口，代码如下:

using System;
using Wintellect.HostSDK;

public class AddIn_A : IAddIn {
   public AddIn_A() {
   }
   public String DoSomething(Int32 x) {
      return "AddIn_A: " + x.ToString();
   }
}

public class AddIn_B : IAddIn {
   public AddIn_B() {
   }
   public String DoSomething(Int32 x) {
      return "AddIn_B: " + (x * 2).ToString();
   }
}

3）宿主应用程序Host.exe引用HostSDK.dll，并动态加载加载项AddInType.dll。为了简化代码，假定加载项已部署到宿主的exe文件相同的目录。强烈建议研究一下Microsoft的MEF（托管可扩展性框架：Managed Extensiblity Framework）。

using System;
using System.IO;
using System.Reflection;
using System.Collections.Generic;
using Wintellect.HostSDK;

public sealed class Program {
   public static void Main() {
      // Find the directory that contains the Host exe
      String AddInDir = Path.GetDirectoryName(
         Assembly.GetEntryAssembly().Location);

      // Assume AddIn assemblies are in same directory as host's EXE file
      String[] AddInAssemblies = Directory.GetFiles(AddInDir, "*.dll");

      // Create a collection of usable Add-In Types
      List<Type> AddInTypes = new List<Type>();

      // Load Add-In assemblies; discover which types are usable by the host
      foreach (String file in AddInAssemblies) {
         Assembly AddInAssembly = Assembly.LoadFrom(file);

         // Examine each publicly-exported type
         foreach (Type t in AddInAssembly.GetExportedTypes()) {
            // If the type is a class that implements the IAddIn 
            // interface, then the type is usable by the host
            if (t.IsClass && typeof(IAddIn).IsAssignableFrom(t)) {
               AddInTypes.Add(t);
            }
         }
      }

      // Initialization complete: the host has discovered the usable Add-Ins

      // Here's how the host can construct Add-In objects and use them
      foreach (Type t in AddInTypes) {
         IAddIn ai = (IAddIn) Activator.CreateInstance(t);
         Console.WriteLine(ai.DoSomething(5));
      }
   }
}

23.5 使用反射发现类型的成员

返回

图1 封装了类型成员的反射类型的层次结构 

 以下程序演示了如何查询一个类型的成员与它们相关的一些信息。

using System;
using System.Reflection;

internal static class Program
{
   public static void Main() 
   {
      // Loop through all assemblies loaded in this AppDomain
      Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
      foreach (Assembly a in assemblies) 
      {
         Show(0, "Assembly: {0}", a);

         // Find Types in the assembly
         foreach (Type t in a.GetExportedTypes()) 
         {
            Show(1, "Type: {0}", t);

            // Indicate the kinds of members we want to discover
            const BindingFlags bf = BindingFlags.DeclaredOnly |
               BindingFlags.NonPublic | BindingFlags.Public |
               BindingFlags.Instance | BindingFlags.Static;

            // Discover the type's members
            foreach (MemberInfo mi in t.GetMembers(bf)) 
            {
               String typeName = String.Empty;
               if (mi is Type)            typeName = "(Nested) Type";
               if (mi is FieldInfo)       typeName = "FieldInfo";
               if (mi is MethodInfo)      typeName = "MethodInfo";
               if (mi is ConstructorInfo) typeName = "ConstructoInfo";
               if (mi is PropertyInfo)    typeName = "PropertyInfo";
               if (mi is EventInfo)       typeName = "EventInfo";

               Show(2, "{0}: {1}", typeName, mi);
            }
         }
      }
   }

   private static void Show(Int32 indent, String format, params Object[] args) 
   {
      Console.WriteLine(new String(' ', 3 * indent) + format, args);
   }
}

Type除了GetMembers方法返回类型的所有成员外，还提供了一些方法能返回特定的类型成员：GetnestedTypes，GetFields，GetConstructors，GetMethods，GetProperties以及GetEvents方法 。

23.5.2 BindingFlags： 筛选返回的成员类型

默认设置时BindingFlags.Public|BindingFlag.Instance|BindingFlags.Static。

23.5.3 发现类型的接口

为获得类型继承的接口，可调用type类型的FindInterfaces或GetInterfaces方法。这些方法返回接口的type对象。注意：这些方法扫描类型的继承层次结构，并返回在指定类型及其所有基类型上定义的所有接口。

判定一个类型那些成员实现了那个特定接口有点复杂，因为多个接口可能定义同一个方法。为获得特定接口的MethodInfo对象，可调用GetInterfaceMap实例方法，它返回System.Reflection.InterfaceMapping的一个实例，它定义了四个字段，见如下实例：

using System;
using System.Reflection;

internal static class InterfaceDiscover
{
   // Define two interfaces for testing
   private interface IBookRetailer : IDisposable {
      void Purchase();
      void ApplyDiscount();
   }

   private interface IMusicRetailer {
      void Purchase();
   }

   // This class implements 2 interfaces defined by this assembly and 1 interface defined by another assembly
   private sealed class MyRetailer : IBookRetailer, IMusicRetailer, IDisposable {
      // IBookRetailer methods
      void IBookRetailer.Purchase() { }
      public void ApplyDiscount() { }

      // IMusicRetailer method
      void IMusicRetailer.Purchase() { }

      // IDisposable method
      public void Dispose() { }

      // MyRetailer method (not an interface method)
      public void Purchase() { }
   }

   public static void Go() {
      // Find interfaces implemented by MyRetailer where the interface is defined in our own assembly.
      // This is accomplished using a delegate to a filter method that we pass to FindInterfaces.
      Type t = typeof(MyRetailer);
      Type[] interfaces = t.FindInterfaces(TypeFilter, typeof(InterfaceDiscover).Assembly);
      Console.WriteLine("MyRetailer implements the following interfaces (defined in this assembly):\n");

      // Show information about each interface
      foreach (Type i in interfaces) {
         InterfaceMapping map = t.GetInterfaceMap(i);
         Console.WriteLine("  Interface '{0}' is implemented by class '{1}'", map.InterfaceType, map.TargetType);

         for (Int32 m = 0; m < map.InterfaceMethods.Length; m++) {
            // Display the interface method name and which type method implements the interface method.
            Console.WriteLine("    {0} is implemented by {1}",
               map.InterfaceMethods[m], map.TargetMethods[m]);
         }
      }
   }

   // Returns true if type matches filter criteria
   private static Boolean TypeFilter(Type t, Object filterCriteria) {
      // Return true if the interface is defined in the same assembly identified by filterCriteria
      return t.Assembly == (Assembly)filterCriteria;
   }
}

结果：

 23.5.4 调用类型的成员

发现类型成员后，你可能想调用其中一个成员。”调用“（invoke）的含义取决于调用成员的种类。如下表所示：

成员类型	用于调用成员的方法
FieldInfo	调用GetValue获取字段的值 调用SetValue设置字段的值
PropertyInfo	调用GetValue调用属性的get访问器方法 调用SetValue调用属性的set访问器方法
EventInfo	调用AddEventHandler调用事件的add访问器方法 调用RemoveEventHandler调用事件的remove访问器方法
ConstructorInfo	调用Invoke构造类型的一个实例，并调用一个构造器
MethodInfo	调用Invoke调用类型的一个方法

Type 的 InvokeMember() 实例方法，可通过它调用一个成员。 该方法会执行两个操作：

1）绑定成员：选择要调用的一个恰当的成员

2）调用：实际调用成员

23.5.5 一次绑定，多次调用

Type的InvokeMember实例方法，通过内在的绑定和调用两步操作实现成员的调用。为了提高性能，可以实现一次绑定，多次调用。 看如下代码：

using System;
using System.Reflection;
using Microsoft.CSharp.RuntimeBinder;

internal static class Invoker {
   // This class is used to demonstrate reflection
   // It has a field, constructor, method, property, and an event
   private sealed class SomeType {
      private Int32 m_someField;
      public SomeType(ref Int32 x) { x *= 2; }
      public override String ToString() { return m_someField.ToString(); }
      public Int32 SomeProp {
         get { return m_someField; }
         set {
            if (value < 1) throw new ArgumentOutOfRangeException("value", "value must be > 0");
            m_someField = value;
         }
      }
      public event EventHandler SomeEvent;
      private void NoCompilerWarnings() {
         SomeEvent.ToString();
      }
   }

   private const BindingFlags c_bf = BindingFlags.DeclaredOnly | BindingFlags.Public |
      BindingFlags.NonPublic | BindingFlags.Instance;

   public static void Go() {
      Type t = typeof(SomeType);
       //演示如何利用Type的InvokeMember来绑定并调用一个成员
      UseInvokeMemberToBindAndInvokeTheMember(t);
      Console.WriteLine();
       //演示绑定到一个成员然后调用它。适用于一次绑定，多次调用
      BindToMemberThenInvokeTheMember(t);
      Console.WriteLine();
       //演示绑定到一个成员，然后创建一个委托来引用该成员，通过委托调用之。速度比上一个更快
      BindToMemberCreateDelegateToMemberThenInvokeTheMember(t);
      Console.WriteLine();
       //演示使用C#的dynamic基本类型来简化访问成员时使用语法。
      UseDynamicToBindAndInvokeTheMember(t);
      Console.WriteLine();
   }

   private static void UseInvokeMemberToBindAndInvokeTheMember(Type t) {
      Console.WriteLine("UseInvokeMemberToBindAndInvokeTheMember");

      // Construct an instance of the Type
      Object[] args = new Object[] { 12 };  // Constructor arguments
      Console.WriteLine("x before constructor called: " + args[0]);
      Object obj = t.InvokeMember(null, c_bf | BindingFlags.CreateInstance, null, null, args);
      Console.WriteLine("Type: " + obj.GetType().ToString());
      Console.WriteLine("x after constructor returns: " + args[0]);

      // Read and write to a field
      t.InvokeMember("m_someField", c_bf | BindingFlags.SetField, null, obj, new Object[] { 5 });
      Int32 v = (Int32)t.InvokeMember("m_someField", c_bf | BindingFlags.GetField, null, obj, null);
      Console.WriteLine("someField: " + v);

      // Call a method
      String s = (String)t.InvokeMember("ToString", c_bf | BindingFlags.InvokeMethod, null, obj, null);
      Console.WriteLine("ToString: " + s);

      // Read and write a property
      try {
         t.InvokeMember("SomeProp", c_bf | BindingFlags.SetProperty, null, obj, new Object[] { 0 });
      }
      catch (TargetInvocationException e) {
         if (e.InnerException.GetType() != typeof(ArgumentOutOfRangeException)) throw;
         Console.WriteLine("Property set catch.");
      }
      t.InvokeMember("SomeProp", c_bf | BindingFlags.SetProperty, null, obj, new Object[] { 2 });
      v = (Int32)t.InvokeMember("SomeProp", c_bf | BindingFlags.GetProperty, null, obj, null);
      Console.WriteLine("SomeProp: " + v);

      // Add and remove a delegate from the event by invoking the event抯 add/remove methods
      EventHandler eh = new EventHandler(EventCallback);
      t.InvokeMember("add_SomeEvent", c_bf | BindingFlags.InvokeMethod, null, obj, new Object[] { eh });
      t.InvokeMember("remove_SomeEvent", c_bf | BindingFlags.InvokeMethod, null, obj, new Object[] { eh });
   }

   private static void BindToMemberThenInvokeTheMember(Type t) {
      Console.WriteLine("BindToMemberThenInvokeTheMember");

      // Construct an instance
      // ConstructorInfo ctor = t.GetConstructor(new Type[] { Type.GetType("System.Int32&") });
      ConstructorInfo ctor = t.GetConstructor(new Type[] { typeof(Int32).MakeByRefType() });
      Object[] args = new Object[] { 12 };  // Constructor arguments
      Console.WriteLine("x before constructor called: " + args[0]);
      Object obj = ctor.Invoke(args);
      Console.WriteLine("Type: " + obj.GetType().ToString());
      Console.WriteLine("x after constructor returns: " + args[0]);

      // Read and write to a field
      FieldInfo fi = obj.GetType().GetField("m_someField", c_bf);
      fi.SetValue(obj, 33);
      Console.WriteLine("someField: " + fi.GetValue(obj));

      // Call a method
      MethodInfo mi = obj.GetType().GetMethod("ToString", c_bf);
      String s = (String)mi.Invoke(obj, null);
      Console.WriteLine("ToString: " + s);

      // Read and write a property
      PropertyInfo pi = obj.GetType().GetProperty("SomeProp", typeof(Int32));
      try {
         pi.SetValue(obj, 0, null);
      }
      catch (TargetInvocationException e) {
         if (e.InnerException.GetType() != typeof(ArgumentOutOfRangeException)) throw;
         Console.WriteLine("Property set catch.");
      }
      pi.SetValue(obj, 2, null);
      Console.WriteLine("SomeProp: " + pi.GetValue(obj, null));

      // Add and remove a delegate from the event
      EventInfo ei = obj.GetType().GetEvent("SomeEvent", c_bf);
      EventHandler eh = new EventHandler(EventCallback); // See ei.EventHandlerType
      ei.AddEventHandler(obj, eh);
      ei.RemoveEventHandler(obj, eh);
   }

   private static void BindToMemberCreateDelegateToMemberThenInvokeTheMember(Type t) {
      Console.WriteLine("BindToMemberCreateDelegateToMemberThenInvokeTheMember");

      // Construct an instance (You can't create a delegate to a constructor)
      Object[] args = new Object[] { 12 };  // Constructor arguments
      Console.WriteLine("x before constructor called: " + args[0]);
      Object obj = Activator.CreateInstance(t, args);
      Console.WriteLine("Type: " + obj.GetType().ToString());
      Console.WriteLine("x after constructor returns: " + args[0]);

      // NOTE: You can't create a delegate to a field

      // Call a method
      MethodInfo mi = obj.GetType().GetMethod("ToString", c_bf);
      var toString = (Func<String>) Delegate.CreateDelegate(typeof(Func<String>), obj, mi);
      String s = toString();
      Console.WriteLine("ToString: " + s);

      // Read and write a property
      PropertyInfo pi = obj.GetType().GetProperty("SomeProp", typeof(Int32));
      var setSomeProp = (Action<Int32>)Delegate.CreateDelegate(typeof(Action<Int32>), obj, pi.GetSetMethod());
      try {
         setSomeProp(0);
      }
      catch (ArgumentOutOfRangeException) {
         Console.WriteLine("Property set catch.");
      }
      setSomeProp(2);
      var getSomeProp = (Func<Int32>)Delegate.CreateDelegate(typeof(Func<Int32>), obj, pi.GetGetMethod());
      Console.WriteLine("SomeProp: " + getSomeProp());

      // Add and remove a delegate from the event
      EventInfo ei = obj.GetType().GetEvent("SomeEvent", c_bf);
      var addSomeEvent = (Action<EventHandler>)Delegate.CreateDelegate(typeof(Action<EventHandler>), obj, ei.GetAddMethod());
      addSomeEvent(EventCallback);
      var removeSomeEvent = (Action<EventHandler>)Delegate.CreateDelegate(typeof(Action<EventHandler>), obj, ei.GetRemoveMethod());
      removeSomeEvent(EventCallback);   
   }

   private static void UseDynamicToBindAndInvokeTheMember(Type t) {
      Console.WriteLine("UseDynamicToBindAndInvokeTheMember");

      // Construct an instance (You can't create a delegate to a constructor)
      Object[] args = new Object[] { 12 };  // Constructor arguments
      Console.WriteLine("x before constructor called: " + args[0]);
      dynamic obj = Activator.CreateInstance(t, args);
      Console.WriteLine("Type: " + obj.GetType().ToString());
      Console.WriteLine("x after constructor returns: " + args[0]);

      // Read and write to a field 
      try {
         obj.m_someField = 5;
         Int32 v = (Int32)obj.m_someField;
         Console.WriteLine("someField: " + v);
      }
      catch (RuntimeBinderException e) {
         // We get here because the field is private
         Console.WriteLine("Failed to access field: " + e.Message);
      }

      // Call a method
      String s = (String)obj.ToString();
      Console.WriteLine("ToString: " + s);

      // Read and write a property
      try {
         obj.SomeProp = 0;
      }
      catch (ArgumentOutOfRangeException) {
         Console.WriteLine("Property set catch.");
      }
      obj.SomeProp = 2;
      Int32 val = (Int32)obj.SomeProp;
      Console.WriteLine("SomeProp: " + val);

      // Add and remove a delegate from the event
      obj.SomeEvent += new EventHandler(EventCallback);
      obj.SomeEvent -= new EventHandler(EventCallback);
   }

   // Callback method added to the event
   private static void EventCallback(Object sender, EventArgs e) { }
}