Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método Array.Sort (Array, Int32, Int32, IComparer)

 

Publicado: noviembre de 2016

Ordena los elementos de un intervalo de elementos de un unidimensional Array usando el objeto IComparer.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

public static void Sort(
	Array array,
	int index,
	int length,
	IComparer comparer
)

Parámetros

array
Type: System.Array

Array unidimensional que se va a ordenar.

index
Type: System.Int32

Índice inicial del intervalo que se va a ordenar.

length
Type: System.Int32

Número de elementos del intervalo que se va a ordenar.

comparer
Type: System.Collections.IComparer

Implementación de IComparer que se va a usar al comparar elementos.

-o-

null para usar la implementación de IComparable de cada elemento.

Exception Condition
ArgumentNullException

El valor de array es null.

RankException

array es multidimensional.

ArgumentOutOfRangeException

index es menor que el límite inferior de array.

-o-

length es menor que cero.

ArgumentException

index y length no especifican un intervalo válido en array.

-o-

La implementación de comparer produjo un error durante la ordenación. Por ejemplo, es posible que comparer no devuelva 0 al comparar un elemento consigo mismo.

InvalidOperationException

comparer es null y uno o más elementos de la array no implementan la interfaz de IComparable.

Si comparer es null, cada elemento dentro del intervalo especificado de elementos de array debe implementar la IComparable para realizar comparaciones con otros elementos de interfaz de array.

Si la ordenación no se completa correctamente, los resultados son indefinidos.

.NET Framework incluye predefinidos IComparer implementaciones se muestran en la tabla siguiente.

Implementación

Descripción

System.Collections.CaseInsensitiveComparer

Compara los dos objetos, pero realiza una comparación entre mayúsculas y minúsculas de cadenas.

Comparer.Default

Compara los dos objetos usando las convenciones de ordenación de la referencia cultural actual.

Comparer.DefaultInvariant

Compara los dos objetos usando las convenciones de ordenación de la referencia cultural invariable.

Comparer<T>.Default

Compara dos objetos de tipo T utilizando el criterio de ordenación predeterminado del tipo.

También puede admitir las comparaciones personalizadas mediante una instancia de su propio IComparer implementación a la comparer parámetro. El ejemplo hace esto mediante la definición de un ReverseComparer clase que invierte el orden predeterminado de instancias de un tipo y realiza la comparación de cadenas entre mayúsculas y minúsculas.

Este método utiliza el algoritmo de ordenación introspectivas (introsort) como sigue:

  • Si el tamaño de la partición es menos de 16 elementos, utiliza un insertion sort algoritmo.

  • Si el número de particiones es superior a 2 * registroN, donde N es el intervalo de la matriz de entrada, utiliza un Heapsort algoritmo.

  • De lo contrario, utiliza un Quicksort algoritmo.

Esta implementación realiza a una ordenación inestable; es decir, si dos elementos son iguales, su orden no puede conservarse. En contraste, una ordenación estable conserva el orden de los elementos que son iguales.

Para las matrices que se ordenan utilizando los algoritmos Heapsort y Quicksort, en el peor de los casos, este método es una O (n Registro n) operación, donde n es length.

Notas para llamadores:

El .NET Framework 4 y versiones anteriores utilizan sólo el algoritmo Quicksort. QuickSort identifica comparadores no válidos en algunas situaciones en que se inicia la operación de ordenación un IndexOutOfRangeException excepción e inicia un ArgumentException excepción al llamador. A partir de la .NET Framework 4.5, es posible que las operaciones de ordenación que previamente produjo ArgumentException no producirá una excepción porque los algoritmos de ordenación y heapsort de inserción no detectan un comparador no válido. En su mayor parte, esto se aplica a las matrices con menos de 16 elementos.

En el ejemplo de código siguiente se muestra cómo ordenar los valores de un Array utilizando el comparador predeterminado y un comparador personalizado que invierte el orden. Tenga en cuenta que el resultado puede variar según la actual CultureInfo.

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    

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar: