反射之動態創建對象

前言

C#有關反射的話題已經是個老生常談的話題，也許園友一看這標題都不屑去看了，但是既然拿出來講必有講之道理，當然，不喜勿噴，高手請繞道！直入話題。

討論

 定義一個Person類代碼如下

   public class Person
    {

        /// <summary>
        /// 年齡
        /// </summary>
        public int Age { get; set; }

        /// <summary>
        /// 姓名
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// 性別
        /// </summary>
        public bool Gender { get; set; }


        /// <summary>
        /// 求兩個數的和
        /// </summary>
        /// <param name="num1"></param>
        /// <param name="num2"></param>
        /// <returns></returns>
        public int Add(int num1,int num2)
        {
            return num1 + num2;
        }
    }

那么現在怎么動態獲取該對象並打印該對象？啊，用反射動態獲取唄，ok,實現如下！

            Type person = typeof(Person);

            Person t = (Person)Activator.CreateInstance(person) as Person;

            Console.WriteLine(t.ToString());

完全沒錯，在黑框框中運行輸出入下：

接下來小小改動一下，在Person類中添加一個構造函數

        public Person(string age, string name, bool gender)
        {
            this.Age = age;
            this.Name = name;
            this.Gender = gender;
        }

此時我們再來運行看看！！什么鬼，怎么出現錯誤了？？？

嚇我一跳，平常來個未將對象設置到對象的實例那是見怪不怪了，出現這個容我想想，無參構造函數似乎暗示着什么，突然醒悟對象不都默認有個無參的構造函數嗎，啊，shit，原來是因為我定義了一個有參數的構造函數，用Activator.CreateInstance動態創建對象調用的無參構造函數啊，緊接着我將鼠標放在該方法跟前，都告訴我了寫着 使用指定類型的默認構造函數來創建該類型的實例 ，知道錯誤所在了，關鍵是怎么去解決，要是類中寫了有參數的構造函數，現在想要反射來動態創建對象豈不是不能夠了嗎？繼續想，記得在javascript中雖然不能夠像C#實現重載，當然js也不存在重載，但是可以根據arguments.length來近似於實現所謂的重載，這里同樣可不可以根據構造函數的個數來實現呢？有了這個想法就開干，當看到這個GetConstructors方法心底就舒坦起來了，經過反復查看其方法改造控制台后的代碼如下：

            var length = 0;
            Person p = null;
            Type person = typeof(Person);
            var gc = person.GetConstructors();
            foreach (var c in gc)
            {
                length = c.GetParameters().Length;
            }

 現在獲取到了構造函數的長度即可以根據參數的個數來進行創建對象，離解決問題更進一步了，這時我想到如果我參數個數相同，怎么知道我是調用哪個構造函數呢？對，根據參數的類型，所以現在問題上升到怎么確定我要傳遞參數的類型呢？看看構造函數的屬性  ConstructorInfo 中有沒有什么方法可以定義參數類型，皇天不負有心人 GetConstructor 方法參數中 有個Type 這就是參數的類型了，然后利用 Invoke 委托對構造函數傳入參數獲取對象，如下：

            ConstructorInfo Constructor = null;

            switch (length)
            {
                case 0:
                    Constructor = person.GetConstructor(new Type[0]);
                    p = Constructor.Invoke(null) as Person;
                    break;
                case 1:
                    Constructor = person.GetConstructor(new Type[1] { typeof(int) });
                    p = Constructor.Invoke(new object[1] { 1 }) as Person;
                    break;
                case 2:
                    Constructor = person.GetConstructor(new Type[2] { typeof(int), typeof(string) });
                    p = Constructor.Invoke(new object[2] { 1, "嘿嘿" }) as Person;
                    break;
                case 3:     
                    Constructor = person.GetConstructor(new Type[3] { typeof(int), typeof(string), typeof(bool) });
                    p = Constructor.Invoke(new object[3] { 1, "嘿嘿", false }) as Person;
                    break;
                default:
                    break;
            }

            //Person t = (Person)Activator.CreateInstance(person) as Person;
            Console.WriteLine(p.ToString());

同樣得到上述結果打印出：反射之動態創建對象.Person，ok，終於解決了，完美！

拓展

在上述過程中用到委托Invoke再傳入參數到其中，鑒於此對於反射，參考代碼改善建議利用dynamic關鍵字簡化反射實現。下面用例子說明，利用反射計算Person類中方法計算兩個數的和。利用反射立馬能夠寫出

    Person dy = new Person();
    var p= typeof(Person).GetMethod("Add");
    Convert.ToInt32(p.Invoke(dy, new object[] { 30, 40 });)

如果利用 dynamic 關鍵字能夠更加精簡而且更加優美 

     dynamic dy = new Person(); 
     dy.Add(30, 40); 

總結 

　　（1）利用反射動態創建對象兩種方法

　　　　【1】利用Activator.CreateInstance，前提是調用對象的默認無參構造函數

