Entity Framework exécute une requête avec des propriétés non mappées. Arbre d'expression

Question

Je veux exécuter la méthode linq sur iqueryable avec un arbre d'expression à partir de la fonction où je passe le nom de la méthode linq et le nom de la propriété. Mais ma méthode exemple fonctionne uniquement avec les propriétés mappées. Il jette une exception quand j'essaie par exemple de trouver max de propriété calculée.

Mes classes:

public partial class Something 
    { 
     public int a { get; set; } 
     public int b { get; set; } 
    } 

    public partial class Something 
    { 
     public int calculated { get { return a * b; } } 
    } 

Méthode d'échantillonnage:

public static object ExecuteLinqMethod(IQueryable<T> q, string Field, string Method) 
    { 
     var param = Expression.Parameter(typeof(T), "p"); 

     Expression prop = Expression.Property(param, Field); 

     var exp = Expression.Lambda(prop, param); 

      Type[] types = new Type[] { q.ElementType, exp.Body.Type }; 
      var mce = Expression.Call(typeof(Queryable),Method,types,q.Expression,exp); 

      return q.Provider.Execute(mce); 
    } 

Answer 1

Pour pouvoir interroger sur les propriétés calculées, vous disposez d'au moins 2 options:

1) vous amassez les valeurs calculées valeurs dans la base de données avec les lignes (ou dans une table différente), et les utiliser dans vos requêtes bien sûr cela nécessite le changement de modèle de données, et la redondance dans les données, mais est le moyen le plus performant. 2) vous devez être capable d'exprimer la façon dont vous "calculez" les propriétés d'une manière que sql comprendra, ce qui signifie que la propriété doit être remplacée par un linq. expression dans la requête finale. J'ai trouvé en 2009 un article incroyable d'Eric Lippert sur l'enregistrement de ces propriétés, mais je ne le trouve plus. En tant que tel ici est un link à un autre, qui a la même idée. Fondamentalement, vous définissez votre calcul comme un arbre d'expression, et utilisez la version compilée dans votre code.

Pour le rendre plus pratique, vous attribuer votre propriété avec un

[AttributeUsage(AttributeTargets.Property)] 
class CalculatedByAttribute: Attribute 
{ 
    public string StaticMethodName {get; private set;} 
    public CalculatedByAttribute(string staticMethodName) 
    { 
     StaticMethodName = staticMethodName; 
    } 
} 

Comme:

public partial class Something 
{ 
    [CalculatedBy("calculatedExpression")] 
    public int calculated { get { return calculatedExpression.Compile()(this); } } 
    public static Expression<Func<Something, int>> calculatedExpression = s => s.a * s.b; 
} 

(bien sûr vous pouvez mettre en cache la compilation) :)

Puis, en votre méthode, si la propriété a votre attribut, vous obtenez la valeur de la propriété statique et l'utilisez dans vos requêtes. Quelque chose le long:

public static object ExecuteLinqMethod<T>(IQueryable<T> q, string Field, string Method) 
{ 
    var propInfo = typeof(T).GetProperty(Field); 
    LambdaExpression exp; 
    var myAttr = propInfo.GetCustomAttributes(typeof(CalculatedByAttribute), true).OfType<CalculatedByAttribute>().FirstOrDefault(); 
    if (myAttr != null) 
     exp = (LambdaExpression)typeof(T).GetField(myAttr.StaticMethodName, BindingFlags.Static | BindingFlags.Public).GetValue(null); 
    else 
    { 
     var param = Expression.Parameter(typeof(T), "p"); 
     Expression prop = Expression.Property(param, Field); 
     exp = Expression.Lambda(prop, param); 
    } 

    Type[] types = new Type[] { q.ElementType, exp.Body.Type }; 
    var mce = Expression.Call(typeof(Queryable),Method,types,q.Expression,exp); 

    return q.Provider.Execute(mce); 
}