Parse cadena a C# lambda Func

Question

¿Hay alguna forma de convertir la representación de cadena de lambda a una función lambda?

Func<Product, bool> func = Parse<Product, bool>("product => product.Name.Length > 0"); 

me trataron dinámico LINQ pero no funciona como se esperaba - por ejemplo, que no espera que la sintaxis lambda =>.

Resumen de las respuestas:

• escribir mi propio compilador de C# - muy divertido
• disparar hasta compilador externo (como csc.exe) - muy lento
• usando DLINQ - como he dicho yo no' t ver cómo se puede analizar lambda expresiones

¿Por qué necesito esto: porque no hay manera de pasar lambdas a los atributos personalizados como

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

Así como una solución que me gustaría pasar lambda como cadena: "role => role.CanDoThis & & role.AllowedCount> 5". Pero parece que tendré que usar DLINQ así: "CanDoThis & & AllowedCount> 5" - ya que esa es la sintaxis que entiende. Pero mi pregunta era sobre las verdaderas lambdas, ya he usado DLINQ al momento de preguntar.

Answer 1

Puede analizar la cadena y crear una expresión lambda utilizando la clase Expression, esencialmente duplicando la función del compilador.

Answer 2

Es posible que pueda hacer algo con CSharpCodeProvider (ajuste la expresión con más código para crear una clase válida y compilarla en un ensamblaje, luego cargue el ensamblaje).

Creo que es así como LINQPad lo hace.

Answer 3

Supongo que tiene que recurrir al CSharpCodeProvider. Sin embargo, lidiar con todas las posibles referencias de variables locales podría no ser trivial. ¿Y cómo le diría a CSharpCodeProvider sobre el tipo del parámetro lambda? Yo probablemente crear una clase de plantilla con este aspecto:

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

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

luego hacer algo como esto:

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

Tenga en cuenta, sin embargo, que para aplicaciones de larga duración, se debe crear todo esto en memoria ensamblados en un dominio de aplicación separado, ya que no se pueden liberar hasta que se descargue el dominio de aplicación en el que residen.

Answer 4

Hay muchos analizadores de expresiones lambda disponibles. Algunos de ellos son Lambda-Parser, Código Sprache

muestra:

Ejemplo 1: concat cadena y el número calcular:

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

respuesta a su problema más específico, (y ustedes ya saben esto, pero yo' Trataré de mencionarlo de todos modos), podrías crear un diccionario que asigne valores que pueden ser una constante (enteros o enumeraciones) a 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...