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:
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.
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.
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.
ref
doit être initialisée avant de la transmettre. 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. 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 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.
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.
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
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
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.