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

定義

1 次元配列の要素を並べ替えます。Sorts the elements in a one-dimensional array.

オーバーロード

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

1 次元 Array の範囲内の要素範囲を、指定した IComparer を使用して並べ替えます。Sorts the elements in a range of elements in a one-dimensional Array using the specified IComparer.

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

2 つの 1 次元 Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) 内の要素範囲を、最初の Array 内のキーに基づき、指定した 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)

Array の各要素によって実装された IComparable を使用して、1 次元 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)

2 つの 1 次元 Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) の要素範囲を、最初の Array 内のキーに基づき、各キーによって実装された IComparable を使用して並べ替えます。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)

1 次元 Array 内の要素を、指定した IComparer を使用して並べ替えます。Sorts the elements in a one-dimensional Array using the specified IComparer.

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

2 つの 1 次元 Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) を、最初の Array 内のキーに基づき、指定した 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)

2 つの 1 次元 Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) を、最初の Array 内のキーに基づき、各キーによって実装された IComparable を使用して並べ替えます。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)

Array の各要素によって実装された IComparable を使用して、1 次元 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[])

Array の各要素によって実装された IComparable<T> ジェネリック インターフェイスを使用して、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>)

Array 内の要素を、指定した IComparer<T> ジェネリック インターフェイスを使用して並べ替えます。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>)

Array 内の要素を、指定した 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)

Array の各要素によって実装された IComparable<T> ジェネリック インターフェイスを使用して、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>)

指定した Array ジェネリック インターフェイスを使用して、IComparer<T> 内の要素範囲を並べ替えます。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[])

2 つの Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) を、最初の Array 内のキーに基づき、各キーによって実装された IComparable<T> ジェネリック インターフェイスを使用して並べ替えます。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>)

2 つの Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) を、最初の Array 内のキーに基づき、指定した IComparer<T> ジェネリック インターフェイスを使用して並べ替えます。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)

2 つの Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) の要素範囲を、最初の Array 内のキーに基づき、各キーによって実装された IComparable<T> ジェネリック インターフェイスを使用して並べ替えます。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>)

2 つの Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) 内の要素範囲を、最初の Array 内のキーに基づき、指定した IComparer<T> ジェネリック インターフェイスを使用して並べ替えます。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)

1 次元 Array の範囲内の要素範囲を、指定した IComparer を使用して並べ替えます。Sorts the elements in a range of elements in a one-dimensional Array using the specified IComparer.

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

パラメーター

array
Array Array Array Array

並べ替え対象となる 1 次元 ArrayThe one-dimensional Array to sort.

index
Int32 Int32 Int32 Int32

並べ替え対象の範囲の開始位置を示すインデックス。The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

並べ替え対象の範囲内にある要素の数。The number of elements in the range to sort.

comparer
IComparer IComparer IComparer IComparer

要素を比較する場合に使用する IComparer の実装。The IComparer implementation to use when comparing elements.

- または --or- 各要素の IComparable 実装を使用する場合は nullnull to use the IComparable implementation of each element.

例外

array が多次元です。array is multidimensional.

index は、array の下限を下回っています。index is less than the lower bound of array.

- または --or- length が 0 未満です。length is less than zero.

index および lengtharray の有効な範囲を指定していません。index and length do not specify a valid range in array.

- または --or- comparer の実装により、並べ替え中にエラーが発生しました。The implementation of comparer caused an error during the sort. たとえば、comparer は、項目をそれ自体と比較したときに 0 を返さなかった可能性があります。For example, comparer might not return 0 when comparing an item with itself.

comparernull で、array の 1 つ以上の要素が IComparable インターフェイスを実装していません。comparer is null, and one or more elements in array do not implement the IComparable interface.

次のコード例は、既定の比較子と並べ替えArray順序を反転するカスタム比較子を使用して、の値を並べ替える方法を示しています。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. 結果は現在CultureInfoのによって異なる場合があることに注意してください。Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

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

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

   Console::WriteLine();
}

