Array.Sort Array.Sort Array.Sort Array.Sort Method

Definition

Sortiert die Elemente in einem eindimensionalen Array. Sorts the elements in a one-dimensional array.

Überlädt

Sort(Array, Int32, Int32, IComparer) Sort(Array, Int32, Int32, IComparer) Sort(Array, Int32, Int32, IComparer)

Sortiert die Elemente in einem Bereich von Elementen in einem eindimensionalen Array mithilfe dem angegebenen IComparer. Sorts the elements in a range of elements in a one-dimensional Array using the specified IComparer.

Sort(Array, Array, Int32, Int32, IComparer) Sort(Array, Array, Int32, Int32, IComparer) Sort(Array, Array, Int32, Int32, IComparer) Sort(Array, Array, Int32, Int32, IComparer)

Sortiert einen Bereich von Elementen in einem Paar von eindimensionalen Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei den angegebenen IComparer. Sorts a range of elements in a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer.

Sort(Array, Int32, Int32) Sort(Array, Int32, Int32) Sort(Array, Int32, Int32)

Sortiert die Elemente in einem Bereich von Elementen in einem eindimensionalen Array mithilfe der IComparable-Implementierung jedes Elements des Array. Sorts the elements in a range of elements in a one-dimensional Array using the IComparable implementation of each element of the Array.

Sort(Array, Array, Int32, Int32) Sort(Array, Array, Int32, Int32) Sort(Array, Array, Int32, Int32) Sort(Array, Array, Int32, Int32)

Sortiert einen Bereich von Elementen in einem Paar von eindimensionalen Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei die IComparable-Implementierung jedes Schlüssels. Sorts a range of elements in a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable implementation of each key.

Sort(Array, IComparer) Sort(Array, IComparer) Sort(Array, IComparer)

Sortiert die Elemente in einem eindimensionalen Array mithilfe des angegebenen IComparer. Sorts the elements in a one-dimensional Array using the specified IComparer.

Sort(Array, Array, IComparer) Sort(Array, Array, IComparer) Sort(Array, Array, IComparer) Sort(Array, Array, IComparer)

Sortiert ein Paar von eindimensionalen Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei den angegebenen IComparer. Sorts a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer.

Sort(Array, Array) Sort(Array, Array) Sort(Array, Array) Sort(Array, Array)

Sortiert ein Paar von eindimensionalen Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei die IComparable-Implementierung jedes Schlüssels. Sorts a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable implementation of each key.

Sort(Array) Sort(Array) Sort(Array)

Sortiert die Elemente in einem ganzen eindimensionalen Array mithilfe der IComparable-Implementierung jedes Elements des Array. Sorts the elements in an entire one-dimensional Array using the IComparable implementation of each element of the Array.

Sort<T>(T[]) Sort<T>(T[]) Sort<T>(T[]) Sort<T>(T[])

Sortiert die Elemente in einem ganzen Array mithilfe der Implementierung der generischen IComparable<T>-Schnittstelle jedes Elements des Array. Sorts the elements in an entire Array using the IComparable<T> generic interface implementation of each element of the Array.

Sort<T>(T[], IComparer<T>) Sort<T>(T[], IComparer<T>) Sort<T>(T[], IComparer<T>) Sort<T>(T[], IComparer<T>)

Sortiert die Elementen in einem Array mit der angegebenen generischen IComparer<T>-Schnittstelle. Sorts the elements in an Array using the specified IComparer<T> generic interface.

Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>)

Sortiert die Elemente in einem Array mithilfe der angegebenen Comparison<T>. Sorts the elements in an Array using the specified Comparison<T>.

Sort<T>(T[], Int32, Int32) Sort<T>(T[], Int32, Int32) Sort<T>(T[], Int32, Int32) Sort<T>(T[], Int32, Int32)

Sortiert die Elemente in einem Bereich von Elementen in einem Array mithilfe der Implementierung der generischen IComparable<T>-Schnittstelle jedes Elements des Array. Sorts the elements in a range of elements in an Array using the IComparable<T> generic interface implementation of each element of the Array.

Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>)

Sortiert die Elemente in einem Bereich von Elementen in der Array mithilfe der angegebenen generischen IComparer<T>-Schnittstelle. Sorts the elements in a range of elements in an Array using the specified IComparer<T> generic interface.

Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[])

Sortiert ein Paar von Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei die Implementierung der generischen IComparable<T>-Schnittstelle jedes Schlüssels. Sorts a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable<T> generic interface implementation of each key.

Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>)

Sortiert ein Paar von Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei die angegebene generische IComparer<T>-Schnittstelle. Sorts a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer<T> generic interface.

Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)

Sortiert einen Bereich von Elementen in einem Paar von Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei die Implementierung der generischen IComparable<T>-Schnittstelle jedes Schlüssels. Sorts a range of elements in a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable<T> generic interface implementation of each key.

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

Sortiert einen Bereich von Elementen in einem Paar von Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei die angegebene generische IComparer<T>-Schnittstelle. Sorts a range of elements in a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer<T> generic interface.

Sort(Array, Int32, Int32, IComparer) Sort(Array, Int32, Int32, IComparer) Sort(Array, Int32, Int32, IComparer)

Sortiert die Elemente in einem Bereich von Elementen in einem eindimensionalen Array mithilfe dem angegebenen IComparer. Sorts the elements in a range of elements in a one-dimensional Array using the specified IComparer.

public:
 static void Sort(Array ^ array, int index, int length, System::Collections::IComparer ^ comparer);
public static void Sort (Array array, int index, int length, System.Collections.IComparer comparer);
static member Sort : Array * int * int * System.Collections.IComparer -> unit
Parameter
array
Array Array Array Array

Das zu sortierende eindimensionale Array. The one-dimensional Array to sort.

index
Int32 Int32 Int32 Int32

Der Startindex des zu sortierenden Bereichs. The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Die Anzahl der Elemente im zu sortierenden Bereich. The number of elements in the range to sort.

comparer
IComparer IComparer IComparer IComparer

Die IComparer-Implementierung, die beim Vergleich von Elementen verwendet werden soll. The IComparer implementation to use when comparing elements. - oder - -or- null, wenn die IComparable-Implementierung des jeweiligen Elements verwendet werden soll. null to use the IComparable implementation of each element.

Ausnahmen

array ist mehrdimensional. array is multidimensional.

index ist kleiner als die untere array-Grenze. index is less than the lower bound of array. - oder - -or- length ist kleiner als Null. length is less than zero.

index und length geben keinen gültigen Bereich im array an. index and length do not specify a valid range in array. - oder - -or- Die Implementierung von comparer hat einen Fehler während der Sortierung verursacht. The implementation of comparer caused an error during the sort. Beispielsweise gibt comparer beim Vergleichen eines Elements mit sich selbst möglicherweise nicht 0 zurück. For example, comparer might not return 0 when comparing an item with itself.

comparer ist null, und mindestens ein Element in array implementiert die IComparable-Schnittstelle nicht. comparer is null, and one or more elements in array do not implement the IComparable interface.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie zum Sortieren der Werte in einer Array mithilfe des Standardvergleichs und einem benutzerdefinierten Vergleich, der die Sortierreihenfolge umgekehrt.The following code example shows how to sort the values in an Array using the default comparer and a custom comparer that reverses the sort order. Beachten Sie, die das Ergebnis, abhängig vom aktuellen variieren kann CultureInfo.Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

public ref class ReverseComparer : IComparer
{
public:
   // Call CaseInsensitiveComparer::Compare with the parameters reversed.
   virtual int Compare(Object^ x, Object^ y) = IComparer::Compare
   {
      return ((gcnew CaseInsensitiveComparer)->Compare(y, x));
   }
};

void DisplayValues(array<String^>^ arr)
{
   for (int i = arr->GetLowerBound(0); i <= arr->GetUpperBound(0); i++)
      Console::WriteLine( "   [{0}] : {1}", i, arr[ i ] );

   Console::WriteLine();
}

int main()
{
   // Create and initialize a new array. and a new custom comparer.
   array<String^>^ words = { "The","QUICK","BROWN","FOX","jumps",
                             "over","the","lazy","dog" };
   // Instantiate the reverse comparer.
   IComparer^ revComparer = gcnew 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);
}

/* 
This code produces the following output.

The Array initially contains the following values:
   [0] : The
   [1] : QUICK
   [2] : BROWN
   [3] : FOX
   [4] : jumps
   [5] : over
   [6] : the
   [7] : lazy
   [8] : dog

After sorting a section of the Array using the default comparer:
   [0] : The
   [1] : BROWN
   [2] : FOX
   [3] : QUICK
   [4] : jumps
   [5] : over
   [6] : the
   [7] : lazy
   [8] : dog

After sorting a section of the Array 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 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

*/
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    
Imports System.Collections

Public Class ReverseComparer : Implements IComparer
   ' Call CaseInsensitiveComparer.Compare with the parameters reversed.
   Function Compare(x As Object, y As Object) As Integer _
            Implements IComparer.Compare
      Return New CaseInsensitiveComparer().Compare(y, x)
   End Function 
End Class

Public Module Example
   Public Sub Main()
      ' Create and initialize a new array.
      Dim words() As String =  { "The", "QUICK", "BROWN", "FOX", "jumps", 
                                 "over", "the", "lazy", "dog" }
      ' Instantiate a new custom comparer.
      Dim revComparer As 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)
   End Sub 

   Public Sub DisplayValues(arr() As String)
      For i As Integer = arr.GetLowerBound(0) To arr.GetUpperBound(0)
         Console.WriteLine("   [{0}] : {1}", i, arr(i))
      Next 
      Console.WriteLine()
   End Sub 
End Module 
' 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

Hinweise

Wenn comparer ist null, jedes Element innerhalb des angegebenen Bereichs von Elementen in array müssen implementieren die IComparable Schnittstelle kann Vergleiche mit jedem anderen Element im array.If comparer is null, each element within the specified range of elements in array must implement the IComparable interface to be capable of comparisons with every other element in array.

Wenn die Sortierung nicht erfolgreich abgeschlossen wird, sind die Ergebnisse nicht definiert.If the sort is not successfully completed, the results are undefined.

.NET Framework enthält vordefinierte IComparer Implementierungen in der folgenden Tabelle aufgeführt.The .NET Framework includes predefined IComparer implementations listed in the following table.

ImplementierungImplementation Beschreibung Description
System.Collections.CaseInsensitiveComparer Vergleicht zwei Objekte, jedoch führt einen Vergleich Groß-/Kleinschreibung von Zeichenfolgen.Compares any two objects, but performs a case-insensitive comparison of strings.
Comparer.Default Vergleicht zwei Objekte mithilfe der Sortierkonventionen der aktuellen Kultur.Compares any two objects by using the sorting conventions of the current culture.
Comparer.DefaultInvariant Vergleicht zwei Objekte mithilfe der Sortierkonventionen der invarianten Kultur.Compares any two objects by using the sorting conventions of the invariant culture.
Comparer<T>.Default Vergleicht zwei Objekte des Typs T mithilfe von Standard-Sortierreihenfolge des Typs.Compares two objects of type T by using the type's default sort order.

Sie können auch benutzerdefinierte Vergleiche unterstützen, durch die Bereitstellung einer Instanz Ihrer eigenen IComparer Implementierung, die die comparer Parameter.You can also support custom comparisons by providing an instance of your own IComparer implementation to the comparer parameter. Durch die Definition wird im Beispiel eine ReverseComparer -Klasse, die die Standardsortierreihenfolge für kehrt Instanzen eines Typs und führt die Groß-/Kleinschreibung Zeichenfolgenvergleich.The example does this by defining a ReverseComparer class that reverses the default sort order for instances of a type and performs case-insensitive string comparison.

Diese Methode verwendet die Beobachtung der inneren Abläufe Sortieralgorithmus (Introsort) wie folgt aus:This method uses the introspective sort (introsort) algorithm as follows:

  • Wenn die Größe der Partition weniger als 16 Elementen ist, wird ein Einfügesortierung Algorithmus.If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Überschreitet die Anzahl der Partitionen 2 * LogN, wobei N ist der Bereich des Eingabearrays, er verwendet eine Heapsort Algorithmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • Andernfalls verwendet es, eine Quicksort Algorithmus.Otherwise, it uses a Quicksort algorithm.

Diese Implementierung führt eine instabile Sortierung. d.h., wenn zwei Elemente gleich sind, möglicherweise die Reihenfolge nicht beibehalten.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Im Gegensatz dazu behält eine stabile Sortierung, die Reihenfolge der Elemente, die gleich sind.In contrast, a stable sort preserves the order of elements that are equal.

Für Arrays, die mithilfe von Algorithmen Heapsort und wenden die Schnellsortierung im schlimmsten Fall sortiert sind, ist diese Methode eine O (n Log n)-Vorgang, in denen n ist length.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is length.

Hinweise für Aufrufer

Die .NET Framework 4 und früheren Versionen verwendet nur den Quicksort-Algorithmus. The .NET Framework 4 and earlier versions used only the Quicksort algorithm. QuickSort identifiziert die ungültige Vergleiche in einigen Situationen, in dem der Sortiervorgang löst, eine IndexOutOfRangeException -Ausnahme aus, und löst eine ArgumentException Ausnahme an den Aufrufer. Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Beginnend mit der .NET Framework 4.5.NET Framework 4.5, es ist möglich, dass ausgelöst, das zuvor Sortiervorgänge hat ArgumentException wird keine Ausnahme, da die Einfügung sortieren und Heapsort Algorithmen eine ungültige Vergleich nicht erkennen. Starting with the .NET Framework 4.5.NET Framework 4.5, it is possible that sorting operations that previously threw ArgumentException will not throw an exception, because the insertion sort and heapsort algorithms do not detect an invalid comparer. Zum größten Teil, gilt dies für Arrays mit weniger als 16 Elementen. For the most part, this applies to arrays with fewer than 16 elements.

Siehe auch

Sort(Array, Array, Int32, Int32, IComparer) Sort(Array, Array, Int32, Int32, IComparer) Sort(Array, Array, Int32, Int32, IComparer) Sort(Array, Array, Int32, Int32, IComparer)

Sortiert einen Bereich von Elementen in einem Paar von eindimensionalen Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei den angegebenen IComparer. Sorts a range of elements in a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer.

public:
 static void Sort(Array ^ keys, Array ^ items, int index, int length, System::Collections::IComparer ^ comparer);
public static void Sort (Array keys, Array items, int index, int length, System.Collections.IComparer comparer);
static member Sort : Array * Array * int * int * System.Collections.IComparer -> unit
Public Shared Sub Sort (keys As Array, items As Array, index As Integer, length As Integer, comparer As IComparer)
Parameter
keys
Array Array Array Array

Das eindimensionale Array mit den zu sortierenden Schlüsseln. The one-dimensional Array that contains the keys to sort.

items
Array Array Array Array

Das eindimensionale Array mit den Elementen, die den jeweiligen Schlüsseln im keysArray entsprechen. The one-dimensional Array that contains the items that correspond to each of the keys in the keysArray. - oder - -or- null, wenn nur das keysArray sortiert werden soll. null to sort only the keysArray.

index
Int32 Int32 Int32 Int32

Der Startindex des zu sortierenden Bereichs. The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Die Anzahl der Elemente im zu sortierenden Bereich. The number of elements in the range to sort.

comparer
IComparer IComparer IComparer IComparer

Die IComparer-Implementierung, die beim Vergleich von Elementen verwendet werden soll. The IComparer implementation to use when comparing elements. - oder - -or- null, wenn die IComparable-Implementierung des jeweiligen Elements verwendet werden soll. null to use the IComparable implementation of each element.

Ausnahmen

Das keysArray ist mehrdimensional. The keysArray is multidimensional. - oder - -or- Das itemsArray ist mehrdimensional. The itemsArray is multidimensional.

index ist kleiner als die untere keys-Grenze. index is less than the lower bound of keys. - oder - -or- length ist kleiner als Null. length is less than zero.

items ist nicht null, und die untere Grenze von keys entspricht nicht der unteren Grenze von items. items is not null, and the lower bound of keys does not match the lower bound of items. - oder - -or- items ist nicht null, und die Länge von keys ist größer als die Länge von items. items is not null, and the length of keys is greater than the length of items. - oder - -or- index und length geben keinen gültigen Bereich im keysArray an. index and length do not specify a valid range in the keysArray. - oder - -or- items ist nicht null, und index und length geben keinen gültigen Bereich im itemsArray an. items is not null, and index and length do not specify a valid range in the itemsArray. - oder - -or- Die Implementierung von comparer hat einen Fehler während der Sortierung verursacht. The implementation of comparer caused an error during the sort. Beispielsweise gibt comparer beim Vergleichen eines Elements mit sich selbst möglicherweise nicht 0 zurück. For example, comparer might not return 0 when comparing an item with itself.

comparer ist null, und mindestens ein Element im keysArray implementiert die IComparable-Schnittstelle nicht. comparer is null, and one or more elements in the keysArray do not implement the IComparable interface.

Beispiele

Im folgenden Codebeispiel wird das Sortieren von zwei verknüpften Arrays, in dem das erste Array enthält die Schlüssel und das zweite Array enthält die Werte, veranschaulicht.The following code example shows how to sort two associated arrays where the first array contains the keys and the second array contains the values. Sortierungen erfolgen mithilfe des Standardvergleichs und einem benutzerdefinierten Vergleich, der die Sortierreihenfolge umgekehrt.Sorts are done using the default comparer and a custom comparer that reverses the sort order. Beachten Sie, die das Ergebnis, abhängig vom aktuellen variieren kann CultureInfo.Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

public ref class myReverserClass: public IComparer
{
private:

   // Calls CaseInsensitiveComparer::Compare with the parameters reversed.
   virtual int Compare( Object^ x, Object^ y ) = IComparer::Compare
   {
      return ((gcnew CaseInsensitiveComparer)->Compare( y, x ));
   }
};

void PrintKeysAndValues( array<String^>^myKeys, array<String^>^myValues )
{
   for ( int i = 0; i < myKeys->Length; i++ )
   {
      Console::WriteLine( " {0, -10}: {1}", myKeys[ i ], myValues[ i ] );
   }
   Console::WriteLine();
}

int main()
{
   // Creates and initializes a new Array and a new custom comparer.
   array<String^>^myKeys = {"red","GREEN","YELLOW","BLUE","purple","black","orange"};
   array<String^>^myValues = {"strawberries","PEARS","LIMES","BERRIES","grapes","olives","cantaloupe"};
   IComparer^ myComparer = gcnew myReverserClass;

   // Displays the values of the Array.
   Console::WriteLine( "The Array initially contains the following values:" );
   PrintKeysAndValues( myKeys, myValues );

   // Sorts a section of the Array using the default comparer.
   Array::Sort( myKeys, myValues, 1, 3 );
   Console::WriteLine( "After sorting a section of the Array using the default comparer:" );

   // Sorts a section of the Array using the reverse case-insensitive comparer.
   Array::Sort( myKeys, myValues, 1, 3, myComparer );
   Console::WriteLine( "After sorting a section of the Array using the reverse case-insensitive comparer:" );
   PrintKeysAndValues( myKeys, myValues );

   // Sorts the entire Array using the default comparer.
   Array::Sort( myKeys, myValues );
   Console::WriteLine( "After sorting the entire Array using the default comparer:" );
   PrintKeysAndValues( myKeys, myValues );

   // Sorts the entire Array using the reverse case-insensitive comparer.
   Array::Sort( myKeys, myValues, myComparer );
   Console::WriteLine( "After sorting the entire Array using the reverse case-insensitive comparer:" );
   PrintKeysAndValues( myKeys, myValues );
}

/* 
This code produces the following output.

The Array initially contains the following values:
   red       : strawberries
   GREEN     : PEARS
   YELLOW    : LIMES
   BLUE      : BERRIES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting a section of the Array using the default comparer:
   red       : strawberries
   BLUE      : BERRIES
   GREEN     : PEARS
   YELLOW    : LIMES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting a section of the Array using the reverse case-insensitive comparer:
   red       : strawberries
   YELLOW    : LIMES
   GREEN     : PEARS
   BLUE      : BERRIES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting the entire Array using the default comparer:
   black     : olives
   BLUE      : BERRIES
   GREEN     : PEARS
   orange    : cantaloupe
   purple    : grapes
   red       : strawberries
   YELLOW    : LIMES

After sorting the entire Array using the reverse case-insensitive comparer:
   YELLOW    : LIMES
   red       : strawberries
   purple    : grapes
   orange    : cantaloupe
   GREEN     : PEARS
   BLUE      : BERRIES
   black     : olives

*/
using System;
using System.Collections;

public class SamplesArray  {
 
   public class myReverserClass : IComparer  {

      // Calls CaseInsensitiveComparer.Compare with the parameters reversed.
      int IComparer.Compare( Object x, Object y )  {
          return( (new CaseInsensitiveComparer()).Compare( y, x ) );
      }

   }

   public static void Main()  {
 
      // Creates and initializes a new Array and a new custom comparer.
      String[] myKeys = { "red", "GREEN", "YELLOW", "BLUE", "purple", "black", "orange" };
      String[] myValues = { "strawberries", "PEARS", "LIMES", "BERRIES", "grapes", "olives", "cantaloupe" };
      IComparer myComparer = new myReverserClass();
 
      // Displays the values of the Array.
      Console.WriteLine( "The Array initially contains the following values:" );
      PrintKeysAndValues( myKeys, myValues );
 
      // Sorts a section of the Array using the default comparer.
      Array.Sort( myKeys, myValues, 1, 3 );
      Console.WriteLine( "After sorting a section of the Array using the default comparer:" );
      PrintKeysAndValues( myKeys, myValues );

      // Sorts a section of the Array using the reverse case-insensitive comparer.
      Array.Sort( myKeys, myValues, 1, 3, myComparer );
      Console.WriteLine( "After sorting a section of the Array using the reverse case-insensitive comparer:" );
      PrintKeysAndValues( myKeys, myValues );

      // Sorts the entire Array using the default comparer.
      Array.Sort( myKeys, myValues );
      Console.WriteLine( "After sorting the entire Array using the default comparer:" );
      PrintKeysAndValues( myKeys, myValues );

      // Sorts the entire Array using the reverse case-insensitive comparer.
      Array.Sort( myKeys, myValues, myComparer );
      Console.WriteLine( "After sorting the entire Array using the reverse case-insensitive comparer:" );
      PrintKeysAndValues( myKeys, myValues );

   }
 
   public static void PrintKeysAndValues( String[] myKeys, String[] myValues )  {
      for ( int i = 0; i < myKeys.Length; i++ )  {
         Console.WriteLine( "   {0,-10}: {1}", myKeys[i], myValues[i] );
      }
      Console.WriteLine();
   }
}


/* 
This code produces the following output.

The Array initially contains the following values:
   red       : strawberries
   GREEN     : PEARS
   YELLOW    : LIMES
   BLUE      : BERRIES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting a section of the Array using the default comparer:
   red       : strawberries
   BLUE      : BERRIES
   GREEN     : PEARS
   YELLOW    : LIMES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting a section of the Array using the reverse case-insensitive comparer:
   red       : strawberries
   YELLOW    : LIMES
   GREEN     : PEARS
   BLUE      : BERRIES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting the entire Array using the default comparer:
   black     : olives
   BLUE      : BERRIES
   GREEN     : PEARS
   orange    : cantaloupe
   purple    : grapes
   red       : strawberries
   YELLOW    : LIMES

After sorting the entire Array using the reverse case-insensitive comparer:
   YELLOW    : LIMES
   red       : strawberries
   purple    : grapes
   orange    : cantaloupe
   GREEN     : PEARS
   BLUE      : BERRIES
   black     : olives

*/

Imports System
Imports System.Collections

Public Class SamplesArray

   Public Class myReverserClass
      Implements IComparer

      ' Calls CaseInsensitiveComparer.Compare with the parameters reversed.
      Function Compare(x As [Object], y As [Object]) As Integer _
         Implements IComparer.Compare
         Return New CaseInsensitiveComparer().Compare(y, x)
      End Function 'IComparer.Compare

   End Class 'myReverserClass


   Public Shared Sub Main()

      ' Creates and initializes a new Array and a new custom comparer.
      Dim myKeys As [String]() =  {"red", "GREEN", "YELLOW", "BLUE", "purple", "black", "orange"}
      Dim myValues As [String]() =  {"strawberries", "PEARS", "LIMES", "BERRIES", "grapes", "olives", "cantaloupe"}
      Dim myComparer = New myReverserClass()

      ' Displays the values of the Array.
      Console.WriteLine("The Array initially contains the following values:")
      PrintKeysAndValues(myKeys, myValues)

      ' Sorts a section of the Array using the default comparer.
      Array.Sort(myKeys, myValues, 1, 3)
      Console.WriteLine("After sorting a section of the Array using the default comparer:")
      PrintKeysAndValues(myKeys, myValues)

      ' Sorts a section of the Array using the reverse case-insensitive comparer.
      Array.Sort(myKeys, myValues, 1, 3, myComparer)
      Console.WriteLine("After sorting a section of the Array using the reverse case-insensitive comparer:")
      PrintKeysAndValues(myKeys, myValues)

      ' Sorts the entire Array using the default comparer.
      Array.Sort(myKeys, myValues)
      Console.WriteLine("After sorting the entire Array using the default comparer:")
      PrintKeysAndValues(myKeys, myValues)

      ' Sorts the entire Array using the reverse case-insensitive comparer.
      Array.Sort(myKeys, myValues, myComparer)
      Console.WriteLine("After sorting the entire Array using the reverse case-insensitive comparer:")
      PrintKeysAndValues(myKeys, myValues)

   End Sub 'Main


   Public Shared Sub PrintKeysAndValues(myKeys() As [String], myValues() As [String])

      Dim i As Integer
      For i = 0 To myKeys.Length - 1
         Console.WriteLine("   {0,-10}: {1}", myKeys(i), myValues(i))
      Next i
      Console.WriteLine()

   End Sub 'PrintKeysAndValues

End Class 'SamplesArray


'This code produces the following output.
'
'The Array initially contains the following values:
'   red       : strawberries
'   GREEN     : PEARS
'   YELLOW    : LIMES
'   BLUE      : BERRIES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting a section of the Array using the default comparer:
'   red       : strawberries
'   BLUE      : BERRIES
'   GREEN     : PEARS
'   YELLOW    : LIMES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting a section of the Array using the reverse case-insensitive comparer:
'   red       : strawberries
'   YELLOW    : LIMES
'   GREEN     : PEARS
'   BLUE      : BERRIES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting the entire Array using the default comparer:
'   black     : olives
'   BLUE      : BERRIES
'   GREEN     : PEARS
'   orange    : cantaloupe
'   purple    : grapes
'   red       : strawberries
'   YELLOW    : LIMES
'
'After sorting the entire Array using the reverse case-insensitive comparer:
'   YELLOW    : LIMES
'   red       : strawberries
'   purple    : grapes
'   orange    : cantaloupe
'   GREEN     : PEARS
'   BLUE      : BERRIES
'   black     : olives

Hinweise

Jeder Schlüssel in der keys Array verfügt über ein entsprechendes Element in der items Array.Each key in the keysArray has a corresponding item in the itemsArray. Wenn ein Schlüssel wird neu angeordnet, bei der Sortierung, des entsprechenden Elements in der items Array wird neu positioniert.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Aus diesem Grund die items Array sortiert wird, entsprechend der Anordnung der entsprechenden Schlüssel in der keys Array.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Wenn comparer ist null, jeder Schlüssel im angegebenen Bereich von Elementen in der keys Array müssen implementieren die IComparable Benutzeroberfläche kann mit jedem anderen Schlüssel verglichen werden.If comparer is null, each key within the specified range of elements in the keysArray must implement the IComparable interface to be capable of comparisons with every other key.

Sie können sortiert, wenn es mehr Elemente als Schlüssel gibt, aber die Elemente, die ohne entsprechenden Schlüssel werden nicht sortiert.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Wenn es weitere Schlüssel als Elemente können nicht sortiert werden; Dies löst dies eine ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Wenn die Sortierung nicht erfolgreich abgeschlossen wird, sind die Ergebnisse nicht definiert.If the sort is not successfully completed, the results are undefined.

.NET Framework enthält vordefinierte IComparer Implementierungen in der folgenden Tabelle aufgeführt.The .NET Framework includes predefined IComparer implementations listed in the following table.

ImplementierungImplementation Beschreibung Description
System.Collections.CaseInsensitiveComparer Vergleicht zwei Objekte, jedoch führt einen Vergleich Groß-/Kleinschreibung von Zeichenfolgen.Compares any two objects, but performs a case-insensitive comparison of strings.
Comparer.Default Vergleicht zwei Objekte mithilfe der Sortierkonventionen der aktuellen Kultur.Compares any two objects by using the sorting conventions of the current culture.
Comparer.DefaultInvariant Vergleicht zwei Objekte mithilfe der Sortierkonventionen der invarianten Kultur.Compares any two objects by using the sorting conventions of the invariant culture.
Comparer<T>.Default Vergleicht zwei Objekte des Typs T mithilfe von Standard-Sortierreihenfolge des Typs.Compares two objects of type T by using the type's default sort order.

Sie können auch benutzerdefinierte Vergleiche unterstützen, durch die Bereitstellung einer Instanz Ihrer eigenen IComparer Implementierung, die die comparer Parameter.You can also support custom comparisons by providing an instance of your own IComparer implementation to the comparer parameter. Im Beispiel wird dieses durch Definieren eines benutzerdefinierten IComparer Implementierung, kehrt die Standardsortierreihenfolge und führt die Groß-/Kleinschreibung Zeichenfolgenvergleich.The example does this by defining a custom IComparer implementation that reverses the default sort order and performs case-insensitive string comparison.

Diese Methode verwendet die Beobachtung der inneren Abläufe Sortieralgorithmus (Introsort) wie folgt aus:This method uses the introspective sort (introsort) algorithm as follows:

  • Wenn die Größe der Partition weniger als 16 Elementen ist, wird ein Einfügesortierung Algorithmus.If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Überschreitet die Anzahl der Partitionen 2 * LogN, wobei N ist der Bereich des Eingabearrays, er verwendet eine Heapsort Algorithmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • Andernfalls verwendet es, eine Quicksort Algorithmus.Otherwise, it uses a Quicksort algorithm.

Diese Implementierung führt eine instabile Sortierung. d.h., wenn zwei Elemente gleich sind, möglicherweise die Reihenfolge nicht beibehalten.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Im Gegensatz dazu behält eine stabile Sortierung, die Reihenfolge der Elemente, die gleich sind.In contrast, a stable sort preserves the order of elements that are equal.

Für Arrays, die mithilfe von Algorithmen Heapsort und wenden die Schnellsortierung im schlimmsten Fall sortiert sind, ist diese Methode eine O (n Log n)-Vorgang, in denen n ist length.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is length.

Hinweise für Aufrufer

Die .NET Framework 4 und früheren Versionen verwendet nur den Quicksort-Algorithmus. The .NET Framework 4 and earlier versions used only the Quicksort algorithm. QuickSort identifiziert die ungültige Vergleiche in einigen Situationen, in dem der Sortiervorgang löst, eine IndexOutOfRangeException -Ausnahme aus, und löst eine ArgumentException Ausnahme an den Aufrufer. Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Beginnend mit der .NET Framework 4.5.NET Framework 4.5, es ist möglich, dass ausgelöst, das zuvor Sortiervorgänge hat ArgumentException wird keine Ausnahme, da die Einfügung sortieren und Heapsort Algorithmen eine ungültige Vergleich nicht erkennen. Starting with the .NET Framework 4.5.NET Framework 4.5, it is possible that sorting operations that previously threw ArgumentException will not throw an exception, because the insertion sort and heapsort algorithms do not detect an invalid comparer. Zum größten Teil, gilt dies für Arrays mit weniger als 16 Elementen. For the most part, this applies to arrays with fewer than 16 elements.

Siehe auch

Sort(Array, Int32, Int32) Sort(Array, Int32, Int32) Sort(Array, Int32, Int32)

Sortiert die Elemente in einem Bereich von Elementen in einem eindimensionalen Array mithilfe der IComparable-Implementierung jedes Elements des Array. Sorts the elements in a range of elements in a one-dimensional Array using the IComparable implementation of each element of the Array.

public:
 static void Sort(Array ^ array, int index, int length);
public static void Sort (Array array, int index, int length);
static member Sort : Array * int * int -> unit
Parameter
array
Array Array Array Array

Das zu sortierende eindimensionale Array. The one-dimensional Array to sort.

index
Int32 Int32 Int32 Int32

Der Startindex des zu sortierenden Bereichs. The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Die Anzahl der Elemente im zu sortierenden Bereich. The number of elements in the range to sort.

Ausnahmen

array ist mehrdimensional. array is multidimensional.

index ist kleiner als die untere array-Grenze. index is less than the lower bound of array. - oder - -or- length ist kleiner als Null. length is less than zero.

index und length geben keinen gültigen Bereich im array an. index and length do not specify a valid range in array.

Mindestens ein Element in array implementiert die IComparable-Schnittstelle nicht. One or more elements in array do not implement the IComparable interface.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie zum Sortieren der Werte in einer Array mithilfe des Standardvergleichs und einem benutzerdefinierten Vergleich, der die Sortierreihenfolge umgekehrt.The following code example shows how to sort the values in an Array using the default comparer and a custom comparer that reverses the sort order. Beachten Sie, die das Ergebnis, abhängig vom aktuellen variieren kann CultureInfo.Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

public ref class ReverseComparer : IComparer
{
public:
   // Call CaseInsensitiveComparer::Compare with the parameters reversed.
   virtual int Compare(Object^ x, Object^ y) = IComparer::Compare
   {
      return ((gcnew CaseInsensitiveComparer)->Compare(y, x));
   }
};

void DisplayValues(array<String^>^ arr)
{
   for (int i = arr->GetLowerBound(0); i <= arr->GetUpperBound(0); i++)
      Console::WriteLine( "   [{0}] : {1}", i, arr[ i ] );

   Console::WriteLine();
}

int main()
{
   // Create and initialize a new array. and a new custom comparer.
   array<String^>^ words = { "The","QUICK","BROWN","FOX","jumps",
                             "over","the","lazy","dog" };
   // Instantiate the reverse comparer.
   IComparer^ revComparer = gcnew 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);
}

/* 
This code produces the following output.

The Array initially contains the following values:
   [0] : The
   [1] : QUICK
   [2] : BROWN
   [3] : FOX
   [4] : jumps
   [5] : over
   [6] : the
   [7] : lazy
   [8] : dog

After sorting a section of the Array using the default comparer:
   [0] : The
   [1] : BROWN
   [2] : FOX
   [3] : QUICK
   [4] : jumps
   [5] : over
   [6] : the
   [7] : lazy
   [8] : dog

After sorting a section of the Array 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 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

*/
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    
Imports System.Collections

Public Class ReverseComparer : Implements IComparer
   ' Call CaseInsensitiveComparer.Compare with the parameters reversed.
   Function Compare(x As Object, y As Object) As Integer _
            Implements IComparer.Compare
      Return New CaseInsensitiveComparer().Compare(y, x)
   End Function 
End Class

Public Module Example
   Public Sub Main()
      ' Create and initialize a new array.
      Dim words() As String =  { "The", "QUICK", "BROWN", "FOX", "jumps", 
                                 "over", "the", "lazy", "dog" }
      ' Instantiate a new custom comparer.
      Dim revComparer As 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)
   End Sub 

   Public Sub DisplayValues(arr() As String)
      For i As Integer = arr.GetLowerBound(0) To arr.GetUpperBound(0)
         Console.WriteLine("   [{0}] : {1}", i, arr(i))
      Next 
      Console.WriteLine()
   End Sub 
End Module 
' 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

Hinweise

Jedes Element innerhalb des angegebenen Bereichs von Elementen in array müssen implementieren die IComparable Schnittstelle kann Vergleiche mit jedem anderen Element im array.Each element within the specified range of elements in array must implement the IComparable interface to be capable of comparisons with every other element in array.

Wenn die Sortierung nicht erfolgreich abgeschlossen wird, sind die Ergebnisse nicht definiert.If the sort is not successfully completed, the results are undefined.

Diese Methode verwendet die Beobachtung der inneren Abläufe Sortieralgorithmus (Introsort) wie folgt aus:This method uses the introspective sort (introsort) algorithm as follows:

  • Wenn die Größe der Partition weniger als 16 Elementen ist, wird ein Einfügesortierung Algorithmus.If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Überschreitet die Anzahl der Partitionen 2 * LogN, wobei N ist der Bereich des Eingabearrays, er verwendet eine Heapsort Algorithmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • Andernfalls verwendet es, eine Quicksort Algorithmus.Otherwise, it uses a Quicksort algorithm.

Diese Implementierung führt eine instabile Sortierung. d.h., wenn zwei Elemente gleich sind, möglicherweise die Reihenfolge nicht beibehalten.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Im Gegensatz dazu behält eine stabile Sortierung, die Reihenfolge der Elemente, die gleich sind.In contrast, a stable sort preserves the order of elements that are equal.

Für Arrays, die mithilfe von Algorithmen Heapsort und wenden die Schnellsortierung im schlimmsten Fall sortiert sind, ist diese Methode eine O (n Log n)-Vorgang, in denen n ist length.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is length.

Siehe auch

Sort(Array, Array, Int32, Int32) Sort(Array, Array, Int32, Int32) Sort(Array, Array, Int32, Int32) Sort(Array, Array, Int32, Int32)

Sortiert einen Bereich von Elementen in einem Paar von eindimensionalen Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei die IComparable-Implementierung jedes Schlüssels. Sorts a range of elements in a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable implementation of each key.

public:
 static void Sort(Array ^ keys, Array ^ items, int index, int length);
public static void Sort (Array keys, Array items, int index, int length);
static member Sort : Array * Array * int * int -> unit
Public Shared Sub Sort (keys As Array, items As Array, index As Integer, length As Integer)
Parameter
keys
Array Array Array Array

Das eindimensionale Array mit den zu sortierenden Schlüsseln. The one-dimensional Array that contains the keys to sort.

items
Array Array Array Array

Das eindimensionale Array mit den Elementen, die den jeweiligen Schlüsseln im keysArray entsprechen. The one-dimensional Array that contains the items that correspond to each of the keys in the keysArray. - oder - -or- null, wenn nur das keysArray sortiert werden soll. null to sort only the keysArray.

index
Int32 Int32 Int32 Int32

Der Startindex des zu sortierenden Bereichs. The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Die Anzahl der Elemente im zu sortierenden Bereich. The number of elements in the range to sort.

Ausnahmen

Das keysArray ist mehrdimensional. The keysArray is multidimensional. - oder - -or- Das itemsArray ist mehrdimensional. The itemsArray is multidimensional.

index ist kleiner als die untere keys-Grenze. index is less than the lower bound of keys. - oder - -or- length ist kleiner als Null. length is less than zero.

items ist nicht null, und die Länge von keys ist größer als die Länge von items. items is not null, and the length of keys is greater than the length of items. - oder - -or- index und length geben keinen gültigen Bereich im keysArray an. index and length do not specify a valid range in the keysArray. - oder - -or- items ist nicht null, und index und length geben keinen gültigen Bereich im itemsArray an. items is not null, and index and length do not specify a valid range in the itemsArray.

Mindestens ein Element im keysArray implementiert die IComparable-Schnittstelle nicht. One or more elements in the keysArray do not implement the IComparable interface.

Beispiele

Im folgenden Codebeispiel wird das Sortieren von zwei verknüpften Arrays, in dem das erste Array enthält die Schlüssel und das zweite Array enthält die Werte, veranschaulicht.The following code example shows how to sort two associated arrays where the first array contains the keys and the second array contains the values. Sortierungen erfolgen mithilfe des Standardvergleichs und einem benutzerdefinierten Vergleich, der die Sortierreihenfolge umgekehrt.Sorts are done using the default comparer and a custom comparer that reverses the sort order. Beachten Sie, die das Ergebnis, abhängig vom aktuellen variieren kann CultureInfo.Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

public ref class myReverserClass: public IComparer
{
private:

   // Calls CaseInsensitiveComparer::Compare with the parameters reversed.
   virtual int Compare( Object^ x, Object^ y ) = IComparer::Compare
   {
      return ((gcnew CaseInsensitiveComparer)->Compare( y, x ));
   }
};

void PrintKeysAndValues( array<String^>^myKeys, array<String^>^myValues )
{
   for ( int i = 0; i < myKeys->Length; i++ )
   {
      Console::WriteLine( " {0, -10}: {1}", myKeys[ i ], myValues[ i ] );
   }
   Console::WriteLine();
}

int main()
{
   // Creates and initializes a new Array and a new custom comparer.
   array<String^>^myKeys = {"red","GREEN","YELLOW","BLUE","purple","black","orange"};
   array<String^>^myValues = {"strawberries","PEARS","LIMES","BERRIES","grapes","olives","cantaloupe"};
   IComparer^ myComparer = gcnew myReverserClass;

   // Displays the values of the Array.
   Console::WriteLine( "The Array initially contains the following values:" );
   PrintKeysAndValues( myKeys, myValues );

   // Sorts a section of the Array using the default comparer.
   Array::Sort( myKeys, myValues, 1, 3 );
   Console::WriteLine( "After sorting a section of the Array using the default comparer:" );

   // Sorts a section of the Array using the reverse case-insensitive comparer.
   Array::Sort( myKeys, myValues, 1, 3, myComparer );
   Console::WriteLine( "After sorting a section of the Array using the reverse case-insensitive comparer:" );
   PrintKeysAndValues( myKeys, myValues );

   // Sorts the entire Array using the default comparer.
   Array::Sort( myKeys, myValues );
   Console::WriteLine( "After sorting the entire Array using the default comparer:" );
   PrintKeysAndValues( myKeys, myValues );

   // Sorts the entire Array using the reverse case-insensitive comparer.
   Array::Sort( myKeys, myValues, myComparer );
   Console::WriteLine( "After sorting the entire Array using the reverse case-insensitive comparer:" );
   PrintKeysAndValues( myKeys, myValues );
}

/* 
This code produces the following output.

The Array initially contains the following values:
   red       : strawberries
   GREEN     : PEARS
   YELLOW    : LIMES
   BLUE      : BERRIES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting a section of the Array using the default comparer:
   red       : strawberries
   BLUE      : BERRIES
   GREEN     : PEARS
   YELLOW    : LIMES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting a section of the Array using the reverse case-insensitive comparer:
   red       : strawberries
   YELLOW    : LIMES
   GREEN     : PEARS
   BLUE      : BERRIES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting the entire Array using the default comparer:
   black     : olives
   BLUE      : BERRIES
   GREEN     : PEARS
   orange    : cantaloupe
   purple    : grapes
   red       : strawberries
   YELLOW    : LIMES

After sorting the entire Array using the reverse case-insensitive comparer:
   YELLOW    : LIMES
   red       : strawberries
   purple    : grapes
   orange    : cantaloupe
   GREEN     : PEARS
   BLUE      : BERRIES
   black     : olives

*/
using System;
using System.Collections;

public class SamplesArray  {
 
   public class myReverserClass : IComparer  {

      // Calls CaseInsensitiveComparer.Compare with the parameters reversed.
      int IComparer.Compare( Object x, Object y )  {
          return( (new CaseInsensitiveComparer()).Compare( y, x ) );
      }

   }

   public static void Main()  {
 
      // Creates and initializes a new Array and a new custom comparer.
      String[] myKeys = { "red", "GREEN", "YELLOW", "BLUE", "purple", "black", "orange" };
      String[] myValues = { "strawberries", "PEARS", "LIMES", "BERRIES", "grapes", "olives", "cantaloupe" };
      IComparer myComparer = new myReverserClass();
 
      // Displays the values of the Array.
      Console.WriteLine( "The Array initially contains the following values:" );
      PrintKeysAndValues( myKeys, myValues );
 
      // Sorts a section of the Array using the default comparer.
      Array.Sort( myKeys, myValues, 1, 3 );
      Console.WriteLine( "After sorting a section of the Array using the default comparer:" );
      PrintKeysAndValues( myKeys, myValues );

      // Sorts a section of the Array using the reverse case-insensitive comparer.
      Array.Sort( myKeys, myValues, 1, 3, myComparer );
      Console.WriteLine( "After sorting a section of the Array using the reverse case-insensitive comparer:" );
      PrintKeysAndValues( myKeys, myValues );

      // Sorts the entire Array using the default comparer.
      Array.Sort( myKeys, myValues );
      Console.WriteLine( "After sorting the entire Array using the default comparer:" );
      PrintKeysAndValues( myKeys, myValues );

      // Sorts the entire Array using the reverse case-insensitive comparer.
      Array.Sort( myKeys, myValues, myComparer );
      Console.WriteLine( "After sorting the entire Array using the reverse case-insensitive comparer:" );
      PrintKeysAndValues( myKeys, myValues );

   }
 
   public static void PrintKeysAndValues( String[] myKeys, String[] myValues )  {
      for ( int i = 0; i < myKeys.Length; i++ )  {
         Console.WriteLine( "   {0,-10}: {1}", myKeys[i], myValues[i] );
      }
      Console.WriteLine();
   }
}


/* 
This code produces the following output.

The Array initially contains the following values:
   red       : strawberries
   GREEN     : PEARS
   YELLOW    : LIMES
   BLUE      : BERRIES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting a section of the Array using the default comparer:
   red       : strawberries
   BLUE      : BERRIES
   GREEN     : PEARS
   YELLOW    : LIMES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting a section of the Array using the reverse case-insensitive comparer:
   red       : strawberries
   YELLOW    : LIMES
   GREEN     : PEARS
   BLUE      : BERRIES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting the entire Array using the default comparer:
   black     : olives
   BLUE      : BERRIES
   GREEN     : PEARS
   orange    : cantaloupe
   purple    : grapes
   red       : strawberries
   YELLOW    : LIMES

After sorting the entire Array using the reverse case-insensitive comparer:
   YELLOW    : LIMES
   red       : strawberries
   purple    : grapes
   orange    : cantaloupe
   GREEN     : PEARS
   BLUE      : BERRIES
   black     : olives

*/

Imports System
Imports System.Collections

Public Class SamplesArray

   Public Class myReverserClass
      Implements IComparer

      ' Calls CaseInsensitiveComparer.Compare with the parameters reversed.
      Function Compare(x As [Object], y As [Object]) As Integer _
         Implements IComparer.Compare
         Return New CaseInsensitiveComparer().Compare(y, x)
      End Function 'IComparer.Compare

   End Class 'myReverserClass


   Public Shared Sub Main()

      ' Creates and initializes a new Array and a new custom comparer.
      Dim myKeys As [String]() =  {"red", "GREEN", "YELLOW", "BLUE", "purple", "black", "orange"}
      Dim myValues As [String]() =  {"strawberries", "PEARS", "LIMES", "BERRIES", "grapes", "olives", "cantaloupe"}
      Dim myComparer = New myReverserClass()

      ' Displays the values of the Array.
      Console.WriteLine("The Array initially contains the following values:")
      PrintKeysAndValues(myKeys, myValues)

      ' Sorts a section of the Array using the default comparer.
      Array.Sort(myKeys, myValues, 1, 3)
      Console.WriteLine("After sorting a section of the Array using the default comparer:")
      PrintKeysAndValues(myKeys, myValues)

      ' Sorts a section of the Array using the reverse case-insensitive comparer.
      Array.Sort(myKeys, myValues, 1, 3, myComparer)
      Console.WriteLine("After sorting a section of the Array using the reverse case-insensitive comparer:")
      PrintKeysAndValues(myKeys, myValues)

      ' Sorts the entire Array using the default comparer.
      Array.Sort(myKeys, myValues)
      Console.WriteLine("After sorting the entire Array using the default comparer:")
      PrintKeysAndValues(myKeys, myValues)

      ' Sorts the entire Array using the reverse case-insensitive comparer.
      Array.Sort(myKeys, myValues, myComparer)
      Console.WriteLine("After sorting the entire Array using the reverse case-insensitive comparer:")
      PrintKeysAndValues(myKeys, myValues)

   End Sub 'Main


   Public Shared Sub PrintKeysAndValues(myKeys() As [String], myValues() As [String])

      Dim i As Integer
      For i = 0 To myKeys.Length - 1
         Console.WriteLine("   {0,-10}: {1}", myKeys(i), myValues(i))
      Next i
      Console.WriteLine()

   End Sub 'PrintKeysAndValues

End Class 'SamplesArray


'This code produces the following output.
'
'The Array initially contains the following values:
'   red       : strawberries
'   GREEN     : PEARS
'   YELLOW    : LIMES
'   BLUE      : BERRIES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting a section of the Array using the default comparer:
'   red       : strawberries
'   BLUE      : BERRIES
'   GREEN     : PEARS
'   YELLOW    : LIMES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting a section of the Array using the reverse case-insensitive comparer:
'   red       : strawberries
'   YELLOW    : LIMES
'   GREEN     : PEARS
'   BLUE      : BERRIES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting the entire Array using the default comparer:
'   black     : olives
'   BLUE      : BERRIES
'   GREEN     : PEARS
'   orange    : cantaloupe
'   purple    : grapes
'   red       : strawberries
'   YELLOW    : LIMES
'
'After sorting the entire Array using the reverse case-insensitive comparer:
'   YELLOW    : LIMES
'   red       : strawberries
'   purple    : grapes
'   orange    : cantaloupe
'   GREEN     : PEARS
'   BLUE      : BERRIES
'   black     : olives

Hinweise

Jeder Schlüssel in der keys Array verfügt über ein entsprechendes Element in der items Array.Each key in the keysArray has a corresponding item in the itemsArray. Wenn ein Schlüssel wird neu angeordnet, bei der Sortierung, des entsprechenden Elements in der items Array wird neu positioniert.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Aus diesem Grund die items Array sortiert wird, entsprechend der Anordnung der entsprechenden Schlüssel in der keys Array.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Jeder Schlüssel im angegebenen Bereich von Elementen in der keys Array müssen implementieren die IComparable Benutzeroberfläche kann mit jedem anderen Schlüssel verglichen werden.Each key within the specified range of elements in the keysArray must implement the IComparable interface to be capable of comparisons with every other key.

Sie können sortiert, wenn es mehr Elemente als Schlüssel gibt, aber die Elemente, die ohne entsprechenden Schlüssel werden nicht sortiert.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Wenn es weitere Schlüssel als Elemente können nicht sortiert werden; Dies löst dies eine ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Wenn die Sortierung nicht erfolgreich abgeschlossen wird, sind die Ergebnisse nicht definiert.If the sort is not successfully completed, the results are undefined.

Diese Methode verwendet die Beobachtung der inneren Abläufe Sortieralgorithmus (Introsort) wie folgt aus:This method uses the introspective sort (introsort) algorithm as follows:

  • Wenn die Größe der Partition weniger als 16 Elementen ist, wird ein Einfügesortierung Algorithmus.If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Überschreitet die Anzahl der Partitionen 2 * LogN, wobei N ist der Bereich des Eingabearrays, er verwendet eine Heapsort Algorithmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • Andernfalls verwendet es, eine Quicksort Algorithmus.Otherwise, it uses a Quicksort algorithm.

Diese Implementierung führt eine instabile Sortierung. d.h., wenn zwei Elemente gleich sind, möglicherweise die Reihenfolge nicht beibehalten.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Im Gegensatz dazu behält eine stabile Sortierung, die Reihenfolge der Elemente, die gleich sind.In contrast, a stable sort preserves the order of elements that are equal.

Für Arrays, die mithilfe von Algorithmen Heapsort und wenden die Schnellsortierung im schlimmsten Fall sortiert sind, ist diese Methode eine O (n Log n)-Vorgang, in denen n ist length.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is length.

Siehe auch

Sort(Array, IComparer) Sort(Array, IComparer) Sort(Array, IComparer)

Sortiert die Elemente in einem eindimensionalen Array mithilfe des angegebenen IComparer. Sorts the elements in a one-dimensional Array using the specified IComparer.

public:
 static void Sort(Array ^ array, System::Collections::IComparer ^ comparer);
public static void Sort (Array array, System.Collections.IComparer comparer);
static member Sort : Array * System.Collections.IComparer -> unit
Parameter
array
Array Array Array Array

Das zu sortierende eindimensionale Array. The one-dimensional array to sort.

comparer
IComparer IComparer IComparer IComparer

Die Implementierung, die beim Vergleich von Elementen verwendet werden soll. The implementation to use when comparing elements. - oder - -or- null, wenn die IComparable-Implementierung des jeweiligen Elements verwendet werden soll. null to use the IComparable implementation of each element.

Ausnahmen

array ist mehrdimensional. array is multidimensional.

comparer ist null, und mindestens ein Element in array implementiert die IComparable-Schnittstelle nicht. comparer is null, and one or more elements in array do not implement the IComparable interface.

Die Implementierung von comparer hat einen Fehler während der Sortierung verursacht. The implementation of comparer caused an error during the sort. Beispielsweise gibt comparer beim Vergleichen eines Elements mit sich selbst möglicherweise nicht 0 zurück. For example, comparer might not return 0 when comparing an item with itself.

Beispiele

Im folgenden Beispiel werden die Werte in einer Zeichenfolge Arrayby mithilfe des Standardvergleichs.The following example sorts the values in a string arrayby using the default comparer. Sie definiert auch eine benutzerdefinierte IComparer Implementierung, die mit dem Namen ReverseComparer , die ein Objekt des Standard-Sortierreihenfolge beim Ausführen eines Zeichenfolgenvergleichs umgekehrt.It also defines a custom IComparer implementation named ReverseComparer that reverses an object's default sort order while performing a case-insensitive string comparison. Beachten Sie, dass die Ausgabe abhängig von der aktuellen Kultur variieren kann.Note that the output might vary depending on the current culture.

using namespace System;
using namespace System::Collections;

public ref class ReverseComparer : IComparer
{
public:
   // Call CaseInsensitiveComparer::Compare with the parameters reversed.
   virtual int Compare(Object^ x, Object^ y) = IComparer::Compare
   {
      return ((gcnew CaseInsensitiveComparer)->Compare(y, x));
   }
};

void DisplayValues(array<String^>^ arr)
{
   for (int i = arr->GetLowerBound(0); i <= arr->GetUpperBound(0); i++)
      Console::WriteLine( "   [{0}] : {1}", i, arr[ i ] );

   Console::WriteLine();
}

int main()
{
   // Create and initialize a new array. and a new custom comparer.
   array<String^>^ words = { "The","QUICK","BROWN","FOX","jumps",
                             "over","the","lazy","dog" };
   // Instantiate the reverse comparer.
   IComparer^ revComparer = gcnew 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);
}

/* 
This code produces the following output.

The Array initially contains the following values:
   [0] : The
   [1] : QUICK
   [2] : BROWN
   [3] : FOX
   [4] : jumps
   [5] : over
   [6] : the
   [7] : lazy
   [8] : dog

After sorting a section of the Array using the default comparer:
   [0] : The
   [1] : BROWN
   [2] : FOX
   [3] : QUICK
   [4] : jumps
   [5] : over
   [6] : the
   [7] : lazy
   [8] : dog

After sorting a section of the Array 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 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

*/
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    
Imports System.Collections

Public Class ReverseComparer : Implements IComparer
   ' Call CaseInsensitiveComparer.Compare with the parameters reversed.
   Function Compare(x As Object, y As Object) As Integer _
            Implements IComparer.Compare
      Return New CaseInsensitiveComparer().Compare(y, x)
   End Function 
End Class

Public Module Example
   Public Sub Main()
      ' Create and initialize a new array.
      Dim words() As String =  { "The", "QUICK", "BROWN", "FOX", "jumps", 
                                 "over", "the", "lazy", "dog" }
      ' Instantiate a new custom comparer.
      Dim revComparer As 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)
   End Sub 

   Public Sub DisplayValues(arr() As String)
      For i As Integer = arr.GetLowerBound(0) To arr.GetUpperBound(0)
         Console.WriteLine("   [{0}] : {1}", i, arr(i))
      Next 
      Console.WriteLine()
   End Sub 
End Module 
' 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

Hinweise

Wenn comparer ist null, jedes Element der array müssen implementieren die IComparable Schnittstelle kann Vergleiche mit jedem anderen Element im array.If comparer is null, each element of array must implement the IComparable interface to be capable of comparisons with every other element in array.

Wenn die Sortierung nicht erfolgreich abgeschlossen wird, sind die Ergebnisse nicht definiert.If the sort is not successfully completed, the results are undefined.

Diese Methode verwendet die Beobachtung der inneren Abläufe Sortieralgorithmus (Introsort) wie folgt aus:This method uses the introspective sort (introsort) algorithm as follows:

  • Wenn die Größe der Partition weniger als 16 Elementen ist, wird ein Einfügesortierung Algorithmus.If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Überschreitet die Anzahl der Partitionen 2 * LogN, wobei N ist der Bereich des Eingabearrays, er verwendet eine Heapsort Algorithmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • Andernfalls verwendet es, eine Quicksort Algorithmus.Otherwise, it uses a Quicksort algorithm.

Diese Implementierung führt eine instabile Sortierung. d.h., wenn zwei Elemente gleich sind, möglicherweise die Reihenfolge nicht beibehalten.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Im Gegensatz dazu behält eine stabile Sortierung, die Reihenfolge der Elemente, die gleich sind.In contrast, a stable sort preserves the order of elements that are equal.

Für Arrays, die mithilfe von Algorithmen Heapsort und wenden die Schnellsortierung im schlimmsten Fall sortiert sind, ist diese Methode eine O (n Log n)-Vorgang, in denen n ist die Length von array.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is the Length of array.

.NET Framework enthält vordefinierte IComparer Implementierungen in der folgenden Tabelle aufgeführt.The .NET Framework includes predefined IComparer implementations listed in the following table.

ImplementierungImplementation Beschreibung Description
System.Collections.CaseInsensitiveComparer Vergleicht zwei Objekte, jedoch führt einen Vergleich Groß-/Kleinschreibung von Zeichenfolgen.Compares any two objects, but performs a case-insensitive comparison of strings.
Comparer.Default Vergleicht zwei Objekte mithilfe der Sortierkonventionen der aktuellen Kultur.Compares any two objects by using the sorting conventions of the current culture.
Comparer.DefaultInvariant Vergleicht zwei Objekte mithilfe der Sortierkonventionen der invarianten Kultur.Compares any two objects by using the sorting conventions of the invariant culture.
Comparer<T>.Default Vergleicht zwei Objekte des Typs T mithilfe von Standard-Sortierreihenfolge des Typs.Compares two objects of type T by using the type's default sort order.

Sie können auch benutzerdefinierte Vergleiche unterstützen, durch die Bereitstellung einer Instanz Ihrer eigenen IComparer Implementierung, die die comparer Parameter.You can also support custom comparisons by providing an instance of your own IComparer implementation to the comparer parameter. Durch die Definition wird im Beispiel eine ReverseComparer -Klasse, die die Standardsortierreihenfolge für kehrt Instanzen eines Typs und führt die Groß-/Kleinschreibung Zeichenfolgenvergleich.The example does this by defining a ReverseComparer class that reverses the default sort order for instances of a type and performs case-insensitive string comparison.

Hinweise für Aufrufer

Die .NET Framework 4 und früheren Versionen verwendet nur den Quicksort-Algorithmus. The .NET Framework 4 and earlier versions used only the Quicksort algorithm. QuickSort identifiziert die ungültige Vergleiche in einigen Situationen, in dem der Sortiervorgang löst, eine IndexOutOfRangeException -Ausnahme aus, und löst eine ArgumentException Ausnahme an den Aufrufer. Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Beginnend mit der .NET Framework 4.5.NET Framework 4.5, es ist möglich, dass ausgelöst, das zuvor Sortiervorgänge hat ArgumentException wird keine Ausnahme, da die Einfügung sortieren und Heapsort Algorithmen eine ungültige Vergleich nicht erkennen. Starting with the .NET Framework 4.5.NET Framework 4.5, it is possible that sorting operations that previously threw ArgumentException will not throw an exception, because the insertion sort and heapsort algorithms do not detect an invalid comparer. Zum größten Teil, gilt dies für Arrays mit weniger als 16 Elementen. For the most part, this applies to arrays with fewer than 16 elements.

Siehe auch

Sort(Array, Array, IComparer) Sort(Array, Array, IComparer) Sort(Array, Array, IComparer) Sort(Array, Array, IComparer)

Sortiert ein Paar von eindimensionalen Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei den angegebenen IComparer. Sorts a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer.

public:
 static void Sort(Array ^ keys, Array ^ items, System::Collections::IComparer ^ comparer);
public static void Sort (Array keys, Array items, System.Collections.IComparer comparer);
static member Sort : Array * Array * System.Collections.IComparer -> unit
Public Shared Sub Sort (keys As Array, items As Array, comparer As IComparer)
Parameter
keys
Array Array Array Array

Das eindimensionale Array mit den zu sortierenden Schlüsseln. The one-dimensional Array that contains the keys to sort.

items
Array Array Array Array

Das eindimensionale Array mit den Elementen, die den jeweiligen Schlüsseln im keysArray entsprechen. The one-dimensional Array that contains the items that correspond to each of the keys in the keysArray. - oder - -or- null, wenn nur das keysArray sortiert werden soll. null to sort only the keysArray.

comparer
IComparer IComparer IComparer IComparer

Die IComparer-Implementierung, die beim Vergleich von Elementen verwendet werden soll. The IComparer implementation to use when comparing elements. - oder - -or- null, wenn die IComparable-Implementierung des jeweiligen Elements verwendet werden soll. null to use the IComparable implementation of each element.

Ausnahmen

Das keysArray ist mehrdimensional. The keysArray is multidimensional. - oder - -or- Das itemsArray ist mehrdimensional. The itemsArray is multidimensional.

items ist nicht null, und die Länge von keys ist größer als die Länge von items. items is not null, and the length of keys is greater than the length of items. - oder - -or- Die Implementierung von comparer hat einen Fehler während der Sortierung verursacht. The implementation of comparer caused an error during the sort. Beispielsweise gibt comparer beim Vergleichen eines Elements mit sich selbst möglicherweise nicht 0 zurück. For example, comparer might not return 0 when comparing an item with itself.

comparer ist null, und mindestens ein Element im keysArray implementiert die IComparable-Schnittstelle nicht. comparer is null, and one or more elements in the keysArray do not implement the IComparable interface.

Beispiele

Das folgende Beispiel zeigt, wie zwei verknüpften Arrays sortiert, wobei das erste Array enthält die Schlüssel und das zweite Array enthält die Werte.The following example shows how to sort two associated arrays where the first array contains the keys and the second array contains the values. Sortierungen erfolgen mithilfe des Standardvergleichs und einem benutzerdefinierten Vergleich, der die Sortierreihenfolge umgekehrt.Sorts are done using the default comparer and a custom comparer that reverses the sort order. Beachten Sie, die das Ergebnis, abhängig vom aktuellen variieren kann CultureInfo.Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

public ref class myReverserClass: public IComparer
{
private:

   // Calls CaseInsensitiveComparer::Compare with the parameters reversed.
   virtual int Compare( Object^ x, Object^ y ) = IComparer::Compare
   {
      return ((gcnew CaseInsensitiveComparer)->Compare( y, x ));
   }
};

void PrintKeysAndValues( array<String^>^myKeys, array<String^>^myValues )
{
   for ( int i = 0; i < myKeys->Length; i++ )
   {
      Console::WriteLine( " {0, -10}: {1}", myKeys[ i ], myValues[ i ] );
   }
   Console::WriteLine();
}

int main()
{
   // Creates and initializes a new Array and a new custom comparer.
   array<String^>^myKeys = {"red","GREEN","YELLOW","BLUE","purple","black","orange"};
   array<String^>^myValues = {"strawberries","PEARS","LIMES","BERRIES","grapes","olives","cantaloupe"};
   IComparer^ myComparer = gcnew myReverserClass;

   // Displays the values of the Array.
   Console::WriteLine( "The Array initially contains the following values:" );
   PrintKeysAndValues( myKeys, myValues );

   // Sorts a section of the Array using the default comparer.
   Array::Sort( myKeys, myValues, 1, 3 );
   Console::WriteLine( "After sorting a section of the Array using the default comparer:" );

   // Sorts a section of the Array using the reverse case-insensitive comparer.
   Array::Sort( myKeys, myValues, 1, 3, myComparer );
   Console::WriteLine( "After sorting a section of the Array using the reverse case-insensitive comparer:" );
   PrintKeysAndValues( myKeys, myValues );

   // Sorts the entire Array using the default comparer.
   Array::Sort( myKeys, myValues );
   Console::WriteLine( "After sorting the entire Array using the default comparer:" );
   PrintKeysAndValues( myKeys, myValues );

   // Sorts the entire Array using the reverse case-insensitive comparer.
   Array::Sort( myKeys, myValues, myComparer );
   Console::WriteLine( "After sorting the entire Array using the reverse case-insensitive comparer:" );
   PrintKeysAndValues( myKeys, myValues );
}

/* 
This code produces the following output.

The Array initially contains the following values:
   red       : strawberries
   GREEN     : PEARS
   YELLOW    : LIMES
   BLUE      : BERRIES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting a section of the Array using the default comparer:
   red       : strawberries
   BLUE      : BERRIES
   GREEN     : PEARS
   YELLOW    : LIMES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting a section of the Array using the reverse case-insensitive comparer:
   red       : strawberries
   YELLOW    : LIMES
   GREEN     : PEARS
   BLUE      : BERRIES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting the entire Array using the default comparer:
   black     : olives
   BLUE      : BERRIES
   GREEN     : PEARS
   orange    : cantaloupe
   purple    : grapes
   red       : strawberries
   YELLOW    : LIMES

After sorting the entire Array using the reverse case-insensitive comparer:
   YELLOW    : LIMES
   red       : strawberries
   purple    : grapes
   orange    : cantaloupe
   GREEN     : PEARS
   BLUE      : BERRIES
   black     : olives

*/
using System;
using System.Collections;

public class SamplesArray  {
 
   public class myReverserClass : IComparer  {

      // Calls CaseInsensitiveComparer.Compare with the parameters reversed.
      int IComparer.Compare( Object x, Object y )  {
          return( (new CaseInsensitiveComparer()).Compare( y, x ) );
      }

   }

   public static void Main()  {
 
      // Creates and initializes a new Array and a new custom comparer.
      String[] myKeys = { "red", "GREEN", "YELLOW", "BLUE", "purple", "black", "orange" };
      String[] myValues = { "strawberries", "PEARS", "LIMES", "BERRIES", "grapes", "olives", "cantaloupe" };
      IComparer myComparer = new myReverserClass();
 
      // Displays the values of the Array.
      Console.WriteLine( "The Array initially contains the following values:" );
      PrintKeysAndValues( myKeys, myValues );
 
      // Sorts a section of the Array using the default comparer.
      Array.Sort( myKeys, myValues, 1, 3 );
      Console.WriteLine( "After sorting a section of the Array using the default comparer:" );
      PrintKeysAndValues( myKeys, myValues );

      // Sorts a section of the Array using the reverse case-insensitive comparer.
      Array.Sort( myKeys, myValues, 1, 3, myComparer );
      Console.WriteLine( "After sorting a section of the Array using the reverse case-insensitive comparer:" );
      PrintKeysAndValues( myKeys, myValues );

      // Sorts the entire Array using the default comparer.
      Array.Sort( myKeys, myValues );
      Console.WriteLine( "After sorting the entire Array using the default comparer:" );
      PrintKeysAndValues( myKeys, myValues );

      // Sorts the entire Array using the reverse case-insensitive comparer.
      Array.Sort( myKeys, myValues, myComparer );
      Console.WriteLine( "After sorting the entire Array using the reverse case-insensitive comparer:" );
      PrintKeysAndValues( myKeys, myValues );

   }
 
   public static void PrintKeysAndValues( String[] myKeys, String[] myValues )  {
      for ( int i = 0; i < myKeys.Length; i++ )  {
         Console.WriteLine( "   {0,-10}: {1}", myKeys[i], myValues[i] );
      }
      Console.WriteLine();
   }
}


/* 
This code produces the following output.

The Array initially contains the following values:
   red       : strawberries
   GREEN     : PEARS
   YELLOW    : LIMES
   BLUE      : BERRIES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting a section of the Array using the default comparer:
   red       : strawberries
   BLUE      : BERRIES
   GREEN     : PEARS
   YELLOW    : LIMES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting a section of the Array using the reverse case-insensitive comparer:
   red       : strawberries
   YELLOW    : LIMES
   GREEN     : PEARS
   BLUE      : BERRIES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting the entire Array using the default comparer:
   black     : olives
   BLUE      : BERRIES
   GREEN     : PEARS
   orange    : cantaloupe
   purple    : grapes
   red       : strawberries
   YELLOW    : LIMES

After sorting the entire Array using the reverse case-insensitive comparer:
   YELLOW    : LIMES
   red       : strawberries
   purple    : grapes
   orange    : cantaloupe
   GREEN     : PEARS
   BLUE      : BERRIES
   black     : olives

*/

