ref 是 C# 的关键字之一，用于将参数按引用传递，即传递变量的内存地址。这意味着在方法内部对该变量进行的修改会影响到方法外部该变量的值。

下面是一个使用 ref 的例子：

static void Main(string[] args)
{
    int number = 10;
    MultiplyByTwo(ref number);
    Console.WriteLine(number); // 输出 20
}

static void MultiplyByTwo(ref int x)
{
    x *= 2;
}

在这个例子中，我们定义了一个整数变量 number，并初始化为 10。然后我们调用 MultiplyByTwo 方法，传递了 number 变量的引用。在方法内部，我们将 x 的值乘以 2。由于我们使用了 ref 关键字，所以这个操作会影响到 number 变量的值。因此，在 Main 方法中，我们输出 number 的值时，得到的是 20。

注意：使用 ref 关键字有一些限制和注意事项，例如必须保证在方法内部对该变量进行的修改是合法的，否则可能会引发一些难以调试的问题。因此，使用 ref 关键字时需要谨慎。

---

C# ref 关键字详解

ref 关键字在 C# 中用于按引用传递参数。正常情况下，方法参数是按值传递的（即传递的是变量的副本），而使用 ref 后，传递的是变量本身的内存地址，方法内对参数的修改会直接影响原始变量。

核心概念

传递方式	是否影响原始变量	适用场景
按值传递（默认）	❌ 不影响	简单数据读取
按引用传递（ref）	✅ 影响	需要修改原变量

基本用法示例

示例1：交换两个变量的值

class Program
{
    static void Swap(ref int a, ref int b)
    {
        int temp = a;
        a = b;
        b = temp;
    }

    static void Main()
    {
        int x = 10, y = 20;
        Console.WriteLine($"交换前: x={x}, y={y}");  // 输出: x=10, y=20
        
        Swap(ref x, ref y);
        Console.WriteLine($"交换后: x={x}, y={y}");  // 输出: x=20, y=10
    }
}

示例2：对比值传递和引用传递

class Program
{
    // 按值传递
    static void IncrementValue(int num)
    {
        num++;  // 只修改副本
    }

    // 按引用传递
    static void IncrementRef(ref int num)
    {
        num++;  // 修改原始变量
    }

    static void Main()
    {
        int value = 5;
        
        IncrementValue(value);
        Console.WriteLine($"值传递后: {value}");  // 输出: 5（未改变）
        
        IncrementRef(ref value);
        Console.WriteLine($"引用传递后: {value}"); // 输出: 6（已改变）
    }
}

使用 ref 的注意事项

1. 调用时必须明确使用 ref：调用方法时也要写 ref，让代码意图清晰
2. 变量必须已初始化：传递给 ref 参数的变量必须先赋值（不能为 null 或未赋值）
3. 方法签名必须匹配：重载方法时，ref 和 out 属于不同的签名

ref 的常见应用场景

场景1：避免大结构体的拷贝

struct LargeStruct
{
    public int[] Data;  // 假设有大量数据
}

static void ProcessLargeStruct(ref LargeStruct data)
{
    // 直接操作原始数据，避免拷贝整个结构体
    data.Data[0] = 100;
}

场景2：方法需要返回多个值

static void GetMinMax(int[] numbers, ref int min, ref int max)
{
    if (numbers == null || numbers.Length == 0) return;
    
    min = numbers[0];
    max = numbers[0];
    
    foreach (int num in numbers)
    {
        if (num < min) min = num;
        if (num > max) max = num;
    }
}

static void Main()
{
    int[] scores = { 85, 92, 78, 96, 88 };
    int min = 0, max = 0;
    
    GetMinMax(scores, ref min, ref max);
    Console.WriteLine($"最小值: {min}, 最大值: {max}");  // 输出: 最小值: 78, 最大值: 96
}

ref 的扩展（C# 7.0+）

ref 局部变量和 ref 返回

class Program
{
    static ref int FindMaxRef(int[] numbers)
    {
        int maxIndex = 0;
        for (int i = 1; i < numbers.Length; i++)
        {
            if (numbers[i] > numbers[maxIndex])
                maxIndex = i;
        }
        return ref numbers[maxIndex];  // 返回引用
    }

    static void Main()
    {
        int[] data = { 3, 7, 2, 9, 5 };
        
        // ref 局部变量
        ref int maxRef = ref FindMaxRef(data);
        maxRef = 100;  // 修改最大值
        
        Console.WriteLine(string.Join(", ", data));  // 输出: 3, 7, 2, 100, 5
    }
}

ref readonly（C# 7.2+）

static ref readonly int GetValue(int[] numbers, int index)
{
    return ref numbers[index];  // 返回只读引用
}

static void Main()
{
    int[] data = { 10, 20, 30 };
    ref readonly int val = ref GetValue(data, 1);
    // val = 100;  // ❌ 编译错误：不能修改 readonly 引用
    Console.WriteLine(val);  // 输出: 20
}

ref vs out 对比

特性	ref	out
传入前必须初始化	✅ 必须	❌ 不需要
方法内必须赋值	❌ 不需要	✅ 必须
主要用于	修改传入的变量	返回额外的结果
方法内可读取	✅ 可以（已初始化）	❌ 不能（未初始化）

// out 示例（与 ref 的区别）
static void TryDivide(int a, int b, out int result)
{
    if (b != 0)
        result = a / b;
    else
        result = 0;  // 必须赋值
}

static void Main()
{
    // out：不需要预先初始化
    TryDivide(10, 2, out int quotient);
    Console.WriteLine(quotient);  // 输出: 5
}

性能考虑

• 对于值类型（int、struct 等），使用 ref 可以避免拷贝，提高性能
• 对于引用类型（class、string 等），传递的是引用本身，使用 ref 可以修改引用指向的对象（例如重新分配一个新对象）

static void ChangeReference(ref Person p)
{
    p = new Person();  // 修改原始引用指向新对象
}

static void Main()
{
    Person person = new Person("张三");
    ChangeReference(ref person);
    // person 现在指向新创建的 Person 对象
}

总结

• ref 实现按引用传递，允许方法修改原始变量
• 调用时必须在参数前显式使用 ref
• 传入的变量必须先初始化
• 适用于值类型避免拷贝、需要多个返回值、修改引用类型引用等场景
• 与 out 不同，ref 强调"传入并可能修改"，out 强调"纯输出"