C# Language ref, fuori

Esempio

Le parole chiave ref e out sì che un argomento venga passato per riferimento, non per valore. Per i tipi di valore, ciò significa che il valore della variabile può essere modificato dal destinatario.

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

Per i tipi di riferimento, l'istanza nella variabile non può essere modificata solo (come nel caso senza ref ), ma può anche essere sostituita del tutto:

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 differenza tra la parola chiave out e ref è che ref richiede che la variabile venga inizializzata dal chiamante, mentre out passa tale responsabilità al destinatario.

Per utilizzare un parametro out , sia la definizione del metodo sia il metodo di chiamata devono utilizzare esplicitamente la parola chiave 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;
}

Live Demo su .NET Fiddle

Quanto segue non si compila, perché out parametri out devono avere un valore assegnato prima che il metodo ritorni (si compilerebbe invece usando ref ):

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

usando la parola chiave come modificatore generico

out parola chiave out può essere utilizzata anche nei parametri di tipo generico quando si definiscono interfacce e delegati generici. In questo caso, la parola chiave out specifica che il parametro type è covariante.

La covarianza consente di utilizzare un tipo più derivato rispetto a quello specificato dal parametro generico. Ciò consente la conversione implicita di classi che implementano interfacce varianti e la conversione implicita di tipi di delegati. Covarianza e controvarianza sono supportate per i tipi di riferimento, ma non sono supportate per i tipi di valore. - 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