正确理解C#中的ref关键字

C# 中的数据有两种类型：引用类型（reference types）和值类型（value types）。 简单类型（包括int, long, double等）和结构（structs）都是值类型，而其他的类都是引用类型。 简单类型在传值的时候会做复制操作，而引用类型只是传递引用，就像 C++ 中的指针一样。

　　注意 structs 在 C# 和 C++ 中的区别。在 C++ 中， structs 和类基本相同（except that the default inheritance and default access are public rather than private）。 而在 C# 中，structs 和类有很大的区别。其中最大的区别（我个人觉得，同时也是容易忽略的一个地方）可能就是它是值类型，而不是引用类型。

　　下面这段代码是 MSDN 中的例子：

// cs_ref.cs
using System;
public class MyClass
{
　public static void TestRef(ref char i)
　{
　　// The value of i will be changed in the calling method
　　i = 'b';
　}
　
　public static void TestNoRef(char i)
　{
　　// The value of i will be unchanged in the calling method
　　i = 'c';
　}
　
　// This method passes a variable as a ref parameter; the value of the
　// variable is changed after control passes back to this method.
　// The same variable is passed as a value parameter; the value of the
　// variable is unchanged after control is passed back to this method.
　public static void Main()
　{
　　char i = 'a';　　// variable must be initialized
　　TestRef(ref i);　// the arg must be passed as ref
　　Console.WriteLine(i);
　　TestNoRef(i);
　　Console.WriteLine(i);
　}
}

大家很容易看出输出结果是：

b
b

那么如果把这个例子做一些新的改动，将值类型（这里用的是 char）改成引用类型，程序运行又是什么效果呢？

// ----------------------------------------
// MyClass definition
public class MyClass
{
　public int Value;
}
// ----------------------------------------
// Tester methods
public static void TestRef(ref MyClass m)
{
　m.Value = 10;
}
public static void TestNoRef(MyClass m)
{
　m.Value = 20;
}
public static void TestCreateRef(ref MyClass m)
{
　m = new MyClass();
　m.Value = 100;
}
public static void TestCreateNoRef(MyClass m)
{
　m = new MyClass();
　m.Value = 200;
}
public static void Main()
{
　MyClass m = new MyClass();
　m.Value = 1;
　
　TestRef(ref m);
　Console.WriteLine(m.Value);
　
　TestNoRef(m);
　Console.WriteLine(m.Value);
　
　TestCreateRef(ref m);
　Console.WriteLine(m.Value);
　
　TestCreateNoRef(m);
　Console.WriteLine(m.Value);
}

　　大家能马上给出正确的答案么？如果能，那看来你对 ref 的用法了解得还是非常不错的。其实如果大家对 C++ 比较熟悉的话，把这段代码换成 C++ 的就好理解的多了。

// ----------------------------------------
// MyClass definition
#pragma once
class MyClass
{
public:
　int Value;
};
typedef MyClass* MyClassPtr;
// ----------------------------------------
// Tester methods
void TestRef(char* i)
{
　*i = 'b';
}
void TestNoRef(char i)
{
　i = 'c';
}
void TestRef(MyClassPtr* m)
{
　(*m)->Value = 10;
}
void TestNoRef(MyClassPtr m)
{
　m->Value = 20;
}
void TestCreateRef(MyClassPtr* m)
{
　delete (*m);
　*m = new MyClass();
　(*m)->Value = 100;
}
void TestCreateNoRef(MyClassPtr m)
{
　m = new MyClass();
　m->Value = 200;
}
int main(int argc, char* argv[])
{
　char c = 'a';
　TestRef(&c);
　printf("%c ", c);　// output: b
　TestNoRef(c);
　printf("%c ", c);　// output: b
　MyClassPtr m = new MyClass;
　m->Value = 1;
　TestRef(&m);
　printf("%d ", m->Value);
　
　TestNoRef(m);
　printf("%d ", m->Value);
　
　TestCreateRef(&m);
　printf("%d ", m->Value);
　
　TestCreateNoRef(m);
　printf("%d ", m->Value);
　delete m;
　return 0;
}

　　这两段分别用 C# 和 C++ 实现的代码的输出结果都是一样的。后面用 MyClass 测试的输出结果是：

10
20
100
100

　对于引用类型就比较难理解了。

　　先要了解到这一层——就是当一个方法接收到一个引用类型的变量的时候，它将获得这个引用（Reference）的一个Copy。由于Ref关键字可以用来向方法传递引用。所以，如果这个功能被误用了——比如：当一个如数组类型的引用对象用关键字Ref传递的时候，被调用的方法实际上已经控制了传递过来的引用本身。这样将使得被调用方法能用不同的对象甚至NULL来代替调用者的原始引用！

　　

　　如图。内存地址为2000的变量arrayA中其实存放着数组{1，2，3，4，……}的内存起始地址10000。如果一个方法fun()使用fun( arrayA[] )的话，它将顺利的获得数据10000，但这个10000将放在一个Copy中，不会放到内存的2000位置。而这个时候我们如果使用fun( ref arrayA[] )的话，我们得到的值就是2000啦（也就是说，被调用方法能够修改掉arrayA中的那个引用，使之不再指向10000，甚至可以用NULL来代替10000，这样的话，那个10000地址中的数据可能就要被垃圾回收机制清理了。）