　　　　【2】利用構造器來動態創建對象

　　（2）利用dynamic關鍵字來簡化反射實現

補充1

用構造器將其進行封裝為如下，其中用時需要手動添加參數類型以及參數默認值

      public static T GetEntity<T>() where T : class
        {
            T entity = null;
            var length = 0;
            Type t = typeof(T);
            var gc = t.GetConstructors();

            foreach (var c in gc)
            {
                length = c.GetParameters().Length;
            }
            ConstructorInfo Constructor = null;
           
            switch (length)
            {
                case 0:
                    Constructor = t.GetConstructor(new Type[0]);
                    entity = Constructor.Invoke(null) as T;
                    break;
                case 1:

                    Constructor = t.GetConstructor(new Type[1] { typeof(int) });
                    entity = Constructor.Invoke(new object[1] { 0 }) as T;
                    break;
                case 2:          
                    Constructor = t.GetConstructor(new Type[2] { typeof(int), typeof(string) });
                    entity = Constructor.Invoke(new object[2] { 0, null }) as T;
                    break;
                case 3:
                    Constructor = t.GetConstructor(new Type[3] { typeof(int), typeof(string), typeof(bool) });
                    entity = Constructor.Invoke(new object[3] { 0, null, false }) as T;
                    break;
                default:
                    break;
            }

            return entity;
        }

 補充2

上述提到用 dynamic 來簡化反射的實現，對於園友提出 對於反射無法獲取到class是什么 ，像 dynamic dy = new Person(); Person dy= new Person() ; 似乎是一樣的，那還不如直接實例化調用其方法即可，一想確實是這樣，經過再次研究覺得用dynamic只是更加便捷而且代碼更加精簡，就像用lamda簡化而省去了用委托或者匿名方法一樣！下面就以一個實例來說明不得不用反射來實現，還用上面的Person類，現在繼續添加一個 OtherPerson 類：

    public class OtherPerson
    {
        private int OtherAge { get; set; }
    }

然后在Person類中添加一個返回值為OtherPerson的私有方法 GetOtherPerson 

       private OtherPerson GetOtherPerson()
        {
            OtherPerson op = new OtherPerson();
            return op;
        }

現在想調用 GetOtherPerson 方法獲取 OtherPerson 類中的私有字段 OtherAge  ，別告訴我直接實例化Person對象，再調用，因為是私有現在無法實現，所以馬上想到的是通過反射來實現獲取這個方法再同樣實現獲取私有字段

            Person p1 = new Person();
            var p = typeof(Person).InvokeMember("GetOtherPerson", BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.NonPublic, null, p1, null);
            var propInfo = p.GetType().GetProperty("OtherAge", BindingFlags.Instance | BindingFlags.NonPublic);
            var age = (int)propInfo.GetValue(p, null);

一大片代碼看起來是不是很惡心，接下來我們將代碼進行改進，使其便捷化，上述提到用dynamic來實現，所以就來吧！

  var age = ((dynamic)p1).GetOtherPerson().OtherAge; 就一行代碼是不是很簡單，再次說明了dynamic的優美和簡潔，so  perfect!那我們運行下看看吧,oh，往往在你最得意的時候結果就會給你當頭一棒，出錯了！如下

