對泛型進行反射

      在制作一個批量序列化工具時遇到了如下問題，在此記錄一下，僅供參考。

      主程序加載另一個程序集，將其中的所有類取出，然后對這些類分別調用泛型類或泛型方法。控制台程序解決方案如下：

• Main工程：提供Worker類進行數據操作，XMLTool<T>泛型類將數據集序列化為.xml文檔，RootCollection<T>類封裝數據集
  • Worker類

  　　     提供成員方法void DoWork<T>()、List<T> GetList<T>()、靜態成員方法StaticDoWork<T>()，代碼如下：

  public class Worker
      {
          public Worker()
          {
          }
  
          public void DoWork<T>()
          {
              Type t = typeof(T);
              Console.WriteLine("Get Class: {0}", t.Name);
              PropertyInfo[] properties = t.GetProperties();
              foreach (PropertyInfo property in properties)
              {
                  Console.WriteLine("\tproperty.Name: " + property.Name + "\tproperty.MemberType: " + property.PropertyType);
              }
          }
  
          public static void StaticDoWork<T>()
          {
              Type t = typeof(T);
              Console.WriteLine("Get Class: {0}", t.Name);
              PropertyInfo[] properties = t.GetProperties();
              foreach (PropertyInfo property in properties)
              {
                  Console.WriteLine("\tproperty.Name: " + property.Name + "\tproperty.MemberType: " + property.PropertyType);
              }
          }
  
          public List<T> GetList<T>()
          {
              Console.WriteLine("Generate List for [{0}]", typeof(T).Name);
              return new List<T>() 
              { 
                  Activator.CreateInstance<T>(), 
                  Activator.CreateInstance<T>() 
              };
          }
      }

   

• XMLTool<T>類

  publicclass XMLTool<T>
      {
  publicstaticvoid XmlSerialize_Save(List<T> needSerializedList, string xmlDirPath, string xmlFileName)
          {
              RootCollection<T> collection = new RootCollection<T>();
              collection.ItemList = needSerializedList;
  if (!Directory.Exists(xmlDirPath))
                  Directory.CreateDirectory(xmlDirPath);
  using (System.IO.FileStream stream = new System.IO.FileStream(xmlFileName, System.IO.FileMode.Create))
              {
                  System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(collection.GetType());
                  serializer.Serialize(stream, collection);
              }
          }
      }

• RootCollection<T>類：

      [Serializable]
      public class RootCollection<T>
      {
          public RootCollection()
          {
              itemList = new List<T>();
          }
  
          private List<T> itemList;
  
          public List<T> ItemList
          {
              get { return itemList; }
              set { itemList = value; }
          }
      }

• MockClassLib工程：提供BaseEntity、Apple、Cat和Person類
• BaseEntity類：抽象類，負責初始化類成員

   1     public abstract class BaseEntity
      {
   3         public BaseEntity()
          {
              InitiaWithNull();
          }
  
   8         private void InitiaWithNull()
          {
              Type type = this.GetType();
              PropertyInfo[] properties = type.GetProperties();
  12             string[] PropNames = new string[properties.Length];
              Dictionary<string, PropertyInfo> PropNameToInfo = new Dictionary<string, PropertyInfo>();
  14             for (int i = 0; i < properties.Length; i++)
              {
                  PropNames[i] = properties[i].Name;
                  PropNameToInfo.Add(PropNames[i], properties[i]);
              }
  
  20             foreach (string propname in PropNames)
              {
  22                 string proptype = PropNameToInfo[propname].PropertyType.Name;
  
  24                 object value = null;
  25                 if (NullValue.Keys.Contains(proptype))
                      value = NullValue[proptype];
  
                  type.GetProperty(propname).SetValue(this, value, null);
              }
          }
  
  32         private static readonly Dictionary<string, object> NullValue = new Dictionary<string, object>() 
              { 
                  { "String", String.Empty }, 
                  { "DateTime", DateTime.MinValue},
                  { "Decimal", Decimal.MinValue}
              };
      }

• Apple、Cat和Person類：測試類，繼承於BaseEntity

   1     public class Apple : BaseEntity
      {
   3        public string Color { get; set; }
      }
  
   6     public class Cat : BaseEntity
      {
   8        public string Type { get; set; }
      }
  
  11     public class Person : BaseEntity
      {
  13        public int ID { get; set; }
  14        public string Name { get; set; }
      }

 

      Main工程的Program的Main方法中，一般情況下，調用Worker的泛型方法來處理測試類的話，可以寫為：

      Worker worker = new Worker();

      worker.DoWork<Apple>();

      worker.DoWork<Cat>();

      worker.DoWork<Person>();

      但是，如果MockClassLib中需要處理的類型非常多時，這樣顯示調用必然是不靈活的，應當怎樣向泛型方法DoWork<T>()的尖括號中動態傳入類型呢？

      考慮代碼：

            //Load assembly
            Assembly mockAssembly = Assembly.LoadFrom("MockClassLibrary.dll");
            Type[] typeArray = mockAssembly.GetTypes();

            //Create instance of Worker          
            Worker worker = new Worker();
            foreach(Type curType in typeArray)
            {
                  worker.DoWork<curType>();   //Error
            }

      可以看到，Type類型的實例是無法直接傳入泛型方法的尖括號中的，T要求顯式指明類型名。

      下面通過反射方式來獲取泛型方法，並創建特定類型的泛型方法。

• 對於非靜態方法：public void DoWork<T>()

          對於非靜態方法，調用MethodInfo.Invoke(object, object[])時，第一個參數需要指明泛型方法的所有者（即這里創建的worker對象），第二個參數為泛

          型方法的參數列表，DoWork<T>()沒有輸入參數，所以設為null

//Create an instance of Worker
Worker worker = new Worker();       

//Get type of Worker
Type workerType = typeof(Worker);

 //Get Generic Method
MethodInfo doWorkMethod = workerType.GetMethod("DoWork");

//Invoke DoWork<T> with different Type
foreach (Type curType in typeArray)
{
    if (curType.IsClass && !curType.IsAbstract)//Filter BaseEntity
    {
        MethodInfo curMethod = doWorkMethod.MakeGenericMethod(curType);
        curMethod.Invoke(worker, null);//Member method，use instance
    }
}

• 對於靜態方法：public static void StaticDoWork<T>()

          不同於非靜態方法，這里直接反射的類靜態方法，所以Invoke()的第一個參數設為null

//Get type of Worker
Worker worker = new Worker();

//Get Generic Method
MethodInfo staticDoWorkMethod = workerType.GetMethod("StaticDoWork");

//Invoke StaticDoWork<T>
foreach (Type curType in typeArray)
{
    if (curType.IsClass && !curType.IsAbstract)
    {
        MethodInfo curMethod = staticDoWorkMethod.MakeGenericMethod(curType);
        curMethod.Invoke(null, null);//Static method
    }
}

• 對於有返回值的非靜態方法：public List<T> GetList()

          如同動態調用DoWork<T>()方法一樣，只是在處理返回值時，可以使用下面的方法

IList tempList = (IList)curMethod.Invoke(worker, null);
//Or
IEnumerable tempList = (IEnumerable)curMethod.Invoke(worker, null);

• 對於泛型類：XMLTool<T>

          下面要使用泛型類XMLTool<T>的靜態方法public static void XmlSerialize_Save(List<T> list, string dirPath, string fileName)方法。

          首先應通過反射構造出指定類型的泛型類XMLTool<T>，再反射出其中的XmlSerialize_Save方法並使用。

//Use Generic Class
Type xmlToolType = typeof(XMLTool<>).MakeGenericType(curType);

//Get method
MethodInfo saveMethod = xmlToolType.GetMethod("XmlSerialize_Save");

//Invoke
saveMethod.Invoke
(
    null, //Static method
    new object[] { resultList, @"c:\", @"c:\Test_" + curType.Name + ".xml" }

);

 

       Program-->Main()方法的全部代碼：

namespace RetrieveUnknownClass
{
    class Program
    {
        static void Main(string[] args)
        {
            //Load assembly
            Assembly mockAssembly = Assembly.LoadFrom("MockClassLibrary.dll");
            Type[] typeArray = mockAssembly.GetTypes();

            //Create instance of Worker          
            Type workerType = typeof(Worker);
            Worker worker = new Worker();

            #region Member method

            Console.WriteLine(">>>>>>>>>Use Generic Method：");
            MethodInfo doWorkMethod = workerType.GetMethod("DoWork");

            //Invoke DoWork<T>
            foreach (Type curType in typeArray)
            {
                if (curType.IsClass && !curType.IsAbstract)
                {
                    MethodInfo curMethod = doWorkMethod.MakeGenericMethod(curType);
                    curMethod.Invoke(worker, null);//Member method，use instance
                }
            }

            #endregion

            #region Static method

            Console.WriteLine("\r\n>>>>>>>>>Use Static Generic Method：");
            MethodInfo staticDoWorkMethod = workerType.GetMethod("StaticDoWork");

            //Invoke StaticDoWork<T>
            foreach (Type curType in typeArray)
            {
                if (curType.IsClass && !curType.IsAbstract)
                {
                    MethodInfo curMethod = staticDoWorkMethod.MakeGenericMethod(curType);
                    curMethod.Invoke(null, null);//Static method
                }
            }

            #endregion

            #region Get A List & Serialize It to Xml File With Generic 

            Console.WriteLine("\r\n>>>>>>>>>Get List By Generic Method：");
            MethodInfo getListMethod = workerType.GetMethod("GetList");

            foreach (Type curType in typeArray)
            {
                if (curType.IsClass && !curType.IsAbstract)
                {
                    MethodInfo curMethod = getListMethod.MakeGenericMethod(curType);
                    //Generate List
                    IList resultList = (IList)curMethod.Invoke(worker, null);
                    //Show List
                    ShowList(resultList);
                    //Use Generic Class
                    Type xmlToolType = typeof(XMLTool<>).MakeGenericType(curType);
                    MethodInfo saveMethod = xmlToolType.GetMethod("XmlSerialize_Save");

                    saveMethod.Invoke
                        (
                            null, //Static method
                            new object[] { resultList, @"c:\", @"c:\Test_" + curType.Name + ".xml" }
                        );
                }
            }
            
            Console.WriteLine("Serialization Completed...\r\n");
            #endregion
        }

        public static void ShowList(IList list)
        {
            Console.WriteLine("Type of list: {0}\r\nCount of current list: {1}\r\nType of item in list: {2}\r\n", 
                list.GetType(), 
                list.Count, 
                list[0].GetType());
        }
    }
}

 

       相關文章：

• 關於MackGenericMethod()方法
• 關於MethodInfo.Invoke()(+2)方法
• Overcoming problems with MethodInfo.Invoke of methods with by-reference value type arguments
• How to: Define a Generic Type with Reflection Emit