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, IComparer)

 

Data di pubblicazione: ottobre 2016

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

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

public static void Sort(
	Array array,
	IComparer comparer
)

Parametri

array
Type: System.Array

Matrice unidimensionale da ordinare.

comparer
Type: System.Collections.IComparer

Implementazione da usare quando si confrontano elementi.

-oppure-

null per usare l'implementazione IComparable di ciascun elemento.

Exception Condition
ArgumentNullException

array è null.

RankException

array è multidimensionale.

InvalidOperationException

comparer è null e uno o più elementi in array non implementano l'interfaccia IComparable.

ArgumentException

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.

Se comparer è null, ogni elemento di array deve implementare il IComparable interfaccia devono essere in grado di eseguire confronti con ogni altro elemento 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 è il Length di array.

.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 utilizzando l'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 consente di invertire l'ordinamento predefinito per le istanze di un tipo ed esegue il confronto tra maiuscole e minuscole.

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.

Nell'esempio seguente Ordina i valori in una stringa di arrayby utilizzando l'operatore di confronto predefinito. Definisce inoltre un oggetto personalizzato IComparer implementazione denominato ReverseComparer che inverte l'ordine predefinito dell'oggetto durante l'esecuzione di un confronto tra stringhe tra maiuscole e minuscole. Si noti che l'output potrebbe variare a seconda delle impostazioni cultura correnti.

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: