a constructor as a delegate - is it possible in C#?
I think as concise as you're going to get (without moving to a factory pattern) would be something with anonymous methods, like this:
delegate Foo FooGenerator(int x);
...
void DoStuff()
{
YourDelegateConsumer(x => new Foo(x));
}
This isn't doing strictly what you asked for (since you're passing a delegate to an anonymous method that returns a new instance, rather than a direct delegate to the constructor), but I don't think what you're asking for is strictly possible.
This is, of course, assuming you're using 3.5+
Nope, the CLR does not allow binding delegates to ConstructorInfo
.
You can however just create your own:
static T Make<T>(Action<T> init) where T : new()
{
var t = new T();
init(t);
return t;
}
Usage
var t = Make<Foo>( x => { x.Bar = "bar"; x.Baz = 1; });
I'm assuming you would normally do something like this as part of a factory implementation, where the actual types aren't known at compile-time...
First, note that an easier approach may be a post-create init step, then you can use generics:
static T Create<T>({args}) where T : class, ISomeInitInterface, new() {
T t = new T();
t.Init(args);
return t;
}
You can then use MakeGenericMethod
and/or CreateDelegate
.
Otherwise; you can do this with on the fly with Expression
(3.5) or DynamicMethod
(2.0).
The Expression
approach is easier to code:
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
or (using 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