A NancyFx Bootstrapper for LightInject

Bootstrapper

namespace HelloWorldNancy
{
    using System;
    using System.Collections.Generic;

    using LightInject;

    using Nancy;
    using Nancy.Bootstrapper;
    using Nancy.Diagnostics;
    using Nancy.ViewEngines;

    public abstract class LightInjectBootstrapper : NancyBootstrapperWithRequestContainerBase<Scope>
    {
        protected IServiceContainer ServiceContainer;

        protected virtual void Configure(IServiceRegistry serviceRegistry)
        {
            
        }

        protected sealed override Scope GetApplicationContainer()
        {
            ServiceContainer = new ServiceContainer();
            Configure(ServiceContainer);
            return null;
        }

        /// <summary>
        /// Creates a per request child/nested container
        /// </summary>
        /// <returns>
        /// Request container instance
        /// </returns>
        protected sealed override Scope CreateRequestContainer()
        {
            return ServiceContainer.BeginScope();
        }

        /// <summary>
        /// Resolve INancyEngine
        /// </summary>
        /// <returns>
        /// INancyEngine implementation
        /// </returns>
        protected sealed override INancyEngine GetEngineInternal()
        {
            return ServiceContainer.GetInstance<INancyEngine>();
        }

        /// <summary>
        /// Register the bootstrapper's implemented types into the container.
        ///             This is necessary so a user can pass in a populated container but not have
        ///             to take the responsibility of registering things like INancyModuleCatalog manually.
        /// </summary>
        /// <param name="applicationContainer">Application container to register into</param>
        protected override void RegisterBootstrapperTypes(Scope applicationContainer)
        {
            ServiceContainer.RegisterInstance<INancyModuleCatalog>(this);
        }

        /// <summary>
        /// Gets the diagnostics for initialisation
        /// </summary>
        /// <returns>
        /// IDiagnostics implementation
        /// </returns>
        protected override IDiagnostics GetDiagnostics()
        {
            return ServiceContainer.GetInstance<IDiagnostics>();
        }

        /// <summary>
        /// Gets all registered application startup tasks
        /// </summary>
        /// <returns>
        /// An <see cref="T:System.Collections.Generic.IEnumerable`1"/> instance containing <see cref="T:Nancy.Bootstrapper.IApplicationStartup"/> instances.
        /// </returns>
        protected override IEnumerable<IApplicationStartup> GetApplicationStartupTasks()
        {
            var result = ServiceContainer.GetAllInstances<IApplicationStartup>();
            return result;
        }

        /// <summary>
        /// Gets all registered application registration tasks
        /// </summary>
        /// <returns>
        /// An <see cref="T:System.Collections.Generic.IEnumerable`1"/> instance containing <see cref="T:Nancy.Bootstrapper.IApplicationRegistrations"/> instances.
        /// </returns>
        protected override IEnumerable<IApplicationRegistrations> GetApplicationRegistrationTasks()
        {
            var result = ServiceContainer.GetAllInstances<IApplicationRegistrations>();
            return result;
        }

        /// <summary>
        /// Register the default implementations of internally used types into the container as singletons
        /// </summary>
        /// <param name="container">Container to register into</param><param name="typeRegistrations">Type registrations to register</param>
        protected override void RegisterTypes(Scope container, IEnumerable<TypeRegistration> typeRegistrations)
        {
            foreach (var typeRegistration in typeRegistrations)
            {
                ServiceContainer.Register(typeRegistration.RegistrationType, typeRegistration.ImplementationType, new PerContainerLifetime());
            }

             ServiceContainer.Register<IFileSystemReader, DefaultFileSystemReader>(new PerContainerLifetime());
        
        }

        /// <summary>
        /// Register the given instances into the container
        /// </summary>
        /// <param name="container">Container to register into</param><param name="instanceRegistrations">Instance registration types</param>
        protected override void RegisterInstances(Scope container, IEnumerable<InstanceRegistration> instanceRegistrations)
        {
            foreach (var instanceRegistration in instanceRegistrations)
            {
                ServiceContainer.RegisterInstance(
                    instanceRegistration.RegistrationType,
                    instanceRegistration.Implementation);
            }
        }

        /// <summary>
        /// Register the various collections into the container as singletons to later be resolved
        ///             by IEnumerable{Type} constructor dependencies.
        /// </summary>
        /// <param name="container">Container to register into</param><param name="collectionTypeRegistrations">Collection type registrations to register</param>
        protected override void RegisterCollectionTypes(Scope container, IEnumerable<CollectionTypeRegistration> collectionTypeRegistrations)
        {
            foreach (var collectionTypeRegistration in collectionTypeRegistrations)
            {
                foreach (var typeRegistration in collectionTypeRegistration.ImplementationTypes)
                {
                    ServiceContainer.Register(
                        collectionTypeRegistration.RegistrationType,
                        typeRegistration,
                        typeRegistration.FullName,
                        new PerContainerLifetime());
                }
            }
        }

        /// <summary>
        /// Register the given module types into the request container
        /// </summary>
        /// <param name="container">Container to register into</param><param name="moduleRegistrationTypes">NancyModule types</param>
        protected override void RegisterRequestContainerModules(Scope container, IEnumerable<ModuleRegistration> moduleRegistrationTypes)
        {
            foreach (var moduleRegistrationType in moduleRegistrationTypes)
            {
                ServiceContainer.Register(
                    typeof(INancyModule),
                    moduleRegistrationType.ModuleType,
                    moduleRegistrationType.ModuleType.FullName,
                    new PerScopeLifetime());
            }
        }

        /// <summary>
        /// Retrieve all module instances from the container
        /// </summary>
        /// <param name="container">Container to use</param>
        /// <returns>
        /// Collection of NancyModule instances
        /// </returns>
        protected override IEnumerable<INancyModule> GetAllModules(Scope container)
        {
            return ServiceContainer.GetAllInstances<INancyModule>();
        }

        protected override INancyModule GetModule(Scope container, Type moduleType)
        {
            return ServiceContainer.GetInstance<INancyModule>(moduleType.FullName);
        }

        
        
    }
}

Usage

    public class Bootstrapper : LightInjectBootstrapper
    {    
        protected override void Configure(IServiceRegistry serviceRegistry)
        {
            serviceRegistry.Register<IFoo, Foo>(new PerScopeLifetime());
        }
    }