Exporter (0) Imprimer
Développer tout

Array.Sort, méthode générique (TKey[], TValue[])

Remarque : cette méthode est nouvelle dans le .NET Framework version 2.0.

Trie une paire d'objets Array (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'implémentation de l'interface générique IComparable de chaque clé.

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

public static void Sort<TKey,TValue> (
	TKey[] keys,
	TValue[] items
)
J#  prend en charge l'utilisation de types et de méthodes génériques mais pas la déclaration de nouveaux types et de méthodes génériques.
JScript ne prend pas en charge les types et les méthodes génériques.

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

Array unidimensionnel de base zéro qui contient les clés à trier.

items

Array unidimensionnel de base zéro qui contient les éléments qui correspondent aux clés dans keys, ou référence Null (Nothing en Visual Basic) pour trier uniquement keys.

Type d'exceptionCondition

ArgumentNullException

keys est référence Null (Nothing en Visual Basic).

ArgumentException

items n'est pas référence Null (Nothing en Visual Basic) et la limite inférieure de keys ne correspond pas à la limite inférieure de items.

- ou -

items n'est pas référence Null (Nothing en Visual Basic) et la longueur de keys ne correspond pas à celle de items.

InvalidOperationException

Un ou plusieurs éléments du Arraykeys n'implémentent pas l'interface générique IComparable.

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.

Chaque élément de Arraykeys doit implémenter l'interface générique IComparable afin de pouvoir faire des comparaisons avec toutes les autres clés.

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é. En revanche, une opération de tri stable ne modifie pas l'ordre d'éléments égaux.

En moyenne, cette méthode est une opération O(n log n) où n est le Length de array ; 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(J[],K[]), Sort(J[],K[],IComparer, générique), Sort(J[],K[],Int32,Int32) et Sort(J[],K[],Int32,Int32,IComparer, générique), 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 :

  • La surcharge Sort(J[],K[]) permet de trier les deux tableaux dans l'ordre des noms de dinosaures du premier tableau.

  • La surcharge Sort(J[],K[],IComparer, générique) et une instance de ReverseCompare sont utilisées pour inverser l'ordre de tri des tableaux associés.

  • La surcharge Sort(J[],K[],Int32,Int32) permet de trier les trois derniers éléments des deux tableaux.

  • La surcharge Sort(J[],K[],Int32,Int32,IComparer, générique) permet de trier les trois derniers éléments des deux tableaux dans l'ordre inverse.

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++ infèrent le type du paramètre de type générique à partir du type des deux premiers arguments. Si vous utilisez MSIL Disassembler (Ildasm.exe) 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.
 */

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile pour Pocket PC, Windows Mobile pour Smartphone, Windows Server 2003, Windows XP Édition Media Center, Windows XP Professionnel Édition x64, Windows XP SP2, Windows XP Starter Edition

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

.NET Framework

Prise en charge dans : 2.0

.NET Compact Framework

Prise en charge dans : 2.0

Ajouts de la communauté

AJOUTER
Afficher:
© 2015 Microsoft