List<T>.BinarySearch Metod

Definition

Namnområde:
System.Collections.Generic
Sammansättningar:
mscorlib.dll, System.Collections.dll
Sammansättning:
mscorlib.dll
Sammansättning:
System.Collections.dll
Sammansättning:
netstandard.dll

Använder en binär sökalgoritm för att hitta ett specifikt element i den sorterade List<T> eller en del av den.

Överlagringar

Name Description
BinarySearch(T)

Söker igenom hela sorterade List<T> efter ett element med hjälp av standardjäxan och returnerar det nollbaserade indexet för elementet.
BinarySearch(T, IComparer<T>)

Söker igenom hela sorterade List<T> efter ett element med hjälp av den angivna jämförelsen och returnerar det nollbaserade indexet för elementet.
BinarySearch(Int32, Int32, T, IComparer<T>)

Söker igenom ett område med element i det sorterade List<T> efter ett element med den angivna jämförelsen och returnerar elementets nollbaserade index.

BinarySearch(T)

Söker igenom hela sorterade List<T> efter ett element med hjälp av standardjäxan och returnerar det nollbaserade indexet för elementet.

public:
 int BinarySearch(T item);
public int BinarySearch(T item);
member this.BinarySearch : 'T -> int
Public Function BinarySearch (item As T) As Integer

Parametrar

item
T

Objektet som ska hittas. Värdet kan vara null för referenstyper.

Returer

Int32

Det nollbaserade indexet item för i det sorterade List<T>, om item hittas, annars ett negativt tal som är bitvis komplement till indexet för nästa element som är större än item eller, om det inte finns något större element, bitvis komplementet av Count.

Undantag

InvalidOperationException

Standardjäxaren Default kan inte hitta en implementering av det IComparable<T> generiska gränssnittet eller IComparable gränssnittet för typen T.

Exempel

I följande exempel visas Sort() metodöverbelastningen och metodöverbelastningen BinarySearch(T) . En List<T> sträng skapas och fylls med fyra strängar, i ingen särskild ordning. Listan visas, sorteras och visas igen.

Metodöverlagringen BinarySearch(T) används sedan för att söka efter två strängar som inte finns i listan och Insert metoden används för att infoga dem. Returvärdet för BinarySearch(T) metoden är negativt i varje enskilt fall, eftersom strängarna inte finns i listan. Om du tar det bitvisa komplementet (~-operatorn i C#, Xor -1 i Visual Basic) av det här negativa talet skapas indexet för det första elementet i listan som är större än söksträngen, och om du infogar på den här platsen bevaras sorteringsordningen. Den andra söksträngen är större än något element i listan, så insättningspositionen är i slutet av listan.

List<string> dinosaurs = new List<string>();

dinosaurs.Add("Pachycephalosaurus");
dinosaurs.Add("Amargasaurus");
dinosaurs.Add("Mamenchisaurus");
dinosaurs.Add("Deinonychus");

Console.WriteLine("Initial list:");
Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}

Console.WriteLine("\nSort:");
dinosaurs.Sort();

Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}

Console.WriteLine("\nBinarySearch and Insert \"Coelophysis\":");
int index = dinosaurs.BinarySearch("Coelophysis");
if (index < 0)
{
    dinosaurs.Insert(~index, "Coelophysis");
}

Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}

Console.WriteLine("\nBinarySearch and Insert \"Tyrannosaurus\":");
index = dinosaurs.BinarySearch("Tyrannosaurus");
if (index < 0)
{
    dinosaurs.Insert(~index, "Tyrannosaurus");
}

Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}
/* This code example produces the following output:

Initial list:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Deinonychus

Sort:

Amargasaurus
Deinonychus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Coelophysis":

Amargasaurus
Coelophysis
Deinonychus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Tyrannosaurus":

Amargasaurus
Coelophysis
Deinonychus
Mamenchisaurus
Pachycephalosaurus
Tyrannosaurus
*/

Imports System.Collections.Generic

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs As New List(Of String)

        dinosaurs.Add("Pachycephalosaurus")
        dinosaurs.Add("Amargasaurus")
        dinosaurs.Add("Mamenchisaurus")
        dinosaurs.Add("Deinonychus")

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & "Sort")
        dinosaurs.Sort

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "BinarySearch and Insert ""Coelophysis"":")
        Dim index As Integer = dinosaurs.BinarySearch("Coelophysis")
        If index < 0 Then
            index = index Xor -1
            dinosaurs.Insert(index, "Coelophysis")
        End If

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "BinarySearch and Insert ""Tyrannosaurus"":")
        index = dinosaurs.BinarySearch("Tyrannosaurus")
        If index < 0 Then
            index = index Xor -1
            dinosaurs.Insert(index, "Tyrannosaurus")
        End If

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

    End Sub
End Class

' This code example produces the following output:
'
'Pachycephalosaurus
'Amargasaurus
'Mamenchisaurus
'Deinonychus
'
'Sort
'
'Amargasaurus
'Deinonychus
'Mamenchisaurus
'Pachycephalosaurus
'
'BinarySearch and Insert "Coelophysis":
'
'Amargasaurus
'Coelophysis
'Deinonychus
'Mamenchisaurus
'Pachycephalosaurus
'
'BinarySearch and Insert "Tyrannosaurus":
'
'Amargasaurus
'Coelophysis
'Deinonychus
'Mamenchisaurus
'Pachycephalosaurus
'Tyrannosaurus

Kommentarer

Den här metoden använder standardjäxan Comparer<T>.Default för typ T för att fastställa ordningen på listelement. Egenskapen Comparer<T>.Default kontrollerar om typen T implementerar det IComparable<T> allmänna gränssnittet och använder den implementeringen, om det är tillgängligt. Comparer<T>.Default Annars kontrollerar du om typen T implementerar IComparable gränssnittet. Om typen T inte implementerar något av gränssnitten Comparer<T>.Default genererar en InvalidOperationException.

List<T> Måste redan sorteras enligt jämförelseimplementeringen. Annars är resultatet felaktigt.

Det är tillåtet att null jämföra med alla referenstyper och genererar inget undantag när du använder det IComparable<T> generiska gränssnittet. Vid sortering null anses vara mindre än något annat objekt.

List<T> Om innehåller fler än ett element med samma värde returnerar metoden bara en av förekomsterna och kan returnera någon av förekomsterna, inte nödvändigtvis den första.

Om inte List<T> innehåller det angivna värdet returnerar metoden ett negativt heltal. Du kan använda den bitvisa komplementåtgärden (~) för det här negativa heltalet för att hämta indexet för det första elementet som är större än sökvärdet. När du infogar värdet i List<T>bör det här indexet användas som insättningspunkt för att behålla sorteringsordningen.

Den här metoden är en O(log n)-åtgärd, där n är antalet element i intervallet.

Se även

Gäller för

BinarySearch(T, IComparer<T>)

Söker igenom hela sorterade List<T> efter ett element med hjälp av den angivna jämförelsen och returnerar det nollbaserade indexet för elementet.

public:
 int BinarySearch(T item, System::Collections::Generic::IComparer<T> ^ comparer);
public int BinarySearch(T item, System.Collections.Generic.IComparer<T> comparer);
member this.BinarySearch : 'T * System.Collections.Generic.IComparer<'T> -> int
Public Function BinarySearch (item As T, comparer As IComparer(Of T)) As Integer

Parametrar

item
T

Objektet som ska hittas. Värdet kan vara null för referenstyper.

comparer
IComparer<T>

Den IComparer<T> implementering som ska användas vid jämförelse av element.

-eller-

null för att använda standardjäxaren Default.

Returer

Int32

Det nollbaserade indexet item för i det sorterade List<T>, om item hittas, annars ett negativt tal som är bitvis komplement till indexet för nästa element som är större än item eller, om det inte finns något större element, bitvis komplementet av Count.

Undantag

InvalidOperationException

comparer är null, och standardjäxaren Default kan inte hitta en implementering av det IComparable<T> generiska gränssnittet eller IComparable gränssnittet för typen T.

Exempel

I följande exempel visas Sort(IComparer<T>) metodöverbelastningen och metodöverbelastningen BinarySearch(T, IComparer<T>) .

Exemplet definierar en alternativ jämförelse för strängar med namnet DinoCompare, som implementerar det allmänna gränssnittet IComparer<string> (IComparer(Of String) i Visual Basic). Jämförelsen fungerar på följande sätt: För det första testas jämförelsen för null, och en nullreferens behandlas som mindre än en icke-null. För det andra jämförs stränglängderna och den längre strängen anses vara större. För det tredje används vanlig strängjämförelse om längderna är lika.

En List<T> sträng skapas och fylls med fyra strängar, i ingen särskild ordning. Listan visas, sorteras med den alternativa jämförelsen och visas igen.

Metodöverlagringen BinarySearch(T, IComparer<T>) används sedan för att söka efter flera strängar som inte finns i listan, med den alternativa jämförelsen. Metoden Insert används för att infoga strängarna. Dessa två metoder finns i funktionen med namnet SearchAndInsert, tillsammans med kod för att ta bitvis komplementet (~-operatorn i C#, Xor -1 i Visual Basic) av det negativa talet som returneras av BinarySearch(T, IComparer<T>) och använder det som ett index för att infoga den nya strängen.

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
 */

Imports System.Collections.Generic

Public Class DinoComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        If x Is Nothing Then
            If y Is Nothing Then 
                ' If x is Nothing and y is Nothing, they're
                ' equal. 
                Return 0
            Else
                ' If x is Nothing and y is not Nothing, y
                ' is greater. 
                Return -1
            End If
        Else
            ' If x is not Nothing...
            '
            If y Is Nothing Then
                ' ...and y is Nothing, x is greater.
                Return 1
            Else
                ' ...and y is not Nothing, compare the 
                ' lengths of the two strings.
                '
                Dim retval As Integer = _
                    x.Length.CompareTo(y.Length)

                If retval <> 0 Then 
                    ' 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)
                End If
            End If
        End If
    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs As New List(Of String)
        dinosaurs.Add("Pachycephalosaurus")
        dinosaurs.Add("Amargasaurus")
        dinosaurs.Add("Mamenchisaurus")
        dinosaurs.Add("Deinonychus")
        Display(dinosaurs)

        Dim dc As New DinoComparer

        Console.WriteLine(vbLf & "Sort 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, Nothing, dc)
        Display(dinosaurs)
    End Sub

    Private Shared Sub SearchAndInsert( _
        ByVal lis As List(Of String), _
        ByVal insert As String, ByVal dc As DinoComparer)

        Console.WriteLine(vbLf & _
            "BinarySearch and Insert ""{0}"":", insert)

        Dim index As Integer = lis.BinarySearch(insert, dc)

        If index < 0 Then
            index = index Xor -1
            lis.Insert(index, insert)
        End If
    End Sub

    Private Shared Sub Display(ByVal lis As List(Of String))
        Console.WriteLine()
        For Each s As String In lis
            Console.WriteLine(s)
        Next
    End Sub
End Class

' 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

Kommentarer

Jämförelsen anpassar hur elementen jämförs. Du kan till exempel använda en CaseInsensitiveComparer instans som jämförelse för att utföra skiftlägesokänsliga strängsökningar.

Om comparer anges jämförs elementen i List<T> det angivna värdet med den angivna IComparer<T> implementeringen.

Om comparer är nullkontrollerar standardjäxaren Comparer<T>.Default om typen T implementerar det IComparable<T> generiska gränssnittet och använder den implementeringen, om det är tillgängligt. Comparer<T>.Default Annars kontrollerar du om typen T implementerar IComparable gränssnittet. Om typen T inte implementerar något av gränssnitten Comparer<T>.Default genererar InvalidOperationException.

List<T> Måste redan sorteras enligt jämförelseimplementeringen. Annars är resultatet felaktigt.

Det är tillåtet att null jämföra med alla referenstyper och genererar inget undantag när du använder det IComparable<T> generiska gränssnittet. Vid sortering null anses vara mindre än något annat objekt.

List<T> Om innehåller fler än ett element med samma värde returnerar metoden bara en av förekomsterna och kan returnera någon av förekomsterna, inte nödvändigtvis den första.

Om inte List<T> innehåller det angivna värdet returnerar metoden ett negativt heltal. Du kan använda den bitvisa komplementåtgärden (~) för det här negativa heltalet för att hämta indexet för det första elementet som är större än sökvärdet. När du infogar värdet i List<T>bör det här indexet användas som insättningspunkt för att behålla sorteringsordningen.

Den här metoden är en O(log n)-åtgärd, där n är antalet element i intervallet.

Se även

Gäller för

BinarySearch(Int32, Int32, T, IComparer<T>)

Söker igenom ett område med element i det sorterade List<T> efter ett element med den angivna jämförelsen och returnerar elementets nollbaserade index.

public:
 int BinarySearch(int index, int count, T item, System::Collections::Generic::IComparer<T> ^ comparer);
public int BinarySearch(int index, int count, T item, System.Collections.Generic.IComparer<T> comparer);
member this.BinarySearch : int * int * 'T * System.Collections.Generic.IComparer<'T> -> int
Public Function BinarySearch (index As Integer, count As Integer, item As T, comparer As IComparer(Of T)) As Integer

Parametrar

index
Int32

Det nollbaserade startindexet för intervallet som ska sökas.

count
Int32

Längden på det intervall som ska sökas.

item
T

Objektet som ska hittas. Värdet kan vara null för referenstyper.

comparer
IComparer<T>

Implementeringen IComparer<T> som ska användas vid jämförelse av element eller null för att använda standardjäxaren Default.

Returer

Int32

Det nollbaserade indexet item för i det sorterade List<T>, om item hittas, annars ett negativt tal som är bitvis komplement till indexet för nästa element som är större än item eller, om det inte finns något större element, bitvis komplementet av Count.

Undantag

ArgumentOutOfRangeException

index är mindre än 0.

-eller-

count är mindre än 0.

ArgumentException

index och count ange inte ett giltigt intervall i List<T>.

InvalidOperationException

comparer är null, och standardjäxaren Default kan inte hitta en implementering av det IComparable<T> generiska gränssnittet eller IComparable gränssnittet för typen T.

Exempel

I följande exempel visas Sort(Int32, Int32, IComparer<T>) metodöverbelastningen och metodöverbelastningen BinarySearch(Int32, Int32, T, IComparer<T>) .

Exemplet definierar en alternativ jämförelse för strängar med namnet DinoCompare, som implementerar det allmänna gränssnittet IComparer<string> (IComparer(Of String) i Visual Basic). Jämförelsen fungerar på följande sätt: För det första testas jämförelsen för null, och en nullreferens behandlas som mindre än en icke-null. För det andra jämförs stränglängderna och den längre strängen anses vara större. För det tredje används vanlig strängjämförelse om längderna är lika.

En List<T> av strängar skapas och fylls med namnen på fem växtätande dinosaurier och tre köttätande dinosaurier. Inom var och en av de två grupperna är namnen inte i någon viss sorteringsordning. Listan visas, intervallet för växtätare sorteras med hjälp av den alternativa jämförelsen och listan visas igen.

Metodöverlagringen BinarySearch(Int32, Int32, T, IComparer<T>) används sedan för att endast söka efter "Brachiosaurus" i intervallet växtätare. Strängen hittades inte och bitvis komplement (~-operatorn i C#, Xor -1 i Visual Basic) för det negativa tal som returneras av metoden BinarySearch(Int32, Int32, T, IComparer<T>) används som ett index för att infoga den nya strängen.

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
 */

Imports System.Collections.Generic

Public Class DinoComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        If x Is Nothing Then
            If y Is Nothing Then 
                ' If x is Nothing and y is Nothing, they're
                ' equal. 
                Return 0
            Else
                ' If x is Nothing and y is not Nothing, y
                ' is greater. 
                Return -1
            End If
        Else
            ' If x is not Nothing...
            '
            If y Is Nothing Then
                ' ...and y is Nothing, x is greater.
                Return 1
            Else
                ' ...and y is not Nothing, compare the 
                ' lengths of the two strings.
                '
                Dim retval As Integer = _
                    x.Length.CompareTo(y.Length)

                If retval <> 0 Then 
                    ' 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)
                End If
            End If
        End If
    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs As New List(Of 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")

        Dim herbivores As Integer = 5
        Display(dinosaurs)

        Dim dc As New DinoComparer

        Console.WriteLine(vbLf & _
            "Sort a range with the alternate comparer:")
        dinosaurs.Sort(0, herbivores, dc)
        Display(dinosaurs)

        Console.WriteLine(vbLf & _
            "BinarySearch a range and Insert ""{0}"":", _
            "Brachiosaurus")

        Dim index As Integer = _
            dinosaurs.BinarySearch(0, herbivores, "Brachiosaurus", dc)

        If index < 0 Then
            index = index Xor -1
            dinosaurs.Insert(index, "Brachiosaurus")
            herbivores += 1
        End If

        Display(dinosaurs)

    End Sub

    Private Shared Sub Display(ByVal lis As List(Of String))
        Console.WriteLine()
        For Each s As String In lis
            Console.WriteLine(s)
        Next
    End Sub
End Class

' 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

Kommentarer

Jämförelsen anpassar hur elementen jämförs. Du kan till exempel använda en CaseInsensitiveComparer instans som jämförelse för att utföra skiftlägesokänsliga strängsökningar.

Om comparer anges jämförs elementen i List<T> det angivna värdet med den angivna IComparer<T> implementeringen.

Om comparer är nullkontrollerar standardjäxaren Comparer<T>.Default om typen T implementerar det IComparable<T> generiska gränssnittet och använder den implementeringen, om det är tillgängligt. Comparer<T>.Default Annars kontrollerar du om typen T implementerar IComparable gränssnittet. Om typen T inte implementerar något av gränssnitten Comparer<T>.Default genererar InvalidOperationException.

List<T> Måste redan sorteras enligt jämförelseimplementeringen. Annars är resultatet felaktigt.

Det är tillåtet att null jämföra med alla referenstyper och genererar inget undantag när du använder det IComparable<T> generiska gränssnittet. Vid sortering null anses vara mindre än något annat objekt.

List<T> Om innehåller fler än ett element med samma värde returnerar metoden bara en av förekomsterna och kan returnera någon av förekomsterna, inte nödvändigtvis den första.

Om inte List<T> innehåller det angivna värdet returnerar metoden ett negativt heltal. Du kan använda den bitvisa komplementåtgärden (~) för det här negativa heltalet för att hämta indexet för det första elementet som är större än sökvärdet. När du infogar värdet i List<T>bör det här indexet användas som insättningspunkt för att behålla sorteringsordningen.

Den här metoden är en O(log n)-åtgärd, där n är antalet element i intervallet.

Se även

Gäller för