Parse chaîne à C# lambda Func

Question

Y at-il un moyen de convertir la représentation de chaîne de lambda à un lambda Func? J'ai essayé Dynamic LINQ mais cela ne fonctionne pas comme prévu - par exemple, il ne s'attend pas à la syntaxe lambda =>.

Résumé des réponses:

• écrire mon propre compilateur C# - très drôle
• tir jusqu'à compilateur externe (comme csc.exe) - très lent
• utilisant DLINQ - comme je le disais, je n » t voir comment il peut analyser lambda expressions

Pourquoi ai-je besoin: parce qu'il n'y a aucun moyen de passer lambdas à des attributs personnalisés comme

[Secure(role => role.CanDoThis && role.AllowedCount > 5)] 

donc comme solution que je voudrais passer lambda sous forme de chaîne: "rôle => role.CanDoThis & & role.AllowedCount> 5". Mais il me semble que je devrais utiliser DLINQ comme ceci: "CanDoThis & & AllowedCount> 5" - puisque c'est la syntaxe qu'il comprend. Mais ma question portait sur les vrais lambdas, j'ai déjà utilisé DLINQ au moment de poser la question.

Answer 1

Vous pouvez analyser la chaîne et créer une expression lambda à l'aide de la classe Expression, en dupliquant essentiellement la fonction du compilateur.

Answer 2

Vous pourriez faire quelque chose avec CSharpCodeProvider (encapsuler l'expression avec du code supplémentaire pour créer une classe valide et la compiler dans un assemblage, puis charger l'assemblage).

Je crois que c'est ainsi que le fait LINQPad.

Answer 3

Je suppose que vous devez recourir à CSharpCodeProvider. Cependant, traiter toutes les références de variables locales possibles peut ne pas être trivial. Et comment diriez-vous au CSharpCodeProvider sur le type du paramètre lambda? Je serais probablement créer une classe de modèle qui ressemble à ceci:

class ExpressionContainer { 
    public Expression<Func<Product, bool>> TheExpression; 
    public string Length; 

    public ExpressionContainer() { 
     TheExpression = <user expression text>; 
    } 
} 

faire quelque chose comme ceci:

string source = <Code from above>; 
Assembly a; 
using (CSharpCodeProvider provider = new CSharpCodeProvider(...) { 
    List<string> assemblies = new List<string>(); 
    foreach (Assembly x in AppDomain.CurrentDomain.GetAssemblies()) { 
     try { 
      assemblies.Add(x.Location); 
     } 
     catch (NotSupportedException) { 
      // Dynamic assemblies will throw, and in .net 3.5 there seems to be no way of finding out whether the assembly is dynamic before trying. 
     } 
    } 

    CompilerResults r = provider.CompileAssemblyFromSource(new CompilerParameters(assemblies.ToArray()) { GenerateExecutable = false, GenerateInMemory = true }, source); 
    if (r.Errors.HasErrors) 
     throw new Exception("Errors compiling expression: " + string.Join(Environment.NewLine, r.Errors.OfType<CompilerError>().Select(e => e.ErrorText).ToArray())); 
    a = r.CompiledAssembly; 
} 
object o = a.CreateInstance("ExpressionContainer"); 
var result = (Expression<Func<Product, bool>>)o.GetType().GetProperty("TheExpression").GetValue(o); 

Notez, cependant, que pour les applications de longue durée, vous devez créer tous ces en mémoire assemblées dans un domaine d'application distinct car elles ne peuvent pas être libérées tant que le domaine d'application dans lequel elles résident n'est pas chargé.

Answer 4

Il existe de nombreux analyseurs d'expression lambda disponibles. Certains d'entre eux sont Lambda-Parser, Sprache

Exemple de code:

Example1: concat chaîne et nombre calculate:

string code = "2.ToString()+(4*2)"; // C# code Func<string> 
func = ExpressionParser.Compile<Func<string>>(code); // compile code 
string result = func(); // result = "28" 

Answer 5

En réponse à votre problème plus spécifique, (et vous savent déjà cela, mais je » J'essaierai de le mentionner de toute façon), vous pouvez créer un dictionnaire qui mappe des valeurs qui peuvent être une constante (entiers ou enums) à lambdas.

sealed class Product { 
    public bool CanDoThis { get; set; } 
    public int AllowedCount { get; set; } 
} 

public enum SecureFuncType { 
    Type1, 
    Type2, 
    Type3 
} 

sealed class SecureAttribute : Attribute { 
    [NotNull] readonly Func<Product, bool> mFunc; 

    public SecureAttribute(SecureFuncType pType) { 
     var secureFuncs = new Dictionary<SecureFuncType, Func<Product, bool>> { 
     { SecureFuncType.Type1, role => role.CanDoThis && role.AllowedCount > 1 }, 
     { SecureFuncType.Type2, role => role.CanDoThis && role.AllowedCount > 2 }, 
     { SecureFuncType.Type3, role => role.CanDoThis && role.AllowedCount > 3 } 
     }; 

     mFunc = secureFuncs[pType]; 
    } 
} 

[Secure(SecureFuncType.Type1)] 
sealed class TestClass { 
} 

// etc...