C＃中的引用类型

Question

考虑以下代码：

public class Program
{
    private static void Main(string[] args)
    {
        var person1 = new Person { Name = "Test" };
        Console.WriteLine(person1.Name);

        Person person2 = person1;
        person2.Name = "Shahrooz";
        Console.WriteLine(person1.Name); //Output: Shahrooz
        person2 = null;
        Console.WriteLine(person1.Name); //Output: Shahrooz
    }
}

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

很显然，当分配person1到person2和Name的属性person2改变时， Name的person1也会随之改变。 person1和person2具有相同的引用。

为什么当person2 = null ， person1变量也不会为null？

Answer 1

person和person2都是对同一对象的引用 。 但是这些是不同的参考。 所以当你跑步时

person2 = null;

您仅更改了参考person2 ，而没有更改参考person和相应的对象。

我猜想最好的解释方法是简化图示。 这是person2 = null 之前的情况：

这是空分配后的图片：

如您所见，在第二张图片上person2没有引用任何内容（严格来说是null ，因为没有引用和对null引用是不同的条件，请参见Rune FS的注释），而person仍然引用现有对象。

Answer 2

将person1和person2 视为指向存储中某个位置的指针 。 在第一步中，只有person1从存储中保存对象的地址，随后person2从存储中保存对象的存储位置的地址。 稍后，当您为person2分配null时， person1保持不受影响。 这就是为什么您看到结果的原因。

您可能会阅读： Joseph Albahari的值与引用类型

但是，使用引用类型时，将在内存中创建对象，然后通过单独的引用（类似于指针）来处理该对象。

我将尝试使用下图描述相同的概念。

创建了一个类型为person的新对象，并且person1引用（指针）指向存储中的内存位置。

创建了一个新的引用（指针） person2 ，它指向存储中的相同对象。

通过person2将对象属性Name更改为新值，因为两个引用都指向同一个对象Console.WriteLine(person1.Name); person2 输出Shahrooz 。

将null分配给person2引用后，它将指向person1 ，但person1仍保留对该对象的引用。

（最后对于内存管理，您应该从Eric Lippert看到堆栈是实现细节，第一部分 ， 堆栈是实现细节，第二部分 ）

Answer 3

您已将person2更改为引用null ，但person1没有引用那里。

我的意思是，如果我们在分配之前查看person2和person1 ，那么它们都引用同一对象。 然后，将person2 = null赋值，因此第二个人2现在正在引用其他类型。 它没有删除引用person2的对象。

我创建了以下gif来说明这一点：

Answer 4

因为您已将引用设置为null 。

当您将引用设置为null ，引用本身为null ..不是它引用的对象。

把它们当作保持的偏移从0可变person具有值120 person2具有偏移120是值120在数据Person对象。 执行此操作时：

person2 = null;

..您实际上是在说person2 = 0; 。 但是， person的值仍为120。

Answer 5

person和person2 指向同一对象。 因此，当您更改任何一个的名称时，两者都将被更改（因为它们指向内存中的相同结构）。

但是，当将person2设置为null ，会使person2成为空指针，因此不再指向与person相同的对象。 它不会对对象本身做任何事情来销毁它，并且由于person仍然指向/引用该对象，所以它也不会被垃圾回收杀死。

如果您还设置person = null ，并且您没有对该对象的其他引用，则最终它将被垃圾收集器删除。

Answer 6

person1和person2指向相同的内存地址。 当您将person2 null时， person2引用而不是内存地址person2 null，因此person1继续引用该内存地址，这就是原因。 如果将Classs Person更改为Struct ，则行为将发生变化。

Answer 7

我发现将引用类型视为保存对象ID最有用。 如果一个变量的类类型为Car ，则语句myCar = new Car(); 要求系统创建一辆新车并报告其ID（假设它是对象＃57）； 然后将“对象＃57”放入变量myCar 。 如果有人写Car2 = myCar; ，将“对象＃57”写入变量Car2。 如果写出car2.Color = blue; ，指示系统查找由Car2标识的汽车（例如，对象＃57）并将其涂成蓝色。

直接在对象ID上直接执行的唯一操作是创建新对象并获取ID，获取“空白” ID（即null），将对象ID复制到可以容纳它的变量或存储位置，检查是否两个对象ID匹配（指的是同一对象）。 所有其他请求都要求系统查找ID引用的对象并对该对象执行操作（不影响持有ID的变量或其他实体）。

在.NET的现有实现中，对象变量可能会保留指向存储在垃圾回收堆中的对象的指针，但这对实现细节无济于事，因为对象引用与任何其他类型的指针之间存在重大差异。 通常假定一个指针代表某个东西的位置，该东西将放置足够长的时间以便使用。 对象引用没有。 一段代码可以使用对位于地址0x12345678的对象的引用来加载SI寄存器，开始使用它，然后在垃圾回收器将对象移至地址0x23456789时被中断。 这听起来像是一场灾难，但是垃圾将检查与代码关联的元数据，观察代码使用SI来保存其正在使用的对象的地址（即0x12345678），确定位于0x12345678的对象已被移动设置为0x23456789，并在SI返回之前将SI更新为保留0x23456789。 请注意，在这种情况下，垃圾收集器更改了存储在SI中的数值，但在移动之前和之后都引用了相同的对象 。 如果在移动之前它引用了自程序启动以来创建的第23592个对象，则此后它将继续这样做。 有趣的是，.NET不会为大多数对象存储任何唯一且不变的标识符。 给定程序内存的两个快照，将无法始终得知第二个快照中是否存在第一个快照中的任何特定对象，或者是否已经放弃了对它的所有跟踪并且创建了一个新对象，而该对象恰好看起来像所有可观察的细节。

Answer 8

person1和person2是堆栈上的两个单独的引用，它们指向堆上的同一Person对象。

当您删除其中一个引用时，会将其从堆栈中删除，并且不再指向堆上的Person对象。 另一个引用仍然保留，仍然指向堆上现有的Person对象。

一旦删除了对Person对象的所有引用，最终垃圾收集器将从内存中删除该对象。

Answer 9

当您创建引用类型时，它实际上是在复制所有引用都指向同一内存位置的对象的引用，但是，如果您将Person2 = Null分配给它，将不会起作用，因为person2只是引用人的一个副本，而我们只是删除了一个副本参考 。

Answer 10

请注意，可以通过更改为struct来获取值语义。

public class Program
{
    static void Main()
    {
        var person1 = new Person { Name = "Test" };
        Console.WriteLine(person1.Name);

        Person person2 = person1;
        person2.Name = "Shahrooz";
        Console.WriteLine(person1.Name);//Output:Test
        Console.WriteLine(person2.Name);//Output:Shahrooz
        person2 = new Person{Name = "Test2"};
        Console.WriteLine(person2.Name);//Output:Test2

    }
}
public struct Person
{
    public string Name { get; set; }
}

Answer 11

public class Program
{
    private static void Main(string[] args)
    {
        var person = new Person {Name = "Test"};
        Console.WriteLine(person.Name);

        Person person2 = person;
        person2.Name = "Shahrooz";
        Console.WriteLine(person.Name);//Output:Shahrooz
        // Here you are just erasing a copy to reference not the object created.
        // Single memory allocation in case of reference type and  parameter
         // are passed as a copy of reference type .   
        person2 = null;
        Console.WriteLine(person.Name);//Output:Shahrooz

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

Answer 12

您首先person1 person2的引用复制到person2 。 现在person1和person2引用相同的对象，这意味着在两个变量下都可以观察到对该对象值的修改（即，更改Name属性）。 然后，当分配null时，您将删除刚刚分配给person2的引用。 现在仅分配给person1 。 请注意，引用本身不会更改。

如果您有一个通过引用接受参数的函数，则可以通过reference to person1 引用传递reference to person1 ，并且可以更改引用本身：

public class Program
{
    private static void Main(string[] args)
    {
        var person1 = new Person { Name = "Test" };
        Console.WriteLine(person1.Name);

        PersonNullifier.NullifyPerson(ref person1);
        Console.WriteLine(person1); //Output: null
    }
}


class PersonNullifier
{
    public static void NullifyPerson( ref Person p ) {
        p = null;
    }
}

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

Answer 13

说：

person2.Name = "Shahrooz";

跟随person2的引用并“变异”（更改）该引用碰巧导致的对象。 引用本身（ person2的值 ）保持不变； 我们仍然在相同的“地址”中引用相同的实例。

分配给person2如下所示：

person2 = null;

更改参考 。 没有对象被更改。 在这种情况下，参考箭头从一个对象“移动”到“没有”， null 。 但是像person2 = new Person();的赋值person2 = new Person(); 也只会更改参考。 没有对象被突变。