前言

今天跟大家分享一个我最近发现的 ref 一个非常鬼畜用法：ref return。这个新的语法糖可以让我们直接返回结构体的引用（我的理解是这样），而不是结构体的副本，从而实现了结构体跟引用类型近似的使用方式，保持了用户惯性和开发直觉。听起来很神奇吧？那就跟我一起来看看吧！

一、常识中的 ref

我们都知道，C#中有两种类型：值类型和引用类型。值类型包括基本类型（int, float, bool等）和结构体（struct），引用类型包括类（class）、数组（array）和字符串（string）。值类型和引用类型的区别在于，值类型在内存中存储的是数据本身，而引用类型在内存中存储的是数据的地址。因此，当我们把值类型作为参数传递给一个方法时，实际上是把数据本身复制了一份给方法，这就叫做值传递（pass by value）。而当我们把引用类型作为参数传递给一个方法时，实际上是把数据的地址复制了一份给方法，这就叫做引用传递（pass by reference）。

值传递和引用传递有什么区别呢？区别就在于，如果我们在方法内部修改了参数的值，那么对于值传递来说，只会影响方法内部的局部变量，不会影响方法外部的原始变量；而对于引用传递来说，会影响方法内外的同一个变量。举个例子：

using System;

class Program
{
    static void Main(string[] args)
    {
        int a = 10; // 值类型
        string b = "Hello"; // 引用类型
        Console.WriteLine($"Before: a = {a}, b = {b}");
        Change(a, b);
        Console.WriteLine($"After: a = {a}, b = {b}");
    }

    static void Change(int x, string y)
    {
        x = 20;
        y = "World";
        Console.WriteLine($"Inside: x = {x}, y = {y}");
    }
}

输出结果是：

Before: a = 10, b = Hello
Inside: x = 20, y = World
After: a = 10, b = Hello

可以看到，在Change方法内部，我们修改了x和y的值，但是在Change方法外部，a和b的值并没有改变。这是因为x和y只是a和b的副本，修改它们并不会影响a和b。

那么有没有办法让我们在方法内部修改值类型参数的值，并且让这个修改反映到方法外部呢？答案是有的，那就是使用ref关键字。ref关键字可以让我们把值类型参数作为引用传递给方法，也就是说，不再复制数据本身，而是复制数据的地址。这样一来，在方法内部修改参数的值，就相当于修改了原始变量的值。例如：

using System;

class Program
{
    static void Main(string[] args)
    {
        int a = 10; // 值类型
        Console.WriteLine($"Before: a = {a}");
        Change(ref a);
        Console.WriteLine($"After: a = {a}");
    }

    static void Change(ref int x)
    {
        x = 20;
        Console.WriteLine($"Inside: x = {x}");
    }
}

输出结果是：

Before: a = 10
Inside: x = 20
After: a = 20

可以看到，在Change方法内部，我们修改了x的值，同时也修改了a的值。这是因为x和a共享了同一个地址，修改其中一个就相当于修改了另一个。

这就是ref参数的常规用法，它可以让我们在方法内部修改值类型参数的值，并且让这个修改反映到方法外部。避免了不必要的数据复制，提高性能和内存效率。特别是当我们处理一些大型的结构体时，使用ref参数可以节省很多开销。

二、ref +return 鬼畜用法

那么，我们刚才说过，ref关键字可以让我们把值类型参数作为引用传递给方法，那么反过来，能不能把值类型作为引用返回给方法呢？答案是可以的，那就是使用 ref return。ref return 可以让我们直接返回结构体的引用，而不是结构体的副本。
这样一来，我们就可以在方法外部修改结构体的值，并且让这个修改反映到方法内部。听起来很鬼畜吧？那就让我来给大家演示一下吧！

首先，我们定义一个简单的结构体：

struct Point
{
    public int x;
    public int y;

    public Point(int x, int y)
    {
        this.x = x;
        this.y = y;
    }

    public override string ToString()
    {
        return $"({x}, {y})";
    }
}

然后，我们定义一个方法，它接受一个Point数组作为参数，并且返回数组中第一个元素的引用：

static ref Point GetFirst(Point[] points)
{
    return ref points[0];
}

注意，这里我们在返回类型和返回语句前面都加了ref关键字，表示我们要返回Point结构体的引用，而不是副本。

