Quand l'utiliser dans vs vs ref vs out

Quelqu'un m'a demandé l'autre jour quand ils devraient utiliser le mot-clé paramètre outau lieu de ref. Alors que je (je pense) comprendre la différence entre les mots clés refet out(qui a été demandé auparavant ) et la meilleure explication semble être que ref== inet out, quels sont certains exemples (hypothétiques ou codés) où je devrais toujours utiliser outet non ref.

Depuis refest plus général, pourquoi voulez-vous jamais utiliser out? Est-ce juste du sucre syntaxique?

Vous devez utiliser outsauf si vous en avez besoin ref.

Cela fait une grande différence lorsque les données doivent être rassemblées, par exemple vers un autre processus, ce qui peut être coûteux. Vous devez donc éviter de rassembler la valeur initiale lorsque la méthode ne l'utilise pas.

Au-delà de cela, il montre également au lecteur de la déclaration ou de l'appel si la valeur initiale est pertinente (et potentiellement préservée), ou jetée.

À titre de différence mineure, un paramètre de sortie n'a pas besoin d'être initialisé.

Exemple pour out:

string a, b;
person.GetBothNames(out a, out b);

où GetBothNames est une méthode pour récupérer deux valeurs atomiquement, la méthode ne changera pas le comportement quels que soient a et b. Si l'appel est dirigé vers un serveur à Hawaï, la copie des valeurs initiales d'ici à Hawaï est une perte de bande passante. Un extrait similaire utilisant ref:

string a = String.Empty, b = String.Empty;
person.GetBothNames(ref a, ref b);

pourrait confondre les lecteurs, car il semble que les valeurs initiales de a et b soient pertinentes (bien que le nom de la méthode indique qu'elles ne le sont pas).

Exemple pour ref:

string name = textbox.Text;
bool didModify = validator.SuggestValidName(ref name);

Ici, la valeur initiale est pertinente pour la méthode.

Utilisez out pour indiquer que le paramètre n'est pas utilisé, uniquement défini. Cela aide l'appelant à comprendre que vous initialisez toujours le paramètre.

De plus, ref et out ne sont pas seulement pour les types de valeur. Ils vous permettent également de réinitialiser l'objet auquel un type de référence fait référence dans une méthode.

Vous avez raison en ce sens que, sémantiquement, reffournit à la fois la fonctionnalité «in» et «out», alors outque la fonctionnalité «out» uniquement. Il y a certaines choses à considérer:

1. outrequiert que la méthode acceptant le paramètre DOIT, à un moment donné avant de retourner, affecter une valeur à la variable. Vous trouvez ce modèle dans certaines des classes de stockage de données clé / valeur comme Dictionary<K,V>, où vous avez des fonctions comme TryGetValue. Cette fonction prend un outparamètre qui contient ce que sera la valeur si elle est récupérée. Il ne serait pas logique que l'appelant passe une valeur dans cette fonction, il outest donc utilisé pour garantir qu'une certaine valeur sera dans la variable après l'appel, même s'il ne s'agit pas de données "réelles" (dans le cas TryGetValueoù la clé n'est pas présente).
2. outet les refparamètres sont marshalés différemment lorsqu'il s'agit de code d'interopérabilité

De plus, en passant, il est important de noter que, bien que les types de référence et les types de valeur diffèrent par la nature de leur valeur, chaque variable de votre application pointe vers un emplacement de mémoire contenant une valeur , même pour les types de référence. Il se trouve que, avec les types de référence, la valeur contenue dans cet emplacement de mémoire est une autreemplacement de la mémoire. Lorsque vous transmettez des valeurs à une fonction (ou effectuez toute autre affectation de variable), la valeur de cette variable est copiée dans l'autre variable. Pour les types de valeur, cela signifie que tout le contenu du type est copié. Pour les types de référence, cela signifie que l'emplacement mémoire est copié. Quoi qu'il en soit, il crée une copie des données contenues dans la variable. La seule réelle pertinence que cela tient concerne la sémantique d'affectation; lors de l'affectation d'une variable ou du passage par valeur (valeur par défaut), lorsqu'une nouvelle affectation est faite à la variable d'origine (ou nouvelle), elle n'affecte pas l'autre variable. Dans le cas des types de référence, oui, les modifications apportées au instancesont disponibles des deux côtés, mais c'est parce que la variable réelle n'est qu'un pointeur vers un autre emplacement mémoire; le contenu de la variable - l'emplacement de la mémoire - n'a pas réellement changé.

