diff --git a/src/Umbraco.Core/Components/Composition.cs b/src/Umbraco.Core/Components/Composition.cs
index dd0b83dcb3..6cd8c8e5f0 100644
--- a/src/Umbraco.Core/Components/Composition.cs
+++ b/src/Umbraco.Core/Components/Composition.cs
@@ -17,7 +17,7 @@ namespace Umbraco.Core.Components
     public class Composition : IRegister
     {
         private readonly Dictionary<Type, ICollectionBuilder> _builders = new Dictionary<Type, ICollectionBuilder>();
-        private readonly Dictionary<Type, Unique> _uniques = new Dictionary<Type, Unique>();
+        private readonly Dictionary<string, Action<IRegister>> _uniques = new Dictionary<string, Action<IRegister>>();
         private readonly IRegister _register;
 
         /// <summary>
@@ -81,14 +81,30 @@ namespace Umbraco.Core.Components
         public void Register(Type serviceType, Type implementingType, Lifetime lifetime = Lifetime.Transient)
             => _register.Register(serviceType, implementingType, lifetime);
 
+        /// <inheritdoc />
+        public void RegisterFor<TService, TTarget>(Type implementingType, Lifetime lifetime = Lifetime.Transient)
+            where TService : class
+            => _register.RegisterFor<TService, TTarget>(implementingType, lifetime);
+
         /// <inheritdoc />
         public void Register<TService>(Func<IFactory, TService> factory, Lifetime lifetime = Lifetime.Transient)
+            where TService : class
             => _register.Register(factory, lifetime);
 
+        /// <inheritdoc />
+        public void RegisterFor<TService, TTarget>(Func<IFactory, TService> factory, Lifetime lifetime = Lifetime.Transient)
+            where TService : class
+            => _register.RegisterFor<TService, TTarget>(factory, lifetime);
+
         /// <inheritdoc />
         public void RegisterInstance(Type serviceType, object instance)
             => _register.RegisterInstance(serviceType, instance);
 
+        /// <inheritdoc />
+        public void RegisterInstanceFor<TService, TTarget>(TService instance)
+            where TService : class
+            => _register.RegisterInstanceFor<TService, TTarget>(instance);
+
         /// <inheritdoc />
         public void RegisterAuto(Type serviceBaseType)
             => _register.RegisterAuto(serviceBaseType);
@@ -104,10 +120,12 @@ namespace Umbraco.Core.Components
                 onCreating();
 
             foreach (var unique in _uniques.Values)
-                unique.RegisterWith(_register);
+                unique(_register);
+            _uniques.Clear(); // no point keep them around
 
             foreach (var builder in _builders.Values)
                 builder.RegisterWith(_register);
+            _builders.Clear(); // no point keep them around
 
             Configs.RegisterWith(_register);
 
@@ -123,74 +141,63 @@ namespace Umbraco.Core.Components
 
         #region Unique
 
-        /// <summary>
-        /// Registers a unique service.
-        /// </summary>
-        /// <remarks>Unique services have one single implementation, and a Singleton lifetime.</remarks>
-        public void RegisterUnique(Type serviceType, Type implementingType)
-            => _uniques[serviceType] = new Unique(serviceType, implementingType);
+        private string GetUniqueName<TService>()
+            => GetUniqueName(typeof(TService));
+
+        private string GetUniqueName(Type serviceType)
+            => serviceType.FullName;
+
+        private string GetUniqueName<TService, TTarget>()
+            => GetUniqueName(typeof(TService), typeof(TTarget));
+
+        private string GetUniqueName(Type serviceType, Type targetType)
+            => serviceType.FullName + "::" + targetType.FullName;
 
         /// <summary>
         /// Registers a unique service.
         /// </summary>
         /// <remarks>Unique services have one single implementation, and a Singleton lifetime.</remarks>
-        public void RegisterUnique(Type serviceType, object instance)
-            => _uniques[serviceType] = new Unique(serviceType, instance);
+        public void RegisterUnique(Type serviceType, Type implementingType)
+            => _uniques[GetUniqueName(serviceType)] = register => register.Register(serviceType, implementingType, Lifetime.Singleton);
+
+        /// <summary>
+        /// Registers a unique service, for a target.
+        /// </summary>
+        /// <remarks>Unique services have one single implementation, and a Singleton lifetime.</remarks>
+        public void RegisterUniqueFor<TService, TTarget>(Type implementingType)
+            where TService : class
+            => _uniques[GetUniqueName<TService, TTarget>()] = register => register.RegisterFor<TService, TTarget>(implementingType, Lifetime.Singleton);
+
+        /// <summary>
+        /// Registers a unique service.
+        /// </summary>
+        /// <remarks>Unique services have one single implementation, and a Singleton lifetime.</remarks>
+        public void RegisterUniqueInstance(Type serviceType, object instance)
+            => _uniques[GetUniqueName(serviceType)] = register => register.RegisterInstance(serviceType, instance);
+
+        /// <summary>
+        /// Registers a unique service, for a target.
+        /// </summary>
+        /// <remarks>Unique services have one single implementation, and a Singleton lifetime.</remarks>
+        public void RegisterUniqueInstanceFor<TService, TTarget>(TService instance)
+            where TService : class
+            => _uniques[GetUniqueName<TService, TTarget>()] = register => register.RegisterInstanceFor<TService, TTarget>(instance);
 
         /// <summary>
         /// Registers a unique service.
         /// </summary>
         /// <remarks>Unique services have one single implementation, and a Singleton lifetime.</remarks>
         public void RegisterUnique<TService>(Func<IFactory, TService> factory)
-            => _uniques[typeof(TService)] = new Unique<TService>(factory);
+            where TService : class
+            => _uniques[GetUniqueName<TService>()] = register => register.Register<TService>(factory, Lifetime.Singleton);
 
-        private class Unique
-        {
-            private readonly Type _serviceType;
-            private readonly Type _implementingType;
-            private readonly object _instance;
-
-            protected Unique(Type serviceType)
-            {
-                _serviceType = serviceType;
-            }
-
-            public Unique(Type serviceType, Type implementingType)
-                : this(serviceType)
-            {
-                _implementingType = implementingType;
-            }
-
-            public Unique(Type serviceType, object instance)
-                : this(serviceType)
-            {
-                _instance = instance;
-            }
-
-            public virtual void RegisterWith(IRegister register)
-            {
-                if (_implementingType != null)
-                    register.Register(_serviceType, _implementingType, Lifetime.Singleton);
-                else if (_instance != null)
-                    register.RegisterInstance(_serviceType, _instance);
-            }
-        }
-
-        private class Unique<TService> : Unique
-        {
-            private readonly Func<IFactory, TService> _factory;
-
-            public Unique(Func<IFactory, TService> factory)
-                : base(typeof(TService))
-            {
-                _factory = factory;
-            }
-
-            public override void RegisterWith(IRegister register)
-            {
-                register.Register(_factory, Lifetime.Singleton);
-            }
-        }
+        /// <summary>
+        /// Registers a unique service, for a target.
+        /// </summary>
+        /// <remarks>Unique services have one single implementation, and a Singleton lifetime.</remarks>
+        public void RegisterUniqueFor<TService, TTarget>(Func<IFactory, TService> factory)
+            where TService : class
+            => _uniques[GetUniqueName<TService, TTarget>()] = register => register.RegisterFor<TService, TTarget>(factory, Lifetime.Singleton);
 
         #endregion
 
diff --git a/src/Umbraco.Core/Components/CompositionExtensions.cs b/src/Umbraco.Core/Components/CompositionExtensions.cs
index 93d190d17e..a4bc82cb4b 100644
--- a/src/Umbraco.Core/Components/CompositionExtensions.cs
+++ b/src/Umbraco.Core/Components/CompositionExtensions.cs
@@ -26,15 +26,16 @@ namespace Umbraco.Core.Components
         /// <typeparam name="TFileSystem">The type of the filesystem.</typeparam>
         /// <typeparam name="TImplementing">The implementing type.</typeparam>
         /// <param name="composition">The composition.</param>
-        /// <param name="supportingFileSystemFactory">A factory method creating the supporting filesystem.</param>
         /// <returns>The register.</returns>
-        public static void RegisterFileSystem<TFileSystem, TImplementing>(this Composition composition, Func<IFactory, IFileSystem> supportingFileSystemFactory)
+        public static void RegisterFileSystem<TFileSystem, TImplementing>(this Composition composition)
             where TImplementing : FileSystemWrapper, TFileSystem
+            where TFileSystem : class
         {
             composition.RegisterUnique<TFileSystem>(factory =>
             {
                 var fileSystems = factory.GetInstance<FileSystems>();
-                return fileSystems.GetFileSystem<TImplementing>(supportingFileSystemFactory(factory));
+                var supporting = factory.GetInstance<SupportingFileSystems>();
+                return fileSystems.GetFileSystem<TImplementing>(supporting.For<TFileSystem>());
             });
         }
 
@@ -43,15 +44,15 @@ namespace Umbraco.Core.Components
         /// </summary>
         /// <typeparam name="TFileSystem">The type of the filesystem.</typeparam>
         /// <param name="composition">The composition.</param>
-        /// <param name="supportingFileSystemFactory">A factory method creating the supporting filesystem.</param>
         /// <returns>The register.</returns>
-        public static void RegisterFileSystem<TFileSystem>(this Composition composition, Func<IFactory, IFileSystem> supportingFileSystemFactory)
+        public static void RegisterFileSystem<TFileSystem>(this Composition composition)
             where TFileSystem : FileSystemWrapper
         {
             composition.RegisterUnique(factory =>
             {
                 var fileSystems = factory.GetInstance<FileSystems>();
-                return fileSystems.GetFileSystem<TFileSystem>(supportingFileSystemFactory(factory));
+                var supporting = factory.GetInstance<SupportingFileSystems>();
+                return fileSystems.GetFileSystem<TFileSystem>(supporting.For<TFileSystem>());
             });
         }
 
diff --git a/src/Umbraco.Core/Composing/CollectionBuilderBase.cs b/src/Umbraco.Core/Composing/CollectionBuilderBase.cs
index 7633f6b001..41038ea4e9 100644
--- a/src/Umbraco.Core/Composing/CollectionBuilderBase.cs
+++ b/src/Umbraco.Core/Composing/CollectionBuilderBase.cs
@@ -12,7 +12,7 @@ namespace Umbraco.Core.Composing
     /// <typeparam name="TItem">The type of the items.</typeparam>
     public abstract class CollectionBuilderBase<TBuilder, TCollection, TItem> : ICollectionBuilder<TCollection, TItem>
         where TBuilder: CollectionBuilderBase<TBuilder, TCollection, TItem>
-        where TCollection : IBuilderCollection<TItem>
+        where TCollection : class, IBuilderCollection<TItem>
     {
         private readonly List<Type> _types = new List<Type>();
         private readonly object _locker = new object();
diff --git a/src/Umbraco.Core/Composing/Composers/FileSystemsComposer.cs b/src/Umbraco.Core/Composing/Composers/FileSystemsComposer.cs
index f1fb095406..ab4bd015de 100644
--- a/src/Umbraco.Core/Composing/Composers/FileSystemsComposer.cs
+++ b/src/Umbraco.Core/Composing/Composers/FileSystemsComposer.cs
@@ -12,10 +12,9 @@ namespace Umbraco.Core.Composing.Composers
          *
          * Create a component and use it to modify the composition by adding something like:
          *
-         *   composition.Container.RegisterFileSystem<IMediaFileSystem, MediaFileSystem>(
-         *       factory => new PhysicalFileSystem("~/somewhere"));
+         *   composition.RegisterUniqueFor<IFileSystem, IMediaFileSystem>(...);
          *
-         * return whatever supporting filesystem you like.
+         * and register whatever supporting filesystem you like.
          *
          *
          * HOW TO IMPLEMENT MY OWN FILESYSTEM
@@ -30,12 +29,15 @@ namespace Umbraco.Core.Composing.Composers
          *       { }
          *   }
          *
-         * The ctor can have more parameters that will be resolved by the container.
+         * The ctor can have more parameters, that will be resolved by the container.
          *
          * Register your filesystem, in a component:
          *
-         *    composition.Container.RegisterFileSystem<MyFileSystem>(
-         *        factory => new PhysicalFileSystem("~/my"));
+         *   composition.RegisterFileSystem<MyFileSystem>();
+         *
+         * Register the underlying filesystem:
+         *
+         *   composition.RegisterUniqueFor<IFileSystem, MyFileSystem>(...);
          *
          * And that's it, you can inject MyFileSystem wherever it's needed.
          *
@@ -48,8 +50,8 @@ namespace Umbraco.Core.Composing.Composers
          * Make the class implement the interface, then
          * register your filesystem, in a component:
          *
-         *    composition.Container.RegisterFileSystem<IMyFileSystem, MyFileSystem>(
-         *        factory => new PhysicalFileSystem("~/my"));
+         *   composition.RegisterFileSystem<IMyFileSystem, MyFileSystem>();
+         *   composition.RegisterUniqueFor<IFileSystem, IMyFileSystem>(...);
          *
          * And that's it, you can inject IMyFileSystem wherever it's needed.
          *
@@ -79,9 +81,16 @@ namespace Umbraco.Core.Composing.Composers
             // register the scheme for media paths
             composition.RegisterUnique<IMediaPathScheme, TwoGuidsMediaPathScheme>();
 
-            // register the IMediaFileSystem implementation with a supporting filesystem
-            composition.RegisterFileSystem<IMediaFileSystem, MediaFileSystem>(
-                factory => new PhysicalFileSystem("~/media"));
+            // register the IMediaFileSystem implementation
+            composition.RegisterFileSystem<IMediaFileSystem, MediaFileSystem>();
+
+            // register the supporting filesystems provider
+            composition.Register(factory => new SupportingFileSystems(factory), Lifetime.Singleton);
+
+            // register the IFileSystem supporting the IMediaFileSystem
+            // this is the only thing that need to be overriden to change the supporting filesystem
+            // and, SupportingFileSystem.For<IMediaFileSystem>() returns the underlying filesystem
+            composition.RegisterUniqueFor<IFileSystem, IMediaFileSystem>(_ => new PhysicalFileSystem("~/media"));
 
             return composition;
         }
