ToList () - Erstellt es eine neue Liste?

Sagen wir, ich habe eine Klasse

public class MyObject
{
   public int SimpleInt{get;set;}
}

Und ich habe eine List<MyObject>, und ich ToList() es und ändern Sie dann eine der SimpleInt, wird meine änderung weitergegeben werden zurück zur ursprünglichen Liste. In anderen Worten, was wäre die Ausgabe der folgenden Methode?

public void RunChangeList()
{
  var objs = new List<MyObject>(){new MyObject(){SimpleInt=0}};
  var whatInt = ChangeToList(objs );
}
public int ChangeToList(List<MyObject> objects)
{
  var objectList = objects.ToList();
  objectList[0].SimpleInt=5;
  return objects[0].SimpleInt;

}

Warum?

P/S: tut mir Leid, wenn es scheint offensichtlich zu finden. Aber ich habe keinen compiler jetzt mit mir...

InformationsquelleAutor der Frage Graviton | 2010-05-05

c#linq

175

Ja, ToList wird eine neue Liste erstellen, aber da in diesem Fall MyObject ist eine Referenz geben Sie dann die neue Liste enthält Verweise auf die gleichen Objekte wie das ursprüngliche Liste.

Aktualisierung der SimpleInt Eigenschaft eines Objekts auf die in der neuen Liste wird auch Auswirkungen auf die entsprechenden Objekts in der ursprünglichen Liste.

(Wenn MyObject erklärt struct eher als eine class dann die neue Liste enthält Kopien der Elemente in der ursprünglichen Liste, und die Aktualisierung einer Eigenschaft von einem element in der neuen Liste würde nicht Einfluss auf die entsprechenden Elemente in der ursprünglichen Liste.)

InformationsquelleAutor der Antwort LukeH

Vom Reflektor würd Quelle:

public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source)
{
    if (source == null)
    {
        throw Error.ArgumentNull("source");
    }
    return new List<TSource>(source);
}

Also ja, deine ursprüngliche Liste wird nicht aktualisiert werden (d.h. das hinzufügen oder entfernen) jedoch die referenzierten Objekte.

InformationsquelleAutor der Antwort Chris S

29

ToList wird immer erstellen Sie eine neue Liste erstellen, die nicht unbedingt alle nachfolgenden änderungen an der Sammlung.

Allerdings wird es änderungen an den Objekten selbst (es sei denn, Sie sind mutable structs).

In anderen Worten, wenn Sie ein Objekt ersetzen, die in der original-Liste mit einem anderen Objekt, das ToList enthält das erste Objekt ein.

Jedoch, wenn Sie ändern die Objekte der ursprünglichen Liste, die ToList immer noch das gleiche enthalten (modifiziert) Objekt.

InformationsquelleAutor der Antwort SLaks
10

Ja, es erzeugt eine neue Liste. Das ist by design.

Die Liste enthält die gleichen Ergebnisse wie der original-Reihenfolge Durchlaufen werden,, sondern materialisiert sich in eine permanente (in-memory) Sammlung. Diese können Sie konsumieren, die Ergebnisse mehrere Male, ohne dass die Kosten für recomputing der Sequenz.

Die Schönheit der LINQ-Sequenzen ist, dass Sie sind zusammensetzbar. Oft ist die IEnumerable<T> Sie bekommen, ist das Ergebnis der Kombination von mehreren filtern, Sortierungs-und/oder Projektions-Operationen. Erweiterung Methoden wie ToList() und ToArray() ermöglichen es Ihnen, konvertieren Sie die berechnete Sequenz in eine standard-Sammlung.

InformationsquelleAutor der Antwort LBushkin
7

Akzeptierte Antwort richtig-Adressen, die OP-Frage, basierend auf Ihren Beispiel. Jedoch, es gilt nur, wenn ToList wird angewendet, um eine konkrete Sammlung; es nicht halten, wenn die Elemente des Quell-Sequenz noch instanziiert werden (aufgrund der verzögerten Ausführung). Im Falle des letzteren, erhalten Sie möglicherweise einen neuen Satz von Elementen, jedes mal, wenn Sie anrufen ToList (oder aufzählen der Reihenfolge).

Hier ist eine Anpassung der OP - code veranschaulicht dieses Verhalten:
```
public static void RunChangeList()
{
    var objs = Enumerable.Range(0, 10).Select(_ => new MyObject() { SimpleInt = 0 });
    var whatInt = ChangeToList(objs);   //whatInt gets 0
}

public static int ChangeToList(IEnumerable<MyObject> objects)
{
    var objectList = objects.ToList();
    objectList.First().SimpleInt = 5;
    return objects.First().SimpleInt;
}
```
Während der obige code kann gekünstelt erscheinen, dieses Verhalten als einen subtilen Fehler in anderen Szenarien. Sehen meine anderen Beispiel für eine situation, wo es bewirkt, dass Aufgaben zu bekommen hervorgebracht wiederholt.

InformationsquelleAutor der Antwort Douglas
6

Wird eine neue Liste erstellt, aber die Elemente sind Referenzen an die ursprünglichen Elemente (wie in der ursprünglichen Liste). Änderungen an der Liste selbst sind unabhängige, aber auf die items finden die Veränderung in beiden Listen.

InformationsquelleAutor der Antwort Preet Sangha
4

Ich denke, dass dies äquivalent ist zu Fragen, ob ToList hat eine Tiefe oder flache Kopie. Als ToList hat keine Möglichkeit zu Klonen, MyObject, es muss eine flache Kopie, so dass die erstellte Liste enthält die gleichen Referenzen wie das original, so gibt der code 5.

InformationsquelleAutor der Antwort Timores

Nur stolpern das alte post und dachte an das hinzufügen meine zwei Cent. Im Allgemeinen, wenn ich in Zweifel, ich schnell die GetHashCode () - Methode auf jedem Objekt, um zu überprüfen, die Identität. Also für die oben

    public class MyObject
{
    public int SimpleInt { get; set; }
}


class Program
{

    public static void RunChangeList()
    {
        var objs = new List<MyObject>() { new MyObject() { SimpleInt = 0 } };
        Console.WriteLine("objs: {0}", objs.GetHashCode());
        Console.WriteLine("objs[0]: {0}", objs[0].GetHashCode());
        var whatInt = ChangeToList(objs);
        Console.WriteLine("whatInt: {0}", whatInt.GetHashCode());
    }

    public static int ChangeToList(List<MyObject> objects)
    {
        Console.WriteLine("objects: {0}", objects.GetHashCode());
        Console.WriteLine("objects[0]: {0}", objects[0].GetHashCode());
        var objectList = objects.ToList();
        Console.WriteLine("objectList: {0}", objectList.GetHashCode());
        Console.WriteLine("objectList[0]: {0}", objectList[0].GetHashCode());
        objectList[0].SimpleInt = 5;
        return objects[0].SimpleInt;

    }

    private static void Main(string[] args)
    {
        RunChangeList();
        Console.ReadLine();
    }

Und Antwort auf meine Maschine -

objs: 45653674
objs[0]: 41149443
Objekte: 45653674
Objekte[0]: 41149443
objectList: 39785641
objectList[0]: 41149443
whatInt: 5

Also im wesentlichen das Objekt, die Liste führt, bleiben die gleichen im obigen code. Hoffe der Ansatz hilft.

InformationsquelleAutor der Antwort vibhu

2

ToList wird, erstellen Sie eine Marke neue Liste.

Wenn die Elemente in der Liste sind value-Typen, Sie werden direkt aktualisiert, wenn Sie sind Referenz-Typen, alle änderungen werden zurück in die referenzierten Objekte.

InformationsquelleAutor der Antwort Oded
2

In dem Fall, wo das source-Objekt ist eine echte IEnumerable (also nicht nur eine Sammlung verpackt eine als enumerable), ToList() kann NICHT wieder das gleiche Objekt verweist wie in der ursprünglichen IEnumerable. Wird es wieder eine neue Liste von Objekten, aber diese Objekte können nicht den gleichen oder sogar Gleich der Objekte ergab sich durch die IEnumerable, wenn es wieder aufgelistet

InformationsquelleAutor der Antwort prmph
1
```
 var objectList = objects.ToList();
  objectList[0].SimpleInt=5;
```
Aktualisieren Sie die original-Objekt als gut. Die neue Liste enthält Referenzen auf die enthaltenen Objekte, wie die original-Liste. Sie können die Elemente verändern und das update wird in der anderen reflektiert.

Nun, wenn Sie aktualisieren eine Liste (hinzufügen oder löschen eines Elements), die nicht reflektiert werden, in der anderen Liste.

InformationsquelleAutor der Antwort kemiller2002
1

Ich nicht sehen, irgendwo in der Dokumentation, die ToList() ist immer garantiert, um wieder eine neue Liste. Wenn ein IEnumerable ist eine Liste, kann es effizienter sein, um dies zu überprüfen und einfach wieder die gleiche Liste.

Die Sorge ist, dass manchmal können Sie absolut sicher sein wollen, dass die zurückgegebene Liste ist != zu der ursprünglichen Liste. Weil nicht Microsoft-Dokument, dass ToList gibt eine neue Liste, können wir nicht sicher sein (es sei denn, jemand gefunden, der Dokumentation). Es könnte auch in der Zukunft ändern, auch wenn es jetzt funktioniert.

neue Liste(IEnumerable enumerablestuff) ist gewährleistet, um wieder eine neue Liste. Ich würde diese stattdessen zu verwenden.

InformationsquelleAutor der Antwort Ben B.

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.