Parametri ByRef con alberi di espressione in C#

Question

Se volevo creare un albero di espressioni che chiamasse un metodo con un parametro out e quindi restituisse il valore out come risultato .. come potrei farlo?

Quanto segue non funziona (genera un'eccezione di runtime), ma forse meglio dimostra quello che sto cercando di fare:

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

So che questo può essere abbastanza facilmente risolto in IL prima (o anche senza compilazione di runtime a tutti), ma sfortunatamente questo fa parte di un processo di creazione di espressioni molto più grande ... quindi spero davvero che questa non sia una limitazione, in quanto una riscrittura completa sarebbe più di un po 'di dolore.

Answer 1

questo funziona per me:

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

forse è solo me, ma io non vedo il punto di tutta la faccenda. Per realizzare ciò che stai cercando di fare, non hai davvero bisogno di scrivere tutte queste cose.

codice di esempio in una console app:

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

Come si vede si ottiene gli stessi risultati in modo più conciso e pulito. Quello che penso stia perdendo è che Action, Action<> e Func<> sono tutti zucchero sintatico per delegate quindi non c'è bisogno di mescolare le 2 sintassi e non c'è bisogno di ricostruire l'intera espressione come si sta facendo.