Почему список передается без ссылки функции, которая действует как переданная с помощью ссылки?

Это не действует так, как будто оно было передано исх.

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. Вы можете изменить «список», только если передадите его по ссылке (чтобы он указывал где-то еще). Вы получаете копию ссылки, которую, если изменить, можно будет наблюдать только внутри вашего метода.

Параметры в C # передаются по значению, если они не отмечены модификаторами ref или out. Для ссылочных типов это означает, что ссылка передается по значению. Следовательно, в Fuss l относится к тому же экземпляру List<int>, что и его вызывающий. Следовательно, вызывающий абонент увидит любые изменения этого экземпляра List<int>.

Теперь, если вы пометите параметр l с помощью ref или out, то параметр будет передан по ссылке. Это означает, что в Fuss, l - это псевдоним места хранения, используемый в качестве параметра для вызова метода. Чтобы было ясно:

public void Fuss(ref List<int> l)

вызванный

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

Теперь, в Fuss, l - это псевдоним для list. В частности, если вы назначите новый экземпляр List<int> для l, вызывающий также увидит этот новый экземпляр, назначенный переменной list. В частности, если вы скажете

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

тогда вызывающий теперь увидит список с одним элементом. Но если вы скажете

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

и позвонить по

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

тогда вызывающий по-прежнему будет видеть list как имеющий три элемента.

Прозрачный?

Разница между ref и non-ref для ссылочных типов, таких как List, заключается не в том, передаете ли вы ссылку (что происходит всегда), а в том, можно ли эту ссылку изменить. Попробуйте следующее

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

и вы увидите, что счетчик равен 2, потому что функция не только управляла исходным списком, но и самой ссылкой.

Переменная, параметр или поле типа «Список» или любого другого ссылочного типа на самом деле не содержит список (или объект любого другого класса). Вместо этого он будет содержать что-то вроде «Object ID # 29115» (конечно, не такую ​​фактическую строку, а комбинацию битов, которая по сути означает это). В другом месте система будет иметь индексированную коллекцию объектов, называемую кучей; если некоторая переменная типа List содержит «Object ID # 29115», то объект # 29115 в куче будет экземпляром List или производным от него типом.

Если MyFoo является переменной типа List, такой оператор, как 'MyFoo.Add ("George")', на самом деле не изменит MyFoo; вместо этого это означает: «Изучите идентификатор объекта, хранящийся в MyFoo, и вызовите метод« Добавить »для объекта, хранящегося в нем. Если MyFoo удерживал« Идентификатор объекта # 19533 »перед выполнением оператора, он продолжит делать это и после этого, но объект Для идентификатора № 19533 будет вызван метод Add (возможно, изменяющий этот объект). И наоборот, такой оператор, как «MyFoo = MyBar», заставит MyFoo содержать тот же идентификатор объекта, что и MyBar, но на самом деле ничего не будет делать с объектами в Если MyBar содержал «Object ID # 59212» перед оператором, то после оператора MyFoo также будет содержать «ObjectId # 59212». Ничего не произойдет ни с идентификатором объекта № 19533, ни с идентификатором объекта № 59212.

ByRef и ByVal применяются только к типам значений, а не к ссылочным типам, которые всегда передаются так, как если бы они были «byref».

Если вам нужно незаметно изменить список, используйте функцию «.ToList ()», и вы получите клон вашего списка.

Имейте в виду, что если ваш список содержит ссылочные типы, ваш «новый» список будет содержать указатели на те же объекты, что и исходный список.

Списки уже являются ссылочными типами, поэтому, когда вы передаете их методу, вы передаете ссылку. Любые Add вызовы повлияют на список в вызывающем абоненте.

Передача List<T> по ref ведет себя, по сути, как передача двойного указателя на этот список. Вот иллюстрация:

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

По значению передаются только примитивные типы, такие как int, double и т. Д.

Сложные типы (например, список) передаются по ссылке (которая является указателем передачи по значению, если быть точным).