Reemplazar parámetros en una expresión lambda

Question

Tenía una parte del código que toma expresiones lambda en tiempo de ejecución, que luego puedo compilar e invocar.

Something thing; 

Expression<Action<Something>> expression = (c => c.DoWork()); 
Delegate del = expression.Compile(); 
del.DynamicInvoke(thing); 

Con el fin de ahorrar tiempo de ejecución, guardé los delegados compilados en una memoria caché, una Dictionary<String, Delegate> el que la clave es la cadena de expresión lambda.

cache.Add("(Something)c => c.DoWork()", del); 

Para exactamente las mismas llamadas, funcionó bien. Sin embargo, me di cuenta de que podía recibir lambdas equivalentes, como "d => d.DoWork()", que en realidad debería usar el mismo delegado, y no lo era.

Esto me hizo preguntarme si había una manera limpia (leer "no usar String.Replace", ya lo hice como una solución temporal) para reemplazar los elementos en una expresión lambda, como quizás reemplazarlos por arg0 para que tanto

(c => c.DoWork()) y (d => d.DoWork())

se transforman y se comparó como (arg0 => arg0.DoWork()) mediante el uso de algo fuctionnally similar a la inyección de un Expression.Parameter (Tipo, Nombre) en una lambda.

¿Es esto posible? (Las respuestas pueden incluir C# 4.0)

Answer 1

Utilicé cadenas, ya que era la forma más fácil para mí. No puede cambiar manualmente el nombre de la expresión del parámetro (tiene la propiedad "Nombre", pero es de solo lectura), por lo que debe construir una nueva expresión a partir de piezas. Lo que hice fue crear un parámetro "sin nombre" (de hecho, obtiene un nombre autogenerado en este caso, que es "Param_0") y luego creé una nueva expresión casi igual a la anterior, pero usando el nuevo parámetro.

public static void Main() 
{ 
    String thing = "test"; 

    Expression<Action<String>> expression = c => c.ToUpper(); 
    Delegate del = expression.Compile(); 
    del.DynamicInvoke(thing); 

    Dictionary<String, Delegate> cache = new Dictionary<String, Delegate>(); 
    cache.Add(GenerateKey(expression), del); 

    Expression<Action<String>> expression1 = d => d.ToUpper(); 
    var test = cache.ContainsKey(GenerateKey(expression1)); 
    Console.WriteLine(test); 

} 

public static string GenerateKey(Expression<Action<String>> expr) 
{ 
    ParameterExpression newParam = Expression.Parameter(expr.Parameters[0].Type); 
    Expression newExprBody = Expression.Call(newParam, ((MethodCallExpression)expr.Body).Method); 
    Expression<Action<String>> newExpr = Expression.Lambda<Action<String>>(newExprBody, newParam); 
    return newExpr.ToString(); 
} 

Answer 2

Hay más en una expresión lambda que solo el texto. Lambdas son reescritos por el compilador en algo mucho más complicado. Por ejemplo, pueden cerrar sobre variables (que podrían incluir otros delegados). Esto significa que dos lambdas podrían verse exactamente iguales, pero realizar acciones completamente diferentes.

Por lo tanto, puede tener suerte en el almacenamiento en caché de su expresión compilada, pero debe darles un nombre significativo para la clave que solo el texto de la expresión. De lo contrario, ninguna cantidad de sustitución de argumentos te ayudará.