“ref”和“ref”有什么区别？ 和“出”； 关键词？

Question

我正在创建一个函数，我需要在其中传递一个对象，以便该函数可以修改它。 ？

public void myFunction(ref MyClass someClass)

和

public void myFunction(out MyClass someClass)

我应该使用哪个以及为什么

Answer 1

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

因此，虽然 ref 是双向的，但 out 是仅输出的。

Answer 2

ref 修饰符意味着：

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

out 修饰符意味着：

1. Value 未设置，并且在设置之前无法通过方法读取。
2. 该方法必须在返回之前设置它。

Answer 3

假设 Dom 出现在 Peter 的小隔间，查看有关 TPS 报告的备忘录。

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

如果多姆不同意，他会让彼得打印一份新的备忘录供他随身携带。

Answer 4

我将尝试解释一下：

我认为我们理解值类型如何工作？ 值类型有（int、long、struct 等）。 当您将它们发送到没有 ref 命令的函数时，它会复制数据。 您在函数中对该数据所做的任何操作都只会影响副本，而不影响原始数据。 ref 命令发送实际数据，任何更改都会影响函数外部的数据。

好的，回到令人困惑的部分，引用类型：

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

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

当您新建 someobject 时，会创建两个部分：

1. 保存 someobject 数据的内存块。
2. 对该块的引用（指针）
   数据的。

现在，当您将某个对象发送到没有引用的方法中时，它会复制引用指针，而不是数据。 现在你有了这样的结果：

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

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

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

如果您清空引用 2 或将其指向新数据，则不会影响引用 1 或引用 1 指向的数据。

(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

现在，当您通过 ref 向方法发送 someobject 时会发生什么？
对某个对象的实际引用被发送到该方法。 因此，您现在只有一个对数据的引用：

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

但这意味着什么？ 它的行为与不通过 ref 发送某个对象完全相同，除了以下两点之外：

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

Answer 5

引用和出 。

只要能够满足您的要求，您就应该优先使用 out。

Answer 6

out：

在 C# 中，一种方法只能返回一个值。 如果您想返回多个值，可以使用 out 关键字。 out 修饰符以引用返回的形式返回。 最简单的答案是使用关键字“out”从方法中获取值。

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

ref：

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

1. 您需要在调用函数之前初始化变量。
2. 不强制为方法中的 ref 参数分配任何值。 如果你不改变这个值，为什么需要将其标记为“ref”？

Answer 7

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

---

out告诉编译器对象的初始化是由
函数，函数必须分配给 out 参数。
不允许将其保留为未分配状态。

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

Answer 8

扩展 Dog、Cat 的例子。 第二个带有 ref 的方法更改调用者引用的对象。 因此“猫”！

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

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

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

Answer 9

ref 和 out 的行为类似，但存在以下差异。

• ref 变量在使用前必须初始化。 out 变量可以在不赋值的情况下使用
• out 参数必须被使用它的函数视为未赋值的值。 因此，我们可以在调用代码中使用已初始化的out参数，但该值在函数执行时会丢失。

Answer 10

由于您传递的是引用类型（类），因此无需使用 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 。

Answer 11

对于那些通过例子学习的人（比如我），这是Anthony Kolesov 所说的。

我创建了一些 ref、out 和其他的最小示例来说明这一点。 我不讨论最佳实践，只是举例来理解差异。

https://gist.github.com/2upmedia/6d98a57b68d849ee7091

Answer 12

对于那些寻求简洁答案的人。

ref 和 out 关键字都用于传递引用。

<小时>

ref关键字的变量必须有一个值或者必须引用一个对象
或 null 在传递之前。

<小时>

与ref不同，out关键字的变量必须有一个值或者必须
引用一个对象或null之后它的传递以及不需要
在传递之前拥有一个值或引用一个对象。

Answer 13

“Baker”

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

字符串一开始看起来有些特别。 但 string 只是一个引用类，如果您定义了 s ，

string s = "Able";

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

s = "Baker";

不会更改原始字符串，而只是创建一个新实例并让 s 指向该实例！

您可以使用以下小代码示例进行尝试：

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

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

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

Answer 14

输出：
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();

      }
   }
}

Answer 15

除了允许您将其他人的变量重新分配给类的不同实例、返回多个值等之外，使用 ref 或 out 还可以让其他人知道您的内容需要他们以及您打算如何处理他们提供的变量

• 您不需要 ref 或out如果您要做的只是修改在参数 someClass 中传递的 MyClass 实例内部的内容。

  • 无论您使用 ref、out 还是什么都不使用，调用方法都会看到诸如 someClass.Message = "Hello World" 之类的变化
  • 在 myFunction(someClass) 中写入 someClass = new MyClass() 会替换 someClass 在 范围内看到的对象。仅 code>myFunction 方法。 调用方法仍然知道它创建并传递给您的方法的原始 MyClass 实例

• 您需要 ref 或 out< /code> 如果您打算将 someClass 替换为一个全新的对象，并希望调用方法看到您的更改

  • 在 myFunction(out someClass) 中写入 someClass = new MyClass() 会更改调用 myFunction 的方法所看到的对象

存在其他程序员

，他们想知道您将如何处理他们的数据。 想象一下您正在编写一个将被数百万开发人员使用的库。 您希望他们知道当他们调用您的方法时您将如何处理他们的变量

• Using ref 声明“当您调用我的方法时传递分配给某个值的变量。请注意，我可能会在我的方法过程中将其完全更改为其他内容，不要指望在我完成后您的变量会指向旧对象”

• Using out 声明“将占位符变量传递给我的方法，它是否有值并不重要；编译器会强制我赋值；我绝对保证在调用我的方法之前，变量所指向的对象在我完成时会有所不同

说一句，在 C#7.2 中，有一个in 修饰符也是如此

，这可以防止该方法将传入的实例交换为不同的实例。 可以将其视为对数百万开发人员说“将您的原始变量引用传递给我，我保证不会将您精心制作的数据交换为其他内容”。 in 有一些特殊性，在某些情况下，例如可能需要隐式转换以使您的 Short 与 in int 兼容，编译器将暂时生成 int，加宽你的不足之处，通过参考传递并完成。 它可以做到这一点，因为你已经声明你不会搞乱它。

---

微软通过数字类型上的 .TryParse 方法做到了这一点：

int i = 98234957;
bool success = int.TryParse("123", out i);

通过将参数标记为 out，他们在这里主动声明“我们肯定将把您精心设计的值 98234957 更改为其他值”

当然，对于解析值类型之类的事情，他们有点必须这样做，因为如果不允许解析方法将值类型交换为其他值，它就不会工作得很好..但是想象一下您正在创建的某个库中有一些虚构的方法：

public void PoorlyNamedMethod(out SomeClass x)

您可以看到它是一个out，因此您可以知道如果您花几个小时处理数字，就会创建完美的方法SomeClass：

SomeClass x = SpendHoursMakingMeAPerfectSomeClass();
//now give it to the library
PoorlyNamedMethod(out x);

嗯，那是浪费时间，花了那么多时间来上完美的课。 它肯定会被扔掉并被 PoorlyNamedMethod 取代

Answer 16

ref 和 out 的工作方式就像 C++ 中的引用传递和指针传递一样。

对于 ref，必须声明并初始化参数。

对于 out，必须声明参数，但可能会也可能不会初始化

        double nbr = 6; // if not initialized we get error
        double dd = doit.square(ref nbr);

        double Half_nbr ; // fine as passed by out, but inside the calling  method you initialize it
        doit.math_routines(nbr, out Half_nbr);

Answer 17

创作时间：

(1) 我们创建调用方法 Main()

(2) 它创建一个 List 对象（这是一个引用类型对象）并将其存储在变量中我的列表。

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

在运行时：

(3) 运行时在堆栈上的 #00 处分配一块内存，其宽度足以存储地址 (#00 = myList，因为变量名称实际上只是 (4) 运行时在堆上的内存

位置 #FF 创建一个列表对象（所有这些地址都是为了举例）

(5) 然后运行时将对象的起始地址 #FF 存储在 #00（或用单词来说，将 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 别名。

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

