CLR 学习笔记：程序集加载和反射（3）

       在获取一个Type之后，这个类型的成员可能包含字段，构造器，方法，属性，事件和嵌套类型。接下来就看说下如何查询一个类型的成员。

   1.发现类型的成员

   上一章提到了System.Reflection.MemberInfo类型，这是一个抽象基类，而我们的类型成员是从MemberInfo派生的一组类。具体的层次结构如下。

   

      可以调用GetMembers方法，传入BindingFlags参数，然后返回由MemberInfo派生对象构成的一个数组。

  Assembly assemblyFromPath = Assembly.LoadFile(@"E:\StrongNameDLL.dll");
  const BindingFlags bf = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly;
  foreach (Type t in assemblyFromPath.GetExportedTypes())
  {
      foreach (MemberInfo mi in t.GetMembers(bf))
      {
          if (mi is FieldInfo)
          {
              //...
          }
          if (mi is MethodInfo)
          {
              //...
          }
      }
  }

        不仅如此，Type还提供了一些方法能够返回特定的成员类型，例如GetNestedTypes，GetFields, GetConstructors, GetMethods, GetProperties, GetEvents，返回的都是一个Info对象的数组；以及对应的GetNestedType，GetField，GetConstructor，GetMethod，GetProperty，GetEvent单数形式方法，返回Info对象。

    2.调用类型的成员

    Type类提供了一个InvokeMember方法，可通过它调用一个成员。  

public object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, CultureInfo culture)
{
    //...
}

        在内部，InvokeMember会执行两个操作。首先，它必须绑定要调用的成员；其次，必须调用成员。

    a.name参数传递一个String，指出希望绑定的成员的名称，而除了target参数，其他参数都是用于帮助InvokeMember方法确定要绑定的成员。

        b.BindingFlags标识了筛选种类以及具体操作。

        c.Binder封装了选在一个成员时的规则，例如BindToField, BindToMethod等。如果传入null,内部使用DefaultBinder对象。

        d.target参数是对想要调用其成员的一个对象的引用。如果要调用一个类型的静态成员，该参数应传递null值。

        e.args表示要传给方法的实参

        3.代码实现

    代码实现了几种不同的访问类型成员的方式，目的是希望大家体会到一次绑定，多次调用的好处。  

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

        static void Main(string[] args)
        {
            Type t = typeof(SomeType);
            //利用Type的InvokeMember来绑定并调用一个成员
            UseInvokeMemberToBindAndInvokeTheMember(t);
            Console.WriteLine();
            //绑定成员，并在以后调用它
            BindToMemberThenInvokeTheMember(t);
            Console.WriteLine();
            //绑定一个对象或成员，然后创建委托来调用，速度快
            BindToMemberCreateDelegateToMemberThenInvokeTheMember(t);
            Console.WriteLine();
            //用dynamic基元类简化访问成员时的语法
            UseDynamicToBindAndInvokeTheMember(t);
            Console.WriteLine();
        }

        private static void UseInvokeMemberToBindAndInvokeTheMember(Type t)
        {
            Console.WriteLine("UseInvokeMemberToBindAndInvokeTheMember");
            //构造实例
            object[] args = new object[] { 12 };
            object obj = t.InvokeMember(null, c_bf | BindingFlags.CreateInstance, null, null, args);
            Console.WriteLine("Type:{0}, Value:{1}.", obj.GetType().ToString(), args[0]);

            //读写一个字段
            t.InvokeMember("m_someField", c_bf | BindingFlags.SetField, null, obj, new object[] { 5 });
            int field = (int)t.InvokeMember("m_someField", c_bf | BindingFlags.GetField, null, obj, null);
            Console.WriteLine("SomeField: " + field);

            //调用一个方法
            string toStringMethod = (string)t.InvokeMember("ToString", c_bf | BindingFlags.InvokeMethod, null, obj, null);
            Console.WriteLine("ToString: " + toStringMethod);

            //读写一个属性
            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 });
            int property = (int)t.InvokeMember("SomeProp", c_bf | BindingFlags.GetProperty, null, obj, null);
            Console.WriteLine("SomeProp: " + property);

            //调用事件add/remove方法，为事件添加和删除一个委托
            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)
        {
            //构造一个实例
            ConstructorInfo ctor = t.GetConstructor(new Type[] { typeof(Int32).MakeByRefType() });
            //ConstructorInfo ctor = t.GetConstructor(new Type[] { Type.GetType("System.Int32&") });
            object[] args = new object[] { 12 };
            object obj = ctor.Invoke(args);

            //读写一个字段
            FieldInfo fi = obj.GetType().GetField("m_someField", c_bf);
            fi.SetValue(obj, 33);
            Console.WriteLine("SomeField: " + fi.GetValue(obj));

            //调用一个方法
            MethodInfo mi = obj.GetType().GetMethod("ToString", c_bf);
            string toString = (string)mi.Invoke(obj, null);
            Console.WriteLine("ToString: " + toString);

            //读写一个属性
            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));

            //为事件添加删除一个委托
            EventInfo ei = obj.GetType().GetEvent("SomeEvent", c_bf);
            EventHandler eh = new EventHandler(EventCallBack);
            ei.AddEventHandler(obj,eh);
            ei.RemoveEventHandler(obj,eh);
        }

        private static void BindToMemberCreateDelegateToMemberThenInvokeTheMember(Type t)
        {
            //构造一个实例
            object[] args = new object[] { 12 };
            object obj = Activator.CreateInstance(t, args);

            //不能创建对一个字段的委托

            //调用一个方法
            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);

            //读写一个属性
            PropertyInfo pi = obj.GetType().GetProperty("SomeProp", c_bf);
            var setSomeProp = (Action<int>)Delegate.CreateDelegate(typeof(Action<int>), obj, pi.GetSetMethod());
            try
            {
                setSomeProp(0);
            }
            catch (ArgumentOutOfRangeException e)
            {
                Console.WriteLine("Property set catch");
            }
            setSomeProp(2);
            var getSomeProp = (Func<int>)Delegate.CreateDelegate(typeof(Func<int>), obj, pi.GetGetMethod());
            Console.WriteLine("SomeProp: " + getSomeProp);

            //从事件中添加删除一个委托
            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)
        {
            //构造一个实例
            object[] args = new object[] { 12 };
            dynamic obj = Activator.CreateInstance(t, args);

            try
            {
                obj.m_someField = 5;
                int v = (int)obj.m_someField;
                Console.WriteLine("someField: " + v);
            }
            catch (RuntimeBinderException e)
            {
                //字段私有
                Console.WriteLine("Failed to access field: " + e.Message);
            }

            //调用一个方法
            string toString = (string)obj.ToString();
            Console.WriteLine("ToString: " + toString);

            //读写一个属性
            try
            {
                obj.SomeProp = 0;
            }
            catch (ArgumentOutOfRangeException e)
            {
                Console.WriteLine("Property set catch");
            }
            obj.SomeProp = 2;
            int value = (int)obj.SomeProp;
            Console.WriteLine("SomeProp: " + value);

            //添加删除一个委托
            obj.SomeEvent += new EventHandler(EventCallBack);
            obj.SomeEvent -= new EventHandler(EventCallBack);
        }

        private static void EventCallBack(object sender, EventArgs e){ }
    }

    internal sealed class SomeType
    {
        private int m_someField;
        public SomeType(ref int x)
        {
            x *= 2;
        }
        public override string ToString()
        {
            return m_someField.ToString();
        }
        public int SomeProp
        {
            get { return m_someField; }
            set
            {
                if (value < 1)
                {
                    throw new ArgumentOutOfRangeException("value");
                }
                m_someField = value;
            }
        }
        public event EventHandler SomeEvent;
        private void NonCompilerWarning()
        {
            SomeEvent.ToString();
        }
    }

 

     4.使用绑定句柄减少内存耗用

     应用程序绑定一组类型或者类型成员到一个集合中，然后在某个时刻，应用程序会搜索这个集合，查找特定的对象，然后调用这个对象。这是个很好机制，只是有一个小问题：Type对象和MemberInfo派生对象需要大量的内存。如果应用程序容纳太多这样的对象，并且只是偶尔调用它们，那么内存耗用会很大，并对程序的性能产生影响。

     我们可以使用运行时句柄（runtime handles）来替代这些对象，从而减小占用的内存。FCL定义了3个运行时句柄类型：RuntimeTypeHandle, RuntimeFieldHandle和RuntimeMethodHandle。它们都是值类型，只包含一个IntPrt。Type或MemberInfo对象与运行时句柄之间的转换相当简单。下面通过具体代码演示。

    internal sealed class ExchangedDemo
    {
        private const BindingFlags c_bf = BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.NonPublic |
             BindingFlags.Instance | BindingFlags.Static;

        public static void ShowExchangeMethod()
        {
            Show("Before doing anything.");
            List<MethodBase> methodInfos = new List<MethodBase>();
            foreach (Type t in typeof(Object).Assembly.GetExportedTypes())
            {
                if (t.IsGenericTypeDefinition)
                {
                    continue;
                }

                MethodBase[] mBase = t.GetMethods(c_bf);
                methodInfos.AddRange(mBase);
            }

            Console.WriteLine("# of methods={0:###,###}",methodInfos.Count);
            Show("After building cache of MethodInfo objects");

            List<RuntimeMethodHandle> methodHandles = methodInfos.ConvertAll<RuntimeMethodHandle>(
                mBase => mBase.MethodHandle);
            Show("Holding MethodInfo and RuntimeMethodHandl cache");
            GC.KeepAlive(methodInfos);

            methodInfos = null;
            Show("After freeing MethodInfo objects");

            methodInfos = methodHandles.ConvertAll<MethodBase>(rmh => MethodBase.GetMethodFromHandle(rmh));
            Show("Size of heap after re-creating MethodInfo objects");

            GC.KeepAlive(methodHandles);
            GC.KeepAlive(methodInfos);

            methodInfos = null;
            methodHandles = null;
            Show("After freeing MethodInfos and RuntimeMethodHandles");
        }

        private static void Show(string msg)
        {
            Console.WriteLine("Heap size = {0,12:##,###,###} - {1}",GC.GetTotalMemory(true),msg);
        }
    }