creazione runtime di generici Funz <T>

Question

ho bisogno di implementare il metodo:

object GetFactory(Type type); 

Questo metodo deve restituire una Funz <T> dove typeparam 'T' è il 'tipo'.

Quindi, il mio problema è che non so come creare un Func <? > in fase di esecuzione utilizzando la riflessione. Activator.CreateInstance non funziona perché non ci sono costruttori sui delegati.

Qualsiasi idea?

Answer 1

Si utilizza Delegate.CreateDelegate, ad esempio da MethodInfo; qui di seguito, ho hard-coded, ma si può usare una logica, o Expression, per ottenere il metodo di creazione effettiva:

using System; 
using System.Reflection; 
class Foo {} 

static class Program 
{ 
    static Func<T> GetFactory<T>() 
    { 
     return (Func<T>)GetFactory(typeof(T)); 
    } 
    static object GetFactory(Type type) 
    { 
     Type funcType = typeof(Func<>).MakeGenericType(type); 
     MethodInfo method = typeof(Program).GetMethod("CreateFoo", 
      BindingFlags.NonPublic | BindingFlags.Static); 
     return Delegate.CreateDelegate(funcType, method); 
    } 
    static Foo CreateFoo() { return new Foo(); } 
    static void Main() 
    { 
     Func<Foo> factory = GetFactory<Foo>(); 
     Foo foo = factory(); 
    } 
} 

Per i metodi non statici, v'è un sovraccarico di Delegate.CreateDelegate che accetta l'istanza di destinazione .

Answer 2

Penso che il solito approccio sarebbe quello di rendere la versione "stupida" la cosa che si spaccia a runtme, e quindi fornire un metodo di estensione di supporto per fornire la versione sicura del tipo su di esso.

Answer 3

è possibile creare oggetti Expression invece di un func e compilare() l'espressione per ottenere un delegato Func.