Cómo ordenar una array en C# | Método Array.Sort() | Conjunto – 5

El método Array.Sort se utiliza para ordenar elementos en una array unidimensional. Hay 17 métodos en la lista de sobrecarga de este método. Aquí discutiremos los siguientes métodos:

Ordenar<TKey, TValue>(TKey[], TValue[], IComparer<TKey>) Método

Este método ordena un par de objetos de array en función de las claves de la primera array mediante la interfaz genérica IComparer;T> especificada. Aquí, en las 2 arrays, una contiene las claves y la otra contiene los elementos correspondientes .
 

Sintaxis: public static void Sort<TKey, TValue> (claves TKey[], elementos TValue[], comparador IComparer); 
Aquí, TKey es el tipo de los elementos de la array de claves y TValue el tipo de los elementos de la array de elementos.
Parámetros:  
claves: Es el arreglo unidimensional que contiene las claves a ordenar. 
items: Es el arreglo unidimensional que contiene los items que corresponden a las claves en keys. 
comparer: es la implementación de la interfaz genérica IComparer<T> para usar al comparar elementos. 
 

Excepciones:
 

• ArgumentNullException: si las claves son nulas.
• ArgumentException: si los elementos no son nulos y el límite inferior de las claves no coincide con el límite inferior de los elementos o los elementos no son nulos y la longitud de las claves es mayor que la longitud de los elementos .
• InvalidOperationException: si el comparador es nulo

Ejemplo:
 

// C# program to demonstrate the use of
// Array.Sort<TKey, TValue>(TKey[],
// TValue[], IComparer<TKey>) Method
using System;
using System.Collections.Generic;
 
class compare : IComparer<string> {
 
    public int Compare(string x, string y)
    {
        // Compare x to y
        return x.CompareTo(y);
    }
}
 
// Driver Class
class GFG {
 
    // Main Method
    public static void Main()
    {
        // Initialize two array
        String[] arr1 = { "H", "J", "K",
                   "L", "I", "N", "M" };
 
        String[] arr2 = { "A", "E", "D",
                   "C", "F", "B", "G" };
 
        // Instantiate the IComparer object
        compare g = new compare();
 
        // Display original values of the array
        Console.WriteLine("The original order of"
                    + " elements in the array:");
 
        Display(arr1, arr2);
 
        // Sort the array
        // "arr1" is keys array
        // "arr2" is items array
        // "g" is IComparer<TKey> object
        Array.Sort(arr1, arr2, g);
 
        Console.WriteLine("\nAfter Sorting: ");
        Display(arr1, arr2);
    }
 
    // Display function
    public static void Display(String[] arr1,
                               String[] arr2)
    {
        for (int i = 0; i < arr1.Length; i++)
        {
            Console.WriteLine(arr1[i] + " : " + arr2[i]);
        }
    }
}

The original order of elements in the array:
H : A
J : E
K : D
L : C
I : F
N : B
M : G

After Sorting: 
H : A
I : F
J : E
K : D
L : C
M : G
N : B

Ordenar<TKey, TValue>(TKey[], TValue[], Int32, Int32) Método

Este método se utiliza para ordenar un rango de elementos en un par de objetos de array en función de las claves de la primera array. Aquí, en las 2 arrays, una contiene las claves y la otra contiene los elementos correspondientes .
 

Sintaxis: public static void Sort<TKey, TValue> (claves TKey[], elementos TValue[], comparador IComparer, int index, int len); 
Aquí, TKey es el tipo de los elementos de la array de claves y TValue es el tipo de los elementos de la array de elementos.
Parámetros:  
claves: Es el arreglo unidimensional que contiene las claves a ordenar. 
items: Es el arreglo unidimensional que contiene los items que corresponden a las claves en keys. 
comparer: es la implementación de la interfaz genérica IComparer<T> para usar al comparar elementos. 
índice: Es el índice inicial del rango a ordenar. 
Len:Es el número de elementos en el rango a ordenar. 
 

Excepciones:
 

• ArgumentNullException: si las claves son nulas.
• ArgumentOutOfRangeException: si el índice es menor que el límite inferior de las claves o len es menor que cero.
• ArgumentException: si los elementos no son nulos y el límite inferior de las claves no coincide con el límite inferior de los elementos o los elementos no son nulos y la longitud de las claves es mayor que la longitud de los elementos o el índice y la longitud no especifica un rango válido en keyArray o items no es nulo e index y len no especifican un rango válido en itemsArray .
• InvalidOperationException: cuando uno o más elementos en keysArray no implementan la interfaz genérica IComparable<T> .

Ejemplo:
 

// C# program to demonstrate the use of
// Array.Sort<TKey, TValue>(TKey[], TValue[],
// Int32, Int32) Method
using System;
 
// Driver Class
class GFG {
 
    // Main Method
    public static void Main()
    {
        // Initialize two array
        String[] arr1 = {"H", "J", "K",
                   "L", "I", "M", "N"};
 
        String[] arr2 = {"A", "E", "D",
                   "C", "F", "B", "G"};
 
        // Display original values of the array
        Console.WriteLine("The original order of"
                    + " elements in the array:");
 
        Display(arr1, arr2);
 
        // Sort the array
        // "arr1" is keys array
        // "arr2" is items array
        // start index 1
        // rang upto index 5
        Array.Sort(arr1, arr2, 1, 5);
 
        Console.WriteLine("\nAfter Sorting: ");
        Display(arr1, arr2);
    }
 
    // Display function
    public static void Display(String[] arr1, String[] arr2)
    {
        for (int i = 0; i < arr1.Length; i++)
        {
            Console.WriteLine(arr1[i] + " : " + arr2[i]);
        }
    }
}

The original order of elements in the array:
H : A
J : E
K : D
L : C
I : F
M : B
N : G

After Sorting: 
H : A
I : F
J : E
K : D
L : C
M : B
N : G

Ordenar<TKey, TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Método

Este método se usa para ordenar un rango de elementos en un par de objetos de array en función de las claves de la primera array mediante la interfaz genérica IComparer<T> especificada . Aquí, en las 2 arrays, una contiene las claves y la otra contiene los elementos correspondientes .
 

Sintaxis: public static void Sort<TKey,TValue> (TKey[] claves, TValue[] elementos, int index, int len, IComparer<TKey> comparador);

Parámetros:  
claves: Es el arreglo unidimensional que contiene las claves a ordenar. 
items: Es el arreglo unidimensional que contiene los items que corresponden a las claves en keys. 
comparer: es la implementación de la interfaz genérica IComparer<T> para usar al comparar elementos. 
índice: Es el índice inicial del rango a ordenar. 
len: Es el número de elementos del rango a ordenar. 
comparer: es la implementación de la interfaz genérica IComparer<T> para usar al comparar elementos. 
 

Excepciones:
 

• ArgumentNullException: si las claves son nulas.
• ArgumentOutOfRangeException: si el índice es menor que el límite inferior de las claves o len es menor que cero.
•  
• ArgumentException: si los elementos no son nulos y el límite inferior de las claves no coincide con el límite inferior de los elementos o los elementos no son nulos y la longitud de las claves es mayor que la longitud de los elementos o el índice y la longitud no especifican un rango válido en el keysArray o items no es nulo e index y len no especifican un rango válido en itemsArray o la implementación del comparador provocó un error durante la ordenación.
   
• InvalidOperationException: cuando uno o más elementos en keysArray no implementan la interfaz genérica IComparable<T> .

Ejemplo:
 

// C# program to demonstrate the use of
// Array.Sort<TKey, TValue>(TKey[], TValue[],
// Int32, Int32, IComparer<TKey>) Method
using System;
using System.Collections.Generic;
 
class compare : IComparer<string> {
 
    public int Compare(string x, string y)
    {
        // Compare x to y
        return x.CompareTo(y);
    }
}
 
// Driver Class
class GFG {
 
    // Main Method
    public static void Main()
    {
        // Initialize two array
        String[] arr1 = {"H", "J", "K",
                   "L", "I", "M", "N"};
 
        String[] arr2 = {"A", "E", "D",
                   "C", "F", "B", "G"};
 
        // Instantiate the IComparer object
        compare g = new compare();
 
        // Display original values of the array
        Console.WriteLine("The original order of"
                    + " elements in the array:");
 
        Display(arr1, arr2);
 
        // Sort the array
        // "arr1" is keys array
        // "arr2" is items array
        // "g" is IComparer<TKey> object
        // start index 1
        // rang upto index 5
        Array.Sort(arr1, arr2, 1, 5, g);
 
        Console.WriteLine("\nAfter Sorting: ");
        Display(arr1, arr2);
    }
 
    // Display function
    public static void Display(String[] arr1, String[] arr2)
    {
        for (int i = 0; i < arr1.Length; i++)
        {
            Console.WriteLine(arr1[i] + " : " + arr2[i]);
        }
    }
}

The original order of elements in the array:
H : A
J : E
K : D
L : C
I : F
M : B
N : G

After Sorting: 
H : A
I : F
J : E
K : D
L : C
M : B
N : G

Referencia: 
 

• https://docs.microsoft.com/en-us/dotnet/api/system.array.sort?view=netframework-4.7.2