Warum ist die Liste übergeben wird, ohne ref, um eine Funktion handeln, wie übergeben mit ref?

Wenn ich nicht diese schrecklich falsch, dieses Verhalten ist merkwürdig für mich. Anstatt zu erklären, poste ich ein Beispiel-code unten, und sagen Sie mir bitte warum bekomme ich Ausgang x und nicht y.

    private void button1_Click(object sender, EventArgs e)
    {
        List<int> l = new List<int>() { 1, 2, 3 };
        Fuss(l);
        MessageBox.Show(l.Count.ToString());
    }

    private void Fuss(List<int> l)
    {
        l.Add(4);
        l.Add(5);
    }

Ausgabe sollte, angenommen ich würde 3 sein. Aber ich bekomme als Ausgabe 5. Ich verstehe die Ausgabe kann 5 sein, wenn ich dies tun:

    private void button1_Click(object sender, EventArgs e)
    {
        List<int> l = new List<int>() { 1, 2, 3 };
        Fuss(ref l);
        MessageBox.Show(l.Count.ToString());
    }

    private void Fuss(ref List<int> l)
    {
        l.Add(4);
        l.Add(5);
    }

Sie sollten wahrscheinlich Lesen Sie auch Jon Skeet Parameterübergabe in C#.

InformationsquelleAutor nawfal | 2011-09-06

argument-passing c#c#-4.0 ref

14

Wirken Sie nicht wie seine passed by ref.
```
void ChangeMe(List<int> list) {
  list = new List<int>();
  list.Add(10);
}
void ChangeMeReally(ref List<int> list) {
  list = new List<int>();
  list.Add(10);
}
```
Versuchen Sie es. Merkst du den Unterschied?

Können Sie nur ändern, den Inhalt der Liste (oder eine Referenz-Typ) wenn Sie übergeben, ohne ein ref (, weil wie schon andere gesagt haben, übergeben Sie einen Verweis auf das Objekt auf dem heap, und somit das gleiche "memory").

Allerdings kann man nicht ändern "Liste", "Liste" eine variable ist, die Punkte auf ein Objekt vom Typ Liste. Sie kann sich nur ändern "Liste", wenn Sie es passieren Referenz (um es irgendwo anders). Sie erhalten eine Kopie der Referenz, die, wenn verändert, können nur beobachtet werden, innerhalb Ihrer Methode.

InformationsquelleAutor
5

Parameter werden als Wert übergeben in C#, es sei denn, Sie sind gekennzeichnet mit dem ref oder out Modifikatoren. Für Referenz-Typen, dies bedeutet, dass die Referenz wird als Wert übergeben. Daher Fuss, l ist auf der gleichen Instanz von List<int> als seine Anrufer. Daher werden alle änderungen zu dieser Instanz von List<int> zu sehen sein wird der Anrufer.

Nun, wenn Sie markieren Sie den parameter l mit ref oder out, dann wird der parameter als Verweis übergeben wird. Was dies bedeutet ist, dass in Fuss, l ist ein alias für den Speicherort verwendet, die als parameter an die Methode aufrufen. Um klar zu sein:
```
public void Fuss(ref List<int> l)
```
genannt
```
List<int> list = new List<int> { 1, 2, 3 };
Fuss(list);
```
Nun, in Fuss, l ist ein alias für list. Insbesondere, wenn Sie zuweisen eine neue Instanz von List<int> zu l Anrufer sehen, dass neue Instanz der Variablen zugewiesen list als gut. Insbesondere, wenn Sie sagen,
```
public void Fuss(ref List<int> l) {
    l = new List<int> { 1 };
}
```
dann die Anrufer sehen jetzt eine Liste mit einem element. Aber wenn Sie sagen,
```
public void Fuss(List<int> l) {
    l = new List<int> { 1 };
}
```
- und call-by -
```
List<int> list = new List<int> { 1, 2, 3 };
Fuss(list);
```
dann der Anrufer noch sehen list als drei Elemente.

Klar?

Ich verstehe, dass. Sie sagen, dass im zweiten Fall (ohne ref), wenn wir versuchen, uns zu ändern l ist, wird es nicht bekommen, spiegelt sich in den Anrufer. Aber wie ist es immer wider in mein problem habe ich gestellt ohne ref?
Ich denke, @Steven 's Antwort klärt Ihre Antwort für mich. Das ist ohne ref ich ändern kann, den Inhalt der Liste, aber nicht die Liste selbst! Mit ref-beides kann ich, so scheint es.
Im zweiten Fall werden sowohl der angerufene und der Anrufer beziehen sich auf die gleiche Instanz von List<int>, so natürlich Sie sehen die änderungen. Im ersten Fall werden sowohl der angerufene und der Anrufer mit dem gleichen Speicherort. Es ist also nicht nur, dass Sie beide das gleiche sehen List<int> ist, aber beide verändern die Instanz von List<int> einander anschaut!
Ich Verstand, was Sie sagen. Ein großer Dank. Aber ich bekam die Stelle klarer aus FishBasketGordo und Steven. Lassen Sie mich markieren Sie Ihre. Zusammen haben Sie drei machten die Sache klarer für mich.

InformationsquelleAutor
3

Den Unterschied zwischen ref und non-ref für Referenz-Typen wie Liste, ist nicht, ob Sie übergeben eine Referenz (das passiert immer), aber ob das Referenz kann geändert werden. Versuchen Sie die folgenden
```
private void Fuss(ref List<int> l)
{
    l = new List<int> { 4, 5 };
}
```
und du wirst sehen, der Graf ist 2, weil die Funktion nicht nur manipuliert die original-Liste, sondern die Referenz selbst.

InformationsquelleAutor
2

ByRef und ByVal gelten nur für value-Typen, keine Referenztypen, die immer weitergegeben, als wären Sie "byref" übergeben werden.

Wenn Sie brauchen, um zu ändern, eine Liste diskret, verwenden Sie die ".ToList ()" - Funktion, und erhalten Sie einen Klon Ihrer Liste.

Halten Sie im Verstand, wenn Ihre Liste enthält die Referenz-Typen, Ihre "neue" Liste enthält Zeiger auf die gleichen Objekte, die Ihre ursprüngliche Liste hat.

dude! diese ".ToList()" von dir hat mich gerettet ein Tag!
Darüber hinaus können Sie auch Sie einen .clone () - Methode

InformationsquelleAutor

Listen sind bereits Referenztypen, so dass, wenn Sie übergeben Sie an eine Methode übergeben Sie eine Referenz. Alle Add anrufen wirkt sich auf die Liste der Anrufer.

Übergabe eines List<T> durch ref verhält sich im wesentlichen wie an einem double-Zeiger auf die Liste. Hier ist eine illustration:

using System;
using System.Collections.Generic;

public class Test
{
    public static void Main()
    {
        List<int> l = new List<int>() { 1, 2, 3 };
        Fuss(l);
        Console.WriteLine(l.Count); //Count will now be 5.

        FussNonRef(l);
        Console.WriteLine(l.Count); //Count will still be 5 because we 
                                    //overwrote the copy of our reference 
                                    //in FussNonRef.

        FussRef(ref l);
        Console.WriteLine(l.Count); //Count will be 2 because we changed
                                    //our reference in FussRef.
    }

    private static void Fuss(List<int> l)
    {
        l.Add(4);
        l.Add(5);
    }

    private static void FussNonRef(List<int> l)
    {
        l = new List<int>();
        l.Add(6);
        l.Add(7);
    }

    private static void FussRef(ref List<int> l)
    {
        l = new List<int>();
        l.Add(8);
        l.Add(9);
    }
}

InformationsquelleAutor

2

Eine variable, ein parameter oder Feld vom Typ "Liste", oder jede andere Typ der Referenz, nicht wirklich eine Liste (oder ein Objekt einer anderen Klasse). Stattdessen wird es etwas wie "Object ID #29115" (nicht wie eine tatsächliche Zeichenfolge, natürlich, aber eine Kombination von bits, die bedeutet im wesentlichen, dass). Anderswo, das system muss eine indizierte Auflistung von Objekten, genannt heap; falls einige Variablen vom Typ Liste hat die "Object ID #29115", danach Objekt #29115 im heap wird eine Instanz-Liste oder einige geben, die davon abgeleitet werden.

Wenn MyFoo ist eine variable vom Typ Liste, eine Aussage wie " MyFoo.Add("George")' wird nicht wirklich ändern MyFoo; vielmehr bedeutet es "Überprüfen des Objekt-ID gespeichert MyFoo, und rufen Sie die "Add" - Methode des Objekts, die darin gespeichert sind. Wenn MyFoo statt "Object ID #19533", bevor die Anweisung ausgeführt wird, wird es auch weiterhin tun danach, aber Objekt ID #19533 hatten dessen Add-Methode aufgerufen wird (wahrscheinlich verändern, dass-Objekt). Umgekehrt, eine Aussage wie "MyFoo = MyBar" MyFoo halten Sie die gleiche Objekt-id als MyBar, aber nicht wirklich etwas tun, um die Objekte in Frage. Wenn MyBar statt "Object ID #59212" vor der Anweisung, dann nach der Aussage, MyFoo wird auch "ObjectId #59212". Nichts wird geschehen-Objekt ID #19533, noch Objekt ID#59212.

Mm ich Holen. Danke für eine andere Perspektive..

InformationsquelleAutor
0

Nur primitive Typen wie int, double etc. als Wert übergeben werden.

Komplexe Typen (wie list) übergeben werden, per Referenz (das ist eine vorübergehende Zeiger-Wert, um genau zu sein).

Das ist falsch. Alle Parameter werden per value übergeben, es sei denn, gekennzeichnet mit ref oder out.
Also, die Stelle in meiner Antwort ist falsch?
Sie sagte: "Nur primitive Typen...die als Wert übergeben werden. Komplexe Typen...übergeben werden per Referenz." Wie gesagt, alle - Parameter werden als Wert übergeben, es sei denn, gekennzeichnet mit ref oder out, nicht "nur primitive Typen.". "Komplex" ist kein gut definierter Begriff; ich nehme an, du meinst Referenz-Typen. Parameter geben Sie als Referenz-Typen werden als Wert übergeben, sofern nicht anders gekennzeichnet-mit ref oder out.
Nein, ich meinte, dass die Methode nicht das Objekt kopieren, sondern nur seine Adresse. Denke darüber nach wie in c++, in denen Sie nicht über Schlüsselwort 'ref'. Lesen Sie noch einmal sorgfältig. Ich Stimme mit Ihren Punkt über "komplexe", Zitat wäre das bessere Wort.
C# ist nicht C++. "Nein, ich meinte, dass die Methode nicht das Objekt kopieren, sondern nur seine Adresse." Abgesehen von der Schlampigkeit ("Methode nicht das Objekt kopieren"), wird der Wert kopiert, bevor Sie an die Methode übergeben. Immer, immer, immer (sofern nicht anders gekennzeichnet-mit ref oder out). Für value-Typen, die Instanz ist der Wert. Für Referenz-Typen, wird der Wert der Referenz. Beachten Sie, dass dies ist nicht der gleiche wie der referent!

InformationsquelleAutor

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.