List<T>.Sort Méthode

Définition

Espace de noms:

System.Collections.Generic

Assembly:

System.Collections.dll

Trie les éléments ou une partie des éléments dans List<T> à l’aide de l’implémentation IComparer<T> spécifiée ou par défaut ou un délégué Comparison<T> fourni pour comparer les éléments de la liste.

Surcharges

Sort(Comparison<T>)	Trie les éléments dans l'ensemble de List<T> à l'aide du Comparison<T> spécifié.
Sort(Int32, Int32, IComparer<T>)	Trie les éléments dans une plage d'éléments de List<T> à l'aide du comparateur spécifié.
Sort()	Trie les éléments dans l'ensemble de List<T> à l'aide du comparateur par défaut.
Sort(IComparer<T>)	Trie les éléments dans l'ensemble de List<T> à l'aide du comparateur spécifié.

Sort(Comparison<T>)

Source:

List.cs

Trie les éléments dans l'ensemble de List<T> à l'aide du Comparison<T> spécifié.

C#

public void Sort (Comparison<T> comparison);

Paramètres

comparison

Comparison<T>

Comparison<T> à utiliser pendant la comparaison d’éléments.

Exceptions

ArgumentNullException

comparison a la valeur null.

ArgumentException

L’implémentation de comparison a provoqué une erreur pendant le tri. Par exemple, comparison peut ne pas retourner 0 lors de la comparaison d’un élément à lui-même.

Exemples

Le code suivant illustre les surcharges de Sort méthode et Sort sur un objet métier simple. L’appel de la Sort méthode entraîne l’utilisation du comparateur par défaut pour le type Part, et la méthode est implémentée à l’aide Sort d’une méthode anonyme.

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

         */
    }
}

L’exemple suivant illustre la surcharge de méthode Sort(Comparison<T>) .

L’exemple définit une autre méthode de comparaison pour les chaînes, nommée CompareDinosByLength. Cette méthode fonctionne comme suit : Tout d’abord, les comparands sont testés pour null, et une référence null est traitée comme inférieure à une valeur non null. Deuxièmement, les longueurs de chaîne sont comparées, et la chaîne la plus longue est considérée comme plus grande. Troisièmement, si les longueurs sont égales, la comparaison de chaînes ordinaires est utilisée.

Un List<T> de chaînes est créé et rempli avec quatre chaînes, sans ordre particulier. La liste inclut également une chaîne vide et une référence null. La liste est affichée, triée à l’aide d’un Comparison<T> délégué générique représentant la CompareDinosByLength méthode, puis affichée à nouveau.

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

Remarques

Si comparison est fourni, les éléments de sont triés à l’aide List<T> de la méthode représentée par le délégué.

Si comparison a la valeur null, un ArgumentNullException est levée.

Cette méthode utilise Array.Sort, qui applique le tri introspectif comme suit :

• Si la taille de partition est inférieure ou égale à 16 éléments, elle utilise un algorithme de tri d’insertion

• Si le nombre de partitions dépasse 2 log n, où n est la plage du tableau d’entrée, il utilise un algorithme Heapsort .

• Sinon, il utilise un algorithme Quicksort.

Cette implémentation effectue un tri instable ; autrement dit, si deux éléments sont égaux, leur ordre peut ne pas être conservé. En revanche, un tri stable conserve l’ordre des éléments qui sont égaux.

Cette méthode est une opération O(n log n), où n est Count.

Voir aussi

• Comparison<T>
• Exécution d’opérations de chaîne Culture-Insensitive dans des collections

Sort(Int32, Int32, IComparer<T>)

Source:

List.cs

Trie les éléments dans une plage d'éléments de List<T> à l'aide du comparateur spécifié.

C#

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

Paramètres

index

Int32

Index de début de base zéro de la plage à trier.

count

Int32

Longueur de la plage à trier.

comparer

IComparer<T>

Implémentation de IComparer<T> à utiliser pendant la comparaison d'éléments, ou null pour utiliser le comparateur par défaut Default.

Exceptions

ArgumentOutOfRangeException

index est inférieur à 0.

- ou -

count est inférieur à 0.

ArgumentException

index et count ne spécifient pas une plage valide dans le List<T>.

- ou -

L’implémentation de comparer a provoqué une erreur pendant le tri. Par exemple, comparer peut ne pas retourner 0 lors de la comparaison d’un élément à lui-même.

InvalidOperationException

comparer a la valeur null, et le comparateur par défaut Default ne peut pas trouver d’implémentation de l’interface générique IComparable<T> ou de l’interface IComparable pour le type T.

Exemples

L’exemple suivant illustre la surcharge de Sort(Int32, Int32, IComparer<T>) méthode et la surcharge de méthode BinarySearch(Int32, Int32, T, IComparer<T>) .

L’exemple définit un comparateur alternatif pour les chaînes nommé DinoCompare, qui implémente l’interface IComparer<string> générique (IComparer(Of String) en Visual Basic, IComparer<String^> en Visual C++). Le comparateur fonctionne comme suit : Tout d’abord, les comparands sont testés pour null, et une référence null est traitée comme inférieure à une valeur non null. Deuxièmement, les longueurs de chaîne sont comparées, et la chaîne la plus longue est considérée comme plus grande. Troisièmement, si les longueurs sont égales, la comparaison de chaînes ordinaires est utilisée.

Un List<T> de chaînes est créé et rempli avec les noms de cinq dinosaures herbivores et de trois dinosaures carnivores. Dans chacun des deux groupes, les noms ne sont pas dans un ordre de tri particulier. La liste est affichée, la plage d’herbivores est triée à l’aide du comparateur alternatif et la liste est affichée à nouveau.

La BinarySearch(Int32, Int32, T, IComparer<T>) surcharge de méthode est ensuite utilisée pour rechercher « Brachiosaurus » uniquement dans la gamme des herbivores. La chaîne est introuvable et le complément au niveau du bit (l’opérateur ~ en C# et Visual C++, Xor -1 en Visual Basic) du nombre négatif retourné par la BinarySearch(Int32, Int32, T, IComparer<T>) méthode est utilisé comme index pour insérer la nouvelle chaîne.

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

Remarques

Si comparer est fourni, les éléments de sont triés à l’aide List<T> de l’implémentation spécifiée IComparer<T> .

Si comparer a la valeur , le comparateur Comparer<T>.Default par défaut vérifie si le type T implémente l’interface IComparable<T> générique et utilise cette implémentation, si elle est nulldisponible. Si ce n’est pas le cas, Comparer<T>.Default vérifie si le type T implémente l’interface IComparable . Si le type T n’implémente pas l’une ou l’autre interface, Comparer<T>.Default lève un InvalidOperationException.

Cette méthode utilise Array.Sort, qui applique le tri introspectif comme suit :

• Si la taille de partition est inférieure ou égale à 16 éléments, elle utilise un algorithme de tri d’insertion

• Si le nombre de partitions dépasse 2 log n, où n est la plage du tableau d’entrée, il utilise un algorithme Heapsort .

• Sinon, il utilise un algorithme Quicksort.

Cette implémentation effectue un tri instable ; autrement dit, si deux éléments sont égaux, leur ordre peut ne pas être conservé. En revanche, un tri stable conserve l’ordre des éléments qui sont égaux.

Cette méthode est une opération O(n log n), où n est Count.

Voir aussi

• Exécution d’opérations de chaîne Culture-Insensitive dans des collections

Sort()

Source:

List.cs

Trie les éléments dans l'ensemble de List<T> à l'aide du comparateur par défaut.

C#

public void Sort ();

Exceptions

InvalidOperationException

Le comparateur par défaut Default ne peut pas trouver une implémentation de l’interface générique IComparable<T> ou de l’interface IComparable pour le type T.

Exemples

L’exemple suivant ajoute des noms à un List<String> objet, affiche la liste dans un ordre non trié, appelle la Sort méthode, puis affiche la liste triée.

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

Le code suivant illustre les surcharges de Sort() méthode et Sort(Comparison<T>) sur un objet métier simple. L’appel de la Sort() méthode entraîne l’utilisation du comparateur par défaut pour le type Part, et la méthode est implémentée à l’aide Sort(Comparison<T>) d’une méthode anonyme.

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

         */
    }
}

L’exemple suivant illustre la surcharge de Sort() méthode et la surcharge de méthode BinarySearch(T) . Un List<T> de chaînes est créé et rempli avec quatre chaînes, sans ordre particulier. La liste est affichée, triée et affichée à nouveau.

La BinarySearch(T) surcharge de méthode est ensuite utilisée pour rechercher deux chaînes qui ne figurent pas dans la liste, et la Insert méthode est utilisée pour les insérer. La valeur de retour de la BinarySearch méthode est négative dans chaque cas, car les chaînes ne figurent pas dans la liste. Le fait de prendre le complément au niveau du bit (l’opérateur ~ en C# et Visual C++, Xor -1 en Visual Basic) de ce nombre négatif produit l’index du premier élément de la liste qui est plus grand que la chaîne de recherche, et l’insertion à cet emplacement conserve l’ordre de tri. La deuxième chaîne de recherche étant plus grande que n’importe quel élément de la liste, la position d’insertion se trouve à la fin de la liste.

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

Remarques

Cette méthode utilise le comparateur Comparer<T>.Default par défaut pour type T afin de déterminer l’ordre des éléments de liste. La Comparer<T>.Default propriété vérifie si le type T implémente l’interface IComparable<T> générique et utilise cette implémentation, si disponible. Si ce n’est pas le cas, Comparer<T>.Default vérifie si le type T implémente l’interface IComparable . Si le type T n’implémente pas l’une ou l’autre interface, Comparer<T>.Default lève un InvalidOperationException.

Cette méthode utilise la Array.Sort méthode , qui applique le tri introspectif comme suit :

• Si la taille de partition est inférieure ou égale à 16 éléments, elle utilise un algorithme de tri d’insertion.

• Si le nombre de partitions dépasse 2 log n, où n est la plage du tableau d’entrée, il utilise un algorithme Heapsort.

• Sinon, il utilise un algorithme Quicksort.

Cette implémentation effectue un tri instable ; autrement dit, si deux éléments sont égaux, leur ordre peut ne pas être conservé. En revanche, un tri stable conserve l’ordre des éléments qui sont égaux.

Cette méthode est une opération O(n log n), où n est Count.

Voir aussi

• Exécution d’opérations de chaîne Culture-Insensitive dans des collections

Sort(IComparer<T>)

Source:

List.cs

Trie les éléments dans l'ensemble de List<T> à l'aide du comparateur spécifié.

C#

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

Paramètres

comparer

IComparer<T>

Implémentation de IComparer<T> à utiliser pendant la comparaison d'éléments, ou null pour utiliser le comparateur par défaut Default.

Exceptions

InvalidOperationException

comparer a la valeur null, et le comparateur par défaut Default ne peut pas trouver d’implémentation de l’interface générique IComparable<T> ou de l’interface IComparable pour le type T.

ArgumentException

L’implémentation de comparer a provoqué une erreur pendant le tri. Par exemple, comparer peut ne pas retourner 0 lors de la comparaison d’un élément à lui-même.

Exemples

L’exemple suivant illustre la surcharge de Sort(IComparer<T>) méthode et la surcharge de méthode BinarySearch(T, IComparer<T>) .

L’exemple définit un comparateur alternatif pour les chaînes nommé DinoCompare, qui implémente l’interface IComparer<string> générique (IComparer(Of String) en Visual Basic, IComparer<String^> en Visual C++). Le comparateur fonctionne comme suit : Tout d’abord, les comparands sont testés pour null, et une référence null est traitée comme inférieure à une valeur non null. Deuxièmement, les longueurs de chaîne sont comparées, et la chaîne la plus longue est considérée comme plus grande. Troisièmement, si les longueurs sont égales, la comparaison de chaînes ordinaires est utilisée.

Un List<T> de chaînes est créé et rempli avec quatre chaînes, sans ordre particulier. La liste est affichée, triée à l’aide du comparateur de remplacement, puis affichée à nouveau.

La BinarySearch(T, IComparer<T>) surcharge de méthode est ensuite utilisée pour rechercher plusieurs chaînes qui ne figurent pas dans la liste, en utilisant le comparateur de remplacement. La Insert méthode est utilisée pour insérer les chaînes. Ces deux méthodes se trouvent dans la fonction nommée SearchAndInsert, ainsi que le code pour prendre le complément au niveau du bit (l’opérateur ~ en C# et Visual C++, Xor -1 en Visual Basic) du nombre négatif retourné par BinarySearch(T, IComparer<T>) et l’utiliser comme index pour insérer la nouvelle chaîne.

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

Remarques

Si comparer est fourni, les éléments de sont triés à l’aide List<T> de l’implémentation spécifiée IComparer<T> .

Si comparer est null, le comparateur Comparer<T>.Default par défaut vérifie si le type T implémente l’interface IComparable<T> générique et utilise cette implémentation, si disponible. Si ce n’est pas le cas, Comparer<T>.Default vérifie si le type T implémente l’interface IComparable . Si le type T n’implémente pas l’une ou l’autre interface, Comparer<T>.Default lève un InvalidOperationException.

Cette méthode utilise la Array.Sort méthode, qui applique le tri introspectif comme suit :

• Si la taille de partition est inférieure ou égale à 16 éléments, elle utilise un algorithme de tri d’insertion.

• Si le nombre de partitions dépasse 2 log n, où n est la plage du tableau d’entrée, il utilise un algorithme Heapsort.

• Sinon, il utilise un algorithme Quicksort.

Cette implémentation effectue un tri instable ; autrement dit, si deux éléments sont égaux, leur ordre peut ne pas être conservé. En revanche, un tri stable conserve l’ordre des éléments qui sont égaux.

Cette méthode est une opération O(n log n), où n est Count.

Voir aussi

• Exécution d’opérations de chaîne Culture-Insensitive dans des collections