Wann ref verwendet werden soll und wann es in C # nicht erforderlich ist

Ich habe ein Objekt, das sich im Speicherstatus des Programms befindet, und einige andere Worker-Funktionen, an die ich das Objekt übergebe, um den Status zu ändern. Ich habe es per Ref an die Arbeiterfunktionen weitergegeben. Ich bin jedoch auf die folgende Funktion gestoßen.

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); 

Es verwirrt mich, weil beide received_sund remoteEPSachen von der Funktion zurückgeben. Warum braucht remoteEPman ein refund received_snicht?

Ich bin auch ein AC-Programmierer, daher habe ich ein Problem damit, Zeiger aus meinem Kopf zu bekommen.

Bearbeiten: Es sieht so aus, als wären Objekte in C # Zeiger auf das Objekt unter der Haube. Wenn Sie also ein Objekt an eine Funktion übergeben, können Sie den Objektinhalt über den Zeiger ändern. Das einzige, was an die Funktion übergeben wird, ist der Zeiger auf das Objekt, damit das Objekt selbst nicht kopiert wird. Sie verwenden ref oder out, wenn Sie in der Funktion, die einem Doppelzeiger ähnelt, ausschalten oder ein neues Objekt erstellen möchten.

Kurze Antwort: Lesen Sie meinen Artikel über das Bestehen von Argumenten .

Lange Antwort: Wenn ein Referenztypparameter als Wert übergeben wird, wird nur die Referenz übergeben, keine Kopie des Objekts. Dies ist wie das Übergeben eines Zeigers (nach Wert) in C oder C ++. Änderungen an den Wert des Parameters selbst wird nicht durch den Anrufer zu sehen ist, sondern ändert sich in dem Objekt , das die Referenzpunkte werden zu sehen.

Wenn ein Parameter (jeglicher Art) geleitet wird , durch Bezugnahme sind das bedeutet , dass alle Änderungen der Parameter durch den Anrufer gesehen - Änderungen der Parameter sind Änderungen der Variablen.

Der Artikel erklärt das alles natürlich ausführlicher :)

Nützliche Antwort: Sie müssen ref / out fast nie verwenden . Dies ist im Grunde ein Weg, um einen anderen Rückgabewert zu erhalten, und sollte normalerweise vermieden werden, gerade weil dies bedeutet, dass die Methode wahrscheinlich versucht, zu viel zu tun. Dies ist nicht immer der Fall ( TryParseusw. sind die kanonischen Beispiele für eine vernünftige Verwendung von out), aber die Verwendung von ref / out sollte eine relative Seltenheit sein.

Stellen Sie sich einen Nicht-Ref-Parameter als Zeiger und einen Ref-Parameter als Doppelzeiger vor. Das hat mir am meisten geholfen.

Sie sollten Werte fast nie mit ref übergeben. Ich vermute, dass das .Net-Team es ohne Interop-Bedenken niemals in die ursprüngliche Spezifikation aufgenommen hätte. Die OO-Methode, um mit den meisten Problemen umzugehen, die ref-Parameter lösen, ist:

Für mehrere Rückgabewerte

• Erstellen Sie Strukturen, die die mehreren Rückgabewerte darstellen

Für Grundelemente, die sich in einer Methode infolge des Methodenaufrufs ändern (Methode hat Nebenwirkungen auf Grundelemente)

• Implementieren Sie die Methode in einem Objekt als Instanzmethode und bearbeiten Sie den Status des Objekts (nicht die Parameter) als Teil des Methodenaufrufs
• Verwenden Sie die Lösung mit mehreren Rückgabewerten und führen Sie die Rückgabewerte in Ihrem Status zusammen
• Erstellen Sie ein Objekt, das einen Status enthält, der von einer Methode bearbeitet werden kann, und übergeben Sie dieses Objekt als Parameter und nicht die Grundelemente selbst.

Sie könnten wahrscheinlich eine ganze C # -App schreiben und niemals Objekte / Strukturen per Referenz übergeben.

Ich hatte einen Professor, der mir folgendes sagte:

Der einzige Ort, an dem Sie Refs verwenden würden, ist der Ort, an dem Sie entweder:

1. Sie möchten ein großes Objekt übergeben (dh die Objekte / Struktur enthält Objekte / Strukturen auf mehreren Ebenen), und das Kopieren wäre teuer und
2. Sie rufen ein Framework, eine Windows-API oder eine andere API auf, die dies erfordert.

Tu es nicht nur, weil du kannst. Sie können durch einige böse Fehler in den Arsch gebissen werden, wenn Sie anfangen, die Werte in einem Parameter zu ändern und nicht aufpassen.

Ich stimme seinem Rat zu und in meinen mehr als fünf Jahren seit der Schule hatte ich nie einen Bedarf dafür, außer das Framework oder die Windows-API aufzurufen.

Da receive_s ein Array ist, übergeben Sie einen Zeiger auf dieses Array. Die Funktion manipuliert die vorhandenen Daten, ohne die zugrunde liegende Position oder den zugrunde liegenden Zeiger zu ändern. Das Schlüsselwort ref gibt an, dass Sie den tatsächlichen Zeiger an die Position übergeben und diesen Zeiger in der Außenfunktion aktualisieren, sodass sich der Wert in der Außenfunktion ändert.

Beispielsweise ist das Bytearray ein Zeiger auf denselben Speicher, bevor und nachdem der Speicher gerade aktualisiert wurde.

Die Endpunktreferenz aktualisiert tatsächlich den Zeiger auf den Endpunkt in der externen Funktion auf eine neue Instanz, die innerhalb der Funktion generiert wird.

Stellen Sie sich einen Verweis so vor, als würden Sie einen Zeiger als Referenz übergeben. Wenn Sie keine Referenz verwenden, übergeben Sie einen Zeiger als Wert.

Besser noch, ignorieren Sie, was ich gerade gesagt habe (es ist wahrscheinlich irreführend, insbesondere bei Werttypen) und lesen Sie diese MSDN-Seite .

Mein Verständnis ist, dass alle von der Object-Klasse abgeleiteten Objekte als Zeiger übergeben werden, während gewöhnliche Typen (int, struct) nicht als Zeiger übergeben werden und ref erfordern. Ich bin mir bei der Zeichenfolge nicht sicher (wird sie letztendlich von der Objektklasse abgeleitet?)

Obwohl ich der allgemeinen Antwort von Jon Skeet und einigen anderen Antworten zustimme, gibt es einen Anwendungsfall für die Verwendung ref, und zwar zur Verschärfung der Leistungsoptimierungen. Bei der Leistungsprofilerstellung wurde beobachtet, dass das Festlegen des Rückgabewerts einer Methode geringfügige Auswirkungen auf die Leistung hat, wohingegen die Verwendung refals Argument, bei dem der Rückgabewert in diesen Parameter eingefügt wird, dazu führt, dass dieser geringfügige Engpass beseitigt wird.

Dies ist wirklich nur dann nützlich, wenn Optimierungsbemühungen auf ein extremes Niveau gebracht werden, wodurch die Lesbarkeit und möglicherweise die Testbarkeit und Wartbarkeit beeinträchtigt werden, um Millisekunden oder möglicherweise Split-Millisekunden zu sparen.

Grundnullregel zuerst: Primitive werden im Kontext der beteiligten TYPEN als Wert (Stapel) und Nicht-Primitiv als Referenz (Heap) übergeben.

Die beteiligten Parameter werden standardmäßig als Wert übergeben. Guter Beitrag, der die Dinge im Detail erklärt. 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
}

Wir können (mit Warnung) sagen, dass nicht-primitive Typen nichts als Zeiger sind. Und wenn wir sie als Referenz übergeben, können wir sagen, dass wir Doppelzeiger übergeben