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 (Array, Int32, Int32, IComparer)

 

Data di pubblicazione: novembre 2016

Ordina gli elementi in un intervallo di elementi di un oggetto Array unidimensionale usando l'oggetto IComparer specificato.

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

public static void Sort(
	Array array,
	int index,
	int length,
	IComparer comparer
)

Parametri

array
Type: System.Array

Oggetto Array unidimensionale 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.IComparer

Implementazione IComparer da usare quando si confrontano gli elementi.

-oppure-

null per usare l'implementazione IComparable di ciascun elemento.

Exception Condition
ArgumentNullException

array è null.

RankException

array è multidimensionale.

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 il IComparable interfaccia.

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

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

.NET Framework include predefiniti IComparer implementazioni elencati nella tabella seguente.

Implementazione

Descrizione

System.Collections.CaseInsensitiveComparer

Confronta due oggetti, ma esegue un confronto tra maiuscole e minuscole delle stringhe.

Comparer.Default

Confronta due oggetti utilizzando le convenzioni di ordinamento delle impostazioni cultura correnti.

Comparer.DefaultInvariant

Confronta due oggetti utilizzando le convenzioni di ordinamento delle impostazioni cultura invarianti.

Comparer<T>.Default

Confronta due oggetti di tipo T tramite ordinamento predefinito del tipo.

È anche possibile supportare i confronti personalizzati, fornendo un'istanza personalizzata IComparer implementazione per il comparer parametro. Nell'esempio viene eseguita la definizione di un ReverseComparer classe che inverte l'ordine predefinito per le istanze di un tipo ed esegue il confronto tra maiuscole e minuscole.

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 viene eseguito un ordinamento instabile; vale a dire se due elementi sono uguali, l'ordine potrebbe non essere mantenuto. Al contrario, un ordinamento stabile mantiene l'ordine degli elementi che sono uguali.

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

Note per i chiamanti:

Le versioni precedenti di .NET Framework 4 utilizzato solo l'algoritmo Quicksort. QuickSort identifica gli operatori di confronto non validi in alcune situazioni in cui l'operazione di ordinamento genera un 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 verrà generata un'eccezione, poiché gli algoritmi di ordinamento e heapsort di inserimento non viene rilevano un operatore di confronto non valido. Nella maggior parte, si applica alle matrici con meno di 16 elementi.

Esempio di codice seguente viene illustrato come ordinare i valori in un Array utilizzando l'operatore di confronto predefinito e un operatore di confronto personalizzato che inverte l'ordine. Si noti che il risultato potrebbe variare a seconda di corrente CultureInfo.

using System;
using System.Collections;

public class ReverseComparer : IComparer  
{
   // Call CaseInsensitiveComparer.Compare with the parameters reversed.
   public int Compare(Object x, Object y)  
   {
       return (new CaseInsensitiveComparer()).Compare(y, x );
   }
}

public class Example 
{
   public static void Main()  
   {
      // Create and initialize a new array. 
      String[] words = { "The", "QUICK", "BROWN", "FOX", "jumps", 
                         "over", "the", "lazy", "dog" };
      // Instantiate the reverse comparer.
      IComparer revComparer = new ReverseComparer();

      // Display the values of the array.
      Console.WriteLine( "The original order of elements in the array:" );
      DisplayValues(words);

      // Sort a section of the array using the default comparer.
      Array.Sort(words, 1, 3);
      Console.WriteLine( "After sorting elements 1-3 by using the default comparer:");
      DisplayValues(words);

      // Sort a section of the array using the reverse case-insensitive comparer.
      Array.Sort(words, 1, 3, revComparer);
      Console.WriteLine( "After sorting elements 1-3 by using the reverse case-insensitive comparer:");
      DisplayValues(words);

      // Sort the entire array using the default comparer.
      Array.Sort(words);
      Console.WriteLine( "After sorting the entire array by using the default comparer:");
      DisplayValues(words);

      // Sort the entire array by using the reverse case-insensitive comparer.
      Array.Sort(words, revComparer);
      Console.WriteLine( "After sorting the entire array using the reverse case-insensitive comparer:");
      DisplayValues(words);
   }

   public static void DisplayValues(String[] arr)  
   {
      for ( int i = arr.GetLowerBound(0); i <= arr.GetUpperBound(0);
            i++ )  {
         Console.WriteLine( "   [{0}] : {1}", i, arr[i] );
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//    The original order of elements in the array:
//       [0] : The
//       [1] : QUICK
//       [2] : BROWN
//       [3] : FOX
//       [4] : jumps
//       [5] : over
//       [6] : the
//       [7] : lazy
//       [8] : dog
//    
//    After sorting elements 1-3 by using the default comparer:
//       [0] : The
//       [1] : BROWN
//       [2] : FOX
//       [3] : QUICK
//       [4] : jumps
//       [5] : over
//       [6] : the
//       [7] : lazy
//       [8] : dog
//    
//    After sorting elements 1-3 by using the reverse case-insensitive comparer:
//       [0] : The
//       [1] : QUICK
//       [2] : FOX
//       [3] : BROWN
//       [4] : jumps
//       [5] : over
//       [6] : the
//       [7] : lazy
//       [8] : dog
//    
//    After sorting the entire array by using the default comparer:
//       [0] : BROWN
//       [1] : dog
//       [2] : FOX
//       [3] : jumps
//       [4] : lazy
//       [5] : over
//       [6] : QUICK
//       [7] : the
//       [8] : The
//    
//    After sorting the entire array using the reverse case-insensitive comparer:
//       [0] : the
//       [1] : The
//       [2] : QUICK
//       [3] : over
//       [4] : lazy
//       [5] : jumps
//       [6] : FOX
//       [7] : dog
//       [8] : BROWN    

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 1.1
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: