Múltiplo "ordenar por" no LINQ

Tenho duas tabelas moviese categoriesrecebo uma lista ordenada por categoryID primeiro e depois por Name .

A tabela de filmes possui três IDs de colunas , Nome e ID da categoria . A tabela de categorias possui duas colunas ID e Nome .

Tentei algo como o seguinte, mas não funcionou.

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

Isso deve funcionar para você:

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

Usando LINQ não-lambda, sintaxe de consulta, você pode fazer isso:

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

[EDITAR para endereçar o comentário] Para controlar a ordem de classificação, use as palavras-chave ascending(que é o padrão e, portanto, não são particularmente úteis) ou descending, assim:

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

Adicionar novo":

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

Isso funciona na minha caixa. Ele retorna algo que pode ser usado para classificar. Retorna um objeto com dois valores.

Semelhante, mas diferente da classificação por uma coluna combinada, a seguir.

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

use a seguinte linha em seu DataContext para registrar a atividade SQL no DataContext no console - para poder ver exatamente o que suas instruções linq estão solicitando no banco de dados:

_db.Log = Console.Out

As seguintes instruções LINQ:

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

E

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

produza o seguinte SQL:

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

Considerando que, repetir um OrderBy no Linq, parece inverter a saída SQL resultante:

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

E

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

produza o seguinte SQL (Name e CategoryId são alternados):

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

Eu criei alguns métodos de extensão (abaixo) para que você não precise se preocupar se um IQueryable já está encomendado ou não. Se você deseja solicitar por várias propriedades, faça o seguinte:

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

Isso é especialmente útil se você criar a ordem dinamicamente, fe a partir de uma lista de propriedades para classificar.

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

Há pelo menos mais uma maneira de fazer isso usando o LINQ, embora não seja o mais fácil. Você pode fazer isso usando o OrberBy()método que usa um IComparer. Primeiro você precisa implementar um IComparerpara a Movieclasse como este:

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

Depois, você pode solicitar os filmes com a seguinte sintaxe:

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

Se você precisar alterar a ordem para decrescente para um dos itens, basta alternar x e y dentro do Compare() método correspondente MovieComparer.

Se usar repositório genérico

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

outro

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