propiedades de acceso anidado con lambda dinámico utilizando Linq.Expression

Question

Supongamos que tengo dos clases:

class person 
{ 
    int ID 
    string name 
    Address address 
} 
class address 
{ 
    int ID 
    string street 
    string country 
} 

Estas clases se dan más o menos, que se asignan a través de NHibernate para ser honesto :)

En una grilla (datatables.net como base) me gustaría tener una clasificación independiente del tipo.

Por lo tanto he creado una expresión lambda:

var param = Expression.Parameter(typeof(T), typeof(T).Name); 
    var sortExpression = Expression.Lambda<Func<T, object>> 
           (Expression.Convert(Expression.Property(param, "Property to sort"), typeof(object)), param); 

Si paso persona que el Tipo T y sustituir a la "propiedad para ordenar" con "nombre" que funciona bien (crea una lambda correcta). Si la propiedad es para ordenar "address.street" no va a funcionar, me tiro el siguiente error:

Property 'address.street' is not defined for type 'person' 

sólo veo una solución hasta el momento, pero no lo suficientemente claro ... Me gustaría tratar de dividir la cadena que contiene el Nombre de la propiedad (dividido por)

¿Alguien puede dar una mejor solución? Necesito agregar sortExpression a un objeto IQueryable query.OrderBy(sortExpression).

No estoy seguro si mi título es claro, por favor, adelante y corríjalo.

Gracias de antemano.

Answer 1

Me parece que estás intentando volver a escribir Microsoft DynamicQuery. ¿Por qué no usar eso en su lugar?

He aquí un ejemplo:

IQueryable<Foo> myQuery = GetHibernateQuery(); 
myQuery = myQuery.OrderBy("address.street"); 

Answer 2

Lo que no está claro?

Hay que dividirlo y luego usar:

Expression.Property(Expression.Property(param, "address"), "street") 

Answer 3

Aquí hay una versión más genérica de la respuesta de LukLed:

protected MemberExpression NestedExpressionProperty(Expression expression, string propertyName) 
    { 
     string[] parts = propertyName.Split('.'); 
     int partsL = parts.Length; 

     return (partsL > 1) 
      ? 
      Expression.Property( 
       NestedExpressionProperty(
        expression, 
        parts.Take(partsL - 1) 
         .Aggregate((a, i) => a + "." + i) 
       ), 
       parts[partsL - 1]) 
      : 
      Expression.Property(expression, propertyName); 
    } 

Usted puede utilizar de esta manera:

var paramExpression = Expression.Parameter(this.type, "val"); 
var firstProp = NestedExpressionProperty(paramExpression,"address.street"); 

Answer 4

Pruebe este de

public static IQueryable<T> SortIQueryable<T>(IQueryable<T> data, string fieldName, string sortOrder) 
    { 
     if (string.IsNullOrWhiteSpace(fieldName)) return data; 
     if (string.IsNullOrWhiteSpace(sortOrder)) return data; 

     var param = Expression.Parameter(typeof(T), "i"); 

     MemberExpression property = null; 
     string[] fieldNames = fieldName.Split('.'); 
     foreach (string filed in fieldNames) 
     { 
      if (property == null) 
      { 
       property = Expression.Property(param, filed); 
      } 
      else 
      { 
       property = Expression.Property(property, filed); 
      } 
     } 

     Expression conversion = Expression.Convert(property, typeof(object));//Expression.Property(param, fieldName) 
     var mySortExpression = Expression.Lambda<Func<T, object>>(conversion, param); 

     return (sortOrder == "desc") ? data.OrderByDescending(mySortExpression) 
      : data.OrderBy(mySortExpression); 
    }