OrderByDescending(TSource, TKey) Metodo (IQueryable(TSource), Expression(Func(TSource, TKey)), IComparer(TKey))
Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo Queryable.OrderByDescending<TSource, TKey>(IQueryable<TSource>, Expression<Func<TSource, TKey>>, IComparer<TKey>)

 

Ordina in senso decrescente gli elementi di una sequenza utilizzando un operatore di confronto specificato.

Spazio dei nomi:   System.Linq
Assembly:  System.Core (in System.Core.dll)

public static IOrderedQueryable<TSource> OrderByDescending<TSource, TKey>(
	this IQueryable<TSource> source,
	Expression<Func<TSource, TKey>> keySelector,
	IComparer<TKey> comparer
)

Parametri

source

Sequenza di valori da ordinare.

keySelector

Funzione per estrarre una chiave da un elemento.

comparer

Oggetto IComparer<T> per confrontare le chiavi.

Valore restituito

Type: System.Linq.IOrderedQueryable<TSource>

Oggetto IOrderedQueryable<T> i cui elementi vengono ordinati in senso decrescente in base a una chiave.

Parametri di tipo

TSource

Tipo degli elementi di source.

TKey

Tipo della chiave restituita dalla funzione rappresentata dall'oggetto keySelector.

Exception Condition
ArgumentNullException

source o keySelector o comparer è null.

Nel metodo è presente almeno un parametro di tipo Expression<TDelegate> il cui argomento di tipo è costituito da uno dei tipi Func<T, TResult>.Per questi parametri è possibile passare un'espressione lambda che verrà compilata in un oggetto Expression<TDelegate>.

Il metodo OrderByDescending<TSource, TKey>(IQueryable<TSource>, Expression<Func<TSource, TKey>>, IComparer<TKey>) genera un oggetto MethodCallExpression che rappresenta una chiamata al metodo OrderByDescending<TSource, TKey>(IQueryable<TSource>, Expression<Func<TSource, TKey>>, IComparer<TKey>) stesso come un metodo generico costruito.Passa quindi un oggetto MethodCallExpression al metodo CreateQuery<TElement>(Expression) di IQueryProvider rappresentato dalla proprietà Provider del parametro source.Viene eseguito il cast del risultato della chiamata a CreateQuery<TElement>(Expression) nel tipo IOrderedQueryable<T>, quindi viene restituito il risultato.

Il comportamento della query conseguente all'esecuzione di una struttura ad albero dell'espressione che rappresenta una chiamata a OrderByDescending<TSource, TKey>(IQueryable<TSource>, Expression<Func<TSource, TKey>>, IComparer<TKey>) dipende dall'implementazione del tipo del parametro source.In base al comportamento previsto, vengono ordinati in senso decrescente gli elementi di source, in base alla chiave ottenuta richiamando keySelector su ogni elemento di source.Il parametro comparer viene utilizzato per confrontare gli elementi.

Nell'esempio di codice riportato di seguito viene illustrato come utilizzare OrderByDescending<TSource, TKey>(IQueryable<TSource>, Expression<Func<TSource, TKey>>, IComparer<TKey>) per ordinare in ordine decrescente gli elementi di una sequenza utilizzando un operatore di confronto personalizzato.

/// <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 };

    // Sort the decimal values in descending order
    // by using a custom comparer.
    IEnumerable<decimal> query =
        decimals.AsQueryable()
        .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
*/

Universal Windows Platform
Disponibile da 4.5
.NET Framework
Disponibile da 3.5
Portable Class Library
Supportato in: portable .NET platforms
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.1
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra:
© 2016 Microsoft