c#之反射详解

一、反射是什么？
1、C#编译运行过程
说到反射，就不得不说一下C#编译运行过程：

首先我们在VS点击编译的时候，就会将C#源代码编译成程序集
程序集以可执行文件 (.exe) 或动态链接库文件 (.dll) 的形式实现

程序集中包含有Microsoft 中间语言 (MSIL) 和必需的元数据。
元数据存储以下信息：

程序集的说明：标识（名称、版本、区域性、公钥）、导出的类型、该程序集所依赖的其他程序集、运行所需的安全权限。
类型的说明：名称、可见性、基类和实现的接口、成员（方法、字段、属性、事件、嵌套的类型）。
特性：修饰类型和成员的其他说明性元素。
在执行时，实时 (JIT) 编译器将 MSIL 转换为本机代码
运行 Microsoft 中间语言 (MSIL) 前，必须根据公共语言运行时将其编译为目标计算机基础结构的本机代码。

运行代码
公共语言运行时提供启用要发生的托管执行的基础结构以及执行期间可使用的服务

2、反射与元数据
反射 来自 System.Reflection命名空间，它可以读取程序集中的元数据，利用元数据创建对象，从而实现各种功能。

区分 反射 与 反编译，反射读取的是元数据，反编译读取的IL代码

3、反射的优缺点
优点：提高了程序的灵活性和扩展性，降低耦合度
缺点：由于反射多了一道程序，性能上相较于直接代码要慢
对于一些大型的项目，该用反射的地方还是要用，即使牺牲一点性能

二、反射的使用
1、反射相关的类和命名空间
反射命名空间
using System.Reflection;

反射相关的类
System.Type
System.AppDomain
System.Activator
System.Reflection.Assembly
System.Reflection.Module


System.Reflection.ConstructorInfo
System.Reflection.ParameterInfo
System.Reflection.MethodInfo
System.Reflection.PropertyInfo
System.Reflection.FieldInfo
System.Reflection.MemberInfo

1、System.Type类的应用
Type类中的基本属性

FullName ：获取该类型的完全限定名称，包括其命名空间，但不包括程序集

Type 中的 Assembly属性
        static void Main(string[] args)
        {
            Type type1 = typeof(User);

            //属性Assembly
            //获取声明该类型的 Assembly。
            //对于泛型类型，则获取定义该泛型类型的 Assembly。
            Assembly assembly = type1.Assembly;
            Console.WriteLine($"{assembly.FullName}");
            Console.ReadLine();
        }

通过Type对象我们也可以获取得到在其中申明了该类型的程序集，至于Assembly的用途将在Assembly那一节进行详细介绍

Type 中的 AssemblyQualifiedName 属性 和 FullName属性

上图中：类型的程序集限定名 的格式中的 全名称部分 即是 Type中的FullName属性值
FullName 获取该类型的完全限定名称，包括其命名空间，但不包括程序集

Type类的常用的方法
    // UserInfo类是为 介绍 Type类中常用方法 而准备的对象
    public class UserInfo
    {
        private int _num = 0;

        public string Phone = "1311111111";
        
        public string Name { get; set; }
        
        public string Address { get; set; }

        public UserInfo()
        {
            Console.WriteLine("UserInfo默认构造函数");
        }

        public UserInfo(string name)
        {
            Console.WriteLine($"UserInfo参数化构造函数：{name}");
        }

        public int PublicMethod()
        {
            return int.MinValue;
        }

        internal void InternalMethod ()
        { 
        
        }
        private void PrivateMethod()
        {
 
        }
    }


class Program
    {
        static void Main(string[] args)
        {
            UserInfo userInfo = new UserInfo();
            //【*】通过System.Object中的GetType()获取Type实例
            Type type = userInfo.GetType();

            //GetConstructors()获取所有的公共的构造函数
            ConstructorInfo[] constructorInfos= type.GetConstructors();

            foreach (var item in constructorInfos)
            {
                //GetParameters()获取指定方法或构造函数的参数
                ParameterInfo[] parameterInfos = item.GetParameters();
                foreach (var pi in parameterInfos)
                {
                    Console.WriteLine($"{item.Name}:{pi.Name}:{pi.ParameterType}");
                }              
            }

            //获取当前Type 实例的所有Public方法
            MethodInfo[] methodInfos = type.GetMethods();
            foreach (var item in methodInfos)
            {               
                Console.WriteLine($"{type.Name}类型中有：{item.Name}方法，返回类型为{item.ReturnType}");
            }

            //获取当前Type 实例的所有Public属性
            PropertyInfo[] propertyInfos = type.GetProperties();
            foreach (var item in propertyInfos)
            {
                Console.WriteLine($"{type.Name}类中有 属性-{item.Name} 类型为-{item.PropertyType}");
            }

            //获取当前Type 实例的所有Public字段
            FieldInfo[] fieldInfos = type.GetFields();
            foreach (var item in fieldInfos)
            {
                Console.WriteLine($"{type.Name}类中有 字段-{item.Name} 类型为-{item.FieldType}");
            }

            MemberInfo[] memberInfos = type.GetMembers();
            foreach (var item in memberInfos)
            {
                Console.WriteLine($"{type.Name}类中有 成员名称-{item.Name} 类型为-{item.MemberType}");
            }

            Console.ReadLine();
        }
    }


来张 代码贴图可能更为直观

由上可知，Type类给我们提供了很全面的 类型的 元数据的 获取方式。

BindingFlags
            Type type1 = Type.GetType("ConsoleApp1.UserInfo");
            //GetMembers 中传入 BindingFlags 相当于是对成员信息进行一个过滤
            //BindingFlags 不仅仅是GetMembers 专有，很多方法中都可以传入BindingFlags进行过滤

            //BindingFlags 是位标志枚举，可使用 | & ^ 等运算符 | 表示取并集，& 表示取交集，^ 表示取差集
            //BindingFlags.Public 表示公共成员
            //BindingFlags.NonPublic 表示非公共成员
            //BindingFlags.Instance 表示实例成员
            //BindingFlags.Static 表示静态成员
            MemberInfo[] memberInfos = type1.GetMembers(BindingFlags.NonPublic|BindingFlags.Instance);
            foreach (var item in memberInfos)
            {
                Console.WriteLine($"BindingFlags.NonPublic|BindingFlags.Instance（实例非公共成员）名称：{item.Name}");
            }

BindingFlags.Instance 和BindingFlags.Static ：实例成员是相对于静态成员而言的，多数情况下我们都省略了BindingFlags 这个参数，少数需要筛选成员的时候，传入该参数

获取Type 实例对象的三个方法


2、System.Activator类的应用
//Activator类主要用于创建对象的实例
Type type = typeof(UserInfo);
UserInfo userInfo=(UserInfo)Activator.CreateInstance(type);

3、System.Reflection.Assembly类的应用
对于程序集的限定名称使用小结

由上图代码可知：

程序集的显示名称，可通过Assembly.FullName 和 Assembly.GetName().FullName（即AssemblyName.FullName） 两种方式获取，这种获取的名称，一般是作为 Assembly.Load()的标准参数值
类型的程序集限定名，可通过Type类中的AssemblyQualifiedName属性获取（通常作为Type.GetType()方法中的参数值）， 相较于Assembly.FullName，名称格式上多了 Type.FullName 这一部分
Assembly类中的常用方法
Assembly.Load()方法接收一个String或AssemblyName类型作为参数，这个参数需要程序集的强名称
程序集的强名称：是程序集的FullName（具有名称，版本，语言，公钥标记）；
程序集的弱命名：只有程序集名称而没有版本，语言和公钥标记；平常我们创建的一个类库，如果没有特殊操作都属于是是弱名称程序集
Load(“强名称程序集”)查找程序集的顺序：首先它会去全局程序集缓存查找，然后到应用程序的根目录查找，最后会到应用程序的私有路径查找。
Load(“弱名称程序集”)查找程序集的顺序：首先到应用程序的根目录查找，最后会到应用程序的私有路径查找。
Assembly.LoadFrom() 根据程序集的文件名或路径，加载程序集；这个方法会加载此程序集引用的其他程序集
Assembly.LoadFile() 加载指定路径上的程序集文件内容，和上面方法的不同之处是这个方法不会加载此程序集引用的其他程序集

程序集加载的三种方式，可以在项目中添加该程序集的引用后使用，也可在未添加该程序集的情况下使用（某些情况下），这样就极大的丰富的项目的灵活性和扩展性

反射：创建对象的三种方式


反射： 调用构造函数创建对象详解


常用方法（包含Type类中的方法）

Invoke 调用静态方法，对象可以为null ,形如
methodInfo.Invoke(null, new object[] { "Activator.CreateInstance + type.GetMethod" });

Assembly assembly1 = Assembly.Load("ClassLibrary1");

            // GetTypes 获取程序集中的所有类型
            Type[] types = assembly1.GetTypes();
            foreach (var item in types)
            {
                if (item.FullName == "ClassLibrary1.Class1")
                {
                    Activator.CreateInstance(item);
                }
            }
            // 通过反射获取方法，然后执行
            // GetType("类型全名",是否引发异常,是否忽略大小写)
            Type type = assembly1.GetType("ClassLibrary1.Class1", false,false);
            object objt = Activator.CreateInstance(type);
            MethodInfo methodInfo = type.GetMethod("Show");

            //通过GetParameters获取方法的参数信息
            ParameterInfo[] parameterInfos = methodInfo.GetParameters();

            // 通过Invoke 调用方法
            // 对于方法而言，Invoke 至少需要传入两个参数，一个参数为 对象实例object，一个参数为方法参数列表 new object[]
            methodInfo.Invoke(objt,new object[] { "Activator.CreateInstance + type.GetMethod" });

            // 通过GetProperty 获取指定名称的属性
            PropertyInfo propertyInfo = type.GetProperty("Name");
            // SetValue 给属性赋值
            propertyInfo.SetValue(objt,"测试类");

            // 通过GetField 获取指定名称的字段
            FieldInfo fieldInfo = type.GetField("_num",BindingFlags.NonPublic);
            // SetValue 给属性赋值
            fieldInfo.SetValue(objt,12);

            Console.ReadLine();

4、System.Reflection.Module类的应用
暂无

5、System.AppDomain类的应用
一个AppDomain可以包含N个Assembly,一个Assembly可以包含N个Module,而一个Module可以包含N个Type.

暂无

6、dynamic 在反射中的应用
变量可以具有不同的编译时和运行时类型。 编译时类型是源代码中变量的声明或推断类型。 运行时类型是该变量所引用的实例的类型。

        static void Main(string[] args)
        {
            Type type = typeof(User);
            object o_user = Activator.CreateInstance(type);
            //o_user.Show() 
            //不可能通过o_class1 调用Show
            dynamic d_user = Activator.CreateInstance(type);
            d_user.Show("sss");
            //可以通过d_user 调用方法Show

            //其实o_user 和 d_user得到结果都是一样的，
            // 但是因为 object 时编译时类型，object本身没有Show方法，因此调用会报错
            // 而dynamic 是运行时类型，编译状态下会绕过编译器的检查，直到真正运行后才确定其数据类型
            Console.ReadLine();
        }

2、反射的应用
1、 数据库辅助类反射
原始情况下，我们写一个简单的SqlServer帮助类
    public class SqlServerHelper
    {
        private static readonly string _connectionString = "server=.;database=test;uid=sa;pwd=123";
        private SqlConnection _sqlConnection;

        //执行增删改
        public int ExecDML(string sql)
        {
            using (_sqlConnection = new SqlConnection(_connectionString))
            {
                _sqlConnection.Open();
                SqlCommand sqlCommand = new SqlCommand(sql,_sqlConnection);
                return sqlCommand.ExecuteNonQuery();
            }
        }
        //执行查询
        public DataSet ExecDQL(string sql)
        {
            using (_sqlConnection=new SqlConnection(_connectionString))
            {
                SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sql,_sqlConnection);
                DataSet dataSet = new DataSet();
                sqlDataAdapter.Fill(dataSet);
                return dataSet;
            }
        }
    }

//调用SqlServerHelper 中方法
    class Program
    {
        static void Main(string[] args)
        {
            SqlServerHelper sqlServerHelper = new SqlServerHelper();
            var data= sqlServerHelper.ExecDQL("select * from userinfo");
            var userName = data.Tables[0].Rows[0][1];
            Console.WriteLine(userName.ToString());
            Console.ReadLine();
        }
    }


选择 反射+配置文件的方式 实现，具体实现步骤如下：
1 创建一个接口
    interface IDbHelper
    {
        int ExecDML(string sql);
        DataSet ExecDQL(string sql);
    }

2 增加配置文件


3 实现接口
public class SqlServerHelper : IDbHelper
    {
        private static readonly string _connectionString = ConfigurationManager.ConnectionStrings["DbConnection"].ToString();
        
        public int ExecDML(string sql)
        {
            using (SqlConnection sqlConnection = new SqlConnection(_connectionString))
            {
                sqlConnection.Open();
                SqlCommand sqlCommand = new SqlCommand(sql, sqlConnection);
                return sqlCommand.ExecuteNonQuery();
            }
        }

        public DataSet ExecDQL(string sql)
        {
            using (SqlConnection sqlConnection = new SqlConnection(_connectionString))
            {
                SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sql, sqlConnection);
                DataSet dataSet = new DataSet();
                sqlDataAdapter.Fill(dataSet);
                return dataSet;
            }
        }
    }


这里主要是通过读取配置文件，确定数据库连接字符串：
ConfigurationManager.ConnectionStrings["DbConnection"].ToString();

4 通过反射+配置文件 调用 数据库执行语句的方法
        static void Main(string[] args)
        {
            string fullName = $"DbHelper.{ConfigurationManager.AppSettings["DbType"].ToString()}";
            IDbHelper dbHelper = (IDbHelper)Assembly.Load("DbHelper").CreateInstance(fullName);
            var data = dbHelper.ExecDQL("select * from userinfo");
            var userName = data.Tables[0].Rows[0][1];
            Console.WriteLine(userName.ToString());
            Console.ReadLine();
        }

从变更使用的数据库为MySql，分析两种方式应对需求的变动
对于原始方法我们需要再重写一个数据库帮助类（如MySqlHelper），然后重新生成帮助类类库文件，最后该调用的代码
如果按照反射+配置文件的方式实现，我们需要实现MySqlHelper类，然后重新生成类库，替换dll文件即可
这个案例只是一个初级的应用，便于理解反射；
反射的应用场景有：IOC容器，MVC框架，ORM，AOP等，因此理解好反射，对于上述知识点的掌握也是有帮助

结语
以上就是本文的内容，希望以上内容可以帮助到您，如文中有不对之处，还请批评指正。
————————————————
版权声明：本文为CSDN博主「鲤籽鲲」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_39847278/article/details/129816667