接下来，我们在Main方法中创建一个Point数组，并且调用GetFirst方法：

static void Main(string[] args)
{
    Point[] points = new Point[3];
    points[0] = new Point(1, 2);
    points[1] = new Point(3, 4);
    points[2] = new Point(5, 6);
    Console.WriteLine($"Before: points[0] = {points[0]}");
    ref var p = ref GetFirst(points);
    Console.WriteLine($"After: points[0] = {points[0]}");
}

输出结果是：

Before: points[0] = (1, 2)
After: points[0] = (1, 2)

可以看到，在调用GetFirst方法之后，并没有改变points[0]的值。这是因为我们只是把points[0]的引用赋值给了p，并没有修改p的值。

那么如果我们现在修改p的值呢？例如：

static void Main(string[] args)
{
    Point[] points = new Point[3];
    points[0] = new Point(1, 2);
    points[1] = new Point(3, 4);
    points[2] = new Point(5, 6);
    Console.WriteLine($"Before: points[0] = {points[0]}");
    ref var p = ref GetFirst(points);
    p.x = 10;
    p.y = 20;
    Console.WriteLine($"After: points[0] = {points[0]}");
}

输出结果是：

Before: points[0] = (1, 2)
After: points[0] = (10, 20)

可以看到，在修改p的值之后，points[0]的值也跟着改变了。这是因为p和points[0]共享了同一个地址，修改其中一个就相当于修改了另一个。

这就是 ref return 的鬼畜用法，它可以让我们直接返回结构体的引用，而不是结构体的副本。这样做有什么好处呢？好处就是，我们可以避免不必要的数据复制，提高性能和内存效率。特别是当我们处理一些大型的结构体时，使用 ref return 可以节省很多开销。

三、ref return在Unity中的应用

那么，ref return这么鬼畜的特性，在实际开发中有什么应用场景呢？答案是有的，而且还很多。今天我就跟大家分享一个我最近在Unity中遇到的一个例子，它就是使用了ref return来优化结构体的操作。

最近发布一个开源的库：Loom 就用到了 ref return 的新语法糖，看起来就是为了 ref 而 ref。

为了让Loom能够正常工作，我需要把它的Update方法插入到Unity的PlayerLoop中。具体来说，我需要把它插入到UnityEngine.PlayerLoop.Update这个PlayerLoopSystem之后。这样一来，Loom就可以在每帧更新之后执行异步任务，并且在下一帧更新之前回调主线程。

那么问题来了，怎么把Loom的Update方法插入到UnityEngine.PlayerLoop.Update之后呢？最直观的想法就是遍历当前的PlayerLoop中所有的PlayerLoopSystem，找到UnityEngine.PlayerLoop.Update对应的索引（index），然后把Loom对应的PlayerLoopSystem插入到索引之后。例如：

using System;
using UnityEngine;
using UnityEngine.LowLevel;

public class Loom 
{
    // 省略了Loom类中其他代码，只保留符合本文中心思想的逻辑哈
    private void Install() 
    {
        // 获取当前的 Player Loop
        var playerloop = PlayerLoop.GetCurrentPlayerLoop();
        // 创建一个新的 Player Loop System
        var loop = new PlayerLoopSystem
        {
            type = typeof(Loom),
            updateDelegate = Update
        };
        // 1. 找到 Update Loop System 的索引
        int index = Array.FindIndex(playerloop.subSystemList, v => v.type == typeof(UnityEngine.PlayerLoop.Update));
        // 2.  将咱们的 loop 插入到 Update loop 中
        var updateloop = playerloop.subSystemList[index];
        var temp = updateloop.subSystemList.ToList();
        temp.Add(loop);
        updateloop.subSystemList = temp.ToArray();
        playerloop.subSystemList[index] = updateloop;
        // 3. 设置自定义的 Loop 到 Unity 引擎
        PlayerLoop.SetPlayerLoop(playerloop);
    }
}

这段代码看起来很简单，但是有一个问题，就是它涉及了很多的结构体的复制。为什么呢？因为
PlayerLoop 和 PlayerLoopSystem 都是结构体，而且它们都是值传递的。所以当我们从 playerloop.subSystemList 中取出 updateloop 时，实际上是取出了它的副本；当我们把updateloop.subSystemList赋值给 temp 时，实际上是把它的副本赋值给了 temp；当我们把 temp.ToArray() 赋值给 updateloop.subSystemList 时，实际上是把它的副本赋值给了 updateloop.subSystemList；当我们把 updateloop 赋值给 playerloop.subSystemList[index] 时，实际上是把它的副本赋值给了 playerloop.subSystemList[index]。这样一来，我们就做了很多不必要的数据复制，浪费了性能和内存。

那么有没有办法避免这些数据复制呢？答案是有的，那就是使用ref return。我们可以定义一个方法，它接受一个 PlayerLoopSystem 和一个委托作为参数，并且返回 PlayerLoopSystem.subSystemList 中符合委托条件的 PlayerLoopSystem 的引用：

static ref PlayerLoopSystem FindSubSystem(PlayerLoopSystem root, Predicate<PlayerLoopSystem> predicate)
{
        for (int j = 0; j < root.subSystemList.Length; j++)
        {
            if (predicate(root.subSystemList[j]))
            {
                // 可以关注 ref 配合 return 的用法，这样可以直接修改 sub 的值
                return ref root.subSystemList[j];
            }
        }
    throw new Exception("Not Found!");
}

然后，我们就可以使用这个方法来找到 UnityEngine.PlayerLoop.Update对应的 PlayerLoopSystem ，并且直接修改它的subSystemList属性，把 Loom 对应的 PlayerLoopSystem 插入到最后：

            var rootLoopSystem = PlayerLoop.GetCurrentPlayerLoop();
            ref var sub_pls = ref FindSubSystem(rootLoopSystem, v => v.type == typeof(UnityEngine.PlayerLoop.Update));
            Array.Resize(ref sub_pls.subSystemList, sub_pls.subSystemList.Length + 1);
            sub_pls.subSystemList[^1] = new PlayerLoopSystem { type = typeof(Loom), updateDelegate = Update };
            PlayerLoop.SetPlayerLoop(rootLoopSystem);

这段代码看起来更简洁了，而且也避免了很多的数据复制。这是因为我们使用了ref return来直接返回 PlayerLoopSystem 的引用，而不是副本。这样一来，我们就可以在方法外部修改 PlayerLoopSystem 的值，并且让这个修改反映到方法内部。这就实现了结构体跟引用类型近似的使用方式，保持了用户惯性和开发直觉。

四、总结

今天跟大家分享了一个C#语言中的一个非常鬼畜的特性：ref return。这个特性可以让我们直接返回结构体的引用，而不是结构体的副本。 避免不必要的数据复制，提高性能和内存效率。特别是当我们处理一些大型的结构体时，使用ref return可以节省很多开销。

同时给大家演示了一个在Unity中使用ref return来优化PlayerLoop的操作的例子，希望对大家有所启发。

当然，ref return也不是万能的，它也有一些限制和注意事项。例如:

• 我们不能返回一个局部变量的引用，因为它会在方法结束后被销毁；
• 我们不能返回一个常量或者字面量的引用，因为它们没有地址；
• 我们不能返回一个表达式或者属性的引用，因为它们不是变量；
• 我们不能把一个ref return赋值给一个普通的变量，因为它会导致数据复制；
• 我们不能把一个ref return作为另一个方法的参数，除非另一个方法也接受ref参数；
• 我们不能把一个ref return作为另一个方法的返回值，除非另一个方法也返回ref值。

总之，使用ref return时要小心谨慎，遵循语法规则，否则可能会出现一些意想不到的错误或者异常。不过也无需过分担心，得益于 IDE 的智能提示，这些都会在开发过程中被指导和修正

最后，感谢 NewBing chat 全程参与到本文的撰写中来！

五、扩展阅读

• https://learn.microsoft.com/zh-cn/dotnet/csharp/language-reference/keywords/ref#ref-returns
• https://docs.microsoft.com/zh-cn/dotnet/csharp/programming-guide/classes-and-structs/ref-returns
• https://docs.unity3d.com/ScriptReference/LowLevel.PlayerLoop.html
• https://github.com/Bian-Sh/Loom
• PlayerLoopSystemSubscription.cs - 在这里第一次遇见 ref return