C# 4 "dinamico" negli alberi di espressione

Question

Sto cercando di capire come mettere insieme tutti i pezzi e apprezzerei un esempio di codice sorgente concreto per un caso semplice con cui iniziare.

Si consideri il seguente codice C#:

Func<int, int, int> f = (x, y) => x + y; 

posso produrre una funzione equivalente in fase di esecuzione utilizzando alberi di espressione come segue:

var x = Expression.Parameter(typeof(int), "x"); 
var y = Expression.Parameter(typeof(int), "y"); 
Func<int, int, int> f = 
    Expression.Lambda<Func<int, int, int>>(
     Expression.Add(x, y), 
     new[] { x, y } 
    ).Compile(); 

Ora dato il seguente lambda:

Func<dynamic, dynamic, dynamic> f = (x, y) => x + y; 

come potrei generare l'equivalente usando gli alberi di espressione (e, presumibilmente, Expression.Dynamic)?

Answer 1

È possibile creare un albero di espressioni che rappresenti un'espressione di aggiunta C# dinamica passando il CallSiteBinder per un'espressione di aggiunta C# dinamica in Expression.Dynamic. È possibile scoprire il codice per creare il Raccoglitore eseguendo Reflector sull'espressione dinamica originale. Il tuo esempio sarebbe simile a questo:

var x = Expression.Parameter(typeof(object), "x"); 
var y = Expression.Parameter(typeof(object), "y"); 
var binder = Binder.BinaryOperation(
    CSharpBinderFlags.None, ExpressionType.Add, typeof(Program), 
    new CSharpArgumentInfo[] { 
     CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null), 
     CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)}); 
Func<dynamic, dynamic, dynamic> f = 
    Expression.Lambda<Func<object, object, object>>(
     Expression.Dynamic(binder, typeof(object), x, y), 
     new[] { x, y } 
    ).Compile(); 

Answer 2

Non è possibile farlo perché un albero di espressioni "Potrebbe non contenere un'operazione dinamica".

Di seguito sarà non compilare, a causa del funzionamento +, per esempio, e si sta cercando di costruire un albero di espressione che viola questa regola:

Expression<Func<dynamic, dynamic, dynamic>> f = (x, y) => x + y; 

Se non si stava facendo un'operazione di somma si potrebbe farla franca

Vedere How to create an Expression<Func<dynamic, dynamic>> - Or is it a bug? per ulteriori informazioni.

Edit:

Questo è il più vicino che posso ottenere, attraverso la definizione di mio metodo Add che accetta parametri dinamici e restituisce un risultato dinamico.

class Program 
{ 
    static void Main(string[] args) 
    { 

     var x = Expression.Parameter(typeof(object), "x"); 
     var y = Expression.Parameter(typeof(object), "y"); 
     Func<dynamic, dynamic, dynamic> f = 
      Expression.Lambda<Func<dynamic, dynamic, dynamic>>(
       Expression.Call(typeof(Program), "Add", null, x, y), 
       new[] { x, y } 
      ).Compile(); 

     Console.WriteLine(f(5, 2)); 
     Console.ReadKey(); 
    } 

    public static dynamic Add(dynamic x, dynamic y) 
    { 
     return x + y; 
    } 
} 

Answer 3

Molto interessante. Credo che sia impossibile per la stessa ragione la seguente non viene compilato:

Expression<Func<dynamic, dynamic, int>> func = (p1, p2) => p1 + p2; 

E 'una CS1963 errore del compilatore (che non sembra essere documentato da MS):

errore CS1963: Un'espressione albero non può contenere un'operazione dinamica