“Order by” Multiple em LINQ

Question

Eu tenho duas tabelas, movies e categories, e eu recebo uma lista ordenada por categoryID em primeiro lugar e, em seguida, por Nome .

A tabela filme tem três colunas, ID, Nome e CódigoDaCategoria . A tabela a categoria dois tem colunas, ID e nome .

Eu tentei algo como o seguinte, mas não funcionou.

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

Answer 1

Isso deve funcionar para você:

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

Answer 2

Usando non-lambda, consulta de sintaxe LINQ, você pode fazer isso:

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

[EDIT ao comentário endereço] Para controlar a ordem de classificação, use o ascending palavras-chave (que é o padrão e, portanto, não particularmente útil) ou descending, assim:

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

Answer 3

Adicionar "novo":

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

que funciona em minha caixa. Ele faz retorno algo que pode ser usado para classificar. Ele retorna um objeto com dois valores.

semelhante, mas diferente de triagem por uma coluna combinada, como se segue.

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

Answer 4

use a seguinte linha em seu DataContext para registrar a atividade SQL no DataContext para o console - então você pode ver exatamente o que as suas declarações LINQ está solicitando a partir do banco de dados:

_db.Log = Console.Out

As seguintes declaraçõ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);

produzir a seguinte SQL:

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

Considerando que, repetindo um OrderBy em 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);

produzir a seguinte SQL (nome e CategoryId são trocados):

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

Answer 5

Eu criei alguns métodos de extensão (abaixo), assim você não precisa se preocupar se um IQueryable já está ordenada ou não. Se você quiser encomendar por várias propriedades apenas fazê-lo da seguinte forma:

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

Isto é especialmente útil se você criar a ordenação de forma dinâmica, F. E. 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);
        }
    }
}

Answer 6

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

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

Em seguida, você pode encomendar os filmes com a seguinte sintaxe:

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

Se você precisa mudar a ordenação para descendente de um dos itens basta mudar o x e y dentro da Compare() método do MovieComparer em conformidade.

Answer 7

Se o uso repositório genérico

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

else

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