C# pass a delegate an argument list for a class constructor in a fairly concise way

Question

In C# can I pass a delegate an argument list for a class constructor in a fairly concise way?

I know this is extremely situational and may seem a bit of an odd request, also it's not for the factory pattern. If it helps think of it as a challenge. The correct answer to this question may be that it is not possible.

Func<MyClassConstructionArgsType, MyClass> make_MyClass =
    args => {return new MyClass(args);};

var n = make_MyClass(comma separated arguments);

I also need there to not be a copy of the description of what the arguments are, the below for example is not a solution:

Func<int, string, MyClass> make_MyClass =
    (a, b) => {return new MyClass(a, b);};

Or, for the same reasons this:

Class Args
{
    ...
}

Func<Args, MyClass> make_MyClass =
    a => {return new MyClass(a);};

var n = make_MyClass(Args(args));

Dito where this is the case:

var n = make_MyClass<MyClass>(comma separated arguments);

The Object[]{comma separated arguments} approach is good except that optional parameters also need to be supported.

This question was created as a result of Anastasiosyal's answer from the following question: c# class reference as opposed to instance reference

Josh first answer seems as close as is possible in C#.

Answer 1

Not without some form of reflection.

You could create a delegate that uses Activator:

Func<Object[], MyClass> makeClass =
   args => (MyClass) Activator.CreateInstance(typeof (MyClass), args);

makeClass(new object[] {"String", 32});

But this is as close as you can get using a delegate. However, if you create a static helper you can make this much nicer to look at:

public static T BuildType<T>(params Object[] args) {
   return (T) Activator.CreateInstance(typeof (T), args);
}

BuildType<MyClass>("String", 32);

Again, without reflection I'm not sure you can really achieve what you want.

Answer 2

How about something along the folowing lines:

public delegate object VariableParamFactoryFunc(params object[] constructorParams);

public class Factory
{
    private Dictionary<Type, VariableParamFactoryFunc> _registeredTypes = new Dictionary<Type, VariableParamFactoryFunc>();

    public void RegisterType<T>(VariableParamFactoryFunc factoryFunc)
    {
        _registeredTypes.Add(typeof(T), factoryFunc);
    }

    public T Resolve<T>(params object resolutionParams)
    {
        VariableParamFactoryFunc factoryFunc;
        if (_registeredTypes.TryGetValue(typeof(T), out factoryFunc))
        {
            return (T)factoryFunc();
        }
        else
        {
            return default(T);
        }
    }
}

Then you would use it by first registering factory functions: (e.g.)

var factory = new Factory() // or you can turn it into a singleton, this is just for demonstration
factory.Register<IMyInterface>((a, b, c) => new ConcreteImplementation(a, b, c))
factory.Register<CustomClass>((a, b) => new CustomClass(a, b));

and then by actually resolving and consuming those factory functions:

IMyInterface myInterface = factory.Resolve<IMyInterface>(1, "string", 2.412);
CustomClass customClass = factory.Resolve<CustomClass>("param1", 1234);

This should allow you flexibility in Resolving constructors with variable number of parameters without paying the performance penalty of Activator.CreateInstance or Reflection, but you loose in type safety since all parameters will be cast to objects and you will need to cast them back to the right type in the factory function

Good luck!

Answer 3

I'm still not 100% clear on what you are looking for here, but I'll have a swing at it.

I'm assuming that you want to create a delegate that invokes a class's constructor, returning a new instance of that class. The trivial way of doing this is:

var makeX = new Func<String, Integer, X>((s,i)=>new X(s,i));

// To use it
var myX = makeX("Foo", 5);

I am not sure why that isn't 'acceptable' in your use case. If you can point out specific technical or syntactic problems with this approach, I'll try to address them.

EDIT:

Assuming that it is acceptable to predefine your own delegates:

delegate X makeX(String s, Integer i);

then you can do:

var myMakeX = new makeX((s,i)=>new X(s,i));

// To use it
var myX = myMakeX("Foo", 5);

But I suspect that's about as short as you can get. Now, if you know ahead of time that, for instance, all of the time you want to specify "Foo" as the value for s, then you can create another delegate that short-circuits that (using a technique called currying):

var myCurryMaker = new Func<String, Func<Integer, X>>(s => return new Func<Integer, X>(i => new X(s, i)));
var myCurriedX = myCurryMaker("Foo");

// To use it
var myX = myCurriedX(5);