C# 基础知识-反射

一.反射

1>反射的命名空间是System.Reflection

2>是.Net框架提供的帮助类库，读取并使用matedata

二.反射基本用法

举例如下

 1>Assembly assembly Assembly.Load("DB.MySql");//1.反射加载DLL (DLL名称是DB.MySql),用Assembly动态加载程序集

 2>Type type = assembly.GetType("DB.MySql.MySqlHelper");//2.获取类型信息（命名空间+类名 ：DB.MySql+MySqlHelper）

 3>object oDBHelper = Activator.CreateInstance(type);//3. 用Activator创建对象

 4>IDBHelper iDBHelper = (IDBHelper)oDBHelper;//4 类型转换，把object对象oDBHelper，通过强制转换为接口IDBHelper

 5>iDBHelper.Query();//5 方法调用，传建好了接口对象iDBHelper，调用方法Query()

三.反射用在哪里

主流框架MVC,IOC,ORM和DOT模型都在用反射，反射最主要的特点就是“动态”

1>IOC（IOC=简单工厂+配置文件+反射）

-之前调用dll，都是先引用dll，添加命名空间，然后创建对象。现在可以动态加载dll，动态获取类型，动态创建对象。

IDBHelper iDBHeler = Factory.CreateHelper();//Factory工厂主要作用是创建对象
iDBHeler.Query();//可以调用对象的方法了,反射是动态的 依赖的是字符串

    /// <summary>
    /// 创建对象
    /// </summary>
    public  class Factory
    {
        private static string IDBHelperConfig = ConfigurationManager.AppSettings["IDBHelperConfig"];
        private static string DllName = IDBHelperConfig.Split(',')[1];
        private static string TypeName = IDBHelperConfig.Split(',')[0];


        public static IDBHelper CreateHelper()//1 2
        {
            Assembly assembly = Assembly.Load(DllName);//1 加载dll
            Type type = assembly.GetType(TypeName);//2 获取类型信息
            object oDBHelper = Activator.CreateInstance(type);//3 创建对象
            IDBHelper iDBHelper = (IDBHelper)oDBHelper;//4 类型转换
            return iDBHelper;
        }
    }

2>MVC（主要是通过反射，调用方法）

 MVC是通过反射，创建对象，然后通过方法名称，达到调用方法的目的

                    //MVC 类名称+方法名称 3                     Assembly assembly = Assembly.Load("DB.SqlServer");
                    Type type = assembly.GetType("DB.SqlServer.ReflectionTest");
                    object oReflectionTest = Activator.CreateInstance(type);
                    {
                        MethodInfo method = type.GetMethod("Show4", BindingFlags.Instance | BindingFlags.NonPublic);//Show4的访问修饰符是Private
                        method.Invoke(oReflectionTest, new object[] { "4" });
                    }
                    {
                        MethodInfo method = type.GetMethod("Show1");//调用无参数方法
                        method.Invoke(oReflectionTest, null);
                    }
                    {
                        MethodInfo method = type.GetMethod("Show2");//调用有参数方法（拿int举例）
                        method.Invoke(oReflectionTest, new object[] { 123 });
                    }
                    {
                        MethodInfo method = type.GetMethod("Show5");
                        method.Invoke(oReflectionTest, new object[] { "麦田的稻草人" });//调用静态方法,Show5是静态方法，第一个object对象传入不传入都可以
                        method.Invoke(null, new object[] { "果然" });
                    }
                    {
                        MethodInfo method = type.GetMethod("Show3", new Type[] { });//调用重载方法,Show3是重载方法
                        method.Invoke(oReflectionTest, new object[] { });
                    }
                    {
                        MethodInfo method = type.GetMethod("Show3", new Type[] { typeof(int) });
                        method.Invoke(oReflectionTest, new object[] { 123 });
                    }
                    {
                        MethodInfo method = type.GetMethod("Show3", new Type[] { typeof(string) });
                        method.Invoke(oReflectionTest, new object[] { "Ant" });
                    }
                    {
                        MethodInfo method = type.GetMethod("Show3", new Type[] { typeof(int), typeof(string) });
                        method.Invoke(oReflectionTest, new object[] { 234, "W" });
                    }
                    {
                        MethodInfo method = type.GetMethod("Show3", new Type[] { typeof(string), typeof(int) });
                        method.Invoke(oReflectionTest, new object[] { "W", 234 });
                    }

下面这个类，是反射测试类

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

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

        public ReflectionTest(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(ReflectionTest));
        }
        #endregion
    }

3>ORM（通过反射，调用属性和字段或者设置属性的值）

                    People people = new People();
                    people.Id = 123;
                    people.Name = "Look";
                    people.Description = "二年级学生";
                    {
                        Type typePeople = typeof(People);
                        Type typePeopleDTO = typeof(PeopleDTO);
                        object peopleDTO = Activator.CreateInstance(typePeopleDTO);
                        foreach (var prop in typePeopleDTO.GetProperties())
                        {
                            object value = typePeople.GetProperty(prop.Name).GetValue(people);
                            prop.SetValue(peopleDTO, value)；
                        }
                        foreach (var filed in typePeopleDTO.GetFields())
                        {
                            object value = typePeople.GetField(filed.Name).GetValue(people);
                            filed.SetValue(peopleDTO, value);
                        }
                    }

下面是people实体类

   /// <summary>
    /// 实体
    /// </summary>
    public class People
    {
        public People()
        {
            Console.WriteLine("{0}被创建", this.GetType().FullName);
        }

        public int Id { get; set; }
        public string Name { get; set; }
        public string Description;
    }

    public class PeopleDTO
    {
        public PeopleDTO()
        {
            Console.WriteLine("{0}被创建", this.GetType().FullName);
        }
        public int Id { get; set; }
        public string Name { get; set; }//ShortName  特性

        public string Description;
    }
}