From 11e41ee07eb67b5396dc73c586e0c34bb9d057aa Mon Sep 17 00:00:00 2001
From: Stephan <stephane@umbraco.dk>
Date: Fri, 23 Sep 2016 20:18:25 +0200
Subject: [PATCH] Restoring most resolvers in Compat7

---
 src/Umbraco.Compat7/Compat7Component.cs       |   7 +-
 src/Umbraco.Compat7/Core/ActionsResolver.cs   |  17 +++
 .../Core/Cache/CacheRefreshersResolver.cs     |  22 +++
 .../CultureDictionaryFactoryResolver.cs       |  24 ++++
 .../Core/Logging/LoggerResolver.cs            |  25 ++++
 .../Core/Logging/ProfilerResolver.cs          |  25 ++++
 .../PublishedContentModelFactoryResolver.cs   |   7 +-
 .../LazyManyObjectsResolverBase.cs            |  57 ++++++++
 .../ManyObjectsResolverBase.cs                | 103 +++++++++++++
 .../WeightedObjectsResolverBase.cs            | 103 +++++++++++++
 .../Migrations/MigrationResolver.cs           |  19 +++
 .../PropertyEditors/PropertyEditorResolver.cs |  21 +++
 .../PropertyValueConvertersResolver.cs        |  12 +-
 .../Core/Strings/ShortStringHelperResolver.cs |  24 ++++
 .../Strings/UrlSegmentProviderResolver.cs     |  19 +++
 .../Core/Sync/ServerMessengerResolver.cs      |  24 ++++
 .../Core/Sync/ServerRegistrarResolver.cs      |  24 ++++
 src/Umbraco.Compat7/Umbraco.Compat7.csproj    |  25 ++++
 .../Web/HealthCheck/HealthCheckResolver.cs    |  19 +++
 .../Web/Media/ThumbnailProvidersResolver.cs   |  24 ++++
 .../Mvc/DefaultRenderMvcControllerResolver.cs |  24 ++++
 .../FilteredControllerFactoriesResolver.cs    |  20 +++
 .../PublishedCache/FacadeServiceResolver.cs   |   5 +-
 .../Web/Routing/ContentFinderResolver.cs      |  20 +++
 .../ContentLastChangeFinderResolver.cs        |  40 ++++++
 .../Web/Routing/SiteDomainHelperResolver.cs   |  25 ++++
 .../Web/Routing/UrlProviderResolver.cs        |  20 +++
 src/Umbraco.Compat7/notes.txt                 |   7 +-
 src/Umbraco.Core/CoreRuntime.cs               |   3 +-
 src/Umbraco.Core/CoreRuntimeComponent.cs      |  10 +-
 .../CollectionBuilderBase.cs                  |  37 ++++-
 .../LazyCollectionBuilderBase.cs              |  69 ++++++++-
 .../OrderedCollectionBuilderBase.cs           | 136 +++++++++++++++---
 .../WeightedCollectionBuilderBase.cs          |  45 +++++-
 .../Migrations/MigrationCollectionBuilder.cs  |   7 +-
 .../PropertyEditorCollectionBuilder.cs        |  16 +--
 .../LazyCollectionBuilderTests.cs             |  12 +-
 .../PackageActionCollectionTests.cs           |   2 +-
 .../Models/Mapping/AutoMapperTests.cs         |   2 +-
 .../TestHelpers/BaseDatabaseFactoryTest.cs    |   2 +-
 .../TestHelpers/BaseUsingSqlCeSyntax.cs       |   2 +-
 src/Umbraco.Web/Current.cs                    |   6 +-
 .../HeathCheckCollectionBuilder.cs            |   2 +
 .../Migrations/PostMigrationComponent.cs      |   2 +-
 src/Umbraco.Web/WebRuntimeComponent.cs        |   8 +-
 .../_Legacy/Actions/ActionAssignDomain.cs     |   9 +-
 46 files changed, 1055 insertions(+), 77 deletions(-)
 create mode 100644 src/Umbraco.Compat7/Core/ActionsResolver.cs
 create mode 100644 src/Umbraco.Compat7/Core/Cache/CacheRefreshersResolver.cs
 create mode 100644 src/Umbraco.Compat7/Core/Dictionary/CultureDictionaryFactoryResolver.cs
 create mode 100644 src/Umbraco.Compat7/Core/Logging/LoggerResolver.cs
 create mode 100644 src/Umbraco.Compat7/Core/Logging/ProfilerResolver.cs
 create mode 100644 src/Umbraco.Compat7/Core/ObjectResolution/LazyManyObjectsResolverBase.cs
 create mode 100644 src/Umbraco.Compat7/Core/ObjectResolution/ManyObjectsResolverBase.cs
 create mode 100644 src/Umbraco.Compat7/Core/ObjectResolution/WeightedObjectsResolverBase.cs
 create mode 100644 src/Umbraco.Compat7/Core/Persistence/Migrations/MigrationResolver.cs
 create mode 100644 src/Umbraco.Compat7/Core/PropertyEditors/PropertyEditorResolver.cs
 create mode 100644 src/Umbraco.Compat7/Core/Strings/ShortStringHelperResolver.cs
 create mode 100644 src/Umbraco.Compat7/Core/Strings/UrlSegmentProviderResolver.cs
 create mode 100644 src/Umbraco.Compat7/Core/Sync/ServerMessengerResolver.cs
 create mode 100644 src/Umbraco.Compat7/Core/Sync/ServerRegistrarResolver.cs
 create mode 100644 src/Umbraco.Compat7/Web/HealthCheck/HealthCheckResolver.cs
 create mode 100644 src/Umbraco.Compat7/Web/Media/ThumbnailProvidersResolver.cs
 create mode 100644 src/Umbraco.Compat7/Web/Mvc/DefaultRenderMvcControllerResolver.cs
 create mode 100644 src/Umbraco.Compat7/Web/Mvc/FilteredControllerFactoriesResolver.cs
 create mode 100644 src/Umbraco.Compat7/Web/Routing/ContentFinderResolver.cs
 create mode 100644 src/Umbraco.Compat7/Web/Routing/ContentLastChangeFinderResolver.cs
 create mode 100644 src/Umbraco.Compat7/Web/Routing/SiteDomainHelperResolver.cs
 create mode 100644 src/Umbraco.Compat7/Web/Routing/UrlProviderResolver.cs

diff --git a/src/Umbraco.Compat7/Compat7Component.cs b/src/Umbraco.Compat7/Compat7Component.cs
index 013070a439..457b8ec6f1 100644
--- a/src/Umbraco.Compat7/Compat7Component.cs
+++ b/src/Umbraco.Compat7/Compat7Component.cs
@@ -9,11 +9,12 @@ using Umbraco.Core.Plugins;
 
 namespace Umbraco.Compat7
 {
-    internal class Compat7Component : UmbracoComponentBase, IUmbracoUserComponent
+    public class Compat7Component : UmbracoComponentBase, IUmbracoUserComponent
     {
         private List<IApplicationEventHandler> _handlers;
         private UmbracoApplicationBase _app;
 
+        // these events replace the UmbracoApplicationBase corresponding events
         public static event EventHandler ApplicationStarting;
         public static event EventHandler ApplicationStarted;
 
@@ -26,8 +27,6 @@ namespace Umbraco.Compat7
             var handlerTypes = pluginManager.ResolveTypes<IApplicationEventHandler>();
             _handlers = handlerTypes.Select(Activator.CreateInstance).Cast<IApplicationEventHandler>().ToList();
 
-            // fixme - UmbracoApplication events
-
             foreach (var handler in _handlers)
                 handler.OnApplicationInitialized(_app, ApplicationContext.Current);
 
@@ -47,8 +46,6 @@ namespace Umbraco.Compat7
 
         public void Initialize(ILogger logger)
         {
-            // fixme - UmbracoApplication events
-
             foreach (var handler in _handlers)
                 handler.OnApplicationStarted(_app, ApplicationContext.Current);
 
diff --git a/src/Umbraco.Compat7/Core/ActionsResolver.cs b/src/Umbraco.Compat7/Core/ActionsResolver.cs
new file mode 100644
index 0000000000..f8f78bc180
--- /dev/null
+++ b/src/Umbraco.Compat7/Core/ActionsResolver.cs
@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+using Umbraco.Web._Legacy.Actions;
+using WebCurrent = Umbraco.Web.Current;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Core
+{
+    public class ActionsResolver
+    {
+        private ActionsResolver()
+        { }
+
+        public static ActionsResolver Current { get; } = new ActionsResolver();
+
+        public IEnumerable<IAction> Actions => WebCurrent.Actions;
+    }
+}
diff --git a/src/Umbraco.Compat7/Core/Cache/CacheRefreshersResolver.cs b/src/Umbraco.Compat7/Core/Cache/CacheRefreshersResolver.cs
new file mode 100644
index 0000000000..110dd848e6
--- /dev/null
+++ b/src/Umbraco.Compat7/Core/Cache/CacheRefreshersResolver.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using Umbraco.Core.ObjectResolution;
+using CoreCurrent = Umbraco.Core.DependencyInjection.Current;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Core.Cache
+{
+    public class CacheRefreshersResolver : LazyManyObjectsResolverBase<CacheRefresherCollectionBuilder, CacheRefresherCollection, ICacheRefresher>
+    {
+        private CacheRefreshersResolver(CacheRefresherCollectionBuilder builder) 
+            : base(builder)
+        { }
+
+        public static CacheRefreshersResolver Current { get; }
+            = new CacheRefreshersResolver(CoreCurrent.Container.GetInstance<CacheRefresherCollectionBuilder>());
+
+        public IEnumerable<ICacheRefresher> CacheRefreshers => CoreCurrent.CacheRefreshers;
+
+        public ICacheRefresher GetById(Guid id) => CoreCurrent.CacheRefreshers[id];
+    }
+}
diff --git a/src/Umbraco.Compat7/Core/Dictionary/CultureDictionaryFactoryResolver.cs b/src/Umbraco.Compat7/Core/Dictionary/CultureDictionaryFactoryResolver.cs
new file mode 100644
index 0000000000..39c91af4fe
--- /dev/null
+++ b/src/Umbraco.Compat7/Core/Dictionary/CultureDictionaryFactoryResolver.cs
@@ -0,0 +1,24 @@
+using Umbraco.Core.DependencyInjection;
+using CoreCurrent = Umbraco.Core.DependencyInjection.Current;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Core.Dictionary
+{
+    public class CultureDictionaryFactoryResolver
+    {
+        private CultureDictionaryFactoryResolver()
+        { }
+
+        public static bool HasCurrent => true;
+
+        public static CultureDictionaryFactoryResolver Current { get; }
+            = new CultureDictionaryFactoryResolver();
+
+        public ICultureDictionaryFactory Factory => CoreCurrent.CultureDictionaryFactory;
+
+        public void SetDictionaryFactory(ICultureDictionaryFactory factory)
+        {
+            CoreCurrent.Container.RegisterSingleton(_ => factory);
+        }
+    }
+}
diff --git a/src/Umbraco.Compat7/Core/Logging/LoggerResolver.cs b/src/Umbraco.Compat7/Core/Logging/LoggerResolver.cs
new file mode 100644
index 0000000000..c27f53daa6
--- /dev/null
+++ b/src/Umbraco.Compat7/Core/Logging/LoggerResolver.cs
@@ -0,0 +1,25 @@
+using System;
+using CoreCurrent = Umbraco.Core.DependencyInjection.Current;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Core.Logging
+{
+    public class LoggerResolver
+    {
+        private LoggerResolver()
+        { }
+
+        public static bool HasCurrent => true;
+
+        public static LoggerResolver Current { get; }
+            = new LoggerResolver();
+
+        public ILogger Logger => CoreCurrent.Logger;
+
+        public void SetLogger(ILogger logger)
+        {
+            throw new NotSupportedException("The logger is determined by the UmbracoApplicationBase and cannot be modified afterwards."
+                + " To use a different logger, override the UmbracoApplicationBase (global.asax) class.");
+        }
+    }
+}
diff --git a/src/Umbraco.Compat7/Core/Logging/ProfilerResolver.cs b/src/Umbraco.Compat7/Core/Logging/ProfilerResolver.cs
new file mode 100644
index 0000000000..bbe4d510be
--- /dev/null
+++ b/src/Umbraco.Compat7/Core/Logging/ProfilerResolver.cs
@@ -0,0 +1,25 @@
+using System;
+using CoreCurrent = Umbraco.Core.DependencyInjection.Current;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Core.Logging
+{
+    public class ProfilerResolver
+    {
+        private ProfilerResolver()
+        { }
+
+        public static bool HasCurrent => true;
+
+        public static ProfilerResolver Current { get; }
+            = new ProfilerResolver();
+
+        public IProfiler Profiler => CoreCurrent.Profiler;
+
+        public void SetProfiler(IProfiler profiler)
+        {
+            throw new NotSupportedException("The profiler is configured during the IRuntime Compose() method. Implement a"
+                + " custom IRuntime if you need to specify your own custom profiler.");
+        }
+    }
+}
diff --git a/src/Umbraco.Compat7/Core/Models/PublishedContent/PublishedContentModelFactoryResolver.cs b/src/Umbraco.Compat7/Core/Models/PublishedContent/PublishedContentModelFactoryResolver.cs
index 7f785f20fc..03e034b8f1 100644
--- a/src/Umbraco.Compat7/Core/Models/PublishedContent/PublishedContentModelFactoryResolver.cs
+++ b/src/Umbraco.Compat7/Core/Models/PublishedContent/PublishedContentModelFactoryResolver.cs
@@ -6,7 +6,12 @@ namespace Umbraco.Core.Models.PublishedContent
 {
     public class PublishedContentModelFactoryResolver
     {
-        public static PublishedContentModelFactoryResolver Current { get; set; } = new PublishedContentModelFactoryResolver();
+        private PublishedContentModelFactoryResolver()
+        { }
+
+        public static PublishedContentModelFactoryResolver Current { get; } = new PublishedContentModelFactoryResolver();
+
+        public static bool HasCurrent => true;
 
         public void SetFactory(IPublishedContentModelFactory factory)
         {
diff --git a/src/Umbraco.Compat7/Core/ObjectResolution/LazyManyObjectsResolverBase.cs b/src/Umbraco.Compat7/Core/ObjectResolution/LazyManyObjectsResolverBase.cs
new file mode 100644
index 0000000000..2658aaf106
--- /dev/null
+++ b/src/Umbraco.Compat7/Core/ObjectResolution/LazyManyObjectsResolverBase.cs
@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using Umbraco.Core.DependencyInjection;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Core.ObjectResolution
+{
+    public abstract class LazyManyObjectsResolverBase<TBuilder, TCollection, TItem>
+        where TBuilder : LazyCollectionBuilderBase<TBuilder, TCollection, TItem>
+        where TCollection : IBuilderCollection<TItem>
+    {
+        protected LazyManyObjectsResolverBase(TBuilder builder)
+        {
+            Builder = builder;
+        }
+
+        protected TBuilder Builder { get; }
+
+        public static bool HasCurrent => true;
+
+        /// <summary>
+        /// Removes types from the list of types, once it has been lazily evaluated, and before actual objects are instanciated.
+        /// </summary>
+        /// <param name="value">The type to remove.</param>
+        public void RemoveType(Type value)
+        {
+            Builder.Exclude(value);
+        }
+
+        /// <summary>
+        /// Lazily adds types from a function producing types.
+        /// </summary>
+        /// <param name="typeListProducer">The functions producing types, to add.</param>
+        public void AddTypeListDelegate(Func<IEnumerable<Type>> typeListProducer)
+        {
+            Builder.Add(typeListProducer);
+        }
+
+        /// <summary>
+        /// Lazily adds a type from an actual type.
+        /// </summary>
+        /// <param name="value">The actual type, to add.</param>
+        /// <remarks>The type is converted to a lazy type.</remarks>
+        public void AddType(Type value)
+        {
+            Builder.Add(value);
+        }
+
+        /// <summary>
+        /// Clears all lazy types
+        /// </summary>
+        public void Clear()
+        {
+            Builder.Clear();
+        }
+    }
+}
diff --git a/src/Umbraco.Compat7/Core/ObjectResolution/ManyObjectsResolverBase.cs b/src/Umbraco.Compat7/Core/ObjectResolution/ManyObjectsResolverBase.cs
new file mode 100644
index 0000000000..a09fe0e0e8
--- /dev/null
+++ b/src/Umbraco.Compat7/Core/ObjectResolution/ManyObjectsResolverBase.cs
@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using Umbraco.Core.DependencyInjection;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Core.ObjectResolution
+{
+    public abstract class ManyObjectsResolverBase<TBuilder, TCollection, TItem>
+        where TBuilder : OrderedCollectionBuilderBase<TBuilder, TCollection, TItem>
+        where TCollection : IBuilderCollection<TItem>
+    {
+        private readonly TBuilder _builder;
+
+        protected ManyObjectsResolverBase(TBuilder builder)
+        {
+            _builder = builder;
+        }
+
+        public static bool HasCurrent => true;
+
+        public void RemoveType(Type value)
+        {
+            _builder.Remove(value);
+        }
+
+        public void RemoveType<T>()
+            where T : TItem
+        {
+            _builder.Remove<T>();
+        }
+
+        protected void AddTypes(IEnumerable<Type> types)
+        {
+            _builder.Append(types);
+        }
+
+        public void AddType(Type value)
+        {
+            _builder.Append(value);
+        }
+
+        public void AddType<T>()
+            where T : TItem
+        {
+            _builder.Append<T>();
+        }
+
+        public void Clear()
+        {
+            _builder.Clear();
+        }
+
+        public void InsertType(int index, Type value)
+        {
+            _builder.Insert(index, value);
+        }
+
+        public void InsertType(Type value)
+        {
+            _builder.Insert(value);
+        }
+
+        public void InsertType<T>(int index)
+            where T : TItem
+        {
+            _builder.Insert<T>(index);
+        }
+
+        public void InsertType<T>()
+            where T : TItem
+        {
+            _builder.Insert<T>();
+        }
+
+        public void InsertTypeBefore(Type existingType, Type value)
+        {
+            _builder.InsertBefore(existingType, value);
+        }
+
+        public void InsertTypeBefore<TExisting, T>()
+            where TExisting : TItem
+            where T : TItem
+        {
+            _builder.InsertBefore<TExisting, T>();
+        }
+
+        public bool ContainsType(Type value)
+        {
+            return _builder.Has(value);
+        }
+
+        public IEnumerable<Type> GetTypes()
+        {
+            return _builder.GetTypes();
+        }
+
+        public bool ContainsType<T>()
+            where T : TItem
+        {
+            return _builder.Has<T>();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Compat7/Core/ObjectResolution/WeightedObjectsResolverBase.cs b/src/Umbraco.Compat7/Core/ObjectResolution/WeightedObjectsResolverBase.cs
new file mode 100644
index 0000000000..8471c4d66d
--- /dev/null
+++ b/src/Umbraco.Compat7/Core/ObjectResolution/WeightedObjectsResolverBase.cs
@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using Umbraco.Core.DependencyInjection;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Core.ObjectResolution
+{
+    public class WeightedObjectsResolverBase<TBuilder, TCollection, TItem>
+        where TBuilder : WeightedCollectionBuilderBase<TBuilder, TCollection, TItem>
+        where TCollection : IBuilderCollection<TItem>
+    {
+        private readonly TBuilder _builder;
+
+        protected WeightedObjectsResolverBase(TBuilder builder)
+        {
+            _builder = builder;
+        }
+
+        public static bool HasCurrent => true;
+
+        public void RemoveType(Type value)
+        {
+            _builder.Remove(value);
+        }
+
+        public void RemoveType<T>()
+            where T : TItem
+        {
+            _builder.Remove<T>();
+        }
+
+        protected void AddTypes(IEnumerable<Type> types)
+        {
+            _builder.Add(types);
+        }
+
+        public void AddType(Type value)
+        {
+            _builder.Add(value);
+        }
+
+        public void AddType<T>()
+            where T : TItem
+        {
+            _builder.Add<T>();
+        }
+
+        public void Clear()
+        {
+            _builder.Clear();
+        }
+
+        public void InsertType(int index, Type value)
+        {
+            _builder.Add(value);
+        }
+
+        public void InsertType(Type value)
+        {
+            _builder.Add(value);
+        }
+
+        public void InsertType<T>(int index)
+            where T : TItem
+        {
+            _builder.Add<T>();
+        }
+
+        public void InsertType<T>()
+            where T : TItem
+        {
+            _builder.Add<T>();
+        }
+
+        public void InsertTypeBefore(Type existingType, Type value)
+        {
+            _builder.Add(value);
+        }
+
+        public void InsertTypeBefore<TExisting, T>()
+            where TExisting : TItem
+            where T : TItem
+        {
+            _builder.Add<T>();
+        }
+
+        public bool ContainsType(Type value)
+        {
+            return _builder.Has(value);
+        }
+
+        public IEnumerable<Type> GetTypes()
+        {
+            return _builder.GetTypes();
+        }
+
+        public bool ContainsType<T>()
+            where T : TItem
+        {
+            return _builder.Has<T>();
+        }
+    }
+}
diff --git a/src/Umbraco.Compat7/Core/Persistence/Migrations/MigrationResolver.cs b/src/Umbraco.Compat7/Core/Persistence/Migrations/MigrationResolver.cs
new file mode 100644
index 0000000000..93c29d24f4
--- /dev/null
+++ b/src/Umbraco.Compat7/Core/Persistence/Migrations/MigrationResolver.cs
@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+using Umbraco.Core.ObjectResolution;
+using CoreCurrent = Umbraco.Core.DependencyInjection.Current;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Core.Persistence.Migrations
+{
+    public class MigrationResolver : LazyManyObjectsResolverBase<MigrationCollectionBuilder, MigrationCollection, IMigration>
+    {
+        private MigrationResolver(MigrationCollectionBuilder builder)
+            : base(builder)
+        { }
+
+        public static MigrationResolver Current { get; }
+            = new MigrationResolver(CoreCurrent.Container.GetInstance<MigrationCollectionBuilder>());
+
+        public IEnumerable<IMigration> GetMigrations(IMigrationContext context) => Builder.CreateCollection(context);
+    }
+}
diff --git a/src/Umbraco.Compat7/Core/PropertyEditors/PropertyEditorResolver.cs b/src/Umbraco.Compat7/Core/PropertyEditors/PropertyEditorResolver.cs
new file mode 100644
index 0000000000..a842a4c6dc
--- /dev/null
+++ b/src/Umbraco.Compat7/Core/PropertyEditors/PropertyEditorResolver.cs
@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using Umbraco.Core.ObjectResolution;
+using CoreCurrent = Umbraco.Core.DependencyInjection.Current;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Core.PropertyEditors
+{
+    public class PropertyEditorResolver : LazyManyObjectsResolverBase<PropertyEditorCollectionBuilder, PropertyEditorCollection, PropertyEditor>
+    {
+        private PropertyEditorResolver(PropertyEditorCollectionBuilder builder)
+            : base(builder)
+        { }
+
+        public static PropertyEditorResolver Current { get; }
+            = new PropertyEditorResolver(CoreCurrent.Container.GetInstance<PropertyEditorCollectionBuilder>());
+
+        public IEnumerable<PropertyEditor> PropertyEditors => CoreCurrent.PropertyEditors;
+
+        public PropertyEditor GetByAlias(string alias) => CoreCurrent.PropertyEditors[alias];
+    }
+}
diff --git a/src/Umbraco.Compat7/Core/PropertyEditors/PropertyValueConvertersResolver.cs b/src/Umbraco.Compat7/Core/PropertyEditors/PropertyValueConvertersResolver.cs
index 98e1db93af..333aa78ac3 100644
--- a/src/Umbraco.Compat7/Core/PropertyEditors/PropertyValueConvertersResolver.cs
+++ b/src/Umbraco.Compat7/Core/PropertyEditors/PropertyValueConvertersResolver.cs
@@ -1,15 +1,19 @@
 using System.Collections.Generic;
+using Umbraco.Core.ObjectResolution;
 using CoreCurrent = Umbraco.Core.DependencyInjection.Current;
 
 // ReSharper disable once CheckNamespace
 namespace Umbraco.Core.PropertyEditors
 {
-    public class PropertyValueConvertersResolver
+    public class PropertyValueConvertersResolver : ManyObjectsResolverBase<PropertyValueConverterCollectionBuilder, PropertyValueConverterCollection, IPropertyValueConverter>
     {
-        public static PropertyValueConvertersResolver Current { get; set; } = new PropertyValueConvertersResolver();
+        private PropertyValueConvertersResolver(PropertyValueConverterCollectionBuilder builder)
+            : base(builder)
+        { }
+
+        public static PropertyValueConvertersResolver Current { get; } 
+            = new PropertyValueConvertersResolver(CoreCurrent.Container.GetInstance<PropertyValueConverterCollectionBuilder>());
 
         public IEnumerable<IPropertyValueConverter> Converters => CoreCurrent.PropertyValueConverters;
-
-        // fixme - should implement the basic resolver add/edit/etc methods!
     }
 }
diff --git a/src/Umbraco.Compat7/Core/Strings/ShortStringHelperResolver.cs b/src/Umbraco.Compat7/Core/Strings/ShortStringHelperResolver.cs
new file mode 100644
index 0000000000..7e0444ab6c
--- /dev/null
+++ b/src/Umbraco.Compat7/Core/Strings/ShortStringHelperResolver.cs
@@ -0,0 +1,24 @@
+using Umbraco.Core.DependencyInjection;
+using CoreCurrent = Umbraco.Core.DependencyInjection.Current;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Core.Strings
+{
+    public class ShortStringHelperResolver
+    {
+        private ShortStringHelperResolver()
+        { }
+
+        public static bool HasCurrent => true;
+
+        public static ShortStringHelperResolver Current { get; }
+            = new ShortStringHelperResolver();
+
+        public IShortStringHelper Helper => CoreCurrent.ShortStringHelper;
+
+        public void SetHelper(IShortStringHelper helper)
+        {
+            CoreCurrent.Container.RegisterSingleton(_ => helper);
+        }
+    }
+}
diff --git a/src/Umbraco.Compat7/Core/Strings/UrlSegmentProviderResolver.cs b/src/Umbraco.Compat7/Core/Strings/UrlSegmentProviderResolver.cs
new file mode 100644
index 0000000000..b44897463a
--- /dev/null
+++ b/src/Umbraco.Compat7/Core/Strings/UrlSegmentProviderResolver.cs
@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+using Umbraco.Core.ObjectResolution;
+using CoreCurrent = Umbraco.Core.DependencyInjection.Current;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Core.Strings
+{
+    public class UrlSegmentProviderResolver : ManyObjectsResolverBase<UrlSegmentProviderCollectionBuilder, UrlSegmentProviderCollection, IUrlSegmentProvider>
+    {
+        private UrlSegmentProviderResolver(UrlSegmentProviderCollectionBuilder builder)
+            : base(builder)
+        { }
+
+        public static UrlSegmentProviderResolver Current { get; } 
+            = new UrlSegmentProviderResolver(CoreCurrent.Container.GetInstance<UrlSegmentProviderCollectionBuilder>());
+
+        public IEnumerable<IUrlSegmentProvider> Providers => CoreCurrent.UrlSegmentProviders;
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Compat7/Core/Sync/ServerMessengerResolver.cs b/src/Umbraco.Compat7/Core/Sync/ServerMessengerResolver.cs
new file mode 100644
index 0000000000..2bbb1b6a7a
--- /dev/null
+++ b/src/Umbraco.Compat7/Core/Sync/ServerMessengerResolver.cs
@@ -0,0 +1,24 @@
+using Umbraco.Core.DependencyInjection;
+using CoreCurrent = Umbraco.Core.DependencyInjection.Current;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Core.Sync
+{
+    public class ServerMessengerResolver
+    {
+        private ServerMessengerResolver()
+        { }
+
+        public static bool HasCurrent => true;
+
+        public static ServerMessengerResolver Current { get; }
+            = new ServerMessengerResolver();
+
+        public IServerMessenger Messenger => CoreCurrent.ServerMessenger;
+
+        public void SetServerMessenger(IServerMessenger messenger)
+        {
+            CoreCurrent.Container.RegisterSingleton(_ => messenger);
+        }
+    }
+}
diff --git a/src/Umbraco.Compat7/Core/Sync/ServerRegistrarResolver.cs b/src/Umbraco.Compat7/Core/Sync/ServerRegistrarResolver.cs
new file mode 100644
index 0000000000..0abc4a121f
--- /dev/null
+++ b/src/Umbraco.Compat7/Core/Sync/ServerRegistrarResolver.cs
@@ -0,0 +1,24 @@
+using Umbraco.Core.DependencyInjection;
+using CoreCurrent = Umbraco.Core.DependencyInjection.Current;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Core.Sync
+{
+    public class ServerRegistrarResolver
+    {
+        private ServerRegistrarResolver()
+        { }
+
+        public static bool HasCurrent => true;
+
+        public static ServerRegistrarResolver Current { get; }
+            = new ServerRegistrarResolver();
+
+        public IServerRegistrar Registrar => CoreCurrent.ServerRegistrar;
+
+        public void SetServerRegistrar(IServerRegistrar registrar)
+        {
+            CoreCurrent.Container.RegisterSingleton(_ => registrar);
+        }
+    }
+}
diff --git a/src/Umbraco.Compat7/Umbraco.Compat7.csproj b/src/Umbraco.Compat7/Umbraco.Compat7.csproj
index 804d56d80d..6098b6c0ed 100644
--- a/src/Umbraco.Compat7/Umbraco.Compat7.csproj
+++ b/src/Umbraco.Compat7/Umbraco.Compat7.csproj
@@ -48,19 +48,41 @@
       <Link>Properties\SolutionInfo.cs</Link>
     </Compile>
     <Compile Include="Compat7Component.cs" />
+    <Compile Include="Core\ActionsResolver.cs" />
     <Compile Include="Core\ApplicationContext.cs" />
     <Compile Include="Core\ApplicationEventHandler.cs" />
+    <Compile Include="Core\Cache\CacheRefreshersResolver.cs" />
+    <Compile Include="Core\Dictionary\CultureDictionaryFactoryResolver.cs" />
     <Compile Include="Core\IApplicationEventHandler.cs" />
+    <Compile Include="Core\Logging\LoggerResolver.cs" />
     <Compile Include="Core\Logging\LogHelper.cs" />
+    <Compile Include="Core\Logging\ProfilerResolver.cs" />
     <Compile Include="Core\Models\PublishedContent\PublishedContentModelFactoryResolver.cs" />
+    <Compile Include="Core\ObjectResolution\LazyManyObjectsResolverBase.cs" />
+    <Compile Include="Core\ObjectResolution\ManyObjectsResolverBase.cs" />
+    <Compile Include="Core\ObjectResolution\WeightedObjectsResolverBase.cs" />
+    <Compile Include="Core\Persistence\Migrations\MigrationResolver.cs" />
+    <Compile Include="Core\PropertyEditors\PropertyEditorResolver.cs" />
     <Compile Include="Core\PropertyEditors\PropertyValueConvertersResolver.cs" />
+    <Compile Include="Core\Strings\ShortStringHelperResolver.cs" />
+    <Compile Include="Core\Strings\UrlSegmentProviderResolver.cs" />
+    <Compile Include="Core\Sync\ServerMessengerResolver.cs" />
+    <Compile Include="Core\Sync\ServerRegistrarResolver.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Web\HealthCheck\HealthCheckResolver.cs" />
+    <Compile Include="Web\Media\ThumbnailProvidersResolver.cs" />
     <Compile Include="Web\Models\IRenderModel.cs" />
     <Compile Include="Web\Models\RenderModel.cs" />
     <Compile Include="Web\Models\RenderModelOfTContent.cs" />
+    <Compile Include="Web\Mvc\DefaultRenderMvcControllerResolver.cs" />
+    <Compile Include="Web\Mvc\FilteredControllerFactoriesResolver.cs" />
     <Compile Include="Web\Mvc\UmbracoTemplatePage.cs" />
     <Compile Include="Web\Mvc\UmbracoTemplatePageOfTContent.cs" />
     <Compile Include="Web\PublishedCache\FacadeServiceResolver.cs" />
+    <Compile Include="Web\Routing\ContentFinderResolver.cs" />
+    <Compile Include="Web\Routing\ContentLastChangeFinderResolver.cs" />
+    <Compile Include="Web\Routing\SiteDomainHelperResolver.cs" />
+    <Compile Include="Web\Routing\UrlProviderResolver.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="app.config" />
@@ -79,6 +101,9 @@
   <ItemGroup>
     <Content Include="notes.txt" />
   </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Core\Persistence\Mappers\" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/src/Umbraco.Compat7/Web/HealthCheck/HealthCheckResolver.cs b/src/Umbraco.Compat7/Web/HealthCheck/HealthCheckResolver.cs
new file mode 100644
index 0000000000..8d2203eeed
--- /dev/null
+++ b/src/Umbraco.Compat7/Web/HealthCheck/HealthCheckResolver.cs
@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+using Umbraco.Core.ObjectResolution;
+using CoreCurrent = Umbraco.Core.DependencyInjection.Current;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Web.HealthCheck
+{
+    public class HealthCheckResolver : LazyManyObjectsResolverBase<HealthCheckCollectionBuilder, HealthCheckCollection, HealthCheck>
+    {
+        private HealthCheckResolver(HealthCheckCollectionBuilder builder) 
+            : base(builder)
+        { }
+
+        public static HealthCheckResolver Current { get; }
+            = new HealthCheckResolver(CoreCurrent.Container.GetInstance<HealthCheckCollectionBuilder>());
+
+        public IEnumerable<HealthCheck> HealthChecks => Builder.CreateCollection(); // transient
+    }
+}
diff --git a/src/Umbraco.Compat7/Web/Media/ThumbnailProvidersResolver.cs b/src/Umbraco.Compat7/Web/Media/ThumbnailProvidersResolver.cs
new file mode 100644
index 0000000000..fb2c685f27
--- /dev/null
+++ b/src/Umbraco.Compat7/Web/Media/ThumbnailProvidersResolver.cs
@@ -0,0 +1,24 @@
+using System.Collections.Generic;
+using Umbraco.Core.Media;
+using Umbraco.Core.ObjectResolution;
+using Umbraco.Web.Media.ThumbnailProviders;
+using CoreCurrent = Umbraco.Core.DependencyInjection.Current;
+using WebCurrent = Umbraco.Web.Current;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Web.Media
+{
+    public class ThumbnailProvidersResolver : WeightedObjectsResolverBase<ThumbnailProviderCollectionBuilder, ThumbnailProviderCollection, IThumbnailProvider>
+    {
+        private ThumbnailProvidersResolver(ThumbnailProviderCollectionBuilder builder)
+            : base(builder)
+        { }
+
+        public static ThumbnailProvidersResolver Current { get; }
+            = new ThumbnailProvidersResolver(CoreCurrent.Container.GetInstance<ThumbnailProviderCollectionBuilder>());
+
+        public IEnumerable<IThumbnailProvider> Providers => WebCurrent.ThumbnailProviders;
+
+        public string GetThumbnailUrl(string fileUrl) => WebCurrent.ThumbnailProviders.GetThumbnailUrl(fileUrl);
+    }
+}
diff --git a/src/Umbraco.Compat7/Web/Mvc/DefaultRenderMvcControllerResolver.cs b/src/Umbraco.Compat7/Web/Mvc/DefaultRenderMvcControllerResolver.cs
new file mode 100644
index 0000000000..5ec70f0f44
--- /dev/null
+++ b/src/Umbraco.Compat7/Web/Mvc/DefaultRenderMvcControllerResolver.cs
@@ -0,0 +1,24 @@
+using System;
+using WebCurrent = Umbraco.Web.Current;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Web.Mvc
+{
+    public class DefaultRenderMvcControllerResolver
+    {
+        private DefaultRenderMvcControllerResolver()
+        { }
+
+        public static bool HasCurrent => true;
+
+        public static DefaultRenderMvcControllerResolver Current { get; }
+            = new DefaultRenderMvcControllerResolver();
+
+        public Type GetDefaultControllerType() => WebCurrent.DefaultRenderMvcControllerType;
+
+        public void SetDefaultControllerType(Type type)
+        {
+            WebCurrent.DefaultRenderMvcControllerType = type;
+        }
+    }
+}
diff --git a/src/Umbraco.Compat7/Web/Mvc/FilteredControllerFactoriesResolver.cs b/src/Umbraco.Compat7/Web/Mvc/FilteredControllerFactoriesResolver.cs
new file mode 100644
index 0000000000..77d81e115e
--- /dev/null
+++ b/src/Umbraco.Compat7/Web/Mvc/FilteredControllerFactoriesResolver.cs
@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using Umbraco.Core.ObjectResolution;
+using CoreCurrent = Umbraco.Core.DependencyInjection.Current;
+using WebCurrent = Umbraco.Web.Current;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Web.Mvc
+{
+    public class FilteredControllerFactoriesResolver : ManyObjectsResolverBase<FilteredControllerFactoryCollectionBuilder, FilteredControllerFactoryCollection, IFilteredControllerFactory>
+    {
+        public FilteredControllerFactoriesResolver(FilteredControllerFactoryCollectionBuilder builder) 
+            : base(builder)
+        { }
+
+        public static FilteredControllerFactoriesResolver Current { get; }
+            = new FilteredControllerFactoriesResolver(CoreCurrent.Container.GetInstance<FilteredControllerFactoryCollectionBuilder>());
+
+        public IEnumerable<IFilteredControllerFactory> Factories => WebCurrent.FilteredControllerFactories;
+    }
+}
diff --git a/src/Umbraco.Compat7/Web/PublishedCache/FacadeServiceResolver.cs b/src/Umbraco.Compat7/Web/PublishedCache/FacadeServiceResolver.cs
index 765217f6cc..3aee10226e 100644
--- a/src/Umbraco.Compat7/Web/PublishedCache/FacadeServiceResolver.cs
+++ b/src/Umbraco.Compat7/Web/PublishedCache/FacadeServiceResolver.cs
@@ -5,7 +5,10 @@ namespace Umbraco.Web.PublishedCache
 {
     public class FacadeServiceResolver
     {
-        public static FacadeServiceResolver Current { get; set; } = new FacadeServiceResolver();
+        private FacadeServiceResolver()
+        { }
+
+        public static FacadeServiceResolver Current { get; } = new FacadeServiceResolver();
 
         public IFacadeService Service => WebCurrent.FacadeService;
     }
diff --git a/src/Umbraco.Compat7/Web/Routing/ContentFinderResolver.cs b/src/Umbraco.Compat7/Web/Routing/ContentFinderResolver.cs
new file mode 100644
index 0000000000..c6b3558bb5
--- /dev/null
+++ b/src/Umbraco.Compat7/Web/Routing/ContentFinderResolver.cs
@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using Umbraco.Core.ObjectResolution;
+using CoreCurrent = Umbraco.Core.DependencyInjection.Current;
+using WebCurrent = Umbraco.Web.Current;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Web.Routing
+{
+    public class ContentFinderResolver : ManyObjectsResolverBase<ContentFinderCollectionBuilder, ContentFinderCollection, IContentFinder>
+    {
+        private ContentFinderResolver(ContentFinderCollectionBuilder builder) 
+            : base(builder)
+        { }
+
+        public static ContentFinderResolver Current { get; }
+            = new ContentFinderResolver(CoreCurrent.Container.GetInstance<ContentFinderCollectionBuilder>());
+
+        public IEnumerable<IContentFinder> Finders => WebCurrent.ContentFinders;
+    }
+}
diff --git a/src/Umbraco.Compat7/Web/Routing/ContentLastChangeFinderResolver.cs b/src/Umbraco.Compat7/Web/Routing/ContentLastChangeFinderResolver.cs
new file mode 100644
index 0000000000..d9c66324c0
--- /dev/null
+++ b/src/Umbraco.Compat7/Web/Routing/ContentLastChangeFinderResolver.cs
@@ -0,0 +1,40 @@
+using System;
+using Umbraco.Core.DependencyInjection;
+using CoreCurrent = Umbraco.Core.DependencyInjection.Current;
+using WebCurrent = Umbraco.Web.Current;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Web.Routing
+{
+    public class ContentLastChangeFinderResolver
+    {
+        private ContentLastChangeFinderResolver()
+        { }
+
+        public static ContentLastChangeFinderResolver Current { get; } = new ContentLastChangeFinderResolver();
+
+        public IContentFinder Finder => WebCurrent.LastChanceContentFinder;
+
+        public void SetFinder(IContentFinder finder)
+        {
+            if (finder == null) throw new ArgumentNullException(nameof(finder));
+            var lastChance = finder as IContentLastChanceFinder ?? new FinderWrapper(finder);
+            CoreCurrent.Container.RegisterSingleton(_ => lastChance);
+        }
+
+        private class FinderWrapper : IContentLastChanceFinder
+        {
+            private readonly IContentFinder _inner;
+
+            public FinderWrapper(IContentFinder inner)
+            {
+                _inner = inner;
+            }
+
+            public bool TryFindContent(PublishedContentRequest contentRequest)
+            {
+                return _inner.TryFindContent(contentRequest);
+            }
+        }
+    }
+}
diff --git a/src/Umbraco.Compat7/Web/Routing/SiteDomainHelperResolver.cs b/src/Umbraco.Compat7/Web/Routing/SiteDomainHelperResolver.cs
new file mode 100644
index 0000000000..65a2637f5b
--- /dev/null
+++ b/src/Umbraco.Compat7/Web/Routing/SiteDomainHelperResolver.cs
@@ -0,0 +1,25 @@
+using Umbraco.Core.DependencyInjection;
+using CoreCurrent = Umbraco.Core.DependencyInjection.Current;
+using WebCurrent = Umbraco.Web.Current;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Web.Routing
+{
+    public class SiteDomainHelperResolver
+    {
+        private SiteDomainHelperResolver()
+        { }
+
+        public static bool HasCurrent => true;
+
+        public static SiteDomainHelperResolver Current { get; }
+            = new SiteDomainHelperResolver();
+
+        public ISiteDomainHelper Helper => WebCurrent.SiteDomainHelper;
+
+        public void SetHelper(ISiteDomainHelper helper)
+        {
+            CoreCurrent.Container.RegisterSingleton(_ => helper);
+        }
+    }
+}
diff --git a/src/Umbraco.Compat7/Web/Routing/UrlProviderResolver.cs b/src/Umbraco.Compat7/Web/Routing/UrlProviderResolver.cs
new file mode 100644
index 0000000000..d36609d3bb
--- /dev/null
+++ b/src/Umbraco.Compat7/Web/Routing/UrlProviderResolver.cs
@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using Umbraco.Core.ObjectResolution;
+using CoreCurrent = Umbraco.Core.DependencyInjection.Current;
+using WebCurrent = Umbraco.Web.Current;
+
+// ReSharper disable once CheckNamespace
+namespace Umbraco.Web.Routing
+{
+    public class UrlProviderResolver : ManyObjectsResolverBase<UrlProviderCollectionBuilder, UrlProviderCollection, IUrlProvider>
+    {
+        private UrlProviderResolver(UrlProviderCollectionBuilder builder) 
+            : base(builder)
+        { }
+
+        public static UrlProviderResolver Current { get; }
+            = new UrlProviderResolver(CoreCurrent.Container.GetInstance<UrlProviderCollectionBuilder>());
+
+        public IEnumerable<IUrlProvider> Providers => WebCurrent.UrlProviders;
+    }
+}
diff --git a/src/Umbraco.Compat7/notes.txt b/src/Umbraco.Compat7/notes.txt
index 96ed679754..f153361aae 100644
--- a/src/Umbraco.Compat7/notes.txt
+++ b/src/Umbraco.Compat7/notes.txt
@@ -19,7 +19,10 @@ This includes:
     status: to be tested
 
 - Resolvers
-    status: to be implemented - all of them - bah
+    compat: full
+    status: 
+	  base resolvers: done
+	  resolvers: TODO
 
 - RenderModel, UmbracoTemplatePage
     compat: will NOT support dynamics, so CurrentPage will prob not work
@@ -33,4 +36,6 @@ What else?
 ** Building
 
 By default, Umbraco.Compat7 is built but not copied / nothing.
+If the conditional symbol 'COMPAT7' is defined, it is copied to Umbraco.Web.UI/bin.
+Currently, that symbol is defined for the DEBUG build.
 Eventually it should become an extra NuGet package.
diff --git a/src/Umbraco.Core/CoreRuntime.cs b/src/Umbraco.Core/CoreRuntime.cs
index 2e94036581..b9e482ad0f 100644
--- a/src/Umbraco.Core/CoreRuntime.cs
+++ b/src/Umbraco.Core/CoreRuntime.cs
@@ -20,7 +20,6 @@ using Umbraco.Core.Services;
 
 namespace Umbraco.Core
 {
-
     /// <summary>
     /// Represents the Core Umbraco runtime.
     /// </summary>
@@ -203,7 +202,7 @@ namespace Umbraco.Core
             // register persistence mappers - means the only place the collection can be modified
             // is in a runtime - afterwards it has been frozen and it is too late
             MapperCollectionBuilder.Register(container)
-                .AddProducer(f => f.GetInstance<PluginManager>().ResolveAssignedMapperTypes());
+                .Add(f => f.GetInstance<PluginManager>().ResolveAssignedMapperTypes());
 
             // register database factory
             // will be initialized with syntax providers and a logger, and will try to configure
diff --git a/src/Umbraco.Core/CoreRuntimeComponent.cs b/src/Umbraco.Core/CoreRuntimeComponent.cs
index 9101620356..1ad75a02c6 100644
--- a/src/Umbraco.Core/CoreRuntimeComponent.cs
+++ b/src/Umbraco.Core/CoreRuntimeComponent.cs
@@ -60,10 +60,10 @@ namespace Umbraco.Core
             container.RegisterSingleton<ManifestBuilder>();
 
             PropertyEditorCollectionBuilder.Register(container)
-                .AddProducer(factory => factory.GetInstance<PluginManager>().ResolvePropertyEditors());
+                .Add(factory => factory.GetInstance<PluginManager>().ResolvePropertyEditors());
 
             ParameterEditorCollectionBuilder.Register(container)
-                .AddProducer(factory => factory.GetInstance<PluginManager>().ResolveParameterEditors());
+                .Add(factory => factory.GetInstance<PluginManager>().ResolveParameterEditors());
 
             // register our predefined validators
             ValidatorCollectionBuilder.Register(container)
@@ -95,13 +95,13 @@ namespace Umbraco.Core
                     true, new DatabaseServerMessengerOptions()));
 
             CacheRefresherCollectionBuilder.Register(container)
-                .AddProducer(factory => factory.GetInstance<PluginManager>().ResolveCacheRefreshers());
+                .Add(factory => factory.GetInstance<PluginManager>().ResolveCacheRefreshers());
 
             PackageActionCollectionBuilder.Register(container)
-                .AddProducer(f => f.GetInstance<PluginManager>().ResolvePackageActions());
+                .Add(f => f.GetInstance<PluginManager>().ResolvePackageActions());
 
             MigrationCollectionBuilder.Register(container)
-                .AddProducer(factory => factory.GetInstance<PluginManager>().ResolveTypes<IMigration>());
+                .Add(factory => factory.GetInstance<PluginManager>().ResolveTypes<IMigration>());
 
             // need to filter out the ones we dont want!! fixme - what does that mean?
             PropertyValueConverterCollectionBuilder.Register(container)
diff --git a/src/Umbraco.Core/DependencyInjection/CollectionBuilderBase.cs b/src/Umbraco.Core/DependencyInjection/CollectionBuilderBase.cs
index b19b220620..bfcdb6c2c7 100644
--- a/src/Umbraco.Core/DependencyInjection/CollectionBuilderBase.cs
+++ b/src/Umbraco.Core/DependencyInjection/CollectionBuilderBase.cs
@@ -38,6 +38,11 @@ namespace Umbraco.Core.DependencyInjection
         /// </summary>
         protected IServiceContainer Container { get; }
 
+        /// <summary>
+        /// Gets the internal list of types as an IEnumerable (immutable).
+        /// </summary>
+        public IEnumerable<Type> GetTypes() => _types;
+
         /// <summary>
         /// Initializes a new instance of the builder.
         /// </summary>
@@ -113,7 +118,8 @@ namespace Umbraco.Core.DependencyInjection
         /// </summary>
         /// <param name="types">The internal list of types.</param>
         /// <returns>The list of types to register.</returns>
-        protected virtual IEnumerable<Type> GetTypes(IEnumerable<Type> types)
+        /// <remarks>Used by implementations to add types to the internal list, sort the list, etc.</remarks>
+        protected virtual IEnumerable<Type> GetRegisteringTypes(IEnumerable<Type> types)
         {
             return types;
         }
@@ -124,12 +130,9 @@ namespace Umbraco.Core.DependencyInjection
             {
                 if (_registrations != null) return;
 
-                var types = GetTypes(_types).ToArray();
+                var types = GetRegisteringTypes(_types).ToArray();
                 foreach (var type in types)
-                {
-                    if (typeof(TItem).IsAssignableFrom(type) == false)
-                        throw new InvalidOperationException($"Cannot register type {type.FullName} as it does not inherit from/implement {typeof(TItem).FullName}.");
-                }
+                    EnsureType(type, "register");
 
                 var prefix = GetType().FullName + "_";
                 var i = 0;
@@ -172,6 +175,13 @@ namespace Umbraco.Core.DependencyInjection
             return _collectionCtor(CreateItems());
         }
 
+        protected Type EnsureType(Type type, string action)
+        {
+            if (typeof(TItem).IsAssignableFrom(type) == false)
+                throw new InvalidOperationException($"Cannot {action} type {type.FullName} as it does not inherit from/implement {typeof(TItem).FullName}.");
+            return type;
+        }
+
         /// <summary>
         /// Gets a value indicating whether the collection contains a type.
         /// </summary>
@@ -179,10 +189,23 @@ namespace Umbraco.Core.DependencyInjection
         /// <returns>A value indicating whether the collection contains the type.</returns>
         /// <remarks>Some builder implementations may use this to expose a public Has{T}() method,
         /// when it makes sense. Probably does not make sense for lazy builders, for example.</remarks>
-        protected bool HasBase<T>()
+        public virtual bool Has<T>()
             where T : TItem
         {
             return _types.Contains(typeof (T));
         }
+
+        /// <summary>
+        /// Gets a value indicating whether the collection contains a type.
+        /// </summary>
+        /// <param name="type">The type to look for.</param>
+        /// <returns>A value indicating whether the collection contains the type.</returns>
+        /// <remarks>Some builder implementations may use this to expose a public Has{T}() method,
+        /// when it makes sense. Probably does not make sense for lazy builders, for example.</remarks>
+        public virtual bool Has(Type type)
+        {
+            EnsureType(type, "find");
+            return _types.Contains(type);
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/DependencyInjection/LazyCollectionBuilderBase.cs b/src/Umbraco.Core/DependencyInjection/LazyCollectionBuilderBase.cs
index eacf72854f..6a4fc7a798 100644
--- a/src/Umbraco.Core/DependencyInjection/LazyCollectionBuilderBase.cs
+++ b/src/Umbraco.Core/DependencyInjection/LazyCollectionBuilderBase.cs
@@ -25,6 +25,22 @@ namespace Umbraco.Core.DependencyInjection
 
         protected abstract TBuilder This { get; }
 
+        /// <summary>
+        /// Clears all types in the collection.
+        /// </summary>
+        /// <returns>The buidler.</returns>
+        public TBuilder Clear()
+        {
+            Configure(types =>
+            {
+                types.Clear();
+                _producers1.Clear();
+                _producers2.Clear();
+                _excluded.Clear();
+            });
+            return This;
+        }
+
         /// <summary>
         /// Adds a type to the collection.
         /// </summary>
@@ -41,6 +57,21 @@ namespace Umbraco.Core.DependencyInjection
             return This;
         }
 
+        /// <summary>
+        /// Adds a type to the collection.
+        /// </summary>
+        /// <param name="type">The type to add.</param>
+        /// <returns>The builder.</returns>
+        public TBuilder Add(Type type)
+        {
+            Configure(types =>
+            {
+                EnsureType(type, "register");
+                if (types.Contains(type) == false) types.Add(type);
+            });
+            return This;
+        }
+
         /// <summary>
         /// Removes a type from the collection.
         /// </summary>
@@ -57,12 +88,27 @@ namespace Umbraco.Core.DependencyInjection
             return This;
         }
 
+        /// <summary>
+        /// Removes a type from the collection.
+        /// </summary>
+        /// <param name="type">The type to remove.</param>
+        /// <returns>The builder.</returns>
+        public TBuilder Remove(Type type)
+        {
+            Configure(types =>
+            {
+                EnsureType(type, "remove");
+                if (types.Contains(type)) types.Remove(type);
+            });
+            return This;
+        }
+
         /// <summary>
         /// Adds a types producer to the collection.
         /// </summary>
         /// <param name="producer">The types producer.</param>
         /// <returns>The builder.</returns>
-        public TBuilder AddProducer(Func<IEnumerable<Type>> producer)
+        public TBuilder Add(Func<IEnumerable<Type>> producer)
         {
             Configure(types =>
             {
@@ -76,7 +122,7 @@ namespace Umbraco.Core.DependencyInjection
         /// </summary>
         /// <param name="producer">The types producer.</param>
         /// <returns>The builder.</returns>
-        public TBuilder AddProducer(Func<IServiceFactory, IEnumerable<Type>> producer)
+        public TBuilder Add(Func<IServiceFactory, IEnumerable<Type>> producer)
         {
             Configure(types =>
             {
@@ -91,6 +137,7 @@ namespace Umbraco.Core.DependencyInjection
         /// <typeparam name="T">The type to exclude.</typeparam>
         /// <returns>The builder.</returns>
         public TBuilder Exclude<T>()
+            where T : TItem
         {
             Configure(types =>
             {
@@ -100,12 +147,28 @@ namespace Umbraco.Core.DependencyInjection
             return This;
         }
 
-        protected override IEnumerable<Type> GetTypes(IEnumerable<Type> types)
+        /// <summary>
+        /// Excludes a type from the collection.
+        /// </summary>
+        /// <param name="type">The type to exclude.</param>
+        /// <returns>The builder.</returns>
+        public TBuilder Exclude(Type type)
+        {
+            Configure(types =>
+            {
+                EnsureType(type, "exclude");
+                if (_excluded.Contains(type) == false) _excluded.Add(type);
+            });
+            return This;
+        }
+
+        protected override IEnumerable<Type> GetRegisteringTypes(IEnumerable<Type> types)
         {
             return types
                 .Union(_producers1.SelectMany(x => x()))
                 .Union(_producers2.SelectMany(x => x(Container)))
                 .Distinct()
+                .Select(x => EnsureType(x, "register"))
                 .Except(_excluded);
         }
     }
diff --git a/src/Umbraco.Core/DependencyInjection/OrderedCollectionBuilderBase.cs b/src/Umbraco.Core/DependencyInjection/OrderedCollectionBuilderBase.cs
index f6f185995f..3960ff3cf7 100644
--- a/src/Umbraco.Core/DependencyInjection/OrderedCollectionBuilderBase.cs
+++ b/src/Umbraco.Core/DependencyInjection/OrderedCollectionBuilderBase.cs
@@ -20,6 +20,16 @@ namespace Umbraco.Core.DependencyInjection
 
         protected abstract TBuilder This { get; }
 
+        /// <summary>
+        /// Clears all types in the collection.
+        /// </summary>
+        /// <returns>The buidler.</returns>
+        public TBuilder Clear()
+        {
+            Configure(types => types.Clear());
+            return This;
+        }
+
         /// <summary>
         /// Appends a type to the collection.
         /// </summary>
@@ -37,6 +47,22 @@ namespace Umbraco.Core.DependencyInjection
             return This;
         }
 
+        /// <summary>
+        /// Appends a type to the collection.
+        /// </summary>
+        /// <param name="type">The type to append.</param>
+        /// <returns>The builder.</returns>
+        public TBuilder Append(Type type)
+        {
+            Configure(types =>
+            {
+                EnsureType(type, "register");
+                if (types.Contains(type)) types.Remove(type);
+                types.Add(type);
+            });
+            return This;
+        }
+
         /// <summary>
         ///  Appends types to the collections.
         /// </summary>
@@ -49,8 +75,7 @@ namespace Umbraco.Core.DependencyInjection
                 foreach (var type in types)
                 {
                     // would be detected by CollectionBuilderBase when registering, anyways, but let's fail fast
-                    if (typeof(TItem).IsAssignableFrom(type) == false)
-                        throw new InvalidOperationException($"Cannot register type {type.FullName} as it does not inherit from/implement {typeof(TItem).FullName}.");
+                    EnsureType(type, "register");
                     if (list.Contains(type)) list.Remove(type);
                     list.Add(type);
                 }
@@ -70,8 +95,7 @@ namespace Umbraco.Core.DependencyInjection
                 foreach (var type in types(Container))
                 {
                     // would be detected by CollectionBuilderBase when registering, anyways, but let's fail fast
-                    if (typeof(TItem).IsAssignableFrom(type) == false)
-                        throw new InvalidOperationException($"Cannot register type {type.FullName} as it does not inherit from/implement {typeof(TItem).FullName}.");
+                    EnsureType(type, "register");
                     if (list.Contains(type)) list.Remove(type);
                     list.Add(type);
                 }
@@ -125,6 +149,35 @@ namespace Umbraco.Core.DependencyInjection
             return This;
         }
 
+        /// <summary>
+        /// Inserts a type into the collection.
+        /// </summary>
+        /// <param name="type">The type to insert.</param>
+        /// <returns>The builder.</returns>
+        /// <remarks>Throws if the index is out of range.</remarks>
+        public TBuilder Insert(Type type)
+        {
+            return Insert(0, type);
+        }
+
+        /// <summary>
+        /// Inserts a type into the collection.
+        /// </summary>
+        /// <param name="index">The index.</param>
+        /// <param name="type">The type to insert.</param>
+        /// <returns>The builder.</returns>
+        /// <remarks>Throws if the index is out of range.</remarks>
+        public TBuilder Insert(int index, Type type)
+        {
+            Configure(types =>
+            {
+                EnsureType(type, "register");
+                if (types.Contains(type)) types.Remove(type);
+                types.Insert(index, type);
+            });
+            return This;
+        }
+
         /// <summary>
         /// Inserts a type before another type.
         /// </summary>
@@ -152,6 +205,32 @@ namespace Umbraco.Core.DependencyInjection
             return This;
         }
 
+        /// <summary>
+        /// Inserts a type before another type.
+        /// </summary>
+        /// <param name="typeBefore">The other type.</param>
+        /// <param name="type">The type to insert.</param>
+        /// <returns>The builder.</returns>
+        /// <remarks>Throws if both types are identical, or if the other type does not already belong to the collection.</remarks>
+        public TBuilder InsertBefore(Type typeBefore, Type type)
+        {
+            Configure(types =>
+            {
+                EnsureType(typeBefore, "find");
+                EnsureType(type, "register");
+
+                if (typeBefore == type) throw new InvalidOperationException();
+
+                var index = types.IndexOf(typeBefore);
+                if (index < 0) throw new InvalidOperationException();
+
+                if (types.Contains(type)) types.Remove(type);
+                index = types.IndexOf(typeBefore); // in case removing type changed index
+                types.Insert(index, type);
+            });
+            return This;
+        }
+
         /// <summary>
         /// Removes a type from the collection.
         /// </summary>
@@ -168,6 +247,21 @@ namespace Umbraco.Core.DependencyInjection
             return This;
         }
 
+        /// <summary>
+        /// Removes a type from the collection.
+        /// </summary>
+        /// <param name="type">The type to remove.</param>
+        /// <returns>The builder.</returns>
+        public TBuilder Remove(Type type)
+        {
+            Configure(types =>
+            {
+                EnsureType(type, "remove");
+                if (types.Contains(type)) types.Remove(type);
+            });
+            return This;
+        }
+
         /// <summary>
         /// Replaces a type in the collection.
         /// </summary>
@@ -197,23 +291,29 @@ namespace Umbraco.Core.DependencyInjection
         }
 
         /// <summary>
-        /// Gets a value indicating whether the collection contains a type.
+        /// Replaces a type in the collection.
         /// </summary>
-        /// <typeparam name="T">The type to look for.</typeparam>
-        /// <returns>A value indicating whether the collection contains the type.</returns>
-        public bool Has<T>()
-            where T : TItem
+        /// <param name="typeReplaced">The type to replace.</param>
+        /// <param name="type">The type to insert.</param>
+        /// <returns>The builder.</returns>
+        /// <remarks>Throws if the type to replace does not already belong to the collection.</remarks>
+        public TBuilder Replace(Type typeReplaced, Type type)
         {
-            return HasBase<T>();
-        }
+            Configure(types =>
+            {
+                EnsureType(typeReplaced, "find");
+                EnsureType(type, "register");
 
-        /// <summary>
-        /// Clears all types in the collection.
-        /// </summary>
-        /// <returns>The buidler.</returns>
-        public TBuilder Clear()
-        {
-            Configure(types => types.Clear());
+                if (typeReplaced == type) return;
+
+                var index = types.IndexOf(typeReplaced);
+                if (index < 0) throw new InvalidOperationException();
+
+                if (types.Contains(type)) types.Remove(type);
+                index = types.IndexOf(typeReplaced); // in case removing type changed index
+                types.Insert(index, type);
+                types.Remove(typeReplaced);
+            });
             return This;
         }
     }
diff --git a/src/Umbraco.Core/DependencyInjection/WeightedCollectionBuilderBase.cs b/src/Umbraco.Core/DependencyInjection/WeightedCollectionBuilderBase.cs
index 46703e1bd3..eb922c9692 100644
--- a/src/Umbraco.Core/DependencyInjection/WeightedCollectionBuilderBase.cs
+++ b/src/Umbraco.Core/DependencyInjection/WeightedCollectionBuilderBase.cs
@@ -21,6 +21,16 @@ namespace Umbraco.Core.DependencyInjection
 
         protected abstract TBuilder This { get; }
 
+        /// <summary>
+        /// Clears all types in the collection.
+        /// </summary>
+        /// <returns>The buidler.</returns>
+        public TBuilder Clear()
+        {
+            Configure(types => types.Clear());
+            return This;
+        }
+
         /// <summary>
         /// Adds a type to the collection.
         /// </summary>
@@ -37,6 +47,21 @@ namespace Umbraco.Core.DependencyInjection
             return This;
         }
 
+        /// <summary>
+        /// Adds a type to the collection.
+        /// </summary>
+        /// <param name="type">The type to add.</param>
+        /// <returns>The builder.</returns>
+        public TBuilder Add(Type type)
+        {
+            Configure(types =>
+            {
+                EnsureType(type, "register");
+                if (types.Contains(type) == false) types.Add(type);
+            });
+            return This;
+        }
+
         /// <summary>
         /// Adds types to the collection.
         /// </summary>
@@ -49,8 +74,7 @@ namespace Umbraco.Core.DependencyInjection
                 foreach (var type in types)
                 {
                     // would be detected by CollectionBuilderBase when registering, anyways, but let's fail fast
-                    if (typeof(TItem).IsAssignableFrom(type) == false)
-                        throw new InvalidOperationException($"Cannot register type {type.FullName} as it does not inherit from/implement {typeof(TItem).FullName}.");
+                    EnsureType(type, "register");
                     if (list.Contains(type) == false) list.Add(type);
                 }
             });
@@ -73,7 +97,22 @@ namespace Umbraco.Core.DependencyInjection
             return This;
         }
 
-        protected override IEnumerable<Type> GetTypes(IEnumerable<Type> types)
+        /// <summary>
+        /// Removes a type from the collection.
+        /// </summary>
+        /// <param name="type">The type to remove.</param>
+        /// <returns>The builder.</returns>
+        public TBuilder Remove(Type type)
+        {
+            Configure(types =>
+            {
+                EnsureType(type, "remove");
+                if (types.Contains(type)) types.Remove(type);
+            });
+            return This;
+        }
+
+        protected override IEnumerable<Type> GetRegisteringTypes(IEnumerable<Type> types)
         {
             var list = types.ToList();
             list.Sort((t1, t2) => GetWeight(t1).CompareTo(GetWeight(t2)));
diff --git a/src/Umbraco.Core/Persistence/Migrations/MigrationCollectionBuilder.cs b/src/Umbraco.Core/Persistence/Migrations/MigrationCollectionBuilder.cs
index 1b07bbbeba..ef97bd04c0 100644
--- a/src/Umbraco.Core/Persistence/Migrations/MigrationCollectionBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/MigrationCollectionBuilder.cs
@@ -19,16 +19,19 @@ namespace Umbraco.Core.Persistence.Migrations
             //
             // for IMigrationContext
             container.RegisterConstructorDependency((factory, info, args) => args.Length > 0 ? args[0] as IMigrationContext : null);
-
         }
 
         protected override void Initialize()
         {
-            // nothing - do not register the collection
+            // nothing - do not register the collection            
         }
 
         protected override MigrationCollectionBuilder This => this;
 
+        // this is *not* needed since we do not register the collection
+        // however, keep it here to be absolutely explicit about it
+        protected override ILifetime CollectionLifetime { get; } = null; // transient
+
         public MigrationCollection CreateCollection(IMigrationContext context)
         {
             return new MigrationCollection(CreateItems(context));
diff --git a/src/Umbraco.Core/PropertyEditors/PropertyEditorCollectionBuilder.cs b/src/Umbraco.Core/PropertyEditors/PropertyEditorCollectionBuilder.cs
index 9a9f5fda08..3b87f8695f 100644
--- a/src/Umbraco.Core/PropertyEditors/PropertyEditorCollectionBuilder.cs
+++ b/src/Umbraco.Core/PropertyEditors/PropertyEditorCollectionBuilder.cs
@@ -6,21 +6,21 @@ using Umbraco.Core.Manifest;
 
 namespace Umbraco.Core.PropertyEditors
 {
-    internal class PropertyEditorCollectionBuilder : LazyCollectionBuilderBase<PropertyEditorCollectionBuilder, PropertyEditorCollection, PropertyEditor>
+    public class PropertyEditorCollectionBuilder : LazyCollectionBuilderBase<PropertyEditorCollectionBuilder, PropertyEditorCollection, PropertyEditor>
     {
-        private readonly ManifestBuilder _manifestBuilder;
-
-        public PropertyEditorCollectionBuilder(IServiceContainer container, ManifestBuilder manifestBuilder)
+        public PropertyEditorCollectionBuilder(IServiceContainer container)
             : base(container)
-        {
-            _manifestBuilder = manifestBuilder;
-        }
+        { }
+
+        // have to property-inject that one as it is internal & the builder is public
+        [Inject]
+        internal ManifestBuilder ManifestBuilder { get; set; }
 
         protected override PropertyEditorCollectionBuilder This => this;
 
         protected override IEnumerable<PropertyEditor> CreateItems(params object[] args)
         {
-            return base.CreateItems(args).Union(_manifestBuilder.PropertyEditors);
+            return base.CreateItems(args).Union(ManifestBuilder.PropertyEditors);
         }
     }
 }
diff --git a/src/Umbraco.Tests/DependencyInjection/LazyCollectionBuilderTests.cs b/src/Umbraco.Tests/DependencyInjection/LazyCollectionBuilderTests.cs
index d7186d8b67..d94733cd41 100644
--- a/src/Umbraco.Tests/DependencyInjection/LazyCollectionBuilderTests.cs
+++ b/src/Umbraco.Tests/DependencyInjection/LazyCollectionBuilderTests.cs
@@ -58,9 +58,9 @@ namespace Umbraco.Tests.DependencyInjection
             container.ConfigureUmbracoCore();
 
             TestCollectionBuilder.Register(container)
-                .AddProducer(() => new[] { typeof(TransientObject3), typeof(TransientObject2) })
-                .AddProducer(() => new[] { typeof(TransientObject3), typeof(TransientObject2) })
-                .AddProducer(() => new[] { typeof(TransientObject1) });
+                .Add(() => new[] { typeof(TransientObject3), typeof(TransientObject2) })
+                .Add(() => new[] { typeof(TransientObject3), typeof(TransientObject2) })
+                .Add(() => new[] { typeof(TransientObject1) });
 
             var values = container.GetInstance<TestCollection>();
 
@@ -84,7 +84,7 @@ namespace Umbraco.Tests.DependencyInjection
                 .Add<TransientObject3>()
                 .Add<TransientObject2>()
                 .Add<TransientObject3>()
-                .AddProducer(() => new[] { typeof(TransientObject1) });
+                .Add(() => new[] { typeof(TransientObject1) });
 
             var values = container.GetInstance<TestCollection>();
 
@@ -111,7 +111,7 @@ namespace Umbraco.Tests.DependencyInjection
                 //.Add<TransientObject4>()
 
                 // legal so far...
-                .AddProducer(() => new[] { typeof(TransientObject4)  });
+                .Add(() => new[] { typeof(TransientObject4)  });
 
 	        Assert.Throws<InvalidOperationException>(() =>
 	        {
@@ -128,7 +128,7 @@ namespace Umbraco.Tests.DependencyInjection
 
             TestCollectionBuilder.Register(container)
                 .Add<TransientObject3>()
-                .AddProducer(() => new[] { typeof(TransientObject3), typeof(TransientObject2), typeof(TransientObject1) })
+                .Add(() => new[] { typeof(TransientObject3), typeof(TransientObject2), typeof(TransientObject1) })
                 .Exclude<TransientObject3>();
 
             var values = container.GetInstance<TestCollection>();
diff --git a/src/Umbraco.Tests/DependencyInjection/PackageActionCollectionTests.cs b/src/Umbraco.Tests/DependencyInjection/PackageActionCollectionTests.cs
index a916f40a98..a8c20289ef 100644
--- a/src/Umbraco.Tests/DependencyInjection/PackageActionCollectionTests.cs
+++ b/src/Umbraco.Tests/DependencyInjection/PackageActionCollectionTests.cs
@@ -23,7 +23,7 @@ namespace Umbraco.Tests.DependencyInjection
             container.ConfigureUmbracoCore();
 
             PackageActionCollectionBuilder.Register(container)
-                .AddProducer(() => PluginManager.ResolvePackageActions());
+                .Add(() => PluginManager.ResolvePackageActions());
 
 			var actions = Current.PackageActions;
 			Assert.AreEqual(2, actions.Count());
diff --git a/src/Umbraco.Tests/Models/Mapping/AutoMapperTests.cs b/src/Umbraco.Tests/Models/Mapping/AutoMapperTests.cs
index 8f123bfba0..39822f1b7e 100644
--- a/src/Umbraco.Tests/Models/Mapping/AutoMapperTests.cs
+++ b/src/Umbraco.Tests/Models/Mapping/AutoMapperTests.cs
@@ -28,7 +28,7 @@ namespace Umbraco.Tests.Models.Mapping
 
             Func<IEnumerable<Type>> typeListProducerList = Enumerable.Empty<Type>;
             PropertyEditorCollectionBuilder.Register(Container)
-                .AddProducer(typeListProducerList);
+                .Add(typeListProducerList);
         }
 
         [Test]
diff --git a/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs b/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs
index e7b4813d6e..1190a68dbe 100644
--- a/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs
+++ b/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs
@@ -86,7 +86,7 @@ namespace Umbraco.Tests.TestHelpers
             Container.Register(_ => manifestBuilder);
 
             PropertyEditorCollectionBuilder.Register(Container)
-                .AddProducer(() => Current.PluginManager.ResolvePropertyEditors());
+                .Add(() => Current.PluginManager.ResolvePropertyEditors());
         }
 
         private CacheHelper _disabledCacheHelper;
diff --git a/src/Umbraco.Tests/TestHelpers/BaseUsingSqlCeSyntax.cs b/src/Umbraco.Tests/TestHelpers/BaseUsingSqlCeSyntax.cs
index d0eb6e06d1..3bc1f1d7cd 100644
--- a/src/Umbraco.Tests/TestHelpers/BaseUsingSqlCeSyntax.cs
+++ b/src/Umbraco.Tests/TestHelpers/BaseUsingSqlCeSyntax.cs
@@ -44,7 +44,7 @@ namespace Umbraco.Tests.TestHelpers
             container.RegisterInstance(pluginManager);
 
             MapperCollectionBuilder.Register(container)
-                .AddProducer(() => Current.PluginManager.ResolveAssignedMapperTypes());
+                .Add(() => Current.PluginManager.ResolveAssignedMapperTypes());
             Mappers = container.GetInstance<IMapperCollection>();
 
             var mappers = new NPoco.MapperCollection { new PocoMapper() };
diff --git a/src/Umbraco.Web/Current.cs b/src/Umbraco.Web/Current.cs
index 1bba684c2f..ba7e496665 100644
--- a/src/Umbraco.Web/Current.cs
+++ b/src/Umbraco.Web/Current.cs
@@ -19,6 +19,7 @@ using Umbraco.Core._Legacy.PackageActions;
 using Umbraco.Web.Editors;
 using Umbraco.Web.HealthCheck;
 using Umbraco.Web.Media;
+using Umbraco.Web.Media.ThumbnailProviders;
 using Umbraco.Web.Mvc;
 using Umbraco.Web.PublishedCache;
 using Umbraco.Web.Routing;
@@ -134,7 +135,7 @@ namespace Umbraco.Web
         public static HealthCheckCollectionBuilder HealthCheckCollectionBuilder
             => Container.GetInstance<HealthCheckCollectionBuilder>();
 
-        public static ActionCollectionBuilder ActionCollectionBuilder
+        internal static ActionCollectionBuilder ActionCollectionBuilder
             => Container.GetInstance<ActionCollectionBuilder>();
 
         public static ActionCollection Actions
@@ -173,6 +174,9 @@ namespace Umbraco.Web
         public static ISiteDomainHelper SiteDomainHelper
             => Container.GetInstance<ISiteDomainHelper>();
 
+        public static ThumbnailProviderCollection ThumbnailProviders
+            => Container.GetInstance<ThumbnailProviderCollection>();
+
         #endregion
 
         #region Web Constants
diff --git a/src/Umbraco.Web/HealthCheck/HeathCheckCollectionBuilder.cs b/src/Umbraco.Web/HealthCheck/HeathCheckCollectionBuilder.cs
index cf82b0ee6d..18a914c481 100644
--- a/src/Umbraco.Web/HealthCheck/HeathCheckCollectionBuilder.cs
+++ b/src/Umbraco.Web/HealthCheck/HeathCheckCollectionBuilder.cs
@@ -11,6 +11,8 @@ namespace Umbraco.Web.HealthCheck
 
         protected override HealthCheckCollectionBuilder This => this;
 
+        // note: in v7 they were per-request, not sure why?
+        // the collection is injected into the controller & there's only 1 controller per request anyways
         protected override ILifetime CollectionLifetime => null; // transient!
     }
 }
diff --git a/src/Umbraco.Web/Strategies/Migrations/PostMigrationComponent.cs b/src/Umbraco.Web/Strategies/Migrations/PostMigrationComponent.cs
index 3d4d76a95d..026e81370b 100644
--- a/src/Umbraco.Web/Strategies/Migrations/PostMigrationComponent.cs
+++ b/src/Umbraco.Web/Strategies/Migrations/PostMigrationComponent.cs
@@ -10,7 +10,7 @@ namespace Umbraco.Web.Strategies.Migrations
         public override void Compose(ServiceContainer container)
         {
             PostMigrationCollectionBuilder.Register(container)
-                .AddProducer(factory => factory.GetInstance<PluginManager>().ResolveTypes<IPostMigration>());
+                .Add(factory => factory.GetInstance<PluginManager>().ResolveTypes<IPostMigration>());
         }
 
         public void Initialize(PostMigrationCollection posts)
diff --git a/src/Umbraco.Web/WebRuntimeComponent.cs b/src/Umbraco.Web/WebRuntimeComponent.cs
index 628cd9c66a..68299ccf14 100644
--- a/src/Umbraco.Web/WebRuntimeComponent.cs
+++ b/src/Umbraco.Web/WebRuntimeComponent.cs
@@ -108,7 +108,7 @@ namespace Umbraco.Web
                 .AddExtensionObjectProducer(() => pluginManager.ResolveXsltExtensions());
 
             EditorValidatorCollectionBuilder.Register(container)
-                .AddProducer(() => pluginManager.ResolveTypes<IEditorValidator>());
+                .Add(() => pluginManager.ResolveTypes<IEditorValidator>());
 
             // set the default RenderMvcController
             Current.DefaultRenderMvcControllerType = typeof(RenderMvcController); // fixme WRONG!
@@ -151,7 +151,7 @@ namespace Umbraco.Web
                 .Append<DefaultUrlProvider>()
                 .Append<CustomRouteUrlProvider>();
 
-            container.Register<IContentLastChanceFinder, ContentFinderByLegacy404>();
+            container.RegisterSingleton<IContentLastChanceFinder, ContentFinderByLegacy404>();
 
             ContentFinderCollectionBuilder.Register(container)
                 // all built-in finders in the correct order,
@@ -164,7 +164,7 @@ namespace Umbraco.Web
                 .Append<ContentFinderByUrlAlias>()
                 .Append<ContentFinderByRedirectUrl>();
 
-            container.Register<ISiteDomainHelper, SiteDomainHelper>();
+            container.RegisterSingleton<ISiteDomainHelper, SiteDomainHelper>();
 
             ThumbnailProviderCollectionBuilder.Register(container)
                 .Add(pluginManager.ResolveThumbnailProviders());
@@ -176,7 +176,7 @@ namespace Umbraco.Web
 
             // register *all* checks, except those marked [HideFromTypeFinder] of course
             HealthCheckCollectionBuilder.Register(container)
-                .AddProducer(() => pluginManager.ResolveTypes<HealthCheck.HealthCheck>());
+                .Add(() => pluginManager.ResolveTypes<HealthCheck.HealthCheck>());
 
             // auto-register views
             container.RegisterAuto(typeof(UmbracoViewPage<>));
diff --git a/src/Umbraco.Web/_Legacy/Actions/ActionAssignDomain.cs b/src/Umbraco.Web/_Legacy/Actions/ActionAssignDomain.cs
index 70601cf959..da0b0f1c45 100644
--- a/src/Umbraco.Web/_Legacy/Actions/ActionAssignDomain.cs
+++ b/src/Umbraco.Web/_Legacy/Actions/ActionAssignDomain.cs
@@ -8,7 +8,7 @@ using Umbraco.Web.UI.Pages;
 
 namespace Umbraco.Web._Legacy.Actions
 {
-    public class ActionCollectionBuilder : ICollectionBuilder<ActionCollection, IAction>
+    internal class ActionCollectionBuilder : ICollectionBuilder<ActionCollection, IAction>
     {
         private static Func<IEnumerable<Type>> _producer;
 
@@ -23,6 +23,13 @@ namespace Umbraco.Web._Legacy.Actions
             var collectionLifetime = builder.CollectionLifetime;
 
             // register the collection - special lifetime
+            // the lifetime here is custom ResettablePerContainerLifetime which will manage one
+            // single instance of the collection (much alike PerContainerLifetime) but can be resetted
+            // to force a new collection to be created.
+            // this is needed because of the weird things we do during install, where we'd use the
+            // infamous DirtyBackdoorToConfiguration to reset the ActionResolver way after Resolution
+            // had frozen. This has been replaced by the possibility here to set the producer at any
+            // time - but the builder is internal - and all this will be gone eventually.
             container.Register(factory => factory.GetInstance<ActionCollectionBuilder>().CreateCollection(), collectionLifetime);
 
             return builder;