2.net基础之反射

反射是.NET中的重要机制，通过反射，可以在运行时获得程序或程序集中每一个类型（包括类、结构、委托、接口和枚举等）的成员和成员的信息。有了反射，即可对每一个类型了如指掌。另外我还可以直接创建对象，即使这个对象的类型在编译时还不知道。 

反射的用途为提升应用程序的灵活性，扩展性。在运行时读取对象，设置对象，调用对象。

1. dll - IL - metadata 反射
2. 反射加载dll，读取module,类，方法，特性
3. 反射创建对象，反射+简单工厂+配置文件  破坏单例，创建泛型
4. 反射调用实例方法，静态方法，重载方法  调用私有方法，泛型方法
5. 反射字段和属性，分别获取值和设置值

1，通过图例来说明程序的运行过程，以及反射调用的内容来自运行过程的哪一个环节。

反射调用的是代码通过编译器编译之后的生成的dll中的元数据。这些元数据包括：应用程序集的描述，应用程序集中的模块，构造函数，方法，字段，事件，属性，参数信息。

通过反射得到相应的元数据元素，可以对其：创建对象，调用，设置值。

2，反射加载dll，读取模块，类，方法，特性

反射用到的命名空间有：System.Reflection  和 System.Type 

通过System.Reflection中的Assembly.Load("dll名称不要后缀")来加载dll返回一个Assembly的对象，再通过返回的Assembly对象中的GetType("dll名称+类名")返回一个对象，通过这个返回的对象来调用，设置该类中方法，属性，事件等等。

　　eg: Assembly assembly = Assembly.Load("Reflection.DB.MySql");

　　　  Type  type = assembly.GetType("Reflection.DB.MySql.MySqlHelper");

{
                Console.WriteLine("***************Reflection反射调用******************");
                Assembly assembly = Assembly.Load("Reflection.DB.MySql");
                foreach (var item in assembly.GetModules())
                {
                    Console.WriteLine(item.Name);
                }

                foreach (var item in assembly.GetTypes()) //获取所有的类
                {
                    Console.WriteLine(item.Name);
                }

                Type type = assembly.GetType("Reflection.DB.MySql.MySqlHelper");
                object objHelper = Activator.CreateInstance(type);  //调用了构造函数
                IDBHelper dbHelper = objHelper as IDBHelper;  //将objHelper转换为接口IDBHelper
                dbHelper.Query();
            }

3.1，反射创建对象，反射+简单工厂+配置文件

通过把以上的代码进行整理，抽取，用配置文件和简单工厂的方法来返回对象。

<appSettings>
  <add key="SqlHelperConfig" value="Reflection.DB.Oracle,Reflection.DB.Oracle.OracleHelper"/>
</appSettings>

再通过简单工厂来调用。

 public class SimpleFactory
    {
        //第2步简单工厂
        //静态字段读取配置文件中的内容
        private static string IDBHelperString = ConfigurationManager.AppSettings["SqlHelperConfig"];
        private static string DllName = IDBHelperString.Split(',')[0];  //获取dll名称
        private static string ClassName = IDBHelperString.Split(',')[1];  //获取类型名称

        public static IDBHelper CreateInstance()
        {
            Assembly assembly = Assembly.Load(DllName);
            Type type = assembly.GetType(ClassName);
           object objHelper =  Activator.CreateInstance(type);
            return objHelper as IDBHelper; 
        }
    }

这样做会增加应用程序的灵活性，比如现阶段应用程序使用的是MySql数据库需要换成oracle数据库。这样只需要再做一个类库去实现oracle的数据库操作改变配置文件中的dll和相应类库的名称即可。

3.2 破坏单例 创建泛型

/// <summary>
    /// 单例模式，保证进程中始终只有一个对象
    /// </summary>
    public sealed class Singleton
    {
        private static Singleton _Singleton = null;
        private Singleton()
        {
            Console.WriteLine("Singleton被构造");
        }

        static Singleton()
        {
            _Singleton = new Singleton();
        }

        public static Singleton GetInstance()
        {
            return _Singleton;
        }
    }

{
                Console.WriteLine("*************** 多构造函数，破坏单例，创建泛型 ******************");
                //第三步，调用多构造函数  
                Assembly assembly = Assembly.Load("Reflection.DB.SqlServer"); //加载dll
                Type type = assembly.GetType("Reflection.DB.SqlServer.Methods"); //加载类
                foreach (var item in type.GetConstructors())
                {   //打印所有的构造函数
                    Console.WriteLine(item.Name);
                }

                //调用构造函数
                Activator.CreateInstance(type);//调用默认的构造函数
                Activator.CreateInstance(type, new object[] { 123 });
                Activator.CreateInstance(type, new object[] { "ABC" });

                //反射调用私有构造方法，破坏单例，多次构造对象，调用私有的构造函数
                //单例：保证一个对象在进程中只有一个，并且只被构建一次
                Type singletonType = assembly.GetType("Reflection.DB.SqlServer.Singleton");
                object objSingleton1 = Activator.CreateInstance(singletonType, true);
                object objSingleton2 = Activator.CreateInstance(singletonType, true);
                object objSingleton3 = Activator.CreateInstance(singletonType, true);
                object objSingleton4 = Activator.CreateInstance(singletonType, true);

                //创建泛型
                Type genericType = assembly.GetType("Reflection.DB.SqlServer.GenericClass`3"); //泛型类有三个泛型参数 
                Type genericNewType = genericType.MakeGenericType(typeof(int), typeof(int), typeof(int));
                object objGeneric = Activator.CreateInstance(genericNewType);
            }

4，反射调用实例方法，静态方法，重载方法

 /// <summary>
    /// 反射测试类
    /// </summary>
    public class Methods
    {
        #region Identity
        /// <summary>
        /// 无参构造函数
        /// </summary>
        public Methods()
        {
            Console.WriteLine("这里是{0}无参数构造函数", this.GetType());
        }

        /// <summary>
        /// 带参数构造函数
        /// </summary>
        /// <param name="name"></param>
        public Methods(string name)
        {
            Console.WriteLine("这里是{0} 有参数构造函数", this.GetType());
        }

        public Methods(int id)
        {
            Console.WriteLine("这里是{0} 有参数构造函数", this.GetType());
        }
        #endregion

        #region Method
        /// <summary>
        /// 无参方法
        /// </summary>
        public void Show1()
        {
            Console.WriteLine("这里是{0}的Show1", this.GetType());
        }
        /// <summary>
        /// 有参数方法
        /// </summary>
        /// <param name="id"></param>
        public void Show2(int id)
        {

            Console.WriteLine("这里是{0}的Show2", this.GetType());
        }
        /// <summary>
        /// 重载方法之一
        /// </summary>
        /// <param name="id"></param>
        /// <param name="name"></param>
        public void Show3(int id, string name)
        {
            Console.WriteLine("这里是{0}的Show3", this.GetType());
        }
        /// <summary>
        /// 重载方法之二
        /// </summary>
        /// <param name="name"></param>
        /// <param name="id"></param>
        public void Show3(string name, int id)
        {
            Console.WriteLine("这里是{0}的Show3_2", this.GetType());
        }
        /// <summary>
        /// 重载方法之三
        /// </summary>
        /// <param name="id"></param>
        public void Show3(int id)
        {

            Console.WriteLine("这里是{0}的Show3_3", this.GetType());
        }
        /// <summary>
        /// 重载方法之四
        /// </summary>
        /// <param name="name"></param>
        public void Show3(string name)
        {

            Console.WriteLine("这里是{0}的Show3_4", this.GetType());
        }
        /// <summary>
        /// 重载方法之五
        /// </summary>
        public void Show3()
        {

            Console.WriteLine("这里是{0}的Show3_1", this.GetType());
        }
        /// <summary>
        /// 私有方法
        /// </summary>
        /// <param name="name"></param>
        private void Show4(string name)
        {
            Console.WriteLine("这里是{0}的Show4", this.GetType());
        }
        /// <summary>
        /// 静态方法
        /// </summary>
        /// <param name="name"></param>
        public static void Show5(string name)
        {
            Console.WriteLine("这里是{0}的Show5", typeof(Methods));
        }
        #endregion
    }

 public class 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);
        }
    }

    public class 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);
        }
    }

#region  反射调用实例方法，静态方法，重载方法 
            {
                Console.WriteLine("*************** 反射调用实例方法，静态方法，重载方法 ******************");
                //第三步，调用多构造函数  
                Assembly assembly = Assembly.Load("Reflection.DB.SqlServer"); //加载dll
                Type type = assembly.GetType("Reflection.DB.SqlServer.Methods"); //加载类
                foreach (var item in type.GetMethods())
                {   //打印所有的构造函数
                    Console.WriteLine(item.Name);
                }

                //调用构造函数,创建实例
                object obj = Activator.CreateInstance(type);
                {
                    //调用无参数的实例方法 
                    MethodInfo methodinfo = type.GetMethod("Show1");
                    methodinfo.Invoke(obj, null); 
                }
                {
                    //调用有参数的静态方法 
                    MethodInfo methodinfo = type.GetMethod("Show5");
                    //调用静态方法，对其调用方法或构造函数的对象可以传递也可以忽略
                    methodinfo.Invoke(obj, new object[] { "静态方法的参数1"});
                    methodinfo.Invoke(null, new object[] { "静态方法的参数2" }); 
                }
                {
                    //调用有参数的重载方法 1  ，参数为int
                    MethodInfo methodinfo = type.GetMethod("Show3",new Type[] {typeof(int)});
                    methodinfo.Invoke(obj, new object[] { 1 }); 
                }

                {
                    //调用有参数的重载方法 2 ， 参数为string
                    MethodInfo methodinfo = type.GetMethod("Show3",new Type[] { typeof(string)});
                    methodinfo.Invoke(obj, new object[] { "string类型重载方法" }); 
                }

                {
                    //调用有参数的重载方法 3 ， 参数为int , string
                    MethodInfo methodinfo = type.GetMethod("Show3", new Type[] { typeof(int),typeof(string) });
                    methodinfo.Invoke(obj, new object[] { 1,"string类型重载方法" });
                }

                {
                    //调用有参数的重载方法 4 ， 参数为string , int
                    MethodInfo methodinfo = type.GetMethod("Show3", new Type[] { typeof(string), typeof(int)});
                    methodinfo.Invoke(obj, new object[] { "string类型重载方法",1  });
                }
            }
            #endregion

