Alberi di espressione e invocazione di un delegato

Question

Quindi ho uno delegate che punta a una funzione che non conosco quando creo l'oggetto delegate. L'oggetto è impostato su una funzione successiva.

Inoltre, desidero creare un albero di espressioni che richiami il delegato con un argomento (nell'interesse della domanda l'argomento può essere 5). Questo è il bit con cui sto lottando; il codice qui sotto mostra ciò che voglio ma non viene compilato.

Func<int, int> func = null; 
Expression expr = Expression.Invoke(func, Expression.Constant(5)); 

Per questo esempio ho potuto fare (questo è pratico da quando ho bisogno di costruire gli alberi di espressione in fase di esecuzione):

Func<int, int> func = null; 
Expression<Func<int>> expr =() => func(5); 

Questo rende expr diventano:

() => Invoke(value(Test.Program+<>c__DisplayClass0).func, 5) 

che sembra per significare che per utilizzare delegatefunc, ho bisogno di produrre il bit value(Test.Program+<>c__DisplayClass0).func.

Quindi, come posso creare un albero di espressioni che invochi un delegato?

Answer 1

OK, questo mostra come può essere fatto (ma è molto poco elegante a mio parere):

Func<int, int> func = null; 
Expression<Func<int, int>> bind = (x) => func(x); 

Expression expr = Expression.Invoke(bind, Expression.Constant(5)); 

Expression<Func<int>> lambda = Expression.Lambda<Func<int>>(expr); 
Func<int> compiled = lambda.Compile(); 

Console.WriteLine(expr); 

func = x => 3 * x; 
Console.WriteLine(compiled()); 

func = x => 7 * x; 
Console.WriteLine(compiled()); 

Console.Read(); 

Essenzialmente Io uso (x) => func(x); per fare una funzione che chiama ciò a cui punta il delegato. Ma puoi vedere che expr è eccessivamente complicato.Per questo motivo non considero questa risposta buona, ma forse può essere costruita su?

Answer 2

questo dovrebbe funzionare:

Action<int> func = i => Console.WriteLine(i * i); 

// If func is null like in your example, the GetType() call fails, 
// so give it a body or use typeof if you know the type at compile time 
var param = Expression.Parameter(func.GetType()); 

// Call the Invoke method on the delegate, which is the same as invoking() it 
var callExpr = Expression.Call(param, func.GetType().GetMethod("Invoke"), Expression.Constant(5)); 

var lambdaExpr = Expression.Lambda<Action<Action<int>>>(callExpr, param); 

var fn = lambdaExpr.Compile(); // Compile the expression tree so it can be executed 

fn(func); // Prints 25 

espressioni possono essere un mindfuck, ma ricordate: espressioni sono sempre costruiti da altre espressioni. Un'espressione è un albero di altre espressioni che descrive il codice. Non puoi passare al delegato effettivo come fai nel tuo esempio, ciò di cui hai bisogno è un'espressione di quel delegato, dicendo che l'espressione si aspetta un parametro del tipo del tuo delegato. Quindi dici di voler chiamare un metodo su quel parametro, ovvero il metodo Invoke, con l'argomento '5'. Tutte le altre cose dopo è solo se si desidera trasformare l'espressione in codice eseguibile, cosa che probabilmente si fa.

L'ho eseguito con .NET4, spero di non averlo mescolato con le sole espressioni .NET.

EDIT In risposta al commento di PythonPower:

Penso che ciò che si vuole (non passando il delegato come argomento) può essere fatto solo quando il delegato in sé è descritto come espressione, in questo modo:

var arg = Expression.Parameter(typeof(int), "i"); 

var multiply = Expression.Multiply(arg, arg); 

var writeln = Expression.Call(typeof(Console).GetMethod("WriteLine", 
    new[] { typeof(int) }), multiply); 

var lambda = Expression.Lambda<Action<int>>(writeln, arg); 

var compiled = lambda.Compile(); 

compiled(5); // Prints 25 

L'unico altro modo in cui posso pensare è quello di catturare un delegato dichiarato localmente in una chiusura, ma non saprei come farlo.

Answer 3

Penso che quello che si vuole fare è usare le proprietà Target e Method del delegato da passare per creare un'espressione Call. Basandosi sul campione di JulianR, questo è ciò che sarebbe simile:

Action<int> func = i => Console.WriteLine(i * i); 

var callExpr = Expression.Call(Expression.Constant(func.Target), func.Method, Expression.Constant(5)); 

var lambdaExpr = Expression.Lambda<Action>(callExpr); 
var fn = lambdaExpr.Compile(); 
fn(); // Prints 25