为什么在传递对象时使用“ref”关键字？

但是，如果您传递一个值，情况就不同了。您可以强制通过引用传递值。例如，这允许您将整数传递给方法，并让该方法代表您修改整数。

你可以写：ref

static public void DoSomething(ref TestRef t)
{
    t = new TestRef();
}

方法完成后，t 将被更改。

如果要更改对象的内容，请传递 a：ref

TestRef t = new TestRef();
t.Something = "Foo";
DoSomething(ref t);

void DoSomething(ref TestRef x)
{
  x = new TestRef();
  x.Something = "Not just a changed TestRef, but a completely different TestRef object";
}

调用 DoSomething 后，不引用原始对象，而是引用完全不同的对象。tnew TestRef

如果您想更改不可变对象的值，例如 .一旦创建，就无法更改 a 的值。但是通过使用 ，您可以创建一个函数来更改另一个具有不同值的字符串的字符串。stringstringref

除非需要，否则使用不是一个好主意。使用 使方法可以自由地更改其他内容的参数，需要对方法的调用者进行编码以确保他们处理这种可能性。refref

此外，当参数类型是对象时，对象变量始终充当对对象的引用。这意味着，当使用关键字时，您就得到了对引用的引用。这允许您按照上面给出的示例中所述执行操作。但是，当参数类型是基元值（例如 ）时，如果在方法中将此参数赋值给，则在方法返回后，传入的参数的值将更改：refint

int v = 1;
Change(ref v);
Debug.Assert(v == 5);
WillNotChange(v);
Debug.Assert(v == 5); // Note: v doesn't become 10

void Change(ref int x)
{
  x = 5;
}

void WillNotChange(int x)
{
  x = 10;
}

由于 TestRef 是一个类（它们是引用对象），因此您可以更改 t 中的内容，而无需将其作为 ref 传递。但是，如果将 t 作为 ref 传递，TestRef 可以更改原始 t 所指的内容。即让它指向不同的对象。

通过将关键字与引用类型一起使用，可以有效地将引用传递给引用。在许多方面，它与使用关键字相同，但略有不同，即不能保证该方法实际上会为“ed”参数分配任何内容。refoutref

这就像在 C 中传递指向指针的指针一样，在 .NET 中，这将允许您更改原始 T 所指的内容，尽管我认为如果您在 .NET 中这样做，您可能会遇到设计问题！

您需要区分“按值传递引用”和“按引用传递参数/参数”。

我已经写了一篇关于这个主题的相当长的文章，以避免每次出现在新闻组上时都必须仔细写。

在 .NET 中，将任何参数传递给方法时，将创建一个副本。在值类型中意味着对值所做的任何修改都在方法范围内，并且在退出方法时会丢失。

当传递引用类型时，也会创建一个副本，但它是引用的副本，即现在内存中有两个对同一对象的引用。因此，如果使用引用来修改对象，它就会被修改。但是，如果您修改引用本身 - 我们必须记住它是一个副本 - 那么任何更改也会在退出方法时丢失。

正如人们之前所说，赋值是对引用的修改，因此丢失了：

public void Method1(object obj) {   
 obj = new Object(); 
}

public void Method2(object obj) {  
 obj = _privateObject; 
}

上述方法不会修改原始对象。

对示例进行一些修改

 using System;

    class Program
        {
            static void Main(string[] args)
            {
                TestRef t = new TestRef();
                t.Something = "Foo";

                DoSomething(t);
                Console.WriteLine(t.Something);

            }

            static public void DoSomething(TestRef t)
            {
                t = new TestRef();
                t.Something = "Bar";
            }
        }



    public class TestRef
    {
    private string s;
        public string Something 
        { 
            get {return s;} 
            set { s = value; }
        }
    }

ref仅针对两个范围模拟（或表现）为全局区域：

• 访客
• 卡莉。

将引用类型（例如）的变量（例如）视为保存“对象 #24601”形式的对象标识符。假设语句导致保存“对象 #24601”（包含四个项目的列表）。然后调用将询问对象 #24601 的长度，它将响应 4，因此等于 4。fooList<T>foo = new List<int> {1,5,7,9};foofoo.Lengthfoo.Length

如果在不使用 的情况下传递给某个方法，则该方法可能会对对象 #24601 进行更改。由于这些变化，可能不再等于 4。但是，方法本身将无法更改，它将继续保存“对象 #24601”。fooreffoo.Lengthfoo

作为参数传递将允许被调用的方法不仅对对象 #24601 进行更改，而且还对自身进行更改。该方法可能会创建一个新的对象 #8675309 并将对该对象的引用存储在 中。如果这样做，将不再保留“对象 #24601”，而是“对象 #8675309”。fooreffoofoofoo

在实践中，引用类型变量不包含“对象 #8675309”形式的字符串;他们甚至没有任何东西可以有意义地转换为数字。尽管每个引用类型变量都将包含一些位模式，但存储在这些变量中的位模式与它们标识的对象之间没有固定的关系。代码无法从对象或对它的引用中提取信息，然后确定另一个引用是否标识了同一对象，除非代码持有或知道标识原始对象的引用。

我相信我在某处读到了关于相关行为的美丽描述。它是这样的：

在 C# 中没有“通过引用传递”，因为没有指针（不安全的代码除外），实际上一切都是“按值复制”。只有复杂类型的实例实际上应该被视为将引用作为值的变量。因此，它们在方法调用中复制了“值”（指向真实数据的引用）。因此，在方法内部，参数引用相同的对象，但保存引用的变量是原始输入的副本。 关键字将其更改为按引用调用。ref

官方独库

官方 Doku 继续