C# Language ref, out


Exemple

Les mots-clés ref et out provoquent un argument par référence, et non par valeur. Pour les types de valeur, cela signifie que la valeur de la variable peut être modifiée par l'appelé.

int x = 5;
ChangeX(ref x);
// The value of x could be different now

Pour les types de référence, l'instance dans la variable peut non seulement être modifiée (comme c'est le cas sans la ref ), mais elle peut également être complètement remplacée:

Address a = new Address();
ChangeFieldInAddress(a);
// a will be the same instance as before, even if it is modified
CreateANewInstance(ref a);
// a could be an entirely new instance now

La principale différence entre le mot-clé out et ref est que ref exige que la variable soit initialisée par l'appelant, tandis que out passe cette responsabilité à l'appelé.

Pour utiliser un paramètre out , la définition de la méthode et la méthode appelante doivent utiliser explicitement le mot clé out .

int number = 1;
Console.WriteLine("Before AddByRef: " + number); // number = 1
AddOneByRef(ref number);
Console.WriteLine("After AddByRef: " + number);  // number = 2
SetByOut(out number);
Console.WriteLine("After SetByOut: " + number);  // number = 34

void AddOneByRef(ref int value)
{
    value++;
}

void SetByOut(out int value)
{
    value = 34;
}

Démo en direct sur .NET Fiddle

Ce qui suit ne compile pas , car out paramètres out doivent avoir une valeur assignée avant que la méthode ne retourne (elle devrait être compilée avec ref ):

void PrintByOut(out int value)
{
    Console.WriteLine("Hello!");
}

utiliser un mot clé comme modificateur générique

out mot clé out peut également être utilisé dans les paramètres de type générique lors de la définition des interfaces génériques et des délégués. Dans ce cas, le mot-clé out indique que le paramètre type est covariant.

La covariance vous permet d'utiliser un type plus dérivé que celui spécifié par le paramètre générique. Cela permet la conversion implicite des classes implémentant des interfaces variantes et la conversion implicite des types de délégué. La covariance et la contravariance sont prises en charge pour les types de référence, mais elles ne sont pas prises en charge pour les types de valeur. - MSDN

//if we have an interface like this
interface ICovariant<out R> { }

//and two variables like
ICovariant<Object> iobj = new Sample<Object>();
ICovariant<String> istr = new Sample<String>();

// then the following statement is valid
// without the out keyword this would have thrown error
iobj = istr; // implicit conversion occurs here