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

Definicja

Sortuje elementy w tablicy jednowymiarowej.Sorts the elements in a one-dimensional array.

Przeciążenia

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

Sortuje elementy w zakresie elementów w jednym wymiarze Array , używając określonego. IComparerSorts 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)

Sortuje zakres elementów w parze jednowymiarowych Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiadające elementy) w oparciu o klucze w pierwszej kolejności Array przy użyciu określonego 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)

Sortuje elementy w zakresie elementów w jednym wymiarze Array IComparable przy użyciu implementacji każdego elementu 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)

Sortuje zakres elementów w parze jednowymiarowych Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) na podstawie kluczy w pierwszej kolejności Array przy użyciu IComparable implementacji każdego klucza.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)

Sortuje elementy w jednym wymiarze Array przy użyciu określonego. IComparerSorts 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)

Sortuje parę jednowymiarowych Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiadające elementy) w oparciu o klucze w pierwszej kolejności Array przy użyciu określonego 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)

Sortuje parę jednowymiarowych Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) w oparciu o klucze w pierwszej kolejności Array przy użyciu IComparable implementacji każdego klucza.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)

Sortuje elementy w całości jednowymiarowym Array IComparable przy użyciu implementacji każdego elementu 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[])

Sortuje elementy w całości Array IComparable<T> przy użyciu ogólnej implementacji interfejsu każdego elementu 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>)

Sortuje elementy Array przy użyciu określonego IComparer<T> interfejsu ogólnego.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>)

Sortuje elementy Array przy użyciu określonego 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)

Sortuje elementy w zakresie elementów Array IComparable<T> przy użyciu ogólnej implementacji interfejsu każdego elementu 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>)

Sortuje elementy w zakresie elementów Array przy użyciu określonego IComparer<T> interfejsu ogólnego.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[])

Sortuje parę Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) w oparciu o klucze w pierwszej kolejności Array przy użyciu IComparable<T> ogólnej implementacji interfejsu każdego klucza.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>)

Sortuje parę Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) w oparciu o klucze w pierwszej kolejności Array przy użyciu określonego IComparer<T> interfejsu ogólnego.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)

Sortuje zakres elementów w parze Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiadające elementy) w oparciu o klucze w pierwszej kolejności Array przy użyciu IComparable<T> uniwersalnej implementacji interfejsu każdego klucza.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>)

Sortuje zakres elementów w parze Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiadające elementy) w oparciu o klucze w pierwszej kolejności Array przy użyciu określonego IComparer<T> interfejsu ogólnego.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)

Sortuje elementy w zakresie elementów w jednym wymiarze Array , używając określonego. IComparerSorts 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

Parametry

array
Array Array Array Array

Jednowymiarowa Array do sortowania.The one-dimensional Array to sort.

index
Int32 Int32 Int32 Int32

Początkowy indeks zakresu, który ma zostać posortowany.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Liczba elementów w zakresie do sortowania.The number of elements in the range to sort.

comparer
IComparer IComparer IComparer IComparer

IComparer Implementacja do użycia podczas porównywania elementów.The IComparer implementation to use when comparing elements.

—lub—-or- nullAby użyć IComparable implementacji każdego elementu.null to use the IComparable implementation of each element.

Wyjątki

arrayjest wielowymiarowych.array is multidimensional.

indexjest mniejsza niż Dolna granica array.index is less than the lower bound of array.

—lub—-or- lengthjest mniejsza od zera.length is less than zero.

indexi length nie określaj prawidłowego zakresu w array.index and length do not specify a valid range in array.

—lub—-or- Implementacja comparer spowodowała błąd podczas sortowania.The implementation of comparer caused an error during the sort. Na przykład, comparer program nie może zwrócić wartości 0 podczas porównywania elementu z samym sobą.For example, comparer might not return 0 when comparing an item with itself.

comparer to null, a jeden lub więcej elementów w array nie implementuje IComparable interfejsu.comparer is null, and one or more elements in array do not implement the IComparable interface.

Przykłady

Poniższy przykład kodu pokazuje, jak sortować wartości Array przy użyciu domyślnej funkcji porównującej i niestandardowego modułu porównującego, która odwraca porządek sortowania.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. Zwróć uwagę, że wynik może się różnić w zależności od CultureInfobieżącej.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

Uwagi

Jeśli comparer array jest null, każdy element w określonym zakresie elementów w musi implementować interfejs, IComparable aby można było porównywać z każdym innym elementem w 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.

Jeśli sortowanie nie zostało ukończone pomyślnie, wyniki są niezdefiniowane.If the sort is not successfully completed, the results are undefined.

.NET Framework obejmuje wstępnie zdefiniowane IComparer implementacje wymienione w poniższej tabeli.The .NET Framework includes predefined IComparer implementations listed in the following table.

ImplementacjaImplementation OpisDescription
System.Collections.CaseInsensitiveComparer Porównuje wszystkie dwa obiekty, ale wykonuje porównanie ciągów bez uwzględniania wielkości liter.Compares any two objects, but performs a case-insensitive comparison of strings.
Comparer.Default Porównuje wszystkie dwa obiekty przy użyciu konwencji sortowania bieżącej kultury.Compares any two objects by using the sorting conventions of the current culture.
Comparer.DefaultInvariant Porównuje wszystkie dwa obiekty przy użyciu konwencji sortowania niezmiennej kultury.Compares any two objects by using the sorting conventions of the invariant culture.
Comparer<T>.Default Porównuje dwa obiekty typu T przy użyciu domyślnej kolejności sortowania typu.Compares two objects of type T by using the type's default sort order.

Możesz również obsługiwać niestandardowe porównania, dostarczając wystąpienie własnej IComparer implementacji comparer do parametru.You can also support custom comparisons by providing an instance of your own IComparer implementation to the comparer parameter. W tym przykładzie jest definiowana ReverseComparer Klasa, która odwraca domyślną kolejność sortowania dla wystąpień typu i wykonuje porównanie ciągów bez uwzględniania wielkości liter.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.

Ta metoda używa algorytmu sortowania introspektywnego w następujący sposób:This method uses the introspective sort (introsort) algorithm as follows:

  • Jeśli rozmiar partycji jest mniejszy niż 16 elementów, używa algorytmu sortowania wstawiania .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Jeśli liczba partycji przekracza 2 * logN, gdzie n jest zakresem tablicy wejściowej, używa algorytmu kopcowanie .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • W przeciwnym razie używa algorytmu sortowania .Otherwise, it uses a Quicksort algorithm.

Ta implementacja wykonuje niestabilne sortowanie; oznacza to, że jeśli dwa elementy są równe, ich kolejność może nie zostać zachowana.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Natomiast stabilne sortowanie zachowuje kolejność elementów, które są równe.In contrast, a stable sort preserves the order of elements that are equal.

W przypadku tablic, które są sortowane przy użyciu algorytmów kopcowanie i sortowania, ta metoda jestn operacją o (log n), gdzie n is 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.

Uwagi dotyczące wywoływania

W .NET Framework 4 i starszych wersjach użyto tylko algorytmu sortowania.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. Sortowania identyfikuje nieprawidłowe porównanie w niektórych sytuacjach, w których operacja sortowania zgłasza IndexOutOfRangeException wyjątek, i ArgumentException zgłasza wyjątek do obiektu wywołującego.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Począwszy od ArgumentException , możliwe jest, że operacje sortowania, które wcześniej wygenerowały nie spowodują wygenerowania wyjątku, ponieważ algorytmy sortowania i kopcowanie wstawiania nie wykrywają nieprawidłowej metody porównującej. .NET Framework 4.5.NET Framework 4.5Starting 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. W większości przypadków ma to zastosowanie do tablic zawierających mniej niż 16 elementów.For the most part, this applies to arrays with fewer than 16 elements.

Zobacz też

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

Sortuje zakres elementów w parze jednowymiarowych Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiadające elementy) w oparciu o klucze w pierwszej kolejności Array przy użyciu określonego 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)

Parametry

keys
Array Array Array Array

Jednowymiarowa Array , która zawiera klucze do sortowania.The one-dimensional Array that contains the keys to sort.

items
Array Array Array Array

Jednowymiarowa Array , która zawiera elementy, które odpowiadają poszczególnym kluczom keys Arrayw.The one-dimensional Array that contains the items that correspond to each of the keys in the keysArray.

—lub—-or- nullAby posortować tylko keys. Arraynull to sort only the keysArray.

index
Int32 Int32 Int32 Int32

Początkowy indeks zakresu, który ma zostać posortowany.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Liczba elementów w zakresie do sortowania.The number of elements in the range to sort.

comparer
IComparer IComparer IComparer IComparer

IComparer Implementacja do użycia podczas porównywania elementów.The IComparer implementation to use when comparing elements.

—lub—-or- nullAby użyć IComparable implementacji każdego elementu.null to use the IComparable implementation of each element.

Wyjątki

keysArray Jest wielowymiarowy.The keysArray is multidimensional.

—lub—-or- itemsArray Jest wielowymiarowy.The itemsArray is multidimensional.

indexjest mniejsza niż Dolna granica keys.index is less than the lower bound of keys.

—lub—-or- lengthjest mniejsza od zera.length is less than zero.

itemsnie jest keys items, a dolna granica jest niezgodna z dolną granicą. nullitems is not null, and the lower bound of keys does not match the lower bound of items.

—lub—-or- itemsnie nulljest, a keys długość jest itemswiększa niż długość.items is not null, and the length of keys is greater than the length of items.

—lub—-or- indexi length nie określaj prawidłowego zakresu keys Arrayw.index and length do not specify a valid range in the keysArray.

—lub—-or- itemsnullnie jest length Array, i itemsi nie określaj prawidłowego zakresu w. indexitems is not null, and index and length do not specify a valid range in the itemsArray.

—lub—-or- Implementacja comparer spowodowała błąd podczas sortowania.The implementation of comparer caused an error during the sort. Na przykład, comparer program nie może zwrócić wartości 0 podczas porównywania elementu z samym sobą.For example, comparer might not return 0 when comparing an item with itself.

comparerjest nulli co najmniej jeden element keys Array w nie implementuje IComparable interfejsu.comparer is null, and one or more elements in the keysArray do not implement the IComparable interface.

Przykłady

Poniższy przykład kodu pokazuje, jak sortować dwie skojarzone tablice, w których pierwsza tablica zawiera klucze, a druga tablica zawiera wartości.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. Sortowanie odbywa się przy użyciu domyślnej funkcji porównującej i niestandardowego modułu porównującego, który odwraca porządek sortowania.Sorts are done using the default comparer and a custom comparer that reverses the sort order. Zwróć uwagę, że wynik może się różnić w zależności od CultureInfobieżącej.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.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


   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

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

Uwagi

Każdy keys klucz w Array ma odpowiadający element w items Array.Each key in the keysArray has a corresponding item in the itemsArray. Gdy klucz jest zmieniany podczas sortowania, odpowiadający element w items Array jest podobnie zmieniany.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. W związku z items tym, Array jest sortowany według układu odpowiednich kluczy w keys Array.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Jeśli comparer keys jest null, każdy klucz w określonym Array zakresie elementów IComparable w musi implementować interfejs, aby można było porównywać z każdym innym kluczem.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.

Można sortować, jeśli istnieje więcej elementów niż klucze, ale elementy, które nie mają odpowiednich kluczy, nie zostaną posortowane.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Nie można sortować, jeśli istnieje więcej kluczy niż elementy; spowoduje to ArgumentExceptionwyrzucanie.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Jeśli sortowanie nie zostało ukończone pomyślnie, wyniki są niezdefiniowane.If the sort is not successfully completed, the results are undefined.

.NET Framework obejmuje wstępnie zdefiniowane IComparer implementacje wymienione w poniższej tabeli.The .NET Framework includes predefined IComparer implementations listed in the following table.

ImplementacjaImplementation OpisDescription
System.Collections.CaseInsensitiveComparer Porównuje wszystkie dwa obiekty, ale wykonuje porównanie ciągów bez uwzględniania wielkości liter.Compares any two objects, but performs a case-insensitive comparison of strings.
Comparer.Default Porównuje wszystkie dwa obiekty przy użyciu konwencji sortowania bieżącej kultury.Compares any two objects by using the sorting conventions of the current culture.
Comparer.DefaultInvariant Porównuje wszystkie dwa obiekty przy użyciu konwencji sortowania niezmiennej kultury.Compares any two objects by using the sorting conventions of the invariant culture.
Comparer<T>.Default Porównuje dwa obiekty typu T przy użyciu domyślnej kolejności sortowania typu.Compares two objects of type T by using the type's default sort order.

Możesz również obsługiwać niestandardowe porównania, dostarczając wystąpienie własnej IComparer implementacji comparer do parametru.You can also support custom comparisons by providing an instance of your own IComparer implementation to the comparer parameter. W tym przykładzie jest definiowana implementacja niestandardowa IComparer , która odwraca domyślny porządek sortowania i wykonuje Porównywanie ciągów bez uwzględniania wielkości liter.The example does this by defining a custom IComparer implementation that reverses the default sort order and performs case-insensitive string comparison.

Ta metoda używa algorytmu sortowania introspektywnego w następujący sposób:This method uses the introspective sort (introsort) algorithm as follows:

  • Jeśli rozmiar partycji jest mniejszy niż 16 elementów, używa algorytmu sortowania wstawiania .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Jeśli liczba partycji przekracza 2 * logN, gdzie n jest zakresem tablicy wejściowej, używa algorytmu kopcowanie .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • W przeciwnym razie używa algorytmu sortowania .Otherwise, it uses a Quicksort algorithm.

Ta implementacja wykonuje niestabilne sortowanie; oznacza to, że jeśli dwa elementy są równe, ich kolejność może nie zostać zachowana.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Natomiast stabilne sortowanie zachowuje kolejność elementów, które są równe.In contrast, a stable sort preserves the order of elements that are equal.

W przypadku tablic, które są sortowane przy użyciu algorytmów kopcowanie i sortowania, ta metoda jestn operacją o (log n), gdzie n is 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.

Uwagi dotyczące wywoływania

W .NET Framework 4 i starszych wersjach użyto tylko algorytmu sortowania.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. Sortowania identyfikuje nieprawidłowe porównanie w niektórych sytuacjach, w których operacja sortowania zgłasza IndexOutOfRangeException wyjątek, i ArgumentException zgłasza wyjątek do obiektu wywołującego.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Począwszy od ArgumentException , możliwe jest, że operacje sortowania, które wcześniej wygenerowały nie spowodują wygenerowania wyjątku, ponieważ algorytmy sortowania i kopcowanie wstawiania nie wykrywają nieprawidłowej metody porównującej. .NET Framework 4.5.NET Framework 4.5Starting 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. W większości przypadków ma to zastosowanie do tablic zawierających mniej niż 16 elementów.For the most part, this applies to arrays with fewer than 16 elements.

Zobacz też

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

Sortuje elementy w zakresie elementów w jednym wymiarze Array IComparable przy użyciu implementacji każdego elementu 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

Parametry

array
Array Array Array Array

Jednowymiarowa Array do sortowania.The one-dimensional Array to sort.

index
Int32 Int32 Int32 Int32

Początkowy indeks zakresu, który ma zostać posortowany.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Liczba elementów w zakresie do sortowania.The number of elements in the range to sort.

Wyjątki

arrayjest wielowymiarowych.array is multidimensional.

indexjest mniejsza niż Dolna granica array.index is less than the lower bound of array.

—lub—-or- lengthjest mniejsza od zera.length is less than zero.

indexi length nie określaj prawidłowego zakresu w array.index and length do not specify a valid range in array.

Co najmniej jeden element w array nie IComparable implementuje interfejsu.One or more elements in array do not implement the IComparable interface.

Przykłady

Poniższy przykład kodu pokazuje, jak sortować wartości Array przy użyciu domyślnej funkcji porównującej i niestandardowego modułu porównującego, która odwraca porządek sortowania.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. Zwróć uwagę, że wynik może się różnić w zależności od CultureInfobieżącej.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

Uwagi

Każdy element w określonym zakresie elementów w programie array musi IComparable implementować interfejs, aby można było porównywać z każdym innym elementem w 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.

Jeśli sortowanie nie zostało ukończone pomyślnie, wyniki są niezdefiniowane.If the sort is not successfully completed, the results are undefined.

Ta metoda używa algorytmu sortowania introspektywnego w następujący sposób:This method uses the introspective sort (introsort) algorithm as follows:

  • Jeśli rozmiar partycji jest mniejszy niż 16 elementów, używa algorytmu sortowania wstawiania .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Jeśli liczba partycji przekracza 2 * logN, gdzie n jest zakresem tablicy wejściowej, używa algorytmu kopcowanie .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • W przeciwnym razie używa algorytmu sortowania .Otherwise, it uses a Quicksort algorithm.

Ta implementacja wykonuje niestabilne sortowanie; oznacza to, że jeśli dwa elementy są równe, ich kolejność może nie zostać zachowana.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Natomiast stabilne sortowanie zachowuje kolejność elementów, które są równe.In contrast, a stable sort preserves the order of elements that are equal.

W przypadku tablic, które są sortowane przy użyciu algorytmów kopcowanie i sortowania, ta metoda jestn operacją o (log n), gdzie n is 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.

Zobacz też

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

Sortuje zakres elementów w parze jednowymiarowych Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) na podstawie kluczy w pierwszej kolejności Array przy użyciu IComparable implementacji każdego klucza.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)

Parametry

keys
Array Array Array Array

Jednowymiarowa Array , która zawiera klucze do sortowania.The one-dimensional Array that contains the keys to sort.

items
Array Array Array Array

Jednowymiarowa Array , która zawiera elementy, które odpowiadają poszczególnym kluczom keys Arrayw.The one-dimensional Array that contains the items that correspond to each of the keys in the keysArray.

—lub—-or- nullAby posortować tylko keys. Arraynull to sort only the keysArray.

index
Int32 Int32 Int32 Int32

Początkowy indeks zakresu, który ma zostać posortowany.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Liczba elementów w zakresie do sortowania.The number of elements in the range to sort.

Wyjątki

keysArray Jest wielowymiarowy.The keysArray is multidimensional.

—lub—-or- itemsArray Jest wielowymiarowy.The itemsArray is multidimensional.

indexjest mniejsza niż Dolna granica keys.index is less than the lower bound of keys.

—lub—-or- lengthjest mniejsza od zera.length is less than zero.

itemsnie nulljest, a keys długość jest itemswiększa niż długość.items is not null, and the length of keys is greater than the length of items.

—lub—-or- indexi length nie określaj prawidłowego zakresu keys Arrayw.index and length do not specify a valid range in the keysArray.

—lub—-or- itemsnullnie jest length Array, i itemsi nie określaj prawidłowego zakresu w. indexitems is not null, and index and length do not specify a valid range in the itemsArray.

Co najmniej jeden element w keys Array nie implementuje IComparable interfejsu.One or more elements in the keysArray do not implement the IComparable interface.

Przykłady

Poniższy przykład kodu pokazuje, jak sortować dwie skojarzone tablice, w których pierwsza tablica zawiera klucze, a druga tablica zawiera wartości.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. Sortowanie odbywa się przy użyciu domyślnej funkcji porównującej i niestandardowego modułu porównującego, który odwraca porządek sortowania.Sorts are done using the default comparer and a custom comparer that reverses the sort order. Zwróć uwagę, że wynik może się różnić w zależności od CultureInfobieżącej.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.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


   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

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

Uwagi

Każdy keys klucz w Array ma odpowiadający element w items Array.Each key in the keysArray has a corresponding item in the itemsArray. Gdy klucz jest zmieniany podczas sortowania, odpowiadający element w items Array jest podobnie zmieniany.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. W związku z items tym, Array jest sortowany według układu odpowiednich kluczy w keys Array.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Każdy klucz w określonym zakresie elementów w keys Array musi implementować interfejs, IComparable aby można było porównywać z każdym innym kluczem.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.

Można sortować, jeśli istnieje więcej elementów niż klucze, ale elementy, które nie mają odpowiednich kluczy, nie zostaną posortowane.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Nie można sortować, jeśli istnieje więcej kluczy niż elementy; spowoduje to ArgumentExceptionwyrzucanie.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Jeśli sortowanie nie zostało ukończone pomyślnie, wyniki są niezdefiniowane.If the sort is not successfully completed, the results are undefined.

Ta metoda używa algorytmu sortowania introspektywnego w następujący sposób:This method uses the introspective sort (introsort) algorithm as follows:

  • Jeśli rozmiar partycji jest mniejszy niż 16 elementów, używa algorytmu sortowania wstawiania .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Jeśli liczba partycji przekracza 2 * logN, gdzie n jest zakresem tablicy wejściowej, używa algorytmu kopcowanie .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • W przeciwnym razie używa algorytmu sortowania .Otherwise, it uses a Quicksort algorithm.

Ta implementacja wykonuje niestabilne sortowanie; oznacza to, że jeśli dwa elementy są równe, ich kolejność może nie zostać zachowana.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Natomiast stabilne sortowanie zachowuje kolejność elementów, które są równe.In contrast, a stable sort preserves the order of elements that are equal.

