Тип посилання в C #

Розглянемо цей код:

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змінна не буде нульовим або?

Обидва personі person2є посиланнями на один і той же об'єкт. Але це різні посилання. Отже, коли ви біжите

person2 = null;

Ви змінюєте лише посилання person2, залишаючи посиланняperson та відповідний об’єкт без змін.

Я думаю, найкращий спосіб пояснити це спрощеною ілюстрацією. Ось як виглядала ситуація раніше person2 = null :

І ось малюнок після нульового призначення:

Як бачите, на другому малюнку person2нічого не згадується (або null, строго кажучи, оскільки посилання ні на що і посилання на nullце різні умови, див. Коментар Rune FS ), в той personже час посилання на існуючий об'єкт.

Розглянемо person1і person2 як вказівники на деяке місце в сховищі. На першому кроці лише person1зберігається адреса об’єкта із сховища, а пізніше person2- адреса місця розташування об’єкта в пам’яті. Пізніше , коли ви призначаєте nullна person2, person1залишається незмінним. Ось чому ви бачите результат.

Ви можете прочитати: Цінність проти еталонних типів від Джозефа Альбахарі

Однак із типовими посиланнями об'єкт створюється в пам'яті, а потім обробляється через окреме посилання - швидше як вказівник.

Я спробую зобразити те саме поняття, використовуючи наступну схему.

Створено новий об'єкт типу person і person1посилання (вказівник) вказує на місце пам'яті в сховищі.

Створено нове посилання (покажчик), person2яке вказує на те саме в сховищі.

Змінено ім'я властивості об'єкта на нове значення, person2оскільки обидва посилання вказують на один і той же об'єкт, Console.WriteLine(person1.Name);виводить Shahrooz.

Після призначення nullв якості person2посилання, він буде вказувати нічого, але person1все ще тримає посилання на об'єкт.

(Нарешті, для управління пам’яттю ви повинні побачити «Стек - це деталь реалізації», частина перша та «Стек - деталь реалізації», частина друга від Еріка Ліпперта)

Ви змінили person2посилання null, але person1посилання там не здійснюється.

Я маю на увазі, що якщо ми розглянемо person2і person1перед призначенням, тоді обидва посилаються на один і той же об’єкт. Потім ви призначаєте person2 = null, тож особа 2 зараз посилається на інший тип. Він не видалив об’єкт, на який person2посилався.

Я створив цей gif для ілюстрації:

Тому що ви встановили посилання на null.

Коли ви встановлюєте посилання на null, саме посилання єnull .., а не об’єктом, на який він посилається.

Подумайте про них як про змінну, яка містить зміщення від 0. personмає значення 120. person2має значення 120. Дані зі зміщенням 120 є Personоб’єктом. Коли ви робите це:

person2 = null;

..you're ефективно кажучи person2 = 0;. Однак personвсе ще має значення 120.

І те, personі person2 інше на один і той же об’єкт. Тому при зміні назви будь-якого з них обидва будуть змінені (оскільки вони вказують на одну і ту ж структуру в пам'яті).

Але коли ви встановлюєте person2значення null, ви перетворюєте person2на нульовий покажчик, так що це не вказує на той самий об'єкт, що personвже. Він не робить нічого для самого об'єкта, щоб знищити його, і з тих пірperson все ще вказує / посилається на об'єкт, він також не буде вбитий через збір сміття.

Якщо ви також встановили person = null, і у вас немає інших посилань на об’єкт, він врешті видалить збирач сміття.

person1і person2вкажіть на ту саму адресу пам'яті. Коли ви нульові person2, ви нульові посилання, а не адресу пам'яті, тому person1продовжує посилатися на цю адресу пам'яті, це і є причиною. Якщо ви зміните Classs Personна a Struct, поведінка зміниться.

Я вважаю, що найкориснішим є уявлення про типи посилань як про ідентифікатори об’єктів. Якщо у когось є змінна типу класу Car, оператор myCar = new Car();просить систему створити нову машину та повідомити її ідентифікатор (припустимо, це об’єкт №57); потім він поміщає "об'єкт №57" у змінну myCar. Якщо хтось пише Car2 = myCar;, це записує "об'єкт №57" у змінну Car2. Якщо хтось пишеcar2.Color = blue; , це вказує системі знайти автомобіль, ідентифікований Car2 (наприклад, об’єкт №57), і пофарбувати його в синій колір.

Єдиними операціями, які виконуються безпосередньо над ідентифікаторами об'єкта, є створення нового об'єкта та отримання ідентифікатора, отримання "порожнього" ідентифікатора (тобто нульовий), копіювання ідентифікатора об'єкта в змінну або місце зберігання, яке може його утримувати, перевірка, чи є два ідентифікатори об'єктів збігаються (посилаються на той самий об'єкт). Усі інші запити вимагають від системи знайти об’єкт, на який посилається ідентифікатор, та діяти на нього (не впливаючи на змінну чи іншу сутність, що тримала ідентифікатор).

У існуючих реалізаціях .NET змінні об'єкти, швидше за все, містять вказівники на об'єкти, що зберігаються у купі, що збирається сміттям, але це не корисна деталь реалізації, оскільки існує критична різниця між посиланням на об'єкт та будь-яким іншим покажчиком. Як правило, вважається, що вказівник відображає місце розташування чогось, що залишатиметься досить довгим, щоб працювати з ним. Посилання на об'єкти ні. Шматок коду може завантажити регістр SI з посиланням на об'єкт, розташований за адресою 0x12345678, почати його використовувати, а потім перервати, поки збирач сміття переміщує об'єкт на адресу 0x23456789. Це би звучало як катастрофа, але сміття вивчить метадані, пов’язані з кодом, зауважимо, що код використовував SI для утримання адреси об’єкта, який він використовував (тобто 0x12345678), визначити, що об’єкт, що знаходився в 0x12345678, було переміщено в 0x23456789, та оновити SI, щоб він містив 0x23456789, перш ніж він повернувся. Зверніть увагу, що в цьому сценарії чисельне значення, що зберігається у SI, було змінено збирачем сміття, але воно посилалосяодин і той же об'єкт до переїзду та після. Якщо перед переміщенням воно посилалося на 23592-й об'єкт, створений з моменту запуску програми, він буде продовжувати робити це після цього. Цікаво, що .NET не зберігає жодного унікального та незмінного ідентифікатора для більшості об’єктів; з урахуванням двох знімків пам'яті програми, не завжди можна буде визначити, чи існує якийсь конкретний об'єкт у першому знімку, або якщо всі сліди до нього були залишені та створено новий об'єкт, який, схоже, схожий на всі спостережувані деталі.

person1 та person2 - це дві окремі посилання на стек, які вказують на один і той же об’єкт Person у купі.

Коли ви видаляєте одне з посилань, воно видаляється зі стеку і більше не вказує на об’єкт Person у купі. Інше посилання залишається, все ще вказуючи на існуючий об’єкт Person у купі.

Як тільки всі посилання на об’єкт Person будуть видалені, тоді збірник сміття видалить об’єкт із пам'яті.

Коли ви створюєте тип посилання, його фактично копіюється посилання з усіма об'єктами, що вказують на одне і те ж розташування пам'яті, однак якщо ви призначили Person2 = Null, це не матиме ефекту, оскільки person2 - це просто копія контрольної особи, і ми щойно видалили копію посилання .

Зверніть увагу, що семантику значення можна отримати, змінивши значення на 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; }
}

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

Спочатку скопіюйте посилання person1на person2. Тепер person1і person2посилання на той самий об'єкт, що означає зміни значення цього об'єкта (тобто зміна Nameвластивості) можна спостерігати за обома змінними. Потім, призначаючи значення null, ви видаляєте посилання, якому ви щойно призначили person2. Це призначено лише 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;}
}

Кажучи:

person2.Name = "Shahrooz";

слідує за посиланням person2та "мутує" (змінює) об'єкт, до якого посилання випадково веде. Сама посилання (по вартості зperson2 ) не змінюється; ми все ще посилаємось на той самий екземпляр за тією ж "адресою".

Призначення person2як у:

person2 = null;

змінює посилання . Жоден об'єкт не змінюється. У цьому випадку посилання стрілок «переміщаються» від одного об'єкта до «нічого», null. Але таке призначення person2 = new Person();також також лише змінить посилання. Жоден об’єкт не мутується.