(10)运行时在堆上的内存位置#004处创建一个列表对象，并用该值替换#04中的#FF（或者在该方法中取消引用原始List对象并指向新的List对象）

#00中的地址不是更改并保留对 #FF 的引用（或原始 myList 指针不受影响）。

---

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

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

Answer 18

为了说明许多出色的解释，我开发了以下控制台应用程序：

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：传递名为 LiStri 的 StringList 副本。 在
  该方法开始时，此副本引用原始列表并且
  因此可用于修改此列表。 稍后的 LiStri 参考资料
  方法内的另一个 List 对象不影响
  原始列表。

• HalloWelt：LiStriRef是已初始化的别名
  ListStringRef。 传递的 List 对象用于初始化
  新的，因此 ref 是必要的。

• CiaoMondo：LiStriOut 是 ListStringOut 的别名，并且必须是
  已初始化。

因此，如果一个方法只是修改传递变量引用的对象，编译器将不允许您使用 out 并且您不应该使用 ref 因为它不会让编译器感到困惑但代码的读者。 如果该方法将使传递的参数引用另一个对象，请对已初始化的对象使用 ref ，对必须为传递的参数初始化新对象的方法使用 out 。 除此之外，ref 和 out 的行为相同。

Answer 19

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

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

Ref 参数用于可能被修改的数据，out 参数用于作为已在使用某些内容的返回值的函数（例如 int.TryParse）的附加输出的数据。

Answer 20

参考：
ref 关键字用于将参数作为引用传递。 这意味着当方法中该参数的值发生更改时，它会反映在调用方法中。 使用 ref 关键字传递的参数必须在调用方法中初始化，然后再传递给被调用方法。

出去：
out 关键字也可以像 ref 关键字一样用于传递参数，但可以在不为其赋值的情况下传递参数。 使用 out 关键字传递的参数必须在返回到调用方法之前在被调用方法中初始化。

public class Example
{
 public static void Main() 
 {
 int val1 = 0; //must be initialized 
 int val2; //optional

 Example1(ref val1);
 Console.WriteLine(val1); 

 Example2(out val2);
 Console.WriteLine(val2); 
 }

 static void Example1(ref int value) 
 {
 value = 1;
 }
 static void Example2(out int value) 
 {
 value = 2; 
 }
}

/* Output     1     2     

方法重载中的 Ref 和 out

方法重载中不能同时使用 ref 和 out。 但是，ref 和 out 在运行时的处理方式不同，但在编译时的处理方式相同（CLR 在为 ref 和 out 创建 IL 时并不区分两者）。

Answer 21

我想举两个主要区别：

1. ref 和 out 通过引用传递，因此；

 class Program
    {
        public static void Main(string[] args)
        {
            var original = new ObjectWithMememberList(3);
            Console.WriteLine(original.MyList.Capacity); // 3
            ChangeList(original.MyList);
            Console.WriteLine(original.MyList.Capacity); // 3
        }

        static void ChangeList(List<int> vr)
        {
            vr = new List<int>(2);
        }
}

但是：

 class Program
    {
        public static void Main(string[] args)
        {
            var original = new ObjectWithMememberList(3);
            Console.WriteLine(original.MyList.Capacity); // 3
            ChangeList(ref original.MyList);
            Console.WriteLine(original.MyList.Capacity); // 2
        }

        static void ChangeList(ref List<int> vr)
        {
            vr = new List<int>(2);
        }
}

与 out 相同。
2. ref 参数必须是可赋值的变量。
嗯：

ChangeList(ref new List<int>()); // Compile Error [might not be initialized before accessing]

但是：

List<int> xs;
ChangeList(out xs); // Compiles

Answer 22

下面我展示了一个同时使用 Ref 和 out 的示例。 现在，你们都将了解裁判和出局的情况。

在下面提到的示例中，当我评论 //myRefObj = new myClass { Name = "ref external called!! " };
行，会得到一个错误，指出“使用未分配的局部变量'myRefObj'”，但out中没有这样的错误。

在哪里使用 Ref：当我们使用 in 参数调用过程时，相同的参数将用于存储该过程的输出。

在哪里使用 Out：当我们调用一个没有 in 参数的过程时，并且相同的参数将用于从该过程返回值。
另请注意输出

public partial class refAndOutUse : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        myClass myRefObj;
        myRefObj = new myClass { Name = "ref outside called!!  <br/>" };
        myRefFunction(ref myRefObj);
        Response.Write(myRefObj.Name); //ref inside function

        myClass myOutObj;
        myOutFunction(out myOutObj);
        Response.Write(myOutObj.Name); //out inside function
    }

    void myRefFunction(ref myClass refObj)
    {
        refObj.Name = "ref inside function <br/>";
        Response.Write(refObj.Name); //ref inside function
    }
    void myOutFunction(out myClass outObj)
    {
        outObj = new myClass { Name = "out inside function <br/>" }; 
        Response.Write(outObj.Name); //out inside function
    }
}

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

Answer 23

 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，它都适用于两种情况
但你必须在该函数中初始化该 int/string

Answer 24

从接收参数的方法的角度来看，ref 和 out 之间的区别在于 C# 要求方法必须写入每个 out 参数在返回之前，除了将其作为 out 参数传递或对其进行写入之外，不得对此类参数执行任何操作，直到将其作为 out 参数传递为止到另一种方法或直接写入。 请注意，其他一些语言没有强加这样的要求； 在 C# 中使用 out 参数声明的虚拟或接口方法可以用另一种语言覆盖，该语言不会对此类参数施加任何特殊限制。

从调用者的角度来看，C# 在许多情况下会假设调用带有 out 参数的方法时会导致传递的变量在未先读取的情况下被写入。 当调用用其他语言编写的方法时，这种假设可能不正确。 例如：

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

如果 myDictionary 标识以 C# 以外的语言编写的 IDictionary 实现，即使 MyStruct s = new MyStruct(myDictionary); 看起来像一个赋值，它可能会使 s 保持不变。

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

Answer 25

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

Answer 26

迟到的答复，但想到发帖。 可能比其他答案更清楚一些。

ref 关键字：

ref 是一个关键字，用于通过引用传递任何值（进一步了解编程中的按值调用和按引用调用）。 简而言之，您声明并初始化一个值，例如让我们说intage = 5;，因此该年龄通过保留 4 个字节的位置保存在内存中。 现在，如果您使用 ref 将这个年龄变量传递给另一个方法（这意味着通过引用而不是通过值传递它们），那么编译器将只传递该变量的引用，或者明确地说，是变量所在位置的内存地址被存储，被调用的方法接收该地址并直接访问该地址中的数据。 显然，对该数据的任何更改也会发生在调用方法中存在的变量上。

示例：我给出我的 stackoverflow 帐户的密码并告诉他
他可以做任何他想做的事，他可以提出问题或回答。 这
问题是，他所做的任何更改都会直接影响我的帐户。

Out 关键字：

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

示例：我将 stackoverflow 站点地址发送给我的朋友并询问
他为我创建一个帐户并返回凭据。

In 关键字：

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

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

MSDN 参考文献：

1. https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/ref
2. https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/out-parameter-修饰符
3. https:// /learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/in-parameter-modifier

希望以上内容清楚。

Answer 27

请注意，在函数内部传递的引用参数是直接起作用的。

例如，

    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;
    }

这将写为 Dog，而不是 Cat。 因此你应该直接处理 someObject。

Answer 28

我可能不太擅长这一点，但是字符串（即使它们在技术上是引用类型并且存在于堆上）肯定是按值传递的，而不是引用传递的？

        string a = "Hello";

        string b = "goodbye";

        b = a; //attempt to make b point to a, won't work.

        a = "testing";

        Console.WriteLine(b); //this will produce "hello", NOT "testing"!!!!

这就是为什么如果您希望更改存在于进行更改的函数范围之外，则需要 ref，否则您不会传递引用。

据我所知，您只需要 ref 来表示结构/值类型和字符串本身，因为字符串是一种引用类型，它假装它是但不是值类型。

不过，我可能完全错了，我是新人。