diff --git a/src/Umbraco.Core/Composing/CompositionExtensions.cs b/src/Umbraco.Core/Composing/CompositionExtensions.cs
index cfc465b59d..ac9a5d6409 100644
--- a/src/Umbraco.Core/Composing/CompositionExtensions.cs
+++ b/src/Umbraco.Core/Composing/CompositionExtensions.cs
@@ -51,11 +51,18 @@ namespace Umbraco.Core.Composing
         public static void RegisterUnique<TService, TImplementing>(this Composition composition)
             => composition.RegisterUnique(typeof(TService), typeof(TImplementing));
 
+        /// <summary>
+        /// Registers a unique service with an implementation type, for a target.
+        /// </summary>
+        public static void RegisterUniqueFor<TService, TTarget, TImplementing>(this Composition composition)
+            where TService : class
+            => composition.RegisterUniqueFor<TService, TTarget>(typeof(TImplementing));
+
         /// <summary>
         /// Registers a unique service with an implementing instance.
         /// </summary>
         public static void RegisterUnique<TService>(this Composition composition, TService instance)
-            => composition.RegisterUnique(typeof(TService), instance);
+            => composition.RegisterUniqueInstance(typeof(TService), instance);
 
         #endregion
     }
diff --git a/src/Umbraco.Core/Composing/FactoryExtensions.cs b/src/Umbraco.Core/Composing/FactoryExtensions.cs
index 2640b7f7e6..8027f2c7a1 100644
--- a/src/Umbraco.Core/Composing/FactoryExtensions.cs
+++ b/src/Umbraco.Core/Composing/FactoryExtensions.cs
@@ -17,6 +17,7 @@ namespace Umbraco.Core.Composing
         /// <returns>An instance of the specified type.</returns>
         /// <remarks>Throws an exception if the factory failed to get an instance of the specified type.</remarks>
         public static T GetInstance<T>(this IFactory factory)
+            where T : class
             => (T)factory.GetInstance(typeof(T));
 
         /// <summary>
@@ -28,6 +29,7 @@ namespace Umbraco.Core.Composing
         /// of the specified type. Throws an exception if the factory does know how
         /// to get an instance of the specified type, but failed to do so.</remarks>
         public static T TryGetInstance<T>(this IFactory factory)
+            where T : class
             => (T)factory.TryGetInstance(typeof(T));
 
         /// <summary>
@@ -42,6 +44,7 @@ namespace Umbraco.Core.Composing
         /// <para>The arguments are used as dependencies by the factory.</para>
         /// </remarks>
         public static T CreateInstance<T>(this IFactory factory, params object[] args)
+            where T : class
             => (T)factory.CreateInstance(typeof(T), args);
 
         /// <summary>
diff --git a/src/Umbraco.Core/Composing/IFactory.cs b/src/Umbraco.Core/Composing/IFactory.cs
index 9a59b1c052..20fbe33737 100644
--- a/src/Umbraco.Core/Composing/IFactory.cs
+++ b/src/Umbraco.Core/Composing/IFactory.cs
@@ -28,6 +28,15 @@ namespace Umbraco.Core.Composing
         /// <remarks>Throws an exception if the container failed to get an instance of the specified type.</remarks>
         object GetInstance(Type type);
 
+        /// <summary>
+        /// Gets a targeted instance of a service.
+        /// </summary>
+        /// <typeparam name="TService">The type of the service.</typeparam>
+        /// <typeparam name="TTarget">The type of the target.</typeparam>
+        /// <returns>The instance of the specified type for the specified target.</returns>
+        /// <remarks>Throws an exception if the container failed to get an instance of the specified type.</remarks>
+        TService GetInstanceFor<TService, TTarget>();
+
         /// <summary>
         /// Tries to get an instance of a service.
         /// </summary>
@@ -48,7 +57,8 @@ namespace Umbraco.Core.Composing
         /// Gets all instances of a service.
         /// </summary>
         /// <typeparam name="TService">The type of the service.</typeparam>
-        IEnumerable<TService> GetAllInstances<TService>();
+        IEnumerable<TService> GetAllInstances<TService>()
+            where TService : class;
 
         /// <summary>
         /// Releases an instance.
diff --git a/src/Umbraco.Core/Composing/IRegister.cs b/src/Umbraco.Core/Composing/IRegister.cs
index 8ad3db5409..d145df8790 100644
--- a/src/Umbraco.Core/Composing/IRegister.cs
+++ b/src/Umbraco.Core/Composing/IRegister.cs
@@ -33,16 +33,35 @@ namespace Umbraco.Core.Composing
         /// </summary>
         void Register(Type serviceType, Type implementingType, Lifetime lifetime = Lifetime.Transient);
 
+        /// <summary>
+        /// Registers a service with an implementation type, for a target.
+        /// </summary>
+        void RegisterFor<TService, TTarget>(Type implementingType, Lifetime lifetime = Lifetime.Transient)
+            where TService : class;
+
         /// <summary>
         /// Registers a service with an implementation factory.
         /// </summary>
-        void Register<TService>(Func<IFactory, TService> factory, Lifetime lifetime = Lifetime.Transient);
+        void Register<TService>(Func<IFactory, TService> factory, Lifetime lifetime = Lifetime.Transient)
+            where TService : class;
+
+        /// <summary>
+        /// Registers a service with an implementation factory, for a target.
+        /// </summary>
+        void RegisterFor<TService, TTarget>(Func<IFactory, TService> factory, Lifetime lifetime = Lifetime.Transient)
+            where TService : class;
 
         /// <summary>
         /// Registers a service with an implementing instance.
         /// </summary>
         void RegisterInstance(Type serviceType, object instance);
 
+        /// <summary>
+        /// Registers a service with an implementing instance, for a target.
+        /// </summary>
+        void RegisterInstanceFor<TService, TTarget>(TService instance)
+            where TService : class;
+
         /// <summary>
         /// Registers a base type for auto-registration.
         /// </summary>
diff --git a/src/Umbraco.Core/Composing/LazyCollectionBuilderBase.cs b/src/Umbraco.Core/Composing/LazyCollectionBuilderBase.cs
index a1a06621e9..46b06daf7d 100644
--- a/src/Umbraco.Core/Composing/LazyCollectionBuilderBase.cs
+++ b/src/Umbraco.Core/Composing/LazyCollectionBuilderBase.cs
@@ -12,7 +12,7 @@ namespace Umbraco.Core.Composing
     /// <typeparam name="TItem">The type of the items.</typeparam>
     public abstract class LazyCollectionBuilderBase<TBuilder, TCollection, TItem> : CollectionBuilderBase<TBuilder, TCollection, TItem>
         where TBuilder : LazyCollectionBuilderBase<TBuilder, TCollection, TItem>
-        where TCollection : IBuilderCollection<TItem>
+        where TCollection : class, IBuilderCollection<TItem>
     {
         private readonly List<Func<IEnumerable<Type>>> _producers = new List<Func<IEnumerable<Type>>>();
         private readonly List<Type> _excluded = new List<Type>();
diff --git a/src/Umbraco.Core/Composing/LightInject/LightInjectContainer.cs b/src/Umbraco.Core/Composing/LightInject/LightInjectContainer.cs
index b39622f66a..4ccc0ba838 100644
--- a/src/Umbraco.Core/Composing/LightInject/LightInjectContainer.cs
+++ b/src/Umbraco.Core/Composing/LightInject/LightInjectContainer.cs
@@ -102,18 +102,25 @@ namespace Umbraco.Core.Composing.LightInject
         /// <inheritdoc />
         public IFactory CreateFactory() => this;
 
+        private static string GetTargetedServiceName<TTarget>() => "TARGET:" + typeof(TTarget).FullName;
+
         #region Factory
 
         /// <inheritdoc />
         public object GetInstance(Type type)
             => Container.GetInstance(type);
 
+        /// <inheritdoc />
+        public TService GetInstanceFor<TService, TTarget>()
+            => Container.GetInstance<TService>(GetTargetedServiceName<TTarget>());
+
         /// <inheritdoc />
         public object TryGetInstance(Type type)
             => Container.TryGetInstance(type);
 
         /// <inheritdoc />
         public IEnumerable<T> GetAllInstances<T>()
+            where T : class
             => Container.GetAllInstances<T>();
 
         /// <inheritdoc />
@@ -139,19 +146,7 @@ namespace Umbraco.Core.Composing.LightInject
         /// <inheritdoc />
         public void Register(Type serviceType, Lifetime lifetime = Lifetime.Transient)
         {
-            switch (lifetime)
-            {
-                case Lifetime.Transient:
-                    Container.Register(serviceType);
-                    break;
-                case Lifetime.Request:
-                case Lifetime.Scope:
-                case Lifetime.Singleton:
-                    Container.Register(serviceType, GetLifetime(lifetime));
-                    break;
-                default:
-                    throw new NotSupportedException($"Lifetime {lifetime} is not supported.");
-            }
+            Container.Register(serviceType, GetLifetime(lifetime));
         }
 
         /// <inheritdoc />
@@ -173,21 +168,24 @@ namespace Umbraco.Core.Composing.LightInject
         }
 
         /// <inheritdoc />
-        public void Register<TService>(Func<IFactory, TService> factory, Lifetime lifetime = Lifetime.Transient)
+        public void RegisterFor<TService, TTarget>(Type implementingType, Lifetime lifetime = Lifetime.Transient)
+            where TService : class
         {
-            switch (lifetime)
-            {
-                case Lifetime.Transient:
-                    Container.Register(f => factory(this));
-                    break;
-                case Lifetime.Request:
-                case Lifetime.Scope:
-                case Lifetime.Singleton:
-                    Container.Register(f => factory(this), GetLifetime(lifetime));
-                    break;
-                default:
-                    throw new NotSupportedException($"Lifetime {lifetime} is not supported.");
-            }
+            Container.Register(typeof(TService), implementingType, GetTargetedServiceName<TTarget>(), GetLifetime(lifetime));
+        }
+
+        /// <inheritdoc />
+        public void Register<TService>(Func<IFactory, TService> factory, Lifetime lifetime = Lifetime.Transient)
+            where TService : class
+        {
+            Container.Register(f => factory(this), GetLifetime(lifetime));
+        }
+
+        /// <inheritdoc />
+        public void RegisterFor<TService, TTarget>(Func<IFactory, TService> factory, Lifetime lifetime = Lifetime.Transient)
+            where TService : class
+        {
+            Container.Register(f => factory(this), GetTargetedServiceName<TTarget>(), GetLifetime(lifetime));
         }
 
         private ILifetime GetLifetime(Lifetime lifetime)
@@ -211,6 +209,11 @@ namespace Umbraco.Core.Composing.LightInject
         public void RegisterInstance(Type serviceType, object instance)
             => Container.RegisterInstance(serviceType, instance);
 
+        /// <inheritdoc />
+        public void RegisterInstanceFor<TService, TTarget>(TService instance)
+            where TService : class
+            => Container.RegisterInstance(typeof(TService), instance, GetTargetedServiceName<TTarget>());
+
         /// <inheritdoc />
         public void RegisterAuto(Type serviceBaseType)
         {
diff --git a/src/Umbraco.Core/Composing/OrderedCollectionBuilderBase.cs b/src/Umbraco.Core/Composing/OrderedCollectionBuilderBase.cs
index bde1bf96c5..241b84d8d2 100644
--- a/src/Umbraco.Core/Composing/OrderedCollectionBuilderBase.cs
+++ b/src/Umbraco.Core/Composing/OrderedCollectionBuilderBase.cs
@@ -11,7 +11,7 @@ namespace Umbraco.Core.Composing
     /// <typeparam name="TItem">The type of the items.</typeparam>
     public abstract class OrderedCollectionBuilderBase<TBuilder, TCollection, TItem> : CollectionBuilderBase<TBuilder, TCollection, TItem>
         where TBuilder : OrderedCollectionBuilderBase<TBuilder, TCollection, TItem>
-        where TCollection : IBuilderCollection<TItem>
+        where TCollection : class, IBuilderCollection<TItem>
     {
         protected abstract TBuilder This { get; }
 
diff --git a/src/Umbraco.Core/Composing/RegisterExtensions.cs b/src/Umbraco.Core/Composing/RegisterExtensions.cs
index 4db1a2e9e4..9afa41e4b3 100644
--- a/src/Umbraco.Core/Composing/RegisterExtensions.cs
+++ b/src/Umbraco.Core/Composing/RegisterExtensions.cs
@@ -11,22 +11,32 @@
         public static void Register<TService, TImplementing>(this IRegister register, Lifetime lifetime = Lifetime.Transient)
             => register.Register(typeof(TService), typeof(TImplementing), lifetime);
 
+        /// <summary>
+        /// Registers a service with an implementation type, for a target.
+        /// </summary>
+        public static void RegisterFor<TService, TTarget, TImplementing>(this IRegister register, Lifetime lifetime = Lifetime.Transient)
+            where TService : class
+            => register.RegisterFor<TService, TTarget>(typeof(TImplementing), lifetime);
+
         /// <summary>
         /// Registers a service as its own implementation.
         /// </summary>
         public static void Register<TService>(this IRegister register, Lifetime lifetime = Lifetime.Transient)
+            where TService : class
             => register.Register(typeof(TService), lifetime);
 
         /// <summary>
         /// Registers a service with an implementing instance.
         /// </summary>
         public static void RegisterInstance<TService>(this IRegister register, TService instance)
+            where TService : class
             => register.RegisterInstance(typeof(TService), instance);
 
         /// <summary>
         /// Registers a base type for auto-registration.
         /// </summary>
         public static void RegisterAuto<TServiceBase>(this IRegister register)
+            where TServiceBase : class
             => register.RegisterAuto(typeof(TServiceBase));
     }
 }
diff --git a/src/Umbraco.Core/Composing/TargetedServiceProvider.cs b/src/Umbraco.Core/Composing/TargetedServiceProvider.cs
new file mode 100644
index 0000000000..3f88e1bc28
--- /dev/null
+++ b/src/Umbraco.Core/Composing/TargetedServiceProvider.cs
@@ -0,0 +1,18 @@
+namespace Umbraco.Core.Composing
+{
+    /// <summary>
+    /// Provides a base class for targeted service factories.
+    /// </summary>
+    /// <typeparam name="TService"></typeparam>
+    public abstract class TargetedServiceProvider<TService>
+    {
+        private readonly IFactory _factory;
+
+        protected TargetedServiceProvider(IFactory factory)
+        {
+            _factory = factory;
+        }
+
+        public TService For<TTarget>() => _factory.GetInstanceFor<TService, TTarget>();
+    }
+}
diff --git a/src/Umbraco.Core/Composing/WeightedCollectionBuilderBase.cs b/src/Umbraco.Core/Composing/WeightedCollectionBuilderBase.cs
index da47c53bf8..f8ecc11d98 100644
--- a/src/Umbraco.Core/Composing/WeightedCollectionBuilderBase.cs
+++ b/src/Umbraco.Core/Composing/WeightedCollectionBuilderBase.cs
@@ -12,7 +12,7 @@ namespace Umbraco.Core.Composing
     /// <typeparam name="TItem">The type of the items.</typeparam>
     public abstract class WeightedCollectionBuilderBase<TBuilder, TCollection, TItem> : CollectionBuilderBase<TBuilder, TCollection, TItem>
         where TBuilder : WeightedCollectionBuilderBase<TBuilder, TCollection, TItem>
-        where TCollection : IBuilderCollection<TItem>
+        where TCollection : class, IBuilderCollection<TItem>
     {
         protected abstract TBuilder This { get; }
 
diff --git a/src/Umbraco.Core/IO/SupportingFileSystems.cs b/src/Umbraco.Core/IO/SupportingFileSystems.cs
new file mode 100644
index 0000000000..c13ae203ee
--- /dev/null
+++ b/src/Umbraco.Core/IO/SupportingFileSystems.cs
@@ -0,0 +1,11 @@
+using Umbraco.Core.Composing;
+
+namespace Umbraco.Core.IO
+{
+    public class SupportingFileSystems : TargetedServiceProvider<IFileSystem>
+    {
+        public SupportingFileSystems(IFactory factory)
+            : base(factory)
+        { }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj
index a01bbf1746..a592fd0f0e 100755
--- a/src/Umbraco.Core/Umbraco.Core.csproj
+++ b/src/Umbraco.Core/Umbraco.Core.csproj
@@ -196,6 +196,7 @@
     <Compile Include="Composing\LightInject\LightInjectContainer.cs" />
     <Compile Include="Composing\LightInject\MixedLightInjectScopeManagerProvider.cs" />
     <Compile Include="Composing\OrderedCollectionBuilderBase.cs" />
+    <Compile Include="Composing\TargetedServiceProvider.cs" />
     <Compile Include="Composing\TypeFinder.cs" />
     <Compile Include="Composing\TypeHelper.cs" />
     <Compile Include="Composing\TypeLoader.cs" />
@@ -343,6 +344,7 @@
     <Compile Include="IO\IMediaPathScheme.cs" />
     <Compile Include="IO\MediaPathSchemes\OriginalMediaPathScheme.cs" />
     <Compile Include="IO\MediaPathSchemes\TwoGuidsMediaPathScheme.cs" />
+    <Compile Include="IO\SupportingFileSystems.cs" />
     <Compile Include="KeyValuePairExtensions.cs" />
     <Compile Include="Logging\IProfilingLogger.cs" />
     <Compile Include="Logging\LogHttpRequest.cs" />
diff --git a/src/Umbraco.Web/Composing/ModuleInjector.cs b/src/Umbraco.Web/Composing/ModuleInjector.cs
index 01930d55fd..57ef766dea 100644
--- a/src/Umbraco.Web/Composing/ModuleInjector.cs
+++ b/src/Umbraco.Web/Composing/ModuleInjector.cs
@@ -1,5 +1,4 @@
-using System;
-using System.Web;
+using System.Web;
 using Umbraco.Core;
 using Umbraco.Core.Composing;
 using Umbraco.Core.Exceptions;
@@ -11,7 +10,7 @@ namespace Umbraco.Web.Composing
     /// </summary>
     /// <typeparam name="TModule">The type of the injected module.</typeparam>
     public abstract class ModuleInjector<TModule> : IHttpModule
-        where TModule : IHttpModule
+        where TModule : class, IHttpModule
     {
         protected TModule Module { get; private set; }