List<T>.BinarySearch Método

Definição

Espaço de Nomes:
System.Collections.Generic
Assemblagens:
mscorlib.dll, System.Collections.dll
Assemblagem:
mscorlib.dll
Assemblagem:
System.Collections.dll
Assemblagem:
netstandard.dll

Utiliza um algoritmo de pesquisa binária para localizar um elemento específico no ordenado List<T> ou uma parte dele.

Sobrecargas

Name Description
BinarySearch(T)

Pesquisa em todo o List<T> conjunto ordenado por um elemento usando o comparador padrão e retorna o índice zero do elemento.
BinarySearch(T, IComparer<T>)

Pesquisa todo o elemento ordenado List<T> usando o comparador especificado e devolve o índice zero do elemento.
BinarySearch(Int32, Int32, T, IComparer<T>)

Pesquisa um intervalo de elementos ordenados List<T> por um elemento usando o comparador especificado e devolve o índice zero do elemento.

BinarySearch(T)

Pesquisa em todo o List<T> conjunto ordenado por um elemento usando o comparador padrão e retorna o índice zero do elemento.

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

Parâmetros

item
T

O objeto a localizar. O valor pode ser null para tipos de referência.

Devoluções

Int32

O índice baseado em zero de item no ordenado List<T>, se item for encontrado; caso contrário, um número negativo que é o complemento bit a bit do índice do próximo elemento que é maior do item que ou, se não houver elemento maior, o complemento bit a bit de Count.

Exceções

InvalidOperationException

O comparador Default padrão não consegue encontrar uma implementação da IComparable<T> interface genérica ou da IComparable interface para o tipo T.

Exemplos

O exemplo seguinte demonstra a Sort() sobrecarga de métodos e a BinarySearch(T) sobrecarga de métodos. A List<T> de cordas é criado e povoado com quatro cadeias, sem ordem específica. A lista é exibida, ordenada e novamente apresentada.

A BinarySearch(T) sobrecarga do método é então usada para procurar duas cadeias que não estão na lista, e o Insert método é usado para as inserir. O valor de retorno do BinarySearch(T) método é negativo em cada caso, porque as cadeias não estão na lista. Tomando o complemento bit a bit (o operador ~ em C#, Xor -1 em Visual Basic) deste número negativo produz-se o índice do primeiro elemento da lista que é maior do que a cadeia de pesquisa, e inserir neste local preserva a ordem de ordenação. A segunda cadeia de pesquisa é maior do que qualquer elemento da lista, pelo que a posição de inserção está no final da lista.

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

Observações

Este método usa o comparador Comparer<T>.Default padrão para o tipo T para determinar a ordem dos elementos da lista. A Comparer<T>.Default propriedade verifica se o tipo T implementa a IComparable<T> interface genérica e utiliza essa implementação, se disponível. Se não, Comparer<T>.Default verifica se o tipo T implementa a IComparable interface. Se o tipo T não implementar nenhuma das interfaces, Comparer<T>.Default lança um InvalidOperationException.

O List<T> já deve estar ordenado de acordo com a implementação do comparador; caso contrário, o resultado está incorreto.

A comparação null com qualquer tipo de referência é permitida e não gera exceção ao usar a IComparable<T> interface genérica. Ao ordenar, null considera-se menos do que qualquer outro objeto.

Se o List<T> contiver mais do que um elemento com o mesmo valor, o método devolve apenas uma das ocorrências, e pode devolver qualquer uma das ocorrências, não necessariamente a primeira.

Se o List<T> não contiver o valor especificado, o método devolve um inteiro negativo. Pode aplicar a operação de complemento bit a bit (~) a este inteiro negativo para obter o índice do primeiro elemento maior do que o valor de pesquisa. Ao inserir o valor no List<T>, este índice deve ser usado como ponto de inserção para manter a ordem de ordenação.

Este método é uma operação O(log n), onde n é o número de elementos no intervalo.

Ver também

Aplica-se a

BinarySearch(T, IComparer<T>)

Pesquisa todo o elemento ordenado List<T> usando o comparador especificado e devolve o índice zero do elemento.

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

Parâmetros

item
T

O objeto a localizar. O valor pode ser null para tipos de referência.

comparer
IComparer<T>

A IComparer<T> implementação a usar ao comparar elementos.

-ou-

null para usar o comparador Defaultpadrão .

Devoluções

Int32

O índice baseado em zero de item no ordenado List<T>, se item for encontrado; caso contrário, um número negativo que é o complemento bit a bit do índice do próximo elemento que é maior do item que ou, se não houver elemento maior, o complemento bit a bit de Count.

Exceções

InvalidOperationException

comparer é null, e o comparador Default padrão não consegue encontrar uma implementação da IComparable<T> interface genérica ou da IComparable interface para o tipo T.

Exemplos

O exemplo seguinte demonstra a Sort(IComparer<T>) sobrecarga de métodos e a BinarySearch(T, IComparer<T>) sobrecarga de métodos.

O exemplo define um comparador alternativo para strings chamado DinoCompare, que implementa a interface genérica IComparer<string> (IComparer(Of String) em Visual Basic). O comparador funciona da seguinte forma: Primeiro, os comparandos são testados para null, e uma referência nula é tratada como inferior a uma não-nula. Em segundo lugar, os comprimentos das cordas são comparados, e a corda mais longa é considerada maior. Terceiro, se os comprimentos forem iguais, utiliza-se a comparação de cordas ordinária.

A List<T> de cordas é criado e povoado com quatro cadeias, sem ordem específica. A lista é apresentada, ordenada usando o comparador alternativo e novamente apresentada.

A BinarySearch(T, IComparer<T>) sobrecarga de métodos é então usada para procurar várias cadeias que não estão na lista, empregando o comparador alternativo. O Insert método é usado para inserir as cordas. Estes dois métodos localizam-se na função chamada SearchAndInsert, juntamente com código para tomar o complemento bit a bit (o operador ~ em C#, Xor -1 em Visual Basic) do número negativo devolvido por BinarySearch(T, IComparer<T>) e usá-lo como índice para inserir a nova cadeia.

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

Observações

O comparador personaliza a forma como os elementos são comparados. Por exemplo, pode usar uma CaseInsensitiveComparer instância como comparador para realizar pesquisas de cadeias insensíveis a maiúsculas minúsculas.

Se comparer for fornecido, os elementos de são List<T> comparados ao valor especificado usando a implementação especificada IComparer<T> .

Se comparer for null, o comparador Comparer<T>.Default padrão verifica se o tipo T implementa a IComparable<T> interface genérica e usa essa implementação, se disponível. Se não, Comparer<T>.Default verifica se o tipo T implementa a IComparable interface. Se o tipo T não implementar nenhuma das interfaces, Comparer<T>.Default lança InvalidOperationException.

O List<T> já deve estar ordenado de acordo com a implementação do comparador; caso contrário, o resultado está incorreto.

A comparação null com qualquer tipo de referência é permitida e não gera exceção ao usar a IComparable<T> interface genérica. Ao ordenar, null considera-se menos do que qualquer outro objeto.

Se o List<T> contiver mais do que um elemento com o mesmo valor, o método devolve apenas uma das ocorrências, e pode devolver qualquer uma das ocorrências, não necessariamente a primeira.

Se o List<T> não contiver o valor especificado, o método devolve um inteiro negativo. Pode aplicar a operação de complemento bit a bit (~) a este inteiro negativo para obter o índice do primeiro elemento maior do que o valor de pesquisa. Ao inserir o valor no List<T>, este índice deve ser usado como ponto de inserção para manter a ordem de ordenação.

Este método é uma operação O(log n), onde n é o número de elementos no intervalo.

Ver também

Aplica-se a

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

Pesquisa um intervalo de elementos ordenados List<T> por um elemento usando o comparador especificado e devolve o índice zero do elemento.

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

Parâmetros

index
Int32

O índice inicial baseado em zero do intervalo a pesquisar.

count
Int32

O comprimento do campo de tiro para procurar.

item
T

O objeto a localizar. O valor pode ser null para tipos de referência.

comparer
IComparer<T>

A IComparer<T> implementação a usar ao comparar elementos, ou null ao usar o comparador Defaultpadrão .

Devoluções

Int32

O índice baseado em zero de item no ordenado List<T>, se item for encontrado; caso contrário, um número negativo que é o complemento bit a bit do índice do próximo elemento que é maior do item que ou, se não houver elemento maior, o complemento bit a bit de Count.

Exceções

ArgumentOutOfRangeException

index é inferior a 0.

-ou-

count é inferior a 0.

ArgumentException

index e count não denotam um intervalo válido no List<T>.

InvalidOperationException

comparer é null, e o comparador Default padrão não consegue encontrar uma implementação da IComparable<T> interface genérica ou da IComparable interface para o tipo T.

Exemplos

O exemplo seguinte demonstra a Sort(Int32, Int32, IComparer<T>) sobrecarga de métodos e a BinarySearch(Int32, Int32, T, IComparer<T>) sobrecarga de métodos.

O exemplo define um comparador alternativo para strings chamado DinoCompare, que implementa a interface genérica IComparer<string> (IComparer(Of String) em Visual Basic). O comparador funciona da seguinte forma: Primeiro, os comparandos são testados para null, e uma referência nula é tratada como inferior a uma não-nula. Em segundo lugar, os comprimentos das cordas são comparados, e a corda mais longa é considerada maior. Terceiro, se os comprimentos forem iguais, utiliza-se a comparação de cordas ordinária.

É criado e List<T> povoado com os nomes de cinco dinossauros herbívoros e três dinossauros carnívoros. Dentro de cada um dos dois grupos, os nomes não estão numa ordem específica de sorte. A lista é apresentada, a gama de herbívoros é ordenada usando o comparador alternativo, e a lista é novamente exibida.

O BinarySearch(Int32, Int32, T, IComparer<T>) método de sobrecarga é então usado apenas para procurar "Brachiosaurus" na gama de herbívoros. A cadeia não é encontrada, e o complemento bit a bit (o operador ~ em C#, Xor -1 em Visual Basic) do número negativo devolvido pelo método BinarySearch(Int32, Int32, T, IComparer<T>) é usado como índice para inserir a nova cadeia.

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

Observações

O comparador personaliza a forma como os elementos são comparados. Por exemplo, pode usar uma CaseInsensitiveComparer instância como comparador para realizar pesquisas de cadeias insensíveis a maiúsculas minúsculas.

Se comparer for fornecido, os elementos de são List<T> comparados ao valor especificado usando a implementação especificada IComparer<T> .

Se comparer for null, o comparador Comparer<T>.Default padrão verifica se o tipo T implementa a IComparable<T> interface genérica e usa essa implementação, se disponível. Se não, Comparer<T>.Default verifica se o tipo T implementa a IComparable interface. Se o tipo T não implementar nenhuma das interfaces, Comparer<T>.Default lança InvalidOperationException.

O List<T> já deve estar ordenado de acordo com a implementação do comparador; caso contrário, o resultado está incorreto.

A comparação null com qualquer tipo de referência é permitida e não gera exceção ao usar a IComparable<T> interface genérica. Ao ordenar, null considera-se menos do que qualquer outro objeto.

Se o List<T> contiver mais do que um elemento com o mesmo valor, o método devolve apenas uma das ocorrências, e pode devolver qualquer uma das ocorrências, não necessariamente a primeira.

Se o List<T> não contiver o valor especificado, o método devolve um inteiro negativo. Pode aplicar a operação de complemento bit a bit (~) a este inteiro negativo para obter o índice do primeiro elemento maior do que o valor de pesquisa. Ao inserir o valor no List<T>, este índice deve ser usado como ponto de inserção para manter a ordem de ordenação.

Este método é uma operação O(log n), onde n é o número de elementos no intervalo.

Ver também

Aplica-se a