W przypadku tablic, które są sortowane przy użyciu algorytmów kopcowanie i sortowania, ta metoda jestn operacją o (log n), gdzie n is 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.

Zobacz też

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

Sortuje elementy w jednym wymiarze Array przy użyciu określonego. IComparerSorts 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

Parametry

array
Array Array Array Array

Tablica Jednowymiarowa do sortowania.The one-dimensional array to sort.

comparer
IComparer IComparer IComparer IComparer

Implementacja do użycia podczas porównywania elementów.The implementation to use when comparing elements.

—lub—-or- nullAby użyć IComparable implementacji każdego elementu.null to use the IComparable implementation of each element.

Wyjątki

arrayjest wielowymiarowych.array is multidimensional.

comparer to null, a jeden lub więcej elementów w array nie implementuje IComparable interfejsu.comparer is null, and one or more elements in array do not implement the IComparable interface.

Implementacja comparer spowodowała błąd podczas sortowania.The implementation of comparer caused an error during the sort. Na przykład, comparer program nie może zwrócić wartości 0 podczas porównywania elementu z samym sobą.For example, comparer might not return 0 when comparing an item with itself.

Przykłady

Poniższy przykład sortuje wartości w tablicy ciągów przy użyciu domyślnej funkcji porównującej.The following example sorts the values in a string array by using the default comparer. Definiuje również implementację IComparer niestandardową ReverseComparer o nazwie, która odwraca domyślny porządek sortowania obiektu podczas wykonywania porównania ciągów bez uwzględniania wielkości liter.It also defines a custom IComparer implementation named ReverseComparer that reverses an object's default sort order while performing a case-insensitive string comparison. Należy zauważyć, że dane wyjściowe mogą się różnić w zależności od bieżącej kultury.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

Uwagi

Jeśli comparer array jest null, każdy element musi implementować interfejs IComparable , aby można było porównań z każdym innym elementem w 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.

Jeśli sortowanie nie zostało ukończone pomyślnie, wyniki są niezdefiniowane.If the sort is not successfully completed, the results are undefined.

Ta metoda używa algorytmu sortowania introspektywnego w następujący sposób:This method uses the introspective sort (introsort) algorithm as follows:

  • Jeśli rozmiar partycji jest mniejszy niż 16 elementów, używa algorytmu sortowania wstawiania .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Jeśli liczba partycji przekracza 2 * logN, gdzie n jest zakresem tablicy wejściowej, używa algorytmu kopcowanie .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • W przeciwnym razie używa algorytmu sortowania .Otherwise, it uses a Quicksort algorithm.

Ta implementacja wykonuje niestabilne sortowanie; oznacza to, że jeśli dwa elementy są równe, ich kolejność może nie zostać zachowana.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Natomiast stabilne sortowanie zachowuje kolejność elementów, które są równe.In contrast, a stable sort preserves the order of elements that are equal.

W przypadku tablic, które są sortowane przy użyciu algorytmów kopcowanie i sortowanian , ta metoda jest Length operacją o (log n), gdzie n jest z 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 obejmuje wstępnie zdefiniowane IComparer implementacje wymienione w poniższej tabeli.The .NET Framework includes predefined IComparer implementations listed in the following table.

ImplementacjaImplementation OpisDescription
System.Collections.CaseInsensitiveComparer Porównuje wszystkie dwa obiekty, ale wykonuje porównanie ciągów bez uwzględniania wielkości liter.Compares any two objects, but performs a case-insensitive comparison of strings.
Comparer.Default Porównuje wszystkie dwa obiekty przy użyciu konwencji sortowania bieżącej kultury.Compares any two objects by using the sorting conventions of the current culture.
Comparer.DefaultInvariant Porównuje wszystkie dwa obiekty przy użyciu konwencji sortowania niezmiennej kultury.Compares any two objects by using the sorting conventions of the invariant culture.
Comparer<T>.Default Porównuje dwa obiekty typu T przy użyciu domyślnej kolejności sortowania typu.Compares two objects of type T by using the type's default sort order.

Możesz również obsługiwać niestandardowe porównania, dostarczając wystąpienie własnej IComparer implementacji comparer do parametru.You can also support custom comparisons by providing an instance of your own IComparer implementation to the comparer parameter. W tym przykładzie jest definiowana ReverseComparer Klasa, która odwraca domyślną kolejność sortowania dla wystąpień typu i wykonuje porównanie ciągów bez uwzględniania wielkości liter.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.

Uwagi dotyczące wywoływania

W .NET Framework 4 i starszych wersjach użyto tylko algorytmu sortowania.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. Sortowania identyfikuje nieprawidłowe porównanie w niektórych sytuacjach, w których operacja sortowania zgłasza IndexOutOfRangeException wyjątek, i ArgumentException zgłasza wyjątek do obiektu wywołującego.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Począwszy od ArgumentException , możliwe jest, że operacje sortowania, które wcześniej wygenerowały nie spowodują wygenerowania wyjątku, ponieważ algorytmy sortowania i kopcowanie wstawiania nie wykrywają nieprawidłowej metody porównującej. .NET Framework 4.5.NET Framework 4.5Starting 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. W większości przypadków ma to zastosowanie do tablic zawierających mniej niż 16 elementów.For the most part, this applies to arrays with fewer than 16 elements.

Zobacz też

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

Sortuje parę jednowymiarowych Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiadające elementy) w oparciu o klucze w pierwszej kolejności Array przy użyciu określonego 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)

Parametry

keys
Array Array Array Array

Jednowymiarowa Array , która zawiera klucze do sortowania.The one-dimensional Array that contains the keys to sort.

items
Array Array Array Array

Jednowymiarowa Array , która zawiera elementy, które odpowiadają poszczególnym kluczom keys Arrayw.The one-dimensional Array that contains the items that correspond to each of the keys in the keysArray.

—lub—-or- nullAby posortować tylko keys. Arraynull to sort only the keysArray.

comparer
IComparer IComparer IComparer IComparer

IComparer Implementacja do użycia podczas porównywania elementów.The IComparer implementation to use when comparing elements.

—lub—-or- nullAby użyć IComparable implementacji każdego elementu.null to use the IComparable implementation of each element.

Wyjątki

keysArray Jest wielowymiarowy.The keysArray is multidimensional.

—lub—-or- itemsArray Jest wielowymiarowy.The itemsArray is multidimensional.

itemsnie nulljest, a keys długość jest itemswiększa niż długość.items is not null, and the length of keys is greater than the length of items.

—lub—-or- Implementacja comparer spowodowała błąd podczas sortowania.The implementation of comparer caused an error during the sort. Na przykład, comparer program nie może zwrócić wartości 0 podczas porównywania elementu z samym sobą.For example, comparer might not return 0 when comparing an item with itself.

comparerjest nulli co najmniej jeden element keys Array w nie implementuje IComparable interfejsu.comparer is null, and one or more elements in the keysArray do not implement the IComparable interface.

Przykłady

Poniższy przykład pokazuje, jak sortować dwie skojarzone tablice, w których pierwsza tablica zawiera klucze, a druga tablica zawiera wartości.The following example shows how to sort two associated arrays where the first array contains the keys and the second array contains the values. Sortowanie odbywa się przy użyciu domyślnej funkcji porównującej i niestandardowego modułu porównującego, który odwraca porządek sortowania.Sorts are done using the default comparer and a custom comparer that reverses the sort order. Zwróć uwagę, że wynik może się różnić w zależności od CultureInfobieżącej.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.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


   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

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

Uwagi

Każdy keys klucz w Array ma odpowiadający element w items Array.Each key in the keysArray has a corresponding item in the itemsArray. Gdy klucz jest zmieniany podczas sortowania, odpowiadający element w items Array jest podobnie zmieniany.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. W związku z items tym, Array jest sortowany według układu odpowiednich kluczy w keys Array.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Jeśli comparer jest null ,każdyIComparable klucz w musiimplementowaćinterfejs,abymożnabyłoporównywaćzkażdyminnymkluczem.Array keysIf comparer is null, each key in the keysArray must implement the IComparable interface to be capable of comparisons with every other key.

Można sortować, jeśli istnieje więcej elementów niż klucze, ale elementy, które nie mają odpowiednich kluczy, nie zostaną posortowane.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Nie można sortować, jeśli istnieje więcej kluczy niż elementy; spowoduje to ArgumentExceptionwyrzucanie.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Jeśli sortowanie nie zostało ukończone pomyślnie, wyniki są niezdefiniowane.If the sort is not successfully completed, the results are undefined.

.NET Framework obejmuje wstępnie zdefiniowane IComparer implementacje wymienione w poniższej tabeli.The .NET Framework includes predefined IComparer implementations listed in the following table.

ImplementacjaImplementation OpisDescription
System.Collections.CaseInsensitiveComparer Porównuje wszystkie dwa obiekty, ale wykonuje porównanie ciągów bez uwzględniania wielkości liter.Compares any two objects, but performs a case-insensitive comparison of strings.
Comparer.Default Porównuje wszystkie dwa obiekty przy użyciu konwencji sortowania bieżącej kultury.Compares any two objects by using the sorting conventions of the current culture.
Comparer.DefaultInvariant Porównuje wszystkie dwa obiekty przy użyciu konwencji sortowania niezmiennej kultury.Compares any two objects by using the sorting conventions of the invariant culture.
Comparer<T>.Default Porównuje dwa obiekty typu T przy użyciu domyślnej kolejności sortowania typu.Compares two objects of type T by using the type's default sort order.

Możesz również obsługiwać niestandardowe porównania, dostarczając wystąpienie własnej IComparer implementacji comparer do parametru.You can also support custom comparisons by providing an instance of your own IComparer implementation to the comparer parameter. W tym przykładzie jest definiowana IComparer implementacja, która odwraca domyślny porządek sortowania i wykonuje Porównywanie ciągów bez uwzględniania wielkości liter.The example does this by defining an IComparer implementation that reverses the default sort order and performs case-insensitive string comparison.

Ta metoda używa algorytmu sortowania introspektywnego w następujący sposób:This method uses the introspective sort (introsort) algorithm as follows:

  • Jeśli rozmiar partycji jest mniejszy niż 16 elementów, używa algorytmu sortowania wstawiania .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Jeśli liczba partycji przekracza 2 * logN, gdzie n jest zakresem tablicy wejściowej, używa algorytmu kopcowanie .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • W przeciwnym razie używa algorytmu sortowania .Otherwise, it uses a Quicksort algorithm.

Ta implementacja wykonuje niestabilne sortowanie; oznacza to, że jeśli dwa elementy są równe, ich kolejność może nie zostać zachowana.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Natomiast stabilne sortowanie zachowuje kolejność elementów, które są równe.In contrast, a stable sort preserves the order of elements that are equal.

