Erzeugen einer neuen Instanz einer Liste in C#

Lassen Sie uns ein Beispiel verwenden :

        List<A> firstList = new List<A>()
        {
            new A() { Id = 3 },
            new A() { Id = 5 }
        };

        List<A> secondList = new List<A>(firstList);

        secondList[1].Id = 999;

        Console.WriteLine(firstList[1].Id);

Ausgabe : 999

Der Hauptgrund für dieses ist, dass, obwohl wir erstellen neue List<T> Objekt (ja, collection-Objekt), verweist auf einen neuen Speicher im verwalteten heap, aber es funktioniert immer noch mit Referenzen auf dieselben Objekte.

Erstellung einer Liste der neuen (!) Objekte mit gleichen Werten müssen Sie Elemente kopieren, irgendwie, eine Möglichkeit ist die Verwendung von LINQ .Select() Methode, um neue Objekte zu erstellen und ToList() Methode, um es konvertieren zu-Liste :

        List<A> firstList = new List<A>()
        {
            new A() { Id = 3 },
            new A() { Id = 5 }
        };

        List<A> secondList = firstList.Select(el => new A() { Id = el.Id }).ToList();

        secondList[1].Id = 999;

        Console.WriteLine(firstList[1].Id);

Ausgang : 5

In der folgenden Zeile:

List<T> exampleList = new List<T>(toModify)

erstellen Sie eine Liste von T-Aufruf List<T>'s Konstruktor, der ein argument vom Typ IEnumerable<T>. Für weitere Informationen über die letztere, bitte haben Sie einen Blick hier.

Methode, die die Argumente in C# übergeben werden standardmäßig by-value und nicht by-reference. Sie können per Referenz übergeben werden, aber Sie müssen explizit angeben, diese in der Signatur der entsprechenden Methode mit der ref Schlüsselwort und an der Stelle, rufen Sie diese Methode, verwenden wieder das gleiche keyword. Also die toModify wird als Wert übergeben an den Konstruktor von List<T>.

Was ist die Bedeutung dieses?

In C# - Typen können in zwei Kategorien unterteilt werden (trotz der Tatsache, dass alle Typen Erben aus dem System.Objekt):

• Wert-Typen
• Referenz-Typen

Wenn wir an den Wert-Typ, der als argument übergeben wir eine Kopie ist es Wert. Jede änderung, die wir machen, in der entweder der ursprüngliche Wert oder in der Kopie der original-Wert nicht reflektiert wird, zu einer anderen. Auf der anderen Seite, wenn wir an einem Referenz-Typ als argument übergeben wir eine Kopie der Referenz. So, jetzt haben wir zwei Verweise (Zeiger), der auf der gleichen Position im Speicher. That being said, es ist klar, dass, wenn wir ändern jede Eigenschaft des Objekts, in dem beide Referenzen Punkte zu, wäre dies sichtbar von beiden.

In Ihrem Fall ist dies, was geschieht. toModify ist eine Liste von Referenz-Typen (unter der Haube haben Sie ein array, dessen Elemente Referenzen auf andere Objekte). So dass jede änderung, die auf die Elemente der ersten Liste toModify, spiegelt sich in der Liste, die Sie konstruieren auf der Grundlage dieser Liste.

Ein einfaches Beispiel, das Sie verwenden können, um zu überprüfen, die oben genannten ist folgende:

public class Point
{
    public int X { get; set; }
    public int Y { get; set; }

    public override string ToString() => $"X: {X}, Y: {Y}";
}

class Program
{
    static void Main(string[] args)
    {
        var listA = new List<int> {1, 2, 3};
        var listB = new List<int>(listA);
        //Before the modification
        Console.WriteLine(listA[0]); //prints 1
        Console.WriteLine(listB[0]); //prints 1
        listA[0] = 2;
        //After the mofication
        Console.WriteLine(listA[0]); //prints 2
        Console.WriteLine(listB[0]); //prints 1
        Console.ReadKey();

        var pointsA = new List<Point>
        {
            new Point {X = 3, Y = 4},
            new Point {X = 4, Y = 5},
            new Point {X = 6, Y = 8},
        };
        var pointsB = new List<Point>(pointsA);
        //Before the modification
        Console.WriteLine(pointsA[0]); //prints X: 3, Y: 4
        Console.WriteLine(pointsB[0]); //prints X: 3, Y: 4
        pointsA[0].X = 4; 
        pointsA[0].Y = 3;
        //After the modification
        Console.WriteLine(pointsA[0]); //prints X: 4, Y: 3
        Console.WriteLine(pointsB[0]); //prints X: 4, Y: 3

        Console.ReadKey();
    }
}