Вопрос: Множественный «порядок по» в LINQ


У меня есть две таблицы, moviesа также categories, и я получаю упорядоченный список CategoryId сначала, а затем имя ,

В таблице фильмов есть три столбца, ID, Name и CategoryID , В таблице категории 2 есть столбцы, ID и имя ,

Я попробовал что-то вроде следующего, но это не сработало.

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

1369


источник


Ответы:


Это должно сработать для вас:

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

2499



Используя не-лямбда-запрос-синтаксис LINQ, вы можете сделать это:

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

[EDIT для отправки комментария] Для управления порядком сортировки используйте ключевые слова ascending(который является значением по умолчанию и, следовательно, не особенно полезным) или descending, вот так:

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

549



Добавить новое":

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

Это работает на моей коробке. Он возвращает то, что можно использовать для сортировки. Он возвращает объект с двумя значениями.

Аналогично, но отличается от сортировки по комбинированной колонке следующим образом.

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

66



use the following line on your DataContext to log the SQL activity on the DataContext to the console - then you can see exactly what your linq statements are requesting from the database:

_db.Log = Console.Out

The following LINQ statements:

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

AND

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

produce the following SQL:

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

Whereas, repeating an OrderBy in Linq, appears to reverse the resulting SQL output:

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

AND

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

produce the following SQL (Name and CategoryId are switched):

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

17



There is at least one more way to do this using LINQ, although not the easiest. You can do it by using the OrberBy() method that uses an IComparer. First you need to implement an IComparer for the Movie class like this:

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

Then you can order the movies with the following syntax:

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

If you need to switch the ordering to descending for one of the items just switch the x and y inside the Compare() method of the MovieComparer accordingly.


12



I have created some extension methods (below) so you don't have to worry if an IQueryable is already ordered or not. If you want to order by multiple properties just do it as follows:

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

This is especially helpful if you create the ordering dynamically, f.e. from a list of properties to sort.

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