Imports System
Imports System.Collections

Public Class SamplesArray

   Public Class myReverserClass
      Implements IComparer

      ' Calls CaseInsensitiveComparer.Compare with the parameters reversed.
      Function Compare(x As [Object], y As [Object]) As Integer _
         Implements IComparer.Compare
         Return New CaseInsensitiveComparer().Compare(y, x)
      End Function 'IComparer.Compare

   End Class 'myReverserClass


   Public Shared Sub Main()

      ' Creates and initializes a new Array and a new custom comparer.
      Dim myKeys As [String]() =  {"red", "GREEN", "YELLOW", "BLUE", "purple", "black", "orange"}
      Dim myValues As [String]() =  {"strawberries", "PEARS", "LIMES", "BERRIES", "grapes", "olives", "cantaloupe"}
      Dim myComparer = New myReverserClass()

      ' Displays the values of the Array.
      Console.WriteLine("The Array initially contains the following values:")
      PrintKeysAndValues(myKeys, myValues)

      ' Sorts a section of the Array using the default comparer.
      Array.Sort(myKeys, myValues, 1, 3)
      Console.WriteLine("After sorting a section of the Array using the default comparer:")
      PrintKeysAndValues(myKeys, myValues)

      ' Sorts a section of the Array using the reverse case-insensitive comparer.
      Array.Sort(myKeys, myValues, 1, 3, myComparer)
      Console.WriteLine("After sorting a section of the Array using the reverse case-insensitive comparer:")
      PrintKeysAndValues(myKeys, myValues)

      ' Sorts the entire Array using the default comparer.
      Array.Sort(myKeys, myValues)
      Console.WriteLine("After sorting the entire Array using the default comparer:")
      PrintKeysAndValues(myKeys, myValues)

      ' Sorts the entire Array using the reverse case-insensitive comparer.
      Array.Sort(myKeys, myValues, myComparer)
      Console.WriteLine("After sorting the entire Array using the reverse case-insensitive comparer:")
      PrintKeysAndValues(myKeys, myValues)

   End Sub 'Main


   Public Shared Sub PrintKeysAndValues(myKeys() As [String], myValues() As [String])

      Dim i As Integer
      For i = 0 To myKeys.Length - 1
         Console.WriteLine("   {0,-10}: {1}", myKeys(i), myValues(i))
      Next i
      Console.WriteLine()

   End Sub 'PrintKeysAndValues

End Class 'SamplesArray


'This code produces the following output.
'
'The Array initially contains the following values:
'   red       : strawberries
'   GREEN     : PEARS
'   YELLOW    : LIMES
'   BLUE      : BERRIES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting a section of the Array using the default comparer:
'   red       : strawberries
'   BLUE      : BERRIES
'   GREEN     : PEARS
'   YELLOW    : LIMES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting a section of the Array using the reverse case-insensitive comparer:
'   red       : strawberries
'   YELLOW    : LIMES
'   GREEN     : PEARS
'   BLUE      : BERRIES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting the entire Array using the default comparer:
'   black     : olives
'   BLUE      : BERRIES
'   GREEN     : PEARS
'   orange    : cantaloupe
'   purple    : grapes
'   red       : strawberries
'   YELLOW    : LIMES
'
'After sorting the entire Array using the reverse case-insensitive comparer:
'   YELLOW    : LIMES
'   red       : strawberries
'   purple    : grapes
'   orange    : cantaloupe
'   GREEN     : PEARS
'   BLUE      : BERRIES
'   black     : olives

Hinweise

Jeder Schlüssel in der keys Array verfügt über ein entsprechendes Element in der items Array.Each key in the keysArray has a corresponding item in the itemsArray. Wenn ein Schlüssel wird neu angeordnet, bei der Sortierung, des entsprechenden Elements in der items Array wird neu positioniert.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Aus diesem Grund die items Array sortiert wird, entsprechend der Anordnung der entsprechenden Schlüssel in der keys Array.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Wenn comparer ist null, die jeweils-Schlüssel in der keys Array müssen implementieren die IComparable Benutzeroberfläche kann mit jedem anderen Schlüssel verglichen werden.If comparer is null, each key in the keysArray must implement the IComparable interface to be capable of comparisons with every other key.

Sie können sortiert, wenn es mehr Elemente als Schlüssel gibt, aber die Elemente, die ohne entsprechenden Schlüssel werden nicht sortiert.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Wenn es weitere Schlüssel als Elemente können nicht sortiert werden; Dies löst dies eine ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Wenn die Sortierung nicht erfolgreich abgeschlossen wird, sind die Ergebnisse nicht definiert.If the sort is not successfully completed, the results are undefined.

.NET Framework enthält vordefinierte IComparer Implementierungen in der folgenden Tabelle aufgeführt.The .NET Framework includes predefined IComparer implementations listed in the following table.

ImplementierungImplementation Beschreibung Description
System.Collections.CaseInsensitiveComparer Vergleicht zwei Objekte, jedoch führt einen Vergleich Groß-/Kleinschreibung von Zeichenfolgen.Compares any two objects, but performs a case-insensitive comparison of strings.
Comparer.Default Vergleicht zwei Objekte mithilfe der Sortierkonventionen der aktuellen Kultur.Compares any two objects by using the sorting conventions of the current culture.
Comparer.DefaultInvariant Vergleicht zwei Objekte mithilfe der Sortierkonventionen der invarianten Kultur.Compares any two objects by using the sorting conventions of the invariant culture.
Comparer<T>.Default Vergleicht zwei Objekte des Typs T mithilfe von Standard-Sortierreihenfolge des Typs.Compares two objects of type T by using the type's default sort order.

Sie können auch benutzerdefinierte Vergleiche unterstützen, durch die Bereitstellung einer Instanz Ihrer eigenen IComparer Implementierung, die die comparer Parameter.You can also support custom comparisons by providing an instance of your own IComparer implementation to the comparer parameter. Durch die Definition wird im Beispiel ein IComparer Implementierung, kehrt die Standardsortierreihenfolge und führt die Groß-/Kleinschreibung Zeichenfolgenvergleich.The example does this by defining an IComparer implementation that reverses the default sort order and performs case-insensitive string comparison.

Diese Methode verwendet die Beobachtung der inneren Abläufe Sortieralgorithmus (Introsort) wie folgt aus:This method uses the introspective sort (introsort) algorithm as follows:

  • Wenn die Größe der Partition weniger als 16 Elementen ist, wird ein Einfügesortierung Algorithmus.If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Überschreitet die Anzahl der Partitionen 2 * LogN, wobei N ist der Bereich des Eingabearrays, er verwendet eine Heapsort Algorithmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • Andernfalls verwendet es, eine Quicksort Algorithmus.Otherwise, it uses a Quicksort algorithm.

Diese Implementierung führt eine instabile Sortierung. d.h., wenn zwei Elemente gleich sind, möglicherweise die Reihenfolge nicht beibehalten.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Im Gegensatz dazu behält eine stabile Sortierung, die Reihenfolge der Elemente, die gleich sind.In contrast, a stable sort preserves the order of elements that are equal.

Für Arrays, die mithilfe von Algorithmen Heapsort und wenden die Schnellsortierung im schlimmsten Fall sortiert sind, ist diese Methode eine O (n Log n)-Vorgang, in denen n ist die Length von keys.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is the Length of keys.

Hinweise für Aufrufer

Die .NET Framework 4 und früheren Versionen verwendet nur den Quicksort-Algorithmus. The .NET Framework 4 and earlier versions used only the Quicksort algorithm. QuickSort identifiziert die ungültige Vergleiche in einigen Situationen, in dem der Sortiervorgang löst, eine IndexOutOfRangeException -Ausnahme aus, und löst eine ArgumentException Ausnahme an den Aufrufer. Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Beginnend mit der .NET Framework 4.5.NET Framework 4.5, es ist möglich, die Sortiervorgänge, Previouslythrew ArgumentException wird keine Ausnahme, da die Einfügung sortieren und Heapsort Algorithmen eine ungültige Vergleich nicht erkennen. Starting with the .NET Framework 4.5.NET Framework 4.5, it is possible that sorting operations that previouslythrew ArgumentException will not throw an exception, becausethe insertion sort and heapsort algorithms do not detect an invalid comparer. Zum größten Teil, gilt dies für Arrays mit weniger als 16 Elementen. For the most part, this applies to arrays with fewer than 16 elements.

Siehe auch

Sort(Array, Array) Sort(Array, Array) Sort(Array, Array) Sort(Array, Array)

Sortiert ein Paar von eindimensionalen Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei die IComparable-Implementierung jedes Schlüssels. Sorts a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable implementation of each key.

public:
 static void Sort(Array ^ keys, Array ^ items);
public static void Sort (Array keys, Array items);
static member Sort : Array * Array -> unit
Public Shared Sub Sort (keys As Array, items As Array)
Parameter
keys
Array Array Array Array

Das eindimensionale Array mit den zu sortierenden Schlüsseln. The one-dimensional Array that contains the keys to sort.

items
Array Array Array Array

Das eindimensionale Array mit den Elementen, die den jeweiligen Schlüsseln im keysArray entsprechen. The one-dimensional Array that contains the items that correspond to each of the keys in the keysArray. - oder - -or- null, wenn nur das keysArray sortiert werden soll. null to sort only the keysArray.

Ausnahmen

Das keysArray ist mehrdimensional. The keysArray is multidimensional. - oder - -or- Das itemsArray ist mehrdimensional. The itemsArray is multidimensional.

items ist nicht null, und die Länge von keys ist größer als die Länge von items. items is not null, and the length of keys is greater than the length of items.

Mindestens ein Element im keysArray implementiert die IComparable-Schnittstelle nicht. One or more elements in the keysArray do not implement the IComparable interface.

Beispiele

Das folgende Beispiel zeigt, wie zwei verknüpften Arrays sortiert, wobei das erste Array enthält die Schlüssel und das zweite Array enthält die Werte.The following example shows how to sort two associated arrays where the first array contains the keys and the second array contains the values. Sortierungen erfolgen mithilfe des Standardvergleichs und einem benutzerdefinierten Vergleich, der die Sortierreihenfolge umgekehrt.Sorts are done using the default comparer and a custom comparer that reverses the sort order. Beachten Sie, die das Ergebnis, abhängig vom aktuellen variieren kann CultureInfo.Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

public ref class myReverserClass: public IComparer
{
private:

   // Calls CaseInsensitiveComparer::Compare with the parameters reversed.
   virtual int Compare( Object^ x, Object^ y ) = IComparer::Compare
   {
      return ((gcnew CaseInsensitiveComparer)->Compare( y, x ));
   }
};

void PrintKeysAndValues( array<String^>^myKeys, array<String^>^myValues )
{
   for ( int i = 0; i < myKeys->Length; i++ )
   {
      Console::WriteLine( " {0, -10}: {1}", myKeys[ i ], myValues[ i ] );
   }
   Console::WriteLine();
}

int main()
{
   // Creates and initializes a new Array and a new custom comparer.
   array<String^>^myKeys = {"red","GREEN","YELLOW","BLUE","purple","black","orange"};
   array<String^>^myValues = {"strawberries","PEARS","LIMES","BERRIES","grapes","olives","cantaloupe"};
   IComparer^ myComparer = gcnew myReverserClass;

   // Displays the values of the Array.
   Console::WriteLine( "The Array initially contains the following values:" );
   PrintKeysAndValues( myKeys, myValues );

   // Sorts a section of the Array using the default comparer.
   Array::Sort( myKeys, myValues, 1, 3 );
   Console::WriteLine( "After sorting a section of the Array using the default comparer:" );

   // Sorts a section of the Array using the reverse case-insensitive comparer.
   Array::Sort( myKeys, myValues, 1, 3, myComparer );
   Console::WriteLine( "After sorting a section of the Array using the reverse case-insensitive comparer:" );
   PrintKeysAndValues( myKeys, myValues );

   // Sorts the entire Array using the default comparer.
   Array::Sort( myKeys, myValues );
   Console::WriteLine( "After sorting the entire Array using the default comparer:" );
   PrintKeysAndValues( myKeys, myValues );

   // Sorts the entire Array using the reverse case-insensitive comparer.
   Array::Sort( myKeys, myValues, myComparer );
   Console::WriteLine( "After sorting the entire Array using the reverse case-insensitive comparer:" );
   PrintKeysAndValues( myKeys, myValues );
}

/* 
This code produces the following output.

The Array initially contains the following values:
   red       : strawberries
   GREEN     : PEARS
   YELLOW    : LIMES
   BLUE      : BERRIES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting a section of the Array using the default comparer:
   red       : strawberries
   BLUE      : BERRIES
   GREEN     : PEARS
   YELLOW    : LIMES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting a section of the Array using the reverse case-insensitive comparer:
   red       : strawberries
   YELLOW    : LIMES
   GREEN     : PEARS
   BLUE      : BERRIES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting the entire Array using the default comparer:
   black     : olives
   BLUE      : BERRIES
   GREEN     : PEARS
   orange    : cantaloupe
   purple    : grapes
   red       : strawberries
   YELLOW    : LIMES

After sorting the entire Array using the reverse case-insensitive comparer:
   YELLOW    : LIMES
   red       : strawberries
   purple    : grapes
   orange    : cantaloupe
   GREEN     : PEARS
   BLUE      : BERRIES
   black     : olives

*/
using System;
using System.Collections;

public class SamplesArray  {
 
   public class myReverserClass : IComparer  {

      // Calls CaseInsensitiveComparer.Compare with the parameters reversed.
      int IComparer.Compare( Object x, Object y )  {
          return( (new CaseInsensitiveComparer()).Compare( y, x ) );
      }

   }

   public static void Main()  {
 
      // Creates and initializes a new Array and a new custom comparer.
      String[] myKeys = { "red", "GREEN", "YELLOW", "BLUE", "purple", "black", "orange" };
      String[] myValues = { "strawberries", "PEARS", "LIMES", "BERRIES", "grapes", "olives", "cantaloupe" };
      IComparer myComparer = new myReverserClass();
 
      // Displays the values of the Array.
      Console.WriteLine( "The Array initially contains the following values:" );
      PrintKeysAndValues( myKeys, myValues );
 
      // Sorts a section of the Array using the default comparer.
      Array.Sort( myKeys, myValues, 1, 3 );
      Console.WriteLine( "After sorting a section of the Array using the default comparer:" );
      PrintKeysAndValues( myKeys, myValues );

      // Sorts a section of the Array using the reverse case-insensitive comparer.
      Array.Sort( myKeys, myValues, 1, 3, myComparer );
      Console.WriteLine( "After sorting a section of the Array using the reverse case-insensitive comparer:" );
      PrintKeysAndValues( myKeys, myValues );

      // Sorts the entire Array using the default comparer.
      Array.Sort( myKeys, myValues );
      Console.WriteLine( "After sorting the entire Array using the default comparer:" );
      PrintKeysAndValues( myKeys, myValues );

      // Sorts the entire Array using the reverse case-insensitive comparer.
      Array.Sort( myKeys, myValues, myComparer );
      Console.WriteLine( "After sorting the entire Array using the reverse case-insensitive comparer:" );
      PrintKeysAndValues( myKeys, myValues );

   }
 
   public static void PrintKeysAndValues( String[] myKeys, String[] myValues )  {
      for ( int i = 0; i < myKeys.Length; i++ )  {
         Console.WriteLine( "   {0,-10}: {1}", myKeys[i], myValues[i] );
      }
      Console.WriteLine();
   }
}


/* 
This code produces the following output.

The Array initially contains the following values:
   red       : strawberries
   GREEN     : PEARS
   YELLOW    : LIMES
   BLUE      : BERRIES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting a section of the Array using the default comparer:
   red       : strawberries
   BLUE      : BERRIES
   GREEN     : PEARS
   YELLOW    : LIMES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting a section of the Array using the reverse case-insensitive comparer:
   red       : strawberries
   YELLOW    : LIMES
   GREEN     : PEARS
   BLUE      : BERRIES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting the entire Array using the default comparer:
   black     : olives
   BLUE      : BERRIES
   GREEN     : PEARS
   orange    : cantaloupe
   purple    : grapes
   red       : strawberries
   YELLOW    : LIMES

After sorting the entire Array using the reverse case-insensitive comparer:
   YELLOW    : LIMES
   red       : strawberries
   purple    : grapes
   orange    : cantaloupe
   GREEN     : PEARS
   BLUE      : BERRIES
   black     : olives

*/

Imports System
Imports System.Collections

Public Class SamplesArray

   Public Class myReverserClass
      Implements IComparer

      ' Calls CaseInsensitiveComparer.Compare with the parameters reversed.
      Function Compare(x As [Object], y As [Object]) As Integer _
         Implements IComparer.Compare
         Return New CaseInsensitiveComparer().Compare(y, x)
      End Function 'IComparer.Compare

   End Class 'myReverserClass


   Public Shared Sub Main()

      ' Creates and initializes a new Array and a new custom comparer.
      Dim myKeys As [String]() =  {"red", "GREEN", "YELLOW", "BLUE", "purple", "black", "orange"}
      Dim myValues As [String]() =  {"strawberries", "PEARS", "LIMES", "BERRIES", "grapes", "olives", "cantaloupe"}
      Dim myComparer = New myReverserClass()

      ' Displays the values of the Array.
      Console.WriteLine("The Array initially contains the following values:")
      PrintKeysAndValues(myKeys, myValues)

      ' Sorts a section of the Array using the default comparer.
      Array.Sort(myKeys, myValues, 1, 3)
      Console.WriteLine("After sorting a section of the Array using the default comparer:")
      PrintKeysAndValues(myKeys, myValues)

      ' Sorts a section of the Array using the reverse case-insensitive comparer.
      Array.Sort(myKeys, myValues, 1, 3, myComparer)
      Console.WriteLine("After sorting a section of the Array using the reverse case-insensitive comparer:")
      PrintKeysAndValues(myKeys, myValues)

      ' Sorts the entire Array using the default comparer.
      Array.Sort(myKeys, myValues)
      Console.WriteLine("After sorting the entire Array using the default comparer:")
      PrintKeysAndValues(myKeys, myValues)

      ' Sorts the entire Array using the reverse case-insensitive comparer.
      Array.Sort(myKeys, myValues, myComparer)
      Console.WriteLine("After sorting the entire Array using the reverse case-insensitive comparer:")
      PrintKeysAndValues(myKeys, myValues)

   End Sub 'Main


   Public Shared Sub PrintKeysAndValues(myKeys() As [String], myValues() As [String])

      Dim i As Integer
      For i = 0 To myKeys.Length - 1
         Console.WriteLine("   {0,-10}: {1}", myKeys(i), myValues(i))
      Next i
      Console.WriteLine()

   End Sub 'PrintKeysAndValues

End Class 'SamplesArray


'This code produces the following output.
'
'The Array initially contains the following values:
'   red       : strawberries
'   GREEN     : PEARS
'   YELLOW    : LIMES
'   BLUE      : BERRIES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting a section of the Array using the default comparer:
'   red       : strawberries
'   BLUE      : BERRIES
'   GREEN     : PEARS
'   YELLOW    : LIMES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting a section of the Array using the reverse case-insensitive comparer:
'   red       : strawberries
'   YELLOW    : LIMES
'   GREEN     : PEARS
'   BLUE      : BERRIES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting the entire Array using the default comparer:
'   black     : olives
'   BLUE      : BERRIES
'   GREEN     : PEARS
'   orange    : cantaloupe
'   purple    : grapes
'   red       : strawberries
'   YELLOW    : LIMES
'
'After sorting the entire Array using the reverse case-insensitive comparer:
'   YELLOW    : LIMES
'   red       : strawberries
'   purple    : grapes
'   orange    : cantaloupe
'   GREEN     : PEARS
'   BLUE      : BERRIES
'   black     : olives

Hinweise

Jeder Schlüssel in der keys Array verfügt über ein entsprechendes Element in der items Array.Each key in the keysArray has a corresponding item in the itemsArray. Wenn ein Schlüssel wird neu angeordnet, bei der Sortierung, des entsprechenden Elements in der items Array wird neu positioniert.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Aus diesem Grund die items Array sortiert wird, entsprechend der Anordnung der entsprechenden Schlüssel in der keys Array.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Jeder Schlüssel in der keys Array müssen implementieren die IComparable Benutzeroberfläche kann mit jedem anderen Schlüssel verglichen werden.Each key in the keysArray must implement the IComparable interface to be capable of comparisons with every other key.

Sie können sortiert, wenn es mehr Elemente als Schlüssel gibt, aber die Elemente, die ohne entsprechenden Schlüssel werden nicht sortiert.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Wenn es weitere Schlüssel als Elemente können nicht sortiert werden; Dies löst dies eine ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Wenn die Sortierung nicht erfolgreich abgeschlossen wird, sind die Ergebnisse nicht definiert.If the sort is not successfully completed, the results are undefined.

Diese Methode verwendet die Beobachtung der inneren Abläufe Sortieralgorithmus (Introsort) wie folgt aus:This method uses the introspective sort (introsort) algorithm as follows:

  • Wenn die Größe der Partition weniger als 16 Elementen ist, wird ein Einfügesortierung Algorithmus.If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Überschreitet die Anzahl der Partitionen 2 * LogN, wobei N ist der Bereich des Eingabearrays, er verwendet eine Heapsort Algorithmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • Andernfalls verwendet es, eine Quicksort Algorithmus.Otherwise, it uses a Quicksort algorithm.

Diese Implementierung führt eine instabile Sortierung. d.h., wenn zwei Elemente gleich sind, möglicherweise die Reihenfolge nicht beibehalten.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Im Gegensatz dazu behält eine stabile Sortierung, die Reihenfolge der Elemente, die gleich sind.In contrast, a stable sort preserves the order of elements that are equal.

Für Arrays, die mithilfe von Algorithmen Heapsort und wenden die Schnellsortierung im schlimmsten Fall sortiert sind, ist diese Methode eine O (n Log n)-Vorgang, in denen n ist die Length von keys.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is the Length of keys.

Siehe auch

Sort(Array) Sort(Array) Sort(Array)

Sortiert die Elemente in einem ganzen eindimensionalen Array mithilfe der IComparable-Implementierung jedes Elements des Array. Sorts the elements in an entire one-dimensional Array using the IComparable implementation of each element of the Array.

public:
 static void Sort(Array ^ array);
public static void Sort (Array array);
static member Sort : Array -> unit
Parameter
array
Array Array Array Array

Das zu sortierende eindimensionale Array. The one-dimensional Array to sort.

Ausnahmen

array ist mehrdimensional. array is multidimensional.

