Múltiple "ordenar por" en LINQ

Question

Tengo dos tablas, películas y categories , y primero obtengo una lista ordenada por categoryID y luego por Nombre .

La tabla de películas tiene tres columnas, ID, Nombre e Id. de categoría . La tabla de categorías dos tiene columnas, ID y Nombre .

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

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

Answer 1

Esto debería funcionar para usted:

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

Answer 2

Utilizando 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 ascendente (que es el valor predeterminado y, por lo tanto, no es particularmente útil) o descendente , así:

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

Answer 3

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 de ordenar por una columna combinada, como sigue.

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

Answer 4

use la siguiente línea en su DataContext para registrar la actividad 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 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);

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

produce 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

Answer 5

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 pedido de forma dinámica, p. ej. de 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);
        }
    }
}

Answer 6

Hay al menos una forma más de hacer esto usando LINQ, aunque no es la más fácil. Puede hacerlo utilizando el método OrberBy () que utiliza un IComparer . Primero necesitas implementar un IComparer para la clase Movie como esta:

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 de Compare () método del MovieComparer en consecuencia.

Answer 7

Si usa un 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();