這保護的級別有點忒高，那必須攻破你的堡壘！弄了一下午最終還是google給出了一位前輩已經這么做過的解決方案！重寫了dynamic的基類DynamicObject,接着就寫了它的擴展方法，代碼如下：

   public class PrivateReflectionDynamicObject : DynamicObject
    {

        private static IDictionary<Type, IDictionary<string, IProperty>> _propertiesOnType = new ConcurrentDictionary<Type, IDictionary<string, IProperty>>();

        // Simple abstraction to make field and property access consistent
        interface IProperty
        {
            string Name { get; }
            object GetValue(object obj, object[] index);
            void SetValue(object obj, object val, object[] index);
        }

        // IProperty implementation over a PropertyInfo
        class Property : IProperty
        {
            internal PropertyInfo PropertyInfo { get; set; }

            string IProperty.Name
            {
                get
                {
                    return PropertyInfo.Name;
                }
            }

            object IProperty.GetValue(object obj, object[] index)
            {
                return PropertyInfo.GetValue(obj, index);
            }

            void IProperty.SetValue(object obj, object val, object[] index)
            {
                PropertyInfo.SetValue(obj, val, index);
            }
        }

        // IProperty implementation over a FieldInfo
        class Field : IProperty
        {
            internal FieldInfo FieldInfo { get; set; }

            string IProperty.Name
            {
                get
                {
                    return FieldInfo.Name;
                }
            }


            object IProperty.GetValue(object obj, object[] index)
            {
                return FieldInfo.GetValue(obj);
            }

            void IProperty.SetValue(object obj, object val, object[] index)
            {
                FieldInfo.SetValue(obj, val);
            }
        }


        private object RealObject { get; set; }
        private const BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

        internal static object WrapObjectIfNeeded(object o)
        {
            // Don't wrap primitive types, which don't have many interesting internal APIs
            if (o == null || o.GetType().IsPrimitive || o is string)
                return o;

            return new PrivateReflectionDynamicObject() { RealObject = o };
        }

        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            IProperty prop = GetProperty(binder.Name);

            // Get the property value
            result = prop.GetValue(RealObject, index: null);

            // Wrap the sub object if necessary. This allows nested anonymous objects to work.
            result = WrapObjectIfNeeded(result);

            return true;
        }

        public override bool TrySetMember(SetMemberBinder binder, object value)
        {
            IProperty prop = GetProperty(binder.Name);

            // Set the property value
            prop.SetValue(RealObject, value, index: null);

            return true;
        }

        public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
        {
            // The indexed property is always named "Item" in C#
            IProperty prop = GetIndexProperty();
            result = prop.GetValue(RealObject, indexes);

            // Wrap the sub object if necessary. This allows nested anonymous objects to work.
            result = WrapObjectIfNeeded(result);

            return true;
        }

        public override bool TrySetIndex(SetIndexBinder binder, object[] indexes, object value)
        {
            // The indexed property is always named "Item" in C#
            IProperty prop = GetIndexProperty();
            prop.SetValue(RealObject, value, indexes);
            return true;
        }

        // Called when a method is called
        public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
        {
            result = InvokeMemberOnType(RealObject.GetType(), RealObject, binder.Name, args);

            // Wrap the sub object if necessary. This allows nested anonymous objects to work.
            result = WrapObjectIfNeeded(result);

            return true;
        }

        public override bool TryConvert(ConvertBinder binder, out object result)
        {
            result = Convert.ChangeType(RealObject, binder.Type);
            return true;
        }

        public override string ToString()
        {
            return RealObject.ToString();
        }

        private IProperty GetIndexProperty()
        {
            // The index property is always named "Item" in C#
            return GetProperty("Item");
        }

        private IProperty GetProperty(string propertyName)
        {

            // Get the list of properties and fields for this type
            IDictionary<string, IProperty> typeProperties = GetTypeProperties(RealObject.GetType());

            // Look for the one we want
            IProperty property;
            if (typeProperties.TryGetValue(propertyName, out property))
            {
                return property;
            }

            // The property doesn't exist

            // Get a list of supported properties and fields and show them as part of the exception message
            // For fields, skip the auto property backing fields (which name start with <)
            var propNames = typeProperties.Keys.Where(name => name[0] != '<').OrderBy(name => name);
            throw new ArgumentException(
                String.Format(
                "The property {0} doesn't exist on type {1}. Supported properties are: {2}",
                propertyName, RealObject.GetType(), String.Join(", ", propNames)));
        }

        private static IDictionary<string, IProperty> GetTypeProperties(Type type)
        {
            // First, check if we already have it cached
            IDictionary<string, IProperty> typeProperties;
            if (_propertiesOnType.TryGetValue(type, out typeProperties))
            {
                return typeProperties;
            }

            // Not cache, so we need to build it

            typeProperties = new ConcurrentDictionary<string, IProperty>();

            // First, add all the properties
            foreach (PropertyInfo prop in type.GetProperties(bindingFlags).Where(p => p.DeclaringType == type))
            {
                typeProperties[prop.Name] = new Property() { PropertyInfo = prop };
            }

            // Now, add all the fields
            foreach (FieldInfo field in type.GetFields(bindingFlags).Where(p => p.DeclaringType == type))
            {
                typeProperties[field.Name] = new Field() { FieldInfo = field };
            }

            // Finally, recurse on the base class to add its fields
            if (type.BaseType != null)
            {
                foreach (IProperty prop in GetTypeProperties(type.BaseType).Values)
                {
                    typeProperties[prop.Name] = prop;
                }
            }

            // Cache it for next time
            _propertiesOnType[type] = typeProperties;

            return typeProperties;
        }

        private static object InvokeMemberOnType(Type type, object target, string name, object[] args)
        {
            try
            {
                // Try to incoke the method
                return type.InvokeMember(
                    name,
                    BindingFlags.InvokeMethod | bindingFlags,
                    null,
                    target,
                    args);
            }
            catch (MissingMethodException)
            {
                // If we couldn't find the method, try on the base class
                if (type.BaseType != null)
                {
                    return InvokeMemberOnType(type.BaseType, target, name, args);
                }

                throw;
            }
        }
    }

擴展方法如下

   public static class PrivateReflectionDynamicObjectExtensions
    {
        public static dynamic AsDynamic(this object o)
        {
            return PrivateReflectionDynamicObject.WrapObjectIfNeeded(o);
        }
    }

最后調用拓展方法  var age = p1.AsDynamic().GetOtherPerson().OtherAge; 成功！所以有時候使用dynamic使得代碼變得更加優美而用反射代碼繁多而且顯得非常臃腫，通過再一次學習dynamic，對此也深信不疑！