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 ArrayList.Sort (Int32, Int32, IComparer)

 

Publicado: noviembre de 2016

Ordena los elementos en un intervalo de elementos de la matriz ArrayList usando el comparador especificado.

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

public virtual void Sort(
	int index,
	int count,
	IComparer comparer
)

Parámetros

index
Type: System.Int32

Índice inicial de base cero del intervalo que se va a ordenar.

count
Type: System.Int32

Longitud 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 bien

Referencia nula (Nothing en Visual Basic) para usar la implementación de IComparable de cada elemento.

Exception Condition
ArgumentOutOfRangeException

index es menor que cero.

O bien

count es menor que cero.

ArgumentException

index y count no especifican un intervalo válido en ArrayList.

NotSupportedException

ArrayList es de solo lectura.

InvalidOperationException

Se produjo un error al comparar dos elementos.

Si comparer se establece en null, este método realiza una ordenación de la comparación (también denominada ordenación inestable); es decir, si dos elementos son iguales, su orden podría no conservarse. En contraste, una ordenación estable conserva el orden de los elementos que son iguales. Para realizar una ordenación estable, debe implementar un personalizado IComparer interfaz.

En promedio, este método es una O (n Registro n) operación, donde n es count; en el peor caso es una operación O(n^2).

En el ejemplo de código siguiente se muestra cómo ordenar los valores en un intervalo de elementos en una ArrayList utilizando el comparador predeterminado y un comparador personalizado que invierte el orden.

using System;
using System.Collections;

public class SamplesArrayList  {

   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 ArrayList.
      ArrayList myAL = new ArrayList();
      myAL.Add( "The" );
      myAL.Add( "QUICK" );
      myAL.Add( "BROWN" );
      myAL.Add( "FOX" );
      myAL.Add( "jumped" );
      myAL.Add( "over" );
      myAL.Add( "the" );
      myAL.Add( "lazy" );
      myAL.Add( "dog" );

      // Displays the values of the ArrayList.
      Console.WriteLine( "The ArrayList initially contains the following values:" );
      PrintIndexAndValues( myAL );

      // Sorts the values of the ArrayList using the default comparer.
      myAL.Sort( 1, 3, null );
      Console.WriteLine( "After sorting from index 1 to index 3 with the default comparer:" );
      PrintIndexAndValues( myAL );

      // Sorts the values of the ArrayList using the reverse case-insensitive comparer.
      IComparer myComparer = new myReverserClass();
      myAL.Sort( 1, 3, myComparer );
      Console.WriteLine( "After sorting from index 1 to index 3 with the reverse case-insensitive comparer:" );
      PrintIndexAndValues( myAL );

   }

   public static void PrintIndexAndValues( IEnumerable myList )  {
      int i = 0;
      foreach ( Object obj in myList )
         Console.WriteLine( "\t[{0}]:\t{1}", i++, obj );
      Console.WriteLine();
   }

}


/* 
This code produces the following output.
The ArrayList initially contains the following values:
        [0]:    The
        [1]:    QUICK
        [2]:    BROWN
        [3]:    FOX
        [4]:    jumped
        [5]:    over
        [6]:    the
        [7]:    lazy
        [8]:    dog

After sorting from index 1 to index 3 with the default comparer:
        [0]:    The
        [1]:    BROWN
        [2]:    FOX
        [3]:    QUICK
        [4]:    jumped
        [5]:    over
        [6]:    the
        [7]:    lazy
        [8]:    dog

After sorting from index 1 to index 3 with the reverse case-insensitive comparer:
        [0]:    The
        [1]:    QUICK
        [2]:    FOX
        [3]:    BROWN
        [4]:    jumped
        [5]:    over
        [6]:    the
        [7]:    lazy
        [8]:    dog
*/

Plataforma universal de Windows
Disponible desde 10
.NET Framework
Disponible desde 1.1
Volver al principio
Mostrar: