Unity InjectionConstructor for multiparam constructor overriding only single one

Question

I have a class with constructor like this:

public class Bar
{
    public Bar(IFoo foo, IFoo2 foo2, IFoo3 foo3, IFooN fooN, String text)
    {

    }
}

I want to register Bar in Unity and provide a value for text:

unity.RegisterType<Bar, Bar>(new InjectionConstructor("123"));

However I can't do this because there is no single parameter constructor for Bar.

Is there a way to provide a value for text without specifying all other parameters as ResolvedParameter<IFooN> etc.. I really don't like it, lot's of code, and every time I change a constructor of Bar I need to add another ResolvedParameter

Microchemistry

FWIW, This is so easy in AutoFac out of the box: builder.RegisterType<Bar>() .WithParameter("text", "the text value") – Respondence

Answer 1

Unity can't do this out of the box. The best you can do is:

container.RegisterType<Bar>(
    new InjectionConstructor(
        typeof(IFoo), typeof(IFoo2), typeof(IFoo3), typeof(IFooN), "123"));

Or you can use the SmartConstructor provided by the TecX project. This blog post describes some background.

Registration would look like this:

container.RegisterType<Bar>(new SmartConstructor("text", "123"));

Suzansuzann

If you need to pass null instead of "123" you will need to use new InjectionParameter<string>(null) – Omura

Using typeof(IFoo) saved me, I couldn't figure out what to pass to the InjectionConstructor. – Oxalate

Answer 2

public void Register<TFrom>(params object[] constructorParams) where TFrom : class
        {
            _container.RegisterType<TFrom>(new InjectionConstructor(constructorParams));
        }

Wentz

Answer 3

I used to do that as described in the answer above (that's using InjectionConstructor). The problem with that is that if the signature of the constructor is changed but InjectionConstructor is not updated, then we will know that only at run time. I think that there is a cleaner way to do that and without getting deep into details of the signature of the constructor. Here is how:

public interface IBar
{
    void DoSomethingWithBar();
}

public interface IMyStringPrameterForBar
{
    string Value { get; }
}

public class MyStringPrameterForBar : IMyStringPrameterForBar
{
    public string Value { get; }
    public MyStringPrameterForBar(string value) => Value = value; 
}

public class Bar : IBar
{
    public Bar(IFoo foo, IFoo2 foo2, IFoo3 foo3, IFooN fooN, IMyStringPrameterForBar text)
    {
    }

    public void DoSomethingWithBar() {}
}

Then when registering interfaces, just add:

unity.RegisterType<IFoo, Foo>();
unity.RegisterType<IFoo2, Foo2>();
unity.RegisterType<IFooN, FooN>();
unity.RegisterInstance(new MyStrignPrameterForBar("123"));
unity.RegisterType<IBar, Bar>();

That's all. if tomorrow Bar needs to take more or less parameters, then after adding or removing extra Foo<N + 1> Unity will still automatically construct Bar.

PS I don't think that interface IMyStringPrameterForBar is actually required. However, I prefer to see only interfaces in Unity registrations because it is much easier to twist them around during tests and/or for any other purpose.

Olive