Passer un objet par référence en C#

1. Passer des variables par valeur à une fonction en C#
2. Passer des variables par référence à une fonction en C#
3. Passer des objets par référence à une fonction en C#

Ce didacticiel abordera les méthodes de transmission d’un objet à une fonction en C#.

Passer des variables par valeur à une fonction en C#

Toutes les variables de type valeur sont passées par valeur par défaut en C#. Supposons que nous passions une variable par valeur à une fonction et modifions cette variable dans la fonction. Dans ce cas, il n’y a aucun effet sur la valeur de la variable passée dans les arguments de la fonction. Ce qui se passe ici, c’est qu’une copie séparée de la variable transmise est créée dans la mémoire et toutes les opérations sont effectuées sur cette copie particulière. L’exemple de code suivant nous montre comment nous pouvons transmettre une variable de type valeur par valeur en C#.

using System;

namespace pass_object_by_reference {
  class Program {
    static void method1(string value) {
      value = "something";
      Console.WriteLine("New value = {0}", value);
    }

    static void Main(string[] args) {
      string valueType = "Nothing";
      method1(valueType);
      Console.WriteLine("Original Value = {0}", valueType);
    }
  }
}

Production:

New value = something Original Value = Nothing

Dans le code ci-dessus, nous avons passé la variable chaîne valueType par valeur à la fonction method1() qui attribue une nouvelle valeur à la variable transmise. Deux copies différentes de variables ayant la même valeur sont créées dans la mémoire lorsque l’on passe la variable valueType par valeur à la fonction method1(). Et puis, la deuxième copie de la variable est modifiée en valeur something. Cette seconde copie n’est accessible qu’à l’intérieur de la fonction method1(). Toute modification de cette seconde valeur ne modifie pas la variable d’origine valueType.

Passer des variables par référence à une fonction en C#

On peut aussi passer une variable de type valeur par référence avec le mot-clé ref en C#. Le mot-clé ref spécifie qu’une valeur est passée par référence à une fonction. Avec cette approche, il n’y aura qu’une seule copie de la variable dans la mémoire, et un pointeur séparé sera passé à la fonction qui pointe vers la valeur de la variable. L’exemple de code suivant nous montre comment passer une variable de type valeur par référence avec le mot clé ref en C#.

using System;

namespace pass_object_by_reference {
  class Program {
    static void method1(ref string value) {
      value = "something";
      Console.WriteLine("New value = {0}", value);
    }

    static void Main(string[] args) {
      string valueType = "Nothing";
      method1(ref valueType);
      Console.WriteLine("Original Value = {0}", valueType);
    }
  }
}

Production:

New value = something Original Value = something

Dans le code ci-dessus, nous avons passé la variable de type valeur valueType par référence à la fonction method1() avec le mot-clé ref en C#. La fonction method1() prend comme argument une référence à la variable valueType et modifie la valeur de la variable valueType en something. Cette fois, la valeur d’origine est modifiée.

Passer des objets par référence à une fonction en C#

Par défaut, toutes les variables de type référence telles que les instances de classe, les instances de struct, etc. sont passées par référence aux fonctions en C#. Ce qui se passe ici, c’est que l’objet d’origine n’est jamais passé en tant que paramètre à une fonction. Une nouvelle référence à l’objet est passée par valeur en tant qu’argument de la fonction. Ainsi, nous finissons par avoir deux copies de pointeurs qui pointent vers le même emplacement mémoire. Si nous modifions la valeur de ce pointeur, la valeur de l’objet d’origine est également modifiée. L’exemple de code suivant nous montre comment passer un objet par référence à une fonction en C#.

using System;

namespace pass_object_by_reference {
  public class Sample {
    public string s { get; set; }
  }
  class Program {
    static void dosomething(Sample obj) {
      obj.s = "something";
    }
    static void Main(string[] args) {
      Sample sam = new Sample();
      sam.s = "Nothing";
      dosomething(sam);
      Console.WriteLine(sam.s);
    }
  }
}

Production:

something

Dans le code ci-dessus, nous avons passé l’objet sam en référence à la fonction dosomething() qui modifie la propriété s à l’intérieur de l’objet sam. Il modifie la valeur de l’objet sam d’origine et affecte quelque chose à la propriété sam.s. Bien que ce soit la manière par défaut de passer des objets par référence, il existe une exception à cette approche. Si nous initialisons l’objet passé avec le mot-clé new et le constructeur de classe, une copie séparée de l’objet est créée à l’intérieur de la mémoire. Toute modification de la valeur de cet objet ne modifie pas l’objet d’origine passé en tant que paramètre. L’exemple de code suivant illustre un scénario dans lequel cet objet est passé par valeur à une fonction en C#.

using System;

namespace pass_object_by_reference {
  public class Sample {
    public string s { get; set; }
  }
  class Program {
    static void dosomething(Sample obj) {
      Console.WriteLine("Initial passed value = {0}", obj.s);
      obj = new Sample();
      obj.s = "something";
      Console.WriteLine("New value = {0}", obj.s);
    }
    static void Main(string[] args) {
      Sample sam = new Sample();
      sam.s = "Nothing";
      dosomething(sam);
      Console.WriteLine("Original Value = {0}", sam.s);
    }
  }
}

Production:

Initial passed value = Nothing New value = something Original Value = Nothing

Nous avons passé l’objet sam par valeur à la fonction dosomething() en C# dans le code ci-dessus. La fonction dosomething() prend l’argument, imprime sa valeur initiale, modifie la valeur et imprime la valeur modifiée. Cette nouvelle valeur est affectée à un nouvel emplacement mémoire et n’est pas accessible par l’objet d’origine sam.