静态非捕获Lambda返回数据：Unsafe实现是否合法？有无更优方案？

现有简化方法：

static void Invoke<TArg>(Action<TArg> action, TArg arg) => action(arg);

需求是：在带有引用参数（ref/out）的方法中调用Invoke，传入作为action的static（非捕获）Lambda，并从Lambda内部为引用参数返回值。

本人实现了基于Unsafe类的方案：

static unsafe void UpdateFooAndGetBar(ref object foo, out object bar) {
    var args = (foo, bar: (object)null);
    Invoke(
        static pArgs => {
            ref var args = ref Unsafe.AsRef<(object, object)>(pArgs.ToPointer());
            args.Item1 = 123;
            args.Item2 = "baz";
        },
        new IntPtr(Unsafe.AsPointer(ref args))
    );
    foo = args.foo;
    bar = args.bar;
}

该方案看似可行，但Unsafe类的使用让我担忧，请问此代码是否合法？是否有更优实现方式？

关于代码合法性 #

这段代码在当前.NET运行时环境下能正常执行，但存在严重的安全隐患和不可靠性：

• 你通过Unsafe.AsPointer获取局部变量args的指针，再包装成IntPtr传入Lambda。虽然当前栈帧在Invoke调用期间不会销毁，但这种操作完全依赖运行时的栈布局行为，属于未定义行为——未来.NET运行时的栈优化（比如栈重排、逃逸分析）可能导致指针失效，引发内存访问错误。
• static Lambda的设计意图是不捕获外部变量，你通过手动传递指针绕开了这个限制，本质上破坏了代码的类型安全性。

更优实现方式 #

不需要依赖Unsafe类，有两种类型安全、可靠的实现方案：

方案1：自定义带引用字段的结构体（可修改Invoke时优先用） #

// 定义包含引用字段的结构体，用于传递ref/out参数
private struct ArgsHolder
{
    public ref object Foo;
    public out object Bar;
}

static void UpdateFooAndGetBar(ref object foo, out object bar)
{
    var args = new ArgsHolder { Foo = ref foo, Bar = out bar };
    Invoke(
        static (ref ArgsHolder holder) => {
            holder.Foo = 123;
            holder.Bar = "baz";
        },
        ref args
    );
}

// 给Invoke增加支持ref参数的重载
static void Invoke<TArg>(Action<ref TArg> action, ref TArg arg) => action(ref arg);

通过带ref/out字段的结构体，直接将原始引用传递给static Lambda，完全不需要不安全代码，行为可预测且类型安全。

方案2：使用包装类（无法修改Invoke时用） #

private class ArgsWrapper
{
    public object Foo;
    public object Bar;
}

static void UpdateFooAndGetBar(ref object foo, out object bar)
{
    var wrapper = new ArgsWrapper { Foo = foo };
    Invoke(
        static (wrapper) => {
            wrapper.Foo = 123;
            wrapper.Bar = "baz";
        },
        wrapper
    );
    foo = wrapper.Foo;
    bar = wrapper.Bar;
}

利用类的引用类型特性，将ref/out参数的值包装进类实例，static Lambda通过访问类字段修改值，完全符合.NET类型系统规则，兼容性和可靠性拉满。

内容的提问来源于stack exchange，提问作者Andromedary