Diese Dokumentation wurde archiviert und wird nicht länger gepflegt.

SortedList (generische Klasse)

Stellt eine Auflistung von Schlüssel-Wert-Paaren dar, die auf Grundlage der zugeordneten IComparer-Implementierung nach den Schlüsseln sortiert sind.

Namespace: System.Collections.Generic
Assembly: System (in system.dll)

[SerializableAttribute] 
[ComVisibleAttribute(false)] 
public class SortedList<TKey,TValue> : IDictionary<TKey,TValue>, ICollection<KeyValuePair<TKey,TValue>>, 
	IEnumerable<KeyValuePair<TKey,TValue>>, IDictionary, ICollection, IEnumerable
J# unterstützt die Verwendung von generischen Typen und Methoden, aber nicht die Deklaration von neuen generischen Typen oder Methoden.
JScript unterstützt keine generischen Typen oder Methoden.
Nicht zutreffend.

Typparameter

TKey

Der Typ der Schlüssel in der Auflistung.

TValue

Der Typ der Werte in der Auflistung.

Bei der generischen SortedList-Klasse handelt es sich um eine binäre Suchstruktur mit O(log n)-Abruf, wobei n für die Anzahl der Elemente im Wörterbuch steht. In dieser Hinsicht ähnelt sie der generischen SortedDictionary-Klasse. Die beiden Klassen verfügen sowohl über ähnliche Objektmodelle als auch über O(log n)-Abruf. Sie unterscheiden sich jedoch in der Speichernutzung und in der Geschwindigkeit von Einfüge- und Entfernungsvorgängen:

  • SortedList benötigt weniger Speicher als SortedDictionary.

  • Unsortierte Daten werden vom SortedDictionary schneller hinzugefügt und entfernt: O(log n) im Gegensatz zu O(n) bei der SortedList.

  • Wenn die Liste in einem Vorgang mit sortierten Daten gefüllt wird, ist die SortedList schneller als das SortedDictionary.

Ein weiterer Unterschied zwischen der SortedDictionary-Klasse und der SortedList-Klasse liegt darin, dass SortedList einen effizienten, indizierten Abruf von Schlüsseln und Werten über die Auflistungen unterstützt, die von der Keys-Eigenschaft und der Values-Eigenschaft zurückgegeben werden. Beim Zugriff auf die Eigenschaften ist es nicht erforderlich, die Listen neu zu generieren, da die Listen nur als Wrapper für die internen Arrays von Schlüsseln und Werten dienen. Im folgenden Code wird gezeigt, wie mithilfe der Values-Eigenschaft eine indizierte Abfrage von Werten aus einer sortierten Liste von Zeichenfolgen erfolgen kann:

string v = mySortedList.Values[3];

SortedList wird als ein Array von Schlüssel-Wert-Paaren implementiert, das anhand des Schlüssels sortiert wird. Jedes Element kann als KeyValuePair-Objekt abgerufen werden.

Schlüsselobjekte müssen unveränderlich sein, solange sie als Schlüssel in SortedList verwendet werden. Jeder Schlüssel in einer SortedList muss eindeutig sein. Ein Schlüssel kann nicht NULL-Verweis (Nothing in Visual Basic) sein. Bei einem Wert ist dies hingegen zulässig, wenn der Typ der Werte in der Liste, TValue, ein Verweistyp ist.

Die SortedList benötigt für das Sortieren und Vergleichen eine Vergleichsimplementierung. Der Standardvergleich Comparer.Default überprüft, ob der Schlüsseltyp TKeySystem.IComparable implementiert, und verwendet diese Implementierung, sofern verfügbar. Andernfalls überprüft Comparer.Default, ob der Schlüsseltyp TKeySystem.IComparable implementiert. Wenn der Schlüsseltyp TKey keine der Schnittstellen implementiert, können Sie in einer Konstruktorüberladung eine System.Collections.Generic.IComparer-Implementierung angeben, die einen comparer-Parameter akzeptiert.

Bei der Kapazität einer SortedList handelt es sich um die Anzahl der Elemente, die die SortedList enthalten kann. Wenn einer SortedList Elemente hinzugefügt werden, wird die Kapazität durch die Neuzuordnung des internen Arrays automatisch nach Bedarf erhöht. Die Kapazität kann über einen Aufruf von TrimExcess oder durch ein explizites Festlegen der Capacity-Eigenschaft verringert werden. Beim Verringern der Kapazität werden der Arbeitsspeicher neu reserviert und alle Elemente in der SortedList kopiert.

Für die foreach-Anweisung in C# (for each in C++, For Each in Visual Basic) ist der Typ der Elemente in der Auflistung erforderlich. Da die Elemente von SortedList Schlüssel-Wert-Paare sind, ist der Elementtyp nicht der Typ des Schlüssels oder Werts. Stattdessen ist der Elementtyp KeyValuePair. Beispiel:

foreach (KeyValuePair<int, string> kvp in mySortedList) {...}

Die foreach-Anweisung ist ein Wrapper um den Enumerator, der nur das Lesen aus der Auflistung aber nicht das Schreiben in diese zulässt.

Im folgenden Codebeispiel wird ein leeres SortedList von Zeichenfolgen mit Zeichenfolgenschlüsseln erstellt, und mithilfe der Add-Methode werden einige Elemente hinzugefügt. Im Beispiel wird veranschaulicht, dass die Add-Methode bei dem Versuch, einen doppelten Schlüssel hinzuzufügen, eine ArgumentException auslöst.

Im Beispiel werden die Werte mithilfe der Item-Eigenschaft (Indexer in C#) abgerufen. Dies veranschaulicht, dass eine KeyNotFoundException ausgelöst wird, wenn ein angeforderter Schlüssel nicht vorhanden ist. Außerdem wird gezeigt, dass ein einem Schlüssel zugeordneter Wert ersetzt werden kann.

In diesem Beispiel wird gezeigt, wie Werte mithilfe der TryGetValue-Methode effizienter abgerufen werden können, wenn ein Programm häufig versucht, auf Schlüsselwerte zuzugreifen, die nicht in der sortierten Liste enthalten sind. Außerdem wird veranschaulicht, wie vor dem Aufrufen der Add-Methode mithilfe der ContainsKey-Methode geprüft werden kann, ob ein Schlüssel vorhanden ist.

Im Beispiel wird gezeigt, wie die Schlüssel und Werte in der sortierten Liste oder eigenständig anhand der Keys-Eigenschaft und der Values aufgelistet werden können.

Abschließend wird im Beispiel die Remove-Methode aufgerufen.

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        // Create a new sorted list of strings, with string
        // keys.
        SortedList<string, string> openWith = 
            new SortedList<string, string>();

        // Add some elements to the list. There are no 
        // duplicate keys, but some of the values are duplicates.
        openWith.Add("txt", "notepad.exe");
        openWith.Add("bmp", "paint.exe");
        openWith.Add("dib", "paint.exe");
        openWith.Add("rtf", "wordpad.exe");

        // The Add method throws an exception if the new key is 
        // already in the list.
        try
        {
            openWith.Add("txt", "winword.exe");
        }
        catch (ArgumentException)
        {
            Console.WriteLine("An element with Key = \"txt\" already exists.");
        }

        // The Item property is another name for the indexer, so you 
        // can omit its name when accessing elements. 
        Console.WriteLine("For key = \"rtf\", value = {0}.", 
            openWith["rtf"]);

        // The indexer can be used to change the value associated
        // with a key.
        openWith["rtf"] = "winword.exe";
        Console.WriteLine("For key = \"rtf\", value = {0}.", 
            openWith["rtf"]);

        // If a key does not exist, setting the indexer for that key
        // adds a new key/value pair.
        openWith["doc"] = "winword.exe";

        // The indexer throws an exception if the requested key is
        // not in the list.
        try
        {
            Console.WriteLine("For key = \"tif\", value = {0}.", 
                openWith["tif"]);
        }
        catch (KeyNotFoundException)
        {
            Console.WriteLine("Key = \"tif\" is not found.");
        }

        // When a program often has to try keys that turn out not to
        // be in the list, TryGetValue can be a more efficient 
        // way to retrieve values.
        string value = "";
        if (openWith.TryGetValue("tif", out value))
        {
            Console.WriteLine("For key = \"tif\", value = {0}.", value);
        }
        else
        {
            Console.WriteLine("Key = \"tif\" is not found.");
        }

        // ContainsKey can be used to test keys before inserting 
        // them.
        if (!openWith.ContainsKey("ht"))
        {
            openWith.Add("ht", "hypertrm.exe");
            Console.WriteLine("Value added for key = \"ht\": {0}", 
                openWith["ht"]);
        }

        // When you use foreach to enumerate list elements,
        // the elements are retrieved as KeyValuePair objects.
        Console.WriteLine();
        foreach( KeyValuePair<string, string> kvp in openWith )
        {
            Console.WriteLine("Key = {0}, Value = {1}", 
                kvp.Key, kvp.Value);
        }

        // To get the values alone, use the Values property.
        IList<string> ilistValues = openWith.Values;

        // The elements of the list are strongly typed with the 
        // type that was specified for the SorteList values.
        Console.WriteLine();
        foreach( string s in ilistValues )
        {
            Console.WriteLine("Value = {0}", s);
        }

        // The Values property is an efficient way to retrieve
        // values by index.
        Console.WriteLine("\nIndexed retrieval using the Values " +
            "property: Values[2] = {0}", openWith.Values[2]);

        // To get the keys alone, use the Keys property.
        IList<string> ilistKeys = openWith.Keys;

        // The elements of the list are strongly typed with the 
        // type that was specified for the SortedList keys.
        Console.WriteLine();
        foreach( string s in ilistKeys )
        {
            Console.WriteLine("Key = {0}", s);
        }

        // The Keys property is an efficient way to retrieve
        // keys by index.
        Console.WriteLine("\nIndexed retrieval using the Keys " +
            "property: Keys[2] = {0}", openWith.Keys[2]);

        // Use the Remove method to remove a key/value pair.
        Console.WriteLine("\nRemove(\"doc\")");
        openWith.Remove("doc");

        if (!openWith.ContainsKey("doc"))
        {
            Console.WriteLine("Key \"doc\" is not found.");
        }
    }
}

