Múltiple "ordenar por" en LINQ

Tengo dos tablas moviesy primero categoriesobtengo una lista ordenada por Id. De categoría y luego por Nombre .

La tabla de películas tiene tres columnas ID, Name y CategoryID . La tabla de categorías tiene dos columnas ID y Nombre .

Intenté algo como lo siguiente, pero no funcionó.

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

Esto debería funcionar para usted:

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

Usando LINQ sintaxis de consulta-sintaxis, puede hacer esto:

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

[EDITAR para abordar el comentario] Para controlar el orden de clasificación, use las palabras clave ascending(que es la predeterminada y, por lo tanto, no es particularmente útil) o descending, de esta manera:

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

Añadir "nuevo":

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

Eso funciona en mi caja. Devuelve algo que se puede usar para ordenar. Devuelve un objeto con dos valores.

Similar, pero diferente a ordenar por una columna combinada, como sigue.

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

use la siguiente línea en su DataContext para registrar la actividad de SQL en el DataContext en la consola; luego podrá ver exactamente lo que sus declaraciones linq solicitan de la base de datos:

_db.Log = Console.Out

Las siguientes declaraciones de LINQ:

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

Y

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

producir el siguiente SQL:

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

Mientras que, al repetir un OrderBy en Linq, parece revertir la salida SQL resultante:

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

Y

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

producir el siguiente SQL (se cambian Name y CategoryId):

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

He creado algunos métodos de extensión (a continuación) para que no tenga que preocuparse si un IQueryable ya está ordenado o no. Si desea ordenar por múltiples propiedades, simplemente hágalo de la siguiente manera:

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

Esto es especialmente útil si crea el orden dinámicamente, por ejemplo, desde una lista de propiedades para ordenar.

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

Hay al menos una forma más de hacer esto usando LINQ, aunque no es la más fácil. Puede hacerlo usando el OrberBy()método que usa un IComparer. Primero debe implementar un IComparerpara la Movieclase 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);
        }
    }
}

Luego puede ordenar las películas con la siguiente sintaxis:

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

Si necesita cambiar el orden a descendente para uno de los elementos, simplemente cambie las x e y dentro del Compare() método MovieComparercorrespondiente.

Si usa repositorio genérico

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

más

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