《CLR via C#：框架设计》读书笔记 - 程序集加载和反射

最新推荐文章于 2023-03-18 18:12:49 发布

装逼是种天赋@#E@$

最新推荐文章于 2023-03-18 18:12:49 发布

阅读量961

点赞数 1

分类专栏： C# 深入装逼

C# 深入装逼专栏收录该内容

26 篇文章 3 订阅

订阅专栏

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) { }
} 
    
  