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

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

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

创作时间:

我们创建调用方法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)在堆上创建一个对象，并将其起始地址存储在参数变量中。不会抛出任何未初始化的错误，并且之前存储的任何引用都将丢失。

Ref表示Ref参数中的值已经设置，方法可以读取和修改它。 使用ref关键字等同于说调用方负责初始化形参的值。

Out告诉编译器，对象的初始化是由 函数需要赋值给out形参。 没有分配是不允许的。

https://www.codemaggot.com/ref-and-out-keywords/

迟了回答，但想到了发帖。可能比其他答案更清楚一点。

ref的关键字:

ref is a keyword which is used to pass any value by reference(refer to call by value and call by reference in programming for further knowledge). In short, you declare and initialize a value for example let us say int age = 5; so this age is saved in the memory by holding a place of 4 bytes. Now if you are passing this age variable to another method with ref (which means passing them by reference and not by value) then the compiler will just pass the reference of that variable or in clear terms, the memory address of the place where the variable is stored and the called method receives this address and directly accesses the data in that address. So obviously any change to that data will happen also to the variable present in the calling method.

示例:我提供了我的stackoverflow帐户的密码并告诉他 他可以做任何他想做的事，他可以提问或回答。的 问题是，他做的任何改变都会直接影响到我的账户。

关键字:

Out和in类似于它们都传递变量的引用。现在我们知道，两者都需要传递变量的引用，很明显，内存中必须有一个地方保存变量的字节。但在out的情况下没有初始化。因为要求是，被调用的方法必须初始化值并返回它。

示例:我将stackoverflow站点地址发送给我的朋友并询问 让他帮我开个账户，把证件还给我。

关键字:

现在，in关键字的工作原理与ref关键字完全相同，只有一个条件，即作为引用传递的值不能被修改。

示例:我提供了我的stackoverflow帐户的密码，但告诉了他 不做任何事情，除了阅读或浏览网站。不要问 问题，没有答案，没有投票，什么都没有。

MSDN引用:

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/ref https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/out-parameter-modifier https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/in-parameter-modifier

希望以上说明清楚了。

: 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();

      }
   }
}

“贝克”

这是因为第一个将字符串引用更改为指向“Baker”。更改引用是可能的，因为您通过ref关键字传递了它(=>是对字符串引用的引用)。 第二个调用获取字符串引用的副本。

弦一开始看起来很特别。但字符串只是一个引用类，如果你定义

string s = "Able";

那么s是一个包含文本“Able”的字符串类的引用! 对同一个变量via的另一个赋值

s = "Baker";

不改变原来的字符串，但只是创建一个新的实例，让我们指向该实例!

你可以试试下面的小代码示例:

string s = "Able";
string s2 = s;
s = "Baker";
Console.WriteLine(s2);

你想要什么? 您将得到的仍然是“Able”，因为您只是将s中的引用设置为另一个实例，而s2指向原始实例。

编辑: String也是不可变的，这意味着根本没有修改现有字符串实例的方法或属性(你可以尝试在文档中找到一个，但你找不到:-))。所有字符串操作方法都会返回一个新的字符串实例!(这就是为什么你在使用StringBuilder类时经常会得到更好的性能)