Parámetros de ByRef con árboles de expresiones en C#

Question

Si quisiera crear un árbol de expresiones que llamara a un método con un parámetro out y luego devolviera el valor out como resultado ... ¿cómo lo haría?

El siguiente no funciona (una excepción de tiempo de ejecución), pero quizás mejor demuestra lo que estoy tratando de hacer:

private delegate void MyDelegate(out int value); 
private static Func<int> Wrap(MyDelegate dele) 
{ 
    MethodInfo fn = dele.Method; 
    ParameterExpression result = ParameterExpression.Variable(typeof(int)); 
    BlockExpression block = BlockExpression.Block(
     typeof(int), // block result 
     Expression.Call(fn, result), // hopefully result is coerced to a reference 
     result); // return the variable 
    return Expression.Lambda<Func<int>>(block).Compile(); 
} 

private static void TestFunction(out int value) 
{ 
    value = 1; 
} 

private static void Test() 
{ 
    Debug.Assert(Wrap(TestFunction)() == 1); 
} 

Sé que esto puede resolverse con bastante facilidad en crudo IL (o, de hecho, sin compilación en tiempo de ejecución), pero desafortunadamente esto es parte de un proceso de construcción de expresiones mucho más grande ... así que realmente espero que esto no sea una limitación, ya que una reescritura completa sería más que un dolor.

Answer 1

Esto funciona para mí:

private static Func<int> Wrap(MyDelegate dele) 
    { 
     var fn = dele.Method; 
     var result = ParameterExpression.Variable(typeof(int)); 
     var block = BlockExpression.Block(
      typeof(int), 
      new[] { result }, 
      new Expression[] 
      { 
       Expression.Call(fn, result), 
       result, 
      }); 
     return Expression.Lambda<Func<int>>(block).Compile(); 
    } 

Answer 2

Tal vez sea sólo yo, pero yo no veo el punto de todo el asunto. Para lograr lo que estás tratando de hacer, realmente no necesitas escribir todo eso.

código de ejemplo en una aplicación de consola:

class Program 
    { 
     static void Main(string[] args) 
     { 
      var temp = Execute(DoSomething); 
      Console.Write(temp); 
      Console.Read(); 
     } 

     static int Execute(Func<int> methodToRun) 
     { 
      return methodToRun.Invoke(); 
     } 

     static int DoSomething() 
     { 
      return 1; 
     } 
    } 

Como se puede ver que le consigue los mismos resultados de una manera más concisa y limpia. Lo que creo que estábamos perdiendo es que Action, Action<> y Func<> son todo el azúcar sintáctica para delegate así que no hay necesidad de mezclar las 2 sintaxis y no hay necesidad de reconstruir toda la expresión como la que está haciendo.