我要试着解释一下:

我想我们理解了值类型是如何工作的，对吧?值类型是(int, long, struct等)。当你将它们发送到一个没有ref命令的函数时，它会复制数据。在函数中对该数据所做的任何操作都只会影响副本，而不会影响原始数据。ref命令发送的是实际数据，任何变化都会影响函数外部的数据。

好了，让人困惑的部分，引用类型:

让我们创建一个引用类型:

List<string> someobject = new List<string>()

当你新建someobject时，会创建两部分:

存储某对象数据的内存块。 指向该块的引用(指针) 的数据。

现在，当你发送someobject到一个没有引用的方法时，它复制的是引用指针，而不是数据。现在你得到了这个:

(outside method) reference1 => someobject
(inside method)  reference2 => someobject

两个引用指向同一个对象。如果你使用reference2修改某个对象的属性，它将影响由reference1指向的相同数据。

 (inside method)  reference2.Add("SomeString");
 (outside method) reference1[0] == "SomeString"   //this is true

如果你清空了reference2或将其指向新的数据，它不会影响reference1和reference1所指向的数据。

(inside method) reference2 = new List<string>();
(outside method) reference1 != null; reference1[0] == "SomeString" //this is true

The references are now pointing like this:
reference2 => new List<string>()
reference1 => someobject

当你将someobject by ref发送给方法时会发生什么? 对某个对象的实际引用被发送给方法。所以你现在只有一个数据引用:

(outside method) reference1 => someobject;
(inside method)  reference1 => someobject;

但这意味着什么呢?它的作用与不通过ref发送someobject完全相同，除了两件主要的事情:

1)当你清空方法内部的引用时，它也会清空方法外部的引用。

 (inside method)  reference1 = null;
 (outside method) reference1 == null;  //true

2)你现在可以将引用指向一个完全不同的数据位置，函数外部的引用现在将指向新的数据位置。

 (inside method)  reference1 = new List<string>();
 (outside method) reference1.Count == 0; //this is true

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

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

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

假设多姆因为TPS报告的备忘录出现在彼得的隔间里。

如果Dom是一个参考参数，他就会有一份备忘录的打印副本。

如果多姆是一个多余的论据，他会让彼得打印一份新的备忘录，让他随身携带。

“贝克”

这是因为第一个将字符串引用更改为指向“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类时经常会得到更好的性能)

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

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的行为是一样的。

out:

在c#中，一个方法只能返回一个值。如果希望返回多个值，可以使用out关键字。out修饰符返回为return-by-reference。最简单的答案是使用关键字“out”从方法中获取值。

您不需要在调用函数中初始化该值。 必须在被调用的函数中赋值，否则编译器将报错。

ref:

在c#中，当你将一个值类型，如int, float, double等作为参数传递给方法参数时，它是按值传递的。因此，如果修改形参值，它不会影响方法调用中的实参。但是，如果您用“ref”关键字标记参数，它将反映在实际的变量中。

在调用函数之前，需要初始化变量。 为方法中的ref参数赋值不是强制的。如果不更改值，为什么需要将其标记为“ref”?