un costruttore come delegato - è possibile in C#?

Question

Ho una classe come di seguito:

class Foo 
{ 
    public Foo(int x) { ... } 
} 

e ho bisogno di passare a un certo metodo di un delegato come questo:

delegate Foo FooGenerator(int x); 

E 'possibile passare al costruttore direttamente come valore FooGenerator, senza dover digitare:

delegate(int x) { return new Foo(x); } 

?

MODIFICA: Per uso personale, la domanda si riferisce a .NET 2.0, ma sono ben accetti suggerimenti/risposte per 3.0+.

Answer 1

No, il CLR non consente delegati vincolanti per ConstructorInfo.

È possibile tuttavia solo creare il proprio:

static T Make<T>(Action<T> init) where T : new() 
{ 
    var t = new T(); 
    init(t); 
    return t; 
} 

Uso

var t = Make<Foo>(x => { x.Bar = "bar"; x.Baz = 1; }); 

Answer 2

Purtroppo no, i costruttori non sono esattamente le stesse cose dei metodi e in quanto tali non è possibile creare un delegato che punti ad essi. Questa è un'idea interessante però, forse con più informazioni potremmo escogitare una sorta di soluzione che sarebbe sintatticamente simile.

Answer 3

Sembra che tu probabilmente stia usando il modello di classe factory.

Factory Method Pattern

Answer 4

La mia ipotesi è che non è possibile in quanto si potrebbe passare un metodo di un oggetto che non è stato ancora creato.

Answer 5

penso più conciso, come si sta andando ad ottenere (senza spostare ad un modello di fabbrica) sarebbe qualcosa con metodi anonimi, in questo modo:

delegate Foo FooGenerator(int x); 

...  

void DoStuff() 
{ 
    YourDelegateConsumer(x => new Foo(x)); 
} 

Questo non sta facendo assolutamente quello che hai chiesto (dal momento che stai passando un delegato a un metodo anonimo che restituisce una nuova istanza, piuttosto che un delegato diretto al costruttore), ma non penso che ciò che chiedi sia strettamente possibile.

Questo è, naturalmente, supponendo che si sta utilizzando 3.5+

Answer 6

Sto assumendo che normalmente fare qualcosa di simile come parte di un'implementazione fabbrica, dove i tipi effettivi aren noto al momento della compilazione ...

In primo luogo, si noti che un approccio più semplice può essere un passo di post-creazione, quindi è possibile utilizzare i generici:

static T Create<T>({args}) where T : class, ISomeInitInterface, new() { 
    T t = new T(); 
    t.Init(args); 
    return t; 
} 

È quindi possibile utilizzare MakeGenericMethod e/o CreateDelegate.

---

Altrimenti; puoi farlo al volo con Expression (3.5) o DynamicMethod (2.0).

Il Expression approccio è più facile da codice:

var param = Expression.Parameter(typeof(int), "val"); 
    var ctor = typeof(Foo).GetConstructor(new[] { typeof(int) }); 
    var lambda = Expression.Lambda<Func<int, Foo>>(
     Expression.New(ctor, param), param); 
    var func = lambda.Compile(); 
    Foo foo = func(123); 
    string s = foo.ToString(); // proof 

o (utilizzando DynamicMethod):

ConstructorInfo ctor = typeof(Foo).GetConstructor(new[] { typeof(int) }); 
    DynamicMethod dm = new DynamicMethod("Create", typeof(Foo), 
      new Type[] { typeof(int) }, typeof(Foo), true); 
    ILGenerator il = dm.GetILGenerator(); 
    il.Emit(OpCodes.Ldarg_0); 
    il.Emit(OpCodes.Newobj, ctor); 
    il.Emit(OpCodes.Ret); 
    Converter<int, Foo> func = (Converter<int, Foo>) 
     dm.CreateDelegate(typeof(Converter<int, Foo>));   
    Foo foo = func(123); 
    string s = foo.ToString(); // proof 

Answer 7

risposta di

Marc Gravell mi ha ispirato al seguente soluzione molto semplice:

static void Main() 
{ 
    Pet a = _MakeObject(typeof(Dog)); 
    Pet b = _MakeObject(typeof(Cat)); 
} 

private static Pet _MakeObject(Type type) 
{ 
    ConstructorInfo info = type.GetConstructor(new Type[0]); 
    return (Pet)info?.Invoke(null); 
} 

Quasi la stessa cosa se il costruttore ha param (in th è un esempio: 1 parametro di tipo int):

static void Main() 
{ 
    Pet a = _MakeObject(typeof(Dog), 5); 
    Pet b = _MakeObject(typeof(Cat), 7); 
} 

private static Pet _MakeObject(Type type, int age) 
{ 
    ConstructorInfo info = type.GetConstructor(new [] { typeof(int) }); 
    return (Pet)info?.Invoke(new object[] { age }); 
}