web-dev-qa-db-fra.com

Différence entre les paramètres ref et out dans .NET

Quelle est la différence entre les paramètres ref et out dans .NET? Quelles sont les situations où l’un peut être plus utile que l’autre? Qu'est-ce qu'un extrait de code où l'un peut être utilisé et l'autre pas?

c#.net
398
ashwnacharya

Ils sont à peu près les mêmes - la seule différence est qu’une variable que vous transmettez en tant que paramètre out n’a pas besoin d’être initialisée, mais qu’elle passe en tant que paramètre ref et doit être définie sur .

int x;
Foo(out x); // OK

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

Les paramètres Ref concernent les données susceptibles d'être modifiées. Les paramètres out correspondent à des données qui constituent une sortie supplémentaire pour la fonction (par exemple, int.TryParse) et qui utilisent déjà la valeur renvoyée.

490
Khoth

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 transmise comme paramètre out avant l'appel; Toutefois, l'appelé doit attribuer le paramètre out avant de revenir.

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

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

Ceux-ci correspondent étroitement aux paramètres [out] et [in,out] des interfaces COM, les avantages des paramètres out étant que les appelants n'ont pas besoin de passer un objet pré-alloué dans les cas où il n'est pas nécessaire par la méthode appelée - Cela évite à la fois le coût de l'allocation et tout coût pouvant être associé au marshaling (plus probablement avec COM, mais pas rare dans .NET).

128
Derek Park

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 passer l’appel.

  • ref signifie que le paramètre a une valeur avant entrant 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 pas de valeur officielle avant d'entrer dans la fonction. La fonction appelée doit l'initialiser. Le paramètre ne sort que

Voici ma façon préférée de regarder les choses: ref est de passer des variables par référence. out consiste à déclarer un secondaire valeur renvoyée pour la fonction. C'est comme si tu pouvais écrire ceci:

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

// This is C#
public bool GetWebThing(string name, ref Buffer paramBuffer, out string 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 appelante n'est pas obligée de 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 ignoré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 distants:

ref: la valeur actuelle est transmise à l'appel distant. Coût de performance supplémentaire.

out: Rien n'est transmis à l'appel distant. Plus rapide.

Techniquement, vous pouvez toujours utiliser ref à la place de out, mais out vous permet d'être plus précis sur le sens de l'argument, ce qui peut parfois être beaucoup plus efficace.

82
Euro Micelli

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

namespace outreftry
{
    class outref
    {
        static void Main(string[] 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 valeur modifiée sera renvoyée à la méthode principale.

namespace outreftry
{
    class outref
    {
        static void Main(string[] 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.

16
kavta
  • 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
  • Les paramètres out peuvent être considérés comme des variables de retour supplémentaires (non entrées)
  • Les paramètres ref peuvent être considérés comme des variables d'entrée et de sortie.
9
Brian R. Bondy

Paramètres Ref et Out:

Les paramètres 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 paramètres sont très utiles lorsque votre méthode doit renvoyer plusieurs valeurs.

Vous devez affecter une 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 d'un paramètre de méthode fait qu'une méthode se réfère à 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);

Paramètre Ex 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 apportée au paramètre sera reflétée dans la variable.

 int sampleData; 
 sampleMethod(out sampleData);

paramètre Ex of 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; 
}
9
Krishna Thota

en dehors:

En C #, une méthode ne peut renvoyer qu'une seule valeur. Si vous souhaitez renvoyer plusieurs valeurs, vous pouvez utiliser le mot clé out. Le modificateur out retourne comme retour par référence. 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. comme argument du paramètre de méthode, il est passé par valeur. Par conséquent, si vous modifiez la valeur du paramètre, cela n'affectera pas l'argument dans l'appel de la 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’attribuer une valeur au paramètre ref dans la méthode. Si vous ne changez pas la valeur, quelle est la nécessité de la marquer comme "ref"?
7
Nazmul Hasan

out spécifie que le paramètre est un paramètre de sortie, c'est-à-dire qu'il n'a aucune valeur jusqu'à ce qu'il soit explicitement défini par la méthode.

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

4
Alan

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

4
Patrick

Les paramètres out sont initialisés par la méthode appelée. Les paramètres ref sont initialisés avant l'appel de la méthode. Par conséquent, les paramètres out sont utilisés lorsque vous devez simplement obtenir une valeur de retour secondaire. Les paramètres ref sont utilisés pour obtenir une valeur et retournent potentiellement une modification de cette valeur à la valeur de retour principale).

1
bdukes

Le mot-clé ref est utilisé pour transmettre des valeurs par référence. (Cela n'empêche pas que les valeurs transmises soient des types valeur ou des types référence). Les paramètres 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 paramètres de référence.

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

1
BlackWasp

Un paramètre out est un paramètre ref auquel un attribut spécial Out() a été ajouté. Si un paramètre d'une méthode C # est déclaré comme out, le compilateur exige 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 attribut Out(), le compilateur va, pour décider si des erreurs de "variable non définie" doivent être signalées, prétendre que la variable est écrite immédiatement avant d'appeler la méthode. Notez que, dans la mesure où d'autres langages .net n'attachent pas la même signification à l'attribut Out(), il est possible que l'appel d'une routine avec un paramètre out laisse la variable en question non affectée. Si une variable est utilisée en tant que paramètre out avant d'être définitivement affectée, le compilateur C # générera du code afin de s'assurer qu'il sera effacé à un moment donné avant son utilisation, mais si une telle variable quitte et revient dans la portée , il n'y a aucune garantie qu'il sera effacé à nouveau.

1
supercat

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

Lorsqu'un paramètre de référence est déclaré dans la méthode, l'argument transmis lors de l'appel de la méthode doit avoir affecté la valeur. Il incombe donc à l'appelant d'attribuer la valeur de l'argument ref avant d'appeler la méthode.

0
Ranganatha

out a obtenu une nouvelle syntaxe plus succinte en C # 7 https://docs.Microsoft.com/en-us/dotnet/articles/csharp/whats-new/csharp-7#more-expression-bodied- membres et encore plus excitantes sont les améliorations du C # 7 Tuple qui sont un choix plus élégant que l’utilisation de ref and out IMHO.

0
Marc Ziss

ref va probablement s'étouffer avec null car il s'attend vraisemblablement à modifier un objet existant. out attend null, puisqu'il renvoie un nouvel objet.

0
Joel Coehoorn

This Les paramètres out et ref en C # a de bons exemples.

La différence fondamentale décrite est que les paramètres out n'ont pas besoin d'être initialisés lorsqu'ils sont passés, contrairement aux paramètres ref.

0
casademora

out et ref sont exactement les mêmes, sauf que les variables out ne doivent pas être initialisées avant de les envoyer dans l'abysse. Je ne suis pas si malin que ça, je l'ai écrit dans la bibliothèque MSDN :).

Pour être plus explicite quant à leur utilisation, toutefois, le modificateur signifie que si vous modifiez la référence de cette variable dans votre code, out et ref feront en sorte que votre variable appelante change également de référence. Dans le code ci-dessous, la variable ceo fera référence à newGuy une fois renvoyée à l'appel de doStuff. Si ce n'était pas pour ref (ou out), la référence ne serait pas changée.

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

private void doStuff(ref Person employee)
{
    Person newGuy = new Person();
    employee = newGuy;
}
0
Jacob Proffitt

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 affecter une valeur
  • Doit lui attribuer une valeur avant de retourner

Ceci est utilisé pour une méthode qui doit écraser son argument, quelle que soit 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 renvoyer 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.

0
jpaugh