it-swarm.com.de

ArrayList vs List <> in C #

Was ist der Unterschied zwischen ArrayList und List<> in C #?

Ist es nur so, dass List<> einen Typ hat, während ArrayList keinen hat?

371
scatman

Ja, so ziemlich. List<T> ist eine generische Klasse. Es unterstützt das Speichern von Werten eines bestimmten Typs ohne Umwandlung in oder aus object (was zu einem Mehraufwand beim Ein-/Auspacken geführt hätte, wenn T ein Werttyp im Fall ArrayList war). ArrayList speichert einfach object Referenzen. Als generische Sammlung implementiert List<T> die generische Schnittstelle IEnumerable<T> und kann problemlos in LINQ verwendet werden (ohne dass ein Aufruf von Cast oder OfType erforderlich ist).

ArrayList gehört zu den Tagen, in denen C # keine Generika hatte. Es ist zu Gunsten von List<T> veraltet. Sie sollten ArrayList nicht in neuem Code verwenden, der auf .NET> = 2.0 abzielt, es sei denn, Sie müssen eine Schnittstelle mit einer alten API herstellen, die es verwendet.

492
Mehrdad Afshari

Mit List<T> können Sie Casting-Fehler verhindern. Es ist sehr nützlich, einen Laufzeitfehler zu vermeiden.

Beispiel:

Hier (mit ArrayList) können Sie diesen Code kompilieren, aber Sie werden später einen Ausführungsfehler sehen.

ArrayList array1 = new ArrayList();
array1.Add(1);
array1.Add("Pony"); //No error at compile process
int total = 0;
foreach (int num in array1)
{
 total += num; //-->Runtime Error
}

Wenn Sie List verwenden, vermeiden Sie diese Fehler:

List<int> list1 = new List<int>();
list1.Add(1);
//list1.Add("Pony"); //<-- Error at compile process
int total = 0;
foreach (int num in list1 )
{
 total += num;
}

Referenz: MSDN

96
termas

Zu den oben genannten Punkten hinzufügen. Die Verwendung von ArrayList unter 64-Bit-Betriebssystemen benötigt 2x Speicher als unter 32-Bit-Betriebssystemen. Währenddessen belegt die generische Liste List<T> viel weniger Speicher als die Liste ArrayList.

wenn wir zum Beispiel ein ArrayList von 19 MB in 32-Bit verwenden, würde es 39 MB in 64-Bit benötigen. Wenn Sie jedoch eine generische Liste List<int> von 8 MB in 32-Bit haben, werden nur 8,1 MB in 64-Bit benötigt, was im Vergleich zu ArrayList einen Unterschied von 481% darstellt.

Quelle: ArrayLists vs. generische Liste für primitive Typen und 64-Bit

23
Anoop

Ein weiterer hinzuzufügender Unterschied betrifft die Thread-Synchronisierung.

ArrayList bietet Thread-Sicherheit durch die Synchronized-Eigenschaft, die einen thread-sicheren Wrapper um die Auflistung zurückgibt. Der Wrapper sperrt bei jedem Hinzufügen oder Entfernen die gesamte Sammlung. Daher muss jeder Thread, der versucht, auf die Auflistung zuzugreifen, warten, bis er an der Reihe ist, um die eine Sperre zu übernehmen. Dies ist nicht skalierbar und kann bei großen Sammlungen zu erheblichen Leistungseinbußen führen.

List<T> bietet keine Thread-Synchronisation. Der Benutzercode muss die gesamte Synchronisierung bereitstellen, wenn Elemente in mehreren Threads gleichzeitig hinzugefügt oder entfernt werden.

Weitere Informationen hier Thread-Synchronisation im .Net Framework

18
NullReference

Einfache Antwort ist,

ArrayList ist nicht generisch

  • Es ist ein Objekttyp, in dem Sie einen beliebigen Datentyp speichern können.
  • Sie können beliebige Werte (Werttyp oder Referenztyp) wie Zeichenfolge, int, Mitarbeiter und Objekt in der ArrayList speichern. (Anmerkung und)
  • Boxen und Unboxing wird passieren.
  • Nicht typsicher.
  • Es ist älter.

Liste ist allgemein

  • Es handelt sich um einen Typ, sodass Sie das T zur Laufzeit angeben können.
  • Sie können basierend auf der Deklaration nur einen Wert vom Typ T (Zeichenfolge oder int oder Mitarbeiter oder Objekt) speichern. (Anmerkung oder)
  • Boxen und Unboxing wird nicht passieren.
  • Geben Sie safe ein.
  • Es ist neuer.

Beispiel:

ArrayList arrayList = new ArrayList();
List<int> list = new List<int>();

arrayList.Add(1);
arrayList.Add("String");
arrayList.Add(new object());


list.Add(1);
list.Add("String");                 // Compile-time Error
list.Add(new object());             // Compile-time Error

Bitte lesen Sie das offizielle Microsoft-Dokument : https://blogs.msdn.Microsoft.com/kcwalina/2005/09/23/system -sammlungen-gegen-system-sammlung-generisches-und-system-sammlungen-objektmodell /

enter image description here

Hinweis : Sie sollten Generics kennen, bevor Sie den Unterschied verstehen: https://docs.Microsoft.com/en-us/dotnet/csharp/programmieranleitung/generika /

7
Aravin

ArrayList sind nicht typsicher, während List<T> typsicher sind. Einfach :).

3
Hassan Rahman

ArrayList ist die Sammlung verschiedener Datentypen, während List<> die Sammlung ähnlicher Typen eigener Abhängigkeiten ist.

3
Law Kant Dayal

Ich denke, die Unterschiede zwischen ArrayList und List<T> sind:

  1. List<T>, wobei T der Werttyp ist, ist schneller als ArrayList. Dies liegt daran, dass List<T> das Ein- und Auspacken vermeidet (wobei T der Werttyp ist).
  2. Viele Quellen sagen - normalerweise ArrayList nur aus Gründen der Abwärtskompatibilität. (ist kein wirklicher Unterschied, aber ich denke, es ist ein wichtiger Hinweis).
  3. Reflexion ist einfacher mit nicht generischen ArrayList dann List<T>
  4. ArrayList hat die Eigenschaft IsSynchronized. Es ist also einfach, synchronisierte ArrayList zu erstellen und zu verwenden. Ich habe die Eigenschaft IsSynchronized für List<T> nicht gefunden. Beachten Sie auch, dass diese Art der Synchronisation relativ ineffizient ist, msdn ):

    var arraylist = new ArrayList();
    var arrayListSyncronized = ArrayList.Synchronized(arraylist
    Console.WriteLine($"syncronized {arraylist.IsSynchronized}");
    Console.WriteLine($"syncronized {arrayListSyncronized.IsSynchronized}");
    
    var list = new List<object>();
    var listSyncronized = ArrayList.Synchronized(list);
    Console.WriteLine($"syncronized {list.IsSynchronized}");//error, no such prop
    Console.WriteLine($"syncronized {list.IsSynchronized}");//error, no such prop
    
  5. ArrayList hat die Eigenschaft ArrayList.SyncRoot, die für die Synchronisation verwendet werden kann ( msdn ). List<T> hat keine SyncRoot -Eigenschaft, daher müssen Sie in der folgenden Konstruktion ein Objekt verwenden, wenn Sie List<T> verwenden:

    ArrayList myCollection = new ArrayList();
    lock(myCollection.SyncRoot) //  ofcourse you can use another object for this goal
    {
        foreach (object item in myCollection)
        {
            // ...
        }
    }
    
1
burzhuy