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

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

 

Ordena un par de objetos Array unidimensionales (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves de la primera matriz Array utilizando la interfaz IComparer especificada.

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

public static void Sort(
	Array keys,
	Array items,
	IComparer comparer
)

Parámetros

keys

Array unidimensional que contiene las claves que se van a ordenar.

items

Objeto Array unidimensional que contiene los elementos que se corresponden con cada una de las claves del objeto Array de keys.

-o-

null para ordenar solo el objeto Array de keys.

comparer

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

-o-

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

Exception Condition
ArgumentNullException

El valor de keys es null.

RankException

La matriz Array de keys es multidimensional.

-o-

La matriz Array de items es multidimensional.

ArgumentException

items no es null, y la longitud de keys es mayor que la longitud de items.

-o-

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

InvalidOperationException

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

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

If comparer is null, each key in the keysArray must implement the IComparable interface to be capable of comparisons with every other key.

Puede ordenar si hay más elementos que las claves, pero no se ordenará los productos con ninguna de las claves correspondientes.No se puede ordenar si hay más claves que elementos; hacer esto produce un ArgumentException.

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 se 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 proporcionando una instancia de su propio IComparer implementación a la comparer parámetro.El ejemplo de ello, deberá definir una IComparer implementación que invierte el criterio de ordenación predeterminado y realiza la comparación de cadenas que distinguen mayúsculas de 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 orden de inserción 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.

  • Si no, utiliza un algoritmo Quicksort.

Esta implementación realiza a una ordenación inestable; es decir, si dos elementos son iguales, no se puede conservar su orden.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 E/s (n registro n) operación, donde n es el Length de keys.

Notas para los llamadores:

El .NET Framework 4 y versiones anteriores se usan sólo el algoritmo Quicksort.QuickSort identifica comparadores no válidos en algunas situaciones en que se inicia la operación de ordenación una 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 se iniciará una excepción, ya que los algoritmos de ordenación y heapsort de inserción no detectan un comparador no válido.En general, esto se aplica a las matrices con menos de 16 elementos.

En el ejemplo siguiente se muestra cómo ordenar dos matrices asociadas, donde la primera contiene las claves y la segunda matriz contiene los valores.Ordenaciones se realizan utilizando el comparador predeterminado y un comparador personalizado que invierte el criterio de ordenación.Tenga en cuenta que el resultado puede variar según la actual CultureInfo.

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

*/

Universal Windows Platform
Disponible desde 10
.NET Framework
Disponible desde 1.1
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Volver al principio
Mostrar: