Предоставляет ли C# список <T> методу по ссылке или в качестве копии?

Question

Принимая мои первые шаги в C# мире от C/C++, так что немного туманно в деталях. Классы, насколько я понял, передаются по ссылке по умолчанию, но как насчет, например. Список < строка > как в:

void DoStuff(List<string> strs) 
{ 
    //do stuff with the list of strings 
} 

и в других местах

List<string> sl = new List<string>(); 
//next fill list in a loop etc. and then do stuff with it: 
DoStuff(sl); 

Является С.Л. в этом случае передается по ссылке или копия сделана так, что мне нужно переопределить функцию уборщица, как

void DoStuff(ref List<string> strs)

, чтобы фактически действовать на sl сам, а не копией?

Answer 1

Он передан по ссылке. List<T> - это класс, и все экземпляры классов передаются по ссылке.

Answer 2

Ключевое слово ref в вашем методе является избыточным, если вы хотите изменить исходный список: List<T> является ссылочным типом (class на C#) и поэтому будет передан методу по ссылке; поэтому метод будет управлять исходным списком.

При передаче Value Type оно создаст копию самого значения. При передаче Reference Type он создаст копию справки.

Подробнее о Value and Reference Types в C#.

Answer 3

Поведение всегда одно и то же: передача путем копирования. В случае, если параметр является объектом, ссылка на объект копируется, поэтому на самом деле вы работаете над одним и тем же объектом/списком/независимо.

Answer 4

Основой всегда является: типы значений передаются по значению, а ссылочные типы «передаются по ссылке» (цитируются, потому что значение ссылки фактически передается по значению, но большинство людей игнорируют это ради краткости).

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

Ключевое слово ref, при использовании в ссылочном типе, семантически передает ссылку на ссылку (я действительно не могу сказать «указатель на указатель»).

Если ваш метод должен был повторно назначить аргумент ref новому объекту, вызывающий объект также увидит это новое назначение. Принимая во внимание, что без ключевого слова ref, метод просто перераспределит свою собственную локальную копию ссылочного значения, и вызывающий объект все равно будет иметь ссылку на свой исходный объект.

Приведенное выше описание бесстыдно взяты из Jon Skeet's article on the topic:

Это различие имеет решающее значение для понимания параметра переходящая в C#, и поэтому я считаю, что это сильно сбивает с толку, чтобы сказать, что объекты передаются по ссылке по умолчанию вместо правильного оператора ссылки на объекты по умолчанию передаются по значению.

Ключевое слово ref необходимо только в том случае, если вы намерены повторно назначить аргумент и иметь видимый для вызывающего абонента. В большинстве случаев вы обнаружите, что это не нужно. Ваш DoStuff может быть переписан, чтобы удалить его и до сих пор передать ссылку на список по значению успешно:

void DoSomething(List<string> strs) 
{ 
    strs.Add("Hello"); 
} 

Answer 5

Сво по ссылке. Не обязательно включать «ref».

С уважением.

Answer 6

Список передается по ссылке. Фактически это означает, что переменная strs внутри метода относится к тому же списку, что и переменная sl вне метода. Если вы используете ref, вы можете переназначить переменную sl внутри метода.

strs = new List<string>() 

сделает sl точкой в ​​новом списке.

Поскольку вы исходите из C/C++: ref может считаться «безопасным указателем». Это похоже на использование & STRs

Answer 7

В дополнение к другим ответам это очень важно, чтобы понять поведение исх

Вот некоторые примеры кода для демонстрационных целей

static void Main(string[] args) 
    { 

     List<string> lstStr = new List<string>(); 

     lstStr.Add("First"); 
     lstStr.Add("Second"); 

     Alter(lstStr); 

     //Alter(ref lstStr); 

     Console.WriteLine("---From Main---"); 
     foreach (string s in lstStr) 
     { 
      Console.WriteLine(s); 
     } 

     Alter2(ref lstStr); 

     Console.WriteLine("---From Main after passed by ref---"); 
     foreach (string s in lstStr) 
     { 
      Console.WriteLine(s); 
     } 

     Console.ReadKey(); 
    } 

    static void Alter(List<string> lstStr2) 
    { 
     lstStr2.Add("Third"); 

     Console.WriteLine("----From Alter----"); 
     foreach (string s in lstStr2) 
     { 
      Console.WriteLine(s); 
     } 

     lstStr2 = new List<string>(); 
     lstStr2.Add("Something new"); 

     Console.WriteLine("----From Alter - after the local var is assigned somthing else----"); 

     foreach (string s in lstStr2) 
     { 
      Console.WriteLine(s); 
     } 

    } 

    static void Alter2(ref List<string> lstStr2) 
    { 
     lstStr2 = new List<string>(); 
     lstStr2.Add("Something new from alter 2"); 

     Console.WriteLine("----From Alter2 - after the local var is assigned new list----"); 

     foreach (string s in lstStr2) 
     { 
      Console.WriteLine(s); 
     } 

    } 


//----From Alter---- 
//First 
//Second 
//Third 
//----From Alter - after the local var is assigned somthing else---- 
// Something new 
// ---From Main--- 
// First 
// Second 
// Third 
// ----From Alter2 - after the local var is assigned new list---- 
// Something new from alter 2 
// ---From Main after passed by ref--- 
// Something new from alter 2