propriétés imbriquées Access avec lambda dynamique à l'aide Linq.Expression

Question

Supposons que j'ai deux classes:

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

Ces classes sont plus ou moins donnés, ils sont mis en correspondance via NHibernate pour être honnête :)

Dans une grille (datatables.net comme base) je voudrais avoir un tri indépendant du type.

Par conséquent, je crée une expression 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 je passe personne comme type T et remplacer la « propriété pour trier » avec « nom » il fonctionne très bien (crée un lambda correct). Si la propriété est de trier « address.street » ça ne marchera pas, jetez-moi l'erreur suivante:

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

Je ne vois qu'une seule solution à ce jour, mais pas assez clair ... Je voudrais essayer de diviser la chaîne qui contient le nom de propriété (divisé par.)

Quelqu'un peut-il donner une meilleure solution? J'ai besoin d'ajouter le sortExpression à un objet IQueryable query.OrderBy(sortExpression).

Je ne sais pas si mon titre est clair, veuillez le corriger.

Merci d'avance.

Answer 1

Il me semble que vous essayez de réécrire Microsoft DynamicQuery. Pourquoi ne pas simplement utiliser cela à la place?

Voici un exemple:

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

Answer 2

Ce qui est pas clair?

Vous devez diviser puis utiliser:

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

Answer 3

est ici une version plus générique de la réponse 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); 
    } 

Vous pouvez l'utiliser comme ceci:

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

Answer 4

Essayez celui-ci

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