.net - sort - c# list beispiel



Was ist der Unterschied zwischen Liste(von T) und Sammlung(von T)? (8)

Ich habe gesehen, dass sie auf die gleiche Art und Weise verwendet wurden, und ich bin besorgt, dass ich dabei bin, einen Weg zu gehen, der irreversibel ist, wenn ich das nicht besser verstehe. Außerdem verwende ich .NET.


Alle diese Schnittstellen erben von IEnumerable , was Sie unbedingt verstehen sollten. Mit dieser Schnittstelle können Sie die Klasse grundsätzlich in einer foreach-Anweisung (in C #) verwenden.

  • ICollection ist die einfachste der aufgeführten Schnittstellen. Es ist eine aufzählbare Schnittstelle, die einen Count unterstützt und das ist es.
  • IList ist alles, was ICollection ist, aber es unterstützt auch das Hinzufügen und Entfernen von Elementen, das Abrufen von Elementen nach Index usw. Es ist die am häufigsten verwendete Schnittstelle für "Listen von Objekten", die ich weiß.
  • IQueryable ist eine aufzählbare Schnittstelle, die LINQ unterstützt. Sie können immer ein IQueryable aus einer IList erstellen und LINQ to Objects verwenden, aber Sie finden IQueryable auch für die verzögerte Ausführung von SQL-Anweisungen in LINQ to SQL und LINQ to Entities.
  • IDictionary ist ein anderes Tier in dem Sinne, dass es eine Zuordnung von eindeutigen Schlüsseln zu Werten ist. Es ist auch aufzählbar, da Sie die Schlüssel / Wert-Paare aufzählen können, aber ansonsten dient es einem anderen Zweck als die anderen, die Sie aufgelistet haben

Beide implementieren dieselben Schnittstellen, so dass sie sich genauso verhalten. Vielleicht sind sie intern anders implementiert, aber das müsste getestet werden.

Die einzigen wirklichen Unterschiede, die ich sehe, sind die Namespaces und die Tatsache, dass Collection<T> mit ComVisibleAttribute(false) markiert ist, sodass der COM-Code sie nicht verwenden kann.


In C # gibt es drei Konzepte, um einen Beutel mit Objekten darzustellen. In der Reihenfolge der zunehmenden Merkmale sind sie:

  • Aufzählbar - ungeordnet, nicht änderbar
  • Sammlung - kann Elemente hinzufügen / entfernen
  • Liste - erlaubt es, dass Artikel eine Bestellung haben (Zugriff und Entfernung per Index)

Enumerable hat keine Reihenfolge. Sie können keine Elemente aus dem Set hinzufügen oder entfernen. Sie können nicht einmal die Gegenstände im Set zählen. Es erlaubt Ihnen, nacheinander auf jedes Element des Sets zuzugreifen.

Sammlung ist ein modifizierbarer Satz. Sie können Objekte aus dem Set hinzufügen und entfernen, Sie können auch die Anzahl der Elemente im Set ermitteln. Aber es gibt immer noch keine Ordnung und weil es keine Reihenfolge gibt: keine Möglichkeit, auf ein Objekt per Index zuzugreifen, und es gibt auch keine Möglichkeit, es zu sortieren.

Liste ist eine geordnete Menge von Objekten. Sie können die Liste sortieren, auf Elemente nach Index zugreifen und Elemente nach Index entfernen.

In der Tat, wenn man die Schnittstellen für diese betrachtet, bauen sie aufeinander auf:

  • interface IEnumerable<T>

    • GetEnumeration<T>
  • interface ICollection<T> : IEnumerable<T>

    • Add
    • Remove
    • Clear
    • Count
  • interface IList<T> = ICollection<T>

    • Insert
    • IndexOf
    • RemoveAt

Wenn Sie Variablen oder Methodenparameter deklarieren, sollten Sie diese verwenden

  • IEnumerierbar
  • ICollektion
  • IList

basierend auf konzeptionell müssen Sie mit der Menge der Objekte tun.

Wenn Sie nur für jedes Objekt in einer Liste etwas tun können, benötigen Sie nur IEnumerable :

void SaveEveryUser(IEnumerable<User> users)
{
    for User u in users
      ...
}

Es ist Ihnen egal, ob die Benutzer in einer List<T> , einer Collection<T> , einem Array<T> oder einem anderen Element enthalten sind. Sie benötigen nur die IEnumerable<T> -Schnittstelle.

Wenn Sie die Elemente in einem Satz hinzufügen, entfernen oder zählen können, verwenden Sie eine Sammlung :

ICollection<User> users = new Collection<User>();
users.Add(new User());

Wenn Sie sich für eine Sortierreihenfolge interessieren und die Reihenfolge korrekt sein müssen, verwenden Sie eine Liste :

IList<User> users = FetchUsers(db);

In Diagrammform:

| Feature                | IEnumerable<T> | ICollection<T> | IList<T> |
|------------------------|----------------|----------------|----------|
| Enumerating items      | X              | X              | X        |
|                        |                |                |          |
| Adding items           |                | X              | X        |
| Removing items         |                | X              | X        |
| Count of items         |                | X              | X        |
|                        |                |                |          |
| Accessing by index     |                |                | X        |
| Removing by indexx     |                |                | X        |
| Getting index of item  |                |                | X        |

Die List<T> und Collection<T> in System.Collections.Generic sind zwei Klassen, die diese Schnittstellen implementieren; aber sie sind nicht die einzigen Klassen:

  • ConcurrentBag<T> ist eine geordnete Tasche von Objekten ( IEnumerable<T> )
  • LinkedList<T> ist eine Tasche, in der Sie nicht auf Objekte per Index zugreifen können ( ICollection ); Sie können jedoch Elemente aus der Sammlung beliebig hinzufügen und entfernen
  • SynchronizedCollection<T> in einer sortierten Sammlung, in der Sie Elemente nach Index hinzufügen / entfernen können

So können Sie leicht ändern:

IEnumerable<User> users = new SynchronizedCollection<User>();

SaveEveryUser(users);

tl; dr

  • Enumerable - Zugriffselemente, ungeordnet, nicht änderbar
  • Sammlung - kann geändert werden (hinzufügen, löschen, zählen)
  • Liste - kann nach Index zugreifen

Wählen Sie das gewünschte Konzept und verwenden Sie die passende Klasse.


Laut MSDN ist List (Of T) .Add "eine O (n) Operation" (wenn "Capacity" überschritten wird), während Collection (Of T) .Add immer "eine O (1) -Operation" ist. Das wäre verständlich, wenn List mit einer Array und Collection einer Linked List implementiert wird. Wenn dies jedoch der Fall wäre, würde man erwarten, dass die Sammlung (Of ​​T) "eine O (n) -Operation" ist. Aber - es ist - nicht !?! Collection (Of T) .Item ist "eine O (1) Operation" genau wie List (Of T) .Item.

Darüber hinaus, "tuinstoel" 's "29. Dezember 08 um 22:31" Post oben behauptet, Geschwindigkeits-Tests zeigen List (Of T) .Fügen Sie schneller als Collection (Of T). Fügen Sie hinzu, was ich reproduziert habe mit Longs und Strings. Obwohl ich nur ~ 33% schneller im Vergleich zu seinen 80% behauptete, laut MSDN sollte es das Gegenteil und "n" Mal gewesen sein!?!


Liste stellt eine Sammlung dar, in der die Reihenfolge der Elemente wichtig ist. Es unterstützt auch Methoden sa Sortieren und suchen. Sammlung ist eine allgemeinere Datenstruktur, die weniger Annahmen über die Daten macht und auch weniger Methoden unterstützt, um sie zu manipulieren. Wenn Sie eine benutzerdefinierte Datenstruktur bereitstellen möchten, sollten Sie die Auflistung wahrscheinlich erweitern. Wenn Sie Daten manipulieren müssen, ohne die Datenstruktur zu offenbaren, ist eine Liste wahrscheinlich der bequemere Weg.


Zusätzlich zu anderen Antworten habe ich einen schnellen Überblick über generische Listen- und Sammlungsfunktionen zusammengestellt. Sammlung ist eine begrenzte Teilmenge der Liste:

* = present
o = partially present

Property/Method   Collection<T>   List<T>
----------------------------------------------
Add()                *              *
AddRange()                          *
AsReadOnly()                        *
BinarySearch()                      *
Capacity                            *
Clear()              *              *
Contains()           *              *
ConvertAll()                        *
CopyTo()             o              *
Count                *              *
Equals()             *              *
Exists()                            *
Find()                              *
FindAll()                           *
FindIndex()                         *
FindLast()                          *
FindLastIndex()                     *
ForEach()                           *
GetEnumerator()      *              *
GetHashCode()        *              *
GetRange()                          *
GetType()            *              *
IndexOf()            o              *
Insert()             *              *
InsertRange()                       *
Item()               *              *
LastIndexOf()                       *
New()                o              *
ReferenceEquals()    *              *
Remove()             *              *
RemoveAll()                         *
RemoveAt()           *              *
RemoveRange()                       *
Reverse()                           *
Sort()                              *
ToArray()                           *
ToString()           *              *
TrimExcess()                        *
TrueForAll()                        *

Collection<T> ist eine anpassbare Hülle um IList<T> . Während IList<T> nicht versiegelt ist, werden keine Anpassungspunkte IList<T> . Collection<T> Methoden von Collection<T> werden standardmäßig an die IList<T> -Standardmethoden IList<T> , können jedoch leicht außer Kraft gesetzt werden, um das zu tun, was Sie möchten. Es ist auch möglich, Ereignisse innerhalb einer Collection<T> zu verkabeln, von denen ich glaube, dass sie mit einer IList nicht möglich wären.

Kurz gesagt, es ist viel einfacher, es nachträglich zu erweitern, was möglicherweise viel weniger Refactoring bedeuten kann.


List<T> ist ein sehr häufig verwendeter Container, da er sehr vielseitig ist (mit vielen praktischen Methoden wie Sort , Find usw.), aber keine Erweiterungspunkte hat, wenn Sie das Verhalten außer Kraft setzen möchten (überprüfen Sie die Elemente auf der Einfügung) , beispielsweise).

Collection<T> ist ein Wrapper um jede IList<T> ( IList<T> List<T> ) - es hat die Erweiterungspunkte ( virtual Methoden), aber nicht so viele Methoden wie Find . Wegen der Indirektion ist es etwas langsamer als List<T> , aber nicht viel.

Mit LINQ werden die zusätzlichen Methoden in List<T> weniger wichtig, da LINQ-to-Objects dazu neigt, sie trotzdem bereitzustellen ... zum Beispiel First(pred) , OrderBy(...) usw.





collections