W przypadku tablic, które są sortowane przy użyciu algorytmów kopcowanie i sortowanian , ta metoda jest Length operacją o (log n), gdzie n jest z 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.

Uwagi dotyczące wywoływania

W .NET Framework 4 i starszych wersjach użyto tylko algorytmu sortowania.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. Sortowania identyfikuje nieprawidłowe porównanie w niektórych sytuacjach, w których operacja sortowania zgłasza IndexOutOfRangeException wyjątek, i ArgumentException zgłasza wyjątek do obiektu wywołującego.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Począwszy od ArgumentException , możliwe jest, że operacje sortowania, które wcześniej wygenerowały nie spowodują wygenerowania wyjątku, ponieważ algorytmy sortowania i kopcowanie wstawiania nie wykrywają nieprawidłowej metody porównującej. .NET Framework 4.5.NET Framework 4.5Starting 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. W większości przypadków ma to zastosowanie do tablic zawierających mniej niż 16 elementów.For the most part, this applies to arrays with fewer than 16 elements.

Zobacz też

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

Sortuje parę jednowymiarowych Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) w oparciu o klucze w pierwszej kolejności Array przy użyciu IComparable implementacji każdego klucza.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)

Parametry

keys
Array Array Array Array

Jednowymiarowa Array , która zawiera klucze do sortowania.The one-dimensional Array that contains the keys to sort.

items
Array Array Array Array

Jednowymiarowa Array , która zawiera elementy, które odpowiadają poszczególnym kluczom keys Arrayw.The one-dimensional Array that contains the items that correspond to each of the keys in the keysArray.

—lub—-or- nullAby posortować tylko keys. Arraynull to sort only the keysArray.

Wyjątki

keysArray Jest wielowymiarowy.The keysArray is multidimensional.

—lub—-or- itemsArray Jest wielowymiarowy.The itemsArray is multidimensional.

itemsnie nulljest, a keys długość jest itemswiększa niż długość.items is not null, and the length of keys is greater than the length of items.

Co najmniej jeden element w keys Array nie implementuje IComparable interfejsu.One or more elements in the keysArray do not implement the IComparable interface.

Przykłady

Poniższy przykład pokazuje, jak sortować dwie skojarzone tablice, w których pierwsza tablica zawiera klucze, a druga tablica zawiera wartości.The following example shows how to sort two associated arrays where the first array contains the keys and the second array contains the values. Sortowanie odbywa się przy użyciu domyślnej funkcji porównującej i niestandardowego modułu porównującego, który odwraca porządek sortowania.Sorts are done using the default comparer and a custom comparer that reverses the sort order. Zwróć uwagę, że wynik może się różnić w zależności od CultureInfobieżącej.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.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


   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

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

Uwagi

Każdy keys klucz w Array ma odpowiadający element w items Array.Each key in the keysArray has a corresponding item in the itemsArray. Gdy klucz jest zmieniany podczas sortowania, odpowiadający element w items Array jest podobnie zmieniany.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. W związku z items tym, Array jest sortowany według układu odpowiednich kluczy w keys Array.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Każdy klucz w keys Array musi implementować IComparable interfejs, aby można było porównań z każdym innym kluczem.Each key in the keysArray must implement the IComparable interface to be capable of comparisons with every other key.

Można sortować, jeśli istnieje więcej elementów niż klucze, ale elementy, które nie mają odpowiednich kluczy, nie zostaną posortowane.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Nie można sortować, jeśli istnieje więcej kluczy niż elementy; spowoduje to ArgumentExceptionwyrzucanie.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Jeśli sortowanie nie zostało ukończone pomyślnie, wyniki są niezdefiniowane.If the sort is not successfully completed, the results are undefined.

Ta metoda używa algorytmu sortowania introspektywnego w następujący sposób:This method uses the introspective sort (introsort) algorithm as follows:

  • Jeśli rozmiar partycji jest mniejszy niż 16 elementów, używa algorytmu sortowania wstawiania .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Jeśli liczba partycji przekracza 2 * logN, gdzie n jest zakresem tablicy wejściowej, używa algorytmu kopcowanie .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • W przeciwnym razie używa algorytmu sortowania .Otherwise, it uses a Quicksort algorithm.

Ta implementacja wykonuje niestabilne sortowanie; oznacza to, że jeśli dwa elementy są równe, ich kolejność może nie zostać zachowana.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Natomiast stabilne sortowanie zachowuje kolejność elementów, które są równe.In contrast, a stable sort preserves the order of elements that are equal.

W przypadku tablic, które są sortowane przy użyciu algorytmów kopcowanie i sortowanian , ta metoda jest Length operacją o (log n), gdzie n jest z 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.

Zobacz też

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

Sortuje elementy w całości jednowymiarowym Array IComparable przy użyciu implementacji każdego elementu 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

Parametry

array
Array Array Array Array

Jednowymiarowa Array do sortowania.The one-dimensional Array to sort.

Wyjątki

arrayjest wielowymiarowych.array is multidimensional.

Co najmniej jeden element w array nie IComparable implementuje interfejsu.One or more elements in array do not implement the IComparable interface.

Przykłady

Poniższy przykład kodu pokazuje, jak sortować wartości Array przy użyciu domyślnej funkcji porównującej i niestandardowego modułu porównującego, która odwraca porządek sortowania.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. Zwróć uwagę, że wynik może się różnić w zależności od CultureInfobieżącej.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

Uwagi

Każdy element array musi implementować interfejs IComparable , aby można było porównań z każdym innym elementem w array.Each element of array must implement the IComparable interface to be capable of comparisons with every other element in array.

Jeśli sortowanie nie zostało ukończone pomyślnie, wyniki są niezdefiniowane.If the sort is not successfully completed, the results are undefined.

Ta metoda używa algorytmu sortowania introspektywnego w następujący sposób:This method uses the introspective sort (introsort) algorithm as follows:

  • Jeśli rozmiar partycji jest mniejszy niż 16 elementów, używa algorytmu sortowania wstawiania .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Jeśli liczba partycji przekracza 2 * logN, gdzie n jest zakresem tablicy wejściowej, używa algorytmu kopcowanie .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • W przeciwnym razie używa algorytmu sortowania .Otherwise, it uses a Quicksort algorithm.

Ta implementacja wykonuje niestabilne sortowanie; oznacza to, że jeśli dwa elementy są równe, ich kolejność może nie zostać zachowana.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Natomiast stabilne sortowanie zachowuje kolejność elementów, które są równe.In contrast, a stable sort preserves the order of elements that are equal.

W przypadku tablic, które są sortowane przy użyciu algorytmów kopcowanie i sortowanian , ta metoda jest Length operacją o (log n), gdzie n jest z 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.

Zobacz też

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

Sortuje elementy w całości Array IComparable<T> przy użyciu ogólnej implementacji interfejsu każdego elementu 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())

Parametry typu

T

Typ elementów tablicy.The type of the elements of the array.

Parametry

array
T[]

Jednowymiarowe, zależne Array od zera, do sortowania.The one-dimensional, zero-based Array to sort.

Wyjątki

Co najmniej jeden element w array nie IComparable<T> implementuje interfejsu generycznego.One or more elements in array do not implement the IComparable<T> generic interface.

Przykłady

Poniższy przykład kodu demonstruje Sort<T>(T[]) Przeciążenie metody ogólnej BinarySearch<T>(T[], T) i Przeciążenie metody ogólnej.The following code example demonstrates the Sort<T>(T[]) generic method overload and the BinarySearch<T>(T[], T) generic method overload. Zostanie utworzona tablica ciągów, w której nie ma określonej kolejności.An array of strings is created, in no particular order.

Tablica jest wyświetlana, sortowana i ponownie wyświetlana.The array is displayed, sorted, and displayed again.

Uwaga

Wywołania Sort i BinarySearch metody ogólne nie wyglądają inaczej od wywołań do ich nieogólnych odpowiedników, ponieważ Visual Basic, C#i C++ wywnioskowania typu parametru typu ogólnego z typu pierwszego argumentu .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. Jeśli używasz Ildasm. exe (Il dezasembler) do badania języka pośredniego firmy Microsoft (MSIL), możesz zobaczyć, że metody ogólne są wywoływane.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.

Przeciążenie BinarySearch<T>(T[], T) metody ogólnej służy następnie do wyszukiwania dwóch ciągów, jeden, który nie znajduje się w tablicy i jeden.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. Tablica i wartość BinarySearch zwracana metody są przenoszone ShowWhere do metody generycznej, która wyświetla wartość indeksu, jeśli ciąg zostanie znaleziony i w przeciwnym razie elementy, do których odbędzie się ciąg wyszukiwania, między, jeśli znajdowały się w tablicy.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. Indeks ma wartość ujemną, jeśli ciąg nie ShowWhere jest n tablicą, więc metoda przyjmuje dopełnienie bitowe (operator ~ w C# i wizualizacja C++, Xor -1 w Visual Basic), aby uzyskać indeks pierwszego elementu na liście, który jest większy niż ciąg wyszukiwania.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.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.

Uwagi

Każdy element array musi IComparable<T> implementować interfejs ogólny, aby można było porównań z każdym innym elementem w array.Each element of array must implement the IComparable<T> generic interface to be capable of comparisons with every other element in array.

Jeśli sortowanie nie zostało ukończone pomyślnie, wyniki są niezdefiniowane.If the sort is not successfully completed, the results are undefined.

Ta metoda używa algorytmu sortowania introspektywnego w następujący sposób:This method uses the introspective sort (introsort) algorithm as follows:

  • Jeśli rozmiar partycji jest mniejszy niż 16 elementów, używa algorytmu sortowania wstawiania .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Jeśli liczba partycji przekracza 2 * logN, gdzie n jest zakresem tablicy wejściowej, używa algorytmu kopcowanie .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • W przeciwnym razie używa algorytmu sortowania .Otherwise, it uses a Quicksort algorithm.

Ta implementacja wykonuje niestabilne sortowanie; oznacza to, że jeśli dwa elementy są równe, ich kolejność może nie zostać zachowana.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Natomiast stabilne sortowanie zachowuje kolejność elementów, które są równe.In contrast, a stable sort preserves the order of elements that are equal.

W przypadku tablic, które są sortowane przy użyciu algorytmów kopcowanie i sortowanian , ta metoda jest Length operacją o (log n), gdzie n jest z 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.

Zobacz też

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

Sortuje elementy Array przy użyciu określonego IComparer<T> interfejsu ogólnego.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))

Parametry typu

T

Typ elementów tablicy.The type of the elements of the array.

Parametry

array
T[]

Jednowymiarowa, zerowa baza Array do sortowaniaThe one-dimensional, zero-base Array to sort

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

Ogólna implementacja interfejsu do użycia podczas porównywania elementów lub null do korzystania z IComparable<T> ogólnej implementacji interfejsu każdego elementu. IComparer<T>The IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

Wyjątki

comparerjest null, a co najmniej jeden element w array nie implementuje IComparable<T> interfejsu ogólnego.comparer is null, and one or more elements in array do not implement the IComparable<T> generic interface.

Implementacja comparer spowodowała błąd podczas sortowania.The implementation of comparer caused an error during the sort. Na przykład, comparer program nie może zwrócić wartości 0 podczas porównywania elementu z samym sobą.For example, comparer might not return 0 when comparing an item with itself.

Przykłady

Poniższy przykład kodu demonstruje Sort<T>(T[], IComparer<T>) Przeciążenie metody ogólnej BinarySearch<T>(T[], T, IComparer<T>) i Przeciążenie metody ogólnej.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.

Przykład kodu definiuje alternatywną funkcję porównującą dla ciągów o ReverseComparenazwie, która IComparer<string> implementuje interfejsIComparer(Of String) ogólny (w IComparer<String^> Visual Basic w C++języku Visual).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. Funkcja porównująca wywołuje CompareTo(String) metodę, odwracając kolejność comparands, tak aby ciągi były sortowane od wysokich do niskiego poziomu, a nie jako niskiego poziomu.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.

Tablica jest wyświetlana, sortowana i ponownie wyświetlana.The array is displayed, sorted, and displayed again. Aby można było użyć metody, BinarySearch tablice muszą być posortowane.Arrays must be sorted in order to use the BinarySearch method.

Uwaga

Wywołania Sort<T>(T[], IComparer<T>) i BinarySearch<T>(T[], T, IComparer<T>) metody ogólne nie wyglądają inaczej od wywołań do ich nieogólnych odpowiedników, ponieważ Visual Basic, C#i C++ wywnioskowania typu parametru typu ogólnego z typu pierwszego argumentu .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. Jeśli używasz Ildasm. exe (Il dezasembler) do badania języka pośredniego firmy Microsoft (MSIL), możesz zobaczyć, że metody ogólne są wywoływane.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.

Przeciążenie BinarySearch<T>(T[], T, IComparer<T>) metody ogólnej służy następnie do wyszukiwania dwóch ciągów, jeden, który nie znajduje się w tablicy i jeden.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. Tablica i wartość BinarySearch<T>(T[], T, IComparer<T>) zwracana metody są przenoszone ShowWhere do metody generycznej, która wyświetla wartość indeksu, jeśli ciąg zostanie znaleziony i w przeciwnym razie elementy, do których odbędzie się ciąg wyszukiwania, między, jeśli znajdowały się w tablicy.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. Indeks ma wartość ujemną, jeśli ciąg nie ShowWhere jest n tablicą, więc metoda przyjmuje dopełnienie bitowe (operator ~ w C# i wizualizacja C++, Xor -1 w Visual Basic), aby uzyskać indeks pierwszego elementu na liście, który jest większy niż ciąg wyszukiwania.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.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.

Uwagi

Jeśli comparer array jest ,każdyIComparable<T> element musi implementować interfejs ogólny, aby można było porównań z każdym innym elementem w array. nullIf 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.

Jeśli sortowanie nie zostało ukończone pomyślnie, wyniki są niezdefiniowane.If the sort is not successfully completed, the results are undefined.

Ta metoda używa algorytmu sortowania introspektywnego w następujący sposób:This method uses the introspective sort (introsort) algorithm as follows:

  • Jeśli rozmiar partycji jest mniejszy niż 16 elementów, używa algorytmu sortowania wstawiania .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Jeśli liczba partycji przekracza 2 * logN, gdzie n jest zakresem tablicy wejściowej, używa algorytmu kopcowanie .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • W przeciwnym razie używa algorytmu sortowania .Otherwise, it uses a Quicksort algorithm.

Ta implementacja wykonuje niestabilne sortowanie; oznacza to, że jeśli dwa elementy są równe, ich kolejność może nie zostać zachowana.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Natomiast stabilne sortowanie zachowuje kolejność elementów, które są równe.In contrast, a stable sort preserves the order of elements that are equal.

W przypadku tablic, które są sortowane przy użyciu algorytmów kopcowanie i sortowanian , ta metoda jest Length operacją o (log n), gdzie n jest z 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.

Uwagi dotyczące wywoływania

W .NET Framework 4 i starszych wersjach użyto tylko algorytmu sortowania.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. Sortowania identyfikuje nieprawidłowe porównanie w niektórych sytuacjach, w których operacja sortowania zgłasza IndexOutOfRangeException wyjątek, i ArgumentException zgłasza wyjątek do obiektu wywołującego.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Począwszy od ArgumentException , możliwe jest, że operacje sortowania, które wcześniej wygenerowały nie spowodują wygenerowania wyjątku, ponieważ algorytmy sortowania i kopcowanie wstawiania nie wykrywają nieprawidłowej metody porównującej. .NET Framework 4.5.NET Framework 4.5Starting 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. W większości przypadków ma to zastosowanie do tablic zawierających mniej niż 16 elementów.For the most part, this applies to arrays with fewer than 16 elements.

Zobacz też

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

Sortuje elementy Array przy użyciu określonego 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))

Parametry typu

T

Typ elementów tablicy.The type of the elements of the array.

Parametry

array
T[]

Jednowymiarowe, zależne Array od zera, do sortowaniaThe one-dimensional, zero-based Array to sort

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

Comparison<T> Do użycia podczas porównywania elementów.The Comparison<T> to use when comparing elements.

Wyjątki

arrayjest null.array is null.

—lub—-or- comparisonjest null.comparison is null.

Implementacja comparison spowodowała błąd podczas sortowania.The implementation of comparison caused an error during the sort. Na przykład, comparison program nie może zwrócić wartości 0 podczas porównywania elementu z samym sobą.For example, comparison might not return 0 when comparing an item with itself.

Przykłady

Poniższy przykład kodu demonstruje Sort(Comparison<T>) Przeciążenie metody.The following code example demonstrates the Sort(Comparison<T>) method overload.

Przykład kodu definiuje alternatywną metodę porównania dla ciągów o nazwie CompareDinosByLength.The code example defines an alternative comparison method for strings, named CompareDinosByLength. Ta metoda działa w następujący sposób: Najpierw comparands są testowane dlanull, a odwołanie o wartości null jest traktowane jako mniejsze niż wartość null.This method works as follows: First, the comparands are tested fornull, and a null reference is treated as less than a non-null. W drugim, długości ciągu są porównywane, a dłuższy ciąg jest uznawany za większy.Second, the string lengths are compared, and the longer string is deemed to be greater. Trzecia, jeśli długości są równe, używane jest zwykłe Porównywanie ciągów.Third, if the lengths are equal, ordinary string comparison is used.

Tablica ciągów jest tworzona i wypełniana czterema ciągami w określonej kolejności.A array of strings is created and populated with four strings, in no particular order. Lista zawiera również pusty ciąg i odwołanie o wartości null.The list also includes an empty string and a null reference. Zostanie wyświetlona lista, posortowana przy użyciu Comparison<T> ogólnego delegata CompareDinosByLength reprezentującego metodę i ponownie wyświetlana.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.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"

Uwagi

Jeśli sortowanie nie zostało ukończone pomyślnie, wyniki są niezdefiniowane.If the sort is not successfully completed, the results are undefined.

Ta metoda używa algorytmu algorytmu Sort (introspektywnego) w następujący sposób:This method uses introspective sort (introsort) algorithm as follows:

  • Jeśli rozmiar partycji jest mniejszy niż 16 elementów, używa algorytmu sortowania wstawiania .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Jeśli liczba partycji przekracza 2 * logN, gdzie n jest zakresem tablicy wejściowej, używa algorytmu kopcowanie .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • W przeciwnym razie używa algorytmu sortowania .Otherwise, it uses a Quicksort algorithm.

Ta implementacja wykonuje niestabilne sortowanie; oznacza to, że jeśli dwa elementy są równe, ich kolejność może nie zostać zachowana.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Natomiast stabilne sortowanie zachowuje kolejność elementów, które są równe.In contrast, a stable sort preserves the order of elements that are equal.

W przypadku tablic, które są sortowane przy użyciu algorytmów kopcowanie i sortowanian , ta metoda jest Length operacją o (log n), gdzie n jest z 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.

Uwagi dotyczące wywoływania

W .NET Framework 4 i starszych wersjach użyto tylko algorytmu sortowania.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. Sortowania identyfikuje nieprawidłowe porównanie w niektórych sytuacjach, w których operacja sortowania zgłasza IndexOutOfRangeException wyjątek, i ArgumentException zgłasza wyjątek do obiektu wywołującego.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Począwszy od ArgumentException , możliwe jest, że operacje sortowania, które wcześniej wygenerowały nie spowodują wygenerowania wyjątku, ponieważ algorytmy sortowania i kopcowanie wstawiania nie wykrywają nieprawidłowej metody porównującej. .NET Framework 4.5.NET Framework 4.5Starting 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. W większości przypadków ma to zastosowanie do tablic zawierających mniej niż 16 elementów.For the most part, this applies to arrays with fewer than 16 elements.

Zobacz też

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

Sortuje elementy w zakresie elementów Array IComparable<T> przy użyciu ogólnej implementacji interfejsu każdego elementu 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)

Parametry typu

T

Typ elementów tablicy.The type of the elements of the array.

Parametry

array
T[]

Jednowymiarowe, zależne Array od zera, do sortowaniaThe one-dimensional, zero-based Array to sort

index
Int32 Int32 Int32 Int32

Początkowy indeks zakresu, który ma zostać posortowany.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Liczba elementów w zakresie do sortowania.The number of elements in the range to sort.

Wyjątki

indexjest mniejsza niż Dolna granica array.index is less than the lower bound of array.

—lub—-or- lengthjest mniejsza od zera.length is less than zero.

indexi length nie określaj prawidłowego zakresu w array.index and length do not specify a valid range in array.

Co najmniej jeden element w array nie IComparable<T> implementuje interfejsu generycznego.One or more elements in array do not implement the IComparable<T> generic interface.

Przykłady

Poniższy przykład kodu demonstruje Sort<T>(T[], Int32, Int32) Przeciążenie metody ogólnej Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) i Przeciążenie metody ogólnej do sortowania zakresu w tablicy.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.

Przykład kodu definiuje alternatywną funkcję porównującą dla ciągów o ReverseComparenazwie, która IComparer<string> implementuje interfejsIComparer(Of String) ogólny (w IComparer<String^> Visual Basic w C++języku Visual).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. Funkcja porównująca wywołuje CompareTo(String) metodę, odwracając kolejność comparands, tak aby ciągi były sortowane od wysokich do niskiego poziomu, a nie jako niskiego poziomu.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.

