Exercice - Utiliser des paramètres de type valeur et référence

5 minutes

En C#, les variables peuvent être classées en deux types principaux, types valeur et types de référence. Ces types décrivent comment les variables stockent leurs valeurs.

Les types valeur tels que int, , boolfloat, doubleet char contiennent directement des valeurs. Les types de référence tels que string, arrayet les objets (tels que les instances de Random) ne stockent pas leurs valeurs directement. Au lieu de cela, les types de référence stockent une adresse où leur valeur est stockée.

Paramètres passés par valeur et passés par référence

Lorsqu’un argument est passé à une méthode, les variables de type valeur ont leurs valeurs copiées dans la méthode. Chaque variable a sa propre copie de la valeur, de sorte que la variable d’origine n’est pas modifiée.

Avec les types de référence, l’adresse de la valeur est passée à la méthode. La variable donnée à la méthode fait référence à la valeur à cette adresse, de sorte que les opérations sur cette variable affectent la valeur référencée par l’autre.

Remarque

Il est important de se rappeler qu’il string s’agit d’un type de référence, mais il est immuable. Cela signifie qu’une fois qu’elle a été affectée à une valeur, elle ne peut pas être modifiée. En C#, lorsque des méthodes et des opérateurs sont utilisés pour modifier une chaîne, le résultat retourné est en fait un nouvel objet de chaîne.

Dans cet exercice, vous allez en savoir plus sur la transmission d’arguments de référence et de type valeur dans des méthodes.

Tester le passage par valeur

Dans l’Éditeur Visual Studio Code, supprimez tout code existant des exercices précédents.
Entrez le code suivant dans l’Éditeur Visual Studio Code :
```
int a = 3;
int b = 4;
int c = 0;

Multiply(a, b, c);
Console.WriteLine($"global statement: {a} x {b} = {c}");

void Multiply(int a, int b, int c) 
{
    c = a * b;
    Console.WriteLine($"inside Multiply method: {a} x {b} = {c}");
}
```
Les variables a, bet c sont passées à la Multiply méthode. Les valeurs des variables sont imprimées pendant l’exécution de la méthode et imprimées à nouveau une fois la méthode terminée.

Les entiers sont des types valeur, qui ont leurs valeurs copiées lorsqu’elles sont passées dans des méthodes. Que pensez-vous que la sortie de c sera ?
Enregistrez et exécutez votre code pour observer la sortie suivante :
```
inside Multiply method: 3 x 4 = 12
global statement: 3 x 4 = 0
```
Notez que la valeur de c n’est modifiée que dans la Multiply méthode. En dehors de la méthode, c conserve sa valeur d’origine.

Tester le passage par référence

Supprimez le code précédent de Visual Studio Code Editor.
Entrez le code suivant dans l’Éditeur Visual Studio Code :
```
int[] array = {1, 2, 3, 4, 5};

PrintArray(array);
Clear(array);
PrintArray(array);

void PrintArray(int[] array) 
{
    foreach (int a in array) 
    {
        Console.Write($"{a} ");
    }
    Console.WriteLine();
}

void Clear(int[] array) 
{
    for (int i = 0; i < array.Length; i++) 
    {
        array[i] = 0;
    }
}
```
Le code commence par array initialisé pour contenir certaines valeurs entières. Les valeurs sont affichées à l’aide de la PrintArray méthode. La Clear méthode est appelée sur le tableau, puis le tableau est à nouveau imprimé.

Les tableaux sont des types référence. Les types de référence stockent l’adresse de leurs valeurs en mémoire. Que pensez-vous que sera le résultat ?
Enregistrez et exécutez votre code pour observer la sortie suivante :
```
1 2 3 4 5 
0 0 0 0 0
```
Veuillez noter que le tableau reste modifié en dehors du périmètre de la méthode Clear. Cela se produit parce que la Clear méthode a mis à jour les valeurs stockées à chaque adresse.

Tester avec des chaînes de caractères

Précédemment, vous avez appris que les chaînes sont un type immuable . Même si une chaîne est un type référence, contrairement à un tableau, sa valeur ne peut pas être modifiée une fois qu’elle est affectée. Vous l’avez peut-être remarqué si vous avez utilisé des méthodes telles que string.Replace ou string.ToUpper. Dans cette tâche, vous allez apprendre à corriger une erreur courante trouvée lors de l’utilisation de chaînes.

Dans l’Éditeur Visual Studio Code, supprimez tout code existant des exercices précédents.

Entrez le code suivant dans l’Éditeur Visual Studio Code :

string status = "Healthy";

Console.WriteLine($"Start: {status}");
SetHealth(status, false);
Console.WriteLine($"End: {status}");

void SetHealth(string status, bool isHealthy) 
{
    status = (isHealthy ? "Healthy" : "Unhealthy");
    Console.WriteLine($"Middle: {status}");
}

Enregistrez et exécutez votre code pour observer la sortie suivante :
```
Start: Healthy
Middle: Unhealthy
End: Healthy
```
Si la SetHealth méthode n’a pas généré l’état, vous avez peut-être supposé que la méthode n’a pas été exécutée correctement. Au lieu de cela, une nouvelle chaîne avec la valeur « Unhealthy » a été créée, puis perdue dans l’étendue de la méthode.

Pour corriger ce problème, vous pouvez modifier SetHealth pour utiliser la variable d'état globale à la place.

Mettez le code à jour comme suit :

string status = "Healthy";

Console.WriteLine($"Start: {status}");
SetHealth(false);
Console.WriteLine($"End: {status}");

void SetHealth(bool isHealthy) 
{
    status = (isHealthy ? "Healthy" : "Unhealthy");
    Console.WriteLine($"Middle: {status}");
}

Dans ce code, vous remplacez la variable globale status par la nouvelle valeur de chaîne.

Enregistrez et exécutez votre code pour observer la sortie suivante :
```
Start: Healthy
Middle: Unhealthy
End: Unhealthy
```
À présent, la chaîne mise à jour est capturée et stockée correctement.

Récapitulatif

Voici ce que vous avez appris sur les paramètres de type valeur et de type de référence jusqu’à présent :

Les variables peuvent être classées comme types valeur et types de référence.
Les types valeur contiennent directement des valeurs et les types de référence stockent l’adresse de la valeur.
Les méthodes utilisant des arguments de type valeur créent leur propre copie des valeurs.
Les méthodes qui effectuent des modifications sur un paramètre de tableau affectent le tableau d’entrée d’origine.
La chaîne est un type de référence immuable.
Les méthodes qui effectuent des modifications sur un paramètre de chaîne n’affectent pas la chaîne d’origine.

Commentaires

Cette page a-t-elle été utile ?