Trasferimento di un delegato in un'azione <T> o Func <T> in runtime

Question

Sto cercando di migliorare il mio codice di riflessione creando delegati per i metodi Getter e Setter.

Il mio codice è simile al seguente:

MyObject obj = new MyObject(); 
var prop = obj.GetType().GetProperty("Prop"); 
var getType = typeof(Func<>).MakeGenericType(prop.PropertyType); 
var setType = typeof(Action<>).MakeGenericType(prop.PropertyType); 

var getMethod = prop.GetGetMethod().CreateDelegate(getType, obj); 
var setMethod = prop.GetSetMethod().CreateDelegate(setType, obj); 

// I'd like to change this section and not to use a dynamic!! 
dynamic castedGet = Convert.ChangeType(getMethod, getType); 
dynamic castedSet = Convert.ChangeType(setMethod, setType); 

CreateDelegate restituisce un Delegate e utilizzando DynamicInvokenon è prestazioni saggio.

Ho fuso (codificato) lo Delegate in Action<T> \ Func<T> e ho visto un enorme aumento delle mie prestazioni.

Allora ho provato a gettare il Delegate in Action<T> \ Func<T> in fase di esecuzione (utilizzando Convert.ChangeType e dynamic) e la mia prestazione è fatto male - probabilmente a causa del fatto che sto usando un tipo dynamic.

Sono abbastanza sicuro di poterlo fare senza dynamic.

mi immagino la soluzione ha qualcosa a che fare con expression trees, ma non sono davvero sicuro di come codificare qualcosa di simile. Se qualcuno ha una buona soluzione che non usa expression trees allora sarà interessante sentirlo anche su di esso.

Answer 1

Se il vostro obiettivo è quello di essere in grado di richiamare la vostra azione/funzione senza conoscere il tipo di ritorno al momento della compilazione, allora probabilmente si vuole finire con un Action<object> e Func<object>, giusto?

È possibile fare questo senza dover compilare un albero di espressione o nulla, in questo modo:

// Use reflection to create the action, invoking the method below. 
var setAction = (Action<object>) this.GetType() 
    .GetMethod("CastAction", BindingFlags.Static | BindingFlags.NonPublic) 
    .MakeGenericMethod(prop.PropertyType) 
    .Invoke(null, new object[]{setMethod}); 

// invoke the action like this: 
object value = 42; // or any value of the right type. 
setAction(value); 

Usando questo metodo di supporto:

private static Action<object> CastAction<T>(Delegate d) 
{ 
    var action = (Action<T>)d; 
    return obj => action((T)obj); 
} 

mio test mostrano che questo è circa il 25% più veloce che usare dynamic e circa il 45% più lento del semplice obj.Prop = 2;

Answer 2

C'è un motivo per cui è necessario utilizzare l'azione < T> o Func < T> per ottenere/impostare dinamicamente una proprietà?

Se non è possibile utilizzare PropertyInfo.GetMethod() e SetMethod()

MyObject obj = new MyObject(); 
PropertyInfo prop = obj.GetType().GetProperty("Prop"); 

MethodInfo getter = prop.GetMethod(); 
getter.Invoke(...) 

MethodInfo setter = prop.SetMethod(); 
setter.Invoke(...)