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 Enumerable.OrderByDescending<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>)

 

Publicado: octubre de 2016

Ordena de manera descendente los elementos de una secuencia utilizando un comparador especificado.

Espacio de nombres:   System.Linq
Ensamblado:  System.Core (en System.Core.dll)

public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(
	this IEnumerable<TSource> source,
	Func<TSource, TKey> keySelector,
	IComparer<TKey> comparer
)

Parámetros

source
Type: System.Collections.Generic.IEnumerable<TSource>

Secuencia de valores que se va a ordenar.

keySelector
Type: System.Func<TSource, TKey>

Función para extraer una clave a partir de un elemento.

comparer
Type: System.Collections.Generic.IComparer<TKey>

IComparer<T> para comparar claves.

Valor devuelto

Type: System.Linq.IOrderedEnumerable<TSource>

Una IOrderedEnumerable<TElement> cuyos elementos se ordenan en orden descendente según una clave.

Parámetros de tipo

TSource

Tipo de los elementos de source.

TKey

Tipo de la clave devuelta por keySelector.

Exception Condition
ArgumentNullException

El valor de source o keySelector es null.

Este método se implementa mediante la ejecución diferida. El valor devuelto inmediato es un objeto que almacena toda la información necesaria para realizar la acción. La consulta representada por este método no se ejecuta hasta que se enumera el objeto llamando a su GetEnumerator método directamente o mediante foreach en Visual C# o For Each en Visual Basic.

Para ordenar una secuencia por los valores de los propios elementos, especifique la función identity (x => x en Visual C# o Function(x) x en Visual Basic) para keySelector.

Se definen dos métodos para extender el tipo IOrderedEnumerable<TElement>, que es el tipo de valor devuelto de este método. Estos dos métodos, es decir, ThenBy y ThenByDescending, permiten especificar criterios de ordenación adicionales para ordenar una secuencia. ThenBy y ThenByDescending también devuelven un IOrderedEnumerable<TElement>, lo que significa que cualquier número de llamadas consecutivas para ThenBy o ThenByDescending pueden realizarse.

System_CAPS_noteNota

Porque IOrderedEnumerable<TElement> hereda de IEnumerable<T>, puede llamar a OrderBy o OrderByDescending en los resultados de una llamada a OrderBy, OrderByDescending, ThenBy o ThenByDescending. Esto presenta un nuevo orden primario que hace caso omiso del orden establecido previamente.

Si comparer es null, el comparador predeterminado Default se utiliza para comparar claves.

Este método realiza a una ordenación estable; es decir, si las claves de dos elementos son iguales, se conserva el orden de los elementos. Por el contrario, una ordenación inestable no conserva el orden de los elementos que tienen la misma clave.

En el ejemplo de código siguiente se muestra cómo utilizar OrderByDescending<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>) para ordenar los elementos de una secuencia en orden descendente mediante una función de transformación y un comparador personalizado.

/// <summary>
/// This IComparer class sorts by the fractional part of the decimal number.
/// </summary>
public class SpecialComparer : IComparer<decimal>
{
    /// <summary>
    /// Compare two decimal numbers by their fractional parts.
    /// </summary>
    /// <param name="d1">The first decimal to compare.</param>
    /// <param name="d2">The second decimal to compare.</param>
    /// <returns>1 if the first decimal's fractional part 
    /// is greater than the second decimal's fractional part,
    /// -1 if the first decimal's fractional
    /// part is less than the second decimal's fractional part,
    /// or the result of calling Decimal.Compare()
    /// if the fractional parts are equal.</returns>
    public int Compare(decimal d1, decimal d2)
    {
        decimal fractional1, fractional2;

        // Get the fractional part of the first number.
        try
        {
            fractional1 = decimal.Remainder(d1, decimal.Floor(d1));
        }
        catch (DivideByZeroException)
        {
            fractional1 = d1;
        }
        // Get the fractional part of the second number.
        try
        {
            fractional2 = decimal.Remainder(d2, decimal.Floor(d2));
        }
        catch (DivideByZeroException)
        {
            fractional2 = d2;
        }

        if (fractional1 == fractional2)
            return Decimal.Compare(d1, d2);
        else if (fractional1 > fractional2)
            return 1;
        else
            return -1;
    }
}

public static void OrderByDescendingEx1()
{
    List<decimal> decimals =
        new List<decimal> { 6.2m, 8.3m, 0.5m, 1.3m, 6.3m, 9.7m };

    IEnumerable<decimal> query =
        decimals.OrderByDescending(num =>
                                       num, new SpecialComparer());

    foreach (decimal num in query)
    {
        Console.WriteLine(num);
    }
}

/*
 This code produces the following output:

 9.7
 0.5
 8.3
 6.3
 1.3
 6.2
*/

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 3.5
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: