ref修饰符的意思是:

该值已经设置，并且 该方法可以读取和修改它。

out修饰符的意思是:

Value未被设置，并且在设置之前不能被方法读取。 方法必须在返回之前设置它。

Ref和out的行为类似，只是有一些不同。

引用变量必须在使用前初始化。Out变量无需赋值即可使用 Out形参必须被使用它的函数视为未赋值。因此，我们可以在调用代码中使用初始化的out形参，但该值将在函数执行时丢失。

注意，在函数内部传递的引用参数是直接处理的。

例如,

    public class MyClass
    {
        public string Name { get; set; }
    }

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

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

这会写狗，而不是猫。因此，您应该直接在someObject上工作。

From the standpoint of a method which receives a parameter, the difference between ref and out is that C# requires that methods must write to every out parameter before returning, and must not do anything with such a parameter, other than passing it as an out parameter or writing to it, until it has been either passed as an out parameter to another method or written directly. Note that some other languages do not impose such requirements; a virtual or interface method which is declared in C# with an out parameter may be overridden in another language which does not impose any special restrictions on such parameters.

从调用者的角度来看，c#在很多情况下假设调用带有out形参的方法时，会导致传入的变量在未被读取之前就被写入。当调用用其他语言编写的方法时，这个假设可能不正确。例如:

struct MyStruct
{
   ...
   myStruct(IDictionary<int, MyStruct> d)
   {
     d.TryGetValue(23, out this);
   }
}

如果myDictionary标识了一个用c#以外的语言编写的dictionary <TKey,TValue>实现，即使MyStruct s = new MyStruct(myDictionary);看起来像一个任务，它可能会留下未修改的s。

注意用VB编写的构造函数。NET与c#中的方法不同，它不假设被调用的方法是否会修改任何out参数，并且无条件地清除所有字段。上面提到的奇怪行为不会发生在完全用VB或完全用c#编写的代码中，但是当用c#编写的代码调用用VB.NET编写的方法时就会发生。

为了说明这些优秀的解释，我开发了以下控制台应用程序:

using System;
using System.Collections.Generic;

namespace CSharpDemos
{
  class Program
  {
    static void Main(string[] args)
    {
      List<string> StringList = new List<string> { "Hello" };
      List<string> StringListRef = new List<string> { "Hallo" };

      AppendWorld(StringList);
      Console.WriteLine(StringList[0] + StringList[1]);

      HalloWelt(ref StringListRef);
      Console.WriteLine(StringListRef[0] + StringListRef[1]);

      CiaoMondo(out List<string> StringListOut);
      Console.WriteLine(StringListOut[0] + StringListOut[1]);
    }

    static void AppendWorld(List<string> LiStri)
    {
      LiStri.Add(" World!");
      LiStri = new List<string> { "¡Hola", " Mundo!" };
      Console.WriteLine(LiStri[0] + LiStri[1]);
    }

    static void HalloWelt(ref List<string> LiStriRef)
     { LiStriRef = new List<string> { LiStriRef[0], " Welt!" }; }

    static void CiaoMondo(out List<string> LiStriOut)
     { LiStriOut = new List<string> { "Ciao", " Mondo!" }; }
   }
}
/*Output:
¡Hola Mundo!
Hello World!
Hallo Welt!
Ciao Mondo!
*/

AppendWorld: A copy of StringList named LiStri is passed. At the start of the method, this copy references the original list and therefore can be used to modify this list. Later LiStri references another List<string> object inside the method which doesn't affect the original list. HalloWelt: LiStriRef is an alias of the already initialized ListStringRef. The passed List<string> object is used to initialize a new one, therefore ref was necessary. CiaoMondo: LiStriOut is an alias of ListStringOut and must be initialized.

因此，如果一个方法只是修改了被传递的变量引用的对象，编译器不会让你使用out，你也不应该使用ref，因为它不仅会让编译器困惑，而且会让代码的读者困惑。如果该方法将使传递的参数引用另一个对象，则对于已经初始化的对象使用ref，对于必须为传递的参数初始化新对象的方法使用out。除此之外，ref和out的行为是一样的。

 public static void Main(string[] args)
    {
        //int a=10;
        //change(ref a);
        //Console.WriteLine(a);
        // Console.Read();

        int b;
        change2(out b);
        Console.WriteLine(b);
        Console.Read();
    }
    // static void change(ref int a)
    //{
    //    a = 20;
    //}

     static void change2(out int b)
     {
         b = 20;
     }

你可以检查这段代码，它会向你描述它的完全不同 当你使用“ref”时，这意味着你已经初始化了int/string

但 当你使用out的时候 无论你是否初始化int/string，它都适用于这两种情况 但是u必须在函数中初始化int/string