Passer avec le refmot - clé indique que la variable d'origine et le paramètre de fonction pointeront en fait vers le même emplacement de mémoire. Encore une fois, cela n'affecte que la sémantique des affectations. Si une nouvelle valeur est affectée à l'une des variables, alors parce que l'autre pointe vers le même emplacement de mémoire, la nouvelle valeur sera reflétée de l'autre côté.

Cela dépend du contexte de compilation (voir l'exemple ci-dessous).

outet les refdeux indiquent une variable passant par référence, mais refnécessitent que la variable soit initialisée avant d'être transmise, ce qui peut être une différence importante dans le contexte de Marshaling (Interop: UmanagedToManagedTransition ou vice versa)

MSDN avertit :

Ne confondez pas le concept de passage par référence avec le concept de types de référence. Les deux concepts ne sont pas identiques. Un paramètre de méthode peut être modifié par ref, qu'il s'agisse d'un type de valeur ou d'un type de référence. Il n'y a pas de boxe d'un type valeur lorsqu'elle est passée par référence.

Depuis les documents MSDN officiels:

• out:

Le mot clé out entraîne la transmission des arguments par référence. Ceci est similaire au mot clé ref, sauf que ref nécessite que la variable soit initialisée avant d'être passée

• ref:

Le mot clé ref fait passer un argument par référence, pas par valeur. L'effet du passage par référence est que toute modification du paramètre dans la méthode est reflétée dans la variable d'argument sous-jacente dans la méthode appelante. La valeur d'un paramètre de référence est toujours la même que la valeur de la variable d'argument sous-jacente.

On peut vérifier que out et ref sont bien les mêmes quand l'argument est assigné:

Exemple CIL :

Considérez l'exemple suivant

static class outRefTest{
    public static int myfunc(int x){x=0; return x; }
    public static void myfuncOut(out int x){x=0;}
    public static void myfuncRef(ref int x){x=0;}
    public static void myfuncRefEmpty(ref int x){}
    // Define other methods and classes here
}

en CIL, les instructions de myfuncOutet myfuncRefsont identiques à celles attendues.

outRefTest.myfunc:
IL_0000:  nop         
IL_0001:  ldc.i4.0    
IL_0002:  starg.s     00 
IL_0004:  ldarg.0     
IL_0005:  stloc.0     
IL_0006:  br.s        IL_0008
IL_0008:  ldloc.0     
IL_0009:  ret         

outRefTest.myfuncOut:
IL_0000:  nop         
IL_0001:  ldarg.0     
IL_0002:  ldc.i4.0    
IL_0003:  stind.i4    
IL_0004:  ret         

outRefTest.myfuncRef:
IL_0000:  nop         
IL_0001:  ldarg.0     
IL_0002:  ldc.i4.0    
IL_0003:  stind.i4    
IL_0004:  ret         

outRefTest.myfuncRefEmpty:
IL_0000:  nop         
IL_0001:  ret         

nop : aucune opération, ldloc : charge locale, stloc : pile locale, ldarg : argument de charge, bs.s : branche vers la cible ....

(Voir: Liste des instructions CIL )

Voici quelques notes que j'ai tirées de cet article de projet de code sur C # Out Vs Ref

1. Il ne doit être utilisé que lorsque nous attendons plusieurs sorties d'une fonction ou d'une méthode. Une réflexion sur les structures peut également être une bonne option pour la même chose.
2. REF et OUT sont des mots clés qui dictent la façon dont les données sont transmises de l'appelant à l'appelé et vice versa.
3. Dans REF, les données passent dans les deux sens. De l'appelant à l'appelé et vice-versa.
4. Les données In Out passent dans un seul sens de l'appelé à l'appelant. Dans ce cas, si l'appelant a tenté d'envoyer des données à l'appelé, elles seront ignorées / rejetées.

Si vous êtes une personne visuelle, veuillez voir cette vidéo de votre tube qui montre la différence pratiquement https://www.youtube.com/watch?v=lYdcY5zulXA

L'image ci-dessous montre les différences plus visuellement

Vous devez utiliser refsi vous prévoyez de lire et d'écrire sur le paramètre. Vous devez utiliser outsi vous prévoyez seulement d'écrire. En effet, outc'est lorsque vous avez besoin de plus d'une valeur de retour, ou lorsque vous ne voulez pas utiliser le mécanisme de retour normal pour la sortie (mais cela devrait être rare).

Il existe des mécanismes de langage qui aident ces cas d'utilisation. Refles paramètres doivent avoir été initialisés avant d'être passés à une méthode (en mettant l'accent sur le fait qu'ils sont en lecture-écriture), et les outparamètres ne peuvent pas être lus avant qu'une valeur leur soit affectée, et il est garanti qu'ils ont été écrits à la fin de la méthode (en mettant l'accent sur le fait qu'ils sont uniquement en écriture). Contrevenir à ces principes entraîne une erreur de compilation.

int x;
Foo(ref x); // error: x is uninitialized

void Bar(out int x) {}  // error: x was not written to

Par exemple, int.TryParseretourne a boolet accepte un out intparamètre:

int value;
if (int.TryParse(numericString, out value))
{
    /* numericString was parsed into value, now do stuff */
}
else
{
    /* numericString couldn't be parsed */
}

Ceci est un exemple clair d'une situation où vous devez sortir deux valeurs: le résultat numérique et si la conversion a réussi ou non. Les auteurs du CLR ont décidé d'opter outici, car ils ne se soucient pas de ce qui intaurait pu être avant.

Pour ref, vous pouvez regarder Interlocked.Increment:

int x = 4;
Interlocked.Increment(ref x);

Interlocked.Incrementincrémente atomiquement la valeur de x. Puisque vous devez lire xpour l'incrémenter, c'est une situation où cela refest plus approprié. Vous vous souciez totalement de ce qui xétait avant sa transmission Increment.

Dans la prochaine version de C #, il sera même possible de déclarer des variables dans les outparamètres, en mettant encore plus l'accent sur leur nature de sortie uniquement:

if (int.TryParse(numericString, out int value))
{
    // 'value' exists and was declared in the `if` statement
}
else
{
    // conversion didn't work, 'value' doesn't exist here
}

outest une version plus contrainte de ref.

Dans un corps de méthode, vous devez affecter à tous les outparamètres avant de quitter la méthode. De même, les valeurs affectées à un outparamètre sont ignorées, alors refqu'elles doivent être affectées.

outVous permet donc de faire:

int a, b, c = foo(out a, out b);

où refil faudrait affecter a et b.

Comment ça sonne:

out = seulement initialiser / remplir un paramètre (le paramètre doit être vide) le renvoyer en clair

ref = référence, paramètre standard (peut-être avec valeur), mais la fonction peut le modifier.

Vous pouvez utiliser le out mot clé contextuel dans deux contextes (chacun est un lien vers des informations détaillées), comme modificateur de paramètre ou dans des déclarations de paramètres de type générique dans les interfaces et les délégués. Cette rubrique décrit le modificateur de paramètre, mais vous pouvez consulter cette autre rubrique pour plus d'informations sur les déclarations de paramètres de type générique.

Le outmot-clé fait passer les arguments par référence. C'est comme le refmot - clé, sauf que cela refnécessite que la variable soit initialisée avant d'être passée. Pour utiliser un outparamètre, la définition de la méthode et la méthode appelante doivent utiliser explicitement le outmot clé. Par exemple: C #

class OutExample
{
    static void Method(out int i)
    {
        i = 44;
    }
    static void Main()
    {
        int value;
        Method(out value);
        // value is now 44
    }
}

Bien qu'il outne soit pas nécessaire d'initialiser les variables transmises en tant qu'arguments avant de les transmettre, la méthode appelée doit affecter une valeur avant le retour de la méthode.

Bien que les mots clés refet outprovoquent des comportements d'exécution différents, ils ne sont pas considérés comme faisant partie de la signature de la méthode au moment de la compilation. Par conséquent, les méthodes ne peuvent pas être surchargées si la seule différence est qu'une méthode prend un refargument et que l'autre prend un outargument. Le code suivant, par exemple, ne compilera pas: C #

class CS0663_Example
{
    // Compiler error CS0663: "Cannot define overloaded 
    // methods that differ only on ref and out".
    public void SampleMethod(out int i) { }
    public void SampleMethod(ref int i) { }
}

La surcharge peut être effectuée, cependant, si une méthode prend un argument refor outet que l'autre n'utilise ni l'un ni l'autre, comme ceci: C #

class OutOverloadExample
{
    public void SampleMethod(int i) { }
    public void SampleMethod(out int i) { i = 5; }
}

Les propriétés ne sont pas des variables et ne peuvent donc pas être passées en tant que outparamètres.

Pour plus d'informations sur le passage de tableaux, consultez Passage de tableaux à l'aide de refet out(Guide de programmation C #).

Vous ne pouvez pas utiliser les mots clés refet outpour les types de méthodes suivants:

Async methods, which you define by using the async modifier.

Iterator methods, which include a yield return or yield break statement.

Exemple

La déclaration d'une outméthode est utile lorsque vous souhaitez qu'une méthode renvoie plusieurs valeurs. L'exemple suivant utilise outpour renvoyer trois variables avec un seul appel de méthode. Notez que le troisième argument est affecté à null. Cela permet aux méthodes de renvoyer des valeurs en option. C #

class OutReturnExample
{
    static void Method(out int i, out string s1, out string s2)
    {
        i = 44;
        s1 = "I've been returned";
        s2 = null;
    }
    static void Main()
    {
        int value;
        string str1, str2;
        Method(out value, out str1, out str2);
        // value is now 44
        // str1 is now "I've been returned"
        // str2 is (still) null;
    }
}

Comment utiliser inou outou refen C #?

• Tous les mots clés dans C#ont la même fonctionnalité mais avec certaines limites .
• in les arguments ne peuvent pas être modifiés par la méthode appelée.
• ref les arguments peuvent être modifiés.
• ref doit être initialisé avant d'être utilisé par l'appelant, il peut être lu et mis à jour dans la méthode.
• out les arguments doivent être modifiés par l'appelant.
• out les arguments doivent être initialisés dans la méthode
• Les variables passées comme inarguments doivent être initialisées avant d'être passées dans un appel de méthode. Cependant, la méthode appelée ne peut pas affecter une valeur ou modifier l'argument.

Vous ne pouvez pas utiliser les in, refet les outmots clés pour les types de méthodes suivantes:

• Méthodes asynchrones , que vous définissez à l'aide du asyncmodificateur.
• Méthodes d'itérateur , qui incluent une instruction yield returnor yield break.

Juste pour clarifier le commentaire de OP que l'utilisation sur ref et out est une "référence à un type de valeur ou une structure déclarée en dehors de la méthode", qui a déjà été établie de manière incorrecte.

Considérez l'utilisation de ref sur un StringBuilder, qui est un type de référence:

private void Nullify(StringBuilder sb, string message)
{
    sb.Append(message);
    sb = null;
}

// -- snip --

StringBuilder sb = new StringBuilder();
string message = "Hi Guy";
Nullify(sb, message);
System.Console.WriteLine(sb.ToString());

// Output
// Hi Guy

Comme apposé à cela:

private void Nullify(ref StringBuilder sb, string message)
{
    sb.Append(message);
    sb = null;
}

// -- snip --

StringBuilder sb = new StringBuilder();
string message = "Hi Guy";
Nullify(ref sb, message);
System.Console.WriteLine(sb.ToString());

// Output
// NullReferenceException

Un argument passé en tant que ref doit être initialisé avant de passer à la méthode tandis que le paramètre out n'a pas besoin d'être initialisé avant de passer à une méthode.

pourquoi voulez-vous jamais utiliser?

Faire savoir aux autres que la variable sera initialisée lorsqu'elle reviendra de la méthode appelée!

Comme mentionné ci-dessus: "pour un paramètre out, la méthode appelante doit affecter une valeur avant le retour de la méthode ."

exemple:

Car car;
SetUpCar(out car);
car.drive();  // You know car is initialized.

Fondamentalement, les deux refetout pour passer objet / valeur entre les méthodes

Le mot clé out entraîne la transmission des arguments par référence. C'est comme le mot-clé ref, sauf que ref nécessite que la variable soit initialisée avant d'être transmise.

out : L'argument n'est pas initialisé et doit être initialisé dans la méthode

ref : L'argument est déjà initialisé et peut être lu et mis à jour dans la méthode.

À quoi sert «ref» pour les types de référence?

Vous pouvez remplacer la référence donnée par une autre instance.

Le saviez-vous?

1. Bien que les mots clés ref et out provoquent des comportements d'exécution différents, ils ne sont pas considérés comme faisant partie de la signature de la méthode au moment de la compilation. Par conséquent, les méthodes ne peuvent pas être surchargées si la seule différence est qu'une méthode prend un argument ref et que l'autre prend un argument out.

2. Vous ne pouvez pas utiliser les mots clés ref et out pour les types de méthodes suivants:

   • Méthodes asynchrones, que vous définissez à l'aide du modificateur asynchrone.
   • Méthodes d'itérateur, qui incluent une déclaration de rendement ou de rupture de rendement.

3. Les propriétés ne sont pas des variables et ne peuvent donc pas être passées en tant que paramètres de sortie.

Notes supplémentaires concernant C # 7:
En C # 7, il n'est pas nécessaire de prédéclarer les variables en utilisant out. Donc, un code comme celui-ci:

public void PrintCoordinates(Point p)
{
  int x, y; // have to "predeclare"
  p.GetCoordinates(out x, out y);
  WriteLine($"({x}, {y})");
}

Peut être écrit comme ceci:

public void PrintCoordinates(Point p)
{
  p.GetCoordinates(out int x, out int y);
  WriteLine($"({x}, {y})");
}

Source: Quoi de neuf dans C # 7.

Je ressens toujours le besoin d'un bon résumé, c'est ce que j'ai trouvé.

Sommaire,

Lorsque nous sommes à l'intérieur de la fonction , voici comment nous spécifions le contrôle d'accès aux données variables ,

in = R

out = doit W avant R

ref = R + W

Explication,

in

La fonction ne peut LIRE que cette variable.

out

La variable ne doit pas être initialisée en premier car la
fonction DOIT y ÉCRIRE avant de LIRE .

ref

La fonction peut LIRE / ECRIRE dans cette variable.

Pourquoi est-il nommé ainsi?

Se concentrer sur l'endroit où les données sont modifiées,

in

Les données doivent uniquement être définies avant d'entrer dans la fonction (in).

out

Les données doivent uniquement être définies avant de quitter la fonction (out).

ref

Les données doivent être définies avant d'entrer dans la fonction (in).
Les données peuvent être définies avant de quitter la fonction (out).

Il convient de noter qu'il ins'agit d'un mot clé valide à partir de C # ver 7.2 :

Le modificateur in parameter est disponible dans C # 7.2 et versions ultérieures. Les versions précédentes génèrent l'erreur de compilateur CS8107 («La fonction« références en lecture seule »n'est pas disponible dans C # 7.0. Veuillez utiliser la version linguistique 7.2 ou supérieure.») Pour configurer la version du langage du compilateur, voir Sélectionner la version du langage C #.

...

Le mot clé in fait passer les arguments par référence. Il fait du paramètre formel un alias pour l'argument, qui doit être une variable. En d'autres termes, toute opération sur le paramètre est effectuée sur l'argument. C'est comme les mots clés ref ou out, sauf que les arguments in ne peuvent pas être modifiés par la méthode appelée. Alors que les arguments ref peuvent être modifiés, les arguments out doivent être modifiés par la méthode appelée, et ces modifications sont observables dans le contexte appelant.