it-swarm.com.de

Mehrfache "Bestellung von" in LINQ

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

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

Ich habe Folgendes versucht, aber es hat nicht funktioniert.

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

Das sollte für Sie funktionieren:

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

Mit der LINQ-Abfragesyntax ohne Lambda 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 descending, wie folgt:

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

Neue hinzufügen":

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.

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

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

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

erzeugen Sie die folgende SQL (Name und CategoryId werden gewechselt):

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

Ich habe einige Erweiterungsmethoden (siehe unten) erstellt, 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 zu sortierender 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);
        }
    }
}
20
sjkm

Es gibt mindestens eine weitere Möglichkeit, dies mit LINQ zu tun, obwohl dies nicht die einfachste ist. Verwenden Sie dazu die Methode OrberBy(), die ein 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 folgender 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 in der Compare() -Methode von MovieComparer entsprechend.

15
prudentcoder

Wenn Sie ein generisches Repository verwenden

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

else

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