Mehrere „order by“ in LINQ

Question

Ich habe zwei Tabellen, movies und categories, und ich bekomme eine geordnete Liste von categoryID und dann von Name .

Der Film Tabelle hat drei Spalten, ID, Name und CategoryID . Die Kategorie-Tabelle zwei Spalten hat, ID und Namen .

Ich habe versucht, so etwas wie die folgenden, aber es hat nicht funktioniert.

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

Answer 1

Dies sollte für Sie arbeiten:

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

Answer 2

Die Verwendung von nicht-lambda, Abfrage-Syntax LINQ, Sie können dies tun:

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

[EDIT-Adresse Kommentar] Um die Sortierreihenfolge zu steuern, verwenden Sie die Schlüsselwörter ascending (was der Standard ist 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

Fügen Sie "neu":

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

Das funktioniert auf meinem Feld. Es zurückkehrt etwas, das verwendet werden kann, zu sortieren. Es gibt ein Objekt mit zwei Werten.

ähnlicher, aber anders durch eine kombinierte Spalte zu sortieren, wie folgt.

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

Answer 4

verwenden Sie die folgende Zeile auf Ihrem Datacontext die SQL-Aktivität auf der Datacontext an die Konsole anzumelden - dann können Sie genau sehen, was Ihre Linq Aussagen aus 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);

erzeugt die folgenden SQL:

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

Während eine OrderBy in Linq zu wiederholen, wird die resultierende SQL-Ausgang umgekehrt:

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

erzeugen die folgenden SQL (Name und CategoryId sind eingeschaltet):

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

Answer 5

Ich habe einige Erweiterungsmethoden (unten) erstellt, so dass Sie sich keine Sorgen machen, wenn ein IQueryable bereits bestellt ist oder nicht. Wenn Sie durch mehrere Eigenschaften bestellen möchten tun Sie es einfach wie folgt:

// 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 Bestellung dynamisch erstellen, F. E. aus einer Liste von Eigenschaften zu sortieren.

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

Answer 6

Es gibt mindestens eine weitere Möglichkeit, dies mit LINQ zu tun, wenn auch nicht die einfachste. Sie können es tun, indem Sie die OrberBy()-Methode, die eine IComparer verwendet. Zuerst müssen Sie eine IComparer für die Movie Klasse 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 folgenden Syntax bestellen:

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

Wenn Sie die Bestellung zu absteigend für eines der Elemente wechseln müssen wechseln nur die x- und y innerhalb des Compare() Verfahren der MovieComparer entsprechend.

Answer 7

Wenn die Verwendung generische Repository

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

sonst

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