How to pass configuration parameters to SimpleInjector packaging?

Question

So SimpleInjector now has a packaging nuget that you can use to isolate different aspects of root composition.

Say I have a configurable composition root in a library that is reused by multiple projects in an application. For example, in an Azure solution I might have a Web role and a Worker role which share a large set of the same dependencies for the most part, but with slightly different configuration options depending on the consumer. When I compose the root, I can pass in a plain old RootCompositionSettings object with properties that tell SimpleInjector how to register dependencies.

However, I am not sure how (or if) I can pass these settings to an IPackage instance. Is it possible to pass custom settings to a SimpleInjector package, and if so, how?

I see that the standard practices for registering packages is to invoke either

container.RegisterPackages(); // scans all loaded assemblies for IPackage
// or
container.RegisterPackages(IEnumerable<Assembly>) // specific assemblies only

...so how can we pass parameters into the packaging instance(s)? Is there some way to do it via the container?

Answer 1

The trick here is to pass the information on with the container to the package. You can do this by using the container's Items dictionary, that is much like ASP.NET's HttpContext.Items collection. This can be done as follows:

using SimpleInjector.Advanced;

container.SetItem(typeof(RootCompositionSettings), settings);

container.RegisterPackages();

Now inside your packages, you can do the following:

var settings = (RootCompositionSettings)container.GetItem(typeof(RootCompositionSettings));

Please note that:

• SetItem and GetItem are extension methods that are located in the SimpleInjector.Advanced namespace. Those methods allow you to access the (internal) Items dictionary.
• You can pass in any key you like. Passing in typeof(RootCompositionSettings) is just convenient in this case, but not required.

If you need to call the settings in more places, it might be useful to create a more specific extension method that allows you to access the setting instance, but that's up to you.

Another option is to not use the IPackage interface and the SimpleInjector.Packaging library at all. In most cases it doesn't really add anything and you could simply define a public static method in the assembly that does the same as a package does. For instance:

public static class BusinessLayerBootstrapper
{
    public static void Bootstrap(Container container, ScopedLifestyle scopedLifestyle,
        RootCompositionSettings settings)
    {
        // Here the same logic as what you would write in your package.
    }
}

Most applications are not that dynamic that you need to load assemblies dynamically and the startup project usually has a hard reference to all the other assemblies. In that case it is perfectly sane to simply call a static method.

And even if you have the requirement of dynamically loading assemblies and allowing them to register their stuff in the container, it's quite trivial to build your own IPackage abstraction instead:\

// Your own IPackage interface
public interface IPackage
{
    void RegisterServices(Container container, RootCompositionSettings settings);
}

// Your own extension method
public static void RegisterPackages(this Container container, 
    RootCompositionSettings settings)
{
    var packages =
        from assembly in AppDomain.CurrentDomain.GetAssemblies()
        from type in assembly.GetExportedTypes()
        where typeof(IPackage).IsAssignableFrom(type)
        where !type.IsAbstract
        select (IPackage)Activator.CreateInstance(type);

    packages.ToList().ForEach(p => p.RegisterServices(container, settings));
}

In fact, except for some extra validations and filtering out dynamic assemblies, the SimpleInjector.Packaging project is not much more than this.