【.NET8】访问私有成员新姿势UnsafeAccessor(上)

UnsafeAccessor,成员,NET8 · 浏览次数 : 1587

小编点评

**UnsafeAccessor概述** UnsafeAccessor是一种更方便、更高效的访问私有成员的方法,它支持修改私有成员的值。 **主要特性** * 支持访问私有成员的私有字段、私有构造方法和私有属性。 * 支持修改私有成员的值。 * 支持使用Reflection、Emit和Expression等方法访问私有成员。 * 支持使用UnsafeAccessor访问私有成员的私有字段、私有构造方法和私有属性。 **示例** ```csharp UnsafeAccessor access = UnsafeAccessor.Get(obj); access.Set("Hello World"); ``` **用途** UnsafeAccessor可用于各种场景,例如: * 在私有类型中访问私有成员的值。 * 在私有构造方法中设置私有成员的值。 * 在私有属性中访问私有成员的值。 * 在修改私有成员的值时进行安全操作。 **局限性** * unsafeAccessor方法只能访问私有成员的私有字段、私有构造方法和私有属性。 * unsafeAccessor方法不能访问私有类型。 * unsafeAccessor方法不能访问私有类型参数。 * unsafeAccessor方法不支持通用泛型。

正文

前言

前几天在.NET性能优化群里面,有群友聊到了.NET8新增的一个特性,这个类叫UnsafeAccessor,有很多群友都不知道这个特性是干嘛的,所以我就想写一篇文章来带大家了解一下这个特性。

其实在很早之前我就有关注到这个特殊的特性,但是当时.NET8还没有正式发布,所以我也没有写文章,现在.NET8已经RC了,很快就会发布正式版,而且刚好有了一些时间,所以也可以带大家了解一下这个新的特性。

由于篇幅原因,这篇文章会分为上下两篇,其中上篇会带大家了解UnsafeAccessor是干嘛的,有哪些用法,下篇会带大家了解UnsafeAccessor的性能比较以及它的实现原理。

首先在我们了解这个类之前要假设一个场景,在很多时候我们都会遇到这样的场景,就是我们需要在一个类中访问另外一个类的私有成员,比如有如下代码:


var a = new A();
Console.WriteLine(a._value);

public class A
{
    private int _value = 10;
}

在上面的代码中,我们在类B中访问了类A的私有成员_value,这种情况在我们的实际开发中是很常见的,但是在.NET中是不允许的,因为私有成员是不允许被外部访问的,所以我们在类B中是不能访问类A的私有成员_value的,但是在实际的开发中,我们有时候确实需要访问类A的私有成员_value,这个时候我们该怎么办呢?下面我们来看一下如何访问私有成员。

.NET8以前的解决方案

在.NET8之前,我们可以通过如下的几种方法来访问私有成员,分别是反射、Emit、Expression,下面我们分别来看一下这几种方法。

反射

在.NET中,有一种叫反射的技术,这个对于任何一个.NET开发工程师应该都不陌生,我们可以通过反射来访问程序集的元数据信息,调用方法,访问字段等等,所以可以通过反射来访问私有成员,比如下面的代码我们可以通过反射来访问私有成员,如下所示:


var a = new A();
// 反射访问私有成员
var value = typeof(A).GetField("_value", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(a);
Console.WriteLine(value);

public class A
{
    private int _value = 10;
}

在上面的代码中,我们通过反射来访问了类A的私有成员_value,这样就可以访问到了,但是这种方式有一个缺点,就是性能比较差,因为反射是通过查找元数据和临时调用来实现的,所以性能比较差。在实际的开发中,我们一般不会使用反射来访问私有成员。

Emit

Emit 是 .NET 提供的一种动态生成和编译代码的技术。通过 Emit,我们可以动态生成一个新的方法,这个方法可以直接访问私有成员,这样就避免了反射的性能问题。以下是一个使用 Emit 访问私有成员的例子:


var a = new A();

// 创建一个动态方法,签名为 int GetValue(A a)
var method = new DynamicMethod("GetValue", typeof(int), new Type[] { typeof(A) }, typeof(A));

// 获取方法的 ILGenerator,通过 Emit 生成方法体
var il = method.GetILGenerator();

// 将参数 a 的私有成员 _value 压入堆栈
il.Emit(OpCodes.Ldarg_0);

// 将私有成员 _value 压入堆栈
il.Emit(OpCodes.Ldfld, typeof(A).GetField("_value", BindingFlags.NonPublic | BindingFlags.Instance));

// 返回栈顶的值
il.Emit(OpCodes.Ret);

// 通过 Emit 创建的方法,可以直接访问私有成员 _value
var func = (Func<A, int>)method.CreateDelegate(typeof(Func<A, int>));

// 调用方法
var value = func(a);
Console.WriteLine(value);

public class A
{
    private int _value = 10;
}

在上面的代码中,我们通过 Emit 创建了一个新的方法,这个方法可以直接访问类 A 的私有成员 _value。这种方法的性能比反射好很多,但是代码比较复杂,不易于维护。

Expression

Expression 是 .NET 提供的一种表达式树的技术。通过 Expression,我们可以创建一个表达式树,然后编译这个表达式树,生成一个可以访问私有成员的方法。以下是一个使用 Expression 访问私有成员的例子:


var a = new A();

// 创建一个表达式树,访问私有成员 _value
var parameter = Expression.Parameter(typeof(A), "x");

// 访问私有成员 _value
var field = Expression.Field(parameter, typeof(A).GetField("_value", BindingFlags.NonPublic | BindingFlags.Instance));

// 编译表达式树,生成一个可以访问私有成员 _value 的方法
var lambda = Expression.Lambda<Func<A, int>>(field, parameter);

// 调用方法
var func = lambda.Compile();
var value = func(a);
Console.WriteLine(value);

public class A
{
    private int _value = 10;
}

在上面的代码中,我们通过 Expression 创建了一个表达式树,然后编译这个表达式树,生成了一个可以访问类 A 的私有成员 _value 的方法。这种方法的性能比反射好,代码也相对简单,但是仍然比直接访问复杂。

.NET8的解决方案

我想很多聪明的小伙伴都已经猜到了,在.NET8中新增的UnsafeAccessor就是用来访问私有成员的,我们可以通过UnsafeAccessor来访问私有成员,下面我们来看一下如何使用UnsafeAccessor来访问私有成员。

私有字段

using System.Runtime.CompilerServices;

[UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_value")]
static extern ref int GetValue(A a);

var a = new A();
var value = GetValue(a);
Console.WriteLine(value);

public class A
{
    private int _value = 10;
}

首先我们需要引入System.Runtime.CompilerServices这个命名空间,然后定义一个staic extern ref方法,这个方法的返回值类型是字段的类型,然后它的参数就是对应实例的类型。在方法上面我们需要添加一个UnsafeAccessor特性,这个特性有一个参数UnsafeAccessorKind,这个参数表示我们要访问的是什么类型的私有成员,比如字段、属性、方法等等,这里我们要访问的是字段,所以我们传入的是UnsafeAccessorKind.Field,然后我们还需要指定要访问的字段的名称,这里我们要访问的是_value字段,所以我们传入的是Name = "_value",这样我们就可以通过UnsafeAccessor来访问私有成员了。

来看一下运行的结果,可以看到和我们预期的一样输出了10

因为它是返回了ref的引用,所以我们可以通过这个引用来修改私有成员的值,比如我们修改一下_value的值,如下所示:

using System.Runtime.CompilerServices;

[UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_value")]
static extern ref int ValueAccessor(A a);

var a = new A();
ref var value = ref ValueAccessor(a);
Console.WriteLine(value);

value = 20;
Console.WriteLine(ValueAccessor(a));

public class A
{
    private int _value = 10;
}

来看一下运行的结果,可以看到我们修改了_value的值,第二次输出的时候就变成了20

私有构造方法

同样的,使用UnsafeAccessor我们也可以访问类中的私有构造方法和私有的方法,我们可以看到UnsafeAccessor有一个参数UnsafeAccessorKind,这个参数表示我们要访问的是什么类型的私有成员,比如字段、属性、方法等等,下方是它的定义:

private enum UnsafeAccessorKind
{
    Constructor,
    Method,
    StaticMethod,
    Field,
    StaticField
};

先来看一下如何访问私有构造方法,如下所示:

using System.Runtime.CompilerServices;

[UnsafeAccessor(UnsafeAccessorKind.Constructor)]
static extern A CreateA(int value);

var a = CreateA(10);
Console.WriteLine(a.Value);

public class A
{
    public readonly int Value;

    private A(int value)
    {
        Value = value;
    }
}

在上面的代码中,我们通过UnsafeAccessor访问了类A的私有构造方法,这个私有构造方法的参数是int类型的,我们可以看到我们通过UnsafeAccessor访问了私有构造方法,然后创建了一个A的实例,然后输出了Value的值,可以看到输出的结果是10,这样我们就可以通过UnsafeAccessor来访问私有构造方法了。

私有属性

由于属性是语法糖,编译器会自动为我们生成一个getset方法,比如public int Value {get; set;},就会自动生成一个get_Valueset_Value方法,我这里就不单独对访问私有方法进行演示,直接演示访问私有属性,它和访问私有方法是一样的,如下所示:

using System.Runtime.CompilerServices;

[UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_Value")]
static extern int GetValue(A a);

[UnsafeAccessor(UnsafeAccessorKind.Method, Name = "set_Value")]
static extern void SetValue(A a, int value);

var a = new A();
SetValue(a, 10);
Console.WriteLine(GetValue(a));

public class A
{
    public int Value { get; set; }
}

在上面的代码中,我们通过UnsafeAccessor访问了类A的私有属性Value,这个私有属性有getset方法,我们通过UnsafeAccessor访问了getset方法,然后我们就可以访问私有属性了,这样我们就可以通过UnsafeAccessor来访问私有属性了。

局限性

当然,现在使用UnsafeAccessor还有一些局限性,大家在使用的过程中需要注意一下。

通用泛型

比如现阶段它不支持通用泛型,像下面这样的代码是不支持的:

[UnsafeAccessor(UnsafeAccessorKind.Field, Name="_myList")]
static extern ref List<T> Field<T>(MyClass<T> _this);

但是现在可以写成下方这样的代码:

[UnsafeAccessor(UnsafeAccessorKind.Field, Name="_myList")]
static extern ref List<string> StringField(MyClass<string> _this);

[UnsafeAccessor(UnsafeAccessorKind.Field, Name="_myList")]
static extern ref List<double> DoubleField(MyClass<double> _this);

不过这会在.NET9中解决,有兴趣的小伙伴可以关注下方的链接:
https://github.com/dotnet/runtime/issues/89439

私有类型

比如有下面这样的一个示例代码:

// Assembly A
private class C
{
    private static int Method(int a) { ... }
}

// Assembly B
[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name="Method")]
static extern int CallMethod(??? c, int a); 

这里的问题是,我们不知道如何定义CallMethod的第一个参数,因为C是私有的,我们无法在CallMethod的入参中定义它。

静态类

比如有下面这样的一个示例代码:

// Assembly A
public static class C
{
    private static int Method(int a) { ... }
}

// Assembly B
[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name="Method")]
static extern int CallMethod(??? c, int a); 

这里的问题是,我们无法在B中定义CallMethod的第一个参数,因为C是静态的,我们无法在CallMethod的入参中定义它。

私有类参数

比如有下面这样的一个示例代码:

// Assembly A
public class C
{
    private class D { }
    private static int Method(D d) { ... }
}

// Assembly B
[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name="Method")]
static extern int CallMethod(??? d); // Unable express D type as a parameter.

这里的问题是,我们无法在B中定义CallMethod的入参,因为D是私有的,我们无法在CallMethod的入参中定义它。包括目前还有私有返回值参数也是无法定义的。

但是这些问题在.NET9中也会解决,有兴趣的小伙伴可以关注下方的链接:

https://github.com/dotnet/runtime/issues/90081

总结

在本文中,首先介绍了在.NET8之前访问私有成员的几种方法,包括反射、Emit、和Expression。这些方法虽然可以实现访问私有成员,但是各有其优缺点,例如反射性能较差,Emit和Expression代码复杂度较高。

随后,我们详细介绍了.NET8新增的特性UnsafeAccessor,这是一种更方便、更高效的访问私有成员的方法。我们通过实例代码演示了如何使用UnsafeAccessor访问私有成员,包括私有字段、私有构造方法和私有属性。并且,UnsafeAccessor还支持修改私有成员的值。

然而,UnsafeAccessor目前还存在一些局限性,例如不支持通用泛型,无法访问私有类型、静态类和私有类参数。但是,这些问题预计在.NET9中将得到解决。

总的来说,UnsafeAccessor为.NET开发者提供了一个新的工具,使我们能够更方便、更高效地访问私有成员。虽然当前还存在一些局限性,但随着.NET的不断发展和进步,我们有理由相信这些问题将会得到解决。同时,我们也期待.NET在未来能够提供更多的功能和特性,以满足我们日益增长的开发需求。

.NET性能优化交流群

相信大家在开发中经常会遇到一些性能问题,苦于没有有效的工具去发现性能瓶颈,或者是发现瓶颈以后不知道该如何优化。之前一直有读者朋友询问有没有技术交流群,但是由于各种原因一直都没创建,现在很高兴的在这里宣布,我创建了一个专门交流.NET性能优化经验的群组,主题包括但不限于:

  • 如何找到.NET性能瓶颈,如使用APM、dotnet tools等工具
  • .NET框架底层原理的实现,如垃圾回收器、JIT等等
  • 如何编写高性能的.NET代码,哪些地方存在性能陷阱

希望能有更多志同道合朋友加入,分享一些工作中遇到的.NET性能问题和宝贵的性能分析优化经验。目前一群已满,现在开放二群。

如果提示已经达到200人,可以加我微信,我拉你进群: ls1075

另外也创建了QQ群,群号: 687779078,欢迎大家加入。

抽奖送书活动预热!!!

感谢大家对我公众号的支持与陪伴!为庆祝公众号一周年,抽奖送出一些书籍,请大家关注公众号后续推文!

image-20230703203249615

与【.NET8】访问私有成员新姿势UnsafeAccessor(上)相似的内容:

【.NET8】访问私有成员新姿势UnsafeAccessor(上)

前言 前几天在.NET性能优化群里面,有群友聊到了.NET8新增的一个特性,这个类叫UnsafeAccessor,有很多群友都不知道这个特性是干嘛的,所以我就想写一篇文章来带大家了解一下这个特性。 其实在很早之前我就有关注到这个特殊的特性,但是当时.NET8还没有正式发布,所以我也没有写文章,现在.

【.NET8】访问私有成员新姿势UnsafeAccessor(下)

前言 书接上回,我们讨论了在.NET8中新增的UnsafeAccessor,并且通过UnsafeAccessor访问了私有成员,这极大的方便了我们代码的编写,当然也聊到了它当前存在的一些局限性,那么它的性能到底如何?我们今天就来实际测试一下。 测试代码 话不多说,直接上代码,本次测试代码如下: us

C# 12 中的新增功能

新的 C# 12 功能在预览版中已经引入. 您可以使用最新的 Visual Studio 预览版或最新的 .NET 8 预览版 SDK 来尝试这些功能。以下是一些新引入的功能: 主构造函数 集合表达式 默认 Lambda 参数 任何类型的别名 内联数组 拦截器 使用nameof访问实例成员 主构造函

.Net8 AddKeyedScoped键值key注册服务异常

异常描述:This service descriptor is keyed. Your service provider may not support keyed services. 场景:.Net8 WebAPI应用程序中使用AutoFac替代了默认的DI容器 当使用键值注册服务后: build

NET8中增加的简单适用的DI扩展库Microsoft.Extensions.DependencyInjection.AutoActivation

这个库提供了在启动期间实例化已注册的单例,而不是在首次使用它时实例化。 单例通常在首次使用时创建,这可能会导致响应传入请求的延迟高于平时。在注册时创建实例有助于防止第一次Request请求的SLA 以往我们要在注册的时候启动单例可能会这样写: //注册: services.AddSingleton<

.NET8 Identity Register

分享给需要帮助的人:记一次 IdentityAPI 中注册的源码解读:设置用户账户为未验证状态,以及除此之外更安全的做法: 延迟用户创建。包含了对优缺点的说明,以及适用场景。 在ASP.NET 8 Identity 中注册API的源码如下: routeGroup.MapPost("/register

.NET8中的Microsoft.Extensions.Http.Resilience库

接上一篇,https://www.cnblogs.com/vipwan/p/18129361 借助Aspire中新增的Microsoft.Extensions.ServiceDiscovery库,我们可以很容易的做到服务发现,那么服务节点的熔断限流以及重试等弹性机制.NET是怎么处理的呢? 比如下图

【c#版本Openfeign】Net8 自带OpenFeign实现远程接口调用

引言 相信巨硬,我们便一直硬。Net版本到现在已经出了7了,8也已经在预览版了,相信在一个半月就会正式发布,其中也有很多拭目以待的新功能了,不仅仅有Apm和Tap的结合,TaskToAscynResult,以及UnsafeAccessor用来获取私有变量,性能比反射,EMIT更高,还有针对Async

【Azure Developer】一个复制Redis Key到另一个Redis服务的工具(redis_copy_net8)

介绍一个简单的工具,用于将Redis数据从一个redis端点复制到另一个redis端点,基于原始存储库转换为.NET 8:https://github.com/LuBu0505/redis-copy-net8

【.NET 8】ASP.NET Core计划 - 支持更完善的AOT发布

.NET7.0刚发布不久,.NET社区开始了.NET8.0的开发,重心重新回到了新功能的迭代。 我们知道在.NET7.0中一个令人激动的特新就是支持了NativeAOT,我们可以通过NativeAOT生成本机程序,由于无需JIT编译,所以无需安装.NET Runtime,也进一步的提升了.程序的启动