¿Cómo puedo hacer un OrderBy con un parámetro de cadena dinámico?

Question

Quiero hacer esto:

var orderBy = "Nome, Cognome desc"; 

var timb = time.Timbratures.Include("Anagrafica_Dipendente") 
    .Where(p => p.CodDipendente == 1); 

if(orderBy != "") 
    timb = timb.OrderBy(orderBy); 

¿Hay una sobrecarga OrderBy disponibles que acepta un parámetro de cadena?

Answer 1

Absolutamente. Puede usar la Biblioteca de consultas dinámicas LINQ, que se encuentra on Scott Guthrie's blog. También hay una versión actualizada disponible on CodePlex.

Le permite crear OrderBy cláusulas, Where cláusulas, y casi todo lo demás al pasar en parámetros de cadena. Funciona muy bien para la creación de código genérico para la clasificación/filtrado de rejillas, etc.

var result = data 
    .Where(/* ... */) 
    .Select(/* ... */) 
    .OrderBy("Foo asc"); 

var query = DbContext.Data 
    .Where(/* ... */) 
    .Select(/* ... */) 
    .OrderBy("Foo ascending"); 

Answer 2

Es necesario utilizar la biblioteca de consultas LINQ Dynamic con el fin de pasar parámetros en tiempo de ejecución,

Esto permitirá que las declaraciones de LINQ como

string orderedBy = "Description"; 
var query = (from p in products 
      orderby(orderedBy) 
      select p); 

Answer 3

Mira en este blog here. Describe una forma de hacerlo, definiendo un EntitySorter<T>.

Se permite pasar en una IEntitySorter<T> en sus métodos de servicio y utilizar de esta manera:

public static Person[] GetAllPersons(IEntitySorter<Person> sorter) 
{ 
    using (var db = ContextFactory.CreateContext()) 
    { 
     IOrderedQueryable<Person> sortedList = sorter.Sort(db.Persons); 

     return sortedList.ToArray(); 
    } 
} 

Además, puede crear un EntitiySorter así:

IEntitySorter<Person> sorter = EntitySorter<Person> 
    .OrderBy(p => p.Name) 
    .ThenByDescending(p => p.Id); 

O así:

var sorter = EntitySorter<Person> 
    .OrderByDescending("Address.City") 
    .ThenBy("Id"); 

Answer 4

Si está utilizando LINQ-to-objects y no quiere Para tomar una dependencia de una biblioteca externa, no es difícil lograr lo que desea.

La cláusula OrderBy() acepta un Func<TSource, TKey> que obtiene una clave de clasificación de un elemento de origen. Se puede definir la función fuera de la OrderBy() cláusula:

Func<Item, Object> orderByFunc = null; 

A continuación, puede asignar a diferentes valores en función de los criterios de clasificación:

if (sortOrder == SortOrder.SortByName) 
    orderByFunc = item => item.Name; 
else if (sortOrder == SortOrder.SortByRank) 
    orderByFunc = item => item.Rank; 

A continuación, se puede ordenar:

var sortedItems = items.OrderBy(orderByFunc); 

Este ejemplo asume que el tipo de fuente es Item que tiene las propiedades Name y Rank.

Tenga en cuenta que en este ejemplo TKey es Object para no restringir los tipos de propiedades que se pueden ordenar. Si el func devuelve un tipo de valor (como Int32), se colocará en un recuadro al ordenar y eso es algo ineficaz. Si puede restringir TKey a un tipo de valor específico, puede evitar este problema.

Answer 5

Otra solución de codeConcussion (https://stackoverflow.com/a/7265394/2793768)

var param = "Address";  
var pi = typeof(Student).GetProperty(param);  
var orderByAddress = items.OrderBy(x => pi.GetValue(x, null)); 

Answer 6

El más simple & la mejor solución:

mylist.OrderBy(s => s.GetType().GetProperty("PropertyName").GetValue(s)); 

Answer 7

En una respuesta anterior:

El más simple & la mejor solución:

mylist.OrderBy(s => s.GetType().GetProperty("PropertyName").GetValue(s)); 

Hay un error de sintaxis, ,null hay que añadir:

mylist.OrderBy(s => s.GetType().GetProperty("PropertyName").GetValue(s,null)); 

Answer 8

usted no necesita una biblioteca externa para esto. El siguiente código funciona para LINQ a SQL/entidades.

/// <summary> 
    /// Sorts the elements of a sequence according to a key and the sort order. 
    /// </summary> 
    /// <typeparam name="TSource">The type of the elements of <paramref name="query" />.</typeparam> 
    /// <param name="query">A sequence of values to order.</param> 
    /// <param name="key">Name of the property of <see cref="TSource"/> by which to sort the elements.</param> 
    /// <param name="ascending">True for ascending order, false for descending order.</param> 
    /// <returns>An <see cref="T:System.Linq.IOrderedQueryable`1" /> whose elements are sorted according to a key and sort order.</returns> 
    public static IQueryable<TSource> OrderBy<TSource>(this IQueryable<TSource> query, string key, bool ascending = true) 
    { 
     if (string.IsNullOrWhiteSpace(key)) 
     { 
      return query; 
     } 

     var lambda = (dynamic)CreateExpression(typeof(TSource), key); 

     return ascending 
      ? Queryable.OrderBy(query, lambda) 
      : Queryable.OrderByDescending(query, lambda); 
    } 

    private static LambdaExpression CreateExpression(Type type, string propertyName) 
    { 
     var param = Expression.Parameter(type, "x"); 

     Expression body = param; 
     foreach (var member in propertyName.Split('.')) 
     { 
      body = Expression.PropertyOrField(body, member); 
     } 

     return Expression.Lambda(body, param); 
    } 

(CreateExpression copiado de https://stackoverflow.com/a/16208620/111438)

Answer 9

así lo hice:

using System.Linq.Expressions; 

namespace System.Linq 
{ 
    public static class LinqExtensions 
    { 

     public static IOrderedQueryable<TSource> OrderBy<TSource>(this IQueryable<TSource> source, string field, string dir = "asc") 
     { 
      // parametro => expressão 
      var parametro = Expression.Parameter(typeof(TSource), "r"); 
      var expressao = Expression.Property(parametro, field); 
      var lambda = Expression.Lambda<Func<TSource, string>>(expressao, parametro); // r => r.AlgumaCoisa 
      if (string.Equals(dir, "desc", StringComparison.InvariantCultureIgnoreCase)){ 
       return source.OrderByDescending(lambda); 
      } 
      return source.OrderBy(lambda); 
     } 

     public static IOrderedQueryable<TSource> ThenBy<TSource>(this IOrderedQueryable<TSource> source, string field, string dir = "asc") 
     { 
      var parametro = Expression.Parameter(typeof(TSource), "r"); 
      var expressao = Expression.Property(parametro, field); 
      var lambda = Expression.Lambda<Func<TSource, string>>(expressao, parametro); // r => r.AlgumaCoisa 
      if (string.Equals(dir, "desc", StringComparison.InvariantCultureIgnoreCase)) 
      { 
       return source.ThenByDescending(lambda); 
      } 
      return source.ThenBy(lambda); 
     } 

    } 
} 

Uso:

example.OrderBy("Nome", "desc").ThenBy("other") 

trabajo como:

example.OrderByDescending(r => r.Nome).ThenBy(r => r.other)