它们几乎是一样的——唯一的区别是，作为out形参传递的变量不需要初始化，使用ref形参的方法必须将其设置为某个值。

int x;    Foo(out x); // OK 
int y;    Foo(ref y); // Error

Ref形参用于可能被修改的数据，out形参用于已经使用返回值的函数(例如int.TryParse)的额外输出数据。

由于您传递的是引用类型(类)，因此不需要使用ref，因为默认情况下只传递对实际对象的引用，因此您总是要更改引用后面的对象。

例子:

public void Foo()
{
    MyClass myObject = new MyClass();
    myObject.Name = "Dog";
    Bar(myObject);
    Console.WriteLine(myObject.Name); // Writes "Cat".
}

public void Bar(MyClass someObject)
{
    someObject.Name = "Cat";
}

只要传入一个类，如果你想在方法中改变对象，就不必使用ref。

创作时间:

我们创建调用方法Main()

(2)它创建一个List对象(这是一个引用类型对象)并将其存储在变量myList中。

public sealed class Program 
{
    public static Main() 
    {
        List<int> myList = new List<int>();

在运行时:

(3)运行时在堆栈#00处分配一个内存，足够宽来存储一个地址(#00 = myList，因为变量名实际上只是内存位置的别名)

(4)运行时在内存位置#FF的堆上创建一个列表对象(所有这些地址都是为了举例)

(5) Runtime会将对象的起始地址#FF存储在#00(或者在word中，将List对象的引用存储在指针myList中)

回到创作时间:

(6)然后我们将List对象作为参数myParamList传递给被调用的方法modifyMyList，并将一个新的List对象赋给它

List<int> myList = new List<int>();

List<int> newList = ModifyMyList(myList)

public List<int> ModifyMyList(List<int> myParamList){
     myParamList = new List<int>();
     return myParamList;
}

在运行时:

(7)运行时启动被调用方法的调用例程，作为它的一部分，检查参数的类型。

(8)在找到引用类型后，它在堆栈#04处分配一个内存，用于别名参数变量myParamList。

然后它将值#FF也存储在其中。

(10) Runtime在内存位置#004的堆上创建一个列表对象，并用这个值替换#04中的#FF(或者在这个方法中取消引用原始的list对象并指向新的list对象)

#00中的地址不会改变，并保留对#FF的引用(或者原始的myList指针不会被干扰)。

ref关键字是一个编译器指令，用于跳过(8)和(9)的运行时代码的生成，这意味着不会为方法参数分配堆。它将使用原始的#00指针对位于#FF的对象进行操作。如果原始指针没有初始化，运行时将停止抱怨它不能继续，因为变量没有初始化

out关键字是一个编译器指令，它与ref几乎相同，只是在(9)和(10)处略有修改。编译器期望参数是未初始化的，并将继续使用(8)，(4)和(5)在堆上创建一个对象，并将其起始地址存储在参数变量中。不会抛出任何未初始化的错误，并且之前存储的任何引用都将丢失。

: return语句只能用于从函数中返回一个值。但是，使用输出参数，可以从一个函数返回两个值。输出参数类似于引用参数，只是它们将数据传输出方法而不是传输到方法中。

下面的例子说明了这一点:

using System;

namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void getValue(out int x )
      {
         int temp = 5;
         x = temp;
      }

      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* local variable definition */
         int a = 100;

         Console.WriteLine("Before method call, value of a : {0}", a);

         /* calling a function to get the value */
         n.getValue(out a);

         Console.WriteLine("After method call, value of a : {0}", a);
         Console.ReadLine();

      }
   }
}

裁判: 引用形参是对变量内存位置的引用。与值参数不同，通过引用传递参数时，不会为这些参数创建新的存储位置。引用参数表示与提供给方法的实际参数相同的内存位置。

在c#中，使用ref关键字声明引用参数。下面的例子说明了这一点:

using System;
namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void swap(ref int x, ref int y)
      {
         int temp;

         temp = x; /* save the value of x */
         x = y;   /* put y into x */
         y = temp; /* put temp into y */
       }

      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* local variable definition */
         int a = 100;
         int b = 200;

         Console.WriteLine("Before swap, value of a : {0}", a);
         Console.WriteLine("Before swap, value of b : {0}", b);

         /* calling a function to swap the values */
         n.swap(ref a, ref b);

         Console.WriteLine("After swap, value of a : {0}", a);
         Console.WriteLine("After swap, value of b : {0}", b);

         Console.ReadLine();

      }
   }
}

如果你想将参数作为引用传递，那么你应该在将参数传递给函数之前初始化它，否则编译器本身会显示错误。但是对于out形参，您不需要在将对象形参传递给方法之前初始化它。可以在调用方法本身中初始化对象。

Ref告诉编译器对象在进入函数之前已经初始化，而out告诉编译器对象将在函数内部初始化。

所以当ref是双向的，out是唯一的。