Przykładowy kod tworzy i wyświetla tablicę nazw dinozaurów, składającą się z trzech herbivores, po których następują trzy (tyrannosaurids).The code example creates and displays an array of dinosaur names, consisting of three herbivores followed by three carnivores (tyrannosaurids, to be precise). Przeciążenie Sort<T>(T[], Int32, Int32) metody ogólnej służy do sortowania ostatnich trzech elementów tablicy, która jest następnie wyświetlana.The Sort<T>(T[], Int32, Int32) generic method overload is used to sort the last three elements of the array, which is then displayed. Przeciążenie metody ReverseCompare ogólnej służy do sortowania ostatnich trzech elementów w odwrotnej kolejności. Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)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. Starannie pomylić dinozaury są wyświetlane ponownie.The thoroughly confused dinosaurs are displayed again.

Uwaga

Wywołania Sort<T>(T[], IComparer<T>) i BinarySearch<T>(T[], T, IComparer<T>) metody ogólne nie wyglądają inaczej od wywołań do ich nieogólnych odpowiedników, ponieważ Visual Basic, C#i C++ wywnioskowania typu parametru typu ogólnego z typu pierwszego argumentu .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. Jeśli używasz Ildasm. exe (Il dezasembler) do badania języka pośredniego firmy Microsoft (MSIL), możesz zobaczyć, że metody ogólne są wywoływane.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.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

Uwagi

Każdy element w określonym zakresie elementów w programie array musi IComparable<T> implementować interfejs ogólny, aby można było porównywać z każdym innym elementem w 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.

Jeśli sortowanie nie zostało ukończone pomyślnie, wyniki są niezdefiniowane.If the sort is not successfully completed, the results are undefined.

Ta metoda używa algorytmu sortowania introspektywnego w następujący sposób:This method uses the introspective sort (introsort) algorithm as follows:

  • Jeśli rozmiar partycji jest mniejszy niż 16 elementów, używa algorytmu sortowania wstawiania .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Jeśli liczba partycji przekracza 2 * logN, gdzie n jest zakresem tablicy wejściowej, używa algorytmu kopcowanie .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • W przeciwnym razie używa algorytmu sortowania .Otherwise, it uses a Quicksort algorithm.

Ta implementacja wykonuje niestabilne sortowanie; oznacza to, że jeśli dwa elementy są równe, ich kolejność może nie zostać zachowana.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Natomiast stabilne sortowanie zachowuje kolejność elementów, które są równe.In contrast, a stable sort preserves the order of elements that are equal.

W przypadku tablic, które są sortowane przy użyciu algorytmów kopcowanie i sortowania, ta metoda jestn operacją o (log n), gdzie n is 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.

Zobacz też

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

Sortuje elementy w zakresie elementów Array przy użyciu określonego IComparer<T> interfejsu ogólnego.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))

Parametry typu

T

Typ elementów tablicy.The type of the elements of the array.

Parametry

array
T[]

Jednowymiarowe, zależne Array od zera, do sortowania.The one-dimensional, zero-based Array to sort.

index
Int32 Int32 Int32 Int32

Początkowy indeks zakresu, który ma zostać posortowany.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Liczba elementów w zakresie do sortowania.The number of elements in the range to sort.

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

Ogólna implementacja interfejsu do użycia podczas porównywania elementów lub null do korzystania z IComparable<T> ogólnej implementacji interfejsu każdego elementu. IComparer<T>The IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

Wyjątki

indexjest mniejsza niż Dolna granica array.index is less than the lower bound of array.

—lub—-or- lengthjest mniejsza od zera.length is less than zero.

indexi length nie określaj prawidłowego zakresu w array.index and length do not specify a valid range in array.

—lub—-or- Implementacja comparer spowodowała błąd podczas sortowania.The implementation of comparer caused an error during the sort. Na przykład, comparer program nie może zwrócić wartości 0 podczas porównywania elementu z samym sobą.For example, comparer might not return 0 when comparing an item with itself.

comparerjest null, a co najmniej jeden element w array nie implementuje IComparable<T> interfejsu ogólnego.comparer is null, and one or more elements in array do not implement the IComparable<T> generic interface.

Przykłady

Poniższy przykład kodu demonstruje Sort<T>(T[], Int32, Int32) Przeciążenie metody ogólnej Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) i Przeciążenie metody ogólnej do sortowania zakresu w tablicy.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.

Przykład kodu definiuje alternatywną funkcję porównującą dla ciągów o ReverseComparenazwie, która IComparer<string> implementuje interfejsIComparer(Of String) ogólny (w IComparer<String^> Visual Basic w C++języku Visual).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. Funkcja porównująca wywołuje CompareTo(String) metodę, odwracając kolejność comparands, tak aby ciągi były sortowane od wysokich do niskiego poziomu, a nie jako niskiego poziomu.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.

Przykładowy kod tworzy i wyświetla tablicę nazw dinozaurów, składającą się z trzech herbivores, po których następują trzy (tyrannosaurids).The code example creates and displays an array of dinosaur names, consisting of three herbivores followed by three carnivores (tyrannosaurids, to be precise). Przeciążenie Sort<T>(T[], Int32, Int32) metody ogólnej służy do sortowania ostatnich trzech elementów tablicy, która jest następnie wyświetlana.The Sort<T>(T[], Int32, Int32) generic method overload is used to sort the last three elements of the array, which is then displayed. Przeciążenie metody ReverseCompare ogólnej służy do sortowania ostatnich trzech elementów w odwrotnej kolejności. Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)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. Starannie pomylić dinozaury są wyświetlane ponownie.The thoroughly confused dinosaurs are displayed again.

Uwaga

Wywołania Sort<T>(T[], IComparer<T>) i BinarySearch<T>(T[], T, IComparer<T>) metody ogólne nie wyglądają inaczej od wywołań do ich nieogólnych odpowiedników, ponieważ Visual Basic, C#i C++ wywnioskowania typu parametru typu ogólnego z typu pierwszego argumentu .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. Jeśli używasz Ildasm. exe (Il dezasembler) do badania języka pośredniego firmy Microsoft (MSIL), możesz zobaczyć, że metody ogólne są wywoływane.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.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

Uwagi

Jeśli comparer array jest null, każdy element w określonym zakresie IComparable<T> elementów w musi implementować interfejs ogólny, aby można było porównywać z każdym innym elementem w 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.

Jeśli sortowanie nie zostało ukończone pomyślnie, wyniki są niezdefiniowane.If the sort is not successfully completed, the results are undefined.

Ta metoda używa algorytmu sortowania introspektywnego w następujący sposób:This method uses the introspective sort (introsort) algorithm as follows:

  • Jeśli rozmiar partycji jest mniejszy niż 16 elementów, używa algorytmu sortowania wstawiania .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Jeśli liczba partycji przekracza 2 * logN, gdzie n jest zakresem tablicy wejściowej, używa algorytmu kopcowanie .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • W przeciwnym razie używa algorytmu sortowania .Otherwise, it uses a Quicksort algorithm.

Ta implementacja wykonuje niestabilne sortowanie; oznacza to, że jeśli dwa elementy są równe, ich kolejność może nie zostać zachowana.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Natomiast stabilne sortowanie zachowuje kolejność elementów, które są równe.In contrast, a stable sort preserves the order of elements that are equal.

W przypadku tablic, które są sortowane przy użyciu algorytmów kopcowanie i sortowania, ta metoda jestn operacją o (log n), gdzie n is 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.

Uwagi dotyczące wywoływania

W .NET Framework 4 i starszych wersjach użyto tylko algorytmu sortowania.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. Sortowania identyfikuje nieprawidłowe porównanie w niektórych sytuacjach, w których operacja sortowania zgłasza IndexOutOfRangeException wyjątek, i ArgumentException zgłasza wyjątek do obiektu wywołującego.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Począwszy od ArgumentException , możliwe jest, że operacje sortowania, które wcześniej wygenerowały nie spowodują wygenerowania wyjątku, ponieważ algorytmy sortowania i kopcowanie wstawiania nie wykrywają nieprawidłowej metody porównującej. .NET Framework 4.5.NET Framework 4.5Starting 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. W większości przypadków ma to zastosowanie do tablic zawierających mniej niż 16 elementów.For the most part, this applies to arrays with fewer than 16 elements.

Zobacz też

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

Sortuje parę Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) w oparciu o klucze w pierwszej kolejności Array przy użyciu IComparable<T> ogólnej implementacji interfejsu każdego klucza.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())

Parametry typu

TKey

Typ elementów tablicy kluczy.The type of the elements of the key array.

TValue

Typ elementów tablicy Items.The type of the elements of the items array.

Parametry

keys
TKey[]

Jednowymiarowa, zależna od Array zera, która zawiera klucze do sortowania.The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

Array Jednowymiarowa, zależna od zera, która zawiera elementy, które odpowiadają kluczom w keys keys, null lub do sortowania.The one-dimensional, zero-based Array that contains the items that correspond to the keys in keys, or null to sort only keys.

Wyjątki

itemsnie jest keys items, a dolna granica jest niezgodna z dolną granicą. nullitems is not null, and the lower bound of keys does not match the lower bound of items.

—lub—-or- itemsnie nulljest, a keys długość jest itemswiększa niż długość.items is not null, and the length of keys is greater than the length of items.

Co najmniej jeden element w keys Array nie implementuje IComparable<T> interfejsu generycznego.One or more elements in the keysArray do not implement the IComparable<T> generic interface.

Przykłady

Sort<TKey,TValue>(TKey[], TValue[])Poniższy przykład kodu demonstruje przeciążenia metody, Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>), Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)i Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) , w celu sortowania par tablic, które reprezentują klucze i wartości.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.

Przykład kodu definiuje alternatywną funkcję porównującą dla ciągów o ReverseComparenazwie, która IComparer<string> implementuje interfejsIComparer(Of String) ogólny (w IComparer<String^> Visual Basic w C++języku Visual).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. Funkcja porównująca wywołuje CompareTo(String) metodę, odwracając kolejność comparands, tak aby ciągi były sortowane od wysokich do niskiego poziomu, a nie jako niskiego poziomu.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.

Przykładowy kod tworzy i wyświetla tablicę nazw dinozaurów (klucze) i tablicę liczb całkowitych reprezentujących maksymalną długość każdej dinozaura w metrach (wartości).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). Tablice są następnie sortowane i wyświetlane kilka razy:The arrays are then sorted and displayed several times:

Uwaga

Wywołania metod ogólnych nie wyglądają inaczej od wywołań do ich nieogólnych odpowiedników, ponieważ Visual Basic, C#i C++ wywnioskowania typu parametru typu ogólnego z typu pierwszych dwa argumenty.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. Jeśli używasz Ildasm. exe (Il dezasembler) do badania języka pośredniego firmy Microsoft (MSIL), możesz zobaczyć, że metody ogólne są wywoływane.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.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.

Uwagi

Każdy keys klucz w Array ma odpowiadający element w items Array.Each key in the keysArray has a corresponding item in the itemsArray. Gdy klucz jest zmieniany podczas sortowania, odpowiadający element w items Array jest podobnie zmieniany.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. W związku z items tym, Array jest sortowany według układu odpowiednich kluczy w keys Array.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Każdy klucz w keys Array musi implementować IComparable<T> interfejs ogólny, aby można było porównań z każdym innym kluczem.Each key in the keysArray must implement the IComparable<T> generic interface to be capable of comparisons with every other key.

Można sortować, jeśli istnieje więcej elementów niż klucze, ale elementy, które nie mają odpowiednich kluczy, nie zostaną posortowane.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Nie można sortować, jeśli istnieje więcej kluczy niż elementy; spowoduje to ArgumentExceptionwyrzucanie.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Jeśli sortowanie nie zostało ukończone pomyślnie, wyniki są niezdefiniowane.If the sort is not successfully completed, the results are undefined.

Ta metoda używa algorytmu sortowania introspektywnego w następujący sposób:This method uses the introspective sort (introsort) algorithm as follows:

  • Jeśli rozmiar partycji jest mniejszy niż 16 elementów, używa algorytmu sortowania wstawiania .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Jeśli liczba partycji przekracza 2 * logN, gdzie n jest zakresem tablicy wejściowej, używa algorytmu kopcowanie .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • W przeciwnym razie używa algorytmu sortowania .Otherwise, it uses a Quicksort algorithm.

Ta implementacja wykonuje niestabilne sortowanie; oznacza to, że jeśli dwa elementy są równe, ich kolejność może nie zostać zachowana.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Natomiast stabilne sortowanie zachowuje kolejność elementów, które są równe.In contrast, a stable sort preserves the order of elements that are equal.

W przypadku tablic, które są sortowane przy użyciu algorytmów kopcowanie i sortowanian , ta metoda jest Length operacją o (log n), gdzie n jest z 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.

Zobacz też

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

Sortuje parę Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiednie elementy) w oparciu o klucze w pierwszej kolejności Array przy użyciu określonego IComparer<T> interfejsu ogólnego.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))

Parametry typu

TKey

Typ elementów tablicy kluczy.The type of the elements of the key array.

TValue

Typ elementów tablicy Items.The type of the elements of the items array.

Parametry

keys
TKey[]

Jednowymiarowa, zależna od Array zera, która zawiera klucze do sortowania.The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

Array Jednowymiarowa, zależna od zera, która zawiera elementy, które odpowiadają kluczom w keys keys, null lub do sortowania.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>

Ogólna implementacja interfejsu do użycia podczas porównywania elementów lub null do korzystania z IComparable<T> ogólnej implementacji interfejsu każdego elementu. IComparer<T>The IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

Wyjątki

itemsnie jest keys items, a dolna granica jest niezgodna z dolną granicą. nullitems is not null, and the lower bound of keys does not match the lower bound of items.

—lub—-or- itemsnie nulljest, a keys długość jest itemswiększa niż długość.items is not null, and the length of keys is greater than the length of items.

—lub—-or- Implementacja comparer spowodowała błąd podczas sortowania.The implementation of comparer caused an error during the sort. Na przykład, comparer program nie może zwrócić wartości 0 podczas porównywania elementu z samym sobą.For example, comparer might not return 0 when comparing an item with itself.

comparerjest nulli co najmniej jeden element keys Array w nie implementuje IComparable<T> interfejsu generycznego.comparer is null, and one or more elements in the keysArray do not implement the IComparable<T> generic interface.

Przykłady

Poniższy przykład kodu pokazuje, że Sort<TKey,TValue>(TKey[], TValue[])[], TValue<linki 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), i Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) przeciążania metod ogólnych dla sortowania par tablic, które reprezentują klucze i wartości.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.

Przykład kodu definiuje alternatywną funkcję porównującą dla ciągów o ReverseComparenazwie, która IComparer<string> implementuje interfejsIComparer(Of String) ogólny (w IComparer<String^> Visual Basic w C++języku Visual).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. Funkcja porównująca wywołuje CompareTo(String) metodę, odwracając kolejność comparands, tak aby ciągi były sortowane od wysokich do niskiego poziomu, a nie jako niskiego poziomu.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.

Przykładowy kod tworzy i wyświetla tablicę nazw dinozaurów (klucze) i tablicę liczb całkowitych reprezentujących maksymalną długość każdej dinozaura w metrach (wartości).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). Tablice są następnie sortowane i wyświetlane kilka razy:The arrays are then sorted and displayed several times:

Uwaga

Wywołania metod ogólnych nie wyglądają inaczej od wywołań do ich nieogólnych odpowiedników, ponieważ Visual Basic, C#i C++ wywnioskowania typu parametru typu ogólnego z typu pierwszych dwa argumenty.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. Jeśli używasz Ildasm. exe (Il dezasembler) do badania języka pośredniego firmy Microsoft (MSIL), możesz zobaczyć, że metody ogólne są wywoływane.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.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.

Uwagi

Każdy keys klucz w Array ma odpowiadający element w items Array.Each key in the keysArray has a corresponding item in the itemsArray. Gdy klucz jest zmieniany podczas sortowania, odpowiadający element w items Array jest podobnie zmieniany.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. W związku z items tym, Array jest sortowany według układu odpowiednich kluczy w keys Array.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Jeśli comparer jest null ,każdyIComparable<T> klucz w musiimplementowaćinterfejsogólny,abymożnabyłoporównywaćzkażdyminnymkluczem.Array keysIf comparer is null, each key in the keysArray must implement the IComparable<T> generic interface to be capable of comparisons with every other key.

Można sortować, jeśli istnieje więcej elementów niż klucze, ale elementy, które nie mają odpowiednich kluczy, nie zostaną posortowane.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Nie można sortować, jeśli istnieje więcej kluczy niż elementy; spowoduje to ArgumentExceptionwyrzucanie.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Jeśli sortowanie nie zostało ukończone pomyślnie, wyniki są niezdefiniowane.If the sort is not successfully completed, the results are undefined.

Ta metoda używa algorytmu sortowania introspektywnego w następujący sposób:This method uses the introspective sort (introsort) algorithm as follows:

  • Jeśli rozmiar partycji jest mniejszy niż 16 elementów, używa algorytmu sortowania wstawiania .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Jeśli liczba partycji przekracza 2 * logN, gdzie n jest zakresem tablicy wejściowej, używa algorytmu kopcowanie .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • W przeciwnym razie używa algorytmu sortowania .Otherwise, it uses a Quicksort algorithm.

Ta implementacja wykonuje niestabilne sortowanie; oznacza to, że jeśli dwa elementy są równe, ich kolejność może nie zostać zachowana.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Natomiast stabilne sortowanie zachowuje kolejność elementów, które są równe.In contrast, a stable sort preserves the order of elements that are equal.

W przypadku tablic, które są sortowane przy użyciu algorytmów kopcowanie i sortowanian , ta metoda jest Length operacją o (log n), gdzie n jest z 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.

Uwagi dotyczące wywoływania

W .NET Framework 4 i starszych wersjach użyto tylko algorytmu sortowania.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. Sortowania identyfikuje nieprawidłowe porównanie w niektórych sytuacjach, w których operacja sortowania zgłasza IndexOutOfRangeException wyjątek, i ArgumentException zgłasza wyjątek do obiektu wywołującego.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Począwszy od ArgumentException , możliwe jest, że operacje sortowania, które wcześniej wygenerowały nie spowodują wygenerowania wyjątku, ponieważ algorytmy sortowania i kopcowanie wstawiania nie wykrywają nieprawidłowej metody porównującej. .NET Framework 4.5.NET Framework 4.5Starting 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. W większości przypadków ma to zastosowanie do tablic zawierających mniej niż 16 elementów.For the most part, this applies to arrays with fewer than 16 elements.

Zobacz też

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)

Sortuje zakres elementów w parze Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiadające elementy) w oparciu o klucze w pierwszej kolejności Array przy użyciu IComparable<T> uniwersalnej implementacji interfejsu każdego klucza.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)

Parametry typu

TKey

Typ elementów tablicy kluczy.The type of the elements of the key array.

TValue

Typ elementów tablicy Items.The type of the elements of the items array.

Parametry

keys
TKey[]

Jednowymiarowa, zależna od Array zera, która zawiera klucze do sortowania.The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

Array Jednowymiarowa, zależna od zera, która zawiera elementy, które odpowiadają kluczom w keys keys, null lub do sortowania.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

Początkowy indeks zakresu, który ma zostać posortowany.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Liczba elementów w zakresie do sortowania.The number of elements in the range to sort.

Wyjątki

indexjest mniejsza niż Dolna granica keys.index is less than the lower bound of keys.

—lub—-or- lengthjest mniejsza od zera.length is less than zero.

itemsnie jest keys items, a dolna granica jest niezgodna z dolną granicą. nullitems is not null, and the lower bound of keys does not match the lower bound of items.

—lub—-or- itemsnie nulljest, a keys długość jest itemswiększa niż długość.items is not null, and the length of keys is greater than the length of items.

—lub—-or- indexi length nie określaj prawidłowego zakresu keys Arrayw.index and length do not specify a valid range in the keysArray.

—lub—-or- itemsnullnie jest length Array, i itemsi nie określaj prawidłowego zakresu w. indexitems is not null, and index and length do not specify a valid range in the itemsArray.

Co najmniej jeden element w keys Array nie implementuje IComparable<T> interfejsu generycznego.One or more elements in the keysArray do not implement the IComparable<T> generic interface.

Przykłady

Poniższy przykład kodu demonstruje Sort<TKey,TValue>(TKey[], TValue[]), Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>), [], TValue<linki XREF: System. Array. Sort% 60% 602% 28% 60% 600% 5B% 5D% 2C% 60% 601% 5B% 5D% 2CSystem. Int32% 2CSystem. Int32% 29 > i Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) przeciążenia metod ogólnych dla sortowania par tablic, które reprezentują klucze i wartości.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.

Przykład kodu definiuje alternatywną funkcję porównującą dla ciągów o ReverseComparenazwie, która IComparer<string> implementuje interfejsIComparer(Of String) ogólny (w IComparer<String^> Visual Basic w C++języku Visual).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. Funkcja porównująca wywołuje CompareTo(String) metodę, odwracając kolejność comparands, tak aby ciągi były sortowane od wysokich do niskiego poziomu, a nie jako niskiego poziomu.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.

Przykładowy kod tworzy i wyświetla tablicę nazw dinozaurów (klucze) i tablicę liczb całkowitych reprezentujących maksymalną długość każdej dinozaura w metrach (wartości).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). Tablice są następnie sortowane i wyświetlane kilka razy:The arrays are then sorted and displayed several times:

Uwaga

Wywołania metod ogólnych nie wyglądają inaczej od wywołań do ich nieogólnych odpowiedników, ponieważ Visual Basic, C#i C++ wywnioskowania typu parametru typu ogólnego z typu pierwszych dwa argumenty.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. Jeśli używasz Ildasm. exe (Il dezasembler) do badania języka pośredniego firmy Microsoft (MSIL), możesz zobaczyć, że metody ogólne są wywoływane.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.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.

Uwagi

Każdy keys klucz w Array ma odpowiadający element w items Array.Each key in the keysArray has a corresponding item in the itemsArray. Gdy klucz jest zmieniany podczas sortowania, odpowiadający element w items Array jest podobnie zmieniany.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. W związku z items tym, Array jest sortowany według układu odpowiednich kluczy w keys Array.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Każdy klucz w określonym zakresie elementów w keys Array musi implementować IComparable<T> interfejs ogólny, aby można było porównywać z każdym innym kluczem.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.

Można sortować, jeśli istnieje więcej elementów niż klucze, ale elementy, które nie mają odpowiednich kluczy, nie zostaną posortowane.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Nie można sortować, jeśli istnieje więcej kluczy niż elementy; spowoduje to ArgumentExceptionwyrzucanie.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Jeśli sortowanie nie zostało ukończone pomyślnie, wyniki są niezdefiniowane.If the sort is not successfully completed, the results are undefined.

Ta metoda używa algorytmu sortowania introspektywnego w następujący sposób:This method uses the introspective sort (introsort) algorithm as follows:

  • Jeśli rozmiar partycji jest mniejszy niż 16 elementów, używa algorytmu sortowania wstawiania .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Jeśli liczba partycji przekracza 2 * logN, gdzie n jest zakresem tablicy wejściowej, używa algorytmu kopcowanie .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • W przeciwnym razie używa algorytmu sortowania .Otherwise, it uses a Quicksort algorithm.

Ta implementacja wykonuje niestabilne sortowanie; oznacza to, że jeśli dwa elementy są równe, ich kolejność może nie zostać zachowana.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Natomiast stabilne sortowanie zachowuje kolejność elementów, które są równe.In contrast, a stable sort preserves the order of elements that are equal.

W przypadku tablic, które są sortowane przy użyciu algorytmów kopcowanie i sortowania, ta metoda jestn operacją o (log n), gdzie n is 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.

Zobacz też

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

Sortuje zakres elementów w parze Array obiektów (jeden zawiera klucze, a drugi zawiera odpowiadające elementy) w oparciu o klucze w pierwszej kolejności Array przy użyciu określonego IComparer<T> interfejsu ogólnego.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))

Parametry typu

TKey

Typ elementów tablicy kluczy.The type of the elements of the key array.

TValue

Typ elementów tablicy Items.The type of the elements of the items array.

Parametry

keys
TKey[]

Jednowymiarowa, zależna od Array zera, która zawiera klucze do sortowania.The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

Array Jednowymiarowa, zależna od zera, która zawiera elementy, które odpowiadają kluczom w keys keys, null lub do sortowania.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

Początkowy indeks zakresu, który ma zostać posortowany.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Liczba elementów w zakresie do sortowania.The number of elements in the range to sort.

comparer
IComparer<TKey>

Ogólna implementacja interfejsu do użycia podczas porównywania elementów lub null do korzystania z IComparable<T> ogólnej implementacji interfejsu każdego elementu. IComparer<T>The IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

Wyjątki

indexjest mniejsza niż Dolna granica keys.index is less than the lower bound of keys.

—lub—-or- lengthjest mniejsza od zera.length is less than zero.

itemsnie jest keys items, a dolna granica jest niezgodna z dolną granicą. nullitems is not null, and the lower bound of keys does not match the lower bound of items.

—lub—-or- itemsnie nulljest, a keys długość jest itemswiększa niż długość.items is not null, and the length of keys is greater than the length of items.

—lub—-or- indexi length nie określaj prawidłowego zakresu keys Arrayw.index and length do not specify a valid range in the keysArray.

—lub—-or- itemsnullnie jest length Array, i itemsi nie określaj prawidłowego zakresu w. indexitems is not null, and index and length do not specify a valid range in the itemsArray.

—lub—-or- Implementacja comparer spowodowała błąd podczas sortowania.The implementation of comparer caused an error during the sort. Na przykład, comparer program nie może zwrócić wartości 0 podczas porównywania elementu z samym sobą.For example, comparer might not return 0 when comparing an item with itself.

comparerjest nulli co najmniej jeden element keys Array w nie implementuje IComparable<T> interfejsu generycznego.comparer is null, and one or more elements in the keysArray do not implement the IComparable<T> generic interface.

Przykłady

Poniższy przykład Sort<TKey,TValue>(TKey[], TValue[])kodu demonstruje Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>)],,<, i [, TValue linki XREF: System. Array. Sort% 60% 602% 28% 60% 600% 5B% 5D% 2C% 60% 601% 5B% 5D% 2CSystem. Int32% 2CSystem. Int32% Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) 2CSystem. Collections. Generic. IComparer% 7B% 60% 600%, wy>o przeciążenia metod ogólnych, do sortowania par tablic, które reprezentują klucze i wartości.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.

Przykład kodu definiuje alternatywną funkcję porównującą dla ciągów o ReverseComparenazwie, która IComparer<string>implementuje interfejsIComparer(Of String) ogólny (w IComparer<String^> Visual Basic w C++języku Visual).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. Funkcja porównująca wywołuje CompareTo(String) metodę, odwracając kolejność comparands, tak aby ciągi były sortowane od wysokich do niskiego poziomu, a nie jako niskiego poziomu.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.

Przykładowy kod tworzy i wyświetla tablicę nazw dinozaurów (klucze) i tablicę liczb całkowitych reprezentujących maksymalną długość każdej dinozaura w metrach (wartości).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). Tablice są następnie sortowane i wyświetlane kilka razy:The arrays are then sorted and displayed several times:

  • Sort<TKey,TValue>(TKey[], TValue[]) Przeciążenie jest używane do sortowania obydwu tablic w kolejności nazw dinozaurów w pierwszej tablicy.The Sort<TKey,TValue>(TKey[], TValue[]) overload is used to sort both arrays in order of the dinosaur names in the first array.

  • Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Przeciążenie iReverseCompare wystąpienie są używane do odwrócenia kolejności sortowania dla sparowanych tablic.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.

  • Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Przeciążenie jest używane do sortowania ostatnich trzech elementów obu tablic.The Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) overload is used to sort the last three elements of both arrays.

  • [], TValue<linki XREF: System. Array. Sort% 60% 602% 28% 60% 600% 5B% 5D% 2C% 3% 601% 5B% 5D% 2CSystem. Int32% 2CSystem. Int32% 2CSystem. Collections. Generic. IComparer% 7b% 60% 600%% 29 > Przeciążenie jest używane do sortowania ostatnich trzech elementy obu tablic w odwrotnej kolejności.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.

Uwaga

Wywołania metod ogólnych nie wyglądają inaczej od wywołań do ich nieogólnych odpowiedników, ponieważ Visual Basic, C#i C++ wywnioskowania typu parametru typu ogólnego z typu pierwszych dwa argumenty.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. Jeśli używasz Ildasm. exe (Il dezasembler) do badania języka pośredniego firmy Microsoft (MSIL), możesz zobaczyć, że metody ogólne są wywoływane.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.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.

Uwagi

Każdy keys klucz w Array ma odpowiadający element w items Array.Each key in the keysArray has a corresponding item in the itemsArray. Gdy klucz jest zmieniany podczas sortowania, odpowiadający element w items Array jest podobnie zmieniany.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. W związku z items tym, Array jest sortowany według układu odpowiednich kluczy w keys Array.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Jeśli comparer keys jest null, każdy klucz w określonym Array zakresie elementów IComparable<T> w musi implementować interfejs ogólny, aby można było porównywać z każdym innym kluczem.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.

Można sortować, jeśli istnieje więcej elementów niż klucze, ale elementy, które nie mają odpowiednich kluczy, nie zostaną posortowane.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Nie można sortować, jeśli istnieje więcej kluczy niż elementy; spowoduje to ArgumentExceptionwyrzucanie.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Jeśli sortowanie nie zostało ukończone pomyślnie, wyniki są niezdefiniowane.If the sort is not successfully completed, the results are undefined.

Ta metoda używa algorytmu sortowania introspektywnego w następujący sposób:This method uses the introspective sort (introsort) algorithm as follows:

  • Jeśli rozmiar partycji jest mniejszy niż 16 elementów, używa algorytmu sortowania wstawiania .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Jeśli liczba partycji przekracza 2 * logN, gdzie n jest zakresem tablicy wejściowej, używa algorytmu kopcowanie .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • W przeciwnym razie używa algorytmu sortowania .Otherwise, it uses a Quicksort algorithm.

Ta implementacja wykonuje niestabilne sortowanie; oznacza to, że jeśli dwa elementy są równe, ich kolejność może nie zostać zachowana.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Natomiast stabilne sortowanie zachowuje kolejność elementów, które są równe.In contrast, a stable sort preserves the order of elements that are equal.

W przypadku tablic, które są sortowane przy użyciu algorytmów kopcowanie i sortowania, ta metoda jestn operacją o (log n), gdzie n is 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.

Uwagi dotyczące wywoływania

W .NET Framework 4 i starszych wersjach użyto tylko algorytmu sortowania.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. Sortowania identyfikuje nieprawidłowe porównanie w niektórych sytuacjach, w których operacja sortowania zgłasza IndexOutOfRangeException wyjątek, i ArgumentException zgłasza wyjątek do obiektu wywołującego.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Począwszy od ArgumentException , możliwe jest, że operacje sortowania, które wcześniej wygenerowały nie spowodują wygenerowania wyjątku, ponieważ algorytmy sortowania i kopcowanie wstawiania nie wykrywają nieprawidłowej metody porównującej. .NET Framework 4.5.NET Framework 4.5Starting 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. W większości przypadków ma to zastosowanie do tablic zawierających mniej niż 16 elementów.For the most part, this applies to arrays with fewer than 16 elements.

Zobacz też

Dotyczy