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<T>(T[], Int32, Int32, IComparer<T>)

 

Data di pubblicazione: ottobre 2016

Ordina un intervallo di elementi di un oggetto Array usando l'interfaccia generica IComparer<T> specificata.

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

public static void Sort<T>(
	T[] array,
	int index,
	int length,
	IComparer<T> comparer
)

Parametri

array
Type: T[]

Oggetto Array unidimensionale e in base zero da ordinare.

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<T>

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

T

Tipo degli elementi della matrice.

Exception Condition
ArgumentNullException

array è null.

ArgumentOutOfRangeException

index è minore del limite inferiore di array.

-oppure-

length è minore di zero.

ArgumentException

index e length non specificano un intervallo valido in array.

-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 in array non implementano l'interfaccia generica di IComparable<T>.

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

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<T>(T[], Int32, Int32) overload del metodo generico e Sort<TKey, TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) overload del metodo generico per l'ordinamento di un intervallo in una matrice.

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, costituito da tre erbivori seguiti da tre carnivori (precisa tyrannosaurids). Il Sort<T>(T[], Int32, Int32) overload del metodo generico viene utilizzato per ordinare gli ultimi tre elementi della matrice, che viene quindi visualizzato. Il Sort<TKey, TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) overload di metodo generico viene utilizzato con ReverseCompare per ordinare gli ultimi tre elementi in ordine inverso. I dinosauri non vengono visualizzati nuovamente.

System_CAPS_noteNota

Le chiamate al Sort<T>(T[], IComparer<T>) e BinarySearch<T>(T[], T, IComparer<T>) 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 del primo argomento. 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 = {"Pachycephalosaurus", 
                              "Amargasaurus", 
                              "Mamenchisaurus", 
                              "Tarbosaurus",
                              "Tyrannosaurus", 
                              "Albertasaurus"};

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

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

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        ReverseComparer rc = new ReverseComparer();

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

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Tarbosaurus
Tyrannosaurus
Albertasaurus

Sort(dinosaurs, 3, 3)

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Albertasaurus
Tarbosaurus
Tyrannosaurus

Sort(dinosaurs, 3, 3, rc)

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Tyrannosaurus
Tarbosaurus
Albertasaurus
 */

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 2.0
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: