Differenza tra ref e out in C #

2019

"Ref" e "Out" sono i modificatori dei parametri usati in C #. Usando ref e out, puoi passare qualsiasi tipo di valore con il suo riferimento a qualsiasi metodo. Il motivo del passaggio di qualsiasi tipo di valore dal suo riferimento introduce la differenza principale tra la parola chiave ref e out. La parola chiave ref consente al metodo chiamato di modificare il contenuto dell'argomento passato ad esso con la parola chiave ref. La parola chiave out consente al metodo chiamato di restituire più di un valore in una singola chiamata. Studiamo la differenza tra ref e out insieme a una tabella di confronto.

Grafico comparativo

Base per il confronto	arbitro	Su
Di base	Permette l'alterazione del valore dell'argomento procede con la parola chiave ref.	Consente a un metodo di restituire quei valori preceduti da una parola chiave out.
Inizializzazione	Il parametro ref deve essere inizializzato prima della chiamata al metodo.	Il parametro out deve essere inizializzato all'interno del metodo chiamato prima che termini.
Dichiarazione	Il parametro da modificare con un metodo è dichiarato come ref mentre la dichiarazione del metodo e il metodo di chiamata.	Il parametro da restituire deve essere dichiarato come ref durante la dichiarazione del metodo e la chiamata al metodo.

Definizione della parola chiave Ref

Il "ref" è un modificatore di parametro usato quando è necessario chiamare un metodo con call-by-reference. Quando vogliamo che le modifiche apportate agli argomenti all'interno di un metodo chiamato debbano riflettere nel valore originale di quella variabile, viene utilizzato il modificatore del parametro ref. Il tipo di valore che vogliamo dichiarare come ref è preceduto dalla parola chiave "ref" durante la dichiarazione del metodo e dal metodo calling. Più di un parametro può essere dichiarato come "ref" mentre si chiama e si dichiara un metodo.

 usando il sistema; class DemoRef {public void Square (ref int s) {s = s * s; }} classe Ref_main {static void Main () {DemoRef ob = new DemoRef (); int a = 10; Console.WriteLine ("una prima chiamata al metodo:" + a); ob.Square (ref a); // Usato ref Keyword Console.WriteLine ("una dopo chiamata:" + a); }} // emette una prima chiamata al metodo: 10 a dopo la chiamata al metodo: 100

Nel codice precedente, la variabile 'a' è passata come argomento al metodo Square (ref a) insieme al modificatore del parametro ref ad esso allegato. Significa che qualunque cosa cambierà il metodo Square (ref a) si comporterà sulla variabile 'a' al suo interno rifletterà nel valore originale di 'a', anche al di fuori del metodo.

Ci sono alcuni punti importanti che devono essere ricordati quando si ha a che fare con il modificatore di parametro "ref".

L'argomento che stai passando dal riferimento a un metodo deve essere inizializzato prima del metodo di chiamata.
Il metodo non deve assegnare il valore iniziale all'argomento ref.
Puoi anche usare ref insieme alla variabile di riferimento.

Definizione della parola chiave Out

Ogni volta che chiami un metodo, restituirebbe un solo valore. Se si desidera che un metodo restituisca più di un valore in una chiamata, è necessario utilizzare la parola chiave "out" insieme ai parametri che si desidera tornare al termine del metodo. A volte accade che quando non vogliamo passare nulla al metodo ma vogliamo che il metodo restituisca qualcosa usiamo i parametri con una parola chiave out. Comprendiamolo con un esempio.

 usando il sistema; class DemoOut {public int Decompose (double x, out double fraction) {int whole_num; intero_num = (int) x; frazione = x - intero_num; return whole_num; }} classe Out_maint {static void Main () {DemoOut ob = new DemoOut (); int i; doppio frac; i = ob.Decompose (100.125, out frac); // utilizzato fuori parola chiave Console.WriteLine ("Numero intero parte è" + i); Console.WriteLine ("parte della frazione è" + frac); }} // output La parte intera è 100 La parte frazionaria è 0.125

Nel codice precedente, vengono restituiti due valori dal metodo, Decompose (). Uno restituisce con la parola chiave "return" ie whole_num, e altro restituisce un parametro che è preceduto dalla parola chiave out mentre il metodo chiama cioè "frac".

I punti importanti da ricordare sulla parola chiave out.

A differenza della parola chiave ref, il parametro che utilizza la parola chiave out non deve essere inizializzato prima della chiamata al metodo.
Il metodo chiamato assegnerà esso stesso un valore al parametro con una parola chiave out poiché viene considerato come non assegnato all'interno del metodo chiamato, ovvero si presume che non abbia alcun valore iniziale.
Il metodo chiamato deve assegnare un valore al parametro out prima che il metodo termini.
La parola chiave out è applicabile anche alla variabile di riferimento.

Differenze chiave tra rif e out in C #

Quando una variabile preceduta dalla parola chiave ref viene passata a qualsiasi metodo, le modifiche apportate ad esso all'interno del metodo si riflettono nel suo valore originale. Quando una variabile passata a un metodo è preceduta da una parola chiave out, il metodo lo restituisce senza utilizzare la parola chiave return.
Il parametro ref deve essere inizializzato prima che venga passato a un metodo. D'altra parte, il parametro out deve essere inizializzato nel metodo a cui è passato.
Durante la chiamata, la dichiarazione o la definizione di un metodo, il parametro ref viene esplicitamente dichiarato come ref. D'altra parte, durante la chiamata, la dichiarazione o la definizione di un metodo, il parametro out viene esplicitamente dichiarato come out.

Conclusione:

Ogni volta che la variabile deve essere passata dal riferimento a un metodo, è possibile utilizzare la parola chiave ref and out. Considerando che, il motivo dell'utilizzo di entrambe le parole chiave è diverso in cui la parola chiave ref può essere utilizzata per modificare il valore dell'argomento preceduto dalla parola chiave ref, passato al metodo chiamato e la parola chiave out viene utilizzata per restituire il valore dell'argomento preceduto dalla parola chiave out.