Mindestens ein Element in array implementiert die IComparable-Schnittstelle nicht. One or more elements in array do not implement the IComparable interface.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie zum Sortieren der Werte in einer Array mithilfe des Standardvergleichs und einem benutzerdefinierten Vergleich, der die Sortierreihenfolge umgekehrt.The following code example shows how to sort the values in an Array using the default comparer and a custom comparer that reverses the sort order. Beachten Sie, die das Ergebnis, abhängig vom aktuellen variieren kann CultureInfo.Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

public ref class ReverseComparer : IComparer
{
public:
   // Call CaseInsensitiveComparer::Compare with the parameters reversed.
   virtual int Compare(Object^ x, Object^ y) = IComparer::Compare
   {
      return ((gcnew CaseInsensitiveComparer)->Compare(y, x));
   }
};

void DisplayValues(array<String^>^ arr)
{
   for (int i = arr->GetLowerBound(0); i <= arr->GetUpperBound(0); i++)
      Console::WriteLine( "   [{0}] : {1}", i, arr[ i ] );

   Console::WriteLine();
}

int main()
{
   // Create and initialize a new array. and a new custom comparer.
   array<String^>^ words = { "The","QUICK","BROWN","FOX","jumps",
                             "over","the","lazy","dog" };
   // Instantiate the reverse comparer.
   IComparer^ revComparer = gcnew 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);
}

/* 
This code produces the following output.

The Array initially contains the following values:
   [0] : The
   [1] : QUICK
   [2] : BROWN
   [3] : FOX
   [4] : jumps
   [5] : over
   [6] : the
   [7] : lazy
   [8] : dog

After sorting a section of the Array using the default comparer:
   [0] : The
   [1] : BROWN
   [2] : FOX
   [3] : QUICK
   [4] : jumps
   [5] : over
   [6] : the
   [7] : lazy
   [8] : dog

After sorting a section of the Array 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 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

*/
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    
Imports System.Collections

Public Class ReverseComparer : Implements IComparer
   ' Call CaseInsensitiveComparer.Compare with the parameters reversed.
   Function Compare(x As Object, y As Object) As Integer _
            Implements IComparer.Compare
      Return New CaseInsensitiveComparer().Compare(y, x)
   End Function 
End Class

Public Module Example
   Public Sub Main()
      ' Create and initialize a new array.
      Dim words() As String =  { "The", "QUICK", "BROWN", "FOX", "jumps", 
                                 "over", "the", "lazy", "dog" }
      ' Instantiate a new custom comparer.
      Dim revComparer As 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)
   End Sub 

   Public Sub DisplayValues(arr() As String)
      For i As Integer = arr.GetLowerBound(0) To arr.GetUpperBound(0)
         Console.WriteLine("   [{0}] : {1}", i, arr(i))
      Next 
      Console.WriteLine()
   End Sub 
End Module 
' 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

Hinweise

Jedes Element der array müssen implementieren die IComparable Schnittstelle kann Vergleiche mit jedem anderen Element im array.Each element of array must implement the IComparable interface to be capable of comparisons with every other element in array.

Wenn die Sortierung nicht erfolgreich abgeschlossen wird, sind die Ergebnisse nicht definiert.If the sort is not successfully completed, the results are undefined.

Diese Methode verwendet die Beobachtung der inneren Abläufe Sortieralgorithmus (Introsort) wie folgt aus:This method uses the introspective sort (introsort) algorithm as follows:

  • Wenn die Größe der Partition weniger als 16 Elementen ist, wird ein Einfügesortierung Algorithmus.If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Überschreitet die Anzahl der Partitionen 2 * LogN, wobei N ist der Bereich des Eingabearrays, er verwendet eine Heapsort Algorithmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • Andernfalls verwendet es, eine Quicksort Algorithmus.Otherwise, it uses a Quicksort algorithm.

Diese Implementierung führt eine instabile Sortierung. d.h., wenn zwei Elemente gleich sind, möglicherweise die Reihenfolge nicht beibehalten.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Im Gegensatz dazu behält eine stabile Sortierung, die Reihenfolge der Elemente, die gleich sind.In contrast, a stable sort preserves the order of elements that are equal.

Für Arrays, die mithilfe von Algorithmen Heapsort und wenden die Schnellsortierung im schlimmsten Fall sortiert sind, ist diese Methode eine O (n Log n)-Vorgang, in denen n ist die Length von array.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is the Length of array.

Siehe auch

Sort<T>(T[]) Sort<T>(T[]) Sort<T>(T[]) Sort<T>(T[])

Sortiert die Elemente in einem ganzen Array mithilfe der Implementierung der generischen IComparable<T>-Schnittstelle jedes Elements des Array. Sorts the elements in an entire Array using the IComparable<T> generic interface implementation of each element of the Array.

public:
generic <typename T>
 static void Sort(cli::array <T> ^ array);
public static void Sort<T> (T[] array);
static member Sort : 'T[] -> unit
Public Shared Sub Sort(Of T) (array As T())
Typparameter
T

Der Typ der Elemente des Arrays. The type of the elements of the array.

Parameter
array
T[]

Das zu sortierende eindimensionale und nullbasierte Array. The one-dimensional, zero-based Array to sort.

Ausnahmen

Mindestens ein Element in array implementiert die generische IComparable<T>-Schnittstelle nicht. One or more elements in array do not implement the IComparable<T> generic interface.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, die Sort<T>(T[]) generischen methodenüberladung und BinarySearch<T>(T[], T) generischen methodenüberladung.The following code example demonstrates the Sort<T>(T[]) generic method overload and the BinarySearch<T>(T[], T) generic method overload. Ein Array von Zeichenfolgen wird in keiner bestimmten Reihenfolge erstellt.An array of strings is created, in no particular order.

Das Array wird angezeigt, sortiert und erneut angezeigt.The array is displayed, sorted, and displayed again.

Hinweis

Die Aufrufe an die Sort und BinarySearch generische Methoden sind nicht anders als die Aufrufe an ihre nicht generischen Entsprechungen, gesucht, da Visual Basic, c# und C++ den Typ des generischen Typparameters aus dem Typ des ersten Arguments abzuleiten.The calls to the Sort and BinarySearch generic methods do not look any different from calls to their nongeneric counterparts, because Visual Basic, C#, and C++ infer the type of the generic type parameter from the type of the first argument. Bei Verwendung der Ildasm.exe (IL Disassembler) um die Microsoft intermediate Language (MSIL) zu untersuchen, sehen Sie, dass die generischen Methoden aufgerufen werden.If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

Die BinarySearch<T>(T[], T) generischen methodenüberladung klicken Sie dann zum Suchen nach zwei Zeichenfolgen verwendet wird, ist eine, die nicht in das Array und einer ist.The BinarySearch<T>(T[], T) generic method overload is then used to search for two strings, one that is not in the array and one that is. Das Array und der Rückgabewert von der BinarySearch Methode übergeben werden, um die ShowWhere generische Methode, die den Indexwert zeigt an, wenn die Zeichenfolge gefunden wurde, und andernfalls die Elemente die Suchzeichenfolge fiel zwischen handele es sich im Array.The array and the return value of the BinarySearch method are passed to the ShowWhere generic method, which displays the index value if the string is found, and otherwise the elements the search string would fall between if it were in the array. Der Index ist negativ, wenn die Zeichenfolge nicht n ist das Array, also die ShowWhere Methode nimmt das bitweise Komplement (der ~-Operator in c# und Visual C++, Xor -1 in Visual Basic), die den Index des ersten Elements in der Liste zu erhalten, die größer als die Suche Stri NG.The index is negative if the string is not n the array, so the ShowWhere method takes the bitwise complement (the ~ operator in C# and Visual C++, Xor -1 in Visual Basic) to obtain the index of the first element in the list that is larger than the search string.

using namespace System;
using namespace System::Collections::Generic;

generic<typename T> void ShowWhere(array<T>^ arr, int index)
{
    if (index<0)
    {
        // If the index is negative, it represents the bitwise
        // complement of the next larger element in the array.
        //
        index = ~index;

        Console::Write("Not found. Sorts between: ");

        if (index == 0)
            Console::Write("beginning of array and ");
        else
            Console::Write("{0} and ", arr[index-1]);

        if (index == arr->Length)
            Console::WriteLine("end of array.");
        else
            Console::WriteLine("{0}.", arr[index]);
    }
    else
    {
        Console::WriteLine("Found at index {0}.", index);
    }
};

void main()
{
    array<String^>^ dinosaurs = {"Pachycephalosaurus", 
                                 "Amargasaurus", 
                                 "Tyrannosaurus", 
                                 "Mamenchisaurus", 
                                 "Deinonychus", 
                                 "Edmontosaurus"};

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\nSort");
    Array::Sort(dinosaurs);

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\nBinarySearch for 'Coelophysis':");
    int index = Array::BinarySearch(dinosaurs, "Coelophysis");
    ShowWhere(dinosaurs, index);

    Console::WriteLine("\nBinarySearch for 'Tyrannosaurus':");
    index = Array::BinarySearch(dinosaurs, "Tyrannosaurus");
    ShowWhere(dinosaurs, index);
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Tyrannosaurus
Mamenchisaurus
Deinonychus
Edmontosaurus

Sort

Amargasaurus
Deinonychus
Edmontosaurus
Mamenchisaurus
Pachycephalosaurus
Tyrannosaurus

BinarySearch for 'Coelophysis':
Not found. Sorts between: Amargasaurus and Deinonychus.

BinarySearch for 'Tyrannosaurus':
Found at index 5.
 */
using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = {"Pachycephalosaurus", 
                              "Amargasaurus", 
                              "Tyrannosaurus", 
                              "Mamenchisaurus", 
                              "Deinonychus", 
                              "Edmontosaurus"};

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

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

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

        Console.WriteLine("\nBinarySearch for 'Coelophysis':");
        int index = Array.BinarySearch(dinosaurs, "Coelophysis");
        ShowWhere(dinosaurs, index);

        Console.WriteLine("\nBinarySearch for 'Tyrannosaurus':");
        index = Array.BinarySearch(dinosaurs, "Tyrannosaurus");
        ShowWhere(dinosaurs, index);
    }

    private static void ShowWhere<T>(T[] array, int index)
    {
        if (index<0)
        {
            // If the index is negative, it represents the bitwise
            // complement of the next larger element in the array.
            //
            index = ~index;

            Console.Write("Not found. Sorts between: ");

            if (index == 0)
                Console.Write("beginning of array and ");
            else
                Console.Write("{0} and ", array[index-1]);

            if (index == array.Length)
                Console.WriteLine("end of array.");
            else
                Console.WriteLine("{0}.", array[index]);
        }
        else
        {
            Console.WriteLine("Found at index {0}.", index);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Tyrannosaurus
Mamenchisaurus
Deinonychus
Edmontosaurus

Sort

Amargasaurus
Deinonychus
Edmontosaurus
Mamenchisaurus
Pachycephalosaurus
Tyrannosaurus

BinarySearch for 'Coelophysis':
Not found. Sorts between: Amargasaurus and Deinonychus.

BinarySearch for 'Tyrannosaurus':
Found at index 5.
 */
Imports System
Imports System.Collections.Generic

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Pachycephalosaurus", _
            "Amargasaurus", _
            "Tyrannosaurus", _
            "Mamenchisaurus", _
            "Deinonychus", _
            "Edmontosaurus"  }

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & "Sort")
        Array.Sort(dinosaurs)

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "BinarySearch for 'Coelophysis':")
        Dim index As Integer = _
            Array.BinarySearch(dinosaurs, "Coelophysis")
        ShowWhere(dinosaurs, index)

        Console.WriteLine(vbLf & _
            "BinarySearch for 'Tyrannosaurus':")
        index = Array.BinarySearch(dinosaurs, "Tyrannosaurus")
        ShowWhere(dinosaurs, index)

    End Sub

    Private Shared Sub ShowWhere(Of T) _
        (ByVal array() As T, ByVal index As Integer) 

        If index < 0 Then
            ' If the index is negative, it represents the bitwise
            ' complement of the next larger element in the array.
            '
            index = index Xor -1

            Console.Write("Not found. Sorts between: ")

            If index = 0 Then
                Console.Write("beginning of array and ")
            Else
                Console.Write("{0} and ", array(index - 1))
            End If 

            If index = array.Length Then
                Console.WriteLine("end of array.")
            Else
                Console.WriteLine("{0}.", array(index))
            End If 
        Else
            Console.WriteLine("Found at index {0}.", index)
        End If

    End Sub

End Class

' This code example produces the following output:
'
'Pachycephalosaurus
'Amargasaurus
'Tyrannosaurus
'Mamenchisaurus
'Deinonychus
'Edmontosaurus
'
'Sort
'
'Amargasaurus
'Deinonychus
'Edmontosaurus
'Mamenchisaurus
'Pachycephalosaurus
'Tyrannosaurus
'
'BinarySearch for 'Coelophysis':
'Not found. Sorts between: Amargasaurus and Deinonychus.
'
'BinarySearch for 'Tyrannosaurus':
'Found at index 5.

Hinweise

Jedes Element der array müssen implementieren die IComparable<T> generische Schnittstelle für Vergleiche mit jedem anderen Element in werden array.Each element of array must implement the IComparable<T> generic interface to be capable of comparisons with every other element in array.

Wenn die Sortierung nicht erfolgreich abgeschlossen wird, sind die Ergebnisse nicht definiert.If the sort is not successfully completed, the results are undefined.

Diese Methode verwendet die Beobachtung der inneren Abläufe Sortieralgorithmus (Introsort) wie folgt aus:This method uses the introspective sort (introsort) algorithm as follows:

  • Wenn die Größe der Partition weniger als 16 Elementen ist, wird ein Einfügesortierung Algorithmus.If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Überschreitet die Anzahl der Partitionen 2 * LogN, wobei N ist der Bereich des Eingabearrays, er verwendet eine Heapsort Algorithmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • Andernfalls verwendet es, eine Quicksort Algorithmus.Otherwise, it uses a Quicksort algorithm.

Diese Implementierung führt eine instabile Sortierung. d.h., wenn zwei Elemente gleich sind, möglicherweise die Reihenfolge nicht beibehalten.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Im Gegensatz dazu behält eine stabile Sortierung, die Reihenfolge der Elemente, die gleich sind.In contrast, a stable sort preserves the order of elements that are equal.

Für Arrays, die mithilfe von Algorithmen Heapsort und wenden die Schnellsortierung im schlimmsten Fall sortiert sind, ist diese Methode eine O (n Log n)-Vorgang, in denen n ist die Length von array.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is the Length of array.

Siehe auch

Sort<T>(T[], IComparer<T>) Sort<T>(T[], IComparer<T>) Sort<T>(T[], IComparer<T>) Sort<T>(T[], IComparer<T>)

Sortiert die Elementen in einem Array mit der angegebenen generischen IComparer<T>-Schnittstelle. Sorts the elements in an Array using the specified IComparer<T> generic interface.

public:
generic <typename T>
 static void Sort(cli::array <T> ^ array, System::Collections::Generic::IComparer<T> ^ comparer);
public static void Sort<T> (T[] array, System.Collections.Generic.IComparer<T> comparer);
static member Sort : 'T[] * System.Collections.Generic.IComparer<'T> -> unit
Public Shared Sub Sort(Of T) (array As T(), comparer As IComparer(Of T))
Typparameter
T

Der Typ der Elemente des Arrays. The type of the elements of the array.

Parameter
array
T[]

Das zu sortierende eindimensionale und nullbasierte Array. The one-dimensional, zero-base Array to sort

comparer
IComparer<T> IComparer<T> IComparer<T> IComparer<T>

Die Implementierung der generischen IComparer<T>-Schnittstelle, die für den Vergleich von Elementen verwendet werden soll, oder null, um die Implementierung der generischen IComparable<T>-Schnittstelle der einzelnen Elemente zu verwenden. The IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

Ausnahmen

comparer ist null, und mindestens ein Element in array implementiert die generische IComparable<T>-Schnittstelle nicht. comparer is null, and one or more elements in array do not implement the IComparable<T> generic interface.

Die Implementierung von comparer hat einen Fehler während der Sortierung verursacht. The implementation of comparer caused an error during the sort. Beispielsweise gibt comparer beim Vergleichen eines Elements mit sich selbst möglicherweise nicht 0 zurück. For example, comparer might not return 0 when comparing an item with itself.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, die Sort<T>(T[], IComparer<T>) generischen methodenüberladung und BinarySearch<T>(T[], T, IComparer<T>) generischen methodenüberladung.The following code example demonstrates the Sort<T>(T[], IComparer<T>) generic method overload and the BinarySearch<T>(T[], T, IComparer<T>) generic method overload.

Das Codebeispiel definiert einen alternativen Vergleich für Zeichenfolgen mit der Bezeichnung ReverseCompare, implementiert die IComparer<string> (IComparer(Of String) in Visual Basic IComparer<String^> in Visual C++) generische Schnittstelle.The code example defines an alternative comparer for strings, named ReverseCompare, which implements the IComparer<string> (IComparer(Of String) in Visual Basic, IComparer<String^> in Visual C++) generic interface. Der Vergleich ruft die CompareTo(String) Methode, die Umkehrung der verglichenen Elemente angibt, damit die Zeichenfolgen hoch bis Niedrig statt mit niedriger zum höchsten zu sortieren.The comparer calls the CompareTo(String) method, reversing the order of the comparands so that the strings sort high-to-low instead of low-to-high.

Das Array wird angezeigt, sortiert und erneut angezeigt.The array is displayed, sorted, and displayed again. Arrays müssen sortiert werden, um Sie verwenden die BinarySearch Methode.Arrays must be sorted in order to use the BinarySearch method.

Hinweis

Die Aufrufe an die Sort<T>(T[], IComparer<T>) und BinarySearch<T>(T[], T, IComparer<T>) generische Methoden sind nicht anders als die Aufrufe an ihre nicht generischen Entsprechungen, gesucht, da Visual Basic, c# und C++ den Typ des generischen Typparameters aus dem Typ des ersten Arguments abzuleiten.The calls to the Sort<T>(T[], IComparer<T>) and BinarySearch<T>(T[], T, IComparer<T>) generic methods do not look any different from calls to their nongeneric counterparts, because Visual Basic, C#, and C++ infer the type of the generic type parameter from the type of the first argument. Bei Verwendung der Ildasm.exe (IL Disassembler) um die Microsoft intermediate Language (MSIL) zu untersuchen, sehen Sie, dass die generischen Methoden aufgerufen werden.If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

Die BinarySearch<T>(T[], T, IComparer<T>) generischen methodenüberladung klicken Sie dann zum Suchen nach zwei Zeichenfolgen verwendet wird, ist eine, die nicht in das Array und einer ist.The BinarySearch<T>(T[], T, IComparer<T>) generic method overload is then used to search for two strings, one that is not in the array and one that is. Das Array und der Rückgabewert von der BinarySearch<T>(T[], T, IComparer<T>) Methode übergeben werden, um die ShowWhere generische Methode, die den Indexwert zeigt an, wenn die Zeichenfolge gefunden wurde, und andernfalls die Elemente die Suchzeichenfolge fiel zwischen handele es sich im Array.The array and the return value of the BinarySearch<T>(T[], T, IComparer<T>) method are passed to the ShowWhere generic method, which displays the index value if the string is found, and otherwise the elements the search string would fall between if it were in the array. Der Index ist negativ, wenn die Zeichenfolge nicht n ist das Array, also die ShowWhere Methode nimmt das bitweise Komplement (der ~-Operator in c# und Visual C++, Xor -1 in Visual Basic), die den Index des ersten Elements in der Liste zu erhalten, die größer als die Suche Stri NG.The index is negative if the string is not n the array, so the ShowWhere method takes the bitwise complement (the ~ operator in C# and Visual C++, Xor -1 in Visual Basic) to obtain the index of the first element in the list that is larger than the search string.

using namespace System;
using namespace System::Collections::Generic;

public ref class ReverseComparer: IComparer<String^>
{
public:
    virtual int Compare(String^ x, String^ y)
    {
        // Compare y and x in reverse order.
        return y->CompareTo(x);
    }
};

generic<typename T> void ShowWhere(array<T>^ arr, int index)
{
    if (index<0)
    {
        // If the index is negative, it represents the bitwise
        // complement of the next larger element in the array.
        //
        index = ~index;

        Console::Write("Not found. Sorts between: ");

        if (index == 0)
            Console::Write("beginning of array and ");
        else
            Console::Write("{0} and ", arr[index-1]);

        if (index == arr->Length)
            Console::WriteLine("end of array.");
        else
            Console::WriteLine("{0}.", arr[index]);
    }
    else
    {
        Console::WriteLine("Found at index {0}.", index);
    }
};

void main()
{
    array<String^>^ dinosaurs = {"Pachycephalosaurus", 
                                 "Amargasaurus", 
                                 "Tyrannosaurus", 
                                 "Mamenchisaurus", 
                                 "Deinonychus", 
                                 "Edmontosaurus"};

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

    ReverseComparer^ rc = gcnew ReverseComparer();

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

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\nBinarySearch for 'Coelophysis':");
    int index = Array::BinarySearch(dinosaurs, "Coelophysis", rc);
    ShowWhere(dinosaurs, index);

    Console::WriteLine("\nBinarySearch for 'Tyrannosaurus':");
    index = Array::BinarySearch(dinosaurs, "Tyrannosaurus", rc);
    ShowWhere(dinosaurs, index);
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Tyrannosaurus
Mamenchisaurus
Deinonychus
Edmontosaurus

Sort

Tyrannosaurus
Pachycephalosaurus
Mamenchisaurus
Edmontosaurus
Deinonychus
Amargasaurus

BinarySearch for 'Coelophysis':
Not found. Sorts between: Deinonychus and Amargasaurus.

BinarySearch for 'Tyrannosaurus':
Found at index 0.
 */
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", 
                              "Tyrannosaurus", 
                              "Mamenchisaurus", 
                              "Deinonychus", 
                              "Edmontosaurus"};

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

        ReverseComparer rc = new ReverseComparer();

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

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

        Console.WriteLine("\nBinarySearch for 'Coelophysis':");
        int index = Array.BinarySearch(dinosaurs, "Coelophysis", rc);
        ShowWhere(dinosaurs, index);

        Console.WriteLine("\nBinarySearch for 'Tyrannosaurus':");
        index = Array.BinarySearch(dinosaurs, "Tyrannosaurus", rc);
        ShowWhere(dinosaurs, index);
    }

    private static void ShowWhere<T>(T[] array, int index)
    {
        if (index<0)
        {
            // If the index is negative, it represents the bitwise
            // complement of the next larger element in the array.
            //
            index = ~index;

            Console.Write("Not found. Sorts between: ");

            if (index == 0)
                Console.Write("beginning of array and ");
            else
                Console.Write("{0} and ", array[index-1]);

            if (index == array.Length)
                Console.WriteLine("end of array.");
            else
                Console.WriteLine("{0}.", array[index]);
        }
        else
        {
            Console.WriteLine("Found at index {0}.", index);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Tyrannosaurus
Mamenchisaurus
Deinonychus
Edmontosaurus

Sort

Tyrannosaurus
Pachycephalosaurus
Mamenchisaurus
Edmontosaurus
Deinonychus
Amargasaurus

BinarySearch for 'Coelophysis':
Not found. Sorts between: Deinonychus and Amargasaurus.

BinarySearch for 'Tyrannosaurus':
Found at index 0.
 */
Imports System
Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        ' Compare y and x in reverse order.
        Return y.CompareTo(x)

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Pachycephalosaurus", _
            "Amargasaurus", _
            "Tyrannosaurus", _
            "Mamenchisaurus", _
            "Deinonychus", _
            "Edmontosaurus"  }

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Dim rc As New ReverseComparer()

        Console.WriteLine(vbLf & "Sort")
        Array.Sort(dinosaurs, rc)

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "BinarySearch for 'Coelophysis':")
        Dim index As Integer = _
            Array.BinarySearch(dinosaurs, "Coelophysis", rc)
        ShowWhere(dinosaurs, index)

        Console.WriteLine(vbLf & _
            "BinarySearch for 'Tyrannosaurus':")
        index = Array.BinarySearch(dinosaurs, "Tyrannosaurus", rc)
        ShowWhere(dinosaurs, index)

    End Sub

    Private Shared Sub ShowWhere(Of T) _
        (ByVal array() As T, ByVal index As Integer) 

        If index < 0 Then
            ' If the index is negative, it represents the bitwise
            ' complement of the next larger element in the array.
            '
            index = index Xor -1

            Console.Write("Not found. Sorts between: ")

            If index = 0 Then
                Console.Write("beginning of array and ")
            Else
                Console.Write("{0} and ", array(index - 1))
            End If 

            If index = array.Length Then
                Console.WriteLine("end of array.")
            Else
                Console.WriteLine("{0}.", array(index))
            End If 
        Else
            Console.WriteLine("Found at index {0}.", index)
        End If

    End Sub

