Quelle est l'utilisation des mots-clés ref, out et in en C# ?

En C#, la plupart des méthodes peuvent avoir zéro ou plusieurs paramètres, qui définissent les données qui doivent être fournies à la méthode. Tout code qui appelle une méthode doit transmettre des données (appelées paramètres) à la méthode. Une méthode déclare ses entrées en tant que paramètres, et elles sont fournies en tant que paramètres par le code appelant.

Par exemple, considérons la méthode suivante et les appels de méthode suivants.

static void Greet(string greeting){
   Console.WriteLine(greeting);
}
...
Greet("Hello");

Dans l'exemple ci-dessus, Greeting est le paramètre de la méthode Greet() et "Hello" est le paramètre passé à la méthode.

Lorsque vous appelez une méthode et transmettez des arguments, ils sont transmis par valeur, ce qui signifie qu'une copie de la valeur est créée lorsqu'elle est transmise à la méthode. Toute modification apportée aux paramètres à l'intérieur de la méthode n'est pas répercutée sur les variables d'origine.

using System;
int number = 8;
Increase(number);
Console.WriteLine(number); // prints 8
static void Increase(int num){
   num = num + 1;
   Console.WriteLine(num); // prints 9
}

Lorsque vous transmettez une variable de type référence (comme un objet), C# copie toujours la référence par valeur car la variable contient la référence, pas l'objet réel. Ainsi, même si vous transmettez une copie de la variable de référence, elles font toutes référence au même objet en mémoire. Par conséquent, toutes les modifications apportées à l’objet par les variables à l’intérieur de la méthode sont visibles par les variables en dehors de la méthode.

using System;
var john = new User{
   Name = "John",
   Salary = 50000
};
Promote(john);
Console.WriteLine(john.Salary); // prints 60000
static void Promote(User u){
   u.Salary += 10000;
   Console.WriteLine(u.Salary); // prints 60000
}

Cependant, si vous modifiez la valeur de la variable elle-même à l'intérieur de la méthode, le changement ne sera pas reflété en dehors de la méthode car seule la copie est modifiée, pas l'objet réel. Par exemple, nous pouvons attribuer la valeur null à un paramètre dans une méthode et la variable réelle restera inchangée.

using System;
var john = new User{
   Name = "John",
   Salary = 50000
};
Promote(john);
Console.WriteLine(john.Salary); // prints 50000
static void Promote(User u){
   u = null;
}

C# permet l'utilisation de trois mots-clés modificateurs différents pour contrôler les paramètres d'une méthode.

ref modifier

C# vous permet de passer des paramètres par référence à l'aide du refmodifier. Peu importe que la variable transmise soit un type référence ou un type valeur. Les paramètres et les arguments feront référence au même emplacement mémoire.

Dans l'exemple ci-dessous, définir le paramètre u sur null rendra également la variable john nulle, générant ainsi une exception de référence nulle.

Exemple

using System;
var john = new User{
   Name = "John",
   Salary = 50000
};
Promote(ref john);
Console.WriteLine(john.Salary); // throws System.NullReferenceException
static void Promote(ref User u){
   u = null;
}

Les paramètres transmis à l'aide du modificateur ref doivent être initialisés avant de passer.

out modificateur

Il est similaire au modificateur ref, sauf :

• Les paramètres n'ont pas besoin d'être initialisés avant d'entrer dans la fonction

• Les paramètres doivent être initialisés (attribués) avant de sortir de la fonction

Dans l'exemple suivant, la fonction Hire initialise un nouvel objet utilisateur qui lui est transmis via le modificateur out. Notez que la variable john est déclarée à la volée lors de l'appel de la méthode Hire.

using System;
Hire(out User john);
Console.WriteLine(john.Salary); // prints 50000
static void Hire(out User u){
   u = new User{
      Name = "John",
      Salary = 50000
   };
}

Comme le modificateur ref, les variables marquées par le modificateur out sont passées par référence.

Habituellement, les variables out > sont utilisées pour obtenir plusieurs valeurs de retour d'une fonction comme celle-ci -

using System;
var john = new User{
   Name = "John",
   Salary = 50000
};
bool shouldPromote = Raise(john.Salary, out double hike);
Console.WriteLine(shouldPromote); // True
Console.WriteLine($"Hike Amount = {hike}"); // prints 5000
static bool Raise(int salary, out double hike){
   hike = salary * 0.1;
   return hike < 7000;
}

in modificateur

Il est similaire aux paramètres ref et out, mais la différence est qu'il accepte in paramètres La méthode ne peut pas modifier la valeur de ce paramètre. Si une modification est tentée, le compilateur C# générera une erreur de compilation.

in Les paramètres peuvent éviter de copier la mémoire de types de valeurs élevées dans des variables de paramètres tout en empêchant l'objet d'être accidentellement modifié. Ceci est utile lors du passage de types de valeurs élevées aux méthodes.

var point = new Coord();
Verify(point);
static void Verify(in Coord c){
   // error: Cannot assign to variable 'in Coord' because it is a readonly variable
   c = new Coord();
}
struct Coord{
   public int X;
   public int Y;
}

Exemple

Démonstration en temps réel

using System;
class Program{
   static void Main(){
      int number = 8;
      Increase(number);
      Console.WriteLine(number); // prints 8
      var john = new User { Name = "John", Salary = 50000 };
      Promote(john);
      Console.WriteLine(john.Salary); // prints 60000
      Leave(john);
      Console.WriteLine(john.Salary); // prints 60000

      LeaveByRef(ref john);
      Console.WriteLine(john?.Salary); // prints nothing

      User dave;
      Hire(out dave);
      Console.WriteLine(dave.Salary); // prints 50000
   }
   static void Increase(int num){
      num = num + 1;
      Console.WriteLine(num); // prints 9
   }
   static void Promote(User u){
      u.Salary += 10000;
      Console.WriteLine(u.Salary); // prints 60000
   }
   static void Leave(User u){
      u = null;
   }
   static void LeaveByRef(ref User u){
      u = null;
   }
   static void Hire(out User u){
      u = new User{
         Name = "John",
         Salary = 50000
      };  
   }
}
class User{
   public string Name { get; set; }
   public int Salary { get; set; }
}

Sortie

9
8
60000
60000
60000
50000

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!