4.2 反射调用私有方法，泛型方法

需要注意调用私有方法时候需要在type.GetMethod("MethodName",BindingFlag.Instance | BindingFlag.NonPublic);

另外需要注意在调用泛型类中的泛型方法和普通类中的泛型方法这两者的区别。

#region 反射调用私有方法，泛型方法
            {
                Console.WriteLine("*************** 反射调用私有方法，泛型方法 ******************");
                //第三步，调用多构造函数  
                Assembly assembly = Assembly.Load("Reflection.DB.SqlServer"); //加载dll
                Type type = assembly.GetType("Reflection.DB.SqlServer.Methods"); //加载类 

                //调用构造函数,创建实例
                object obj = Activator.CreateInstance(type);
                { 
                    MethodInfo methodinfo = type.GetMethod("Show4",BindingFlags.Instance | BindingFlags.NonPublic);
                    methodinfo.Invoke(obj, new object[] { "aaa" });
                }
                {
                    //调用普通类中的泛型方法
                    Type genericType = assembly.GetType("Reflection.DB.SqlServer.GenericMethod");
                    object genericObj = Activator.CreateInstance(genericType);
                    MethodInfo method = genericType.GetMethod("Show");
                    MethodInfo methodNew = method.MakeGenericMethod(new Type[] { typeof(int), typeof(int), typeof(int) });
                    methodNew.Invoke(genericObj, new object[] { 1, 2, 3 });
                }
                {
                    //调用泛型类中的泛型方法
                    Type genericType = assembly.GetType("Reflection.DB.SqlServer.GenericClass`3"); //泛型类有三个泛型参数 
                    Type genericNewType = genericType.MakeGenericType(typeof(int), typeof(int), typeof(int)); 
                    object objGeneric = Activator.CreateInstance(genericNewType);
                    MethodInfo method = genericNewType.GetMethod("Show");
                    method.Invoke(objGeneric, new object[] { 1, 2, 3 });
                }

            }
            #endregion

 5.1反射字段和属性

#region  反射字段和属性
            {

                People people = new People();
                people.Id = 1;
                people.Name = "ABC";
                people.Description = "一个中国人";
                Type type = typeof(People);
                object oPeople = Activator.CreateInstance(type);
                foreach (var item in type.GetProperties())
                {
                    //获取属性名称和默认值
                    Console.WriteLine("{0}={1}",item.Name,item.GetValue(people));
                }

                foreach (var item in type.GetFields())
                {
                    //获取字段名称和默认值
                    Console.WriteLine("{0}={1}", item.Name, item.GetValue(people));
                }

            }
            #endregion

5.2 反射操作数据库

 public T Get<T>(int id)
        {
            Type type = typeof(T);
            string columnStrings = string.Join(",", type.GetProperties().Select(p => string.Format("[{0}]", p.Name)));
            string sql = string.Format("SELECT {0} FROM {1} WHERE ID={2}", columnStrings, type.Name, id);
            object obj = Activator.CreateInstance(type);
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                connection.Open();
                SqlCommand command = new SqlCommand(sql, connection);
                SqlDataReader reader = command.ExecuteReader();
                if (reader.Read())
                {
                    foreach (var item in type.GetProperties())
                    {
                        item.SetValue(obj, reader[item.Name]);
                    }
                }
                connection.Close();
            }

            return (T)obj;
        }

调用代码：

region 反射拼装sql，从数据库中读取数据
            {
                SqlServerHelper sqlHelper = new SqlServerHelper();
                Company company = sqlHelper.Get<Company>(1);
                Type type = typeof(Company); 
                foreach (var item in type.GetProperties())
                {
                    Console.WriteLine("{0}={1}", item.Name, item.GetValue(company));
                }
            }
            #endregion