Nancy bootstrapper with StructureMap (without just in time registrations)

StructureMapNancyBootstrapper.cs

public class StructureMapNancyBootstrapper : StructureMapNancyBootstrapperBase
{
    public StructureMapNancyBootstrapper() : base(typeof(MyModule).Assembly)
    {
    }

    protected override IContainer GetApplicationContainer()
    {
        return new Container();
    }

    protected override void ApplicationStartup(IContainer applicationContainer, IPipelines pipelines)
    {
    }

    protected override void RequestStartup(IContainer requestContainer, IPipelines pipelines, NancyContext context)
    {
    }
}

StructureMapNancyBootstrapperBase.cs

public abstract class StructureMapNancyBootstrapperBase : NancyBootstrapperWithRequestContainerBase<IContainer>
{
    readonly Type[] moduleTypes;

    protected StructureMapNancyBootstrapperBase() : this(Assembly.GetCallingAssembly())
    {
    }

    protected StructureMapNancyBootstrapperBase(params Type[] moduleTypes)
    {
        this.moduleTypes = moduleTypes;
    }

    protected StructureMapNancyBootstrapperBase(params Assembly[] moduleAssemblies)
    {
        moduleTypes = moduleAssemblies
            .SelectMany(a => a.GetExportedTypes())
            .Where(t => typeof(INancyModule).IsAssignableFrom(t))
            .ToArray();
    }

    public IContainer Container
    {
        get { return ApplicationContainer; }
    }

    protected override IContainer GetApplicationContainer()
    {
        return new Container();
    }

    protected override IContainer CreateRequestContainer()
    {
        return ApplicationContainer.GetNestedContainer();
    }

    protected override void ConfigureApplicationContainer(IContainer applicationContainer)
    {
        applicationContainer.Configure(registry =>
        {
            foreach (var moduleType in moduleTypes)
            {
                registry.For(moduleType, Lifecycles.Transient).Use(moduleType);
                registry.For(typeof(INancyModule), Lifecycles.Transient).Use(moduleType);
            }
        });
    }

    protected override void ApplicationStartup(IContainer applicationContainer, IPipelines pipelines)
    {
    }

    protected override void RequestStartup(IContainer requestContainer, IPipelines pipelines, NancyContext context)
    {
    }

    protected override void RegisterBootstrapperTypes(IContainer applicationContainer)
    {
        applicationContainer.Configure(registry =>
        {
            registry.For<INancyModuleCatalog>(Lifecycles.Singleton).Use(this);
            registry.For<IFileSystemReader>(Lifecycles.Singleton).Use<DefaultFileSystemReader>();
            registry.For<Func<IRouteCache>>(Lifecycles.Singleton).Use(context => new Func<IRouteCache>(context.GetInstance<IRouteCache>));
        });
    }

    protected override void RegisterTypes(IContainer applicationContainer, IEnumerable<TypeRegistration> typeRegistrations)
    {
        applicationContainer.Configure(registry =>
        {
            foreach (var typeRegistration in typeRegistrations)
            {
                registry.For(typeRegistration.RegistrationType, Lifecycles.Singleton).Use(typeRegistration.ImplementationType);
            }
        });
    }

    protected override void RegisterCollectionTypes(IContainer applicationContainer, IEnumerable<CollectionTypeRegistration> collectionTypeRegistrations)
    {
        applicationContainer.Configure(registry =>
        {
            foreach (var collectionTypeRegistration in collectionTypeRegistrations)
            {
                foreach (var implementationType in collectionTypeRegistration.ImplementationTypes)
                {
                    registry.For(collectionTypeRegistration.RegistrationType, Lifecycles.Singleton).Use(implementationType);
                }
            }
        });
    }

    protected override void RegisterInstances(IContainer applicationContainer, IEnumerable<InstanceRegistration> instanceRegistrations)
    {
        applicationContainer.Configure(registry =>
        {
            foreach (var instanceRegistration in instanceRegistrations)
            {
                registry.For(instanceRegistration.RegistrationType, Lifecycles.Singleton).Use(instanceRegistration.Implementation);
            }
        });
    }

    protected override void RegisterRequestContainerModules(IContainer requestContainer, IEnumerable<ModuleRegistration> moduleRegistrations)
    {
        // Not using just in time registrations
    }

    protected override INancyEngine GetEngineInternal()
    {
        return ApplicationContainer.GetInstance<INancyEngine>();
    }

    protected override IEnumerable<IApplicationStartup> GetApplicationStartupTasks()
    {
        return ApplicationContainer.GetAllInstances<IApplicationStartup>();
    }

    protected override IEnumerable<IApplicationRegistrations> GetApplicationRegistrationTasks()
    {
        return ApplicationContainer.GetAllInstances<IApplicationRegistrations>();
    }

    protected override IDiagnostics GetDiagnostics()
    {
        return ApplicationContainer.GetInstance<IDiagnostics>();
    }

    protected override IEnumerable<INancyModule> GetAllModules(IContainer container)
    {
        return container.GetAllInstances<INancyModule>();
    }

    protected override INancyModule GetModule(IContainer container, Type moduleType)
    {
        return (INancyModule)container.GetInstance(moduleType);
    }
}