Mehrfache "Reihenfolge nach" in LINQ

Question

Ich habe zwei Tabellen, movies y categories und ich möchte eine geordnete Liste erhalten nach categoryID zuerst und dann durch Name .

Die Filmtabelle hat drei Spalten ID, Name und KategorieID . Die Kategorietabelle hat zwei Spalten ID und Name .

Ich habe etwas wie das Folgende versucht, aber es hat nicht funktioniert.

var movies = _db.Movies.OrderBy( m => { m.CategoryID, m.Name })

Answer 1

Das sollte für Sie funktionieren:

var movies = _db.Movies.OrderBy(c => c.Category).ThenBy(n => n.Name)

Answer 2

Mit LINQ ohne Lambda und Abfragesyntax ist dies möglich:

var movies = from row in _db.Movies 
             orderby row.Category, row.Name
             select row;

[EDIT to address comment] Um die Sortierreihenfolge zu kontrollieren, verwenden Sie die Schlüsselwörter ascending (dies ist die Standardeinstellung und daher nicht besonders nützlich) oder descending , etwa so:

var movies = from row in _db.Movies 
             orderby row.Category descending, row.Name
             select row;

Answer 3

Hinzufügen "neu":

var movies = _db.Movies.OrderBy( m => new { m.CategoryID, m.Name })

Das funktioniert bei meiner Box. Es gibt etwas zurück, das zum Sortieren verwendet werden kann. Es gibt ein Objekt mit zwei Werten zurück.

Ähnlich, aber anders als beim Sortieren nach einer kombinierten Spalte, wie folgt.

var movies = _db.Movies.OrderBy( m => (m.CategoryID.ToString() + m.Name))

Answer 4

Verwenden Sie die folgende Zeile in Ihrem DataContext, um die SQL-Aktivität auf dem DataContext in der Konsole zu protokollieren - dann können Sie genau sehen, was Ihre Linq-Anweisungen von der Datenbank anfordern:

_db.Log = Console.Out

Die folgenden LINQ-Anweisungen:

var movies = from row in _db.Movies 
             orderby row.CategoryID, row.Name
             select row;

UND

var movies = _db.Movies.OrderBy(m => m.CategoryID).ThenBy(m => m.Name);

die folgende SQL-Datei erzeugen:

SELECT [t0].ID, [t0].[Name], [t0].CategoryID
FROM [dbo].[Movies] as [t0]
ORDER BY [t0].CategoryID, [t0].[Name]

Die Wiederholung eines OrderBy in Linq hingegen scheint die resultierende SQL-Ausgabe umzukehren:

var movies = from row in _db.Movies 
             orderby row.CategoryID
             orderby row.Name
             select row;

UND

var movies = _db.Movies.OrderBy(m => m.CategoryID).OrderBy(m => m.Name);

folgendes SQL erzeugen (Name und CategoryId sind vertauscht):

SELECT [t0].ID, [t0].[Name], [t0].CategoryID
FROM [dbo].[Movies] as [t0]
ORDER BY [t0].[Name], [t0].CategoryID

Answer 5

Ich habe einige Erweiterungsmethoden erstellt (siehe unten), damit Sie sich nicht darum kümmern müssen, ob eine IQueryable bereits bestellt ist oder nicht. Wenn Sie nach mehreren Eigenschaften sortieren möchten, gehen Sie wie folgt vor:

// We do not have to care if the queryable is already sorted or not. 
// The order of the Smart* calls defines the order priority
queryable.SmartOrderBy(i => i.Property1).SmartOrderByDescending(i => i.Property2);

Dies ist besonders hilfreich, wenn Sie die Reihenfolge dynamisch erstellen, z. B. aus einer Liste von Eigenschaften, die sortiert werden sollen.

public static class IQueryableExtension
{
    public static bool IsOrdered<T>(this IQueryable<T> queryable) {
        if(queryable == null) {
            throw new ArgumentNullException("queryable");
        }

        return queryable.Expression.Type == typeof(IOrderedQueryable<T>);
    }

    public static IQueryable<T> SmartOrderBy<T, TKey>(this IQueryable<T> queryable, Expression<Func<T, TKey>> keySelector) {
        if(queryable.IsOrdered()) {
            var orderedQuery = queryable as IOrderedQueryable<T>;
            return orderedQuery.ThenBy(keySelector);
        } else {
            return queryable.OrderBy(keySelector);
        }
    }

    public static IQueryable<T> SmartOrderByDescending<T, TKey>(this IQueryable<T> queryable, Expression<Func<T, TKey>> keySelector) {
        if(queryable.IsOrdered()) {
            var orderedQuery = queryable as IOrderedQueryable<T>;
            return orderedQuery.ThenByDescending(keySelector);
        } else {
            return queryable.OrderByDescending(keySelector);
        }
    }
}