int main()
{
   // Create and initialize a new array. and a new custom comparer.
   array<String^>^ words = { "The","QUICK","BROWN","FOX","jumps",
                             "over","the","lazy","dog" };
   // Instantiate the reverse comparer.
   IComparer^ revComparer = gcnew ReverseComparer();
   
   // Display the values of the Array.
   Console::WriteLine( "The original order of elements in the array:" );
   DisplayValues(words);

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

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

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

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

/* 
This code produces the following output.

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

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

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

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

After sorting the entire Array using the reverse case-insensitive comparer:
   [0] : the
   [1] : The
   [2] : QUICK
   [3] : over
   [4] : lazy
   [5] : jumps
   [6] : FOX
   [7] : dog
   [8] : BROWN

*/
using System;
using System.Collections;

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

public class Example 
{
   public static void Main()  
   {
      // Create and initialize a new array. 
      String[] words = { "The", "QUICK", "BROWN", "FOX", "jumps", 
                         "over", "the", "lazy", "dog" };
      // Instantiate the reverse comparer.
      IComparer revComparer = new ReverseComparer();
 
      // Display the values of the array.
      Console.WriteLine( "The original order of elements in the array:" );
      DisplayValues(words);
 
      // Sort a section of the array using the default comparer.
      Array.Sort(words, 1, 3);
      Console.WriteLine( "After sorting elements 1-3 by using the default comparer:");
      DisplayValues(words);

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

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

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

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

Public Module Example
   Public Sub Main()
      ' Create and initialize a new array.
      Dim words() As String =  { "The", "QUICK", "BROWN", "FOX", "jumps", 
                                 "over", "the", "lazy", "dog" }
      ' Instantiate a new custom comparer.
      Dim revComparer As New ReverseComparer()

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

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

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

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

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

   Public Sub DisplayValues(arr() As String)
      For i As Integer = arr.GetLowerBound(0) To arr.GetUpperBound(0)
         Console.WriteLine("   [{0}] : {1}", i, arr(i))
      Next 
      Console.WriteLine()
   End Sub 
End Module 
' The example displays the following output:
'    The original order of elements in the array:
'       [0] : The
'       [1] : QUICK
'       [2] : BROWN
'       [3] : FOX
'       [4] : jumps
'       [5] : over
'       [6] : the
'       [7] : lazy
'       [8] : dog
'    
'    After sorting elements 1-3 by using the default comparer:
'       [0] : The
'       [1] : BROWN
'       [2] : FOX
'       [3] : QUICK
'       [4] : jumps
'       [5] : over
'       [6] : the
'       [7] : lazy
'       [8] : dog
'    
'    After sorting elements 1-3 by using the reverse case-insensitive comparer:
'       [0] : The
'       [1] : QUICK
'       [2] : FOX
'       [3] : BROWN
'       [4] : jumps
'       [5] : over
'       [6] : the
'       [7] : lazy
'       [8] : dog
'    
'    After sorting the entire array by using the default comparer:
'       [0] : BROWN
'       [1] : dog
'       [2] : FOX
'       [3] : jumps
'       [4] : lazy
'       [5] : over
'       [6] : QUICK
'       [7] : the
'       [8] : The
'    
'    After sorting the entire array using the reverse case-insensitive comparer:
'       [0] : the
'       [1] : The
'       [2] : QUICK
'       [3] : over
'       [4] : lazy
'       [5] : jumps
'       [6] : FOX
'       [7] : dog
'       [8] : BROWN

注釈

comparer array IComparableの場合、内の指定された要素範囲内の各要素は、内arrayの他のすべての要素と比較できるように、インターフェイスを実装する必要があります。 nullIf 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.

並べ替えが正常に完了しなかった場合、結果は未定義になります。If the sort is not successfully completed, the results are undefined.

.NET Framework には、 IComparer次の表に示す定義済みの実装が含まれています。The .NET Framework includes predefined IComparer implementations listed in the following table.

実装Implementation 説明Description
System.Collections.CaseInsensitiveComparer 2つのオブジェクトを比較しますが、文字列の大文字と小文字を区別しない比較を実行します。Compares any two objects, but performs a case-insensitive comparison of strings.
Comparer.Default 現在のカルチャの並べ替え規則を使用して、2つのオブジェクトを比較します。Compares any two objects by using the sorting conventions of the current culture.
Comparer.DefaultInvariant インバリアントカルチャの並べ替え規則を使用して、2つのオブジェクトを比較します。Compares any two objects by using the sorting conventions of the invariant culture.
Comparer<T>.Default 型の既定の並べ替えT順序を使用して、型の2つのオブジェクトを比較します。Compares two objects of type T by using the type's default sort order.

独自IComparerの実装のインスタンスをパラメーターに指定することによって、 comparerカスタムの比較をサポートすることもできます。You can also support custom comparisons by providing an instance of your own IComparer implementation to the comparer parameter. この例では、型のReverseComparerインスタンスの既定の並べ替え順序を反転するクラスを定義し、大文字と小文字を区別しない文字列比較を実行します。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.

このメソッドでは、次のように introspective sort (introsort) アルゴリズムが使用されます。This method uses the introspective sort (introsort) algorithm as follows:

  • パーティションサイズが16要素よりも小さい場合、挿入並べ替えアルゴリズムが使用されます。If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • パーティションの数が 2 * LogNを超えている場合 ( nは入力配列の範囲)、 heapsortアルゴリズムが使用されます。If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • それ以外の場合は、クイックソートアルゴリズムを使用します。Otherwise, it uses a Quicksort algorithm.

この実装は、不安定な並べ替えを実行します。つまり、2つの要素が等しい場合、その順序は保持されない可能性があります。This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. これに対して、安定した並べ替えでは、等しい要素の順序が保持されます。In contrast, a stable sort preserves the order of elements that are equal.

Heapsort アルゴリズムとクイックソートアルゴリズムを使用して並べ替えられた配列の場合、最悪の場合、このメソッドはn O n(log) 操作nlengthなります。ここで、はです。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.

注意 (呼び出し元)

.NET Framework 4 以前のバージョンでは、クイックソートアルゴリズムのみが使用されていました。The .NET Framework 4 and earlier versions used only the Quicksort algorithm. クイックソートは、並べ替え操作によって例外がIndexOutOfRangeExceptionスローされ、呼び出し元にArgumentException例外をスローする場合に、無効な比較子を識別します。Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. 以降では、挿入の並べ替えおよび heapsort アルゴリズムで無効ArgumentExceptionな比較子が検出されないため、以前にスローされた並べ替え操作で例外がスローされない可能性があります。 .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. ほとんどの場合、これは16個未満の要素を持つ配列に適用されます。For the most part, this applies to arrays with fewer than 16 elements.

こちらもご覧ください

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

2 つの 1 次元 Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) 内の要素範囲を、最初の Array 内のキーに基づき、指定した 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)

パラメーター

keys
Array Array Array Array

並べ替え対象となるキーを格納する 1 次元 ArrayThe one-dimensional Array that contains the keys to sort.

items
Array Array Array Array

keysArray 内の各キーに対応する項目を格納する 1 次元 ArrayThe one-dimensional Array that contains the items that correspond to each of the keys in the keysArray.

- または --or- keysArray のみを並べ替える場合は nullnull to sort only the keysArray.

index
Int32 Int32 Int32 Int32

並べ替え対象の範囲の開始位置を示すインデックス。The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

並べ替え対象の範囲内にある要素の数。The number of elements in the range to sort.

comparer
IComparer IComparer IComparer IComparer

要素を比較する場合に使用する IComparer の実装。The IComparer implementation to use when comparing elements.

- または --or- 各要素の IComparable 実装を使用する場合は nullnull to use the IComparable implementation of each element.

例外

keysArray が多次元です。The keysArray is multidimensional.

- または --or- itemsArray が多次元です。The itemsArray is multidimensional.

index は、keys の下限を下回っています。index is less than the lower bound of keys.

- または --or- length が 0 未満です。length is less than zero.

itemsnull ではなく、keys の下限が items の下限と一致していません。items is not null, and the lower bound of keys does not match the lower bound of items.

- または --or- itemsnull ではなく、keys の長さが items の長さを超えています。items is not null, and the length of keys is greater than the length of items.

- または --or- index および lengthkeysArray内の指定した位置にある値を取得します。index and length do not specify a valid range in the keysArray.

- または --or- itemsnull ではなく、index および lengthitemsArray 内の有効な範囲を示していません。items is not null, and index and length do not specify a valid range in the itemsArray.

または-or- comparer の実装により、並べ替え中にエラーが発生しました。The implementation of comparer caused an error during the sort. たとえば、comparer は、項目をそれ自体と比較したときに 0 を返さなかった可能性があります。For example, comparer might not return 0 when comparing an item with itself.

comparernull であり、keysArray 内の 1 つ以上の要素に IComparable インターフェイスが実装されていません。comparer is null, and one or more elements in the keysArray do not implement the IComparable interface.

次のコード例では、最初の配列にキーが含まれ、2番目の配列に値が格納されている2つの関連する配列を並べ替える方法を示します。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. 並べ替えは、既定の比較子と、並べ替え順序を反転するカスタム比較子を使用して行われます。Sorts are done using the default comparer and a custom comparer that reverses the sort order. 結果は現在CultureInfoのによって異なる場合があることに注意してください。Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

public ref class myReverserClass: public IComparer
{
private:

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

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

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

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

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

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

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

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

/* 
This code produces the following output.

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

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

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

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

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

*/
using System;
using System.Collections;

public class SamplesArray  {
 
   public class myReverserClass : IComparer  {

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

   }

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

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

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

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

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


/* 
This code produces the following output.

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

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

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

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

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

*/

Imports System
Imports System.Collections

Public Class SamplesArray

   Public Class myReverserClass
      Implements IComparer

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

   End Class 'myReverserClass


   Public Shared Sub Main()

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

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

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

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

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

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

   End Sub 'Main


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

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

   End Sub 'PrintKeysAndValues

End Class 'SamplesArray


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

注釈

keys items Arrayの各キーには、内の対応する項目があります。ArrayEach key in the keysArray has a corresponding item in the itemsArray. 並べ替え中にキーが移動されると、内items Arrayの対応する項目も同様に再配置されます。When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. したがって、 keysは、内Arrayの対応するキーの配置に従って並べ替えられます。 items ArrayTherefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

comparernull場合、 keys 内のArray指定された要素範囲内の各キーは、他のすべてのキーと比較できるように、インターフェイスを実装する必要があります。IComparableIf 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.

キー以外の項目がある場合は、並べ替えることができますが、対応するキーがない項目は並べ替えられません。You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. 項目よりも多くのキーがある場合は、並べ替えることはできません。この操作を行うArgumentExceptionと、がスローされます。You cannot sort if there are more keys than items; doing this throws an ArgumentException.

並べ替えが正常に完了しなかった場合、結果は未定義になります。If the sort is not successfully completed, the results are undefined.

.NET Framework には、 IComparer次の表に示す定義済みの実装が含まれています。The .NET Framework includes predefined IComparer implementations listed in the following table.

実装Implementation 説明Description
System.Collections.CaseInsensitiveComparer 2つのオブジェクトを比較しますが、文字列の大文字と小文字を区別しない比較を実行します。Compares any two objects, but performs a case-insensitive comparison of strings.
Comparer.Default 現在のカルチャの並べ替え規則を使用して、2つのオブジェクトを比較します。Compares any two objects by using the sorting conventions of the current culture.
Comparer.DefaultInvariant インバリアントカルチャの並べ替え規則を使用して、2つのオブジェクトを比較します。Compares any two objects by using the sorting conventions of the invariant culture.
Comparer<T>.Default 型の既定の並べ替えT順序を使用して、型の2つのオブジェクトを比較します。Compares two objects of type T by using the type's default sort order.

独自IComparerの実装のインスタンスをパラメーターに指定することによって、 comparerカスタムの比較をサポートすることもできます。You can also support custom comparisons by providing an instance of your own IComparer implementation to the comparer parameter. この例では、既定の並べ替えIComparer順序を反転し、大文字と小文字を区別しない文字列比較を実行するカスタム実装を定義します。The example does this by defining a custom IComparer implementation that reverses the default sort order and performs case-insensitive string comparison.

このメソッドでは、次のように introspective sort (introsort) アルゴリズムが使用されます。This method uses the introspective sort (introsort) algorithm as follows:

  • パーティションサイズが16要素よりも小さい場合、挿入並べ替えアルゴリズムが使用されます。If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • パーティションの数が 2 * LogNを超えている場合 ( nは入力配列の範囲)、 heapsortアルゴリズムが使用されます。If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • それ以外の場合は、クイックソートアルゴリズムを使用します。Otherwise, it uses a Quicksort algorithm.

この実装は、不安定な並べ替えを実行します。つまり、2つの要素が等しい場合、その順序は保持されない可能性があります。This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. これに対して、安定した並べ替えでは、等しい要素の順序が保持されます。In contrast, a stable sort preserves the order of elements that are equal.

Heapsort アルゴリズムとクイックソートアルゴリズムを使用して並べ替えられた配列の場合、最悪の場合、このメソッドはn O n(log) 操作nlengthなります。ここで、はです。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.

注意 (呼び出し元)

.NET Framework 4 以前のバージョンでは、クイックソートアルゴリズムのみが使用されていました。The .NET Framework 4 and earlier versions used only the Quicksort algorithm. クイックソートは、並べ替え操作によって例外がIndexOutOfRangeExceptionスローされ、呼び出し元にArgumentException例外をスローする場合に、無効な比較子を識別します。Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. 以降では、挿入の並べ替えおよび heapsort アルゴリズムで無効ArgumentExceptionな比較子が検出されないため、以前にスローされた並べ替え操作で例外がスローされない可能性があります。 .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. ほとんどの場合、これは16個未満の要素を持つ配列に適用されます。For the most part, this applies to arrays with fewer than 16 elements.

こちらもご覧ください

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

Array の各要素によって実装された IComparable を使用して、1 次元 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

パラメーター

array
Array Array Array Array

並べ替え対象となる 1 次元 ArrayThe one-dimensional Array to sort.

index
Int32 Int32 Int32 Int32

並べ替え対象の範囲の開始位置を示すインデックス。The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

並べ替え対象の範囲内にある要素の数。The number of elements in the range to sort.

例外

array が多次元です。array is multidimensional.

index は、array の下限を下回っています。index is less than the lower bound of array.

- または --or- length が 0 未満です。length is less than zero.

index および lengtharray の有効な範囲を指定していません。index and length do not specify a valid range in array.

array の 1 つ以上の要素が、IComparable インターフェイスを実装していません。One or more elements in array do not implement the IComparable interface.

次のコード例は、既定の比較子と並べ替えArray順序を反転するカスタム比較子を使用して、の値を並べ替える方法を示しています。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. 結果は現在CultureInfoのによって異なる場合があることに注意してください。Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

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

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

   Console::WriteLine();
}

int main()
{
   // Create and initialize a new array. and a new custom comparer.
   array<String^>^ words = { "The","QUICK","BROWN","FOX","jumps",
                             "over","the","lazy","dog" };
   // Instantiate the reverse comparer.
   IComparer^ revComparer = gcnew ReverseComparer();
   
   // Display the values of the Array.
   Console::WriteLine( "The original order of elements in the array:" );
   DisplayValues(words);

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

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

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

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

/* 
This code produces the following output.

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

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

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

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

After sorting the entire Array using the reverse case-insensitive comparer:
   [0] : the
   [1] : The
   [2] : QUICK
   [3] : over
   [4] : lazy
   [5] : jumps
   [6] : FOX
   [7] : dog
   [8] : BROWN

*/
using System;
using System.Collections;

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

public class Example 
{
   public static void Main()  
   {
      // Create and initialize a new array. 
      String[] words = { "The", "QUICK", "BROWN", "FOX", "jumps", 
                         "over", "the", "lazy", "dog" };
      // Instantiate the reverse comparer.
      IComparer revComparer = new ReverseComparer();
 
      // Display the values of the array.
      Console.WriteLine( "The original order of elements in the array:" );
      DisplayValues(words);
 
      // Sort a section of the array using the default comparer.
      Array.Sort(words, 1, 3);
      Console.WriteLine( "After sorting elements 1-3 by using the default comparer:");
      DisplayValues(words);

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

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

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

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

Public Module Example
   Public Sub Main()
      ' Create and initialize a new array.
      Dim words() As String =  { "The", "QUICK", "BROWN", "FOX", "jumps", 
                                 "over", "the", "lazy", "dog" }
      ' Instantiate a new custom comparer.
      Dim revComparer As New ReverseComparer()

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

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

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

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

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

   Public Sub DisplayValues(arr() As String)
      For i As Integer = arr.GetLowerBound(0) To arr.GetUpperBound(0)
         Console.WriteLine("   [{0}] : {1}", i, arr(i))
      Next 
      Console.WriteLine()
   End Sub 
End Module 
' The example displays the following output:
'    The original order of elements in the array:
'       [0] : The
'       [1] : QUICK
'       [2] : BROWN
'       [3] : FOX
'       [4] : jumps
'       [5] : over
'       [6] : the
'       [7] : lazy
'       [8] : dog
'    
'    After sorting elements 1-3 by using the default comparer:
'       [0] : The
'       [1] : BROWN
'       [2] : FOX
'       [3] : QUICK
'       [4] : jumps
'       [5] : over
'       [6] : the
'       [7] : lazy
'       [8] : dog
'    
'    After sorting elements 1-3 by using the reverse case-insensitive comparer:
'       [0] : The
'       [1] : QUICK
'       [2] : FOX
'       [3] : BROWN
'       [4] : jumps
'       [5] : over
'       [6] : the
'       [7] : lazy
'       [8] : dog
'    
'    After sorting the entire array by using the default comparer:
'       [0] : BROWN
'       [1] : dog
'       [2] : FOX
'       [3] : jumps
'       [4] : lazy
'       [5] : over
'       [6] : QUICK
'       [7] : the
'       [8] : The
'    
'    After sorting the entire array using the reverse case-insensitive comparer:
'       [0] : the
'       [1] : The
'       [2] : QUICK
'       [3] : over
'       [4] : lazy
'       [5] : jumps
'       [6] : FOX
'       [7] : dog
'       [8] : BROWN

注釈

arrayの指定した要素範囲内の各要素はIComparable 、内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.

並べ替えが正常に完了しなかった場合、結果は未定義になります。If the sort is not successfully completed, the results are undefined.

このメソッドでは、次のように introspective sort (introsort) アルゴリズムが使用されます。This method uses the introspective sort (introsort) algorithm as follows:

  • パーティションサイズが16要素よりも小さい場合、挿入並べ替えアルゴリズムが使用されます。If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • パーティションの数が 2 * LogNを超えている場合 ( nは入力配列の範囲)、 heapsortアルゴリズムが使用されます。If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • それ以外の場合は、クイックソートアルゴリズムを使用します。Otherwise, it uses a Quicksort algorithm.

この実装は、不安定な並べ替えを実行します。つまり、2つの要素が等しい場合、その順序は保持されない可能性があります。This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. これに対して、安定した並べ替えでは、等しい要素の順序が保持されます。In contrast, a stable sort preserves the order of elements that are equal.

Heapsort アルゴリズムとクイックソートアルゴリズムを使用して並べ替えられた配列の場合、最悪の場合、このメソッドはn O n(log) 操作nlengthなります。ここで、はです。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.

こちらもご覧ください

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

2 つの 1 次元 Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) の要素範囲を、最初の Array 内のキーに基づき、各キーによって実装された IComparable を使用して並べ替えます。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)

パラメーター

keys
Array Array Array Array

並べ替え対象となるキーを格納する 1 次元 ArrayThe one-dimensional Array that contains the keys to sort.

items
Array Array Array Array

keysArray 内の各キーに対応する項目を格納する 1 次元 ArrayThe one-dimensional Array that contains the items that correspond to each of the keys in the keysArray.

または-or- keysArray のみを並べ替える場合は nullnull to sort only the keysArray.

index
Int32 Int32 Int32 Int32

並べ替え対象の範囲の開始位置を示すインデックス。The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

並べ替え対象の範囲内にある要素の数。The number of elements in the range to sort.

例外

keysArray が多次元です。The keysArray is multidimensional.

- または --or- itemsArray が多次元です。The itemsArray is multidimensional.

index は、keys の下限を下回っています。index is less than the lower bound of keys.

- または --or- length が 0 未満です。length is less than zero.

itemsnullではなく、 keys の長さが itemsの長さを超えています。items is not null, and the length of keys is greater than the length of items.

または-or- index および lengthkeysArray内の指定した位置にある値を取得します。index and length do not specify a valid range in the keysArray.

または-or- itemsnull ではなく、index および lengthitemsArray 内の有効な範囲を示していません。items is not null, and index and length do not specify a valid range in the itemsArray.

keysArray 内の 1 つ以上の要素に IComparable インターフェイスが実装されていません。One or more elements in the keysArray do not implement the IComparable interface.

次のコード例では、最初の配列にキーが含まれ、2番目の配列に値が格納されている2つの関連する配列を並べ替える方法を示します。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. 並べ替えは、既定の比較子と、並べ替え順序を反転するカスタム比較子を使用して行われます。Sorts are done using the default comparer and a custom comparer that reverses the sort order. 結果は現在CultureInfoのによって異なる場合があることに注意してください。Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

public ref class myReverserClass: public IComparer
{
private:

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

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

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

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

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

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

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

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

/* 
This code produces the following output.

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

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

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

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

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

*/
using System;
using System.Collections;

public class SamplesArray  {
 
   public class myReverserClass : IComparer  {

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

   }

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

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

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

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

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


/* 
This code produces the following output.

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

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

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

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

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

*/

Imports System
Imports System.Collections

Public Class SamplesArray

   Public Class myReverserClass
      Implements IComparer

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

   End Class 'myReverserClass


   Public Shared Sub Main()

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

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

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

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

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

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

   End Sub 'Main


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

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

   End Sub 'PrintKeysAndValues

End Class 'SamplesArray


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

注釈

keys items Arrayの各キーには、内の対応する項目があります。ArrayEach key in the keysArray has a corresponding item in the itemsArray. 並べ替え中にキーが移動されると、内items Arrayの対応する項目も同様に再配置されます。When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. したがって、 keysは、内Arrayの対応するキーの配置に従って並べ替えられます。 items ArrayTherefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

keys の指定IComparableされた要素範囲内の各キーは、他のすべてのキーと比較できるように、インターフェイスを実装する必要があります。ArrayEach key within the specified range of elements in the keysArray must implement the IComparable interface to be capable of comparisons with every other key.

キー以外の項目がある場合は、並べ替えることができますが、対応するキーがない項目は並べ替えられません。You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. 項目よりも多くのキーがある場合は、並べ替えることはできません。この操作を行うArgumentExceptionと、がスローされます。You cannot sort if there are more keys than items; doing this throws an ArgumentException.

並べ替えが正常に完了しなかった場合、結果は未定義になります。If the sort is not successfully completed, the results are undefined.

このメソッドでは、次のように introspective sort (introsort) アルゴリズムが使用されます。This method uses the introspective sort (introsort) algorithm as follows:

  • パーティションサイズが16要素よりも小さい場合、挿入並べ替えアルゴリズムが使用されます。If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • パーティションの数が 2 * LogNを超えている場合 ( nは入力配列の範囲)、 heapsortアルゴリズムが使用されます。If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • それ以外の場合は、クイックソートアルゴリズムを使用します。Otherwise, it uses a Quicksort algorithm.

この実装は、不安定な並べ替えを実行します。つまり、2つの要素が等しい場合、その順序は保持されない可能性があります。This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. これに対して、安定した並べ替えでは、等しい要素の順序が保持されます。In contrast, a stable sort preserves the order of elements that are equal.

Heapsort アルゴリズムとクイックソートアルゴリズムを使用して並べ替えられた配列の場合、最悪の場合、このメソッドはn O n(log) 操作nlengthなります。ここで、はです。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.

こちらもご覧ください

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

1 次元 Array 内の要素を、指定した IComparer を使用して並べ替えます。Sorts the elements in a one-dimensional Array using the specified IComparer.

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

パラメーター

array
Array Array Array Array

並べ替え対象となる 1 次元配列。The one-dimensional array to sort.

comparer
IComparer IComparer IComparer IComparer

要素を比較する場合に使用する実装。The implementation to use when comparing elements.

または-or- 各要素の IComparable 実装を使用する場合は nullnull to use the IComparable implementation of each element.

例外

array が多次元です。array is multidimensional.

comparernull で、array の 1 つ以上の要素が IComparable インターフェイスを実装していません。comparer is null, and one or more elements in array do not implement the IComparable interface.

comparer の実装により、並べ替え中にエラーが発生しました。The implementation of comparer caused an error during the sort. たとえば、comparer は、項目をそれ自体と比較したときに 0 を返さなかった可能性があります。For example, comparer might not return 0 when comparing an item with itself.

次の例では、既定の比較子を使用して、文字列配列内の値を並べ替えます。The following example sorts the values in a string array by using the default comparer. また、大文字とIComparer小文字ReverseComparerを区別しない文字列比較を実行しているときに、オブジェクトの既定の並べ替え順序を反転するという名前のカスタム実装を定義します。It also defines a custom IComparer implementation named ReverseComparer that reverses an object's default sort order while performing a case-insensitive string comparison. 出力は、現在のカルチャによって異なる場合があることに注意してください。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

注釈

comparer array の場合IComparable 、の各要素は、の他のすべての要素と比較できるようにarray、インターフェイスを実装する必要があります。 nullIf comparer is null, each element of array must implement the IComparable interface to be capable of comparisons with every other element in array.

並べ替えが正常に完了しなかった場合、結果は未定義になります。If the sort is not successfully completed, the results are undefined.

このメソッドでは、次のように introspective sort (introsort) アルゴリズムが使用されます。This method uses the introspective sort (introsort) algorithm as follows:

  • パーティションサイズが16要素よりも小さい場合、挿入並べ替えアルゴリズムが使用されます。If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • パーティションの数が 2 * LogNを超えている場合 ( nは入力配列の範囲)、 heapsortアルゴリズムが使用されます。If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • それ以外の場合は、クイックソートアルゴリズムを使用します。Otherwise, it uses a Quicksort algorithm.

この実装は、不安定な並べ替えを実行します。つまり、2つの要素が等しい場合、その順序は保持されない可能性があります。This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. これに対して、安定した並べ替えでは、等しい要素の順序が保持されます。In contrast, a stable sort preserves the order of elements that are equal.

Heapsort アルゴリズムとクイックソートアルゴリズムを使用して並べ替えられた配列の場合、最悪の場合、このメソッドはn O n(log) Length操作nになります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 には、 IComparer次の表に示す定義済みの実装が含まれています。The .NET Framework includes predefined IComparer implementations listed in the following table.

実装Implementation 説明Description
System.Collections.CaseInsensitiveComparer 2つのオブジェクトを比較しますが、文字列の大文字と小文字を区別しない比較を実行します。Compares any two objects, but performs a case-insensitive comparison of strings.
Comparer.Default 現在のカルチャの並べ替え規則を使用して、2つのオブジェクトを比較します。Compares any two objects by using the sorting conventions of the current culture.
Comparer.DefaultInvariant インバリアントカルチャの並べ替え規則を使用して、2つのオブジェクトを比較します。Compares any two objects by using the sorting conventions of the invariant culture.
Comparer<T>.Default 型の既定の並べ替えT順序を使用して、型の2つのオブジェクトを比較します。Compares two objects of type T by using the type's default sort order.

独自IComparerの実装のインスタンスをパラメーターに指定することによって、 comparerカスタムの比較をサポートすることもできます。You can also support custom comparisons by providing an instance of your own IComparer implementation to the comparer parameter. この例では、型のReverseComparerインスタンスの既定の並べ替え順序を反転するクラスを定義し、大文字と小文字を区別しない文字列比較を実行します。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.

注意 (呼び出し元)

.NET Framework 4 以前のバージョンでは、クイックソートアルゴリズムのみが使用されていました。The .NET Framework 4 and earlier versions used only the Quicksort algorithm. クイックソートは、並べ替え操作によって例外がIndexOutOfRangeExceptionスローされ、呼び出し元にArgumentException例外をスローする場合に、無効な比較子を識別します。Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. 以降では、挿入の並べ替えおよび heapsort アルゴリズムで無効ArgumentExceptionな比較子が検出されないため、以前にスローされた並べ替え操作で例外がスローされない可能性があります。 .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. ほとんどの場合、これは16個未満の要素を持つ配列に適用されます。For the most part, this applies to arrays with fewer than 16 elements.

こちらもご覧ください

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

2 つの 1 次元 Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) を、最初の Array 内のキーに基づき、指定した 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)

パラメーター

keys
Array Array Array Array

並べ替え対象となるキーを格納する 1 次元 ArrayThe one-dimensional Array that contains the keys to sort.

items
Array Array Array Array

keysArray 内の各キーに対応する項目を格納する 1 次元 ArrayThe one-dimensional Array that contains the items that correspond to each of the keys in the keysArray.

- または --or- keysArray のみを並べ替える場合は nullnull to sort only the keysArray.

comparer
IComparer IComparer IComparer IComparer

要素を比較する場合に使用する IComparer の実装。The IComparer implementation to use when comparing elements.

- または --or- 各要素の IComparable 実装を使用する場合は nullnull to use the IComparable implementation of each element.

例外

keysArray が多次元です。The keysArray is multidimensional.

- または --or- itemsArray が多次元です。The itemsArray is multidimensional.

itemsnull ではなく、keys の長さが items の長さを超えています。items is not null, and the length of keys is greater than the length of items.

- または --or- comparer の実装により、並べ替え中にエラーが発生しました。The implementation of comparer caused an error during the sort. たとえば、comparer は、項目をそれ自体と比較したときに 0 を返さなかった可能性があります。For example, comparer might not return 0 when comparing an item with itself.

comparernull であり、keysArray 内の 1 つ以上の要素に IComparable インターフェイスが実装されていません。comparer is null, and one or more elements in the keysArray do not implement the IComparable interface.

次の例では、最初の配列にキーが含まれ、2番目の配列に値が格納されている2つの関連する配列を並べ替える方法を示します。The following example shows how to sort two associated arrays where the first array contains the keys and the second array contains the values. 並べ替えは、既定の比較子と、並べ替え順序を反転するカスタム比較子を使用して行われます。Sorts are done using the default comparer and a custom comparer that reverses the sort order. 結果は現在CultureInfoのによって異なる場合があることに注意してください。Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

public ref class myReverserClass: public IComparer
{
private:

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

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

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

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

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

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

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

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

/* 
This code produces the following output.

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

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

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

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

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

*/
using System;
using System.Collections;

public class SamplesArray  {
 
   public class myReverserClass : IComparer  {

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

   }

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

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

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

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

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


/* 
This code produces the following output.

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

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

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

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

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

*/

Imports System
Imports System.Collections

Public Class SamplesArray

   Public Class myReverserClass
      Implements IComparer

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

   End Class 'myReverserClass


   Public Shared Sub Main()

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

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

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

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

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

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

   End Sub 'Main


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

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

   End Sub 'PrintKeysAndValues

End Class 'SamplesArray


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

注釈

keys items Arrayの各キーには、内の対応する項目があります。ArrayEach key in the keysArray has a corresponding item in the itemsArray. 並べ替え中にキーが移動されると、内items Arrayの対応する項目も同様に再配置されます。When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. したがって、 keysは、内Arrayの対応するキーの配置に従って並べ替えられます。 items ArrayTherefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

comparer の場合keys 、内の各キーは、他のすべてのキーと比較できるように、インターフェイスを実装する必要があります。IComparable Array nullIf comparer is null, each key in the keysArray must implement the IComparable interface to be capable of comparisons with every other key.

キー以外の項目がある場合は、並べ替えることができますが、対応するキーがない項目は並べ替えられません。You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. 項目よりも多くのキーがある場合は、並べ替えることはできません。この操作を行うArgumentExceptionと、がスローされます。You cannot sort if there are more keys than items; doing this throws an ArgumentException.

並べ替えが正常に完了しなかった場合、結果は未定義になります。If the sort is not successfully completed, the results are undefined.

.NET Framework には、 IComparer次の表に示す定義済みの実装が含まれています。The .NET Framework includes predefined IComparer implementations listed in the following table.

実装Implementation 説明Description
System.Collections.CaseInsensitiveComparer 2つのオブジェクトを比較しますが、文字列の大文字と小文字を区別しない比較を実行します。Compares any two objects, but performs a case-insensitive comparison of strings.
Comparer.Default 現在のカルチャの並べ替え規則を使用して、2つのオブジェクトを比較します。Compares any two objects by using the sorting conventions of the current culture.
Comparer.DefaultInvariant インバリアントカルチャの並べ替え規則を使用して、2つのオブジェクトを比較します。Compares any two objects by using the sorting conventions of the invariant culture.
Comparer<T>.Default 型の既定の並べ替えT順序を使用して、型の2つのオブジェクトを比較します。Compares two objects of type T by using the type's default sort order.

独自IComparerの実装のインスタンスをパラメーターに指定することによって、 comparerカスタムの比較をサポートすることもできます。You can also support custom comparisons by providing an instance of your own IComparer implementation to the comparer parameter. この例では、既定のIComparer並べ替え順序を反転し、大文字と小文字を区別しない文字列比較を実行する実装を定義します。The example does this by defining an IComparer implementation that reverses the default sort order and performs case-insensitive string comparison.

このメソッドでは、次のように introspective sort (introsort) アルゴリズムが使用されます。This method uses the introspective sort (introsort) algorithm as follows:

  • パーティションサイズが16要素よりも小さい場合、挿入並べ替えアルゴリズムが使用されます。If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • パーティションの数が 2 * LogNを超えている場合 ( nは入力配列の範囲)、 heapsortアルゴリズムが使用されます。If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • それ以外の場合は、クイックソートアルゴリズムを使用します。Otherwise, it uses a Quicksort algorithm.

この実装は、不安定な並べ替えを実行します。つまり、2つの要素が等しい場合、その順序は保持されない可能性があります。This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. これに対して、安定した並べ替えでは、等しい要素の順序が保持されます。In contrast, a stable sort preserves the order of elements that are equal.

Heapsort アルゴリズムとクイックソートアルゴリズムを使用して並べ替えられた配列の場合、最悪の場合、このメソッドはn O n(log) Length操作nになります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.

注意 (呼び出し元)

.NET Framework 4 以前のバージョンでは、クイックソートアルゴリズムのみが使用されていました。The .NET Framework 4 and earlier versions used only the Quicksort algorithm. クイックソートは、並べ替え操作によって例外がIndexOutOfRangeExceptionスローされ、呼び出し元にArgumentException例外をスローする場合に、無効な比較子を識別します。Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. 以降では、挿入の並べ替えおよび heapsort アルゴリズムで無効ArgumentExceptionな比較子が検出されないため、以前にスローされた並べ替え操作で例外がスローされない可能性があります。 .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. ほとんどの場合、これは16個未満の要素を持つ配列に適用されます。For the most part, this applies to arrays with fewer than 16 elements.

こちらもご覧ください

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

2 つの 1 次元 Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) を、最初の Array 内のキーに基づき、各キーによって実装された IComparable を使用して並べ替えます。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)

パラメーター

keys
Array Array Array Array

並べ替え対象となるキーを格納する 1 次元 ArrayThe one-dimensional Array that contains the keys to sort.

items
Array Array Array Array

keysArray 内の各キーに対応する項目を格納する 1 次元 ArrayThe one-dimensional Array that contains the items that correspond to each of the keys in the keysArray.

- または --or- keysArray のみを並べ替える場合は nullnull to sort only the keysArray.

例外

keysArray が多次元です。The keysArray is multidimensional.

- または --or- itemsArray が多次元です。The itemsArray is multidimensional.

itemsnull ではなく、keys の長さが items の長さを超えています。items is not null, and the length of keys is greater than the length of items.

keysArray 内の 1 つ以上の要素に IComparable インターフェイスが実装されていません。One or more elements in the keysArray do not implement the IComparable interface.

次の例では、最初の配列にキーが含まれ、2番目の配列に値が格納されている2つの関連する配列を並べ替える方法を示します。The following example shows how to sort two associated arrays where the first array contains the keys and the second array contains the values. 並べ替えは、既定の比較子と、並べ替え順序を反転するカスタム比較子を使用して行われます。Sorts are done using the default comparer and a custom comparer that reverses the sort order. 結果は現在CultureInfoのによって異なる場合があることに注意してください。Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

public ref class myReverserClass: public IComparer
{
private:

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

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

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

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

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

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

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

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

/* 
This code produces the following output.

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

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

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

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

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

*/
using System;
using System.Collections;

public class SamplesArray  {
 
   public class myReverserClass : IComparer  {

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

   }

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

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

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

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

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


/* 
This code produces the following output.

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

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

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

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

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

*/

Imports System
Imports System.Collections

Public Class SamplesArray

   Public Class myReverserClass
      Implements IComparer

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

   End Class 'myReverserClass


   Public Shared Sub Main()

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

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

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

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

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

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

   End Sub 'Main


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

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

   End Sub 'PrintKeysAndValues

End Class 'SamplesArray


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

注釈

keys items Arrayの各キーには、内の対応する項目があります。ArrayEach key in the keysArray has a corresponding item in the itemsArray. 並べ替え中にキーが移動されると、内items Arrayの対応する項目も同様に再配置されます。When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. したがって、 keysは、内Arrayの対応するキーの配置に従って並べ替えられます。 items ArrayTherefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

の各キー keys Arrayは、他のIComparableすべてのキーと比較できるように、インターフェイスを実装する必要があります。Each key in the keysArray must implement the IComparable interface to be capable of comparisons with every other key.

キー以外の項目がある場合は、並べ替えることができますが、対応するキーがない項目は並べ替えられません。You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. 項目よりも多くのキーがある場合は、並べ替えることはできません。この操作を行うArgumentExceptionと、がスローされます。You cannot sort if there are more keys than items; doing this throws an ArgumentException.

並べ替えが正常に完了しなかった場合、結果は未定義になります。If the sort is not successfully completed, the results are undefined.

このメソッドでは、次のように introspective sort (introsort) アルゴリズムが使用されます。This method uses the introspective sort (introsort) algorithm as follows:

  • パーティションサイズが16要素よりも小さい場合、挿入並べ替えアルゴリズムが使用されます。If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • パーティションの数が 2 * LogNを超えている場合 ( nは入力配列の範囲)、 heapsortアルゴリズムが使用されます。If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • それ以外の場合は、クイックソートアルゴリズムを使用します。Otherwise, it uses a Quicksort algorithm.

この実装は、不安定な並べ替えを実行します。つまり、2つの要素が等しい場合、その順序は保持されない可能性があります。This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. これに対して、安定した並べ替えでは、等しい要素の順序が保持されます。In contrast, a stable sort preserves the order of elements that are equal.

Heapsort アルゴリズムとクイックソートアルゴリズムを使用して並べ替えられた配列の場合、最悪の場合、このメソッドはn O n(log) Length操作nになります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.

こちらもご覧ください

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

Array の各要素によって実装された IComparable を使用して、1 次元 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

パラメーター

array
Array Array Array Array

並べ替え対象となる 1 次元 ArrayThe one-dimensional Array to sort.

例外

array が多次元です。array is multidimensional.

array の 1 つ以上の要素が、IComparable インターフェイスを実装していません。One or more elements in array do not implement the IComparable interface.

次のコード例は、既定の比較子と並べ替えArray順序を反転するカスタム比較子を使用して、の値を並べ替える方法を示しています。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. 結果は現在CultureInfoのによって異なる場合があることに注意してください。Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

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

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

   Console::WriteLine();
}

int main()
{
   // Create and initialize a new array. and a new custom comparer.
   array<String^>^ words = { "The","QUICK","BROWN","FOX","jumps",
                             "over","the","lazy","dog" };
   // Instantiate the reverse comparer.
   IComparer^ revComparer = gcnew ReverseComparer();
   
   // Display the values of the Array.
   Console::WriteLine( "The original order of elements in the array:" );
   DisplayValues(words);

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

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

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

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

/* 
This code produces the following output.

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

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

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

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

After sorting the entire Array using the reverse case-insensitive comparer:
   [0] : the
   [1] : The
   [2] : QUICK
   [3] : over
   [4] : lazy
   [5] : jumps
   [6] : FOX
   [7] : dog
   [8] : BROWN

*/
using System;
using System.Collections;

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

public class Example 
{
   public static void Main()  
   {
      // Create and initialize a new array. 
      String[] words = { "The", "QUICK", "BROWN", "FOX", "jumps", 
                         "over", "the", "lazy", "dog" };
      // Instantiate the reverse comparer.
      IComparer revComparer = new ReverseComparer();
 
      // Display the values of the array.
      Console.WriteLine( "The original order of elements in the array:" );
      DisplayValues(words);
 
      // Sort a section of the array using the default comparer.
      Array.Sort(words, 1, 3);
      Console.WriteLine( "After sorting elements 1-3 by using the default comparer:");
      DisplayValues(words);

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

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

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

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

Public Module Example
   Public Sub Main()
      ' Create and initialize a new array.
      Dim words() As String =  { "The", "QUICK", "BROWN", "FOX", "jumps", 
                                 "over", "the", "lazy", "dog" }
      ' Instantiate a new custom comparer.
      Dim revComparer As New ReverseComparer()

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

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

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

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

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

   Public Sub DisplayValues(arr() As String)
      For i As Integer = arr.GetLowerBound(0) To arr.GetUpperBound(0)
         Console.WriteLine("   [{0}] : {1}", i, arr(i))
      Next 
      Console.WriteLine()
   End Sub 
End Module 
' The example displays the following output:
'    The original order of elements in the array:
'       [0] : The
'       [1] : QUICK
'       [2] : BROWN
'       [3] : FOX
'       [4] : jumps
'       [5] : over
'       [6] : the
'       [7] : lazy
'       [8] : dog
'    
'    After sorting elements 1-3 by using the default comparer:
'       [0] : The
'       [1] : BROWN
'       [2] : FOX
'       [3] : QUICK
'       [4] : jumps
'       [5] : over
'       [6] : the
'       [7] : lazy
'       [8] : dog
'    
'    After sorting elements 1-3 by using the reverse case-insensitive comparer:
'       [0] : The
'       [1] : QUICK
'       [2] : FOX
'       [3] : BROWN
'       [4] : jumps
'       [5] : over
'       [6] : the
'       [7] : lazy
'       [8] : dog
'    
'    After sorting the entire array by using the default comparer:
'       [0] : BROWN
'       [1] : dog
'       [2] : FOX
'       [3] : jumps
'       [4] : lazy
'       [5] : over
'       [6] : QUICK
'       [7] : the
'       [8] : The
'    
'    After sorting the entire array using the reverse case-insensitive comparer:
'       [0] : the
'       [1] : The
'       [2] : QUICK
'       [3] : over
'       [4] : lazy
'       [5] : jumps
'       [6] : FOX
'       [7] : dog
'       [8] : BROWN

注釈

array各要素は、のIComparable他のすべての要素arrayと比較できるように、インターフェイスを実装する必要があります。Each element of array must implement the IComparable interface to be capable of comparisons with every other element in array.

並べ替えが正常に完了しなかった場合、結果は未定義になります。If the sort is not successfully completed, the results are undefined.

このメソッドでは、次のように introspective sort (introsort) アルゴリズムが使用されます。This method uses the introspective sort (introsort) algorithm as follows:

  • パーティションサイズが16要素よりも小さい場合、挿入並べ替えアルゴリズムが使用されます。If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • パーティションの数が 2 * LogNを超えている場合 ( nは入力配列の範囲)、 heapsortアルゴリズムが使用されます。If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • それ以外の場合は、クイックソートアルゴリズムを使用します。Otherwise, it uses a Quicksort algorithm.

この実装は、不安定な並べ替えを実行します。つまり、2つの要素が等しい場合、その順序は保持されない可能性があります。This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. これに対して、安定した並べ替えでは、等しい要素の順序が保持されます。In contrast, a stable sort preserves the order of elements that are equal.

Heapsort アルゴリズムとクイックソートアルゴリズムを使用して並べ替えられた配列の場合、最悪の場合、このメソッドはn O n(log) Length操作nになります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.

こちらもご覧ください

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

Array の各要素によって実装された IComparable<T> ジェネリック インターフェイスを使用して、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())

型パラメーター

T

配列要素の型。The type of the elements of the array.

パラメーター

array
T[]

並べ替え対象となる、インデックス番号が 0 から始まる 1 次元 ArrayThe one-dimensional, zero-based Array to sort.

例外

array の 1 つ以上の要素が、IComparable<T> ジェネリック インターフェイスを実装していません。One or more elements in array do not implement the IComparable<T> generic interface.

次のコード例は、 Sort<T>(T[])ジェネリックメソッドのオーバーロードBinarySearch<T>(T[], T)とジェネリックメソッドのオーバーロードを示しています。The following code example demonstrates the Sort<T>(T[]) generic method overload and the BinarySearch<T>(T[], T) generic method overload. 文字列の配列は、特定の順序で作成されません。An array of strings is created, in no particular order.

配列が表示され、並べ替えられて、もう一度表示されます。The array is displayed, sorted, and displayed again.

注意

メソッドSortBinarySearchジェネリックメソッドへの呼び出しは、対応する非ジェネリックの呼び出しとは異なるものになりますC#。これは Visual Basic、、およびC++が、最初の引数の型からジェネリック型パラメーターの型を推論するためです。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. Ildasm.exe (IL 逆アセンブラー)を使用して Microsoft 中間言語 (MSIL) を調べると、ジェネリックメソッドが呼び出されていることがわかります。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.

次に、ジェネリックメソッドオーバーロードを使用して2つの文字列を検索します。1つは配列に含まれず、もう1つはです。 BinarySearch<T>(T[], T)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. BinarySearchメソッドの配列と戻り値は、 ShowWhereジェネリックメソッドに渡されます。このメソッドには、文字列が見つかった場合はインデックス値が表示され、それ以外の場合は検索文字列が配列内にある場合はその要素が含まれます。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. 文字列が配列ではない場合、インデックスは負の値になりShowWhereます。したがって、メソッドはビットごとのC#補数 ( C++とXorの場合は ~ 演算子、Visual Basic の場合は-1) を取得して、より大きいリスト内の最初の要素のインデックスを取得します。検索文字列。The index is negative if the string is not n the array, so the ShowWhere method takes the bitwise complement (the ~ operator in C# and Visual C++, Xor -1 in Visual Basic) to obtain the index of the first element in the list that is larger than the search string.

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

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

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

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

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

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

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

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

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

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

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

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Tyrannosaurus
Mamenchisaurus
Deinonychus
Edmontosaurus

Sort

Amargasaurus
Deinonychus
Edmontosaurus
Mamenchisaurus
Pachycephalosaurus
Tyrannosaurus

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

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

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

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

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

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

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

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

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

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

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

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

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Tyrannosaurus
Mamenchisaurus
Deinonychus
Edmontosaurus

Sort

Amargasaurus
Deinonychus
Edmontosaurus
Mamenchisaurus
Pachycephalosaurus
Tyrannosaurus

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

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

Public Class Example

    Public Shared Sub Main()

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

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

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

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

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

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

    End Sub

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

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

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

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

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

    End Sub

End Class

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

注釈

array各要素は、のIComparable<T>他のすべての要素arrayと比較できるように、ジェネリックインターフェイスを実装する必要があります。Each element of array must implement the IComparable<T> generic interface to be capable of comparisons with every other element in array.

並べ替えが正常に完了しなかった場合、結果は未定義になります。If the sort is not successfully completed, the results are undefined.

このメソッドでは、次のように introspective sort (introsort) アルゴリズムが使用されます。This method uses the introspective sort (introsort) algorithm as follows:

  • パーティションサイズが16要素よりも小さい場合、挿入並べ替えアルゴリズムが使用されます。If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • パーティションの数が 2 * LogNを超えている場合 ( nは入力配列の範囲)、 heapsortアルゴリズムが使用されます。If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • それ以外の場合は、クイックソートアルゴリズムを使用します。Otherwise, it uses a Quicksort algorithm.

この実装は、不安定な並べ替えを実行します。つまり、2つの要素が等しい場合、その順序は保持されない可能性があります。This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. これに対して、安定した並べ替えでは、等しい要素の順序が保持されます。In contrast, a stable sort preserves the order of elements that are equal.

Heapsort アルゴリズムとクイックソートアルゴリズムを使用して並べ替えられた配列の場合、最悪の場合、このメソッドはn O n(log) Length操作nになります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.

こちらもご覧ください

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

Array 内の要素を、指定した IComparer<T> ジェネリック インターフェイスを使用して並べ替えます。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))

型パラメーター

T

配列要素の型。The type of the elements of the array.

パラメーター

array
T[]

並べ替える 1 次元の Array。インデックス番号が 0 から始まる必要があります。The one-dimensional, zero-base Array to sort

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

要素を比較する際に使用する IComparer<T> ジェネリック インターフェイスの実装。各要素が実装する IComparable<T> ジェネリック インターフェイスを使用する場合は nullThe IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

例外

comparernull で、array の 1 つ以上の要素が IComparable<T> ジェネリック インターフェイスを実装していません。comparer is null, and one or more elements in array do not implement the IComparable<T> generic interface.

comparer の実装により、並べ替え中にエラーが発生しました。The implementation of comparer caused an error during the sort. たとえば、comparer は、項目をそれ自体と比較したときに 0 を返さなかった可能性があります。For example, comparer might not return 0 when comparing an item with itself.

次のコード例は、 Sort<T>(T[], IComparer<T>)ジェネリックメソッドのオーバーロードBinarySearch<T>(T[], T, IComparer<T>)とジェネリックメソッドのオーバーロードを示しています。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.

このコード例では、というReverseCompare名前の文字列の代替比較子を定義しています。これは、 IComparer<string> (IComparer(Of String) Visual Basic では、 IComparer<String^> Visual C++) ジェネリックインターフェイスを実装します。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. 比較子は、 CompareTo(String)比較対照値の順序を逆にしてメソッドを呼び出し、文字列が低い順に並べ替えられるようにします。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.

配列が表示され、並べ替えられて、もう一度表示されます。The array is displayed, sorted, and displayed again. メソッドを使用するには、 BinarySearch配列を並べ替える必要があります。Arrays must be sorted in order to use the BinarySearch method.

注意

メソッドSort<T>(T[], IComparer<T>)BinarySearch<T>(T[], T, IComparer<T>)ジェネリックメソッドへの呼び出しは、対応する非ジェネリックの呼び出しとは異なるものになりますC#。これは Visual Basic、、およびC++が、最初の引数の型からジェネリック型パラメーターの型を推論するためです。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. Ildasm.exe (IL 逆アセンブラー)を使用して Microsoft 中間言語 (MSIL) を調べると、ジェネリックメソッドが呼び出されていることがわかります。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.

次に、ジェネリックメソッドオーバーロードを使用して2つの文字列を検索します。1つは配列に含まれず、もう1つはです。 BinarySearch<T>(T[], T, IComparer<T>)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. BinarySearch<T>(T[], T, IComparer<T>)メソッドの配列と戻り値は、 ShowWhereジェネリックメソッドに渡されます。このメソッドには、文字列が見つかった場合はインデックス値が表示され、それ以外の場合は検索文字列が配列内にある場合はその要素が含まれます。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. 文字列が配列ではない場合、インデックスは負の値になりShowWhereます。したがって、メソッドはビットごとのC#補数 ( C++とXorの場合は ~ 演算子、Visual Basic の場合は-1) を取得して、より大きいリスト内の最初の要素のインデックスを取得します。検索文字列。The index is negative if the string is not n the array, so the ShowWhere method takes the bitwise complement (the ~ operator in C# and Visual C++, Xor -1 in Visual Basic) to obtain the index of the first element in the list that is larger than the search string.

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

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

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

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

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

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

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

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

    ReverseComparer^ rc = gcnew ReverseComparer();

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

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

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

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

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Tyrannosaurus
Mamenchisaurus
Deinonychus
Edmontosaurus

Sort

Tyrannosaurus
Pachycephalosaurus
Mamenchisaurus
Edmontosaurus
Deinonychus
Amargasaurus

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

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

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

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

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

        ReverseComparer rc = new ReverseComparer();

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

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

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

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

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

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

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

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

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Tyrannosaurus
Mamenchisaurus
Deinonychus
Edmontosaurus

Sort

Tyrannosaurus
Pachycephalosaurus
Mamenchisaurus
Edmontosaurus
Deinonychus
Amargasaurus

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

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

Public Class ReverseComparer
    Implements IComparer(Of String)

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

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

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

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

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

        Dim rc As New ReverseComparer()

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

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

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

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

    End Sub

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

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

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

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

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

    End Sub

End Class

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

注釈

comparer array の場合IComparable<T> 、の各要素は、の他のすべての要素と比較できるように、 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.

並べ替えが正常に完了しなかった場合、結果は未定義になります。If the sort is not successfully completed, the results are undefined.

このメソッドでは、次のように introspective sort (introsort) アルゴリズムが使用されます。This method uses the introspective sort (introsort) algorithm as follows:

  • パーティションサイズが16要素よりも小さい場合、挿入並べ替えアルゴリズムが使用されます。If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • パーティションの数が 2 * LogNを超えている場合 ( nは入力配列の範囲)、 heapsortアルゴリズムが使用されます。If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • それ以外の場合は、クイックソートアルゴリズムを使用します。Otherwise, it uses a Quicksort algorithm.

この実装は、不安定な並べ替えを実行します。つまり、2つの要素が等しい場合、その順序は保持されない可能性があります。This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. これに対して、安定した並べ替えでは、等しい要素の順序が保持されます。In contrast, a stable sort preserves the order of elements that are equal.

Heapsort アルゴリズムとクイックソートアルゴリズムを使用して並べ替えられた配列の場合、最悪の場合、このメソッドはn O n(log) Length操作nになります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 4 以前のバージョンでは、クイックソートアルゴリズムのみが使用されていました。The .NET Framework 4 and earlier versions used only the Quicksort algorithm. クイックソートは、並べ替え操作によって例外がIndexOutOfRangeExceptionスローされ、呼び出し元にArgumentException例外をスローする場合に、無効な比較子を識別します。Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. 以降では、挿入の並べ替えおよび heapsort アルゴリズムで無効ArgumentExceptionな比較子が検出されないため、以前にスローされた並べ替え操作で例外がスローされない可能性があります。 .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. ほとんどの場合、これは16個未満の要素を持つ配列に適用されます。For the most part, this applies to arrays with fewer than 16 elements.

こちらもご覧ください

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

Array 内の要素を、指定した 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))

型パラメーター

T

配列要素の型。The type of the elements of the array.

パラメーター

array
T[]

並べ替える 1 次元の Array。インデックス番号が 0 から始まる必要があります。The one-dimensional, zero-based Array to sort

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

要素を比較する場合に使用する Comparison<T>The Comparison<T> to use when comparing elements.

例外

arraynullです。array is null.

- または --or- comparisonnullです。comparison is null.

comparison の実装により、並べ替え中にエラーが発生しました。The implementation of comparison caused an error during the sort. たとえば、comparison は、項目をそれ自体と比較したときに 0 を返さなかった可能性があります。For example, comparison might not return 0 when comparing an item with itself.

次のコード例は、 Sort(Comparison<T>)メソッドのオーバーロードを示しています。The following code example demonstrates the Sort(Comparison<T>) method overload.

このコード例では、という名前CompareDinosByLengthの文字列に対して、別の比較メソッドを定義しています。The code example defines an alternative comparison method for strings, named CompareDinosByLength. この方法は次のように機能します。まず、比較対照値をテストnullし、null 参照を null 以外の値として処理します。This method works as follows: First, the comparands are tested fornull, and a null reference is treated as less than a non-null. 次に、文字列の長さが比較され、長い方の文字列が大きいと見なされます。Second, the string lengths are compared, and the longer string is deemed to be greater. 3番目の長さが等しい場合は、通常の文字列比較が使用されます。Third, if the lengths are equal, ordinary string comparison is used.

文字列の配列が作成され、特定の順序ではなく4つの文字列が設定されます。A array of strings is created and populated with four strings, in no particular order. この一覧には、空の文字列と null 参照も含まれています。The list also includes an empty string and a null reference. リストが表示され、 Comparison<T> CompareDinosByLengthメソッドを表す汎用デリゲートを使用して並べ替えられ、もう一度表示されます。The list is displayed, sorted using a Comparison<T> generic delegate representing the CompareDinosByLength method, and displayed again.

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

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

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

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

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

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

}

/* This code example produces the following output:

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

Sort with generic Comparison<String^> delegate:

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

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

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

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

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

    }

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

/* This code example produces the following output:

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

Sort with generic Comparison<string> delegate:

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

Public Class Example

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

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

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

    End Function

    Public Shared Sub Main()

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

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

    End Sub

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

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

注釈

並べ替えが正常に完了しなかった場合、結果は未定義になります。If the sort is not successfully completed, the results are undefined.

このメソッドは、次のように introspective sort (introsort) アルゴリズムを使用します。This method uses introspective sort (introsort) algorithm as follows:

  • パーティションサイズが16要素よりも小さい場合、挿入並べ替えアルゴリズムが使用されます。If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • パーティションの数が 2 * LogNを超えている場合 ( nは入力配列の範囲)、 heapsortアルゴリズムが使用されます。If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • それ以外の場合は、クイックソートアルゴリズムを使用します。Otherwise, it uses a Quicksort algorithm.

この実装は、不安定な並べ替えを実行します。つまり、2つの要素が等しい場合、その順序は保持されない可能性があります。This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. これに対して、安定した並べ替えでは、等しい要素の順序が保持されます。In contrast, a stable sort preserves the order of elements that are equal.

Heapsort アルゴリズムとクイックソートアルゴリズムを使用して並べ替えられた配列の場合、最悪の場合、このメソッドはn O n(log) Length操作nになります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 4 以前のバージョンでは、クイックソートアルゴリズムのみが使用されていました。The .NET Framework 4 and earlier versions used only the Quicksort algorithm. クイックソートは、並べ替え操作によって例外がIndexOutOfRangeExceptionスローされ、呼び出し元にArgumentException例外をスローする場合に、無効な比較子を識別します。Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. 以降では、挿入の並べ替えおよび heapsort アルゴリズムで無効ArgumentExceptionな比較子が検出されないため、以前にスローされた並べ替え操作で例外がスローされない可能性があります。 .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. ほとんどの場合、これは16個未満の要素を持つ配列に適用されます。For the most part, this applies to arrays with fewer than 16 elements.

こちらもご覧ください

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

Array の各要素によって実装された IComparable<T> ジェネリック インターフェイスを使用して、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)

型パラメーター

T

配列要素の型。The type of the elements of the array.

パラメーター

array
T[]

並べ替える 1 次元の Array。インデックス番号が 0 から始まる必要があります。The one-dimensional, zero-based Array to sort

index
Int32 Int32 Int32 Int32

並べ替え対象の範囲の開始位置を示すインデックス。The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

並べ替え対象の範囲内にある要素の数。The number of elements in the range to sort.

例外

index は、array の下限を下回っています。index is less than the lower bound of array.

- または --or- length が 0 未満です。length is less than zero.

index および lengtharray の有効な範囲を指定していません。index and length do not specify a valid range in array.

array の 1 つ以上の要素が、IComparable<T> ジェネリック インターフェイスを実装していません。One or more elements in array do not implement the IComparable<T> generic interface.

次のコード例は、 Sort<T>(T[], Int32, Int32)ジェネリックメソッドのオーバーロードSort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)と、配列内の範囲を並べ替えるためのジェネリックメソッドオーバーロードを示しています。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.

このコード例では、というReverseCompare名前の文字列の代替比較子を定義しています。これは、 IComparer<string> (IComparer(Of String) Visual Basic では、 IComparer<String^> Visual C++) ジェネリックインターフェイスを実装します。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. 比較子は、 CompareTo(String)比較対照値の順序を逆にしてメソッドを呼び出し、文字列が低い順に並べ替えられるようにします。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.

このコード例では、3つの herbivores の後に3つの carnivores (tyrannosaurids) で構成される恐竜の名前の配列を作成して表示します。The code example creates and displays an array of dinosaur names, consisting of three herbivores followed by three carnivores (tyrannosaurids, to be precise). Sort<T>(T[], Int32, Int32)ジェネリックメソッドオーバーロードは、配列の最後の3つの要素の並べ替えに使用され、その後表示されます。The Sort<T>(T[], Int32, Int32) generic method overload is used to sort the last three elements of the array, which is then displayed. ジェネリックSort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)メソッドオーバーロードは、最後のReverseCompare 3 つの要素を逆順に並べ替えるためにと共に使用されます。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. 完全に混同された恐竜が再び表示されます。The thoroughly confused dinosaurs are displayed again.

注意

メソッドSort<T>(T[], IComparer<T>)BinarySearch<T>(T[], T, IComparer<T>)ジェネリックメソッドへの呼び出しは、対応する非ジェネリックの呼び出しとは異なるものになりますC#。これは Visual Basic、、およびC++が、最初の引数の型からジェネリック型パラメーターの型を推論するためです。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. Ildasm.exe (IL 逆アセンブラー)を使用して Microsoft 中間言語 (MSIL) を調べると、ジェネリックメソッドが呼び出されていることがわかります。If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

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

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

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

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

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

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

    ReverseComparer^ rc = gcnew ReverseComparer();

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

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

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Tarbosaurus
Tyrannosaurus
Albertasaurus

Sort(dinosaurs, 3, 3)

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Albertasaurus
Tarbosaurus
Tyrannosaurus

Sort(dinosaurs, 3, 3, rc)

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Tyrannosaurus
Tarbosaurus
Albertasaurus
 */
using System;
using System.Collections.Generic;

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

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

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

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

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

        ReverseComparer rc = new ReverseComparer();

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

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

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Tarbosaurus
Tyrannosaurus
Albertasaurus

Sort(dinosaurs, 3, 3)

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Albertasaurus
Tarbosaurus
Tyrannosaurus

Sort(dinosaurs, 3, 3, rc)

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Tyrannosaurus
Tarbosaurus
Albertasaurus
 */
Imports System
Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

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

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

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

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

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

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

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

        Dim rc As New ReverseComparer()

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

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

    End Sub

End Class

' This code example produces the following output:
'
'Pachycephalosaurus
'Amargasaurus
'Mamenchisaurus
'Tarbosaurus
'Tyrannosaurus
'Albertasaurus
'
'Sort(dinosaurs, 3, 3)
'
'Pachycephalosaurus
'Amargasaurus
'Mamenchisaurus
'Albertasaurus
'Tarbosaurus
'Tyrannosaurus
'
'Sort(dinosaurs, 3, 3, rc)
'
'Pachycephalosaurus
'Amargasaurus
'Mamenchisaurus
'Tyrannosaurus
'Tarbosaurus
'Albertasaurus

注釈

arrayの指定した要素範囲内の各要素はIComparable<T> 、の他のすべての要素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.

並べ替えが正常に完了しなかった場合、結果は未定義になります。If the sort is not successfully completed, the results are undefined.

このメソッドでは、次のように introspective sort (introsort) アルゴリズムが使用されます。This method uses the introspective sort (introsort) algorithm as follows:

  • パーティションサイズが16要素よりも小さい場合、挿入並べ替えアルゴリズムが使用されます。If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • パーティションの数が 2 * LogNを超えている場合 ( nは入力配列の範囲)、 heapsortアルゴリズムが使用されます。If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • それ以外の場合は、クイックソートアルゴリズムを使用します。Otherwise, it uses a Quicksort algorithm.

この実装は、不安定な並べ替えを実行します。つまり、2つの要素が等しい場合、その順序は保持されない可能性があります。This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. これに対して、安定した並べ替えでは、等しい要素の順序が保持されます。In contrast, a stable sort preserves the order of elements that are equal.

Heapsort アルゴリズムとクイックソートアルゴリズムを使用して並べ替えられた配列の場合、最悪の場合、このメソッドはn O n(log) 操作nlengthなります。ここで、はです。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.

こちらもご覧ください

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

指定した Array ジェネリック インターフェイスを使用して、IComparer<T> 内の要素範囲を並べ替えます。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))

型パラメーター

T

配列要素の型。The type of the elements of the array.

パラメーター

array
T[]

並べ替え対象となる、インデックス番号が 0 から始まる 1 次元 ArrayThe one-dimensional, zero-based Array to sort.

index
Int32 Int32 Int32 Int32

並べ替え対象の範囲の開始位置を示すインデックス。The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

並べ替え対象の範囲内にある要素の数。The number of elements in the range to sort.

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

要素を比較する際に使用する IComparer<T> ジェネリック インターフェイスの実装。各要素が実装する IComparable<T> ジェネリック インターフェイスを使用する場合は nullThe IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

例外

index は、array の下限を下回っています。index is less than the lower bound of array.

または-or- length が 0 未満です。length is less than zero.

index および lengtharray の有効な範囲を指定していません。index and length do not specify a valid range in array.

- または --or- comparer の実装により、並べ替え中にエラーが発生しました。The implementation of comparer caused an error during the sort. たとえば、comparer は、項目をそれ自体と比較したときに 0 を返さなかった可能性があります。For example, comparer might not return 0 when comparing an item with itself.

comparernull で、array の 1 つ以上の要素が IComparable<T> ジェネリック インターフェイスを実装していません。comparer is null, and one or more elements in array do not implement the IComparable<T> generic interface.

