10分鐘教你理解反射

什麼是反射？

反射反射，程序員的快樂!在.Net領域程序設計中，反射是無處不在的，MVC、ASP.Net、各類ORM、IOC、AOP幾乎全部的框架都離不開反射。反編譯工具使用的底層技術用的不是反射，是一種逆向工程。

反射（Reflection、System.Reflection），是.Net Framework提供的一個幫助類庫，能夠讀取並使用Metadata中描述的數據信息。元數據（Metadata），描述了dll/exe裏面的各類信息，又稱中介數據、中繼數據，爲描述數據的數據（data about data），主要是描述數據屬性（property）的信息，用來支持如指示存儲位置、歷史數據、資源查找、文件記錄等功能。

反射的優缺點：

優勢：動態—在不破壞原有程序的狀況下，可對程序進行良好的擴展。Eg：咱們有這樣一需求，項目在最初的時候用的是Mysql數據庫，因爲項目狀況變化須要更換成SqlServer數據庫。面對這種項目的需求，傳統的解決方法是在項目中添加新的SqlServer數據庫訪問代碼，將數據庫訪問實現層更改成SqlServer，最後編譯源代碼並從新發布。

傳統解決方法示例僞代碼以下：

1                     IDBHelper iDBHelper = new MySqlHelper();
2                     IDBHelper iDBHelper = new SqlServerHelper();
3                     iDBHelper.Query();

使用反射的示例代碼：

 1 namespace ReflectionDemo
 2 {
 3     /// <summary>
 4     /// 反射工廠
 5     /// </summary>
 6     public class SimpleFactory
 7     {
 8         //讀取配置文件
 9         private static string IDBHelperConfig = ConfigurationManager.AppSettings["IDBHelperConfig"];
10         //獲取須要加載的dll名稱
11         private static string DllName = IDBHelperConfig.Split(',')[0]; 
12         //獲取須要的類型名稱
13         private static string TypeName = IDBHelperConfig.Split(',')[1];
14         /// <summary>
15         /// 經過反射動態加載與類型名稱相匹配的實例
16         /// </summary>
17         /// <returns></returns>
18         public static IDBHelper CreateInstance()
19         {
20             Assembly assembly = Assembly.Load(DllName);
21             Type type = assembly.GetType(TypeName);
22             object oDBHelper = Activator.CreateInstance(type);
23             IDBHelper iDBHelper = oDBHelper as IDBHelper;
24             return iDBHelper;
25         }
26     }
27 }

  <add key="IDBHelperConfig" value="MySqlDb,MySqlDb.MySqlHelper"/>

                IDBHelper iDBHelper = SimpleFactory.CreateInstance();
                iDBHelper.Query();

經過反射實現了程序的可配置，經過修改配置文件就能夠自動切換實現類，實現類必須是事先已有的， 沒有將實現類固定，而是經過配置文件執行，經過反射建立的。可擴展:徹底不修改原有代碼，只是增長新的實現、修改配置文件，就能夠支持新功能。這就是反射的動態特性。

缺點：使用麻煩、避開編譯器檢查致使運程序行時異常變多、性能問題。

經過反射調用構造函數

  1 namespace SqlServerDb
  2 {
  3 
  4     /// <summary>
  5     /// 反射測試類
  6     /// </summary>
  7     public class ReflectionTest
  8     {
  9         #region Identity
 10         /// <summary>
 11         /// 無參構造函數
 12         /// </summary>
 13         public ReflectionTest()
 14         {
 15             Console.WriteLine("這裏是{0}無參數構造函數", this.GetType());
 16         }
 17 
 18         /// <summary>
 19         /// 帶參數構造函數
 20         /// </summary>
 21         /// <param name="name"></param>
 22         public ReflectionTest(string name)
 23         {
 24             Console.WriteLine("這裏是{0} 有參數【string】構造函數", this.GetType());
 25         }
 26 
 27         public ReflectionTest(int id)
 28         {
 29             Console.WriteLine("這裏是{0} 有參數【int】構造函數", this.GetType());
 30         }
 31         #endregion
 32 
 33         #region Method
 34         /// <summary>
 35         /// 無參方法
 36         /// </summary>
 37         public void Show1()
 38         {
 39             Console.WriteLine("這裏是{0}的Show1", this.GetType());
 40         }
 41         /// <summary>
 42         /// 有參數方法
 43         /// </summary>
 44         /// <param name="id"></param>
 45         public void Show2(int id)
 46         {
 47 
 48             Console.WriteLine("這裏是{0}的Show2", this.GetType());
 49         }
 50         /// <summary>
 51         /// 重載方法之一
 52         /// </summary>
 53         /// <param name="id"></param>
 54         /// <param name="name"></param>
 55         public void Show3(int id, string name)
 56         {
 57             Console.WriteLine("這裏是{0}的Show3", this.GetType());
 58         }
 59         /// <summary>
 60         /// 重載方法之二
 61         /// </summary>
 62         /// <param name="name"></param>
 63         /// <param name="id"></param>
 64         public void Show3(string name, int id)
 65         {
 66             Console.WriteLine("這裏是{0}的Show3_2", this.GetType());
 67         }
 68         /// <summary>
 69         /// 重載方法之三
 70         /// </summary>
 71         /// <param name="id"></param>
 72         public void Show3(int id)
 73         {
 74             Console.WriteLine("這裏是{0}的Show3_3", this.GetType());
 75         }
 76         /// <summary>
 77         /// 重載方法之四
 78         /// </summary>
 79         /// <param name="name"></param>
 80         public void Show3(string name)
 81         {
 82             Console.WriteLine("這裏是{0}的Show3_4", this.GetType());
 83         }
 84 
 85         /// <summary>
 86         /// 重載方法之五
 87         /// </summary>
 88         public void Show3()
 89         {
 90             Console.WriteLine("這裏是{0}的Show3_1", this.GetType());
 91         }
 92 
 93         /// <summary>
 94         /// 私有方法
 95         /// </summary>
 96         /// <param name="name"></param>
 97         private void Show4(string name)
 98         {
 99             Console.WriteLine("這裏是{0}的Show4", this.GetType());
100         }
101 
102         /// <summary>
103         /// 靜態方法
104         /// </summary>
105         /// <param name="name"></param>
106         public static void Show5(string name)
107         {
108             Console.WriteLine("這裏是{0}的Show5", typeof(ReflectionTest));
109         }
110         #endregion
111     }
112 }

 1                 Assembly assembly = Assembly.Load("SqlServerDb");
 2                 Type type = assembly.GetType("SqlServerDb.ReflectionTest");
 3                 foreach (ConstructorInfo ctor in type.GetConstructors())
 4                 {
 5                     Console.WriteLine($"ctor.Name：{ctor.Name}");
 6                     foreach (var parameter in ctor.GetParameters())
 7                     {
 8                         Console.WriteLine($"ParameterType：{parameter.ParameterType}，parameterName： {parameter.Name}");
 9                     }
10                 }
11                 object oTest1 = Activator.CreateInstance(type);
12                 object oTest2 = Activator.CreateInstance(type, new object[] { 123 });
13                 object oTest3 = Activator.CreateInstance(type, new object[] { "陌殤" });

 反射破壞單例

1                 //反射破壞單例---就是反射調用私有構造函數
2                 Assembly assembly = Assembly.Load("SqlServerDb");
3                 Type type = assembly.GetType("SqlServerDb.Singleton");
4                 Singleton singletonA = (Singleton)Activator.CreateInstance(type, true);
5                 Singleton singletonB = (Singleton)Activator.CreateInstance(type, true);
6                 Console.WriteLine($"{object.ReferenceEquals(singletonA, singletonB)}");

反射調用泛型類

namespace SqlServerDb
{

    /// <summary>
    /// 泛型測試類
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="W"></typeparam>
    /// <typeparam name="X"></typeparam>
    public class GenericClass<T, W, X>
    {
        public GenericClass()
        {
            Console.WriteLine("GenericClass<T, W, X>的構造函數被調用了");
        }


        public void Show(T t, W w, X x)
        {
            Console.WriteLine("t.type={0},w.type={1},x.type={2}", t.GetType().Name, w.GetType().Name, x.GetType().Name);
        }
    }

    /// <summary>
    /// 泛型測試方法
    /// </summary>
    public class GenericMethod
    {

        public GenericMethod()
        {
            Console.WriteLine("GenericMethod類的構造函數被調用了。");
        }

        public void Show<T, W, X>(T t, W w, X x)
        {
            Console.WriteLine("t.type={0},w.type={1},x.type={2}", t.GetType().Name, w.GetType().Name, x.GetType().Name);
        }

        
    }

    public class GenericDouble<T>
    {
        public void Show<W, X>(T t, W w, X x)
        {
            Console.WriteLine("t.type={0},w.type={1},x.type={2}", t.GetType().Name, w.GetType().Name, x.GetType().Name);
        }
    }
}

1                 Assembly assembly = Assembly.Load("SqlServerDb");
2                 Type type = assembly.GetType("SqlServerDb.GenericClass`3");
3                 GenericClass<string, int, DateTime> genericClass = new GenericClass<string, int, DateTime>();
4                 //genericClass.Show("12", 1, DateTime.Now);
5                 //object oGeneric = Activator.CreateInstance(type);
6                 Type typeMake = type.MakeGenericType(new Type[] { typeof(string), typeof(int), typeof(DateTime) });
7                 object oGeneric = Activator.CreateInstance(typeMake);

反射調用泛型方法

                Assembly assembly = Assembly.Load("SqlServerDb");
                Type type = assembly.GetType("SqlServerDb.GenericMethod");
                object oGeneric = Activator.CreateInstance(type);

若是反射建立對象以後，知道方法名稱，怎麼樣不作類型轉換，直接調用方法？

 1    2                 Assembly assembly = Assembly.Load("SqlServerDb");
 3                 Type type = assembly.GetType("SqlServerDb.ReflectionTest");
 4                 object oTest = Activator.CreateInstance(type);
 5                 foreach (var method in type.GetMethods())
 6                 {
 7                     Console.WriteLine(method.Name);
 8                     foreach (var parameter in method.GetParameters())
 9                     {
10                         Console.WriteLine($"{parameter.Name}  {parameter.ParameterType}");
11                     }
12                 }
13                 {
14                     ReflectionTest reflection = new ReflectionTest();
15                     reflection.Show1();
16                 }
17                 {
18                     MethodInfo method = type.GetMethod("Show1");
19                     //if()
20                     method.Invoke(oTest, null);
21                 }
22                 {
23                     MethodInfo method = type.GetMethod("Show2");
24                     method.Invoke(oTest, new object[] { 123 });
25                 }
26                 {
27                     MethodInfo method = type.GetMethod("Show3", new Type[] { });
28                     method.Invoke(oTest, null);
29                 }
30                 {
31                     MethodInfo method = type.GetMethod("Show3", new Type[] { typeof(int) });
32                     method.Invoke(oTest, new object[] { 123 });
33                 }
34                 {
35                     MethodInfo method = type.GetMethod("Show3", new Type[] { typeof(string) });
36                     method.Invoke(oTest, new object[] { "一輩子爲你" });
37                 }
38                 {
39                     MethodInfo method = type.GetMethod("Show3", new Type[] { typeof(int), typeof(string) });
40                     method.Invoke(oTest, new object[] { 234, "心欲無痕" });
41                 }
42                 {
43                     MethodInfo method = type.GetMethod("Show3", new Type[] { typeof(string), typeof(int) });
44                     method.Invoke(oTest, new object[] { "PHS", 345 });
45                 }
46                 {
47                     MethodInfo method = type.GetMethod("Show5");
48                     method.Invoke(oTest, new object[] { "張中魁" });//靜態方法實例能夠要
49                 }
50                 {
51                     MethodInfo method = type.GetMethod("Show5");
52                     method.Invoke(null, new object[] { "張中魁" });//靜態方法實例也能夠不要
53                 }

反射調用私有方法

1             {
2                 //調用私有方法
3                 Console.WriteLine("&&&&&&&&&&&&&&&&&&&&私有方法&&&&&&&&&&&&&&&&&&&");
4                 Assembly assembly = Assembly.Load("SqlServerDb");
5                 Type type = assembly.GetType("SqlServerDb.ReflectionTest");
6                 object oTest = Activator.CreateInstance(type);
7                 var method = type.GetMethod("Show4", BindingFlags.Instance | BindingFlags.NonPublic);
8                 method.Invoke(oTest, new object[] { "我是老王" });
9             }

反射調用泛型方法

                Assembly assembly = Assembly.Load("SqlServerDb");
                Type type = assembly.GetType("SqlServerDb.GenericMethod");
                object oGeneric = Activator.CreateInstance(type);
                foreach (var item in type.GetMethods())
                {
                    Console.WriteLine(item.Name);
                }
                MethodInfo method = type.GetMethod("Show");
                //指定泛型方法的參數類型
                var methodNew = method.MakeGenericMethod(new Type[] { typeof(int), typeof(string), typeof(DateTime) });
                object oReturn = methodNew.Invoke(oGeneric, new object[] { 123, "董小姐", DateTime.Now });

反射調用泛型方法加泛型類

1                 Assembly assembly = Assembly.Load("SqlServerDb");
2                 //在獲取類型的同時經過MakeGenericType指定泛型的參數類型
3                 Type type = assembly.GetType("SqlServerDb.GenericDouble`1").MakeGenericType(typeof(int));
4                 object oObject = Activator.CreateInstance(type);
5                 MethodInfo method = type.GetMethod("Show").MakeGenericMethod(typeof(string), typeof(DateTime));
6                 method.Invoke(oObject, new object[] { 345, "感謝有夢", DateTime.Now });