End Class

' This code example produces the following output:
'
'Pachycephalosaurus
'Amargasaurus
'Tyrannosaurus
'Mamenchisaurus
'Deinonychus
'Edmontosaurus
'
'Sort
'
'Tyrannosaurus
'Pachycephalosaurus
'Mamenchisaurus
'Edmontosaurus
'Deinonychus
'Amargasaurus
'
'BinarySearch for 'Coelophysis':
'Not found. Sorts between: Deinonychus and Amargasaurus.
'
'BinarySearch for 'Tyrannosaurus':
'Found at index 0.

Hinweise

Wenn comparer ist null, jedes Element der array müssen implementieren die IComparable<T> generische Schnittstelle für Vergleiche mit jedem anderen Element in werden array.If comparer is null, each element of array must implement the IComparable<T> generic interface to be capable of comparisons with every other element in array.

Wenn die Sortierung nicht erfolgreich abgeschlossen wird, sind die Ergebnisse nicht definiert.If the sort is not successfully completed, the results are undefined.

Diese Methode verwendet die Beobachtung der inneren Abläufe Sortieralgorithmus (Introsort) wie folgt aus:This method uses the introspective sort (introsort) algorithm as follows:

  • Wenn die Größe der Partition weniger als 16 Elementen ist, wird ein Einfügesortierung Algorithmus.If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Überschreitet die Anzahl der Partitionen 2 * LogN, wobei N ist der Bereich des Eingabearrays, er verwendet eine Heapsort Algorithmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • Andernfalls verwendet es, eine Quicksort Algorithmus.Otherwise, it uses a Quicksort algorithm.

Diese Implementierung führt eine instabile Sortierung. d.h., wenn zwei Elemente gleich sind, möglicherweise die Reihenfolge nicht beibehalten.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Im Gegensatz dazu behält eine stabile Sortierung, die Reihenfolge der Elemente, die gleich sind.In contrast, a stable sort preserves the order of elements that are equal.

Für Arrays, die mithilfe von Algorithmen Heapsort und wenden die Schnellsortierung im schlimmsten Fall sortiert sind, ist diese Methode eine O (n Log n)-Vorgang, in denen n ist die Length von array.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is the Length of array.

Hinweise für Aufrufer

Die .NET Framework 4 und früheren Versionen verwendet nur den Quicksort-Algorithmus. The .NET Framework 4 and earlier versions used only the Quicksort algorithm. QuickSort identifiziert die ungültige Vergleiche in einigen Situationen, in dem der Sortiervorgang löst, eine IndexOutOfRangeException -Ausnahme aus, und löst eine ArgumentException Ausnahme an den Aufrufer. Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Beginnend mit der .NET Framework 4.5.NET Framework 4.5, es ist möglich, dass ausgelöst, das zuvor Sortiervorgänge hat ArgumentException wird keine Ausnahme, da die Einfügung sortieren und Heapsort Algorithmen eine ungültige Vergleich nicht erkennen. Starting with the .NET Framework 4.5.NET Framework 4.5, it is possible that sorting operations that previously threw ArgumentException will not throw an exception, because the insertion sort and heapsort algorithms do not detect an invalid comparer. Zum größten Teil, gilt dies für Arrays mit weniger als 16 Elementen. For the most part, this applies to arrays with fewer than 16 elements.

Siehe auch

Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>)

Sortiert die Elemente in einem Array mithilfe der angegebenen Comparison<T>. Sorts the elements in an Array using the specified Comparison<T>.

public:
generic <typename T>
 static void Sort(cli::array <T> ^ array, Comparison<T> ^ comparison);
public static void Sort<T> (T[] array, Comparison<T> comparison);
static member Sort : 'T[] * Comparison<'T> -> unit
Public Shared Sub Sort(Of T) (array As T(), comparison As Comparison(Of T))
Typparameter
T

Der Typ der Elemente des Arrays. The type of the elements of the array.

Parameter
array
T[]

Das zu sortierende eindimensionale und nullbasierte Array. The one-dimensional, zero-based Array to sort

comparison
Comparison<T> Comparison<T> Comparison<T> Comparison<T>

Die Comparison<T>, die beim Vergleich von Elementen verwendet werden soll. The Comparison<T> to use when comparing elements.

Ausnahmen

array ist null. array is null. - oder - -or- comparison ist null. comparison is null.

Die Implementierung von comparison hat einen Fehler während der Sortierung verursacht. The implementation of comparison caused an error during the sort. Beispielsweise gibt comparison beim Vergleichen eines Elements mit sich selbst möglicherweise nicht 0 zurück. For example, comparison might not return 0 when comparing an item with itself.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, die Sort(Comparison<T>) -methodenüberladung.The following code example demonstrates the Sort(Comparison<T>) method overload.

Das Codebeispiel definiert eine alternative Vergleichsmethode für Zeichenfolgen wird mit dem Namen CompareDinosByLength.The code example defines an alternative comparison method for strings, named CompareDinosByLength. Diese Methode funktioniert wie folgt: zunächst die Comparandsare getestetnull, und als kleiner als ein Wert ungleich Null ein null-Verweis behandelt wird.This method works as follows: First, the comparandsare tested fornull, and a null reference is treated as less than a non-null. Zweitens: die Länge der Zeichenfolge verglichen werden und größer sein als die längere Zeichenfolge angesehen wird.Second, the string lengths are compared, and the longer string is deemed to be greater. Wenn die Länge gleich sind, wird im dritten gewöhnliche Zeichenfolgenvergleich verwendet.Third, if the lengths are equal, ordinary string comparison is used.

Ein Array von Zeichenfolgen erstellt und mit vier Zeichenfolgen, in keiner bestimmten Reihenfolge aufgefüllt.A array of strings is created and populated with four strings, in no particular order. Die Liste enthält auch eine leere Zeichenfolge und ein null-Verweis.The list also includes an empty string and a null reference. Die Liste wird angezeigt, sortiert, mit einem Comparison<T> generischen Delegaten darstellt der CompareDinosByLength -Methode, und erneut angezeigt.The list is displayed, sorted using a Comparison<T> generic delegate representing the CompareDinosByLength method, and displayed again.

using namespace System;
using namespace System::Collections::Generic;

int CompareDinosByLength(String^ x, String^ y)
{
    if (x == nullptr)
    {
        if (y == nullptr)
        {
            // If x is null and y is null, they're
            // equal. 
            return 0;
        }
        else
        {
            // If x is null and y is not null, y
            // is greater. 
            return -1;
        }
    }
    else
    {
        // If x is not null...
        //
        if (y == nullptr)
            // ...and y is null, x is greater.
        {
            return 1;
        }
        else
        {
            // ...and y is not null, compare the 
            // lengths of the two strings.
            //
            int retval = x->Length.CompareTo(y->Length);

            if (retval != 0)
            {
                // If the strings are not of equal length,
                // the longer string is greater.
                //
                return retval;
            }
            else
            {
                // If the strings are of equal length,
                // sort them with ordinary string comparison.
                //
                return x->CompareTo(y);
            }
        }
    }
};

void Display(array<String^>^ arr)
{
    Console::WriteLine();
    for each(String^ s in arr)
    {
        if (s == nullptr)
            Console::WriteLine("(null)");
        else
            Console::WriteLine("\"{0}\"", s);
    }
};

void main()
{
    array<String^>^ dinosaurs = { 
        "Pachycephalosaurus",
        "Amargasaurus",
        "",
        nullptr,
        "Mamenchisaurus",
        "Deinonychus" };
    Display(dinosaurs);

    Console::WriteLine("\nSort with generic Comparison<String^> delegate:");
    Array::Sort(dinosaurs,
        gcnew Comparison<String^>(CompareDinosByLength));
    Display(dinosaurs);

}

/* This code example produces the following output:

"Pachycephalosaurus"
"Amargasaurus"
""
(null)
"Mamenchisaurus"
"Deinonychus"

Sort with generic Comparison<String^> delegate:

(null)
""
"Deinonychus"
"Amargasaurus"
"Mamenchisaurus"
"Pachycephalosaurus"
 */
using System;
using System.Collections.Generic;

public class Example
{
    private static int CompareDinosByLength(string x, string y)
    {
        if (x == null)
        {
            if (y == null)
            {
                // If x is null and y is null, they're
                // equal. 
                return 0;
            }
            else
            {
                // If x is null and y is not null, y
                // is greater. 
                return -1;
            }
        }
        else
        {
            // If x is not null...
            //
            if (y == null)
                // ...and y is null, x is greater.
            {
                return 1;
            }
            else
            {
                // ...and y is not null, compare the 
                // lengths of the two strings.
                //
                int retval = x.Length.CompareTo(y.Length);

                if (retval != 0)
                {
                    // If the strings are not of equal length,
                    // the longer string is greater.
                    //
                    return retval;
                }
                else
                {
                    // If the strings are of equal length,
                    // sort them with ordinary string comparison.
                    //
                    return x.CompareTo(y);
                }
            }
        }
    }

    public static void Main()
    {
        string[] dinosaurs = {
            "Pachycephalosaurus",
            "Amargasaurus",
            "",
            null,
            "Mamenchisaurus",
            "Deinonychus" };
        Display(dinosaurs);

        Console.WriteLine("\nSort with generic Comparison<string> delegate:");
        Array.Sort(dinosaurs, CompareDinosByLength);
        Display(dinosaurs);

    }

    private static void Display(string[] arr)
    {
        Console.WriteLine();
        foreach( string s in arr )
        {
            if (s == null)
                Console.WriteLine("(null)");
            else
                Console.WriteLine("\"{0}\"", s);
        }
    }
}

/* This code example produces the following output:

"Pachycephalosaurus"
"Amargasaurus"
""
(null)
"Mamenchisaurus"
"Deinonychus"

Sort with generic Comparison<string> delegate:

(null)
""
"Deinonychus"
"Amargasaurus"
"Mamenchisaurus"
"Pachycephalosaurus"
 */
Imports System
Imports System.Collections.Generic

Public Class Example

    Private Shared Function CompareDinosByLength( _
        ByVal x As String, ByVal y As String) As Integer

        If x Is Nothing Then
            If y Is Nothing Then 
                ' If x is Nothing and y is Nothing, they're
                ' equal. 
                Return 0
            Else
                ' If x is Nothing and y is not Nothing, y
                ' is greater. 
                Return -1
            End If
        Else
            ' If x is not Nothing...
            '
            If y Is Nothing Then
                ' ...and y is Nothing, x is greater.
                Return 1
            Else
                ' ...and y is not Nothing, compare the 
                ' lengths of the two strings.
                '
                Dim retval As Integer = _
                    x.Length.CompareTo(y.Length)

                If retval <> 0 Then 
                    ' If the strings are not of equal length,
                    ' the longer string is greater.
                    '
                    Return retval
                Else
                    ' If the strings are of equal length,
                    ' sort them with ordinary string comparison.
                    '
                    Return x.CompareTo(y)
                End If
            End If
        End If

    End Function

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Pachycephalosaurus", _
            "Amargasaurus", _
            "", _
            Nothing, _
            "Mamenchisaurus", _
            "Deinonychus" }
        Display(dinosaurs)

        Console.WriteLine(vbLf & "Sort with generic Comparison(Of String) delegate:")
        Array.Sort(dinosaurs, AddressOf CompareDinosByLength)
        Display(dinosaurs)

    End Sub

    Private Shared Sub Display(ByVal arr() As String)
        Console.WriteLine()
        For Each s As String In arr
            If s Is Nothing Then
                Console.WriteLine("(Nothing)")
            Else
                Console.WriteLine("""{0}""", s)
            End If
        Next
    End Sub
End Class

' This code example produces the following output:
'
'"Pachycephalosaurus"
'"Amargasaurus"
'""
'(Nothing)
'"Mamenchisaurus"
'"Deinonychus"
'
'Sort with generic Comparison(Of String) delegate:
'
'(Nothing)
'""
'"Deinonychus"
'"Amargasaurus"
'"Mamenchisaurus"
'"Pachycephalosaurus"

Hinweise

Wenn die Sortierung nicht erfolgreich abgeschlossen wird, sind die Ergebnisse nicht definiert.If the sort is not successfully completed, the results are undefined.

Diese Methode verwendet die Beobachtung der inneren Abläufe Sortieralgorithmus (Introsort) wie folgt:This method uses introspective sort (introsort) algorithm as follows:

  • Wenn die Größe der Partition weniger als 16 Elementen ist, wird ein Einfügesortierung Algorithmus.If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Überschreitet die Anzahl der Partitionen 2 * LogN, wobei N ist der Bereich des Eingabearrays, er verwendet eine Heapsort Algorithmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • Andernfalls verwendet es, eine Quicksort Algorithmus.Otherwise, it uses a Quicksort algorithm.

Diese Implementierung führt eine instabile Sortierung. d.h., wenn zwei Elemente gleich sind, möglicherweise die Reihenfolge nicht beibehalten.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Im Gegensatz dazu behält eine stabile Sortierung, die Reihenfolge der Elemente, die gleich sind.In contrast, a stable sort preserves the order of elements that are equal.

Für Arrays, die mithilfe von Algorithmen Heapsort und wenden die Schnellsortierung im schlimmsten Fall sortiert sind, ist diese Methode eine O (n Log n)-Vorgang, in denen n ist die Length von array.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is the Length of array.

Hinweise für Aufrufer

Die .NET Framework 4 und früheren Versionen verwendet nur den Quicksort-Algorithmus. The .NET Framework 4 and earlier versions used only the Quicksort algorithm. QuickSort identifiziert die ungültige Vergleiche in einigen Situationen, in dem der Sortiervorgang löst, eine IndexOutOfRangeException -Ausnahme aus, und löst eine ArgumentException Ausnahme an den Aufrufer. Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Beginnend mit der .NET Framework 4.5.NET Framework 4.5, es ist möglich, dass ausgelöst, das zuvor Sortiervorgänge hat ArgumentException wird keine Ausnahme, da die Einfügung sortieren und Heapsort Algorithmen eine ungültige Vergleich nicht erkennen. Starting with the .NET Framework 4.5.NET Framework 4.5, it is possible that sorting operations that previously threw ArgumentException will not throw an exception, because the insertion sort and heapsort algorithms do not detect an invalid comparer. Zum größten Teil, gilt dies für Arrays mit weniger als 16 Elementen. For the most part, this applies to arrays with fewer than 16 elements.

Siehe auch

Sort<T>(T[], Int32, Int32) Sort<T>(T[], Int32, Int32) Sort<T>(T[], Int32, Int32) Sort<T>(T[], Int32, Int32)

Sortiert die Elemente in einem Bereich von Elementen in einem Array mithilfe der Implementierung der generischen IComparable<T>-Schnittstelle jedes Elements des Array. Sorts the elements in a range of elements in an Array using the IComparable<T> generic interface implementation of each element of the Array.

public:
generic <typename T>
 static void Sort(cli::array <T> ^ array, int index, int length);
public static void Sort<T> (T[] array, int index, int length);
static member Sort : 'T[] * int * int -> unit
Public Shared Sub Sort(Of T) (array As T(), index As Integer, length As Integer)
Typparameter
T

Der Typ der Elemente des Arrays. The type of the elements of the array.

Parameter
array
T[]

Das zu sortierende eindimensionale und nullbasierte Array. The one-dimensional, zero-based Array to sort

index
Int32 Int32 Int32 Int32

Der Startindex des zu sortierenden Bereichs. The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Die Anzahl der Elemente im zu sortierenden Bereich. The number of elements in the range to sort.

Ausnahmen

index ist kleiner als die Untergrenze von array. index is less than the lower bound of array. - oder - -or- length ist kleiner als Null. length is less than zero.

index und length geben keinen gültigen Bereich im array an. index and length do not specify a valid range in array.

Mindestens ein Element in array implementiert die generische IComparable<T>-Schnittstelle nicht. One or more elements in array do not implement the IComparable<T> generic interface.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, die Sort<T>(T[], Int32, Int32) generischen methodenüberladung und Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) generischen methodenüberladung für einen Bereich in einem Array zu sortieren.The following code example demonstrates the Sort<T>(T[], Int32, Int32) generic method overload and the Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) generic method overload for sorting a range in an array.

Das Codebeispiel definiert einen alternativen Vergleich für Zeichenfolgen mit der Bezeichnung ReverseCompare, implementiert die IComparer<string> (IComparer(Of String) in Visual Basic IComparer<String^> in Visual C++) generische Schnittstelle.The code example defines an alternative comparer for strings, named ReverseCompare, which implements the IComparer<string> (IComparer(Of String) in Visual Basic, IComparer<String^> in Visual C++) generic interface. Der Vergleich ruft die CompareTo(String) Methode, die Umkehrung der verglichenen Elemente angibt, damit die Zeichenfolgen hoch bis Niedrig statt mit niedriger zum höchsten zu sortieren.The comparer calls the CompareTo(String) method, reversing the order of the comparands so that the strings sort high-to-low instead of low-to-high.

Im Codebeispiel wird erstellt und zeigt ein Array der Namen von Godzilla, drei Pflanzenfresser und drei Fleischfresser (Tyrannosaurids, um genau zu sein).The code example creates and displays an array of dinosaur names, consisting of three herbivores followed by three carnivores (tyrannosaurids, to be precise). Die Sort<T>(T[], Int32, Int32) generische Überladung wird verwendet, um die letzten drei Elemente des Arrays, sortieren, die dann angezeigt werden.The Sort<T>(T[], Int32, Int32) generic method overload is used to sort the last three elements of the array, which is then displayed. Die Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) generischen methodenüberladung der Verwendung ReverseCompare der letzten drei Elemente in umgekehrter Reihenfolge zu sortieren.The Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) generic method overload is used with ReverseCompare to sort the last three elements in reverse order. Die Dinosaurier gründlich verwechselt werden erneut angezeigt.The thoroughly confused dinosaurs are displayed again.

Hinweis

Die Aufrufe an die Sort<T>(T[], IComparer<T>) und BinarySearch<T>(T[], T, IComparer<T>) generische Methoden sind nicht anders als die Aufrufe an ihre nicht generischen Entsprechungen, gesucht, da Visual Basic, c# und C++ den Typ des generischen Typparameters aus dem Typ des ersten Arguments abzuleiten.The calls to the Sort<T>(T[], IComparer<T>) and BinarySearch<T>(T[], T, IComparer<T>) generic methods do not look any different from calls to their nongeneric counterparts, because Visual Basic, C#, and C++ infer the type of the generic type parameter from the type of the first argument. Bei Verwendung der Ildasm.exe (IL Disassembler) um die Microsoft intermediate Language (MSIL) zu untersuchen, sehen Sie, dass die generischen Methoden aufgerufen werden.If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

using namespace System;
using namespace System::Collections::Generic;

public ref class ReverseComparer: IComparer<String^>
{
public:
    virtual int Compare(String^ x, String^ y)
    {
        // Compare y and x in reverse order.
        return y->CompareTo(x);
    }
};

void main()
{
    array<String^>^ dinosaurs = {"Pachycephalosaurus", 
                                 "Amargasaurus", 
                                 "Mamenchisaurus",
                                 "Tarbosaurus",
                                 "Tyrannosaurus", 
                                 "Albertasaurus"};

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

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

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

    ReverseComparer^ rc = gcnew ReverseComparer();

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

    Console::WriteLine();
    for each(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
 */
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
 */
Imports System
Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        ' Compare y and x in reverse order.
        Return y.CompareTo(x)

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Pachycephalosaurus", _
            "Amargasaurus", _
            "Mamenchisaurus", _
            "Tarbosaurus", _
            "Tyrannosaurus", _
            "Albertasaurus"  }

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & "Sort(dinosaurs, 3, 3)")
        Array.Sort(dinosaurs, 3, 3)

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Dim rc As New ReverseComparer()

        Console.WriteLine(vbLf & "Sort(dinosaurs, 3, 3, rc)")
        Array.Sort(dinosaurs, 3, 3, rc)

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

    End Sub

End Class

' 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

Hinweise

Jedes Element innerhalb des angegebenen Bereichs von Elementen in array müssen implementieren die IComparable<T> generische Schnittstelle für Vergleiche mit jedem anderen Element in werden array.Each element within the specified range of elements in array must implement the IComparable<T> generic interface to be capable of comparisons with every other element in array.

Wenn die Sortierung nicht erfolgreich abgeschlossen wird, sind die Ergebnisse nicht definiert.If the sort is not successfully completed, the results are undefined.

Diese Methode verwendet die Beobachtung der inneren Abläufe Sortieralgorithmus (Introsort) wie folgt aus:This method uses the introspective sort (introsort) algorithm as follows:

  • Wenn die Größe der Partition weniger als 16 Elementen ist, wird ein Einfügesortierung Algorithmus.If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Überschreitet die Anzahl der Partitionen 2 * LogN, wobei N ist der Bereich des Eingabearrays, er verwendet eine Heapsort Algorithmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • Andernfalls verwendet es, eine Quicksort Algorithmus.Otherwise, it uses a Quicksort algorithm.

Diese Implementierung führt eine instabile Sortierung. d.h., wenn zwei Elemente gleich sind, möglicherweise die Reihenfolge nicht beibehalten.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Im Gegensatz dazu behält eine stabile Sortierung, die Reihenfolge der Elemente, die gleich sind.In contrast, a stable sort preserves the order of elements that are equal.

Für Arrays, die mithilfe von Algorithmen Heapsort und wenden die Schnellsortierung im schlimmsten Fall sortiert sind, ist diese Methode eine O (n Log n)-Vorgang, in denen n ist length.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is length.

Siehe auch

Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>)

Sortiert die Elemente in einem Bereich von Elementen in der Array mithilfe der angegebenen generischen IComparer<T>-Schnittstelle. Sorts the elements in a range of elements in an Array using the specified IComparer<T> generic interface.

public:
generic <typename T>
 static void Sort(cli::array <T> ^ array, int index, int length, System::Collections::Generic::IComparer<T> ^ comparer);
public static void Sort<T> (T[] array, int index, int length, System.Collections.Generic.IComparer<T> comparer);
static member Sort : 'T[] * int * int * System.Collections.Generic.IComparer<'T> -> unit
Public Shared Sub Sort(Of T) (array As T(), index As Integer, length As Integer, comparer As IComparer(Of T))
Typparameter
T

Der Typ der Elemente des Arrays. The type of the elements of the array.

Parameter
array
T[]

Das zu sortierende eindimensionale und nullbasierte Array. The one-dimensional, zero-based Array to sort.

index
Int32 Int32 Int32 Int32

Der Startindex des zu sortierenden Bereichs. The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Die Anzahl der Elemente im zu sortierenden Bereich. The number of elements in the range to sort.

comparer
IComparer<T> IComparer<T> IComparer<T> IComparer<T>

Die Implementierung der generischen IComparer<T>-Schnittstelle, die für den Vergleich von Elementen verwendet werden soll, oder null, um die Implementierung der generischen IComparable<T>-Schnittstelle der einzelnen Elemente zu verwenden. The IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

Ausnahmen

index ist kleiner als die Untergrenze von array. index is less than the lower bound of array. - oder - -or- length ist kleiner als Null. length is less than zero.

index und length geben keinen gültigen Bereich im array an. index and length do not specify a valid range in array. - oder - -or- Die Implementierung von comparer hat einen Fehler während der Sortierung verursacht. The implementation of comparer caused an error during the sort. Beispielsweise gibt comparer beim Vergleichen eines Elements mit sich selbst möglicherweise nicht 0 zurück. For example, comparer might not return 0 when comparing an item with itself.

comparer ist null, und mindestens ein Element in array implementiert die generische IComparable<T>-Schnittstelle nicht. comparer is null, and one or more elements in array do not implement the IComparable<T> generic interface.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, die Sort<T>(T[], Int32, Int32) generischen methodenüberladung und Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) generischen methodenüberladung für einen Bereich in einem Array zu sortieren.The following code example demonstrates the Sort<T>(T[], Int32, Int32) generic method overload and the Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) generic method overload for sorting a range in an array.

Das Codebeispiel definiert einen alternativen Vergleich für Zeichenfolgen mit der Bezeichnung ReverseCompare, implementiert die IComparer<string> (IComparer(Of String) in Visual Basic IComparer<String^> in Visual C++) generische Schnittstelle.The code example defines an alternative comparer for strings, named ReverseCompare, which implements the IComparer<string> (IComparer(Of String) in Visual Basic, IComparer<String^> in Visual C++) generic interface. Der Vergleich ruft die CompareTo(String) Methode, die Umkehrung der verglichenen Elemente angibt, damit die Zeichenfolgen hoch bis Niedrig statt mit niedriger zum höchsten zu sortieren.The comparer calls the CompareTo(String) method, reversing the order of the comparands so that the strings sort high-to-low instead of low-to-high.

Im Codebeispiel wird erstellt und zeigt ein Array der Namen von Godzilla, drei Pflanzenfresser und drei Fleischfresser (Tyrannosaurids, um genau zu sein).The code example creates and displays an array of dinosaur names, consisting of three herbivores followed by three carnivores (tyrannosaurids, to be precise). Die Sort<T>(T[], Int32, Int32) generische Überladung wird verwendet, um die letzten drei Elemente des Arrays, sortieren, die dann angezeigt werden.The Sort<T>(T[], Int32, Int32) generic method overload is used to sort the last three elements of the array, which is then displayed. Die Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) generischen methodenüberladung der Verwendung ReverseCompare der letzten drei Elemente in umgekehrter Reihenfolge zu sortieren.The Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) generic method overload is used with ReverseCompare to sort the last three elements in reverse order. Die Dinosaurier gründlich verwechselt werden erneut angezeigt.The thoroughly confused dinosaurs are displayed again.

Hinweis

Die Aufrufe an die Sort<T>(T[], IComparer<T>) und BinarySearch<T>(T[], T, IComparer<T>) generische Methoden sind nicht anders als die Aufrufe an ihre nicht generischen Entsprechungen, gesucht, da Visual Basic, c# und C++ den Typ des generischen Typparameters aus dem Typ des ersten Arguments abzuleiten.The calls to the Sort<T>(T[], IComparer<T>) and BinarySearch<T>(T[], T, IComparer<T>) generic methods do not look any different from calls to their nongeneric counterparts, because Visual Basic, C#, and C++ infer the type of the generic type parameter from the type of the first argument. Bei Verwendung der Ildasm.exe (IL Disassembler) um die Microsoft intermediate Language (MSIL) zu untersuchen, sehen Sie, dass die generischen Methoden aufgerufen werden.If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

using namespace System;
using namespace System::Collections::Generic;

public ref class ReverseComparer: IComparer<String^>
{
public:
    virtual int Compare(String^ x, String^ y)
    {
        // Compare y and x in reverse order.
        return y->CompareTo(x);
    }
};

void main()
{
    array<String^>^ dinosaurs = {"Pachycephalosaurus", 
                                 "Amargasaurus", 
                                 "Mamenchisaurus",
                                 "Tarbosaurus",
                                 "Tyrannosaurus", 
                                 "Albertasaurus"};

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

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

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

    ReverseComparer^ rc = gcnew ReverseComparer();

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

    Console::WriteLine();
    for each(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
 */
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
 */
Imports System
Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        ' Compare y and x in reverse order.
        Return y.CompareTo(x)

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Pachycephalosaurus", _
            "Amargasaurus", _
            "Mamenchisaurus", _
            "Tarbosaurus", _
            "Tyrannosaurus", _
            "Albertasaurus"  }

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & "Sort(dinosaurs, 3, 3)")
        Array.Sort(dinosaurs, 3, 3)

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Dim rc As New ReverseComparer()

        Console.WriteLine(vbLf & "Sort(dinosaurs, 3, 3, rc)")
        Array.Sort(dinosaurs, 3, 3, rc)

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

    End Sub

End Class

' 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

Hinweise

Wenn comparer ist null, jedes Element innerhalb des angegebenen Bereichs von Elementen in array müssen implementieren die IComparable<T> generische Schnittstelle für Vergleiche mit jedem anderen Element in werden array.If comparer is null, each element within the specified range of elements in array must implement the IComparable<T> generic interface to be capable of comparisons with every other element in array.

Wenn die Sortierung nicht erfolgreich abgeschlossen wird, sind die Ergebnisse nicht definiert.If the sort is not successfully completed, the results are undefined.

Diese Methode verwendet die Beobachtung der inneren Abläufe Sortieralgorithmus (Introsort) wie folgt aus:This method uses the introspective sort (introsort) algorithm as follows:

  • Wenn die Größe der Partition weniger als 16 Elementen ist, wird ein Einfügesortierung Algorithmus.If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Überschreitet die Anzahl der Partitionen 2 * LogN, wobei N ist der Bereich des Eingabearrays, er verwendet eine Heapsort Algorithmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • Andernfalls verwendet es, eine Quicksort Algorithmus.Otherwise, it uses a Quicksort algorithm.

Diese Implementierung führt eine instabile Sortierung. d.h., wenn zwei Elemente gleich sind, möglicherweise die Reihenfolge nicht beibehalten.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Im Gegensatz dazu behält eine stabile Sortierung, die Reihenfolge der Elemente, die gleich sind.In contrast, a stable sort preserves the order of elements that are equal.

Für Arrays, die mithilfe von Algorithmen Heapsort und wenden die Schnellsortierung im schlimmsten Fall sortiert sind, ist diese Methode eine O (n Log n)-Vorgang, in denen n ist length.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is length.

Hinweise für Aufrufer

Die .NET Framework 4 und früheren Versionen verwendet nur den Quicksort-Algorithmus. The .NET Framework 4 and earlier versions used only the Quicksort algorithm. QuickSort identifiziert die ungültige Vergleiche in einigen Situationen, in dem der Sortiervorgang löst, eine IndexOutOfRangeException -Ausnahme aus, und löst eine ArgumentException Ausnahme an den Aufrufer. Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Beginnend mit der .NET Framework 4.5.NET Framework 4.5, es ist möglich, dass ausgelöst, das zuvor Sortiervorgänge hat ArgumentException wird keine Ausnahme, da die Einfügung sortieren und Heapsort Algorithmen eine ungültige Vergleich nicht erkennen. Starting with the .NET Framework 4.5.NET Framework 4.5, it is possible that sorting operations that previously threw ArgumentException will not throw an exception, because the insertion sort and heapsort algorithms do not detect an invalid comparer. Zum größten Teil, gilt dies für Arrays mit weniger als 16 Elementen. For the most part, this applies to arrays with fewer than 16 elements.

Siehe auch

Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[])

Sortiert ein Paar von Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei die Implementierung der generischen IComparable<T>-Schnittstelle jedes Schlüssels. Sorts a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable<T> generic interface implementation of each key.

public:
generic <typename TKey, typename TValue>
 static void Sort(cli::array <TKey> ^ keys, cli::array <TValue> ^ items);
public static void Sort<TKey,TValue> (TKey[] keys, TValue[] items);
static member Sort : 'Key[] * 'Value[] -> unit
Public Shared Sub Sort(Of TKey, TValue) (keys As TKey(), items As TValue())
Typparameter
TKey

Der Typ der Elemente des Schlüsselarrays. The type of the elements of the key array.

TValue

Der Typ der Elemente des Elementarrays. The type of the elements of the items array.

Parameter
keys
TKey[]

Das eindimensionale nullbasierte Array mit den zu sortierenden Schlüsseln. The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

Das eindimensionale nullbasierte Array, das die den Schlüsseln in keys entsprechenden Elemente enthält, oder null, um nur keys zu sortieren. The one-dimensional, zero-based Array that contains the items that correspond to the keys in keys, or null to sort only keys.

Ausnahmen

items ist nicht null, und die untere Grenze von keys entspricht nicht der unteren Grenze von items. items is not null, and the lower bound of keys does not match the lower bound of items. - oder - -or- items ist nicht null, und die Länge von keys ist größer als die Länge von items. items is not null, and the length of keys is greater than the length of items.

Mindestens ein Element im keysArray implementiert die generische IComparable<T>-Schnittstelle nicht. One or more elements in the keysArray do not implement the IComparable<T> generic interface.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, die Sort<TKey,TValue>(TKey[], TValue[]), Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>), Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32), und Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Überladungen der generischen Methode, für die Sortierung der Paare von Arrays, die Schlüssel und Werte darstellen.The following code example demonstrates the Sort<TKey,TValue>(TKey[], TValue[]), Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>), Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32), and Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) generic method overloads, for sorting pairs of arrays that represent keys and values.

Das Codebeispiel definiert einen alternativen Vergleich für Zeichenfolgen mit der Bezeichnung ReverseCompare, implementiert die IComparer<string> (IComparer(Of String) in Visual Basic IComparer<String^> in Visual C++) generische Schnittstelle.The code example defines an alternative comparer for strings, named ReverseCompare, which implements the IComparer<string> (IComparer(Of String) in Visual Basic, IComparer<String^> in Visual C++) generic interface. Der Vergleich ruft die CompareTo(String) Methode, die Umkehrung der verglichenen Elemente angibt, damit die Zeichenfolgen hoch bis Niedrig statt mit niedriger zum höchsten zu sortieren.The comparer calls the CompareTo(String) method, reversing the order of the comparands so that the strings sort high-to-low instead of low-to-high.

Im Codebeispiel wird erstellt und zeigt ein Array von Godzilla Namen (Schlüssel) und ein Array von ganzen Zahlen, die die maximale Länge der einzelnen Godzilla in Metern (Werte) darstellt.The code example creates and displays an array of dinosaur names (the keys) and an array of integers representing the maximum length of each dinosaur in meters (the values). Die Arrays werden dann sortiert und mehrmals angezeigt:The arrays are then sorted and displayed several times:

Hinweis

Die Aufrufe an den generischen Methoden suchen nicht anders als die Aufrufe an ihre nicht generischen Entsprechungen, da Visual Basic, c# und C++ den Typ des generischen Typparameters aus dem Typ der ersten beiden Argumente abzuleiten.The calls to the generic methods do not look any different from calls to their nongeneric counterparts, because Visual Basic, C#, and C++ infer the type of the generic type parameter from the type of the first two arguments. Bei Verwendung der Ildasm.exe (IL Disassembler) um die Microsoft intermediate Language (MSIL) zu untersuchen, sehen Sie, dass die generischen Methoden aufgerufen werden.If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

using namespace System;
using namespace System::Collections::Generic;

public ref class ReverseComparer: IComparer<String^>
{
public:
    virtual int Compare(String^ x, String^ y)
    {
        // Compare y and x in reverse order.
        return y->CompareTo(x);
    }
};

void main()
{
    array<String^>^ dinosaurs = {
            "Seismosaurus", 
            "Chasmosaurus", 
            "Coelophysis", 
            "Mamenchisaurus", 
            "Caudipteryx", 
            "Cetiosaurus"  };

    array<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 = gcnew 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.
 */
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.
 */
Imports System
Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        ' Compare y and x in reverse order.
        Return y.CompareTo(x)

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Seismosaurus", _
            "Chasmosaurus", _
            "Coelophysis", _
            "Mamenchisaurus", _
            "Caudipteryx", _
            "Cetiosaurus"  }

        Dim dinosaurSizes() As Integer = { 40, 5, 3, 22, 1, 18 }

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes)")
        Array.Sort(dinosaurs, dinosaurSizes)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Dim rc As New ReverseComparer()

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, rc)")
        Array.Sort(dinosaurs, dinosaurSizes, rc)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, 3, 3)")
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, 3, 3, rc)")
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

    End Sub

End Class

' 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.

Hinweise

Jeder Schlüssel in der keys Array verfügt über ein entsprechendes Element in der items Array.Each key in the keysArray has a corresponding item in the itemsArray. Wenn ein Schlüssel wird neu angeordnet, bei der Sortierung, des entsprechenden Elements in der items Array wird neu positioniert.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Aus diesem Grund die items Array sortiert wird, entsprechend der Anordnung der entsprechenden Schlüssel in der keys Array.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Jeder Schlüssel in der keys Array müssen implementieren die IComparable<T> generische Schnittstelle für die er mit jedem anderen Schlüssel verglichen werden.Each key in the keysArray must implement the IComparable<T> generic interface to be capable of comparisons with every other key.

Sie können sortiert, wenn es mehr Elemente als Schlüssel gibt, aber die Elemente, die ohne entsprechenden Schlüssel werden nicht sortiert.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Wenn es weitere Schlüssel als Elemente können nicht sortiert werden; Dies löst dies eine ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Wenn die Sortierung nicht erfolgreich abgeschlossen wird, sind die Ergebnisse nicht definiert.If the sort is not successfully completed, the results are undefined.

Diese Methode verwendet die Beobachtung der inneren Abläufe Sortieralgorithmus (Introsort) wie folgt aus:This method uses the introspective sort (introsort) algorithm as follows:

  • Wenn die Größe der Partition weniger als 16 Elementen ist, wird ein Einfügesortierung Algorithmus.If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Überschreitet die Anzahl der Partitionen 2 * LogN, wobei N ist der Bereich des Eingabearrays, er verwendet eine Heapsort Algorithmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • Andernfalls verwendet es, eine Quicksort Algorithmus.Otherwise, it uses a Quicksort algorithm.

Diese Implementierung führt eine instabile Sortierung. d.h., wenn zwei Elemente gleich sind, möglicherweise die Reihenfolge nicht beibehalten.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Im Gegensatz dazu behält eine stabile Sortierung, die Reihenfolge der Elemente, die gleich sind.In contrast, a stable sort preserves the order of elements that are equal.

Für Arrays, die mithilfe von Algorithmen Heapsort und wenden die Schnellsortierung im schlimmsten Fall sortiert sind, ist diese Methode eine O (n Log n)-Vorgang, in denen n ist die Length von array.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is the Length of array.

Siehe auch

Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>)

Sortiert ein Paar von Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei die angegebene generische IComparer<T>-Schnittstelle. Sorts a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer<T> generic interface.

public:
generic <typename TKey, typename TValue>
 static void Sort(cli::array <TKey> ^ keys, cli::array <TValue> ^ items, System::Collections::Generic::IComparer<TKey> ^ comparer);
public static void Sort<TKey,TValue> (TKey[] keys, TValue[] items, System.Collections.Generic.IComparer<TKey> comparer);
static member Sort : 'Key[] * 'Value[] * System.Collections.Generic.IComparer<'Key> -> unit
Public Shared Sub Sort(Of TKey, TValue) (keys As TKey(), items As TValue(), comparer As IComparer(Of TKey))
Typparameter
TKey

Der Typ der Elemente des Schlüsselarrays. The type of the elements of the key array.

TValue

Der Typ der Elemente des Elementarrays. The type of the elements of the items array.

Parameter
keys
TKey[]

Das eindimensionale nullbasierte Array mit den zu sortierenden Schlüsseln. The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

Das eindimensionale nullbasierte Array, das die den Schlüsseln in keys entsprechenden Elemente enthält, oder null, um nur keys zu sortieren. The one-dimensional, zero-based Array that contains the items that correspond to the keys in keys, or null to sort only keys.

comparer
IComparer<TKey>

Die Implementierung der generischen IComparer<T>-Schnittstelle, die für den Vergleich von Elementen verwendet werden soll, oder null, um die Implementierung der generischen IComparable<T>-Schnittstelle der einzelnen Elemente zu verwenden. The IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

Ausnahmen

items ist nicht null, und die untere Grenze von keys entspricht nicht der unteren Grenze von items. items is not null, and the lower bound of keys does not match the lower bound of items. - oder - -or- items ist nicht null, und die Länge von keys ist größer als die Länge von items. items is not null, and the length of keys is greater than the length of items. - oder - -or- Die Implementierung von comparer hat einen Fehler während der Sortierung verursacht. The implementation of comparer caused an error during the sort. Beispielsweise gibt comparer beim Vergleichen eines Elements mit sich selbst möglicherweise nicht 0 zurück. For example, comparer might not return 0 when comparing an item with itself.

comparer ist null, und mindestens ein Element im keysArray implementiert die generische IComparable<T>-Schnittstelle nicht. comparer is null, and one or more elements in the keysArray do not implement the IComparable<T> generic interface.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, die Sort<TKey,TValue>(TKey[], TValue[]), [], TValue<xref:System.Array.Sort%60%602%28%60%600%5B%5D%2C%60%601%5B%5D%2CSystem.Collections.Generic.IComparer%7B%60%600%7D%29 >,Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32), und Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Überladungen der generischen Methode, für die Sortierung der Paare von Arrays, die Schlüssel und Werte darstellen.The following code example demonstrates the Sort<TKey,TValue>(TKey[], TValue[]), [], TValue<xref:System.Array.Sort%60%602%28%60%600%5B%5D%2C%60%601%5B%5D%2CSystem.Collections.Generic.IComparer%7B%60%600%7D%29>,Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32), and Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) generic method overloads, for sorting pairs of arrays that represent keys and values.

Das Codebeispiel definiert einen alternativen Vergleich für Zeichenfolgen mit der Bezeichnung ReverseCompare, implementiert die IComparer<string> (IComparer(Of String) in Visual Basic IComparer<String^> in Visual C++) generische Schnittstelle.The code example defines an alternative comparer for strings, named ReverseCompare, which implements the IComparer<string> (IComparer(Of String) in Visual Basic, IComparer<String^> in Visual C++) generic interface. Der Vergleich ruft die CompareTo(String) Methode, die Umkehrung der verglichenen Elemente angibt, damit die Zeichenfolgen hoch bis Niedrig statt mit niedriger zum höchsten zu sortieren.The comparer calls the CompareTo(String) method, reversing the order of the comparands so that the strings sort high-to-low instead of low-to-high.

Im Codebeispiel wird erstellt und zeigt ein Array von Godzilla Namen (Schlüssel) und ein Array von ganzen Zahlen, die die maximale Länge der einzelnen Godzilla in Metern (Werte) darstellt.The code example creates and displays an array of dinosaur names (the keys) and an array of integers representing the maximum length of each dinosaur in meters (the values). Die Arrays werden dann sortiert und mehrmals angezeigt:The arrays are then sorted and displayed several times:

Hinweis

Die Aufrufe an den generischen Methoden suchen nicht anders als die Aufrufe an ihre nicht generischen Entsprechungen, da Visual Basic, c# und C++ den Typ des generischen Typparameters aus dem Typ der ersten beiden Argumente abzuleiten.The calls to the generic methods do not look any different from calls to their nongeneric counterparts, because Visual Basic, C#, and C++ infer the type of the generic type parameter from the type of the first two arguments. Bei Verwendung der Ildasm.exe (IL Disassembler) um die Microsoft intermediate Language (MSIL) zu untersuchen, sehen Sie, dass die generischen Methoden aufgerufen werden.If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

using namespace System;
using namespace System::Collections::Generic;

public ref class ReverseComparer: IComparer<String^>
{
public:
    virtual int Compare(String^ x, String^ y)
    {
        // Compare y and x in reverse order.
        return y->CompareTo(x);
    }
};

void main()
{
    array<String^>^ dinosaurs = {
            "Seismosaurus", 
            "Chasmosaurus", 
            "Coelophysis", 
            "Mamenchisaurus", 
            "Caudipteryx", 
            "Cetiosaurus"  };

    array<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 = gcnew 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.
 */
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.
 */
Imports System
Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        ' Compare y and x in reverse order.
        Return y.CompareTo(x)

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Seismosaurus", _
            "Chasmosaurus", _
            "Coelophysis", _
            "Mamenchisaurus", _
            "Caudipteryx", _
            "Cetiosaurus"  }

        Dim dinosaurSizes() As Integer = { 40, 5, 3, 22, 1, 18 }

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes)")
        Array.Sort(dinosaurs, dinosaurSizes)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Dim rc As New ReverseComparer()

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, rc)")
        Array.Sort(dinosaurs, dinosaurSizes, rc)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, 3, 3)")
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, 3, 3, rc)")
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

    End Sub

End Class

' 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.

Hinweise

Jeder Schlüssel in der keys Array verfügt über ein entsprechendes Element in der items Array.Each key in the keysArray has a corresponding item in the itemsArray. Wenn ein Schlüssel wird neu angeordnet, bei der Sortierung, des entsprechenden Elements in der items Array wird neu positioniert.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Aus diesem Grund die items Array sortiert wird, entsprechend der Anordnung der entsprechenden Schlüssel in der keys Array.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Wenn comparer ist null, die jeweils-Schlüssel in der keys Array müssen implementieren die IComparable<T> generische Schnittstelle für die er mit jedem anderen Schlüssel verglichen werden.If comparer is null, each key in the keysArray must implement the IComparable<T> generic interface to be capable of comparisons with every other key.

Sie können sortiert, wenn es mehr Elemente als Schlüssel gibt, aber die Elemente, die ohne entsprechenden Schlüssel werden nicht sortiert.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Wenn es weitere Schlüssel als Elemente können nicht sortiert werden; Dies löst dies eine ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Wenn die Sortierung nicht erfolgreich abgeschlossen wird, sind die Ergebnisse nicht definiert.If the sort is not successfully completed, the results are undefined.

Diese Methode verwendet die Beobachtung der inneren Abläufe Sortieralgorithmus (Introsort) wie folgt aus:This method uses the introspective sort (introsort) algorithm as follows:

  • Wenn die Größe der Partition weniger als 16 Elementen ist, wird ein Einfügesortierung Algorithmus.If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Überschreitet die Anzahl der Partitionen 2 * LogN, wobei N ist der Bereich des Eingabearrays, er verwendet eine Heapsort Algorithmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • Andernfalls verwendet es, eine Quicksort Algorithmus.Otherwise, it uses a Quicksort algorithm.

Diese Implementierung führt eine instabile Sortierung. d.h., wenn zwei Elemente gleich sind, möglicherweise die Reihenfolge nicht beibehalten.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Im Gegensatz dazu behält eine stabile Sortierung, die Reihenfolge der Elemente, die gleich sind.In contrast, a stable sort preserves the order of elements that are equal.

Für Arrays, die mithilfe von Algorithmen Heapsort und wenden die Schnellsortierung im schlimmsten Fall sortiert sind, ist diese Methode eine O (n Log n)-Vorgang, in denen n ist die Length von array.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is the Length of array.

Hinweise für Aufrufer

Die .NET Framework 4 und früheren Versionen verwendet nur den Quicksort-Algorithmus. The .NET Framework 4 and earlier versions used only the Quicksort algorithm. QuickSort identifiziert die ungültige Vergleiche in einigen Situationen, in dem der Sortiervorgang löst, eine IndexOutOfRangeException -Ausnahme aus, und löst eine ArgumentException Ausnahme an den Aufrufer. Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Beginnend mit der .NET Framework 4.5.NET Framework 4.5, es ist möglich, dass ausgelöst, das zuvor Sortiervorgänge hat ArgumentException wird keine Ausnahme, da die Einfügung sortieren und Heapsort Algorithmen eine ungültige Vergleich nicht erkennen. Starting with the .NET Framework 4.5.NET Framework 4.5, it is possible that sorting operations that previously threw ArgumentException will not throw an exception, because the insertion sort and heapsort algorithms do not detect an invalid comparer. Zum größten Teil, gilt dies für Arrays mit weniger als 16 Elementen. For the most part, this applies to arrays with fewer than 16 elements.

Siehe auch

Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)

Sortiert einen Bereich von Elementen in einem Paar von Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei die Implementierung der generischen IComparable<T>-Schnittstelle jedes Schlüssels. Sorts a range of elements in a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable<T> generic interface implementation of each key.

public:
generic <typename TKey, typename TValue>
 static void Sort(cli::array <TKey> ^ keys, cli::array <TValue> ^ items, int index, int length);
public static void Sort<TKey,TValue> (TKey[] keys, TValue[] items, int index, int length);
static member Sort : 'Key[] * 'Value[] * int * int -> unit
Public Shared Sub Sort(Of TKey, TValue) (keys As TKey(), items As TValue(), index As Integer, length As Integer)
Typparameter
TKey

Der Typ der Elemente des Schlüsselarrays. The type of the elements of the key array.

TValue

Der Typ der Elemente des Elementarrays. The type of the elements of the items array.

Parameter
keys
TKey[]

Das eindimensionale nullbasierte Array mit den zu sortierenden Schlüsseln. The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

Das eindimensionale nullbasierte Array, das die den Schlüsseln in keys entsprechenden Elemente enthält, oder null, um nur keys zu sortieren. The one-dimensional, zero-based Array that contains the items that correspond to the keys in keys, or null to sort only keys.

index
Int32 Int32 Int32 Int32

Der Startindex des zu sortierenden Bereichs. The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Die Anzahl der Elemente im zu sortierenden Bereich. The number of elements in the range to sort.

Ausnahmen

index ist kleiner als die Untergrenze von keys. index is less than the lower bound of keys. - oder - -or- length ist kleiner als Null. length is less than zero.

items ist nicht null, und die untere Grenze von keys entspricht nicht der unteren Grenze von items. items is not null, and the lower bound of keys does not match the lower bound of items. - oder - -or- items ist nicht null, und die Länge von keys ist größer als die Länge von items. items is not null, and the length of keys is greater than the length of items. - oder - -or- index und length geben keinen gültigen Bereich im keysArray an. index and length do not specify a valid range in the keysArray. - oder - -or- items ist nicht null, und index und length geben keinen gültigen Bereich im itemsArray an. items is not null, and index and length do not specify a valid range in the itemsArray.

Mindestens ein Element im keysArray implementiert die generische IComparable<T>-Schnittstelle nicht. One or more elements in the keysArray do not implement the IComparable<T> generic interface.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, die Sort<TKey,TValue>(TKey[], TValue[]), Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>), [], TValue<xref:System.Array.Sort%60%602%28%60%600%5B%5D%2C%60%601%5B%5D%2CSystem.Int32%2CSystem.Int32%29 >, und Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) generische-methodenüberladungen, für die Sortierung der Paare von Arrays, die Schlüssel und Werte darstellen.The following code example demonstrates the Sort<TKey,TValue>(TKey[], TValue[]), Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>), [], TValue<xref:System.Array.Sort%60%602%28%60%600%5B%5D%2C%60%601%5B%5D%2CSystem.Int32%2CSystem.Int32%29>, and Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) generic method overloads, for sorting pairs of arrays that represent keys and values.

Das Codebeispiel definiert einen alternativen Vergleich für Zeichenfolgen mit der Bezeichnung ReverseCompare, implementiert die IComparer<string> (IComparer(Of String) in Visual Basic IComparer<String^> in Visual C++) generische Schnittstelle.The code example defines an alternative comparer for strings, named ReverseCompare, which implements the IComparer<string> (IComparer(Of String) in Visual Basic, IComparer<String^> in Visual C++) generic interface. Der Vergleich ruft die CompareTo(String) Methode, die Umkehrung der verglichenen Elemente angibt, damit die Zeichenfolgen hoch bis Niedrig statt mit niedriger zum höchsten zu sortieren.The comparer calls the CompareTo(String) method, reversing the order of the comparands so that the strings sort high-to-low instead of low-to-high.

Im Codebeispiel wird erstellt und zeigt ein Array von Godzilla Namen (Schlüssel) und ein Array von ganzen Zahlen, die die maximale Länge der einzelnen Godzilla in Metern (Werte) darstellt.The code example creates and displays an array of dinosaur names (the keys) and an array of integers representing the maximum length of each dinosaur in meters (the values). Die Arrays werden dann sortiert und mehrmals angezeigt:The arrays are then sorted and displayed several times:

Hinweis

Die Aufrufe an den generischen Methoden suchen nicht anders als die Aufrufe an ihre nicht generischen Entsprechungen, da Visual Basic, c# und C++ den Typ des generischen Typparameters aus dem Typ der ersten beiden Argumente abzuleiten.The calls to the generic methods do not look any different from calls to their nongeneric counterparts, because Visual Basic, C#, and C++ infer the type of the generic type parameter from the type of the first two arguments. Bei Verwendung der Ildasm.exe (IL Disassembler) um die Microsoft intermediate Language (MSIL) zu untersuchen, sehen Sie, dass die generischen Methoden aufgerufen werden.If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

using namespace System;
using namespace System::Collections::Generic;

public ref class ReverseComparer: IComparer<String^>
{
public:
    virtual int Compare(String^ x, String^ y)
    {
        // Compare y and x in reverse order.
        return y->CompareTo(x);
    }
};

void main()
{
    array<String^>^ dinosaurs = {
            "Seismosaurus", 
            "Chasmosaurus", 
            "Coelophysis", 
            "Mamenchisaurus", 
            "Caudipteryx", 
            "Cetiosaurus"  };

    array<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 = gcnew 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.
 */
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.
 */
Imports System
Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        ' Compare y and x in reverse order.
        Return y.CompareTo(x)

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Seismosaurus", _
            "Chasmosaurus", _
            "Coelophysis", _
            "Mamenchisaurus", _
            "Caudipteryx", _
            "Cetiosaurus"  }

        Dim dinosaurSizes() As Integer = { 40, 5, 3, 22, 1, 18 }

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes)")
        Array.Sort(dinosaurs, dinosaurSizes)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Dim rc As New ReverseComparer()

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, rc)")
        Array.Sort(dinosaurs, dinosaurSizes, rc)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, 3, 3)")
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, 3, 3, rc)")
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

    End Sub

End Class

' 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.

Hinweise

Jeder Schlüssel in der keys Array verfügt über ein entsprechendes Element in der items Array.Each key in the keysArray has a corresponding item in the itemsArray. Wenn ein Schlüssel wird neu angeordnet, bei der Sortierung, des entsprechenden Elements in der items Array wird neu positioniert.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Aus diesem Grund die items Array sortiert wird, entsprechend der Anordnung der entsprechenden Schlüssel in der keys Array.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Jeder Schlüssel im angegebenen Bereich von Elementen in der keys Array müssen implementieren die IComparable<T> generische Schnittstelle für die er mit jedem anderen Schlüssel verglichen werden.Each key within the specified range of elements in the keysArray must implement the IComparable<T> generic interface to be capable of comparisons with every other key.

Sie können sortiert, wenn es mehr Elemente als Schlüssel gibt, aber die Elemente, die ohne entsprechenden Schlüssel werden nicht sortiert.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Wenn es weitere Schlüssel als Elemente können nicht sortiert werden; Dies löst dies eine ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Wenn die Sortierung nicht erfolgreich abgeschlossen wird, sind die Ergebnisse nicht definiert.If the sort is not successfully completed, the results are undefined.

Diese Methode verwendet die Beobachtung der inneren Abläufe Sortieralgorithmus (Introsort) wie folgt aus:This method uses the introspective sort (introsort) algorithm as follows:

  • Wenn die Größe der Partition weniger als 16 Elementen ist, wird ein Einfügesortierung Algorithmus.If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Überschreitet die Anzahl der Partitionen 2 * LogN, wobei N ist der Bereich des Eingabearrays, er verwendet eine Heapsort Algorithmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • Andernfalls verwendet es, eine Quicksort Algorithmus.Otherwise, it uses a Quicksort algorithm.

Diese Implementierung führt eine instabile Sortierung. d.h., wenn zwei Elemente gleich sind, möglicherweise die Reihenfolge nicht beibehalten.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Im Gegensatz dazu behält eine stabile Sortierung, die Reihenfolge der Elemente, die gleich sind.In contrast, a stable sort preserves the order of elements that are equal.

Für Arrays, die mithilfe von Algorithmen Heapsort und wenden die Schnellsortierung im schlimmsten Fall sortiert sind, ist diese Methode eine O (n Log n)-Vorgang, in denen n ist length.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is length.

Siehe auch

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

Sortiert einen Bereich von Elementen in einem Paar von Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei die angegebene generische IComparer<T>-Schnittstelle. Sorts a range of elements in a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer<T> generic interface.

public:
generic <typename TKey, typename TValue>
 static void Sort(cli::array <TKey> ^ keys, cli::array <TValue> ^ items, int index, int length, System::Collections::Generic::IComparer<TKey> ^ comparer);
public static void Sort<TKey,TValue> (TKey[] keys, TValue[] items, int index, int length, System.Collections.Generic.IComparer<TKey> comparer);
static member Sort : 'Key[] * 'Value[] * int * int * System.Collections.Generic.IComparer<'Key> -> unit
Public Shared Sub Sort(Of TKey, TValue) (keys As TKey(), items As TValue(), index As Integer, length As Integer, comparer As IComparer(Of TKey))
Typparameter
TKey

Der Typ der Elemente des Schlüsselarrays. The type of the elements of the key array.

TValue

Der Typ der Elemente des Elementarrays. The type of the elements of the items array.

Parameter
keys
TKey[]

Das eindimensionale nullbasierte Array mit den zu sortierenden Schlüsseln. The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

Das eindimensionale nullbasierte Array, das die den Schlüsseln in keys entsprechenden Elemente enthält, oder null, um nur keys zu sortieren. The one-dimensional, zero-based Array that contains the items that correspond to the keys in keys, or null to sort only keys.

index
Int32 Int32 Int32 Int32

Der Startindex des zu sortierenden Bereichs. The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Die Anzahl der Elemente im zu sortierenden Bereich. The number of elements in the range to sort.

comparer
IComparer<TKey>

Die Implementierung der generischen IComparer<T>-Schnittstelle, die für den Vergleich von Elementen verwendet werden soll, oder null, um die Implementierung der generischen IComparable<T>-Schnittstelle der einzelnen Elemente zu verwenden. The IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

Ausnahmen

index ist kleiner als die Untergrenze von keys. index is less than the lower bound of keys. - oder - -or- length ist kleiner als Null. length is less than zero.

items ist nicht null, und die untere Grenze von keys entspricht nicht der unteren Grenze von items. items is not null, and the lower bound of keys does not match the lower bound of items. - oder - -or- items ist nicht null, und die Länge von keys ist größer als die Länge von items. items is not null, and the length of keys is greater than the length of items. - oder - -or- index und length geben keinen gültigen Bereich im keysArray an. index and length do not specify a valid range in the keysArray. - oder - -or- items ist nicht null, und index und length geben keinen gültigen Bereich im itemsArray an. items is not null, and index and length do not specify a valid range in the itemsArray. - oder - -or- Die Implementierung von comparer hat einen Fehler während der Sortierung verursacht. The implementation of comparer caused an error during the sort. Beispielsweise gibt comparer beim Vergleichen eines Elements mit sich selbst möglicherweise nicht 0 zurück. For example, comparer might not return 0 when comparing an item with itself.

comparer ist null, und mindestens ein Element im keysArray implementiert die generische IComparable<T>-Schnittstelle nicht. comparer is null, and one or more elements in the keysArray do not implement the IComparable<T> generic interface.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, die Sort<TKey,TValue>(TKey[], TValue[]), Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>), Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32), und [], TValue<xref:System.Array.Sort%60%602%28%60%600%5B%5D%2C%60%601%5B%5D%2CSystem.Int32%2CSystem.Int32% 2CSystem.Collections.Generic.IComparer%7B%60%600%7D%29 > Überladungen der generischen Methode, für die Sortierung der Paare von Arrays, die Schlüssel und Werte darstellen.The following code example demonstrates the Sort<TKey,TValue>(TKey[], TValue[]), Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>), Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32), and [], TValue<xref:System.Array.Sort%60%602%28%60%600%5B%5D%2C%60%601%5B%5D%2CSystem.Int32%2CSystem.Int32%2CSystem.Collections.Generic.IComparer%7B%60%600%7D%29> generic method overloads, for sorting pairs of arrays that represent keys and values.

Das Codebeispiel definiert einen alternativen Vergleich für Zeichenfolgen mit der Bezeichnung ReverseCompare, implementiert die IComparer<string>(IComparer(Of String) in Visual Basic IComparer<String^> in Visual C++) generische Schnittstelle.The code example defines an alternative comparer for strings, named ReverseCompare, which implements the IComparer<string>(IComparer(Of String) in Visual Basic, IComparer<String^> in Visual C++) generic interface. Der Vergleich ruft die CompareTo(String) Methode, die Umkehrung der verglichenen Elemente angibt, damit die Zeichenfolgen hoch bis Niedrig statt mit niedriger zum höchsten zu sortieren.The comparer calls the CompareTo(String) method, reversing the order of the comparands so that the strings sort high-to-low instead of low-to-high.

Im Codebeispiel wird erstellt und zeigt ein Array von Godzilla Namen (Schlüssel) und ein Array von ganzen Zahlen, die die maximale Länge der einzelnen Godzilla in Metern (Werte) darstellt.The code example creates and displays an array of dinosaur names (the keys) and an array of integers representing the maximum length of each dinosaur in meters (the values). Die Arrays werden dann sortiert und mehrmals angezeigt:The arrays are then sorted and displayed several times:

  • Die Sort<TKey,TValue>(TKey[], TValue[]) Überladung wird verwendet, um beide Arrays in der Reihenfolge der Namen Godzilla im ersten Array zu sortieren.The Sort<TKey,TValue>(TKey[], TValue[]) overload is used to sort both arrays in order of the dinosaur names in the first array.

  • Die Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Überladung und einer Instanz von ReverseCompare werden verwendet, um die Sortierreihenfolge der gekoppelten Arrays umzukehren.The Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) overload and an instance of ReverseCompare are used to reverse the sort order of the paired arrays.

  • Die Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Überladung wird verwendet, um die letzten drei Elemente beider Arrays zu sortieren.The Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) overload is used to sort the last three elements of both arrays.

  • Die [], TValue<xref:System.Array.Sort%60%602%28%60%600%5B%5D%2C%60%601%5B%5D%2CSystem.Int32%2CSystem.Int32%2CSystem.Collections.Generic.IComparer%7B%60%600%7D%29 > Überladung wird verwendet, um die letzten drei zu sortieren. Elemente beider arrays in umgekehrter Reihenfolge.The [], TValue<xref:System.Array.Sort%60%602%28%60%600%5B%5D%2C%60%601%5B%5D%2CSystem.Int32%2CSystem.Int32%2CSystem.Collections.Generic.IComparer%7B%60%600%7D%29> overload is used to sort the last three elements of both arrays in reverse order.

Hinweis

Die Aufrufe an den generischen Methoden suchen nicht anders als die Aufrufe an ihre nicht generischen Entsprechungen, da Visual Basic, c# und C++ den Typ des generischen Typparameters aus dem Typ der ersten beiden Argumente abzuleiten.The calls to the generic methods do not look any different from calls to their nongeneric counterparts, because Visual Basic, C#, and C++ infer the type of the generic type parameter from the type of the first two arguments. Bei Verwendung der Ildasm.exe (IL Disassembler) um die Microsoft intermediate Language (MSIL) zu untersuchen, sehen Sie, dass die generischen Methoden aufgerufen werden.If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

using namespace System;
using namespace System::Collections::Generic;

public ref class ReverseComparer: IComparer<String^>
{
public:
    virtual int Compare(String^ x, String^ y)
    {
        // Compare y and x in reverse order.
        return y->CompareTo(x);
    }
};

void main()
{
    array<String^>^ dinosaurs = {
            "Seismosaurus", 
            "Chasmosaurus", 
            "Coelophysis", 
            "Mamenchisaurus", 
            "Caudipteryx", 
            "Cetiosaurus"  };

    array<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 = gcnew 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.
 */
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.
 */
Imports System
Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        ' Compare y and x in reverse order.
        Return y.CompareTo(x)

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Seismosaurus", _
            "Chasmosaurus", _
            "Coelophysis", _
            "Mamenchisaurus", _
            "Caudipteryx", _
            "Cetiosaurus"  }

        Dim dinosaurSizes() As Integer = { 40, 5, 3, 22, 1, 18 }

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes)")
        Array.Sort(dinosaurs, dinosaurSizes)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Dim rc As New ReverseComparer()

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, rc)")
        Array.Sort(dinosaurs, dinosaurSizes, rc)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, 3, 3)")
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, 3, 3, rc)")
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

    End Sub

End Class

' 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.

Hinweise

Jeder Schlüssel in der keys Array verfügt über ein entsprechendes Element in der items Array.Each key in the keysArray has a corresponding item in the itemsArray. Wenn ein Schlüssel wird neu angeordnet, bei der Sortierung, des entsprechenden Elements in der items Array wird neu positioniert.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Aus diesem Grund die items Array sortiert wird, entsprechend der Anordnung der entsprechenden Schlüssel in der keys Array.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Wenn comparer ist null, jeder Schlüssel im angegebenen Bereich von Elementen in der keys Array müssen implementieren die IComparable<T> generische Schnittstelle für die er mit jedem anderen Schlüssel verglichen werden.If comparer is null, each key within the specified range of elements in the keysArray must implement the IComparable<T> generic interface to be capable of comparisons with every other key.

Sie können sortiert, wenn es mehr Elemente als Schlüssel gibt, aber die Elemente, die ohne entsprechenden Schlüssel werden nicht sortiert.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Wenn es weitere Schlüssel als Elemente können nicht sortiert werden; Dies löst dies eine ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Wenn die Sortierung nicht erfolgreich abgeschlossen wird, sind die Ergebnisse nicht definiert.If the sort is not successfully completed, the results are undefined.

Diese Methode verwendet die Beobachtung der inneren Abläufe Sortieralgorithmus (Introsort) wie folgt aus:This method uses the introspective sort (introsort) algorithm as follows:

  • Wenn die Größe der Partition weniger als 16 Elementen ist, wird ein Einfügesortierung Algorithmus.If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Überschreitet die Anzahl der Partitionen 2 * LogN, wobei N ist der Bereich des Eingabearrays, er verwendet eine Heapsort Algorithmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • Andernfalls verwendet es, eine Quicksort Algorithmus.Otherwise, it uses a Quicksort algorithm.

Diese Implementierung führt eine instabile Sortierung. d.h., wenn zwei Elemente gleich sind, möglicherweise die Reihenfolge nicht beibehalten.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Im Gegensatz dazu behält eine stabile Sortierung, die Reihenfolge der Elemente, die gleich sind.In contrast, a stable sort preserves the order of elements that are equal.

Für Arrays, die mithilfe von Algorithmen Heapsort und wenden die Schnellsortierung im schlimmsten Fall sortiert sind, ist diese Methode eine O (n Log n)-Vorgang, in denen n ist length.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is length.

Hinweise für Aufrufer

Die .NET Framework 4 und früheren Versionen verwendet nur den Quicksort-Algorithmus. The .NET Framework 4 and earlier versions used only the Quicksort algorithm. QuickSort identifiziert die ungültige Vergleiche in einigen Situationen, in dem der Sortiervorgang löst, eine IndexOutOfRangeException -Ausnahme aus, und löst eine ArgumentException Ausnahme an den Aufrufer. Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Beginnend mit der .NET Framework 4.5.NET Framework 4.5, es ist möglich, dass ausgelöst, das zuvor Sortiervorgänge hat ArgumentException wird keine Ausnahme, da die Einfügung sortieren und Heapsort Algorithmen eine ungültige Vergleich nicht erkennen. Starting with the .NET Framework 4.5.NET Framework 4.5, it is possible that sorting operations that previously threw ArgumentException will not throw an exception, because the insertion sort and heapsort algorithms do not detect an invalid comparer. Zum größten Teil, gilt dies für Arrays mit weniger als 16 Elementen. For the most part, this applies to arrays with fewer than 16 elements.

Siehe auch

Gilt für: