List<T>.Sort Método

Definição

Namespace:

System.Collections.Generic

Assembly:

System.Collections.dll

Classifica os elementos ou uma parte dos elementos na List<T> usando a implementação IComparer<T> especificada ou padrão, ou um delegado Comparison<T> fornecido para comparar os elementos de lista.

Sobrecargas

Sort(Comparison<T>)	Classifica os elementos em todo o List<T> usando o Comparison<T> especificado.
Sort(Int32, Int32, IComparer<T>)	Classifica os elementos em um intervalo de elementos em List<T> usando o comparador especificado.
Sort()	Classifica os elementos em todo o List<T> usando o comparador padrão.
Sort(IComparer<T>)	Classifica os elementos em todo o List<T> usando o comparador especificado.

Sort(Comparison<T>)

Origem:

List.cs

Classifica os elementos em todo o List<T> usando o Comparison<T> especificado.

C#

public void Sort (Comparison<T> comparison);

Parâmetros

comparison

Comparison<T>

O Comparison<T> a ser usado na comparação de elementos.

Exceções

ArgumentNullException

comparison é null.

ArgumentException

A implementação de comparison causou um erro durante a classificação. Por exemplo, comparison não pode retornar 0 ao comparar um item com ele próprio.

Exemplos

O código a seguir demonstra as sobrecargas de Sort método e Sort em um objeto comercial simples. Chamar o Sort método resulta no uso do comparador padrão para o tipo Part e o Sort método é implementado usando um método anônimo.

C#

using System;
using System.Collections.Generic;
// Simple business object. A PartId is used to identify the type of part
// but the part name can change.
public class Part : IEquatable<Part> , IComparable<Part>
{
    public string PartName { get; set; }

    public int PartId { get; set; }

    public override string ToString()
    {
        return "ID: " + PartId + "   Name: " + PartName;
    }
    public override bool Equals(object obj)
    {
        if (obj == null) return false;
        Part objAsPart = obj as Part;
        if (objAsPart == null) return false;
        else return Equals(objAsPart);
    }
    public int SortByNameAscending(string name1, string name2)
    {

        return name1.CompareTo(name2);
    }

    // Default comparer for Part type.
    public int CompareTo(Part comparePart)
    {
          // A null value means that this object is greater.
        if (comparePart == null)
            return 1;

        else
            return this.PartId.CompareTo(comparePart.PartId);
    }
    public override int GetHashCode()
    {
        return PartId;
    }
    public bool Equals(Part other)
    {
        if (other == null) return false;
        return (this.PartId.Equals(other.PartId));
    }
    // Should also override == and != operators.
}
public class Example
{
    public static void Main()
    {
        // Create a list of parts.
        List<Part> parts = new List<Part>();

        // Add parts to the list.
        parts.Add(new Part() { PartName = "regular seat", PartId = 1434 });
        parts.Add(new Part() { PartName= "crank arm", PartId = 1234 });
        parts.Add(new Part() { PartName = "shift lever", PartId = 1634 }); ;
        // Name intentionally left null.
        parts.Add(new Part() {  PartId = 1334 });
        parts.Add(new Part() { PartName = "banana seat", PartId = 1444 });
        parts.Add(new Part() { PartName = "cassette", PartId = 1534 });

        // Write out the parts in the list. This will call the overridden
        // ToString method in the Part class.
        Console.WriteLine("\nBefore sort:");
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }

        // Call Sort on the list. This will use the
        // default comparer, which is the Compare method
        // implemented on Part.
        parts.Sort();

        Console.WriteLine("\nAfter sort by part number:");
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }

        // This shows calling the Sort(Comparison(T) overload using
        // an anonymous method for the Comparison delegate.
        // This method treats null as the lesser of two values.
        parts.Sort(delegate(Part x, Part y)
        {
            if (x.PartName == null && y.PartName == null) return 0;
            else if (x.PartName == null) return -1;
            else if (y.PartName == null) return 1;
            else return x.PartName.CompareTo(y.PartName);
        });

        Console.WriteLine("\nAfter sort by name:");
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }

        /*

            Before sort:
        ID: 1434   Name: regular seat
        ID: 1234   Name: crank arm
        ID: 1634   Name: shift lever
        ID: 1334   Name:
        ID: 1444   Name: banana seat
        ID: 1534   Name: cassette

        After sort by part number:
        ID: 1234   Name: crank arm
        ID: 1334   Name:
        ID: 1434   Name: regular seat
        ID: 1444   Name: banana seat
        ID: 1534   Name: cassette
        ID: 1634   Name: shift lever

        After sort by name:
        ID: 1334   Name:
        ID: 1444   Name: banana seat
        ID: 1534   Name: cassette
        ID: 1234   Name: crank arm
        ID: 1434   Name: regular seat
        ID: 1634   Name: shift lever

         */
    }
}

O exemplo a seguir demonstra a sobrecarga do Sort(Comparison<T>) método.

O exemplo define um método de comparação alternativo para cadeias de caracteres, chamado CompareDinosByLength. Esse método funciona da seguinte maneira: primeiro, os comparands são testados para nulle uma referência nula é tratada como menor que um não nulo. Em segundo lugar, os comprimentos da cadeia de caracteres são comparados e a cadeia de caracteres mais longa é considerada maior. Em terceiro lugar, se os comprimentos forem iguais, a comparação de cadeia de caracteres comum será usada.

Um List<T> de cadeias de caracteres é criado e preenchido com quatro cadeias de caracteres, em nenhuma ordem específica. A lista também inclui uma cadeia de caracteres vazia e uma referência nula. A lista é exibida, classificada usando um Comparison<T> delegado genérico que representa o CompareDinosByLength método e exibida novamente.

C#

using System;
using System.Collections.Generic;

public class Example
{
    private static int CompareDinosByLength(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 static void Main()
    {
        List<string> dinosaurs = new List<string>();
        dinosaurs.Add("Pachycephalosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("");
        dinosaurs.Add(null);
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");
        Display(dinosaurs);

        Console.WriteLine("\nSort with generic Comparison<string> delegate:");
        dinosaurs.Sort(CompareDinosByLength);
        Display(dinosaurs);
    }

    private static void Display(List<string> list)
    {
        Console.WriteLine();
        foreach( string s in list )
        {
            if (s == null)
                Console.WriteLine("(null)");
            else
                Console.WriteLine("\"{0}\"", s);
        }
    }
}

/* This code example produces the following output:

"Pachycephalosaurus"
"Amargasaurus"
""
(null)
"Mamenchisaurus"
"Deinonychus"

Sort with generic Comparison<string> delegate:

(null)
""
"Deinonychus"
"Amargasaurus"
"Mamenchisaurus"
"Pachycephalosaurus"
 */

Comentários

Se comparison for fornecido, os elementos do List<T> serão classificados usando o método representado pelo delegado.

Se comparison for null, um ArgumentNullException será lançado.

Esse método usa Array.Sort, que aplica a classificação introspectiva da seguinte maneira:

• Se o tamanho da partição for menor ou igual a 16 elementos, ele usará um algoritmo de classificação de inserção

• Se o número de partições exceder 2 log n, em que n é o intervalo da matriz de entrada, ele usará um algoritmo Heapsort .

• Caso contrário, ele usará um algoritmo Quicksort.

Esta implementação realiza uma classificação instável; ou seja, se dois elementos são iguais, a ordem não deve ser preservada. Por outro lado, uma classificação estável preserva a ordem de elementos iguais.

Esse método é uma operação O(n log n), em que n é Count.

Confira também

• Comparison<T>
• Executando operações de cadeia de caracteres Culture-Insensitive em coleções

Sort(Int32, Int32, IComparer<T>)

Origem:

List.cs

Classifica os elementos em um intervalo de elementos em List<T> usando o comparador especificado.

C#

public void Sort (int index, int count, System.Collections.Generic.IComparer<T>? comparer);

Parâmetros

index

Int32

O índice inicial baseado em zero do intervalo a ser classificado.

count

Int32

O tamanho do intervalo a ser classificado.

comparer

IComparer<T>

A implementação IComparer<T> a ser usada na comparação de elementos ou null para usar o comparador padrão Default.

Exceções

ArgumentOutOfRangeException

index é menor que 0.

- ou -

count é menor que 0.

ArgumentException

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

- ou -

A implementação de comparer causou um erro durante a classificação. Por exemplo, comparer não pode retornar 0 ao comparar um item com ele próprio.

InvalidOperationException

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

Exemplos

O exemplo a seguir demonstra a sobrecarga do Sort(Int32, Int32, IComparer<T>) método e a sobrecarga do BinarySearch(Int32, Int32, T, IComparer<T>) método.

O exemplo define um comparador alternativo para cadeias de caracteres denominadas DinoCompare, que implementa a IComparer<string> interface genérica (IComparer(Of String) no Visual Basic, IComparer<String^> no Visual C++). O comparador funciona da seguinte maneira: primeiro, os comparands são testados para nulle uma referência nula é tratada como menor que um não nulo. Em segundo lugar, os comprimentos da cadeia de caracteres são comparados e a cadeia de caracteres mais longa é considerada maior. Em terceiro lugar, se os comprimentos forem iguais, a comparação de cadeia de caracteres comum será usada.

Um List<T> de cadeias de caracteres é criado e preenchido com os nomes de cinco dinossauros herbívoros e três dinossauros carnívoros. Em cada um dos dois grupos, os nomes não estão em nenhuma ordem de classificação específica. A lista é exibida, o intervalo de herbívoros é classificado usando o comparador alternativo e a lista é exibida novamente.

Em BinarySearch(Int32, Int32, T, IComparer<T>) seguida, a sobrecarga do método é usada para pesquisar apenas o intervalo de herbívoros para "Brachisauro". A cadeia de caracteres não foi encontrada e o complemento bit a bit (o operador ~ em C# e Visual C++, Xor -1 no Visual Basic) do número negativo retornado pelo BinarySearch(Int32, Int32, T, IComparer<T>) método é usado como um índice para inserir a nova cadeia de caracteres.

C#

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

Comentários

Se comparer for fornecido, os elementos do List<T> serão classificados usando a implementação especificada IComparer<T> .

Se comparer for null, o comparador Comparer<T>.Default padrão verificará se o tipo T implementa a IComparable<T> interface genérica e usa essa implementação, se disponível. Caso contrário, 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 gerará um InvalidOperationException.

Esse método usa Array.Sort, que aplica a classificação introspectiva da seguinte maneira:

• Se o tamanho da partição for menor ou igual a 16 elementos, ele usará um algoritmo de classificação de inserção

• Se o número de partições exceder 2 log n, em que n é o intervalo da matriz de entrada, ele usará um algoritmo Heapsort .

• Caso contrário, ele usará um algoritmo Quicksort.

Esta implementação realiza uma classificação instável; ou seja, se dois elementos são iguais, a ordem não deve ser preservada. Por outro lado, uma classificação estável preserva a ordem de elementos iguais.

Esse método é uma operação O(n log n), em que n é Count.

Confira também

• Executando operações de cadeia de caracteres Culture-Insensitive em coleções

Sort()

Origem:

List.cs

Classifica os elementos em todo o List<T> usando o comparador padrão.

C#

public void Sort ();

Exceções

InvalidOperationException

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

Exemplos

O exemplo a seguir adiciona alguns nomes a um List<String> objeto , exibe a lista em ordem não classificada, chama o Sort método e exibe a lista classificada.

C#

String[] names = { "Samuel", "Dakota", "Koani", "Saya", "Vanya", "Jody",
                   "Yiska", "Yuma", "Jody", "Nikita" };
var nameList = new List<String>();
nameList.AddRange(names);
Console.WriteLine("List in unsorted order: ");
foreach (var name in nameList)
   Console.Write("   {0}", name);

Console.WriteLine(Environment.NewLine);

nameList.Sort();
Console.WriteLine("List in sorted order: ");
foreach (var name in nameList)
   Console.Write("   {0}", name);

Console.WriteLine();

// The example displays the following output:
//    List in unsorted order:
//       Samuel   Dakota   Koani   Saya   Vanya   Jody   Yiska   Yuma   Jody   Nikita
//
//    List in sorted order:
//       Dakota   Jody   Jody   Koani   Nikita   Samuel   Saya   Vanya   Yiska   Yuma

O código a seguir demonstra as sobrecargas de Sort() método e Sort(Comparison<T>) em um objeto comercial simples. Chamar o Sort() método resulta no uso do comparador padrão para o tipo Part e o Sort(Comparison<T>) método é implementado usando um método anônimo.

C#

using System;
using System.Collections.Generic;
// Simple business object. A PartId is used to identify the type of part
// but the part name can change.
public class Part : IEquatable<Part> , IComparable<Part>
{
    public string PartName { get; set; }

    public int PartId { get; set; }

    public override string ToString()
    {
        return "ID: " + PartId + "   Name: " + PartName;
    }
    public override bool Equals(object obj)
    {
        if (obj == null) return false;
        Part objAsPart = obj as Part;
        if (objAsPart == null) return false;
        else return Equals(objAsPart);
    }
    public int SortByNameAscending(string name1, string name2)
    {

        return name1.CompareTo(name2);
    }

    // Default comparer for Part type.
    public int CompareTo(Part comparePart)
    {
          // A null value means that this object is greater.
        if (comparePart == null)
            return 1;

        else
            return this.PartId.CompareTo(comparePart.PartId);
    }
    public override int GetHashCode()
    {
        return PartId;
    }
    public bool Equals(Part other)
    {
        if (other == null) return false;
        return (this.PartId.Equals(other.PartId));
    }
    // Should also override == and != operators.
}
public class Example
{
    public static void Main()
    {
        // Create a list of parts.
        List<Part> parts = new List<Part>();

        // Add parts to the list.
        parts.Add(new Part() { PartName = "regular seat", PartId = 1434 });
        parts.Add(new Part() { PartName= "crank arm", PartId = 1234 });
        parts.Add(new Part() { PartName = "shift lever", PartId = 1634 }); ;
        // Name intentionally left null.
        parts.Add(new Part() {  PartId = 1334 });
        parts.Add(new Part() { PartName = "banana seat", PartId = 1444 });
        parts.Add(new Part() { PartName = "cassette", PartId = 1534 });

        // Write out the parts in the list. This will call the overridden
        // ToString method in the Part class.
        Console.WriteLine("\nBefore sort:");
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }

        // Call Sort on the list. This will use the
        // default comparer, which is the Compare method
        // implemented on Part.
        parts.Sort();

        Console.WriteLine("\nAfter sort by part number:");
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }

        // This shows calling the Sort(Comparison(T) overload using
        // an anonymous method for the Comparison delegate.
        // This method treats null as the lesser of two values.
        parts.Sort(delegate(Part x, Part y)
        {
            if (x.PartName == null && y.PartName == null) return 0;
            else if (x.PartName == null) return -1;
            else if (y.PartName == null) return 1;
            else return x.PartName.CompareTo(y.PartName);
        });

        Console.WriteLine("\nAfter sort by name:");
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }

        /*

            Before sort:
        ID: 1434   Name: regular seat
        ID: 1234   Name: crank arm
        ID: 1634   Name: shift lever
        ID: 1334   Name:
        ID: 1444   Name: banana seat
        ID: 1534   Name: cassette

        After sort by part number:
        ID: 1234   Name: crank arm
        ID: 1334   Name:
        ID: 1434   Name: regular seat
        ID: 1444   Name: banana seat
        ID: 1534   Name: cassette
        ID: 1634   Name: shift lever

        After sort by name:
        ID: 1334   Name:
        ID: 1444   Name: banana seat
        ID: 1534   Name: cassette
        ID: 1234   Name: crank arm
        ID: 1434   Name: regular seat
        ID: 1634   Name: shift lever

         */
    }
}

O exemplo a seguir demonstra a sobrecarga do Sort() método e a sobrecarga do BinarySearch(T) método. Um List<T> de cadeias de caracteres é criado e preenchido com quatro cadeias de caracteres, em nenhuma ordem específica. A lista é exibida, classificada e exibida novamente.

Em BinarySearch(T) seguida, a sobrecarga do método é usada para pesquisar duas cadeias de caracteres que não estão na lista e o Insert método é usado para inseri-las. O valor retornado do BinarySearch método é negativo em cada caso, porque as cadeias de caracteres não estão na lista. Usar o complemento bit a bit (o operador ~ em C# e Visual C++, Xor -1 no Visual Basic) desse número negativo produz o índice do primeiro elemento na lista que é maior que a cadeia de caracteres de pesquisa e inserir nesse local preserva a ordem de classificação. A segunda cadeia de caracteres de pesquisa é maior que qualquer elemento na lista, portanto, a posição de inserção está no final da lista.

C#

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

Comentários

Esse método usa o comparador Comparer<T>.Default padrão para o tipo T para determinar a ordem dos elementos de lista. A Comparer<T>.Default propriedade verifica se o tipo T implementa a IComparable<T> interface genérica e usa essa implementação, se disponível. Caso contrário, 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 gerará um InvalidOperationException.

Esse método usa o Array.Sort método , que aplica a classificação introspectiva da seguinte maneira:

• Se o tamanho da partição for menor ou igual a 16 elementos, ele usará um algoritmo de classificação de inserção.

• Se o número de partições exceder 2 log n, em que n é o intervalo da matriz de entrada, ele usará um algoritmo Heapsort.

• Caso contrário, ele usará um algoritmo Quicksort.

Esta implementação realiza uma classificação instável; ou seja, se dois elementos são iguais, a ordem não deve ser preservada. Por outro lado, uma classificação estável preserva a ordem de elementos iguais.

Esse método é uma operação O(n log n), em que n é Count.

Confira também

• Executando operações de cadeia de caracteres Culture-Insensitive em coleções

Sort(IComparer<T>)

Origem:

List.cs

Classifica os elementos em todo o List<T> usando o comparador especificado.

C#

public void Sort (System.Collections.Generic.IComparer<T>? comparer);

Parâmetros

comparer

IComparer<T>

A implementação IComparer<T> a ser usada na comparação de elementos ou null para usar o comparador padrão Default.

Exceções

InvalidOperationException

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

ArgumentException

A implementação de comparer causou um erro durante a classificação. Por exemplo, comparer não pode retornar 0 ao comparar um item com ele próprio.

Exemplos

O exemplo a seguir demonstra a sobrecarga do Sort(IComparer<T>) método e a sobrecarga do BinarySearch(T, IComparer<T>) método.

O exemplo define um comparador alternativo para cadeias de caracteres denominadas DinoCompare, que implementa a IComparer<string> interface genérica (IComparer(Of String) no Visual Basic, IComparer<String^> no Visual C++). O comparador funciona da seguinte maneira: primeiro, os comparands são testados para nulle uma referência nula é tratada como menor que um não nulo. Em segundo lugar, os comprimentos da cadeia de caracteres são comparados e a cadeia de caracteres mais longa é considerada maior. Em terceiro lugar, se os comprimentos forem iguais, a comparação de cadeia de caracteres comum será usada.

Um List<T> de cadeias de caracteres é criado e preenchido com quatro cadeias de caracteres, em nenhuma ordem específica. A lista é exibida, classificada usando o comparador alternativo e exibida novamente.

Em BinarySearch(T, IComparer<T>) seguida, a sobrecarga do método é usada para pesquisar várias cadeias de caracteres que não estão na lista, empregando o comparador alternativo. O Insert método é usado para inserir as cadeias de caracteres. Esses dois métodos estão localizados na função chamada SearchAndInsert, juntamente com o código para usar o complemento bit a bit (o operador ~ em C# e Visual C++, Xor -1 no Visual Basic) do número negativo retornado por BinarySearch(T, IComparer<T>) e usá-lo como um índice para inserir a nova cadeia de caracteres.

C#

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

Comentários

Se comparer for fornecido, os elementos do List<T> serão classificados usando a implementação especificada IComparer<T> .

Se comparer for null, o comparador Comparer<T>.Default padrão verificará se o tipo T implementa a IComparable<T> interface genérica e usa essa implementação, se disponível. Caso contrário, 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 gerará um InvalidOperationException.

Esse método usa o Array.Sort método , que aplica a classificação introspectiva da seguinte maneira:

• Se o tamanho da partição for menor ou igual a 16 elementos, ele usará um algoritmo de classificação de inserção.

• Se o número de partições exceder 2 log n, em que n é o intervalo da matriz de entrada, ele usa um algoritmo Heapsort.

• Caso contrário, ele usa um algoritmo Quicksort.

Esta implementação realiza uma classificação instável; ou seja, se dois elementos são iguais, a ordem não deve ser preservada. Por outro lado, uma classificação estável preserva a ordem de elementos iguais.

Esse método é uma operação O(n log n), em que n é Count.

Confira também

• Executando operações de cadeia de caracteres Culture-Insensitive em coleções