为什么在没有引用的情况下传递列表到函数时，其行为就像使用引用传递一样？

Question

如果我没有犯下严重的错误，这种行为对我来说很奇怪。我将在下面发布一个示例代码，而不是解释，请告诉我为什么我得到输出 x 而不是 y。

    private void button1_Click(object sender, EventArgs e)
    {
        List<int> l = new List<int>() { 1, 2, 3 };
        Fuss(l);
        MessageBox.Show(l.Count.ToString()); // output is 5
    }

    private void Fuss(List<int> l)
    {
        l.Add(4);
        l.Add(5);
    }

我假设输出应该是 3。但是我得到的输出是 5。我知道如果我这样做，输出可以是 5：

    private void button1_Click(object sender, EventArgs e)
    {
        List<int> l = new List<int>() { 1, 2, 3 };
        Fuss(ref l);
        MessageBox.Show(l.Count.ToString()); // output is 5
    }

    private void Fuss(ref List<int> l)
    {
        l.Add(4);
        l.Add(5);
    }

Answer 1

它的行为不像是通过引用传递的。

void ChangeMe(List<int> list) {
  list = new List<int>();
  list.Add(10);
}
void ChangeMeReally(ref List<int> list) {
  list = new List<int>();
  list.Add(10);
}

尝试一下。你注意到其中的区别了吗？

如果您在没有引用的情况下传递列表（或任何引用类型），则只能更改列表的内容（因为正如其他人所说，您正在传递对堆上对象的引用，从而更改相同的“内存”）。

但是您不能更改“list”，“list”是一个指向 List 类型的对象的变量。如果您通过引用传递“列表”（以使其指向其他位置），则只能更改“列表”。您将获得引用的副本，如果更改，则只能在您的方法内观察到该副本。

Answer 2

在 C# 中，参数按值传递，除非它们用 ref 或 out 修饰符标记。对于引用类型，这意味着引用是按值传递的。因此，在 Fuss 中，l 引用 List 与其调用者相同的实例。因此，对此 List 实例的任何修改都将被调用者看到。

现在，如果您使用 ref 或 out 标记参数 l，则该参数将通过引用传递。这意味着在 Fuss 中，l 是存储位置的别名，用作调用该方法的参数。需要明确的是：

public void Fuss(ref List<int> l)

在 Fuss 中，由 Now 调用

List<int> list = new List<int> { 1, 2, 3 };
Fuss(list);

，l 是 list 的别名。特别是，如果您将 List 的新实例分配给 l，调用者将看到分配给变量 list 的新实例以及。特别是，如果您说

public void Fuss(ref List<int> l) {
    l = new List<int> { 1 };
}

then，调用者现在将看到一个包含一个元素的列表。但是，如果您说

public void Fuss(List<int> l) {
    l = new List<int> { 1 };
}

并调用

List<int> list = new List<int> { 1, 2, 3 };
Fuss(list);

，那么调用者仍然会看到 list 具有三个元素。

清除？

Answer 3

ByRef 和 ByVal 仅适用于值类型，不适用于引用类型，引用类型始终像“byref”一样传递。

如果您需要谨慎地修改列表，请使用“.ToList()”函数，您将获得列表的克隆。

请记住，如果您的列表包含引用类型，则“新”列表包含指向与原始列表相同的对象的指针。

Answer 4

列表已经是引用类型，因此当您将它们传递给方法时，您正在传递引用。任何 Add 调用都会影响调用者中的列表。

通过 ref 传递 List 的行为本质上类似于向该列表传递双指针。这是一个例子：

using System;
using System.Collections.Generic;

public class Test
{
    public static void Main()
    {
        List<int> l = new List<int>() { 1, 2, 3 };
        Fuss(l);
        Console.WriteLine(l.Count); // Count will now be 5.

        FussNonRef(l);
        Console.WriteLine(l.Count); // Count will still be 5 because we 
                                    // overwrote the copy of our reference 
                                    // in FussNonRef.

        FussRef(ref l);
        Console.WriteLine(l.Count); // Count will be 2 because we changed
                                    // our reference in FussRef.
    }

    private static void Fuss(List<int> l)
    {
        l.Add(4);
        l.Add(5);
    }

    private static void FussNonRef(List<int> l)
    {
        l = new List<int>();
        l.Add(6);
        l.Add(7);
    }

    private static void FussRef(ref List<int> l)
    {
        l = new List<int>();
        l.Add(8);
        l.Add(9);
    }
}

Answer 5

“List”类型的变量、参数或字段或任何其他引用类型实际上并不保存列表（或任何其他类的对象）。相反，它会保存类似“对象 ID #29115”的内容（当然，不是这样一个实际的字符串，而是本质上意味着这一点的位组合）。在其他地方，系统将有一个称为堆的索引对象集合；如果 List 类型的某个变量保存“对象 ID #29115”，则堆中的对象 #29115 将是 List 的实例或从中派生的某种类型。

如果 MyFoo 是 List 类型的变量，像 'MyFoo.Add("George")' 这样的语句实际上不会改变 MyFoo；相反，它的意思是“检查存储在 MyFoo 中的对象 ID，并调用存储在其中的对象的“Add”方法。如果 MyFoo 在执行语句之前持有“Object ID #19533”，则之后它将继续这样做，但是 Object ID #19533 将调用其 Add 方法（可能会更改该对象），相反，像“MyFoo = MyBar”这样的语句将使 MyFoo 拥有与 MyBar 相同的对象 ID，但实际上不会这样做。如果 MyBar 在该语句之前持有“Object ID #59212”，则在该语句之后，MyFoo 也将持有“ObjectId #59212”，对象 ID #19533 和对象 ID#59212 都不会发生任何情况。 。

Answer 6

对于像 List 这样的引用类型，ref 和 non-ref 之间的区别不在于是否传递引用（这种情况总是发生），而是该引用是否可以更改。尝试以下操作

private void Fuss(ref List<int> l)
{
    l = new List<int> { 4, 5 };
}

，您将看到计数为 2，因为该函数不仅操作原始列表，还操作引用本身。

Answer 7

只有 int、double 等基本类型是按值传递的。

复杂类型（如列表）通过引用传递（确切地说，这是按值传递指针）。

Answer 8

让我们解释一下简单:)

• 第一个代码块中的“Fuss”知道他应该接受来自列表类型的引用
• 第二个代码块中的“Fuss”知道他应该接受不接受任何东西！但只是对“sth else”的引用，意外地这个“sth else”与你的第一块代码中的东西是一样的