Pregunta Múltiple "ordenar por" en LINQ


Tengo dos mesas, movies y categoriesy obtengo una lista ordenada por categoria ID primero y luego por Nombre.

La mesa de películas tiene tres columnas, ID, nombre y ID de categoría. La tabla de categoría dos tiene columnas, ID y nombre.

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

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

1380
2017-11-18 13:34


origen


Respuestas:


Esto debería funcionar para usted:

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

2524
2017-11-18 13:41



Usando LINQ no-lambda, query-syntax, puedes hacer esto:

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

[EDITAR para dirigir el comentario] Para controlar el orden de clasificación, use las palabras clave ascending (que es el valor predeterminado y, por lo tanto, no es particularmente útil) o descending, al igual que:

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

550
2017-09-30 14:49



Agrega "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 se muestra a continuación.

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

67
2018-06-22 14:27



utilice la siguiente línea en su DataContext para registrar la actividad de SQL en DataContext en la consola; a continuación, puede ver exactamente lo que sus sentencias de linq están solicitando a 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);

producir el siguiente SQL:

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

Mientras que, repitiendo un OrderBy en Linq, parece invertir el resultado 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 (Name y CategoryId están cambiados):

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

18
2018-02-18 21:03



Hay al menos una forma más de hacerlo utilizando LINQ, aunque no es la más fácil. Puedes hacerlo usando el OrberBy() método que usa una IComparer. Primero necesitas implementar un IComparer Para el Movie clase 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 para descender para uno de los artículos, simplemente cambie la xey dentro del Compare()  método de la MovieComparer en consecuencia.


12
2018-04-03 14:07



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 realizar un pedido por varias 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 dinámicamente el orden, por 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);
        }
    }
}

11
2018-06-08 14:49



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

0
2017-07-17 14:29