Quando usare ref e quando non è necessario in C #

Ho un oggetto che è il mio stato in memoria del programma e ho anche alcune altre funzioni di lavoro a cui passo l'oggetto per modificare lo stato. L'ho passato per riferimento alle funzioni di lavoro. Tuttavia mi sono imbattuto nella seguente funzione.

byte[] received_s = new byte[2048];
IPEndPoint tmpIpEndPoint = new IPEndPoint(IPAddress.Any, UdpPort_msg);
EndPoint remoteEP = (tmpIpEndPoint);

int sz = soUdp_msg.ReceiveFrom(received_s, ref remoteEP); 

Mi confonde perché entrambi received_se remoteEPstanno restituendo cose dalla funzione. Perché ha remoteEPbisogno di un refe received_snon lo fa?

Sono anche un programmatore CA quindi ho problemi a togliermi i puntatori dalla testa.

Modifica: sembra che gli oggetti in C # siano puntatori all'oggetto nascosto. Quindi, quando si passa un oggetto a una funzione, è possibile modificare il contenuto dell'oggetto tramite il puntatore e l'unica cosa passata alla funzione è il puntatore all'oggetto in modo che l'oggetto stesso non venga copiato. Puoi usare ref o out se vuoi essere in grado di cambiare o creare un nuovo oggetto nella funzione che è come un doppio puntatore.

Risposta breve: leggi il mio articolo sul passaggio di argomenti .

Risposta lunga: quando un parametro del tipo di riferimento viene passato per valore, viene passato solo il riferimento, non una copia dell'oggetto. È come passare un puntatore (per valore) in C o C ++. Modifiche al valore del parametro stesso non saranno visti dal chiamante, ma cambia nell'oggetto quali punti di riferimento per il sarà visibile.

Quando un parametro (di qualsiasi tipo) viene passato per riferimento, significa che qualsiasi modifica al parametro viene vista dal chiamante: le modifiche al parametro sono modifiche alla variabile.

L'articolo spiega tutto questo in modo più dettagliato, ovviamente :)

Risposta utile: non è quasi mai necessario utilizzare ref / out . È fondamentalmente un modo per ottenere un altro valore di ritorno e di solito dovrebbe essere evitato proprio perché significa che il metodo sta probabilmente cercando di fare troppo. Non è sempre così ( TryParseecc. Sono esempi canonici di uso ragionevole di out), ma l'uso di ref / out dovrebbe essere una rarità relativa.

Pensa a un parametro non ref come a un puntatore e a un parametro ref come a un doppio puntatore. Questo mi ha aiutato di più.

Non dovresti quasi mai passare i valori per rif. Sospetto che se non fosse stato per problemi di interoperabilità, il team .Net non lo avrebbe mai incluso nelle specifiche originali. Il modo OO di affrontare la maggior parte dei problemi risolti dai parametri di riferimento è:

Per più valori restituiti

• Crea strutture che rappresentano più valori restituiti

Per le primitive che cambiano in un metodo come risultato della chiamata al metodo (il metodo ha effetti collaterali sui parametri primitivi)

• Implementa il metodo in un oggetto come metodo di istanza e modifica lo stato dell'oggetto (non i parametri) come parte della chiamata al metodo
• Utilizzare la soluzione del valore restituito multiplo e unire i valori restituiti al proprio stato
• Crea un oggetto che contiene uno stato che può essere manipolato da un metodo e passa quell'oggetto come parametro e non le primitive stesse.

Probabilmente potresti scrivere un'intera app C # e non passare mai alcun oggetto / struttura per riferimento.

Ho avuto un professore che mi ha detto questo:

L'unico posto in cui useresti gli ref è dove:

1. Vuoi passare un oggetto di grandi dimensioni (cioè, l'oggetto / struttura ha oggetti / strutture al suo interno a più livelli) e copiarlo sarebbe costoso e
2. Stai chiamando un Framework, un'API di Windows o un'altra API che lo richiede.

Non farlo solo perché puoi. Puoi essere morso nel culo da alcuni bug fastidiosi se inizi a modificare i valori in un parametro e non stai prestando attenzione.

Sono d'accordo con il suo consiglio e nei miei cinque anni più dalla scuola, non ne ho mai avuto bisogno al di fuori di chiamare il Framework o l'API di Windows.

Poiché ricevuto_s è un array, stai passando un puntatore a quell'array. La funzione manipola i dati esistenti in posizione, senza modificare la posizione o il puntatore sottostante. La parola chiave ref indica che stai passando il puntatore effettivo alla posizione e aggiornando quel puntatore nella funzione esterna, quindi il valore nella funzione esterna cambierà.

Ad esempio, l'array di byte è un puntatore alla stessa memoria prima e dopo, la memoria è stata appena aggiornata.

Il riferimento all'endpoint sta effettivamente aggiornando il puntatore all'endpoint nella funzione esterna a una nuova istanza generata all'interno della funzione.

Pensa a un riferimento nel senso che stai passando un puntatore per riferimento. Non usare un ref significa che stai passando un puntatore per valore.

Meglio ancora, ignora ciò che ho appena detto (probabilmente è fuorviante, specialmente con i tipi di valore) e leggi questa pagina MSDN .

la mia comprensione è che tutti gli oggetti derivati ​​dalla classe Object vengono passati come puntatori mentre i tipi ordinari (int, struct) non vengono passati come puntatori e richiedono ref. Non sono sicuro della stringa (è in definitiva derivato dalla classe Object?)

Mentre sono d'accordo con la risposta di Jon Skeet in generale e alcune delle altre risposte, esiste un caso d'uso per l'utilizzo ref, ovvero per rafforzare le ottimizzazioni delle prestazioni. Durante la profilazione delle prestazioni è stato osservato che l'impostazione del valore di ritorno di un metodo ha lievi implicazioni sulle prestazioni, mentre l'utilizzo refcome argomento in cui il valore di ritorno viene popolato in quel parametro provoca la rimozione di questo leggero collo di bottiglia.

Questo è davvero utile solo quando gli sforzi di ottimizzazione sono portati a livelli estremi, sacrificando la leggibilità e forse la testabilità e la manutenibilità per risparmiare millisecondi o forse frazioni di millisecondi.

Prima regola ground zero, le primitive vengono passate per valore (stack) e non primitive per riferimento (heap) nel contesto dei TIPI coinvolti.

I parametri coinvolti vengono passati da Value per impostazione predefinita. Buon post che spiega le cose in dettaglio. http://yoda.arachsys.com/csharp/parameters.html

Student myStudent = new Student {Name="A",RollNo=1};

ChangeName(myStudent);

static void ChangeName(Student s1)
{
  s1.Name = "Z"; // myStudent.Name will also change from A to Z
                // {AS s1 and myStudent both refers to same Heap(Memory)
                //Student being the non-Primitive type
}

ChangeNameVersion2(ref myStudent);
static void ChangeNameVersion2(ref Student s1)
{
  s1.Name = "Z"; // Not any difference {same as **ChangeName**}
}

static void ChangeNameVersion3(ref Student s1)
{
    s1 = new Student{Name="Champ"};

    // reference(myStudent) will also point toward this new Object having new memory
    // previous mystudent memory will be released as it is not pointed by any object
}

Possiamo dire (con avvertimento) I tipi non primitivi non sono altro che Puntatori E quando li passiamo per ref possiamo dire che stiamo passando il Doppio Puntatore