Crear método anónimo a partir de una cadena en C#

Question

¿es posible crear un método anónimo en C# desde una cadena?

p. Ej. si tengo una cadena "x + y * z" ¿es posible convertir esto en algún tipo de método/objeto lambda que pueda llamar con los parámetros arbitrarios x, y, z?

Answer 1

Es posible, sí. Debe analizar la cadena y, por ejemplo, compilar un delegado utilizando árboles de expresiones.

Aquí es un ejemplo de creación (x, y, z) => x + y * z utilizando árboles de expresión:

ParameterExpression parameterX = Expression.Parameter(typeof(int), "x"); 
ParameterExpression parameterY = Expression.Parameter(typeof(int), "y"); 
ParameterExpression parameterZ = Expression.Parameter(typeof(int), "z"); 
Expression multiplyYZ = Expression.Multiply(parameterY, parameterZ); 
Expression addXMultiplyYZ = Expression.Add(parameterX, multiplyYZ); 
Func<int,int,int,int> f = Expression.Lambda<Func<int, int, int, int>> 
(
    addXMultiplyYZ, 
    parameterX, 
    parameterY, 
    parameterZ 
).Compile(); 
Console.WriteLine(f(24, 6, 3)); // prints 42 to the console 

Answer 2

C# no tiene ninguna funcionalidad como esta (otros lenguajes, como JavaScript, tienen funciones eval para manejar cosas como esta). Tendrá que analizar la cadena y crear un método usted mismo con cualquiera de los árboles de expresión o emitiendo IL.

Answer 3

Podría ser posible con una gramática (por ejemplo antlr) y un intérprete que crea árboles de expresión. No es una tarea pequeña, sin embargo, puede tener éxito si limita el alcance de lo que acepta como entrada. Aquí hay algunas referencias:

• C# ANTLR3 Grammar (compleja, pero se podía extraer una porción)
• Expression Trees

aquí es lo que algunos código puede parecerse a transformar un iTree antlr en un árbol de expresión. No está completo, pero te muestra a qué te enfrentas.

private Dictionary<string, ParameterExpression> variables 
    = new Dictionary<string, ParameterExpression>(); 

public Expression Visit(ITree tree) 
{ 
    switch(tree.Type) 
    { 
     case MyParser.NUMBER_LITERAL: 
      { 
       float value; 
       var literal = tree.GetChild(0).Text; 
       if (!Single.TryParse(literal, out value)) 
        throw new MyParserException("Invalid number literal"); 
       return Expression.Constant(value); 
      } 

     case MyParser.IDENTIFIER: 
      { 
       var ident = tree.GetChild(0).Text; 
       if (!this.variables.ContainsKey(ident)) 
       { 
        this.variables.Add(ident, 
         Expression.Parameter(typeof(float), ident)); 
       } 

       return this.variables[ident]; 
      } 

     case MyParser.ADD_EXPR: 
      return Expression.Add(Visit(tree.GetChild(0)), Visit(tree.GetChild(1))); 

     // ... more here 
    } 
} 

Answer 4

Existen funciones para hacer esto en .Net framework.

No es fácil. Necesita agregar algún código alrededor de la declaración para convertirla en un ensamblaje completo que incluya una clase y un método al que pueda llamar.

Después de que pase la cadena de

CSharpCodeProvider.CompileAssemblyFromSource(options, yourcode); 

Here is an example

Answer 5

Sólo por diversión usando CodeDom (cualquier código C# válida está permitido en la cadena siempre que está presente en mscorlib (Sin verificación de errores en absoluto):

static class Program 
{ 
    static string code = @" 
     public static class __CompiledExpr__ 
     {{ 
      public static {0} Run({1}) 
      {{ 
       return {2}; 
      }} 
     }} 
     "; 

    static MethodInfo ToMethod(string expr, Type[] argTypes, string[] argNames, Type resultType) 
    { 
     StringBuilder argString = new StringBuilder(); 
     for (int i = 0; i < argTypes.Length; i++) 
     { 
      if (i != 0) argString.Append(", "); 
      argString.AppendFormat("{0} {1}", argTypes[i].FullName, argNames[i]); 
     } 
     string finalCode = string.Format(code, resultType != null ? resultType.FullName : "void", 
      argString, expr); 

     var parameters = new CompilerParameters(); 
     parameters.ReferencedAssemblies.Add("mscorlib.dll"); 
     parameters.ReferencedAssemblies.Add(Path.GetFileName(Assembly.GetExecutingAssembly().Location)); 
     parameters.GenerateInMemory = true; 

     var c = new CSharpCodeProvider(); 
     CompilerResults results = c.CompileAssemblyFromSource(parameters, finalCode); 
     var asm = results.CompiledAssembly; 
     var compiledType = asm.GetType("__CompiledExpr__"); 
     return compiledType.GetMethod("Run"); 
    } 

    static Action ToAction(this string expr) 
    { 
     var method = ToMethod(expr, new Type[0], new string[0], null); 
     return() => method.Invoke(null, new object[0]); 
    } 

    static Func<TResult> ToFunc<TResult>(this string expr) 
    { 
     var method = ToMethod(expr, new Type[0], new string[0], typeof(TResult)); 
     return() => (TResult)method.Invoke(null, new object[0]); 
    } 

    static Func<T, TResult> ToFunc<T, TResult>(this string expr, string arg1Name) 
    { 
     var method = ToMethod(expr, new Type[] { typeof(T) }, new string[] { arg1Name }, typeof(TResult)); 
     return (T arg1) => (TResult)method.Invoke(null, new object[] { arg1 }); 
    } 

    static Func<T1, T2, TResult> ToFunc<T1, T2, TResult>(this string expr, string arg1Name, string arg2Name) 
    { 
     var method = ToMethod(expr, new Type[] { typeof(T1), typeof(T2) }, 
      new string[] { arg1Name, arg2Name }, typeof(TResult)); 
     return (T1 arg1, T2 arg2) => (TResult)method.Invoke(null, new object[] { arg1, arg2 }); 
    } 

    static Func<T1, T2, T3, TResult> ToFunc<T1, T2, T3, TResult>(this string expr, string arg1Name, string arg2Name, string arg3Name) 
    { 
     var method = ToMethod(expr, new Type[] { typeof(T1), typeof(T2), typeof(T3) }, 
      new string[] { arg1Name, arg2Name, arg3Name }, typeof(TResult)); 
     return (T1 arg1, T2 arg2, T3 arg3) => (TResult)method.Invoke(null, new object[] { arg1, arg2, arg3 }); 
    } 

    static void Main(string[] args) 
    { 
     var f = "x + y * z".ToFunc<int, int, long, long>("x", "y", "z"); 
     var x = f(3, 6, 8); 

    } 
}