/* This code example produces the following output:

An element with Key = "txt" already exists.
For key = "rtf", value = wordpad.exe.
For key = "rtf", value = winword.exe.
Key = "tif" is not found.
Key = "tif" is not found.
Value added for key = "ht": hypertrm.exe

Key = bmp, Value = paint.exe
Key = dib, Value = paint.exe
Key = doc, Value = winword.exe
Key = ht, Value = hypertrm.exe
Key = rtf, Value = winword.exe
Key = txt, Value = notepad.exe

Value = paint.exe
Value = paint.exe
Value = winword.exe
Value = hypertrm.exe
Value = winword.exe
Value = notepad.exe

Indexed retrieval using the Values property: Values[2] = winword.exe

Key = bmp
Key = dib
Key = doc
Key = ht
Key = rtf
Key = txt

Indexed retrieval using the Keys property: Keys[2] = doc

Remove("doc")
Key "doc" is not found.
 */

System.Object
  System.Collections.Generic.SortedList

Öffentliche statische (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

SortedList stellt eine gleichzeitige Unterstützung für mehrere Reader bereit, sofern die Auflistung nicht verändert wird. Die Enumeration einer Auflistung ist jedoch systembedingt in keinem Fall eine threadsichere Prozedur. Um Threadsicherheit während der Enumeration zu gewährleisten, können Sie die Auflistung während der gesamten Enumeration sperren. Um den Lese- und Schreibzugriff auf diese Auflistung durch mehrere Threads zuzulassen, müssen Sie eine eigene Synchronisierung implementieren.

Windows 98, Windows Server 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

Microsoft .NET Framework 3.0 wird unter Windows Vista, Microsoft Windows XP SP2 und Windows Server 2003 SP1 unterstützt.

.NET Framework

Unterstützt in: 3.0, 2.0

.NET Compact Framework

Unterstützt in: 2.0

XNA Framework

Unterstützt in: 1.0
Anzeigen: