Différence entre les parameters ref et out dans .NET

Quelle est la différence entre out parameters ref et out dans .NET? Quelles sont les situations où l’une peut être plus utile que l’autre? Quel serait un extrait de code où l’un peut être utilisé et un autre non?

Ils sont à peu près les mêmes – la seule différence est qu’une variable que vous passez en tant out paramètre de out n’a pas besoin d’être initialisée mais que le transmettre en tant que paramètre ref doit être défini sur quelque chose.

 int x; Foo(out x); // OK int y; Foo(ref y); // Error: y should be initialized before calling the method 

Ref parameters de Ref sont pour les données qui pourraient être modifiées, out parameters de out sont pour les données qui constituent une sortie supplémentaire pour la fonction (par exemple, int.TryParse ) qui utilise déjà la valeur de retour pour quelque chose.

Pourquoi C # a-t-il à la fois «ref» et «out»?

L’appelant d’une méthode qui prend un paramètre out n’est pas obligé d’affecter à la variable passée en tant que paramètre out avant l’appel; Cependant, l’appelé doit affecter le paramètre out avant de retourner.

En revanche, les parameters ref sont considérés initialement comme étant atsortingbués par l’appelant. En tant que tel, l’appelé n’est pas obligé d’affecter le paramètre ref avant utilisation. Les parameters de référence sont transmis à la fois dans et hors d’une méthode.

Donc, out signifie out, tandis que ref est pour in et out.

Celles-ci correspondent étroitement aux parameters [out] et [in,out] des interfaces COM, les avantages des parameters out étant que les appelants n’ont pas besoin de passer un object pré-alloué dans les cas où la méthode appelée ne l’exige pas. à la fois le coût de l’allocation et tout coût pouvant être associé au marshaling (plus probable avec COM, mais pas rare avec .NET).

ref et out permettent à la méthode appelée de modifier un paramètre. La différence entre eux est ce qui se passe avant de faire l’appel.

  • ref signifie que le paramètre a une valeur avant d’ entrer dans la fonction. La fonction appelée peut lire et / ou modifier la valeur à tout moment. Le paramètre entre, puis sort

  • out signifie que le paramètre n’a aucune valeur officielle avant d’entrer dans la fonction. La fonction appelée doit l’initialiser. Le paramètre ne s’éteint que

Voici ma façon préférée de le regarder: ref est de passer des variables par référence. out est de déclarer une valeur de retour secondaire pour la fonction. C’est comme si vous pouviez écrire ceci:

 // This is not C# public (bool, ssortingng) GetWebThing(ssortingng name, ref Buffer paramBuffer); // This is C# public bool GetWebThing(ssortingng name, ref Buffer paramBuffer, out ssortingng actualUrl); 

Voici une liste plus détaillée des effets de chaque alternative:

Avant d’appeler la méthode:

ref : l’appelant doit définir la valeur du paramètre avant de le transmettre à la méthode appelée.

out : la méthode caller n’est pas requirejse pour définir la valeur de l’argument avant d’appeler la méthode. Très probablement, vous ne devriez pas. En fait, toute valeur actuelle est rejetée.

Pendant l’appel:

ref : La méthode appelée peut lire l’argument à tout moment.

out : La méthode appelée doit initialiser le paramètre avant de le lire.

Appels à distance:

ref : La valeur actuelle est atsortingbuée à l’appel distant. Coût de performance supplémentaire.

out : rien n’est passé à l’appel distant. Plus rapide.

Techniquement parlant, vous pouvez toujours utiliser ref à la place de out , mais out vous permet d’être plus précis sur la signification de l’argument, et parfois cela peut être beaucoup plus efficace.

Exemple pour OUT: la variable obtient la valeur initialisée après son entrée dans la méthode. Plus tard, la même valeur est renvoyée à la méthode principale.

 namespace outreftry { class outref { static void Main(ssortingng[] args) { yyy a = new yyy(); ; // u can try giving int i=100 but is useless as that value is not passed into // the method. Only variable goes into the method and gets changed its // value and comes out. int i; a.abc(out i); System.Console.WriteLine(i); } } class yyy { public void abc(out int i) { i = 10; } } } 

Sortie:

dix

===============================================

Exemple pour Ref: La variable doit être initialisée avant d’entrer dans la méthode. Plus tard, la même valeur ou la même valeur modifiée sera renvoyée à la méthode principale.

 namespace outreftry { class outref { static void Main(ssortingng[] args) { yyy a = new yyy(); ; int i = 0; a.abc(ref i); System.Console.WriteLine(i); } } class yyy { public void abc(ref int i) { System.Console.WriteLine(i); i = 10; } } } 

Sortie:

  0 10 

=================================

J’espère que c’est clair maintenant.

  • Une variable ref doit être initialisée avant de la transmettre.
  • Une variable out doit être définie dans l’implémentation de votre fonction
  • out parameters out peuvent être considérés comme des variables de retour supplémentaires (non entrées)
  • ref parameters ref peuvent être considérés comme des variables d’entrée et de sortie.

Paramètres Ref et Out:

Les parameters out et ref sont utilisés pour renvoyer des valeurs dans la même variable, que vous transmettez en tant qu’argument d’une méthode. Ces deux parameters sont très utiles lorsque votre méthode doit renvoyer plus d’une valeur.

Vous devez affecter la valeur au paramètre out dans le corps de la méthode calee, sinon la méthode ne sera pas compilée.


Paramètre de référence: il doit être initialisé avant de passer à la méthode. Le mot-clé ref sur un paramètre de méthode oblige une méthode à faire référence à la même variable qui a été transmise en tant que paramètre d’entrée pour la même méthode. Si vous apportez des modifications à la variable, elles seront reflétées dans la variable.

 int sampleData = 0; sampleMethod(ref sampleData); 

Ex du paramètre de référence

 public static void Main() { int i = 3; // Variable need to be initialized sampleMethod(ref i ); } public static void sampleMethod(ref int sampleData) { sampleData++; } 

Paramètre Out: Il n’est pas nécessaire d’être initialisé avant de passer à Method. Le paramètre out peut être utilisé pour renvoyer les valeurs de la même variable transmise en tant que paramètre de la méthode. Toute modification apscope au paramètre sera reflétée dans la variable.

  int sampleData; sampleMethod(out sampleData); 

Paramètre Ex de Out

 public static void Main() { int i, j; // Variable need not be initialized sampleMethod(out i, out j); } public static int sampleMethod(out int sampleData1, out int sampleData2) { sampleData1 = 10; sampleData2 = 20; return 0; } 

en dehors:

En C #, une méthode ne peut renvoyer qu’une seule valeur. Si vous souhaitez renvoyer plus d’une valeur, vous pouvez utiliser le mot clé out. Le modificateur de sortie retourne par renvoi. La réponse la plus simple est que le mot-clé «out» est utilisé pour obtenir la valeur de la méthode.

  • Vous n’avez pas besoin d’initialiser la valeur dans la fonction appelante.
  • Vous devez affecter la valeur dans la fonction appelée, sinon le compilateur signalera une erreur.

ref:

En C #, lorsque vous passez un type de valeur tel que int, float, double etc. en tant qu’argument au paramètre method, il est transmis par valeur. Par conséquent, si vous modifiez la valeur du paramètre, cela n’affecte pas l’argument dans l’appel de méthode. Mais si vous marquez le paramètre avec le mot-clé «ref», il sera reflété dans la variable réelle.

  • Vous devez initialiser la variable avant d’appeler la fonction.
  • Il n’est pas obligatoire d’affecter une valeur au paramètre ref dans la méthode. Si vous ne modifiez pas la valeur, quel est le besoin de la marquer comme «ref»?

Les parameters de référence ne doivent pas nécessairement être définis dans la fonction, alors que les parameters de sortie doivent être liés à une valeur avant de quitter la fonction. Les variables passées comme sorties peuvent également être transmises à une fonction sans être initialisées.

out spécifie que le paramètre est un paramètre de sortie, c’est-à-dire qu’il n’a pas de valeur tant qu’il n’est pas explicitement défini par la méthode.

ref spécifie que la valeur est une référence qui a une valeur et dont vous pouvez modifier la valeur dans la méthode.

out parameters out sont initialisés par la méthode appelée, les parameters ref sont initialisés avant d’appeler la méthode. Par conséquent, out parameters out sont utilisés lorsque vous devez simplement obtenir une valeur de retour secondaire, les parameters ref sont utilisés pour obtenir une valeur et renvoyer potentiellement une modification à cette valeur (secondairement à la valeur de retour principale).

Le mot-clé ref est utilisé pour transmettre des valeurs par référence. (Cela n’exclut pas que les valeurs passées soient des types de valeur ou des types de référence). Les parameters de sortie spécifiés avec le mot-clé out servent à renvoyer les valeurs d’une méthode.

Une différence clé dans le code est que vous devez définir la valeur d’un paramètre de sortie dans la méthode. Ce n’est pas le cas pour les parameters ref.

Pour plus de détails, consultez http://www.blackwasp.co.uk/CSharpMethodParameters.aspx

Un paramètre out est un paramètre ref avec un atsortingbut spécial Out() ajouté. Si un paramètre pour une méthode C # est déclaré comme étant out , le compilateur exigera que le paramètre soit écrit avant de pouvoir être lu et avant que la méthode ne puisse être renvoyée. Si C # appelle une méthode dont le paramètre inclut un atsortingbut Out() , le compilateur va, pour décider de signaler les erreurs de “variable indéfinie”, prétendre que la variable est écrite immédiatement avant d’appeler la méthode. Notez que, comme les autres langages .net n’attachent pas la même signification à l’atsortingbut Out() , il est possible que l’appel d’une routine avec un paramètre out laisse la variable en question inchangée. Si une variable est utilisée comme paramètre out avant d’être définitivement atsortingbuée, le compilateur C # générera du code pour s’assurer qu’il sera effacé à un moment donné avant son utilisation, mais si une telle variable quitte et rentre dans le champ d’application, il n’y a aucune garantie qu’il sera effacé à nouveau.

ref va probablement s’étouffer sur null car il s’attend probablement à modifier un object existant. out attend null, puisqu’il renvoie un nouvel object.

out et ref sont exactement les mêmes sauf que les variables out ne doivent pas être initialisées avant de les envoyer dans les abysses. Je ne suis pas si intelligent que ça, j’ai écrit ça depuis la bibliothèque MSDN :).

Pour être plus explicite quant à leur utilisation, la signification du modificateur est que si vous modifiez la référence de cette variable dans votre code, out et ref feront également en sorte que votre variable d’appel change de référence. Dans le code ci-dessous, la variable ceo sera une référence au newGuy une fois qu’elle sera renvoyée de l’appel à doStuff. Si ce n’était pour ref (ou out), la référence ne serait pas modifiée.

 private void newEmployee() { Person ceo = Person.FindCEO(); doStuff(ref ceo); } private void doStuff(ref Person employee) { Person newGuy = new Person(); employee = newGuy; } 

Ce parametre out et ref en C # a de bons exemples.

La différence fondamentale décrite est que out parameters out n’ont pas besoin d’être initialisés lorsqu’ils sont transmis, alors que les parameters ref le font.

Lorsqu’un paramètre out est déclaré dans la déclaration de méthode, le corps de la méthode doit atsortingbuer une valeur à la variable out avant de retourner. Il est donc de la responsabilité de la méthode appelée d’atsortingbuer la valeur au paramètre out avant son retour.

Lorsqu’un paramètre ref est déclaré dans la méthode, l’argument transmis lors de l’appel de la méthode doit avoir été atsortingbué à la valeur. Il est donc de la responsabilité de l’appelant d’atsortingbuer la valeur de l’argument ref avant d’appeler la méthode.

Ils sont subtilement différents.

Un paramètre out n’a pas besoin d’être initialisé par l’appelé avant d’être transmis à la méthode. Par conséquent, toute méthode avec un paramètre out

  • Impossible de lire le paramètre avant de lui atsortingbuer une valeur
  • Doit lui assigner une valeur avant de retourner

Ceci est utilisé pour une méthode qui doit remplacer son argument indépendamment de sa valeur précédente.


Un paramètre ref doit être initialisé par l’appelé avant de le transmettre à la méthode. Par conséquent, toute méthode avec un paramètre ref

  • Peut inspecter la valeur avant de l’assigner
  • Peut retourner la valeur d’origine, intacte

Ceci est utilisé pour une méthode qui doit (par exemple) inspecter sa valeur et la valider ou la normaliser.

out a obtenu une nouvelle syntaxe plus succincte dans C # 7 https://docs.microsoft.com/en-us/dotnet/articles/csharp/whats-new/csharp-7#more-expression-bodied-members et bien plus encore Les améliorations du tuple en C # 7 sont un choix plus élégant que l’utilisation de réf et d’IMHO.