Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo Array.Sort<TKey, TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)

 

Data di pubblicazione: novembre 2016

Ordina un intervallo di elementi in una coppia di oggetti Array (uno contenente le chiavi e l'altro contenente gli elementi corrispondenti) in base alle chiavi nel primo oggetto Array usando l'interfaccia generica IComparer<T> specificata.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

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

Parametri

keys
Type: TKey[]

Oggetto Array unidimensionale in base zero che contiene le chiavi da ordinare.

items
Type: TValue[]

Oggetto unidimensionale in base zero Array che contiene gli elementi che corrispondono alle chiavi in keys oppure null per ordinare solo keys.

index
Type: System.Int32

Indice iniziale dell'intervallo da ordinare.

length
Type: System.Int32

Numero di elementi nell'intervallo da ordinare.

comparer
Type: System.Collections.Generic.IComparer<TKey>

Implementazione dell'interfaccia generica IComparer<T> da usare per il confronto fra gli elementi oppure null per usare l'implementazione dell'interfaccia generica IComparable<T> di ciascun elemento.

Parametri tipo

TKey

Tipo degli elementi della matrice delle chiavi.

TValue

Tipo degli elementi della matrice degli elementi.

Exception Condition
ArgumentNullException

keys è null.

ArgumentOutOfRangeException

index è minore del limite inferiore di keys.

-oppure-

length è minore di zero.

ArgumentException

items non è null e il limite inferiore di keys non corrisponde al limite inferiore di items.

-oppure-

items non è null e la lunghezza di keys è maggiore della lunghezza di items.

-oppure-

index e length non specificano un intervallo valido in keysArray.

-oppure-

items non è null, e index e length non specificano un intervallo valido in itemsArray.

-oppure-

L'implementazione di comparer ha causato un errore durante l'ordinamento. Ad esempio, comparer potrebbe non restituire 0 quando si confronta un elemento con se stesso.

InvalidOperationException

comparer è null e uno o più elementi nell'oggetto Array di keys non implementano l'interfaccia generica IComparable<T>.

Ogni chiave di keysArray dispone di un elemento corrispondente itemsArray. Quando una chiave viene riposizionata durante l'ordinamento, l'elemento corrispondente nella itemsArray viene riposizionato in modo analogo. Pertanto, il itemsArray viene ordinato in base la disposizione delle chiavi corrispondenti nel keysArray.

Se comparer è null, ogni chiave all'interno dell'intervallo specificato di elementi di keysArray deve implementare il IComparable<T> interfaccia generica per essere in grado di eseguire confronti con ogni altra chiave.

È possibile ordinare se sono presenti più elementi di chiavi, ma non saranno ordinati gli elementi che non dispongono di alcuna chiave corrispondente. Se sono presenti più chiavi di elementi; non è possibile ordinare in caso contrario viene generata una ArgumentException.

Se l'ordinamento non è stato completato correttamente, i risultati sono indefiniti.

Questo metodo utilizza l'algoritmo di ordinamento interiorizzata (introsort) come segue:

  • Se la dimensione della partizione è inferiore a 16 elementi, viene utilizzato un insertion sort algoritmo.

  • Se il numero di partizioni superiore a 2 * LogN, dove N è l'intervallo della matrice di input, viene utilizzato un Heapsort algoritmo.

  • In caso contrario, viene utilizzato un Quicksort algoritmo.

Questa implementazione esegue un ordinamento instabile; ovvero, se due elementi sono uguali, l'ordine potrebbe non essere mantenuta. Al contrario, un ordinamento stabile mantiene l'ordine degli elementi che sono uguali.

Per le matrici vengono ordinate utilizzando gli algoritmi Heapsort e Quicksort, nel peggiore dei casi, questo metodo è un'operazione O (n log n) operazione, in cui n è length.

Note per i chiamanti:

Il .NET Framework 4 e versioni precedenti utilizzato solo l'algoritmo Quicksort. QuickSort identifica gli operatori di confronto non validi in alcune situazioni in cui l'operazione di ordinamento genera una IndexOutOfRangeException eccezione e genera un ArgumentException eccezione al chiamante. A partire dal .NET Framework 4.5, è possibile che le operazioni di ordinamento che in precedenza ha generato ArgumentException non genererà un'eccezione, poiché gli algoritmi di ordinamento e heapsort di inserimento non viene rilevano un operatore di confronto non valido. La maggior parte, si applica alle matrici con un massimo di 16 elementi.

L'esempio di codice seguente illustra il Sort<TKey, TValue>(TKey[], TValue[]), Sort<TKey, TValue>(TKey[], TValue[], IComparer<TKey>), Sort<TKey, TValue>(TKey[], TValue[], Int32, Int32), e Sort<TKey, TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) overload di metodo generico, per l'ordinamento di coppie di matrici che rappresentano le chiavi e valori.

L'esempio di codice definisce un operatore di confronto alternativo per le stringhe, denominato ReverseCompare, che implementa il IComparer<string>(IComparer(Of String) in Visual Basic IComparer<String^> in Visual C++) dell'interfaccia generica. Operatore di confronto chiama il CompareTo(String) metodo, invertendo l'ordine dei termini del confronto in modo che l'ordinamento delle stringhe alto verso il basso, anziché basso verso l'alto.

L'esempio di codice crea e visualizza una matrice di nomi di dinosauro (chiavi) e una matrice di interi che rappresenta la lunghezza massima di ciascun dinosauro espressa in metri (valori). Le matrici vengono ordinate e visualizzate più volte:

System_CAPS_noteNota

Le chiamate ai metodi generici non presenta alcuna differenza dalle chiamate alle controparti non generiche, perché Visual Basic, c# e C++ dedurre il tipo di parametro di tipo generico dal tipo dei primi due argomenti. Se si utilizza il Ildasm.exe (IL Disassembler) per esaminare il Microsoft intermediate language (MSIL), si noterà che vengono chiamati i metodi generici.

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

Universal Windows Platform
Disponibile da 10
.NET Framework
Disponibile da 2.0
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Torna all'inizio
Mostra: