Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Enumerable.OrderByDescending<TSource, TKey> méthode (IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>)

 

Date de publication : novembre 2016

Trie les éléments d'une séquence dans l'ordre décroissant à l'aide d'un comparateur spécifié.

Espace de noms:   System.Linq
Assembly:  System.Core (dans System.Core.dll)

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

Paramètres

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

Séquence de valeurs à classer.

keySelector
Type: System.Func<TSource, TKey>

Fonction permettant d'extraire une clé d'un élément.

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

Un IComparer<T> pour comparer les clés.

Valeur de retour

Type: System.Linq.IOrderedEnumerable<TSource>

Une IOrderedEnumerable<TElement> dont les éléments sont triés dans l’ordre décroissant selon une clé.

Paramètres de type

TSource

Le type des éléments de source.

TKey

Le type de la clé retournée par keySelector.

Exception Condition
ArgumentNullException

source ou keySelector a la valeur null.

Cette méthode est implémentée à l’aide de l’exécution différée. L’exécution valeur de retour est un objet qui stocke toutes les informations qui sont requis pour effectuer l’action. La requête représentée par cette méthode n’est pas exécutée tant que l’objet est énumérée en appelant son GetEnumerator méthode directement ou à l’aide de foreach dans Visual C# ou For Each dans Visual Basic.

Pour classer une séquence selon les valeurs des éléments mêmes, spécifiez la fonction identity (x => x dans Visual C# ou Function(x) x dans Visual Basic) pour keySelector.

Deux méthodes sont définies pour étendre le type IOrderedEnumerable<TElement>, qui est le type de retour de cette méthode. Ces deux méthodes, à savoir ThenBy et ThenByDescending, vous pouvez spécifier des critères de tri supplémentaires pour trier une séquence. ThenBy et ThenByDescending également retourner un IOrderedEnumerable<TElement>, ce qui signifie que n’importe quel nombre d’appels consécutifs de ThenBy ou ThenByDescending peuvent être effectuées.

System_CAPS_noteRemarque

Étant donné que IOrderedEnumerable<TElement> hérite IEnumerable<T>, vous pouvez appeler OrderBy ou OrderByDescending sur les résultats d’un appel à OrderBy, OrderByDescending, ThenBy ou ThenByDescending. Cela introduit un nouveau classement principal qui ignore le classement établie précédemment.

Si comparer est null, le comparateur par défaut Default est utilisé pour comparer les clés.

Cette méthode effectue un tri stable. Autrement dit, si les clés de deux éléments sont égaux, l’ordre des éléments est conservé. En revanche, un tri instable ne conserve pas l’ordre des éléments qui ont la même clé.

L’exemple de code suivant montre comment utiliser OrderByDescending<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>) pour trier les éléments d’une séquence dans l’ordre décroissant à l’aide d’une fonction de transformation et d’un comparateur personnalisé.

/// <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
*/

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 3.5
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 2.0
Silverlight pour Windows Phone
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1
Retour au début
Afficher: