.NET Core 反射(Reflection)底层原理浅谈

a54546

简介

反射,反射,程序员的快乐。
前期绑定与后期绑定

在.NET中，前期绑定（Early Binding）是指在编译时就确定了对象的类型和方法，而后期绑定（Late Binding）或动态绑定是在运行时确定对象的类型和方法。
前置知识：C#类型系统结构

C#作为C++++ ，在类型系统上沿用C++的类型系统

前期绑定

在代码能执行之前，将代码中依赖的assembly,module,class,method,field等类型系统的元素提前构建好。
前期绑定的优点是编译时类型检查，提高了类型安全性和性能。缺点是如果需要更换类型，需要重新编译代码。灵活性不够

比如一个简单的的控制台，就自动提前加载了各种需要的DLL文件。完成前期绑定。
后期绑定

后期绑定的优点是可以在运行时更改类型，无需重新编译代码。缺点是在编译时不进行类型检查，可能导致运行时错误。
几个常用的场景，比如dynamic ，多态，System.Reflection等
举个例子，使用Reflection下的“元数据查询API”，动态加载DLL
            var dllpath = "xxx.dll";            Assembly assembly = Assembly.LoadFrom(dllpath);//构建Assembly+Module            Type dataAccessType = assembly.GetType("xxxxx");//构建Class(MethodTable+EEClass)            object dataAccess = Activator.CreateInstance(dataAccessType);//在托管堆中创建MT实例            MethodInfo addMethod = dataAccessType.GetMethod("Add");//构建MethodDesc                                    addMethod.Invoke(dataAccess, new object[] { "hello world" });//调用方法反射

反射的本质就是“操作元数据”
什么是元数据？

MetaData，本是上就是存储在dll中的一个信息数据库，记录了这个assembled中有哪些方法，哪些类，哪些属性等等信息

可以看到，各种Table组成的信息，是不是类似一个数据库？
举个例子：
执行Type.GetType("int"),反射会在MetaData寻找"int"的类型。但在运行时会返回null.因为MetaData中只有"System.Int32"这个字符串。
反射如何查询MetaData?

通过Reflection XXXInfo系列API 查询所有细节
Type t = typeof(System.IO.FileStream);FieldInfo[] fi = t.GetFields(BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);PropertyInfo[] pi = t.GetProperties(BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);EventInfo[] ei = t.GetEvents(BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);......反射如何构建类型系统

通过Reflection XXXBuilder系列API 构建一个全新的类型
            AssemblyBuilder ab = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("MyAssembly"), AssemblyBuilderAccess.RunAndCollect);//创建Assembly            ModuleBuilder mob = ab.DefineDynamicModule("MyModule");//创建Module            TypeBuilder tb = mob.DefineType("MyType", TypeAttributes.Public | TypeAttributes.Class);//创建Class            MethodBuilder mb = tb.DefineMethod("SumMethod", MethodAttributes.Public | MethodAttributes.Static, typeof(int), new Type[] { typeof(int), typeof(int) });//创建MethodTable            ILGenerator il = mb.GetILGenerator();//通过IL API 动态构建MethodDesc            il.Emit(OpCodes.Ldarg_0);            il.Emit(OpCodes.Ldarg_1);            il.Emit(OpCodes.Add);            il.Emit(OpCodes.Ret);            Type type = tb.CreateType();  //mt + eeclass            MethodInfo method = type.GetMethod("SumMethod");            Console.WriteLine(method.Invoke(null, new object[] { 5, 10 }));反射底层调用

C#的类型系统，与C++的类型系统是一一对应的。因此其底层必定是调用C++的方法。
示意图如下,有兴趣的小伙伴可以去参考coreclr的源码

眼见为实，以Invoke为例


反射到底慢在哪？

• 动态解析
  从上面可知道，反射作为后期绑定，在runtime中要根据metadata查询出信息，严重依赖字符串匹配，这本身就增加了额外的操作
  
• 动态调用
  使用反射调用方法时，先要将参数打包成数组，再解包到线程栈上。又是额外操作。
  
• 无法在编译时优化
  反射是动态的临时调用，JIT无法优化。只能根据代码一步一步执行。
  
• 额外的安全检查
  调用方法时，进行额外的安全性检查，检查参数类型是否正确。这也会增加一定的开销
  
• 缓存易失效
  反射如果参数发生变化，那么缓存的汇编就会失效。又需要重新查找与解析。
  

总之，千言万语汇成一句话。最好的反射就是不要用反射。除非你能保证对性能要求不高/缓存高命中率
眼见为实

点击查看代码    public class Person    {        public int Add(int a,int b)        {            return a + b;        }    }        public class TestBenchmark    {        private const int N= 1000000;                //原生调用        [Benchmark]        public int Method1()        {            int result = 0;            for (int i = 0; i <= N; i++)            {                var person = new Person();                result +=person.Add(i, i + 1);            }            return result;        }                //反射直接调用        [Benchmark]        public int Method2()        {            int result = 0;            for (int i = 0; i <<= N; i++)            {                object personInstance = Activator.CreateInstance(typeof(Person));                Type personType = personInstance.GetType();                MethodInfo addMethod = personType.GetMethod("Add", BindingFlags.Instance | BindingFlags.Public, null, new Type[] { typeof(int), typeof(int) }, null);                result +=(int) addMethod.Invoke(personInstance, new object[] { i, i + 1 });            }            return result;        }                //反射调用缓存        [Benchmark]        public int Method3()        {            //模拟数据被缓存            object personInstance = Activator.CreateInstance(typeof(Person));            Type personType = personInstance.GetType();            MethodInfo addMethod = personType.GetMethod("Add", BindingFlags.Instance | BindingFlags.Public, null, new Type[] { typeof(int), typeof(int) }, null);                        int result = 0;            for (int i = 0; i <= N; i++)            {                result += (int)addMethod.Invoke(personInstance, new object[] { i, i + 1 });            }            return result;        }    }

对于Invoke没有优化空间，只能从缓存元数据对象开始

CLR的对反射的优化

除了缓存反射的汇编，.NET 中提供了一系列新特性来尽可能的绕开“反射”
Cache



CLR在底层会尽可能的使用缓存对象，来提供性能
Emit

Emit 是 .NET 提供的一种动态生成和编译代码的技术。通过 Emit，我们可以动态生成一个新的方法，这个方法可以直接访问私有成员，这对于一些特殊场景非常有用，比如动态代理、代码生成器、AOP（面向切面编程）等.
public class Person{    private int _age;    public override string ToString()    {        return _age.ToString();    }}static void EmitTest(Person person){    // 获取Person类的类型对象    Type personType = typeof(Person);    // 获取私有字段_age的FieldInfo，无法避免部分使用反射    FieldInfo ageField = personType.GetField("_age", BindingFlags.Instance | BindingFlags.NonPublic);    if (ageField == null)    {        throw new ArgumentException("未找到指定的私有字段");    }    // 创建一个动态方法    DynamicMethod dynamicMethod = new DynamicMethod("SetAgeValue", null, new Type[] { typeof(Person), typeof(int) }, personType);    // 获取IL生成器    ILGenerator ilGenerator = dynamicMethod.GetILGenerator();    // 将传入的Person对象加载到计算栈上（this指针）    ilGenerator.Emit(OpCodes.Ldarg_0);    // 将传入的新值加载到计算栈上    ilGenerator.Emit(OpCodes.Ldarg_1);    // 将新值存储到对应的私有字段中    ilGenerator.Emit(OpCodes.Stfld, ageField);    // 返回（因为方法无返回值，这里只是结束方法执行）    ilGenerator.Emit(OpCodes.Ret);    // 创建委托类型，其签名与动态方法匹配    Action<Person, int> setAgeAction = (Action<Person, int>)dynamicMethod.CreateDelegate(typeof(Action<Person, int>));    // 通过委托调用动态生成的方法来修改私有字段的值    setAgeAction(person, 100);}

切构建代码又臭又长。

Expression

Expression 是 .NET 提供的一种表达式树的技术。通过 Expression，我们可以创建一个表达式树，然后编译这个表达式树，生成一个可以访问私有成员的方法
static void ExpressionTest(Person person){    // 获取Person类的类型对象    Type personType = typeof(Person);    // 获取私有字段_age的FieldInfo，无法避免部分使用反射    FieldInfo ageField = personType.GetField("_age", BindingFlags.Instance | BindingFlags.NonPublic);    if (ageField == null)    {        throw new ArgumentException("未找到指定的私有字段");    }    // 创建参数表达式，对应传入的Person对象实例    ParameterExpression instanceParam = Expression.Parameter(personType, "instance");    // 创建参数表达式，对应传入的新值    ParameterExpression newValueParam = Expression.Parameter(typeof(int), "newValue");    // 创建一个赋值表达式，将新值赋给私有字段    BinaryExpression assignExpression = Expression.Assign(Expression.Field(instanceParam, ageField), newValueParam);    // 创建一个包含赋值表达式的表达式块，这里因为只有一个赋值操作，所以块里就这一个表达式    BlockExpression blockExpression = Expression.Block(assignExpression);    // 创建一个可执行的委托，其类型与表达式块的逻辑匹配    Action<Person, int> setAgeAction = Expression.Lambda<Action<Person, int>>(blockExpression, instanceParam, newValueParam).Compile();    // 通过委托调用表达式树生成的逻辑来修改私有字段的值    setAgeAction(person, 100);}

切构建代码又臭又长。

UnsafeAccessorAttribute

.Net 8中引入了新特性UnsafeAccessorAttribute 。
使用该特性，来提供对私有字段的快速修改
static void New(){    var person = new Person();    GetAgeField(person) = 100;}[UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_age")]static extern ref int GetAgeField(Person counter);为什么它这么快？

对于C#来说，私有类型是OOP语言的定义。它定义了什么是私有类型，它的行为是什么。
但对于程序本身来说，代码和数据都只是一段内存，实际上你的指针想访问哪就访问哪。哪管你什么私有类型。换一个指向地址不就得了。因此CLR开放了这么一个口子，利用外部访问直接操作内存。看它的命名UnsafeAccessor就能猜到意图了
3，2，1. 上汇编！！！

直接将rax寄存器偏移量+8，直接返回int(占用4字节，偏移量8)类型的_age。 没有Emit，Expression的弯弯绕绕，丝毫不拖泥带水。
.NET 9中的改进

支持泛型，更优雅。
https://learn.microsoft.com/zh-cn/dotnet/core/compatibility/core-libraries/9.0/unsafeaccessor-generics
参考资料

https://blog.csdn.net/sD7O95O/article/details/133002995
https://learn.microsoft.com/zh-cn/dotnet/api/system.runtime.compilerservices.unsafeaccessorattribute?view=net-8.0