Sort(TKey, TValue), méthode (TKey[], TValue[], Int32, Int32, IComparer(TKey))
Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez aussi afficher la version anglaise dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte.
Traduction
Anglais

Array.Sort<TKey, TValue>, méthode (TKey[], TValue[], Int32, Int32, IComparer<TKey>)

Trie une plage d'éléments dans une paire d'objets Array unidimensionnels (l'un contient les clés et l'autre, les éléments correspondants) en fonction des clés du premier Array à l'aide de l'interface générique IComparer<T> spécifiée.

Espace de noms :  System
Assembly :  mscorlib (dans mscorlib.dll)

public static void Sort<TKey, TValue>(
	TKey[] keys,
	TValue[] items,
	int index,
	int length,
	IComparer<TKey> comparer
)

Paramètres de type

TKey

Type des éléments du tableau des clés.

TValue

Type des éléments du tableau des éléments.

Paramètres

keys
Type : TKey[]
Array unidimensionnel de base zéro qui contient les clés à trier.
items
Type : TValue[]
Array unidimensionnel de base zéro qui contient les éléments qui correspondent aux clés dans keys, ou null pour trier uniquement keys.
index
Type : System.Int32
Index de départ de la plage à trier.
length
Type : System.Int32
Nombre d'éléments à trier dans la plage.
comparer
Type : System.Collections.Generic.IComparer<TKey>
Implémentation de l'interface générique IComparer<T> à utiliser lors de la comparaison d'éléments, ou null pour utiliser l'implémentation de l'interface générique IComparable<T> de chaque élément.

ExceptionCondition
ArgumentNullException

keys est null.

ArgumentOutOfRangeException

index est inférieur à la limite inférieure de keys.

ou

length est inférieur à zéro.

ArgumentException

items n'est pas null et la limite inférieure de keys ne correspond pas à la limite inférieure de items.

ou

items n'est pas null et la longueur de keys est supérieure à celle de items.

ou

index et length ne spécifient pas une plage valide dans Arraykeys.

ou

items n'est pas null et index et length ne spécifient pas une plage valide dans Arrayitems.

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 est null et un ou plusieurs éléments du Arraykeys n'implémentent pas l'interface générique IComparable<T>.

Chaque clé du Arraykeys possède un élément correspondant dans le Arrayitems. Si une clé est repositionnée pendant le tri, l'élément correspondant dans le Arrayitems est repositionné de manière similaire. Par conséquent, le Arrayitems est trié selon la disposition des clés correspondantes dans le Arraykeys.

Si comparer est null, chaque clé de la plage d'éléments spécifiée du Arraykeys doit implémenter l'interface IComparable<T> afin de pouvoir faire des comparaisons avec toutes les autres clés.

Vous pouvez trier s'il y a davantage d'éléments que de clés, mais les éléments qui n'ont pas de clé correspondante ne seront pas triés. Vous ne pouvez pas trier s'il y a davantage de clés que d'éléments ; cela lèverait une ArgumentException.

Si le tri a échoué, les résultats ne sont pas définis.

Cette méthode utilise l'algorithme QuickSort. Cette implémentation effectue un tri instable ; autrement dit, lorsque deux éléments sont égaux, leur ordre risque de ne pas être respecté. Au contraire, un tri stable conserve l'ordre des éléments qui sont égaux.

En moyenne, cette méthode est une opération O(n log n) où n est length ; dans le pire des cas, c'est une opération O(n ^ 2).

L'exemple de code suivant illustre les surcharges des méthodes génériques Sort<TKey, TValue>(TKey[], TValue[]), Sort<TKey, TValue>(TKey[], TValue[], IComparer<TKey>), Sort<TKey, TValue>(TKey[], TValue[], Int32, Int32) et Sort<TKey, TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>), pour le tri de paires de tableaux représentant des clés et des valeurs.

Pour les chaînes nommées ReverseCompare, l'exemple de code définit un autre comparateur, qui implémente l'interface générique IComparer<string> (IComparer(Of String) en Visual Basic, IComparer<String^> en Visual C++). Le comparateur appelle la méthode CompareTo(String), inversant ainsi l'ordre des comparateurs afin que les chaînes soient triées de haut en bas au lieu de bas en haut.

L'exemple de code crée et affiche un tableau de noms de dinosaures (les clés) et un tableau d'entiers représentant la longueur maximale de chaque dinosaure en mètres (les valeurs). Les tableaux sont ensuite triés et affichés plusieurs fois :

RemarqueRemarque

Les appels aux méthodes génériques sont identiques aux appels aux méthodes non génériques, car Visual Basic, C# et C++ déduisent le type du paramètre de type générique à partir du type des deux premiers arguments. Si vous utilisez le Ildasm.exe (Désassembleur MSIL) pour examiner le langage MSIL (Microsoft Intermediate Language), vous pouvez constater que les méthodes génériques sont appelées.


using System;
using System.Collections.Generic;

public class ReverseComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        // Compare y and x in reverse order.
        return y.CompareTo(x);
    }
}

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = {
            "Seismosaurus", 
            "Chasmosaurus", 
            "Coelophysis", 
            "Mamenchisaurus", 
            "Caudipteryx", 
            "Cetiosaurus"  };

        int[] dinosaurSizes = { 40, 5, 3, 22, 1, 18 };

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes)");
        Array.Sort(dinosaurs, dinosaurSizes);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        ReverseComparer rc = new ReverseComparer();

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes, rc)");
        Array.Sort(dinosaurs, dinosaurSizes, rc);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes, 3, 3)");
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes, 3, 3, rc)");
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3, rc);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }
    }
}

/* This code example produces the following output:

Seismosaurus: up to 40 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.

Sort(dinosaurs, dinosaurSizes)

Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Seismosaurus: up to 40 meters long.

Sort(dinosaurs, dinosaurSizes, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.
 */


.NET Framework

Pris en charge dans : 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Windows 7, Windows Vista SP1 ou ultérieur, Windows XP SP3, Windows XP SP2 Édition x64, Windows Server 2008 (installation minimale non prise en charge), Windows Server 2008 R2 (installation minimale prise en charge avec SP1 ou version ultérieure), Windows Server 2003 SP2

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Ajouts de la communauté

AJOUTER
Afficher:
© 2016 Microsoft