Wielokrotne „zamówienie przez” w LINQ

Mam dwie tabele moviesi najpierw categoriesotrzymuję uporządkowaną listę według kategorii ID, a następnie Nazwy .

Tabela filmów ma trzy kolumny Identyfikator, Nazwa i ID kategorii . Tabela kategorii ma dwie kolumny Identyfikator i Nazwa .

Próbowałem czegoś takiego, ale to nie zadziałało.

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

To powinno Ci pomóc:

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

Używając LINQ innej niż lambda, składni zapytania, możesz to zrobić:

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

[EDYCJA, aby skomentować komentarz] Aby kontrolować porządek sortowania, użyj słów kluczowych ascending(które są domyślne i dlatego nie są szczególnie przydatne) lub descending, w ten sposób:

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

Dodaj nowe":

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

To działa na moim pudełku. Zwraca coś, co można wykorzystać do sortowania. Zwraca obiekt o dwóch wartościach.

Podobne, ale inne niż sortowanie według połączonej kolumny, jak następuje.

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

użyj następującego wiersza w DataContext, aby zarejestrować działanie SQL w DataContext w konsoli - wtedy możesz zobaczyć dokładnie, czego żądają twoje instrukcje linq z bazy danych:

_db.Log = Console.Out

Następujące instrukcje LINQ:

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

I

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

utworzyć następujący kod SQL:

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

Podczas gdy powtarzanie OrderBy w Linq wydaje się odwracać wynikowy wynik SQL:

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

I

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

utworzyć następujący kod SQL (nazwy i identyfikator kategorii są przełączane):

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

Stworzyłem kilka metod rozszerzenia (poniżej), więc nie musisz się martwić, czy IQueryable jest już zamówiony, czy nie. Jeśli chcesz zamówić według wielu właściwości, zrób to w następujący sposób:

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

Jest to szczególnie przydatne, jeśli tworzysz porządek dynamicznie, np. Z listy właściwości do sortowania.

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

Jest co najmniej jeden sposób, aby to zrobić za pomocą LINQ, choć nie najłatwiejszy. Możesz to zrobić przy użyciu OrberBy()metody wykorzystującej IComparer. Najpierw musisz zaimplementować IComparerdla takiej Movieklasy:

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

Następnie możesz zamówić filmy o następującej składni:

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

Jeśli chcesz zmienić kolejność na malejącą dla jednego z elementów, po prostu przełącz xiy wewnątrz Compare() metody MovieComparerodpowiednio.

Jeśli używasz ogólnego repozytorium

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

jeszcze

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