C# Language
Type de valeur vs type de référence

Syntaxe

• Passage par référence: public void Double (ref int numberToDouble) {}

Remarques

Changer les valeurs ailleurs

public static void Main(string[] args)
{
    var studentList = new List<Student>();
    studentList.Add(new Student("Scott", "Nuke"));
    studentList.Add(new Student("Vincent", "King"));
    studentList.Add(new Student("Craig", "Bertt"));

    // make a separate list to print out later
    var printingList = studentList; // this is a new list object, but holding the same student objects inside it

    // oops, we've noticed typos in the names, so we fix those
    studentList[0].LastName = "Duke";
    studentList[1].LastName = "Kong";
    studentList[2].LastName = "Brett";

    // okay, we now print the list
    PrintPrintingList(printingList);
}

private static void PrintPrintingList(List<Student> students)
{
    foreach (Student student in students)
    {
        Console.WriteLine(string.Format("{0} {1}", student.FirstName, student.LastName));
    }
}

Vous remarquerez que même si la liste printingList a été créée avant les corrections apportées aux noms d'élèves après les fautes de frappe, la méthode PrintPrintingList affiche toujours les noms corrigés:

Scott Duke
Vincent Kong
Craig Brett

En effet, les deux listes contiennent une liste de références aux mêmes étudiants. SO modifier l'objet objet sous-jacent propage aux utilisations par l'une ou l'autre liste.

Voici à quoi ressemblerait la classe d'élèves.

public class Student
{
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public Student(string firstName, string lastName)
    {
        this.FirstName = firstName;
        this.LastName = lastName;
    }
}

En passant par référence

Si vous souhaitez que les types de valeurs et les types de référence dans les méthodes fonctionnent correctement, utilisez le mot-clé ref dans la signature de votre méthode pour le paramètre que vous souhaitez transmettre par référence, ainsi que lorsque vous appelez la méthode.

public static void Main(string[] args)
{
    ...
    DoubleNumber(ref number); // calling code
    Console.WriteLine(number); // outputs 8
    ...
}

public void DoubleNumber(ref int number)
{
    number += number;
}

Faire ces modifications rendrait le numéro mis à jour comme prévu, ce qui signifie que la sortie de la console pour le numéro serait 8.

Passage par référence en utilisant le mot-clé ref.

De la documentation :

En C #, les arguments peuvent être transmis aux paramètres par valeur ou par référence. Le passage par référence permet aux membres de la fonction, aux méthodes, aux propriétés, aux indexeurs, aux opérateurs et aux constructeurs de modifier la valeur des paramètres et de conserver cette modification dans l'environnement appelant. Pour transmettre un paramètre par référence, utilisez le mot-clé ref ou out .

La différence entre ref et out est que out signifie que le paramètre passé doit être assigné avant que la fonction ends.in change les paramètres passés avec ref peuvent être modifiés ou laissés inchangés.

using System;

class Program
{
    static void Main(string[] args)
    {
        int a = 20;
        Console.WriteLine("Inside Main - Before Callee: a = {0}", a);
        Callee(a);
        Console.WriteLine("Inside Main - After Callee: a = {0}", a);
        
        Console.WriteLine("Inside Main - Before CalleeRef: a = {0}", a);
        CalleeRef(ref a);
        Console.WriteLine("Inside Main - After CalleeRef: a = {0}", a);
     
        Console.WriteLine("Inside Main - Before CalleeOut: a = {0}", a);
        CalleeOut(out a);
        Console.WriteLine("Inside Main - After CalleeOut: a = {0}", a);
        
        Console.ReadLine();
    }

    static void Callee(int a)
    {
        a = 5;
        Console.WriteLine("Inside Callee a : {0}", a);
    }

    static void CalleeRef(ref int a)
    {
        a = 6;
        Console.WriteLine("Inside CalleeRef a : {0}", a);
    }
    
    static void CalleeOut(out int a)
    {
        a = 7;
        Console.WriteLine("Inside CalleeOut a : {0}", a);
    }
}

Sortie :

Inside Main - Before Callee: a = 20
Inside Callee a : 5
Inside Main - After Callee: a = 20
Inside Main - Before CalleeRef: a = 20
Inside CalleeRef a : 6
Inside Main - After CalleeRef: a = 6
Inside Main - Before CalleeOut: a = 6
Inside CalleeOut a : 7
Inside Main - After CalleeOut: a = 7

Affectation

var a = new List<int>();
var b = a;
a.Add(5);
Console.WriteLine(a.Count); // prints 1 
Console.WriteLine(b.Count); // prints 1 as well

L'affectation à une variable d'une List<int> ne crée pas une copie de la List<int> . Au lieu de cela, il copie la référence à la List<int> . Nous appelons les types qui se comportent de cette façon les types de référence .

Différence avec les paramètres de méthode réf et out

Il existe deux manières possibles de passer un type de valeur par référence: ref et out . La différence est que, en le passant avec ref la valeur doit être initialisée mais pas lors du passage avec out . L'utilisation de out garantit que la variable a une valeur après l'appel de la méthode:

public void ByRef(ref int value)
{
    Console.WriteLine(nameof(ByRef) + value);
    value += 4;
    Console.WriteLine(nameof(ByRef) + value);
}

public void ByOut(out int value)
{
    value += 4 // CS0269: Use of unassigned out parameter `value'  
    Console.WriteLine(nameof(ByOut) + value); // CS0269: Use of unassigned out parameter `value'  

    value = 4;
    Console.WriteLine(nameof(ByOut) + value);
}

public void TestOut()
{
    int outValue1;
    ByOut(out outValue1); // prints 4

    int outValue2 = 10;   // does not make any sense for out
    ByOut(out outValue2); // prints 4
}

public void TestRef()
{
    int refValue1;
    ByRef(ref refValue1); // S0165  Use of unassigned local variable 'refValue'

    int refValue2 = 0;
    ByRef(ref refValue2); // prints 0 and 4

    int refValue3 = 10;
    ByRef(ref refValue3); // prints 10 and 14
}

Le hic est que l'aide out le paramètre must être initialisé avant de quitter la méthode, donc la méthode suivante est possible ref mais pas out :

public void EmtyRef(bool condition, ref int value)
{
    if (condition)
    {
        value += 10;
    }
}

public void EmtyOut(bool condition, out int value)
{
    if (condition)
    {
        value = 10;
    }
} //CS0177: The out parameter 'value' must be assigned before control leaves the current method

En effet, si la condition ne tient pas, la value ne sera pas attribuée.

paramètres de réf vs out

Code

class Program
{
    static void Main(string[] args)
    {
        int a = 20;
        Console.WriteLine("Inside Main - Before Callee: a = {0}", a);
        Callee(a);
        Console.WriteLine("Inside Main - After Callee: a = {0}", a);
        Console.WriteLine();

        Console.WriteLine("Inside Main - Before CalleeRef: a = {0}", a);
        CalleeRef(ref a);
        Console.WriteLine("Inside Main - After CalleeRef: a = {0}", a);
        Console.WriteLine();

        Console.WriteLine("Inside Main - Before CalleeOut: a = {0}", a);
        CalleeOut(out a);
        Console.WriteLine("Inside Main - After CalleeOut: a = {0}", a);
        Console.ReadLine();
    }

    static void Callee(int a)
    {
        a += 5;
        Console.WriteLine("Inside Callee a : {0}", a);
    }

    static void CalleeRef(ref int a)
    {
        a += 10;
        Console.WriteLine("Inside CalleeRef a : {0}", a);
    }

    static void CalleeOut(out int a)
    {
        // can't use a+=15 since for this method 'a' is not intialized only declared in the method declaration
        a = 25; //has to be initialized
        Console.WriteLine("Inside CalleeOut a : {0}", a);
    }
}

Sortie

Inside Main - Before Callee: a = 20
Inside Callee a : 25
Inside Main - After Callee: a = 20

Inside Main - Before CalleeRef: a = 20
Inside CalleeRef a : 30
Inside Main - After CalleeRef: a = 30

Inside Main - Before CalleeOut: a = 30
Inside CalleeOut a : 25
Inside Main - After CalleeOut: a = 25