List.BinarySearch-Methode (T, IComparer (generisch))

public int BinarySearch (
	T item,
	IComparer<T> comparer
)

public int BinarySearch (
	T item, 
	IComparer<T> comparer
)

public function BinarySearch (
	item : T, 
	comparer : IComparer<T>
) : int

Parameter

item

Das zu suchende Objekt. Der Wert kann für Verweistypen NULL (Nothing in Visual Basic) sein.

comparer

Die IComparer-Implementierung, die beim Vergleich von Elementen verwendet werden soll.

– oder –

NULL (Nothing in Visual Basic) zur Verwendung des Standardvergleichs Comparer.Default.

Rückgabewert

Der Comparer bestimmt, wie die Elemente miteinander verglichen werden. Sie können z. B. eine CaseInsensitiveComparer-Instanz als Comparer für die Suche nach Zeichenfolgen verwenden, bei der die Groß- und Kleinschreibung nicht berücksichtig wird.

Wenn comparer verfügbar ist, werden die Elemente der List unter Verwendung der angegebenen IComparer-Implementation mit den angegebenen Werten verglichen.

Wenn comparer den Wert NULL (Nothing in Visual Basic) besitzt, überprüft der Standardvergleich Comparer.Default, ob der Typ T die generische IComparable-Schnittstelle implementiert und diese Implementierung ggf. verwendet. Andernfalls überprüft Comparer.Default, ob der Typ T die IComparable-Schnittstelle implementiert. Wenn der Typ T keine der Schnittstellen implementiert, löst Comparer.Default eine InvalidOperationException aus.

List muss bereits entsprechend der Vergleichsimplementierung sortiert sein. Andernfalls ist das Ergebnis falsch.

Ein Vergleich von NULL (Nothing in Visual Basic) mit einem beliebigen Verweistyp ist zulässig und generiert beim Verwenden der generischen IComparable-Schnittstelle keine Ausnahme. Beim Sortieren ist NULL (Nothing in Visual Basic) kleiner als jedes andere Objekt.

Wenn List mehr als ein Element mit demselben Wert enthält, gibt die Methode nur ein Vorkommen zurück. Es wird nicht notwendigerweise das erste Vorkommen zurückgegeben, sondern es kann ein beliebiges Vorkommen zurückgegeben werden.

Wenn List den angegebenen Wert nicht enthält, gibt die Methode eine negative ganze Zahl zurück. Auf diese negative ganze Zahl können Sie die bitweise Komplementoperation (~) anwenden, um den Index des ersten Elements abzurufen, das größer als der Suchwert ist. Beim Einfügen des Werts in die List sollte dieser Index als Einfügemarke verwendet werden, um die Sortierreihenfolge beizubehalten.

Diese Methode ist eine O(log n)-Operation, wobei n der Anzahl der Elemente in dem Bereich entspricht.

Im folgenden Codebeispiel werden die Sort(IComparer (generisch))-Methodenüberladung und die BinarySearch(T,IComparer (generisch))-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 (Nothing in Visual Basic) 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.

Es wird eine List von Zeichenfolgen erstellt und ohne bestimmte Reihenfolge mit vier Zeichenfolgen aufgefüllt. Die Liste wird angezeigt, mit dem alternativen Vergleich sortiert und erneut angezeigt.

Anschließend wird mithilfe der BinarySearch(T,IComparer (generisch))-Methodenüberladung nach verschiedenen Zeichenfolgen gesucht, die nicht in der Liste enthalten sind. Dabei wird der alternative Vergleich verwendet. Die Insert-Methode wird zum Einfügen der Zeichenfolgen verwendet. Diese beiden Methoden befinden sich in der Funktion SearchAndInsert neben Code, der das bitweise Komplement (den Operator ~ in C# und Visual C++, Xor -1 in Visual Basic) der von BinarySearch(T,IComparer (generisch)) zurückgegebenen negativen Zahl annimmt und es 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("Amargasaurus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");
        Display(dinosaurs);

        DinoComparer dc = new DinoComparer();

        Console.WriteLine("\nSort with alternate comparer:");
        dinosaurs.Sort(dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, "Coelophysis", dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, "Oviraptor", dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, "Tyrannosaur", dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, null, dc);
        Display(dinosaurs);
    }

    private static void SearchAndInsert(List<string> list, 
        string insert, DinoComparer dc)
    {
        Console.WriteLine("\nBinarySearch and Insert \"{0}\":", insert);

        int index = list.BinarySearch(insert, dc);

        if (index < 0)
        {
            list.Insert(~index, insert);
        }
    }

    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
Amargasaurus
Mamenchisaurus
Deinonychus

Sort with alternate comparer:

Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Coelophysis":

Coelophysis
Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Oviraptor":

Oviraptor
Coelophysis
Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Tyrannosaur":

Oviraptor
Coelophysis
Deinonychus
Tyrannosaur
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "":


Oviraptor
Coelophysis
Deinonychus
Tyrannosaur
Amargasaurus
Mamenchisaurus
Pachycephalosaurus
 */

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

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

.NET Framework

.NET Compact Framework