How can I make Autofac inject different uniquely initialized instances of the same class to different controllers?

Question

I have 2 controllers, both require an object of the MySettings type which represents a set of settings. Each controller needs its custom set of settings. In order to do that at the registration of the module I create 2 settings objects by hand and put them both to the container. Question is how can I specify that each controller is supposed to be injected with its own pre-defined custom-initialized instance of the MySettings type?

UPDATE:

Now there is an ugly workaround in place that basically renders Autofac useless as all resolving is done by hand:

public class MyModule : Module {
    protected override void Load(ContainerBuilder builder) {
        builder.Register(context => {
            var productControllerSettings = new MyListSettings(
                pageSize: 20,
                orderBy: "Name",
                orderDirection: OrderDirection.Ascending
            );
            // and hell of other parameters that I need to resove
            // by hands by doing context.Resolve<...> for each of them
            var productController = new ProductController(
                productControllerSettings
                /*, the reset of parameters */
            );
            return productController;
        });

        builder.Register(context => {
            var userControllerSettings = new MyListSettings {
                pageSize: 20,
                orderBy: "LastName",
                orderDirection: OrderDirection.Ascending
            };
            var userController = new UserController(
                userControllerSettings
                /*, the rest of parameters resolved by calling context.Resolve<> by hands */
            );
            return userController;
        });
    }
}

There must be a better way of doing it I hope.

UPDATE2:

Another way of getting around this shortfall is to make 2 new classes of settings based on MySettings class. This way each instance uniquely corresponds to a class and Autofac can easily resolve it. I don't want to do just for the sake of making Autofac work.

Answer 1

The easiest solution would be to use the Named registration feature of Autofac.

So register your MyControllerSettings instances with a name and use this name as a parameter when registering your controllers:

var productControllerSettings = new MyListSettings(
    pageSize: 20,
    orderBy: "Name",
    orderDirection: OrderDirection.Ascending);

builder.RegisterInstance(productControllerSettings)
       .Named<MyListSettings>("productControllerSettings");

var userControllerSettings = new MyListSettings(
        pageSize: 20,
        orderBy: "LastName",
        orderDirection: OrderDirection.Ascending);
builder.RegisterInstance(userControllerSettings)
       .Named<MyListSettings>("userControllerSettings");

builder.RegisterType<ProductController>()
    .WithParameter(
        ResolvedParameter.ForNamed<MyListSettings>("productControllerSettings"));

builder.RegisterType<UserController>()
    .WithParameter(
        ResolvedParameter.ForNamed<MyListSettings>("userControllerSettings"));

However this solution requires to list all the controller - named parameter pairs during the registration which could be error-prone.

A different approach would be that you don't directly depend on the MyListSettings in your controllers but a on "MyListSettings" provider. You can have this provider as a concrete class or you can use the Autofac's built in relation types for this like IIndex to create a lightweight provider.

So your controllers could look like this:

public class ProductController
{
    private readonly MyListSettings productControllerSettings;

    public ProductController(Func<Type, MyListSettings> settingsProvider)
    {
        this.productControllerSettings = settingsProvider(GetType());
    }
}

public class UserController
{
    private readonly MyListSettings userControllerSettings;

    public UserController(Func<Type, MyListSettings> settingsProvider)
    {
        this.userControllerSettings = settingsProvider(GetType());
    }
}

And the corresponding registration:

var productControllerSettings = new MyListSettings(
    pageSize: 25,
    orderBy: "Name",
    orderDirection: OrderDirection.Ascending);

builder.RegisterInstance(productControllerSettings)
       .Keyed<MyListSettings>(typeof (UserController1));

var userControllerSettings = new MyListSettings(
    pageSize: 20,
    orderBy: "LastName",
    orderDirection: OrderDirection.Ascending);

builder.RegisterInstance(userControllerSettings)
       .Keyed<MyListSettings>(typeof (ProductController1));

//register the provider func
builder.Register<Func<Type, MyListSettings>>(
    c => (t) => c.Resolve<IIndex<Type, MyListSettings>>()[t]);

builder.RegisterType<ProductController>();
builder.RegisterType<UserController>();

You should note that you can use anything for the Keyed not just the a Type anything what you can for identified which controller should get which settings so strings, enums, etc.

Answer 2

Another alternative would be to use AutoFac's Metadata features.

public UserController(IEnumerable<Meta<ISettings>> allSettings)
{
    this.settings = allSettings.Where(s => ....);
}

This would allow you to fetch multiple settings objects and select the ones you want based on metadata supplied with each one.