Qu'est ce que diff entre Ref et Out?

Question

Possible en double:
Whats the difference between the 'ref' and 'out' keywords?

Quelle est la différence entre ref et out? Je suis confus au sujet de quand utiliser ref et out. Alors s'il vous plaît expliquer comment utiliser ref et out, et dans quelles situations.

Answer 1

• Vous utilisez Ref lorsque vous passez un paramètre initialisé et que vous attendez la méthode/fonction de la modifier.

• Vous utilisez Out lorsque vous passez un paramètre non initialisé et la méthode devra initialiser et remplir ce paramètre (vous obtenez un avertissement ou même une erreur).

  bool IsUserValid (nom d'utilisateur de chaîne);

  void IsUserValid (nom d'utilisateur de chaîne, out bool valide);

Les déclarations ci-dessus sont à peu près les mêmes. Il est plus facile de renvoyer la valeur, dans ce cas, vous utiliserez le type de retour. Mais si votre méthode doit également renvoyer la date de naissance de l'utilisateur, vous ne pouvez pas retourner les deux paramètres dans la déclaration, vous devez utiliser les paramètres out pour retourner l'un d'entre eux (ou annuler la méthode et renvoyer les deux comme out).

Answer 2

Quelle meilleure façon de vous montrer que vous donner un MSDN link;)

de ce lien:

La différence entre ref et est dehors subtile mais importante. Chaque mode de passage de paramètre est conçu pour s'appliquer à un scénario de programmation légèrement différent. La différence importante entre les paramètres out et ref est les règles d'affectation définies utilisées par chacun.

Answer 3

Une chose à surveiller est quand (pas) d'utiliser "ref" avec des paramètres de type référence. Le "ref" est pour la référence elle-même, pas pour le contenu de l'objet vers lequel pointe la référence.

Si vous passez une référence « en valeur » (qui est, sans « ref » ou « out »), vous ne pouvez pas changer la référence (donc un « nouveau » ne survivra pas à l'appel), vous On peut cependant encore changer les valeurs des propriétés sur lesquelles cette référence pointe (si la classe le permet).

Answer 4

Il est généralement désapprouvé d'utiliser (ou d'abuser) et de ref, il est souvent plus simple de renvoyer une structure ou une classe simple, contenant les champs multiples que vous devez "retourner". En ce qui concerne ref vs. out, out requiert une variable non initialisée, et le code ne compilera pas à moins que vous ne définissiez le paramètre out avant de quitter la fonction.

Le code ci-dessous donc pas compilation:

bool TryParse(string text, out int result) 
{ 
    if (text == null) 
    return false; 
    else 
    { 
    // do the parsing 
    } 
} 

ref ne nécessite pas de vous les définir. De même que Hans mentionne que vous pouvez réellement "nouveau" l'objet d'un type de référence en utilisant ref (puisque vous obtenez une référence à la référence, qui est approximativement égale à un objet ** pointeur en C++)

Answer 5

Vraiment il y en a 3 façons de passer un paramètre à une méthode: par référence, par valeur et comme sortie.

Par valeur est la valeur par défaut et ne dispose pas d'un mot-clé en C# (il fait en VB.Net: ByVal) - il passe une copie de types de valeurs:

public void SomeMethod1(int num) 
{ 
    num = 2; 
} 

int myNum = 1; 
SomeMethod1(myNum ); 
// myNum is still 1, we just set a new one 

Embrouillant - Par valeur passe une copie de la référence pour les types de référence. Cela signifie que les modifications apportées à un point de type de référence à l'instance, mais vous avez seulement une copie du pointeur réelle à la référence:

public void SomeMethod1(MyClass instance) 
{ 
    // changes the name on the instance 
    instance.Name = "test 1"; 

    // we're only nulling the copy passed to this method 
    instance = null; 
} 

public void SomeMethod2(MyClass instance) 
{ 
    // changes the name on the instance 
    instance.Name = "test 2"; 

    // this is a new instance only in this method 
    instance = new MyClass { Name = "new instance" }; 
} 

MyClass myInst = new MyClass { Name = "original" }; 
SomeMethod1(myInst); 
// myInst.Name is now "test 1" 

SomeMethod2(myInst); 
// myInst.Name is now "test 2" 

Ok, maintenant par référence (ref en C# ou ByRef en VB.Net) passe une référence à la valeur de struct:

public void SomeMethod1(ref int num) 
{ 
    num = 2; 
} 

int myNum = 1; 
SomeMethod1(ref myNum ); 
// myNum is now 2, we changed the reference 

assez simple, mais pour les types de référence par référence passe le pointeur à l'instance réelle, pas une copie:

public void SomeMethod1(ref MyClass instance) 
{ 
    // changes the name on the instance 
    instance.Name = "test 1"; 

    // we're nulling the reference passed to this method 
    instance = null; 
} 

public void SomeMethod2(ref MyClass instance) 
{ 
    // changes the name on the instance 
    instance.Name = "test 2"; 

    // this is a new instance replacing the original 
    instance = new MyClass { Name = "new instance" }; 
} 

MyClass myInst = new MyClass { Name = "original" }; 
SomeMethod1(ref myInst); 
// myInst.Name will now throw a NullReferenceException because myInst is null 

SomeMethod2(ref myInst); 
// myInst.Name is now "new instance" 

Ainsi, alors que les deux par référence et par valeur sont similaires pour les types de référence, le comportement est très différent si vous changez la référence elle-même (plutôt que ce que vous faites référence).

Enfin comme sortie est une variable de retour supplémentaire, tout comme le rendement réel. Ces deux sont les mêmes bascially:

public int SomeMethod1() 
{ 
    return 1; 
} 

public void SomeMethod2(out int num) 
{ 
    num = 1; 
} 

Si vous avez un paramètre, elle doit être rempli par la méthode (comme un retour).