System.Array.Sort Method

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.

Syntax

[System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)]
public static void Sort (Array keys, Array items)

Parameters

keys
The one-dimensional Array that contains the keys to sort.
items
The one-dimensional Array that contains the items that correspond to each of the keys in the keys Array.

Exceptions

TypeReason
ArgumentNullException keys is null.
RankException

keys has more than one dimension.

-or-

items is not a null reference and has more than one dimension.

ArgumentException

items is not a null reference, and keys.GetLowerBound(0) does not equal items.GetLowerBound(0).

-or-

items is not a null reference, and keys.Length > items.Length.

InvalidOperationExceptionOne or more elements in keys that are used in a comparison do not implement the IComparable interface.

Remarks

Each key in the keys Array has a corresponding item in the items Array. When a key is repositioned during the sorting, the corresponding item in the items Array is similarly repositioned. Therefore, the items Array is sorted according to the arrangement of the corresponding keys in the keys Array.

Each key in the keys Array 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. 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.

This method uses the introspective sort (introsort) algorithm as follows:

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.

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 Array.Length of keys.

Example

This example demonstrates the Array.Sort(Array) method.

C# Example

using System;
public class ArraySortExample {
   public static void Main() {
      string[] strAry = { "All's", "well", "that", "ends", "well" };
      int[] intAry = { 3, 4, 0, 1, 2 };
      Console.Write( "The original string array is: " );
      foreach ( string str in strAry )
         Console.Write( str + " " );
      Console.WriteLine();
      Console.Write( "The key array is: " );
      foreach ( int i in intAry )
         Console.Write( i + " " );
      Console.WriteLine();
      Array.Sort( intAry, strAry );
      Console.Write( "The sorted string array is: " );
      foreach ( string str in strAry )
         Console.Write( str + " " );
   }
}

The output is

The original string array is: All's well that ends well
The key array is: 3 4 0 1 2
The sorted string array is: that ends well All's well

Requirements

Namespace: System
Assembly: mscorlib (in mscorlib.dll)
Assembly Versions: 1.0.5000.0, 2.0.0.0, 4.0.0.0