Mehrfache "Bestellung von" in LINQ

Ich habe zwei Tabellen moviesund categoriesund erhalte zuerst eine geordnete Liste nach Kategorie- ID und dann nach Name .

Die Filmtabelle enthält drei Spalten: ID, Name und CategoryID . Die Kategorietabelle hat zwei Spalten ID und Name .

Ich habe Folgendes versucht, aber es hat nicht funktioniert.

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

Dies sollte für Sie funktionieren:

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

Mit der Nicht-Lambda-Abfragesyntax LINQ können Sie Folgendes tun:

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

[BEARBEITEN, um Kommentar zu adressieren] Um die Sortierreihenfolge zu steuern, verwenden Sie die Schlüsselwörter ascending(dies ist die Standardeinstellung und daher nicht besonders nützlich) oder descendingwie folgt :

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

Neue hinzufügen":

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

Das funktioniert auf 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))

Verwenden Sie die folgende Zeile in Ihrem DataContext, um die SQL-Aktivität im 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);

Erstellen Sie die folgende SQL:

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

Während das Wiederholen eines OrderBy in Linq die resultierende SQL-Ausgabe umzukehren scheint:

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);

Erstellen Sie die folgende SQL (Name und CategoryId werden umgeschaltet):

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

Ich habe einige Erweiterungsmethoden erstellt (siehe unten), damit Sie sich keine Sorgen machen müssen, ob ein IQueryable bereits bestellt wurde oder nicht. Wenn Sie nach mehreren Eigenschaften bestellen 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 zu sortierenden Eigenschaften.

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

Es gibt mindestens eine weitere Möglichkeit, dies mit LINQ zu tun, obwohl dies nicht die einfachste ist. Sie können dies mit der OrberBy()Methode tun , die ein verwendet IComparer. Zuerst müssen Sie eine IComparerfür die MovieKlasse wie folgt implementieren :

public class MovieComparer : IComparer<Movie>
{
    public int Compare(Movie x, Movie y)
    {
        if (x.CategoryId == y.CategoryId)
        {
            return x.Name.CompareTo(y.Name);
        }
        else
        {
            return x.CategoryId.CompareTo(y.CategoryId);
        }
    }
}

Dann können Sie die Filme mit der folgenden Syntax bestellen:

var movies = _db.Movies.OrderBy(item => item, new MovieComparer());

Wenn Sie die Reihenfolge für eines der Elemente auf absteigend ändern müssen, ändern Sie einfach das x und y innerhalb der Compare() Methode des MovieComparer.

Wenn Sie ein generisches Repository verwenden

> lstModule = _ModuleRepository.GetAll().OrderBy(x => new { x.Level,
> x.Rank}).ToList();

sonst

> _db.Module.Where(x=> ......).OrderBy(x => new { x.Level, x.Rank}).ToList();