Frage Mehrere "Bestellung von" in LINQ


Ich habe zwei Tische, movies und categoriesund ich bekomme eine geordnete Liste von Kategorie ID zuerst und dann durch Name.

Der Filmtisch hat drei Spalten, ID, Name und KategorieID. Die Kategorietabelle zwei hat 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 })

1380
2017-11-18 13:34


Ursprung


Antworten:


Dies sollte für Sie funktionieren:

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

2524
2017-11-18 13:41



Mit Nicht-Lambda, Abfragesyntax LINQ, können Sie dies tun:

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

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

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

550
2017-09-30 14:49



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 das Sortieren nach einer kombinierten Spalte, wie folgt.

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

67
2018-06-22 14:27



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

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

erzeuge die folgende SQL (Name und CategoryId sind geschaltet):

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

18
2018-02-18 21:03



Es gibt mindestens eine weitere Möglichkeit, dies mithilfe von LINQ zu tun, obwohl dies nicht der einfachste ist. Sie können es tun, indem Sie die OrberBy() Methode, die ein verwendet IComparer. Zuerst müssen Sie implementieren ein IComparer für die Movie Klasse wie folgt:

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 folgender Syntax bestellen:

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

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


12
2018-04-03 14:07



Ich habe einige Erweiterungsmethoden (unten) erstellt, so dass Sie sich keine Sorgen machen müssen, wenn ein IQueryable bereits bestellt ist oder nicht. Wenn Sie nach mehreren Eigenschaften sortieren 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, z. 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);
        }
    }
}

11
2018-06-08 14:49



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

0
2017-07-17 14:29