次のコード例は、 Sort<T>(T[], Int32, Int32)ジェネリックメソッドのオーバーロードSort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)と、配列内の範囲を並べ替えるためのジェネリックメソッドオーバーロードを示しています。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.

このコード例では、というReverseCompare名前の文字列の代替比較子を定義しています。これは、 IComparer<string> (IComparer(Of String) Visual Basic では、 IComparer<String^> Visual C++) ジェネリックインターフェイスを実装します。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. 比較子は、 CompareTo(String)比較対照値の順序を逆にしてメソッドを呼び出し、文字列が低い順に並べ替えられるようにします。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.

このコード例では、3つの herbivores の後に3つの carnivores (tyrannosaurids) で構成される恐竜の名前の配列を作成して表示します。The code example creates and displays an array of dinosaur names, consisting of three herbivores followed by three carnivores (tyrannosaurids, to be precise). Sort<T>(T[], Int32, Int32)ジェネリックメソッドオーバーロードは、配列の最後の3つの要素の並べ替えに使用され、その後表示されます。The Sort<T>(T[], Int32, Int32) generic method overload is used to sort the last three elements of the array, which is then displayed. ジェネリックSort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)メソッドオーバーロードは、最後のReverseCompare 3 つの要素を逆順に並べ替えるためにと共に使用されます。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. 完全に混同された恐竜が再び表示されます。The thoroughly confused dinosaurs are displayed again.

注意

メソッドSort<T>(T[], IComparer<T>)BinarySearch<T>(T[], T, IComparer<T>)ジェネリックメソッドへの呼び出しは、対応する非ジェネリックの呼び出しとは異なるものになりますC#。これは Visual Basic、、およびC++が、最初の引数の型からジェネリック型パラメーターの型を推論するためです。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. Ildasm.exe (IL 逆アセンブラー)を使用して Microsoft 中間言語 (MSIL) を調べると、ジェネリックメソッドが呼び出されていることがわかります。If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

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

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

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

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

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

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

    ReverseComparer^ rc = gcnew ReverseComparer();

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

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

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Tarbosaurus
Tyrannosaurus
Albertasaurus

Sort(dinosaurs, 3, 3)

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Albertasaurus
Tarbosaurus
Tyrannosaurus

Sort(dinosaurs, 3, 3, rc)

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Tyrannosaurus
Tarbosaurus
Albertasaurus
 */
using System;
using System.Collections.Generic;

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

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

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

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

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

        ReverseComparer rc = new ReverseComparer();

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

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

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Tarbosaurus
Tyrannosaurus
Albertasaurus

Sort(dinosaurs, 3, 3)

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Albertasaurus
Tarbosaurus
Tyrannosaurus

Sort(dinosaurs, 3, 3, rc)

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Tyrannosaurus
Tarbosaurus
Albertasaurus
 */
Imports System
Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

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

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

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

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

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

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

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

        Dim rc As New ReverseComparer()

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

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

    End Sub

End Class

' This code example produces the following output:
'
'Pachycephalosaurus
'Amargasaurus
'Mamenchisaurus
'Tarbosaurus
'Tyrannosaurus
'Albertasaurus
'
'Sort(dinosaurs, 3, 3)
'
'Pachycephalosaurus
'Amargasaurus
'Mamenchisaurus
'Albertasaurus
'Tarbosaurus
'Tyrannosaurus
'
'Sort(dinosaurs, 3, 3, rc)
'
'Pachycephalosaurus
'Amargasaurus
'Mamenchisaurus
'Tyrannosaurus
'Tarbosaurus
'Albertasaurus

注釈

comparer array IComparable<T>の場合、内の指定された要素範囲内の各要素は、内arrayの他のすべての要素と比較できるように、ジェネリックインターフェイスを実装する必要があります。 nullIf 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.

並べ替えが正常に完了しなかった場合、結果は未定義になります。If the sort is not successfully completed, the results are undefined.

このメソッドでは、次のように introspective sort (introsort) アルゴリズムが使用されます。This method uses the introspective sort (introsort) algorithm as follows:

  • パーティションサイズが16要素よりも小さい場合、挿入並べ替えアルゴリズムが使用されます。If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • パーティションの数が 2 * LogNを超えている場合 ( nは入力配列の範囲)、 heapsortアルゴリズムが使用されます。If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • それ以外の場合は、クイックソートアルゴリズムを使用します。Otherwise, it uses a Quicksort algorithm.

この実装は、不安定な並べ替えを実行します。つまり、2つの要素が等しい場合、その順序は保持されない可能性があります。This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. これに対して、安定した並べ替えでは、等しい要素の順序が保持されます。In contrast, a stable sort preserves the order of elements that are equal.

Heapsort アルゴリズムとクイックソートアルゴリズムを使用して並べ替えられた配列の場合、最悪の場合、このメソッドはn O n(log) 操作nlengthなります。ここで、はです。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.

注意 (呼び出し元)

.NET Framework 4 以前のバージョンでは、クイックソートアルゴリズムのみが使用されていました。The .NET Framework 4 and earlier versions used only the Quicksort algorithm. クイックソートは、並べ替え操作によって例外がIndexOutOfRangeExceptionスローされ、呼び出し元にArgumentException例外をスローする場合に、無効な比較子を識別します。Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. 以降では、挿入の並べ替えおよび heapsort アルゴリズムで無効ArgumentExceptionな比較子が検出されないため、以前にスローされた並べ替え操作で例外がスローされない可能性があります。 .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. ほとんどの場合、これは16個未満の要素を持つ配列に適用されます。For the most part, this applies to arrays with fewer than 16 elements.

こちらもご覧ください

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

2 つの Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) を、最初の Array 内のキーに基づき、各キーによって実装された IComparable<T> ジェネリック インターフェイスを使用して並べ替えます。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())

型パラメーター

TKey

キー用の配列要素の型。The type of the elements of the key array.

TValue

項目用の配列要素の型。The type of the elements of the items array.

パラメーター

keys
TKey[]

並べ替えるキーを格納している 1 次元の Array。インデックス番号が 0 から始まる必要があります。The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

keys 内のキーに対応する項目が格納された、インデックス番号が 0 から始まる 1 次元 Arraykeys だけを並べ替える場合は nullThe one-dimensional, zero-based Array that contains the items that correspond to the keys in keys, or null to sort only keys.

例外

itemsnullではなく、 keys の下限が itemsの下限と一致していません。items is not null, and the lower bound of keys does not match the lower bound of items.

または-or- itemsnull ではなく、keys の長さが items の長さを超えています。items is not null, and the length of keys is greater than the length of items.

keysArray 内の 1 つ以上の要素に IComparable<T> ジェネリック インターフェイスが実装されていません。One or more elements in the keysArray do not implement the IComparable<T> generic interface.

次のコード例は、 Sort<TKey,TValue>(TKey[], TValue[])キーとSort<TKey,TValue>(TKey[], TValue[], Int32, Int32)値を表す配列のペアを並べ替えるための、 Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>)、、およびSort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)ジェネリックメソッドのオーバーロードを示しています。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.

このコード例では、というReverseCompare名前の文字列の代替比較子を定義しています。これは、 IComparer<string> (IComparer(Of String) Visual Basic では、 IComparer<String^> Visual C++) ジェネリックインターフェイスを実装します。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. 比較子は、 CompareTo(String)比較対照値の順序を逆にしてメソッドを呼び出し、文字列が低い順に並べ替えられるようにします。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.

このコード例では、恐竜の名前 (キー) と、各恐竜の最大長をメートル (値) で表す整数の配列を作成して表示します。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). 次に、配列が並べ替えられ、複数回表示されます。The arrays are then sorted and displayed several times:

注意

ジェネリックメソッドへの呼び出しは、それに対応する非ジェネリックメソッドの呼び出しとは異なるものにC#はなりC++ません。これは Visual Basic、、およびが、最初の2つの引数の型からジェネリック型パラメーターの型を推論するためです。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. Ildasm.exe (IL 逆アセンブラー)を使用して Microsoft 中間言語 (MSIL) を調べると、ジェネリックメソッドが呼び出されていることがわかります。If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

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

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

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

    array<int>^ dinosaurSizes = { 40, 5, 3, 22, 1, 18 };

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

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

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

    ReverseComparer^ rc = gcnew ReverseComparer();

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

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

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

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

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

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }
}

/* This code example produces the following output:

Seismosaurus: up to 40 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.

Sort(dinosaurs, dinosaurSizes)

Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Seismosaurus: up to 40 meters long.

Sort(dinosaurs, dinosaurSizes, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.
 */
using System;
using System.Collections.Generic;

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

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = {
            "Seismosaurus", 
            "Chasmosaurus", 
            "Coelophysis", 
            "Mamenchisaurus", 
            "Caudipteryx", 
            "Cetiosaurus"  };

        int[] dinosaurSizes = { 40, 5, 3, 22, 1, 18 };

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

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

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        ReverseComparer rc = new ReverseComparer();

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

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

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

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

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

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }
    }
}

/* This code example produces the following output:

Seismosaurus: up to 40 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.

Sort(dinosaurs, dinosaurSizes)

Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Seismosaurus: up to 40 meters long.

Sort(dinosaurs, dinosaurSizes, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.
 */
Imports System
Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

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

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

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

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

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

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

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

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

        Dim rc As New ReverseComparer()

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

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

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

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

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

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

    End Sub

End Class

' This code example produces the following output:
'
'Seismosaurus: up to 40 meters long.
'Chasmosaurus: up to 5 meters long.
'Coelophysis: up to 3 meters long.
'Mamenchisaurus: up to 22 meters long.
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'
'Sort(dinosaurs, dinosaurSizes)
'
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'Chasmosaurus: up to 5 meters long.
'Coelophysis: up to 3 meters long.
'Mamenchisaurus: up to 22 meters long.
'Seismosaurus: up to 40 meters long.
'
'Sort(dinosaurs, dinosaurSizes, rc)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Chasmosaurus: up to 5 meters long.
'Cetiosaurus: up to 18 meters long.
'Caudipteryx: up to 1 meters long.
'
'Sort(dinosaurs, dinosaurSizes, 3, 3)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'Chasmosaurus: up to 5 meters long.
'
'Sort(dinosaurs, dinosaurSizes, 3, 3, rc)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Chasmosaurus: up to 5 meters long.
'Cetiosaurus: up to 18 meters long.
'Caudipteryx: up to 1 meters long.

注釈

keys items Arrayの各キーには、内の対応する項目があります。ArrayEach key in the keysArray has a corresponding item in the itemsArray. 並べ替え中にキーが移動されると、内items Arrayの対応する項目も同様に再配置されます。When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. したがって、 keysは、内Arrayの対応するキーの配置に従って並べ替えられます。 items ArrayTherefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

の各キーはkeysArray他のIComparable<T>すべてのキーと比較できるように、ジェネリックインターフェイスを実装する必要があります。Each key in the keysArray must implement the IComparable<T> generic interface to be capable of comparisons with every other key.

キー以外の項目がある場合は、並べ替えることができますが、対応するキーがない項目は並べ替えられません。You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. 項目よりも多くのキーがある場合は、並べ替えることはできません。この操作を行うArgumentExceptionと、がスローされます。You cannot sort if there are more keys than items; doing this throws an ArgumentException.

並べ替えが正常に完了しなかった場合、結果は未定義になります。If the sort is not successfully completed, the results are undefined.

このメソッドでは、次のように introspective sort (introsort) アルゴリズムが使用されます。This method uses the introspective sort (introsort) algorithm as follows:

  • パーティションサイズが16要素よりも小さい場合、挿入並べ替えアルゴリズムが使用されます。If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • パーティションの数が 2 * LogNを超えている場合 ( nは入力配列の範囲)、 heapsortアルゴリズムが使用されます。If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • それ以外の場合は、クイックソートアルゴリズムを使用します。Otherwise, it uses a Quicksort algorithm.

この実装は、不安定な並べ替えを実行します。つまり、2つの要素が等しい場合、その順序は保持されない可能性があります。This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. これに対して、安定した並べ替えでは、等しい要素の順序が保持されます。In contrast, a stable sort preserves the order of elements that are equal.

Heapsort アルゴリズムとクイックソートアルゴリズムを使用して並べ替えられた配列の場合、最悪の場合、このメソッドはn O n(log) Length操作nになります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.

こちらもご覧ください

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

2 つの Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) を、最初の Array 内のキーに基づき、指定した IComparer<T> ジェネリック インターフェイスを使用して並べ替えます。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))

型パラメーター

TKey

キー用の配列要素の型。The type of the elements of the key array.

TValue

項目用の配列要素の型。The type of the elements of the items array.

パラメーター

keys
TKey[]

並べ替えるキーを格納している 1 次元の Array。インデックス番号が 0 から始まる必要があります。The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

keys 内のキーに対応する項目が格納された、インデックス番号が 0 から始まる 1 次元 Arraykeys だけを並べ替える場合は nullThe 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>

要素を比較する際に使用する IComparer<T> ジェネリック インターフェイスの実装。各要素が実装する IComparable<T> ジェネリック インターフェイスを使用する場合は nullThe IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

例外

itemsnullではなく、 keys の下限が itemsの下限と一致していません。items is not null, and the lower bound of keys does not match the lower bound of items.

- または --or- itemsnull ではなく、keys の長さが items の長さを超えています。items is not null, and the length of keys is greater than the length of items.

- または --or- comparer の実装により、並べ替え中にエラーが発生しました。The implementation of comparer caused an error during the sort. たとえば、comparer は、項目をそれ自体と比較したときに 0 を返さなかった可能性があります。For example, comparer might not return 0 when comparing an item with itself.

comparernull であり、keysArray 内の 1 つ以上の要素に IComparable<T> ジェネリック インターフェイスが実装されていません。comparer is null, and one or more elements in the keysArray do not implement the IComparable<T> generic interface.

次のコード例ではSort<TKey,TValue>(TKey[], TValue[])、"], TValue<% 60% 602>% 28% 60% 600% 5b% 5d% 2c% 60% 601% 5b% 5d% 2csystem.string. IComparer% 7b% 60% 600% 7d% 29 >、Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)、というコード例を示しています。およびSort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)ジェネリックメソッドオーバーロード。キーと値を表す配列のペアを並べ替えるために使用します。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.

このコード例では、というReverseCompare名前の文字列の代替比較子を定義しています。これは、 IComparer<string> (IComparer(Of String) Visual Basic では、 IComparer<String^> Visual C++) ジェネリックインターフェイスを実装します。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. 比較子は、 CompareTo(String)比較対照値の順序を逆にしてメソッドを呼び出し、文字列が低い順に並べ替えられるようにします。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.

このコード例では、恐竜の名前 (キー) と、各恐竜の最大長をメートル (値) で表す整数の配列を作成して表示します。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). 次に、配列が並べ替えられ、複数回表示されます。The arrays are then sorted and displayed several times:

注意

ジェネリックメソッドへの呼び出しは、それに対応する非ジェネリックメソッドの呼び出しとは異なるものにC#はなりC++ません。これは Visual Basic、、およびが、最初の2つの引数の型からジェネリック型パラメーターの型を推論するためです。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. Ildasm.exe (IL 逆アセンブラー)を使用して Microsoft 中間言語 (MSIL) を調べると、ジェネリックメソッドが呼び出されていることがわかります。If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

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

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

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

    array<int>^ dinosaurSizes = { 40, 5, 3, 22, 1, 18 };

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

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

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

    ReverseComparer^ rc = gcnew ReverseComparer();

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

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

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

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

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

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }
}

/* This code example produces the following output:

Seismosaurus: up to 40 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.

Sort(dinosaurs, dinosaurSizes)

Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Seismosaurus: up to 40 meters long.

Sort(dinosaurs, dinosaurSizes, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.
 */
using System;
using System.Collections.Generic;

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

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = {
            "Seismosaurus", 
            "Chasmosaurus", 
            "Coelophysis", 
            "Mamenchisaurus", 
            "Caudipteryx", 
            "Cetiosaurus"  };

        int[] dinosaurSizes = { 40, 5, 3, 22, 1, 18 };

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

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

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        ReverseComparer rc = new ReverseComparer();

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

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

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

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

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

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }
    }
}

/* This code example produces the following output:

Seismosaurus: up to 40 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.

Sort(dinosaurs, dinosaurSizes)

Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Seismosaurus: up to 40 meters long.

Sort(dinosaurs, dinosaurSizes, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.
 */
Imports System
Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

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

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

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

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

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

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

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

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

        Dim rc As New ReverseComparer()

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

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

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

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

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

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

    End Sub

End Class

' This code example produces the following output:
'
'Seismosaurus: up to 40 meters long.
'Chasmosaurus: up to 5 meters long.
'Coelophysis: up to 3 meters long.
'Mamenchisaurus: up to 22 meters long.
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'
'Sort(dinosaurs, dinosaurSizes)
'
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'Chasmosaurus: up to 5 meters long.
'Coelophysis: up to 3 meters long.
'Mamenchisaurus: up to 22 meters long.
'Seismosaurus: up to 40 meters long.
'
'Sort(dinosaurs, dinosaurSizes, rc)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Chasmosaurus: up to 5 meters long.
'Cetiosaurus: up to 18 meters long.
'Caudipteryx: up to 1 meters long.
'
'Sort(dinosaurs, dinosaurSizes, 3, 3)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'Chasmosaurus: up to 5 meters long.
'
'Sort(dinosaurs, dinosaurSizes, 3, 3, rc)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Chasmosaurus: up to 5 meters long.
'Cetiosaurus: up to 18 meters long.
'Caudipteryx: up to 1 meters long.

注釈

keys items Arrayの各キーには、内の対応する項目があります。ArrayEach key in the keysArray has a corresponding item in the itemsArray. 並べ替え中にキーが移動されると、内items Arrayの対応する項目も同様に再配置されます。When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. したがって、 keysは、内Arrayの対応するキーの配置に従って並べ替えられます。 items ArrayTherefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

comparer の場合keys 、内の各キーは、他のすべてのキーと比較できるように、ジェネリックインターフェイスを実装する必要があります。IComparable<T> Array nullIf comparer is null, each key in the keysArray must implement the IComparable<T> generic interface to be capable of comparisons with every other key.

キー以外の項目がある場合は、並べ替えることができますが、対応するキーがない項目は並べ替えられません。You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. 項目よりも多くのキーがある場合は、並べ替えることはできません。この操作を行うArgumentExceptionと、がスローされます。You cannot sort if there are more keys than items; doing this throws an ArgumentException.

並べ替えが正常に完了しなかった場合、結果は未定義になります。If the sort is not successfully completed, the results are undefined.

このメソッドでは、次のように introspective sort (introsort) アルゴリズムが使用されます。This method uses the introspective sort (introsort) algorithm as follows:

  • パーティションサイズが16要素よりも小さい場合、挿入並べ替えアルゴリズムが使用されます。If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • パーティションの数が 2 * LogNを超えている場合 ( nは入力配列の範囲)、 heapsortアルゴリズムが使用されます。If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • それ以外の場合は、クイックソートアルゴリズムを使用します。Otherwise, it uses a Quicksort algorithm.

この実装は、不安定な並べ替えを実行します。つまり、2つの要素が等しい場合、その順序は保持されない可能性があります。This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. これに対して、安定した並べ替えでは、等しい要素の順序が保持されます。In contrast, a stable sort preserves the order of elements that are equal.

Heapsort アルゴリズムとクイックソートアルゴリズムを使用して並べ替えられた配列の場合、最悪の場合、このメソッドはn O n(log) Length操作nになります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 4 以前のバージョンでは、クイックソートアルゴリズムのみが使用されていました。The .NET Framework 4 and earlier versions used only the Quicksort algorithm. クイックソートは、並べ替え操作によって例外がIndexOutOfRangeExceptionスローされ、呼び出し元にArgumentException例外をスローする場合に、無効な比較子を識別します。Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. 以降では、挿入の並べ替えおよび heapsort アルゴリズムで無効ArgumentExceptionな比較子が検出されないため、以前にスローされた並べ替え操作で例外がスローされない可能性があります。 .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. ほとんどの場合、これは16個未満の要素を持つ配列に適用されます。For the most part, this applies to arrays with fewer than 16 elements.

こちらもご覧ください

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)

2 つの Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) の要素範囲を、最初の Array 内のキーに基づき、各キーによって実装された IComparable<T> ジェネリック インターフェイスを使用して並べ替えます。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)

型パラメーター

TKey

キー用の配列要素の型。The type of the elements of the key array.

TValue

項目用の配列要素の型。The type of the elements of the items array.

パラメーター

keys
TKey[]

並べ替えるキーを格納している 1 次元の Array。インデックス番号が 0 から始まる必要があります。The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

keys 内のキーに対応する項目が格納された、インデックス番号が 0 から始まる 1 次元 Arraykeys だけを並べ替える場合は nullThe 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

並べ替え対象の範囲の開始位置を示すインデックス。The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

並べ替え対象の範囲内にある要素の数。The number of elements in the range to sort.

例外

index は、keys の下限を下回っています。index is less than the lower bound of keys.

または-or- length が 0 未満です。length is less than zero.

itemsnull ではなく、keys の下限が items の下限と一致していません。items is not null, and the lower bound of keys does not match the lower bound of items.

または-or- itemsnull ではなく、keys の長さが items の長さを超えています。items is not null, and the length of keys is greater than the length of items.

または-or- index および lengthkeysArray内の指定した位置にある値を取得します。index and length do not specify a valid range in the keysArray.

- または --or- itemsnull ではなく、index および lengthitemsArray 内の有効な範囲を示していません。items is not null, and index and length do not specify a valid range in the itemsArray.

keysArray 内の 1 つ以上の要素に IComparable<T> ジェネリック インターフェイスが実装されていません。One or more elements in the keysArray do not implement the IComparable<T> generic interface.

次のコード例は、 Sort<TKey,TValue>(TKey[], TValue[]), Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>), [], TValue<xref: 602>% 60%% 28% 60% 600% 5b% 5d% 2c% 60% 601% 5b% 5d% 2csystem.string% 2csystem.string% 29 >, およびを示してSort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)います。ジェネリックメソッドオーバーロード。キーと値を表す配列のペアを並べ替えるために使用します。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.

このコード例では、というReverseCompare名前の文字列の代替比較子を定義しています。これは、 IComparer<string> (IComparer(Of String) Visual Basic では、 IComparer<String^> Visual C++) ジェネリックインターフェイスを実装します。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. 比較子は、 CompareTo(String)比較対照値の順序を逆にしてメソッドを呼び出し、文字列が低い順に並べ替えられるようにします。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.

このコード例では、恐竜の名前 (キー) と、各恐竜の最大長をメートル (値) で表す整数の配列を作成して表示します。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). 次に、配列が並べ替えられ、複数回表示されます。The arrays are then sorted and displayed several times:

注意

ジェネリックメソッドへの呼び出しは、それに対応する非ジェネリックメソッドの呼び出しとは異なるものにC#はなりC++ません。これは Visual Basic、、およびが、最初の2つの引数の型からジェネリック型パラメーターの型を推論するためです。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. Ildasm.exe (IL 逆アセンブラー)を使用して Microsoft 中間言語 (MSIL) を調べると、ジェネリックメソッドが呼び出されていることがわかります。If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

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

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

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

    array<int>^ dinosaurSizes = { 40, 5, 3, 22, 1, 18 };

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

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

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

    ReverseComparer^ rc = gcnew ReverseComparer();

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

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

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

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

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

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }
}

/* This code example produces the following output:

Seismosaurus: up to 40 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.

Sort(dinosaurs, dinosaurSizes)

Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Seismosaurus: up to 40 meters long.

Sort(dinosaurs, dinosaurSizes, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.
 */
using System;
using System.Collections.Generic;

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

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = {
            "Seismosaurus", 
            "Chasmosaurus", 
            "Coelophysis", 
            "Mamenchisaurus", 
            "Caudipteryx", 
            "Cetiosaurus"  };

        int[] dinosaurSizes = { 40, 5, 3, 22, 1, 18 };

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

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

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        ReverseComparer rc = new ReverseComparer();

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

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

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

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

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

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }
    }
}

/* This code example produces the following output:

Seismosaurus: up to 40 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.

Sort(dinosaurs, dinosaurSizes)

Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Seismosaurus: up to 40 meters long.

Sort(dinosaurs, dinosaurSizes, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.
 */
Imports System
Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

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

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

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

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

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

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

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

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

        Dim rc As New ReverseComparer()

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

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

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

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

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

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

    End Sub

End Class

' This code example produces the following output:
'
'Seismosaurus: up to 40 meters long.
'Chasmosaurus: up to 5 meters long.
'Coelophysis: up to 3 meters long.
'Mamenchisaurus: up to 22 meters long.
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'
'Sort(dinosaurs, dinosaurSizes)
'
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'Chasmosaurus: up to 5 meters long.
'Coelophysis: up to 3 meters long.
'Mamenchisaurus: up to 22 meters long.
'Seismosaurus: up to 40 meters long.
'
'Sort(dinosaurs, dinosaurSizes, rc)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Chasmosaurus: up to 5 meters long.
'Cetiosaurus: up to 18 meters long.
'Caudipteryx: up to 1 meters long.
'
'Sort(dinosaurs, dinosaurSizes, 3, 3)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'Chasmosaurus: up to 5 meters long.
'
'Sort(dinosaurs, dinosaurSizes, 3, 3, rc)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Chasmosaurus: up to 5 meters long.
'Cetiosaurus: up to 18 meters long.
'Caudipteryx: up to 1 meters long.

注釈

keys items Arrayの各キーには、内の対応する項目があります。ArrayEach key in the keysArray has a corresponding item in the itemsArray. 並べ替え中にキーが移動されると、内items Arrayの対応する項目も同様に再配置されます。When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. したがって、 keysは、内Arrayの対応するキーの配置に従って並べ替えられます。 items ArrayTherefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

keys の指定IComparable<T>された要素範囲内の各キーは、他のすべてのキーと比較できるように、ジェネリックインターフェイスを実装する必要があります。ArrayEach 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.

キー以外の項目がある場合は、並べ替えることができますが、対応するキーがない項目は並べ替えられません。You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. 項目よりも多くのキーがある場合は、並べ替えることはできません。この操作を行うArgumentExceptionと、がスローされます。You cannot sort if there are more keys than items; doing this throws an ArgumentException.

並べ替えが正常に完了しなかった場合、結果は未定義になります。If the sort is not successfully completed, the results are undefined.

このメソッドでは、次のように introspective sort (introsort) アルゴリズムが使用されます。This method uses the introspective sort (introsort) algorithm as follows:

  • パーティションサイズが16要素よりも小さい場合、挿入並べ替えアルゴリズムが使用されます。If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • パーティションの数が 2 * LogNを超えている場合 ( nは入力配列の範囲)、 heapsortアルゴリズムが使用されます。If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • それ以外の場合は、クイックソートアルゴリズムを使用します。Otherwise, it uses a Quicksort algorithm.

この実装は、不安定な並べ替えを実行します。つまり、2つの要素が等しい場合、その順序は保持されない可能性があります。This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. これに対して、安定した並べ替えでは、等しい要素の順序が保持されます。In contrast, a stable sort preserves the order of elements that are equal.

Heapsort アルゴリズムとクイックソートアルゴリズムを使用して並べ替えられた配列の場合、最悪の場合、このメソッドはn O n(log) 操作nlengthなります。ここで、はです。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.

こちらもご覧ください

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

2 つの Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) 内の要素範囲を、最初の Array 内のキーに基づき、指定した IComparer<T> ジェネリック インターフェイスを使用して並べ替えます。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))

型パラメーター

TKey

キー用の配列要素の型。The type of the elements of the key array.

TValue

項目用の配列要素の型。The type of the elements of the items array.

パラメーター

keys
TKey[]

並べ替えるキーを格納している 1 次元の Array。インデックス番号が 0 から始まる必要があります。The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

keys 内のキーに対応する項目が格納された、インデックス番号が 0 から始まる 1 次元 Arraykeys だけを並べ替える場合は nullThe 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

並べ替え対象の範囲の開始位置を示すインデックス。The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

並べ替え対象の範囲内にある要素の数。The number of elements in the range to sort.

comparer
IComparer<TKey>

要素を比較する際に使用する IComparer<T> ジェネリック インターフェイスの実装。各要素が実装する IComparable<T> ジェネリック インターフェイスを使用する場合は nullThe IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

例外

index は、keys の下限を下回っています。index is less than the lower bound of keys.

- または --or- length が 0 未満です。length is less than zero.

itemsnull ではなく、keys の下限が items の下限と一致していません。items is not null, and the lower bound of keys does not match the lower bound of items.

または-or- itemsnull ではなく、keys の長さが items の長さを超えています。items is not null, and the length of keys is greater than the length of items.

- または --or- index および lengthkeysArray内の指定した位置にある値を取得します。index and length do not specify a valid range in the keysArray.

- または --or- itemsnull ではなく、index および lengthitemsArray 内の有効な範囲を示していません。items is not null, and index and length do not specify a valid range in the itemsArray.

- または --or- comparer の実装により、並べ替え中にエラーが発生しました。The implementation of comparer caused an error during the sort. たとえば、comparer は、項目をそれ自体と比較したときに 0 を返さなかった可能性があります。For example, comparer might not return 0 when comparing an item with itself.

comparernull であり、keysArray 内の 1 つ以上の要素に IComparable<T> ジェネリック インターフェイスが実装されていません。comparer is null, and one or more elements in the keysArray do not implement the IComparable<T> generic interface.

次のコード例は、 Sort<TKey,TValue>(TKey[], TValue[])Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>)Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)、および [], TValue<% 60% 602>% 28% 60% 600% 5b% 5d% 2c% 60% 601% 5b% 5d% 2csystem.string% 2csystem.string% を示しています。2Csystem.string. IComparer% 7B% 60% 600% 7D% 29 >、キーと値を表す配列のペアを並べ替えるためのジェネリックメソッドオーバーロードです。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.

このコード例では、というReverseCompare名前の文字列の代替比較子を定義しています。これは、 IComparer<string>(IComparer(Of String) Visual Basic では、 IComparer<String^> Visual C++) ジェネリックインターフェイスを実装します。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. 比較子は、 CompareTo(String)比較対照値の順序を逆にしてメソッドを呼び出し、文字列が低い順に並べ替えられるようにします。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.

このコード例では、恐竜の名前 (キー) と、各恐竜の最大長をメートル (値) で表す整数の配列を作成して表示します。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). 次に、配列が並べ替えられ、複数回表示されます。The arrays are then sorted and displayed several times:

  • オーバーロードSort<TKey,TValue>(TKey[], TValue[])は、最初の配列の恐竜名の順に両方の配列を並べ替えるために使用されます。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>)とのReverseCompareインスタンスは、ペアになっている配列の並べ替え順序を逆にするために使用されます。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)は、両方の配列の最後の3つの要素を並べ替えるために使用されます。The Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) overload is used to sort the last three elements of both arrays.

  • [], TValue<xref: 2csystem.string% 60% 602>% 28% 60% 600% 5b% 5d% 2c% 60% 601% 5b% 5d% 2csystem.string% 2csystem.string% IComparer% 7b% 60% 600% 7d% 29 > オーバーロードを使用して、最後の3つを並べ替えます。逆の順序で両方の配列の要素。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.

注意

ジェネリックメソッドへの呼び出しは、それに対応する非ジェネリックメソッドの呼び出しとは異なるものにC#はなりC++ません。これは Visual Basic、、およびが、最初の2つの引数の型からジェネリック型パラメーターの型を推論するためです。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. Ildasm.exe (IL 逆アセンブラー)を使用して Microsoft 中間言語 (MSIL) を調べると、ジェネリックメソッドが呼び出されていることがわかります。If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

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

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

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

    array<int>^ dinosaurSizes = { 40, 5, 3, 22, 1, 18 };

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

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

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

    ReverseComparer^ rc = gcnew ReverseComparer();

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

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

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

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

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

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }
}

/* This code example produces the following output:

Seismosaurus: up to 40 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.

Sort(dinosaurs, dinosaurSizes)

Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Seismosaurus: up to 40 meters long.

Sort(dinosaurs, dinosaurSizes, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.
 */
using System;
using System.Collections.Generic;

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

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = {
            "Seismosaurus", 
            "Chasmosaurus", 
            "Coelophysis", 
            "Mamenchisaurus", 
            "Caudipteryx", 
            "Cetiosaurus"  };

        int[] dinosaurSizes = { 40, 5, 3, 22, 1, 18 };

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

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

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        ReverseComparer rc = new ReverseComparer();

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

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

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

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

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

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }
    }
}

/* This code example produces the following output:

Seismosaurus: up to 40 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.

Sort(dinosaurs, dinosaurSizes)

Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Seismosaurus: up to 40 meters long.

Sort(dinosaurs, dinosaurSizes, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.
 */
Imports System
Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

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

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

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

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

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

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

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

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

        Dim rc As New ReverseComparer()

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

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

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

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

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

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

    End Sub

End Class

' This code example produces the following output:
'
'Seismosaurus: up to 40 meters long.
'Chasmosaurus: up to 5 meters long.
'Coelophysis: up to 3 meters long.
'Mamenchisaurus: up to 22 meters long.
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'
'Sort(dinosaurs, dinosaurSizes)
'
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'Chasmosaurus: up to 5 meters long.
'Coelophysis: up to 3 meters long.
'Mamenchisaurus: up to 22 meters long.
'Seismosaurus: up to 40 meters long.
'
'Sort(dinosaurs, dinosaurSizes, rc)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Chasmosaurus: up to 5 meters long.
'Cetiosaurus: up to 18 meters long.
'Caudipteryx: up to 1 meters long.
'
'Sort(dinosaurs, dinosaurSizes, 3, 3)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'Chasmosaurus: up to 5 meters long.
'
'Sort(dinosaurs, dinosaurSizes, 3, 3, rc)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Chasmosaurus: up to 5 meters long.
'Cetiosaurus: up to 18 meters long.
'Caudipteryx: up to 1 meters long.

注釈

keys items Arrayの各キーには、内の対応する項目があります。ArrayEach key in the keysArray has a corresponding item in the itemsArray. 並べ替え中にキーが移動されると、内items Arrayの対応する項目も同様に再配置されます。When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. したがって、 keysは、内Arrayの対応するキーの配置に従って並べ替えられます。 items ArrayTherefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

comparernull場合、 keys 内のArray指定された要素範囲内の各キーは、他のすべてのキーと比較できるように、ジェネリックインターフェイスを実装する必要があります。IComparable<T>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.

キー以外の項目がある場合は、並べ替えることができますが、対応するキーがない項目は並べ替えられません。You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. 項目よりも多くのキーがある場合は、並べ替えることはできません。この操作を行うArgumentExceptionと、がスローされます。You cannot sort if there are more keys than items; doing this throws an ArgumentException.

並べ替えが正常に完了しなかった場合、結果は未定義になります。If the sort is not successfully completed, the results are undefined.

このメソッドでは、次のように introspective sort (introsort) アルゴリズムが使用されます。This method uses the introspective sort (introsort) algorithm as follows:

  • パーティションサイズが16要素よりも小さい場合、挿入並べ替えアルゴリズムが使用されます。If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • パーティションの数が 2 * LogNを超えている場合 ( nは入力配列の範囲)、 heapsortアルゴリズムが使用されます。If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • それ以外の場合は、クイックソートアルゴリズムを使用します。Otherwise, it uses a Quicksort algorithm.

この実装は、不安定な並べ替えを実行します。つまり、2つの要素が等しい場合、その順序は保持されない可能性があります。This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. これに対して、安定した並べ替えでは、等しい要素の順序が保持されます。In contrast, a stable sort preserves the order of elements that are equal.

Heapsort アルゴリズムとクイックソートアルゴリズムを使用して並べ替えられた配列の場合、最悪の場合、このメソッドはn O n(log) 操作nlengthなります。ここで、はです。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.

注意 (呼び出し元)

.NET Framework 4 以前のバージョンでは、クイックソートアルゴリズムのみが使用されていました。The .NET Framework 4 and earlier versions used only the Quicksort algorithm. クイックソートは、並べ替え操作によって例外がIndexOutOfRangeExceptionスローされ、呼び出し元にArgumentException例外をスローする場合に、無効な比較子を識別します。Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. 以降では、挿入の並べ替えおよび heapsort アルゴリズムで無効ArgumentExceptionな比較子が検出されないため、以前にスローされた並べ替え操作で例外がスローされない可能性があります。 .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. ほとんどの場合、これは16個未満の要素を持つ配列に適用されます。For the most part, this applies to arrays with fewer than 16 elements.

こちらもご覧ください

適用対象