multiple - Múltiple "orden por" en LINQ

order by list c# desc

Question

Tengo dos tablas, movies y categories , y primero obtengo una lista ordenada por categoryID y luego por Name .

La tabla de películas tiene tres columnas, ID, Nombre y CategoryID . 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

Añadir "nuevo":

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

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

Similar, pero diferente a la clasificación por una columna combinada, como sigue.

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

Answer 2

Esto debería funcionar para usted:

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

Answer 3

Hay al menos una forma más de hacerlo utilizando LINQ, aunque no es la más fácil. Puedes hacerlo usando el método OrberBy() que usa un IComparer . Primero necesitas implementar un IComparer para la clase de Movie 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 puedes ordenar las películas con la siguiente sintaxis:

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

Si necesita cambiar el orden para descender para uno de los elementos, simplemente cambie las x y y dentro del método Compare() de MovieComparer consecuencia.

Answer 4

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, 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, fe 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 5

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

Answer 6

Utilizando non-lambda, LINQ de sintaxis de consulta, 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 opción predeterminada y, por lo tanto, no es particularmente útil) o descending , así:

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

Answer 7

use la siguiente línea en su DataContext para registrar la actividad de SQL en el DataContext en la consola; luego puede ver exactamente lo que sus declaraciones de linq solicitan desde 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 (nombre y CategoryId se cambian):

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