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

List<T>.Sort-Methode (Int32, Int32, IComparer<T>)

Aktualisiert: November 2007

Sortiert die Elemente in einem Bereich von Elementen in der List<T> mithilfe des angegebenen Vergleichs.

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

public void Sort(
	int index,
	int count,
	IComparer<T> comparer
)
public void Sort(
	int index,
	int count,
	IComparer<T> comparer
)
public function Sort(
	index : int, 
	count : int, 
	comparer : IComparer<T>
)

Parameter

index
Typ: System.Int32
Der nullbasierte Startindex des zu sortierenden Bereichs.
count
Typ: System.Int32
Die Länge des zu sortierenden Bereichs.
comparer
Typ: System.Collections.Generic.IComparer<T>
Die IComparer<T>-Implementierung, die beim Vergleichen von Elementen verwendet werden soll, oder null, wenn der Standardvergleich Comparer<T>.Default verwendet werden soll.

AusnahmeBedingung
ArgumentOutOfRangeException

index ist kleiner als 0 (null).

– oder –

count ist kleiner als 0 (null).

ArgumentException

index und count geben keinen gültigen Bereich in der List<T> an.

– oder –

Die Implementierung von comparer hat während der Sortierung einen Fehler verursacht. comparer kann z. B. möglicherweise nicht 0 zurückgeben, wenn ein Element mit sich selbst verglichen wird.

InvalidOperationException

comparer ist null, und der Standardvergleich Comparer<T>.Default kann keine Implementierung der generischen IComparable<T>-Schnittstelle oder der IComparable-Schnittstelle für den Typ T finden.

Wenn comparer angegeben ist, werden die Elemente der List<T> mit der angegebenen IComparer<T>-Implementierung sortiert.

Wenn comparer den Wert null besitzt, überprüft der Standardvergleich Comparer<T>.Default, ob der Typ T die generische IComparable<T>-Schnittstelle implementiert und diese Implementierung ggf. verwendet. Andernfalls überprüft Comparer<T>.Default, ob der Typ T die IComparable-Schnittstelle implementiert. Wenn der Typ T keine der Schnittstellen implementiert, löst Comparer<T>.Default eine InvalidOperationException aus.

Diese Methode verwendet Array.Sort, das wiederum den QuickSort-Algorithmus verwendet. Diese Implementierung führt eine instabile Sortierung durch, d. h., bei zwei gleichen Elementen wird die Reihenfolge möglicherweise nicht beibehalten. Bei einer stabilen Sortierung wird im Gegensatz dazu die Reihenfolge von gleichen Elementen beibehalten.

Im Durchschnitt ist diese Methode eine O(n log n)-Operation, wobei n Count ist. Im ungünstigsten Fall stellt sie eine O(n^2)-Operation dar.

Im folgenden Codebeispiel werden die Sort(Int32, Int32, IComparer<T>)-Methodenüberladung und die BinarySearch(Int32, Int32, T, IComparer<T>)-Methodenüberladung veranschaulicht.

Im Codebeispiel wird ein alternativer Vergleich für DinoCompare-Zeichenfolgen definiert und die generische Schnittstelle IComparer<string> (IComparer(Of String) in Visual Basic, IComparer<String^> in Visual C++) implementiert. Der Vergleich funktioniert folgendermaßen: Zunächst werden die zu vergleichenden Objekte auf null getestet, und ein NULL-Verweis wird als kleiner angesehen als ein Nicht-NULL-Verweis. Dann werden die Zeichenfolgenlängen verglichen, und die längere Zeichenfolge wird als größer betrachtet. In einem dritten Schritt wird der gewöhnliche Zeichenfolgenvergleich verwendet, wenn die Längen übereinstimmen.

Eine List<T> von Zeichenfolgen wird erstellt und mit den Namen von fünf pflanzenfressenden Dinosauriern und drei fleischfressenden Dinosauriern gefüllt. In diesen zwei Gruppen wird keine besondere Sortierreihenfolge auf die Namen angewendet. Die Liste wird angezeigt, die Gruppe der Pflanzenfresser wird mit dem alternativen Vergleich sortiert, und die Liste wird erneut angezeigt.

Die BinarySearch(Int32, Int32, T, IComparer<T>)-Methodenüberladung wird anschließend verwendet, um ausschließlich den Bereich der Pflanzenfresser nach "Brachiosaurus" zu durchsuchen. Die Zeichenfolge wird nicht gefunden, und das bitweise Komplement (der Operator ~ in C# und Visual C++, Xor -1 in Visual Basic) der von der BinarySearch(Int32, Int32, T, IComparer<T>)-Methode zurückgegebenen negativen Zahl wird als Index zum Einfügen der neuen Zeichenfolge verwendet.

using System;
using System.Collections.Generic;

public class DinoComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        if (x == null)
        {
            if (y == null)
            {
                // If x is null and y is null, they're
                // equal. 
                return 0;
            }
            else
            {
                // If x is null and y is not null, y
                // is greater. 
                return -1;
            }
        }
        else
        {
            // If x is not null...
            //
            if (y == null)
                // ...and y is null, x is greater.
            {
                return 1;
            }
            else
            {
                // ...and y is not null, compare the 
                // lengths of the two strings.
                //
                int retval = x.Length.CompareTo(y.Length);

                if (retval != 0)
                {
                    // If the strings are not of equal length,
                    // the longer string is greater.
                    //
                    return retval;
                }
                else
                {
                    // If the strings are of equal length,
                    // sort them with ordinary string comparison.
                    //
                    return x.CompareTo(y);
                }
            }
        }
    }
}

public class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new List<string>();

        dinosaurs.Add("Pachycephalosaurus");
        dinosaurs.Add("Parasauralophus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Galimimus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");
        dinosaurs.Add("Oviraptor");
        dinosaurs.Add("Tyrannosaurus");

        int herbivores = 5;
        Display(dinosaurs);

        DinoComparer dc = new DinoComparer();

        Console.WriteLine("\nSort a range with the alternate comparer:");
        dinosaurs.Sort(0, herbivores, dc);
        Display(dinosaurs);

        Console.WriteLine("\nBinarySearch a range and Insert \"{0}\":",
            "Brachiosaurus");

        int index = dinosaurs.BinarySearch(0, herbivores, "Brachiosaurus", dc);

        if (index < 0)
        {
            dinosaurs.Insert(~index, "Brachiosaurus");
            herbivores++;
        }

        Display(dinosaurs);
    }

    private static void Display(List<string> list)
    {
        Console.WriteLine();
        foreach( string s in list )
        {
            Console.WriteLine(s);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Parasauralophus
Amargasaurus
Galimimus
Mamenchisaurus
Deinonychus
Oviraptor
Tyrannosaurus

Sort a range with the alternate comparer:

Galimimus
Amargasaurus
Mamenchisaurus
Parasauralophus
Pachycephalosaurus
Deinonychus
Oviraptor
Tyrannosaurus

BinarySearch a range and Insert "Brachiosaurus":

Galimimus
Amargasaurus
Brachiosaurus
Mamenchisaurus
Parasauralophus
Pachycephalosaurus
Deinonychus
Oviraptor
Tyrannosaurus
 */


Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile für Smartphone, Windows Mobile für Pocket PC, Xbox 360

.NET Framework und .NET Compact Framework unterstützen nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

.NET Framework

Unterstützt in: 3.5, 3.0, 2.0

.NET Compact Framework

Unterstützt in: 3.5, 2.0

XNA Framework

Unterstützt in: 2.0, 1.0
Anzeigen: