Merge remote-tracking branch 'upstream/dev-v7' into dev-v7-U4-9571

# Conflicts:
#	src/Umbraco.Web.UI.Client/src/less/tree.less

src/SQLCE4Umbraco/SqlCE4Umbraco.csproj

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
@@ -49,9 +49,11 @@
     <Reference Include="System.Core" />
     <Reference Include="System.Data.SqlServerCe, Version=4.0.0.1, Culture=neutral, PublicKeyToken=89845dcd8080cc91, processorArchitecture=MSIL">
       <HintPath>..\packages\SqlServerCE.4.0.0.1\lib\System.Data.SqlServerCe.dll</HintPath>
+      <Private>True</Private>
     </Reference>
     <Reference Include="System.Data.SqlServerCe.Entity, Version=4.0.0.1, Culture=neutral, PublicKeyToken=89845dcd8080cc91, processorArchitecture=MSIL">
       <HintPath>..\packages\SqlServerCE.4.0.0.1\lib\System.Data.SqlServerCe.Entity.dll</HintPath>
+      <Private>True</Private>
     </Reference>
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />

src/SQLCE4Umbraco/SqlCEHelper.cs

@@ -180,12 +180,16 @@ namespace SqlCE4Umbraco
         /// <returns>The return value of the command.</returns>
         protected override object ExecuteScalar(string commandText, SqlCeParameter[] parameters)
         {
-            #if DEBUG && DebugDataLayer
+#if DEBUG && DebugDataLayer
                 // Log Query Execution
                 Trace.TraceInformation(GetType().Name + " SQL ExecuteScalar: " + commandText);
-            #endif
-
-            return SqlCeApplicationBlock.ExecuteScalar(ConnectionString, CommandType.Text, commandText, parameters);
+#endif
+            using (var cc = UseCurrentConnection)
+            {
+                return SqlCeApplicationBlock.ExecuteScalar(
+                    (SqlCeConnection) cc.Connection, (SqlCeTransaction) cc.Transaction,
+                    CommandType.Text, commandText, parameters);
+            }
         }
 
         /// <summary>
@@ -198,12 +202,17 @@ namespace SqlCE4Umbraco
         /// </returns>
         protected override int ExecuteNonQuery(string commandText, SqlCeParameter[] parameters)
         {
-            #if DEBUG && DebugDataLayer
+#if DEBUG && DebugDataLayer
                 // Log Query Execution
                 Trace.TraceInformation(GetType().Name + " SQL ExecuteNonQuery: " + commandText);
-            #endif
+#endif
 
-            return SqlCeApplicationBlock.ExecuteNonQuery(ConnectionString, CommandType.Text, commandText, parameters);
+            using (var cc = UseCurrentConnection)
+            {
+                return SqlCeApplicationBlock.ExecuteNonQuery(
+                    (SqlCeConnection) cc.Connection, (SqlCeTransaction) cc.Transaction,
+                    CommandType.Text, commandText, parameters);
+            }
         }
 
         /// <summary>
@@ -216,13 +225,17 @@ namespace SqlCE4Umbraco
         /// </returns>
         protected override IRecordsReader ExecuteReader(string commandText, SqlCeParameter[] parameters)
         {
-            #if DEBUG && DebugDataLayer
+#if DEBUG && DebugDataLayer
                 // Log Query Execution
                 Trace.TraceInformation(GetType().Name + " SQL ExecuteReader: " + commandText);
-            #endif
+#endif
 
-            return new SqlCeDataReaderHelper(SqlCeApplicationBlock.ExecuteReader(ConnectionString, CommandType.Text,
-                                                            commandText, parameters));
+            using (var cc = UseCurrentConnection)
+            {
+                return new SqlCeDataReaderHelper(SqlCeApplicationBlock.ExecuteReader(
+                    (SqlCeConnection) cc.Connection, (SqlCeTransaction) cc.Transaction,
+                    CommandType.Text, commandText, parameters));
+            }
         }
 
 

src/SQLCE4Umbraco/SqlCeApplicationBlock.cs

@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Data.SqlServerCe;
 using System.Data;
 using System.Diagnostics;
@@ -26,30 +24,61 @@ namespace SqlCE4Umbraco
             params SqlCeParameter[] commandParameters
             )
         {
-            object retVal;
-
             try
             {
-                using (SqlCeConnection conn = SqlCeContextGuardian.Open(connectionString))
+                using (var conn = SqlCeContextGuardian.Open(connectionString))
                 {
-                    using (SqlCeCommand cmd = new SqlCeCommand(commandText, conn))
-                    {
-                        AttachParameters(cmd, commandParameters);
-                        Debug.WriteLine("---------------------------------SCALAR-------------------------------------");
-                        Debug.WriteLine(commandText);
-                        Debug.WriteLine("----------------------------------------------------------------------------");
-                        retVal = cmd.ExecuteScalar();
-                    }
+                    return ExecuteScalarTry(conn, null, commandText, commandParameters);
                 }
-
-                return retVal;
             }
             catch (Exception ee)
             {
-                throw new SqlCeProviderException("Error running Scalar: \nSQL Statement:\n" + commandText + "\n\nException:\n" + ee.ToString());
+                throw new SqlCeProviderException("Error running Scalar: \nSQL Statement:\n" + commandText + "\n\nException:\n" + ee);
             }
         }
 
+        public static object ExecuteScalar(
+            SqlCeConnection conn, SqlCeTransaction trx,
+            CommandType commandType,
+            string commandText,
+            params SqlCeParameter[] commandParameters)
+        {
+            try
+            {
+                return ExecuteScalarTry(conn, trx, commandText, commandParameters);
+            }
+            catch (Exception ee)
+            {
+                throw new SqlCeProviderException("Error running Scalar: \nSQL Statement:\n" + commandText + "\n\nException:\n" + ee);
+            }
+        }
+
+        public static object ExecuteScalar(
+            SqlCeConnection conn,
+            CommandType commandType,
+            string commandText,
+            params SqlCeParameter[] commandParameters)
+        {
+            return ExecuteScalar(conn, null, commandType, commandText, commandParameters);
+        }
+
+        private static object ExecuteScalarTry(
+            SqlCeConnection conn, SqlCeTransaction trx,
+            string commandText,
+            params SqlCeParameter[] commandParameters)
+        {
+            object retVal;
+            using (var cmd = trx == null ? new SqlCeCommand(commandText, conn) : new SqlCeCommand(commandText, conn, trx))
+            {
+                AttachParameters(cmd, commandParameters);
+                Debug.WriteLine("---------------------------------SCALAR-------------------------------------");
+                Debug.WriteLine(commandText);
+                Debug.WriteLine("----------------------------------------------------------------------------");
+                retVal = cmd.ExecuteScalar();
+            }
+            return retVal;
+        }
+
         /// <summary>
         /// 
         /// </summary>
@@ -66,49 +95,10 @@ namespace SqlCE4Umbraco
         {
             try
             {
-                int rowsAffected;
-                using (SqlCeConnection conn = SqlCeContextGuardian.Open(connectionString))
+                using (var conn = SqlCeContextGuardian.Open(connectionString))
                 {
-                    // this is for multiple queries in the installer
-                    if (commandText.Trim().StartsWith("!!!"))
-                    {
-                        commandText = commandText.Trim().Trim('!');
-                        string[] commands = commandText.Split('|');
-                        string currentCmd = String.Empty;
-
-                        foreach (string cmd in commands)
-                        {
-                            try
-                            {
-                                currentCmd = cmd;
-                                if (!String.IsNullOrWhiteSpace(cmd))
-                                {
-                                    SqlCeCommand c = new SqlCeCommand(cmd, conn);
-                                    c.ExecuteNonQuery();
-                                }
-                            }
-                            catch (Exception e)
-                            {
-                                Debug.WriteLine("*******************************************************************");
-                                Debug.WriteLine(currentCmd);
-                                Debug.WriteLine(e);
-                                Debug.WriteLine("*******************************************************************");
-                            }
-                        }
-                        return 1;
-                    }
-                    else
-                    {
-                        Debug.WriteLine("----------------------------------------------------------------------------");
-                        Debug.WriteLine(commandText);
-                        Debug.WriteLine("----------------------------------------------------------------------------");
-                        SqlCeCommand cmd = new SqlCeCommand(commandText, conn);
-                        AttachParameters(cmd, commandParameters);
-                        rowsAffected = cmd.ExecuteNonQuery();
-                    }
+                    return ExecuteNonQueryTry(conn, null, commandText, commandParameters);
                 }
-
-                return rowsAffected;
             }
             catch (Exception ee)
             {
@@ -116,6 +106,74 @@ namespace SqlCE4Umbraco
             }
         }
 
+        public static int ExecuteNonQuery(
+            SqlCeConnection conn,
+            CommandType commandType,
+            string commandText,
+            params SqlCeParameter[] commandParameters
+        )
+        {
+            return ExecuteNonQuery(conn, null, commandType, commandText, commandParameters);
+        }
+
+        public static int ExecuteNonQuery(
+            SqlCeConnection conn, SqlCeTransaction trx,
+            CommandType commandType,
+            string commandText,
+            params SqlCeParameter[] commandParameters
+            )
+        {
+            try
+            {
+                return ExecuteNonQueryTry(conn, trx, commandText, commandParameters);
+            }
+            catch (Exception ee)
+            {
+                throw new SqlCeProviderException("Error running NonQuery: \nSQL Statement:\n" + commandText + "\n\nException:\n" + ee.ToString());
+            }
+        }
+
+        private static int ExecuteNonQueryTry(
+            SqlCeConnection conn, SqlCeTransaction trx,
+            string commandText,
+            params SqlCeParameter[] commandParameters)
+        {
+            // this is for multiple queries in the installer
+            if (commandText.Trim().StartsWith("!!!"))
+            {
+                commandText = commandText.Trim().Trim('!');
+                var commands = commandText.Split('|');
+                var currentCmd = string.Empty;
+
+                foreach (var command in commands)
+                {
+                    try
+                    {
+                        currentCmd = command;
+                        if (string.IsNullOrWhiteSpace(command)) continue;
+                        var c = trx == null ? new SqlCeCommand(command, conn) : new SqlCeCommand(command, conn, trx);
+                        c.ExecuteNonQuery();
+                    }
+                    catch (Exception e)
+                    {
+                        Debug.WriteLine("*******************************************************************");
+                        Debug.WriteLine(currentCmd);
+                        Debug.WriteLine(e);
+                        Debug.WriteLine("*******************************************************************");
+                    }
+                }
+                return 1;
+            }
+
+            Debug.WriteLine("----------------------------------------------------------------------------");
+            Debug.WriteLine(commandText);
+            Debug.WriteLine("----------------------------------------------------------------------------");
+            var cmd = new SqlCeCommand(commandText, conn);
+            AttachParameters(cmd, commandParameters);
+            var rowsAffected = cmd.ExecuteNonQuery();
+            return rowsAffected;
+        }
+
         /// <summary>
         /// 
         /// </summary>
@@ -133,25 +191,8 @@ namespace SqlCE4Umbraco
         {
             try
             {
-                Debug.WriteLine("---------------------------------READER-------------------------------------");
-                Debug.WriteLine(commandText);
-                Debug.WriteLine("----------------------------------------------------------------------------");
-                SqlCeDataReader reader;
-                SqlCeConnection conn = SqlCeContextGuardian.Open(connectionString);
-
-                try
-                {
-                    SqlCeCommand cmd = new SqlCeCommand(commandText, conn);
-                    AttachParameters(cmd, commandParameters);
-                    reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
-                }
-                catch
-                {
-                    conn.Close();
-                    throw;
-                }
-
-                return reader;
+                var conn = SqlCeContextGuardian.Open(connectionString);
+                return ExecuteReaderTry(conn, null, commandText, commandParameters);
             }
             catch (Exception ee)
             {
@@ -159,30 +200,71 @@ namespace SqlCE4Umbraco
             }
         }
 
-        public static bool VerifyConnection(string connectionString)
+        public static SqlCeDataReader ExecuteReader(
+            SqlCeConnection conn,
+            CommandType commandType,
+            string commandText,
+            params SqlCeParameter[] commandParameters
+        )
         {
-            bool isConnected = false;
-            using (SqlCeConnection conn = SqlCeContextGuardian.Open(connectionString))
-            {
-                isConnected = conn.State == ConnectionState.Open;
-            }
-
-            return isConnected;
+            return ExecuteReader(conn, commandType, commandText, commandParameters);
         }
 
-        private static void AttachParameters(SqlCeCommand command, SqlCeParameter[] commandParameters)
+        public static SqlCeDataReader ExecuteReader(
+            SqlCeConnection conn, SqlCeTransaction trx,
+            CommandType commandType,
+            string commandText,
+            params SqlCeParameter[] commandParameters
+            )
         {
-            foreach (SqlCeParameter parameter in commandParameters)
+            try
+            {
+                return ExecuteReaderTry(conn, trx, commandText, commandParameters);
+            }
+            catch (Exception ee)
+            {
+                throw new SqlCeProviderException("Error running Reader: \nSQL Statement:\n" + commandText + "\n\nException:\n" + ee.ToString());
+            }
+        }
+
+        private static SqlCeDataReader ExecuteReaderTry(
+            SqlCeConnection conn, SqlCeTransaction trx,
+            string commandText,
+            params SqlCeParameter[] commandParameters)
+        {
+            Debug.WriteLine("---------------------------------READER-------------------------------------");
+            Debug.WriteLine(commandText);
+            Debug.WriteLine("----------------------------------------------------------------------------");
+
+            try
+            {
+                var cmd = trx == null ? new SqlCeCommand(commandText, conn) : new SqlCeCommand(commandText, conn, trx);
+                AttachParameters(cmd, commandParameters);
+                return cmd.ExecuteReader();
+            }
+            catch
+            {
+                conn.Close();
+                throw;
+            }
+        }
+
+        public static bool VerifyConnection(string connectionString)
+        {
+            using (var conn = SqlCeContextGuardian.Open(connectionString))
+            {
+                return conn.State == ConnectionState.Open;
+            }
+        }
+
+        private static void AttachParameters(SqlCeCommand command, IEnumerable<SqlCeParameter> commandParameters)
+        {
+            foreach (var parameter in commandParameters)
             {
                 if ((parameter.Direction == ParameterDirection.InputOutput) && (parameter.Value == null))
-                {
                     parameter.Value = DBNull.Value;
-                }
                 command.Parameters.Add(parameter);
             }
         }
-
-
-
     }
 }

src/SQLCE4Umbraco/app.config

@@ -4,7 +4,7 @@
     <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
       <dependentAssembly>
         <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
+        <bindingRedirect oldVersion="0.0.0.0-10.0.0.0" newVersion="10.0.0.0" />
       </dependentAssembly>
       <dependentAssembly>
         <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35" culture="neutral" />
@@ -30,6 +30,10 @@
         <assemblyIdentity name="Microsoft.Owin.Security.Cookies" publicKeyToken="31bf3856ad364e35" culture="neutral" />
         <bindingRedirect oldVersion="0.0.0.0-3.0.1.0" newVersion="3.0.1.0" />
       </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="log4net" publicKeyToken="669e0ddf0bb1aa2a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-2.0.8.0" newVersion="2.0.8.0" />
+      </dependentAssembly>
     </assemblyBinding>
   </runtime>
-</configuration>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" /></startup></configuration>

src/SolutionInfo.cs

@@ -11,5 +11,5 @@ using System.Resources;
 
 [assembly: AssemblyVersion("1.0.*")]
 
-[assembly: AssemblyFileVersion("7.5.11")]
-[assembly: AssemblyInformationalVersion("7.5.11")]
+[assembly: AssemblyFileVersion("7.6.1")]
+[assembly: AssemblyInformationalVersion("7.6.1")]

src/Umbraco.Core/ApplicationContext.cs

@@ -1,12 +1,11 @@
 using System;
 using System.Configuration;
 using System.Threading;
-using System.Threading.Tasks;
-using System.Web;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 using Umbraco.Core.ObjectResolution;
 using Umbraco.Core.Profiling;
+using Umbraco.Core.Scoping;
 using Umbraco.Core.Services;
 using Umbraco.Core.Sync;
 
@@ -162,6 +161,11 @@ namespace Umbraco.Core
     	/// </summary>
     	public static ApplicationContext Current { get; internal set; }
 
+        /// <summary>
+        /// Gets the scope provider.
+        /// </summary>
+        internal IScopeProvider ScopeProvider { get { return _databaseContext == null ? null : _databaseContext.ScopeProvider; } }
+
 		/// <summary>
 		/// Returns the application wide cache accessor
 		/// </summary>
@@ -296,7 +300,7 @@ namespace Umbraco.Core
                         // if we have a db context available, if we don't then we are not installed anyways
                         if (DatabaseContext.IsDatabaseConfigured && DatabaseContext.CanConnect)
                         {
-                            var found = Services.MigrationEntryService.FindEntry(GlobalSettings.UmbracoMigrationName, UmbracoVersion.GetSemanticVersion());
+                            var found = Services.MigrationEntryService.FindEntry(Constants.System.UmbracoMigrationName, UmbracoVersion.GetSemanticVersion());
                             if (found == null)
                             {
                                 //we haven't executed this migration in this environment, so even though the config versions match, 
@@ -418,10 +422,17 @@ namespace Umbraco.Core
                 this.ApplicationCache = null;
                 if (_databaseContext != null) //need to check the internal field here
                 {
+                    if (_databaseContext.ScopeProvider.AmbientScope != null)
+                    {
+                        var scope = _databaseContext.ScopeProvider.AmbientScope;
+                        scope.Dispose();
+                    }
+                    /*
                     if (DatabaseContext.IsDatabaseConfigured && DatabaseContext.Database != null)
                     {
                         DatabaseContext.Database.Dispose();       
-                    }                    
+                    } 
+                    */                   
                 }
                 this.DatabaseContext = null;
                 this.Services = null;

src/Umbraco.Core/BindingRedirects.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Reflection;
+using System.Text.RegularExpressions;
+using System.Web;
+using Umbraco.Core;
+
+[assembly: PreApplicationStartMethod(typeof(BindingRedirects), "Initialize")]
+
+namespace Umbraco.Core
+{
+    /// <summary>
+    /// Manages any assembly binding redirects that cannot be done via config (i.e. unsigned --> signed assemblies)
+    /// </summary>
+    public sealed class BindingRedirects
+    {
+        public static void Initialize()
+        {
+            // this only gets called when an assembly can't be resolved
+            AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
+        }
+
+        private static readonly Regex Log4NetAssemblyPattern = new Regex("log4net, Version=([\\d\\.]+?), Culture=neutral, PublicKeyToken=\\w+$", RegexOptions.Compiled);
+        private const string Log4NetReplacement = "log4net, Version=2.0.8.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a";
+        
+        /// <summary>
+        /// This is used to do an assembly binding redirect via code - normally required due to signature changes in assemblies
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="args"></param>
+        /// <returns></returns>
+        private static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
+        {
+            //log4net:            
+            if (Log4NetAssemblyPattern.IsMatch(args.Name) && args.Name != Log4NetReplacement)
+            {
+                return Assembly.Load(Log4NetAssemblyPattern.Replace(args.Name, Log4NetReplacement));
+            }
+            
+            //AutoMapper:
+            // ensure the assembly is indeed AutoMapper and that the PublicKeyToken is null before trying to Load again
+            // do NOT just replace this with 'return Assembly', as it will cause an infinite loop -> stackoverflow
+            if (args.Name.StartsWith("AutoMapper") && args.Name.EndsWith("PublicKeyToken=null"))
+                return Assembly.Load(args.Name.Replace(", PublicKeyToken=null", ", PublicKeyToken=be96cd2c38ef1005"));
+
+            return null;
+            
+        }
+    }
+}

src/Umbraco.Core/ByteArrayExtensions.cs

@@ -0,0 +1,39 @@
+namespace Umbraco.Core
+{
+    public static class ByteArrayExtensions
+    {
+        private static readonly char[] BytesToHexStringLookup = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+
+        public static string ToHexString(this byte[] bytes)
+        {
+            int i = 0, p = 0, bytesLength = bytes.Length;
+            var chars = new char[bytesLength * 2];
+            while (i < bytesLength)
+            {
+                var b = bytes[i++];
+                chars[p++] = BytesToHexStringLookup[b / 0x10];
+                chars[p++] = BytesToHexStringLookup[b % 0x10];
+            }
+            return new string(chars, 0, chars.Length);
+        }
+
+        public static string ToHexString(this byte[] bytes, char separator, int blockSize, int blockCount)
+        {
+            int p = 0, bytesLength = bytes.Length, count = 0, size = 0;
+            var chars = new char[bytesLength * 2 + blockCount];
+            for (var i = 0; i < bytesLength; i++)
+            {
+                var b = bytes[i++];
+                chars[p++] = BytesToHexStringLookup[b / 0x10];
+                chars[p++] = BytesToHexStringLookup[b % 0x10];
+                if (count == blockCount) continue;
+                if (++size < blockSize) continue;
+
+                chars[p++] = '/';
+                size = 0;
+                count++;
+            }
+            return new string(chars, 0, chars.Length);
+        }
+    }
+}

src/Umbraco.Core/Cache/DeepCloneRuntimeCacheProvider.cs

@@ -26,6 +26,9 @@ namespace Umbraco.Core.Cache
 
         public DeepCloneRuntimeCacheProvider(IRuntimeCacheProvider innerProvider)
         {
+            if (innerProvider.GetType() == typeof(DeepCloneRuntimeCacheProvider))
+                throw new InvalidOperationException("A " + typeof(DeepCloneRuntimeCacheProvider) + " cannot wrap another instance of " + typeof(DeepCloneRuntimeCacheProvider));
+
             InnerProvider = innerProvider;
         }
 
@@ -105,9 +108,11 @@ namespace Umbraco.Core.Cache
                 var value = result.Value; // force evaluation now - this may throw if cacheItem throws, and then nothing goes into cache
                 if (value == null) return null; // do not store null values (backward compat)
 
+                //Clone/reset to go into the cache
                 return CheckCloneableAndTracksChanges(value);
             }, timeout, isSliding, priority, removedCallback, dependentFiles);
 
+            //Clone/reset to go out of the cache
             return CheckCloneableAndTracksChanges(cached);
         }
 

src/Umbraco.Core/Cache/DefaultRepositoryCachePolicy.cs

@@ -1,268 +1,250 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Umbraco.Core.Logging;
 using Umbraco.Core.Models.EntityBase;
+using Umbraco.Core.Scoping;
 
 namespace Umbraco.Core.Cache
 {
     /// <summary>
-    /// The default cache policy for retrieving a single entity
+    /// Represents the default cache policy.
     /// </summary>
-    /// <typeparam name="TEntity"></typeparam>
-    /// <typeparam name="TId"></typeparam>
+    /// <typeparam name="TEntity">The type of the entity.</typeparam>
+    /// <typeparam name="TId">The type of the identifier.</typeparam>
     /// <remarks>
-    /// This cache policy uses sliding expiration and caches instances for 5 minutes. However if allow zero count is true, then we use the
-    /// default policy with no expiry.
+    /// <para>The default cache policy caches entities with a 5 minutes sliding expiration.</para>
+    /// <para>Each entity is cached individually.</para>
+    /// <para>If options.GetAllCacheAllowZeroCount then a 'zero-count' array is cached when GetAll finds nothing.</para>
+    /// <para>If options.GetAllCacheValidateCount then we check against the db when getting many entities.</para>
     /// </remarks>
     internal class DefaultRepositoryCachePolicy<TEntity, TId> : RepositoryCachePolicyBase<TEntity, TId>
         where TEntity : class, IAggregateRoot
     {
+        private static readonly TEntity[] EmptyEntities = new TEntity[0]; // const
         private readonly RepositoryCachePolicyOptions _options;
-       
+
         public DefaultRepositoryCachePolicy(IRuntimeCacheProvider cache, RepositoryCachePolicyOptions options)
             : base(cache)
-        {            
+        {
             if (options == null) throw new ArgumentNullException("options");
-            _options = options;         
+            _options = options;
         }
 
-        protected string GetCacheIdKey(object id)
+        public override IRepositoryCachePolicy<TEntity, TId> Scoped(IRuntimeCacheProvider runtimeCache, IScope scope)
+        {
+            return new ScopedRepositoryCachePolicy<TEntity, TId>(this, runtimeCache, scope);
+        }
+
+        protected string GetEntityCacheKey(object id)
         {
             if (id == null) throw new ArgumentNullException("id");
-
-            return string.Format("{0}{1}", GetCacheTypeKey(), id);
+            return GetEntityTypeCacheKey() + id;
         }
 
-        protected string GetCacheTypeKey()
+        protected string GetEntityTypeCacheKey()
         {
             return string.Format("uRepo_{0}_", typeof(TEntity).Name);
         }
 
-        public override void CreateOrUpdate(TEntity entity, Action<TEntity> persistMethod)
+        protected virtual void InsertEntity(string cacheKey, TEntity entity)
+        {
+            Cache.InsertCacheItem(cacheKey, () => entity, TimeSpan.FromMinutes(5), true);
+        }
+
+        protected virtual void InsertEntities(TId[] ids, TEntity[] entities)
+        {
+            if (ids.Length == 0 && entities.Length == 0 && _options.GetAllCacheAllowZeroCount)
+            {
+                // getting all of them, and finding nothing.
+                // if we can cache a zero count, cache an empty array,
+                // for as long as the cache is not cleared (no expiration)
+                Cache.InsertCacheItem(GetEntityTypeCacheKey(), () => EmptyEntities);
+            }
+            else
+            {
+                // individually cache each item
+                foreach (var entity in entities)
+                {
+                    var capture = entity;
+                    Cache.InsertCacheItem(GetEntityCacheKey(entity.Id), () => capture, TimeSpan.FromMinutes(5), true);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        public override void Create(TEntity entity, Action<TEntity> persistNew)
         {
             if (entity == null) throw new ArgumentNullException("entity");
-            if (persistMethod == null) throw new ArgumentNullException("persistMethod");
 
             try
             {
-                persistMethod(entity);
+                persistNew(entity);
 
-                //set the disposal action                
-                SetCacheAction(() =>
+                // just to be safe, we cannot cache an item without an identity
+                if (entity.HasIdentity)
                 {
-                    //just to be safe, we cannot cache an item without an identity
-                    if (entity.HasIdentity)
-                    {
-                        Cache.InsertCacheItem(GetCacheIdKey(entity.Id), () => entity,
-                            timeout: TimeSpan.FromMinutes(5),
-                            isSliding: true);
-                    }
-                    
-                    //If there's a GetAllCacheAllowZeroCount cache, ensure it is cleared
-                    Cache.ClearCacheItem(GetCacheTypeKey());
-                });
-                
+                    Cache.InsertCacheItem(GetEntityCacheKey(entity.Id), () => entity, TimeSpan.FromMinutes(5), true);
+                }
+
+                // if there's a GetAllCacheAllowZeroCount cache, ensure it is cleared
+                Cache.ClearCacheItem(GetEntityTypeCacheKey());
             }
             catch
             {
-                //set the disposal action                
-                SetCacheAction(() =>
-                {
-                    //if an exception is thrown we need to remove the entry from cache, this is ONLY a work around because of the way
-                    // that we cache entities: http://issues.umbraco.org/issue/U4-4259
-                    Cache.ClearCacheItem(GetCacheIdKey(entity.Id));
+                // if an exception is thrown we need to remove the entry from cache,
+                // this is ONLY a work around because of the way
+                // that we cache entities: http://issues.umbraco.org/issue/U4-4259
+                Cache.ClearCacheItem(GetEntityCacheKey(entity.Id));
+
+                // if there's a GetAllCacheAllowZeroCount cache, ensure it is cleared
+                Cache.ClearCacheItem(GetEntityTypeCacheKey());
 
-                    //If there's a GetAllCacheAllowZeroCount cache, ensure it is cleared
-                    Cache.ClearCacheItem(GetCacheTypeKey());
-                });
-                
                 throw;
             }
         }
 
-        public override void Remove(TEntity entity, Action<TEntity> persistMethod)
+        /// <inheritdoc />
+        public override void Update(TEntity entity, Action<TEntity> persistUpdated)
         {
             if (entity == null) throw new ArgumentNullException("entity");
-            if (persistMethod == null) throw new ArgumentNullException("persistMethod");
 
             try
             {
-                persistMethod(entity);
-            }
-            finally
-            {
-                //set the disposal action
-                var cacheKey = GetCacheIdKey(entity.Id);
-                SetCacheAction(() =>
+                persistUpdated(entity);
+
+                // just to be safe, we cannot cache an item without an identity
+                if (entity.HasIdentity)
                 {
-                    Cache.ClearCacheItem(cacheKey);
-                    //If there's a GetAllCacheAllowZeroCount cache, ensure it is cleared
-                    Cache.ClearCacheItem(GetCacheTypeKey());
-                });
+                    Cache.InsertCacheItem(GetEntityCacheKey(entity.Id), () => entity, TimeSpan.FromMinutes(5), true);
+                }
+
+                // if there's a GetAllCacheAllowZeroCount cache, ensure it is cleared
+                Cache.ClearCacheItem(GetEntityTypeCacheKey());
+            }
+            catch
+            {
+                // if an exception is thrown we need to remove the entry from cache,
+                // this is ONLY a work around because of the way
+                // that we cache entities: http://issues.umbraco.org/issue/U4-4259
+                Cache.ClearCacheItem(GetEntityCacheKey(entity.Id));
+
+                // if there's a GetAllCacheAllowZeroCount cache, ensure it is cleared
+                Cache.ClearCacheItem(GetEntityTypeCacheKey());
+
+                throw;
             }
         }
 
-        public override TEntity Get(TId id, Func<TId, TEntity> getFromRepo)
+        /// <inheritdoc />
+        public override void Delete(TEntity entity, Action<TEntity> persistDeleted)
         {
-            if (getFromRepo == null) throw new ArgumentNullException("getFromRepo");
+            if (entity == null) throw new ArgumentNullException("entity");
 
-            var cacheKey = GetCacheIdKey(id);
+            try
+            {
+                persistDeleted(entity);
+            }
+            finally
+            {
+                // whatever happens, clear the cache
+                var cacheKey = GetEntityCacheKey(entity.Id);
+                Cache.ClearCacheItem(cacheKey);
+                // if there's a GetAllCacheAllowZeroCount cache, ensure it is cleared
+                Cache.ClearCacheItem(GetEntityTypeCacheKey());
+            }
+        }
+
+        /// <inheritdoc />
+        public override TEntity Get(TId id, Func<TId, TEntity> performGet, Func<TId[], IEnumerable<TEntity>> performGetAll)
+        {
+            var cacheKey = GetEntityCacheKey(id);
             var fromCache = Cache.GetCacheItem<TEntity>(cacheKey);
+
+            // if found in cache then return else fetch and cache
             if (fromCache != null)
                 return fromCache;
-            
-            var entity = getFromRepo(id);
+            var entity = performGet(id);
 
-            //set the disposal action
-            SetCacheAction(cacheKey, entity);
+            if (entity != null && entity.HasIdentity)
+                InsertEntity(cacheKey, entity);
 
             return entity;
         }
 
-        public override TEntity Get(TId id)
+        /// <inheritdoc />
+        public override TEntity GetCached(TId id)
         {
-            var cacheKey = GetCacheIdKey(id);
+            var cacheKey = GetEntityCacheKey(id);
             return Cache.GetCacheItem<TEntity>(cacheKey);
         }
 
-        public override bool Exists(TId id, Func<TId, bool> getFromRepo)
+        /// <inheritdoc />
+        public override bool Exists(TId id, Func<TId, bool> performExists, Func<TId[], IEnumerable<TEntity>> performGetAll)
         {
-            if (getFromRepo == null) throw new ArgumentNullException("getFromRepo");
-
-            var cacheKey = GetCacheIdKey(id);
+            // if found in cache the return else check
+            var cacheKey = GetEntityCacheKey(id);
             var fromCache = Cache.GetCacheItem<TEntity>(cacheKey);
-            return fromCache != null || getFromRepo(id);
+            return fromCache != null || performExists(id);
         }
 
-        public override TEntity[] GetAll(TId[] ids, Func<TId[], IEnumerable<TEntity>> getFromRepo)            
+        /// <inheritdoc />
+        public override TEntity[] GetAll(TId[] ids, Func<TId[], IEnumerable<TEntity>> performGetAll)
         {
-            if (getFromRepo == null) throw new ArgumentNullException("getFromRepo");
-
-            if (ids.Any())
+            if (ids.Length > 0)
             {
-                var entities = ids.Select(Get).ToArray();
-                if (ids.Length.Equals(entities.Length) && entities.Any(x => x == null) == false)
-                    return entities;
+                // try to get each entity from the cache
+                // if we can find all of them, return
+                var entities = ids.Select(GetCached).WhereNotNull().ToArray();
+                if (ids.Length.Equals(entities.Length))
+                    return entities; // no need for null checks, we are not caching nulls
             }
             else
             {
-                var allEntities = GetAllFromCache();
-                if (allEntities.Any())
+                // get everything we have
+                var entities = Cache.GetCacheItemsByKeySearch<TEntity>(GetEntityTypeCacheKey())
+                    .ToArray(); // no need for null checks, we are not caching nulls
+
+                if (entities.Length > 0)
                 {
+                    // if some of them were in the cache...
                     if (_options.GetAllCacheValidateCount)
                     {
-                        //Get count of all entities of current type (TEntity) to ensure cached result is correct
+                        // need to validate the count, get the actual count and return if ok
                         var totalCount = _options.PerformCount();
-                        if (allEntities.Length == totalCount)
-                            return allEntities;
+                        if (entities.Length == totalCount)
+                            return entities;
                     }
                     else
                     {
-                        return allEntities;
+                        // no need to validate, just return what we have and assume it's all there is
+                        return entities;
                     }
                 }
                 else if (_options.GetAllCacheAllowZeroCount)
                 {
-                    //if the repository allows caching a zero count, then check the zero count cache
-                    if (HasZeroCountCache())
-                    {
-                        //there is a zero count cache so return an empty list
-                        return new TEntity[] {};
-                    }
+                    // if none of them were in the cache
+                    // and we allow zero count - check for the special (empty) entry
+                    var empty = Cache.GetCacheItem<TEntity[]>(GetEntityTypeCacheKey());
+                    if (empty != null) return empty;
                 }
             }
 
-            //we need to do the lookup from the repo
-            var entityCollection = getFromRepo(ids)
-                //ensure we don't include any null refs in the returned collection!
-                .WhereNotNull()
+            // cache failed, get from repo and cache
+            var repoEntities = performGetAll(ids)
+                .WhereNotNull() // exclude nulls!
+                .Where(x => x.HasIdentity) // be safe, though would be weird...
                 .ToArray();
 
-            //set the disposal action
-            SetCacheAction(ids, entityCollection);
+            // note: if empty & allow zero count, will cache a special (empty) entry
+            InsertEntities(ids, repoEntities);
 
-            return entityCollection;
+            return repoEntities;
         }
 
-        /// <summary>
-        /// Looks up the zero count cache, must return null if it doesn't exist
-        /// </summary>
-        /// <returns></returns>
-        protected bool HasZeroCountCache()
+        /// <inheritdoc />
+        public override void ClearAll()
         {
-            var zeroCount = Cache.GetCacheItem<TEntity[]>(GetCacheTypeKey());
-            return (zeroCount != null && zeroCount.Any() == false);
+            Cache.ClearAllCache();
         }
-
-        /// <summary>
-        /// Performs the lookup for all entities of this type from the cache
-        /// </summary>
-        /// <returns></returns>
-        protected TEntity[] GetAllFromCache()
-        {
-            var allEntities = Cache.GetCacheItemsByKeySearch<TEntity>(GetCacheTypeKey())
-                    .WhereNotNull()
-                    .ToArray();
-            return allEntities.Any() ? allEntities : new TEntity[] {};
-        }       
-
-        /// <summary>
-        /// Sets the action to execute on disposal for a single entity
-        /// </summary>
-        /// <param name="cacheKey"></param>
-        /// <param name="entity"></param>
-        protected virtual void SetCacheAction(string cacheKey, TEntity entity)
-        {
-            if (entity == null) return;
-
-            SetCacheAction(() =>
-            {
-                //just to be safe, we cannot cache an item without an identity
-                if (entity.HasIdentity)
-                {
-                    Cache.InsertCacheItem(cacheKey, () => entity,
-                        timeout: TimeSpan.FromMinutes(5),
-                        isSliding: true);
-                }
-            });
-        }
-
-        /// <summary>
-        /// Sets the action to execute on disposal for an entity collection
-        /// </summary>
-        /// <param name="ids"></param>
-        /// <param name="entityCollection"></param>
-        protected virtual void SetCacheAction(TId[] ids, TEntity[] entityCollection)
-        {
-            SetCacheAction(() =>
-            {
-                //This option cannot execute if we are looking up specific Ids
-                if (ids.Any() == false && entityCollection.Length == 0 && _options.GetAllCacheAllowZeroCount)
-                {
-                    //there was nothing returned but we want to cache a zero count result so add an TEntity[] to the cache
-                    // to signify that there is a zero count cache
-                    //NOTE: Don't set expiry/sliding for a zero count
-                    Cache.InsertCacheItem(GetCacheTypeKey(), () => new TEntity[] {});
-                }
-                else
-                {
-                    //This is the default behavior, we'll individually cache each item so that if/when these items are resolved 
-                    // by id, they are returned from the already existing cache.
-                    foreach (var entity in entityCollection.WhereNotNull())
-                    {
-                        var localCopy = entity;
-                        //just to be safe, we cannot cache an item without an identity
-                        if (localCopy.HasIdentity)
-                        {
-                            Cache.InsertCacheItem(GetCacheIdKey(entity.Id), () => localCopy,
-                                timeout: TimeSpan.FromMinutes(5),
-                                isSliding: true);
-                        }
-                    }
-                }
-            });
-        }
-        
     }
 }

src/Umbraco.Core/Cache/DefaultRepositoryCachePolicyFactory.cs

@@ -1,27 +0,0 @@
-using Umbraco.Core.Models.EntityBase;
-
-namespace Umbraco.Core.Cache
-{
-    /// <summary>
-    /// Creates cache policies
-    /// </summary>
-    /// <typeparam name="TEntity"></typeparam>
-    /// <typeparam name="TId"></typeparam>
-    internal class DefaultRepositoryCachePolicyFactory<TEntity, TId> : IRepositoryCachePolicyFactory<TEntity, TId>
-        where TEntity : class, IAggregateRoot
-    {
-        private readonly IRuntimeCacheProvider _runtimeCache;
-        private readonly RepositoryCachePolicyOptions _options;
-
-        public DefaultRepositoryCachePolicyFactory(IRuntimeCacheProvider runtimeCache, RepositoryCachePolicyOptions options)
-        {
-            _runtimeCache = runtimeCache;
-            _options = options;
-        }
-
-        public virtual IRepositoryCachePolicy<TEntity, TId> CreatePolicy()
-        {
-            return new DefaultRepositoryCachePolicy<TEntity, TId>(_runtimeCache, _options);
-        }
-    }
-}

src/Umbraco.Core/Cache/FullDataSetRepositoryCachePolicy.cs

@@ -3,227 +3,178 @@ using System.Collections.Generic;
 using System.Linq;
 using Umbraco.Core.Collections;
 using Umbraco.Core.Models.EntityBase;
+using Umbraco.Core.Scoping;
 
 namespace Umbraco.Core.Cache
 {
     /// <summary>
-    /// A caching policy that caches an entire dataset as a single collection
+    /// Represents a caching policy that caches the entire entities set as a single collection.
     /// </summary>
-    /// <typeparam name="TEntity"></typeparam>
-    /// <typeparam name="TId"></typeparam>
+    /// <typeparam name="TEntity">The type of the entity.</typeparam>
+    /// <typeparam name="TId">The type of the identifier.</typeparam>
+    /// <remarks>
+    /// <para>Caches the entire set of entities as a single collection.</para>
+    /// <para>Used by Content-, Media- and MemberTypeRepository, DataTypeRepository, DomainRepository,
+    /// LanguageRepository, PublicAccessRepository, TemplateRepository... things that make sense to
+    /// keep as a whole in memory.</para>
+    /// </remarks>
     internal class FullDataSetRepositoryCachePolicy<TEntity, TId> : RepositoryCachePolicyBase<TEntity, TId>
         where TEntity : class, IAggregateRoot
     {
-        private readonly Func<TEntity, TId> _getEntityId;
-        private readonly Func<IEnumerable<TEntity>> _getAllFromRepo;
+        private readonly Func<TEntity, TId> _entityGetId;
         private readonly bool _expires;
 
-        public FullDataSetRepositoryCachePolicy(IRuntimeCacheProvider cache, Func<TEntity, TId> getEntityId, Func<IEnumerable<TEntity>> getAllFromRepo, bool expires)
+        public FullDataSetRepositoryCachePolicy(IRuntimeCacheProvider cache, Func<TEntity, TId> entityGetId, bool expires)
             : base(cache)
         {
-            _getEntityId = getEntityId;
-            _getAllFromRepo = getAllFromRepo;
+            _entityGetId = entityGetId;
             _expires = expires;
         }
 
-        private bool? _hasZeroCountCache;
+        public override IRepositoryCachePolicy<TEntity, TId> Scoped(IRuntimeCacheProvider runtimeCache, IScope scope)
+        {
+            return new ScopedRepositoryCachePolicy<TEntity, TId>(this, runtimeCache, scope);
+        }
 
+        protected static readonly TId[] EmptyIds = new TId[0]; // const
 
-        protected string GetCacheTypeKey()
+        protected string GetEntityTypeCacheKey()
         {
             return string.Format("uRepo_{0}_", typeof(TEntity).Name);
         }
 
-        public override void CreateOrUpdate(TEntity entity, Action<TEntity> persistMethod)
+        protected void InsertEntities(TEntity[] entities)
         {
-            if (entity == null) throw new ArgumentNullException("entity");
-            if (persistMethod == null) throw new ArgumentNullException("persistMethod");
+            // cache is expected to be a deep-cloning cache ie it deep-clones whatever is
+            // IDeepCloneable when it goes in, and out. it also resets dirty properties,
+            // making sure that no 'dirty' entity is cached.
+            //
+            // this policy is caching the entire list of entities. to ensure that entities
+            // are properly deep-clones when cached, it uses a DeepCloneableList. however,
+            // we don't want to deep-clone *each* entity in the list when fetching it from
+            // cache as that would not be efficient for Get(id). so the DeepCloneableList is
+            // set to ListCloneBehavior.CloneOnce ie it will clone *once* when inserting,
+            // and then will *not* clone when retrieving.
 
-            try
+            if (_expires)
             {
-                persistMethod(entity);
-
-                //set the disposal action                
-                SetCacheAction(() =>
-                {
-                    //Clear all
-                    Cache.ClearCacheItem(GetCacheTypeKey());
-                });
+                Cache.InsertCacheItem(GetEntityTypeCacheKey(), () => new DeepCloneableList<TEntity>(entities), TimeSpan.FromMinutes(5), true);
             }
-            catch
+            else
             {
-                //set the disposal action                
-                SetCacheAction(() =>
-                {
-                    //Clear all
-                    Cache.ClearCacheItem(GetCacheTypeKey());
-                });
-                throw;
+                Cache.InsertCacheItem(GetEntityTypeCacheKey(), () => new DeepCloneableList<TEntity>(entities));
             }
         }
 
-        public override void Remove(TEntity entity, Action<TEntity> persistMethod)
+        /// <inheritdoc />
+        public override void Create(TEntity entity, Action<TEntity> persistNew)
         {
             if (entity == null) throw new ArgumentNullException("entity");
-            if (persistMethod == null) throw new ArgumentNullException("persistMethod");
 
             try
             {
-                persistMethod(entity);
+                persistNew(entity);
             }
             finally
             {
-                //set the disposal action
-                SetCacheAction(() =>
-                {
-                    //Clear all
-                    Cache.ClearCacheItem(GetCacheTypeKey());
-                });
+                ClearAll();
             }
         }
 
-        public override TEntity Get(TId id, Func<TId, TEntity> getFromRepo)
+        /// <inheritdoc />
+        public override void Update(TEntity entity, Action<TEntity> persistUpdated)
         {
-            //Force get all with cache
-            var found = GetAll(new TId[] { }, ids => _getAllFromRepo().WhereNotNull());
+            if (entity == null) throw new ArgumentNullException("entity");
 
-            //we don't have anything in cache (this should never happen), just return from the repo
-            if (found == null) return getFromRepo(id);
-            var entity = found.FirstOrDefault(x => _getEntityId(x).Equals(id));
-            if (entity == null) return null;
-
-            //We must ensure to deep clone each one out manually since the deep clone list only clones one way
-            return (TEntity)entity.DeepClone();
-        }
-
-        public override TEntity Get(TId id)
-        {
-            //Force get all with cache
-            var found = GetAll(new TId[] { }, ids => _getAllFromRepo().WhereNotNull());
-
-            //we don't have anything in cache (this should never happen), just return null
-            if (found == null) return null;
-            var entity = found.FirstOrDefault(x => _getEntityId(x).Equals(id));
-            if (entity == null) return null;
-
-            //We must ensure to deep clone each one out manually since the deep clone list only clones one way
-            return (TEntity)entity.DeepClone();
-        }
-
-        public override bool Exists(TId id, Func<TId, bool> getFromRepo)
-        {
-            //Force get all with cache
-            var found = GetAll(new TId[] { }, ids => _getAllFromRepo().WhereNotNull());
-
-            //we don't have anything in cache (this should never happen), just return from the repo
-            return found == null
-                ? getFromRepo(id)
-                : found.Any(x => _getEntityId(x).Equals(id));
-        }
-
-        public override TEntity[] GetAll(TId[] ids, Func<TId[], IEnumerable<TEntity>> getFromRepo)
-        {
-            //process getting all including setting the cache callback
-            var result = PerformGetAll(getFromRepo);
-
-            //now that the base result has been calculated, they will all be cached. 
-            // Now we can just filter by ids if they have been supplied
-
-            return (ids.Any()
-                ? result.Where(x => ids.Contains(_getEntityId(x))).ToArray()
-                : result)
-                //We must ensure to deep clone each one out manually since the deep clone list only clones one way
-                .Select(x => (TEntity)x.DeepClone())
-                .ToArray();
-        }
-
-        private TEntity[] PerformGetAll(Func<TId[], IEnumerable<TEntity>> getFromRepo)
-        {
-            var allEntities = GetAllFromCache();
-            if (allEntities.Any())
+            try
             {
-                return allEntities;
+                persistUpdated(entity);
             }
-
-            //check the zero count cache
-            if (HasZeroCountCache())
+            finally
             {
-                //there is a zero count cache so return an empty list
-                return new TEntity[] { };
+                ClearAll();
             }
-
-            //we need to do the lookup from the repo
-            var entityCollection = getFromRepo(new TId[] { })
-                //ensure we don't include any null refs in the returned collection!
-                .WhereNotNull()
-                .ToArray();
-
-            //set the disposal action
-            SetCacheAction(entityCollection);
-
-            return entityCollection;
         }
 
-        /// <summary>
-        /// For this type of caching policy, we don't cache individual items
-        /// </summary>
-        /// <param name="cacheKey"></param>
-        /// <param name="entity"></param>
-        protected void SetCacheAction(string cacheKey, TEntity entity)
+        /// <inheritdoc />
+        public override void Delete(TEntity entity, Action<TEntity> persistDeleted)
         {
-            //No-op
-        }
+            if (entity == null) throw new ArgumentNullException("entity");
 
-        /// <summary>
-        /// Sets the action to execute on disposal for an entity collection
-        /// </summary>
-        /// <param name="entityCollection"></param>
-        protected void SetCacheAction(TEntity[] entityCollection)
-        {
-            //set the disposal action
-            SetCacheAction(() =>
+            try
             {
-                //We want to cache the result as a single collection
-
-                if (_expires)
-                {
-                    Cache.InsertCacheItem(GetCacheTypeKey(), () => new DeepCloneableList<TEntity>(entityCollection),
-                        timeout: TimeSpan.FromMinutes(5),
-                        isSliding: true);
-                }
-                else
-                {
-                    Cache.InsertCacheItem(GetCacheTypeKey(), () => new DeepCloneableList<TEntity>(entityCollection));
-                }
-            });
+                persistDeleted(entity);
+            }
+            finally
+            {
+                ClearAll();
+            }
         }
 
-        /// <summary>
-        /// Looks up the zero count cache, must return null if it doesn't exist
-        /// </summary>
-        /// <returns></returns>
-        protected bool HasZeroCountCache()
+        /// <inheritdoc />
+        public override TEntity Get(TId id, Func<TId, TEntity> performGet, Func<TId[], IEnumerable<TEntity>> performGetAll)
         {
-            if (_hasZeroCountCache.HasValue)
-                return _hasZeroCountCache.Value;
+            // get all from the cache, then look for the entity
+            var all = GetAllCached(performGetAll);
+            var entity = all.FirstOrDefault(x => _entityGetId(x).Equals(id));
 
-            _hasZeroCountCache = Cache.GetCacheItem<DeepCloneableList<TEntity>>(GetCacheTypeKey()) != null;
-            return _hasZeroCountCache.Value;
+            // see note in InsertEntities - what we get here is the original
+            // cached entity, not a clone, so we need to manually ensure it is deep-cloned.
+            return entity == null ? null : (TEntity) entity.DeepClone();
         }
 
-        /// <summary>
-        /// This policy will cache the full data set as a single collection
-        /// </summary>
-        /// <returns></returns>
-        protected TEntity[] GetAllFromCache()
+        /// <inheritdoc />
+        public override TEntity GetCached(TId id)
         {
-            var found = Cache.GetCacheItem<DeepCloneableList<TEntity>>(GetCacheTypeKey());
+            // get all from the cache -- and only the cache, then look for the entity
+            var all = Cache.GetCacheItem<DeepCloneableList<TEntity>>(GetEntityTypeCacheKey());
+            var entity = all == null ? null : all.FirstOrDefault(x => _entityGetId(x).Equals(id));
 
-            //This method will get called before checking for zero count cache, so we'll just set the flag here
-            _hasZeroCountCache = found != null;
-
-            return found == null ? new TEntity[] { } : found.WhereNotNull().ToArray();
+            // see note in InsertEntities - what we get here is the original
+            // cached entity, not a clone, so we need to manually ensure it is deep-cloned.
+            return entity == null ? null : (TEntity)entity.DeepClone();
         }
 
+        /// <inheritdoc />
+        public override bool Exists(TId id, Func<TId, bool> performExits, Func<TId[], IEnumerable<TEntity>> performGetAll)
+        {
+            // get all as one set, then look for the entity
+            var all = GetAllCached(performGetAll);
+            return all.Any(x => _entityGetId(x).Equals(id));
+        }
+
+        /// <inheritdoc />
+        public override TEntity[] GetAll(TId[] ids, Func<TId[], IEnumerable<TEntity>> performGetAll)
+        {
+            // get all as one set, from cache if possible, else repo
+            var all = GetAllCached(performGetAll);
+
+            // if ids have been specified, filter
+            if (ids.Length > 0) all = all.Where(x => ids.Contains(_entityGetId(x)));
+
+            // and return
+            // see note in SetCacheActionToInsertEntities - what we get here is the original
+            // cached entities, not clones, so we need to manually ensure they are deep-cloned.
+            return all.Select(x => (TEntity) x.DeepClone()).ToArray();
+        }
+
+        // does NOT clone anything, so be nice with the returned values
+        private IEnumerable<TEntity> GetAllCached(Func<TId[], IEnumerable<TEntity>> performGetAll)
+        {
+            // try the cache first
+            var all = Cache.GetCacheItem<DeepCloneableList<TEntity>>(GetEntityTypeCacheKey());
+            if (all != null) return all.ToArray();
+
+            // else get from repo and cache
+            var entities = performGetAll(EmptyIds).WhereNotNull().ToArray();
+            InsertEntities(entities); // may be an empty array...
+            return entities;
+        }
+
+        /// <inheritdoc />
+        public override void ClearAll()
+        {
+            Cache.ClearCacheItem(GetEntityTypeCacheKey());
+        }
     }
 }

src/Umbraco.Core/Cache/FullDataSetRepositoryCachePolicyFactory.cs

@@ -1,33 +0,0 @@
-using System;
-using System.Collections.Generic;
-using Umbraco.Core.Models.EntityBase;
-
-namespace Umbraco.Core.Cache
-{
-    /// <summary>
-    /// Creates cache policies
-    /// </summary>
-    /// <typeparam name="TEntity"></typeparam>
-    /// <typeparam name="TId"></typeparam>
-    internal class FullDataSetRepositoryCachePolicyFactory<TEntity, TId> : IRepositoryCachePolicyFactory<TEntity, TId>
-        where TEntity : class, IAggregateRoot
-    {
-        private readonly IRuntimeCacheProvider _runtimeCache;
-        private readonly Func<TEntity, TId> _getEntityId;
-        private readonly Func<IEnumerable<TEntity>> _getAllFromRepo;
-        private readonly bool _expires;
-
-        public FullDataSetRepositoryCachePolicyFactory(IRuntimeCacheProvider runtimeCache, Func<TEntity, TId> getEntityId, Func<IEnumerable<TEntity>> getAllFromRepo, bool expires)
-        {
-            _runtimeCache = runtimeCache;
-            _getEntityId = getEntityId;
-            _getAllFromRepo = getAllFromRepo;
-            _expires = expires;
-        }
-
-        public virtual IRepositoryCachePolicy<TEntity, TId> CreatePolicy()
-        {
-            return new FullDataSetRepositoryCachePolicy<TEntity, TId>(_runtimeCache, _getEntityId, _getAllFromRepo, _expires);
-        }
-    }
-}

src/Umbraco.Core/Cache/HttpRuntimeCacheProvider.cs

@@ -154,7 +154,7 @@ namespace Umbraco.Core.Cache
 
             value = result.Value; // will not throw (safe lazy)
             var eh = value as ExceptionHolder;
-            if (eh != null) throw eh.Exception; // throw once!
+            if (eh != null) throw new Exception("Exception while creating a value.", eh.Exception); // throw once!
             return value;
         }
 

src/Umbraco.Core/Cache/IRepositoryCachePolicy.cs

@@ -1,18 +1,97 @@
 using System;
 using System.Collections.Generic;
 using Umbraco.Core.Models.EntityBase;
+using Umbraco.Core.Scoping;
 
 namespace Umbraco.Core.Cache
 {
-    internal interface IRepositoryCachePolicy<TEntity, TId> : IDisposable
+    internal interface IRepositoryCachePolicy<TEntity, TId>
         where TEntity : class, IAggregateRoot
     {
-        TEntity Get(TId id, Func<TId, TEntity> getFromRepo);
-        TEntity Get(TId id);
-        bool Exists(TId id, Func<TId, bool> getFromRepo);
-        
-        void CreateOrUpdate(TEntity entity, Action<TEntity> persistMethod);
-        void Remove(TEntity entity, Action<TEntity> persistMethod);
-        TEntity[] GetAll(TId[] ids, Func<TId[], IEnumerable<TEntity>> getFromRepo);
+        // note:
+        // at the moment each repository instance creates its corresponding cache policy instance
+        // we could reduce allocations by using static cache policy instances but then we would need
+        // to modify all methods here to pass the repository and cache eg:
+        //
+        // TEntity Get(TRepository repository, IRuntimeCacheProvider cache, TId id);
+        //
+        // it is not *that* complicated but then RepositoryBase needs to have a TRepository generic
+        // type parameter and it all becomes convoluted - keeping it simple for the time being.
+
+        /// <summary>
+        /// Creates a scoped version of this cache policy.
+        /// </summary>
+        /// <param name="runtimeCache">The global isolated runtime cache for this policy.</param>
+        /// <param name="scope">The scope.</param>
+        /// <remarks>When a policy is scoped, it means that it has been created with a scoped
+        /// isolated runtime cache, and now it needs to be wrapped into something that can apply
+        /// changes to the global isolated runtime cache.</remarks>
+        IRepositoryCachePolicy<TEntity, TId> Scoped(IRuntimeCacheProvider runtimeCache, IScope scope);
+
+        /// <summary>
+        /// Gets an entity from the cache, else from the repository.
+        /// </summary>
+        /// <param name="id">The identifier.</param>
+        /// <param name="performGet">The repository PerformGet method.</param>
+        /// <param name="performGetAll">The repository PerformGetAll method.</param>
+        /// <returns>The entity with the specified identifier, if it exits, else null.</returns>
+        /// <remarks>First considers the cache then the repository.</remarks>
+        TEntity Get(TId id, Func<TId, TEntity> performGet, Func<TId[], IEnumerable<TEntity>> performGetAll);
+
+        /// <summary>
+        /// Gets an entity from the cache.
+        /// </summary>
+        /// <param name="id">The identifier.</param>
+        /// <returns>The entity with the specified identifier, if it is in the cache already, else null.</returns>
+        /// <remarks>Does not consider the repository at all.</remarks>
+        TEntity GetCached(TId id);
+
+        /// <summary>
+        /// Gets a value indicating whether an entity with a specified identifier exists.
+        /// </summary>
+        /// <param name="id">The identifier.</param>
+        /// <param name="performExists">The repository PerformExists method.</param>
+        /// <param name="performGetAll">The repository PerformGetAll method.</param>
+        /// <returns>A value indicating whether an entity with the specified identifier exists.</returns>
+        /// <remarks>First considers the cache then the repository.</remarks>
+        bool Exists(TId id, Func<TId, bool> performExists, Func<TId[], IEnumerable<TEntity>> performGetAll);
+
+        /// <summary>
+        /// Creates an entity.
+        /// </summary>
+        /// <param name="entity">The entity.</param>
+        /// <param name="persistNew">The repository PersistNewItem method.</param>
+        /// <remarks>Creates the entity in the repository, and updates the cache accordingly.</remarks>
+        void Create(TEntity entity, Action<TEntity> persistNew);
+
+        /// <summary>
+        /// Updates an entity.
+        /// </summary>
+        /// <param name="entity">The entity.</param>
+        /// <param name="persistUpdated">The reopsitory PersistUpdatedItem method.</param>
+        /// <remarks>Updates the entity in the repository, and updates the cache accordingly.</remarks>
+        void Update(TEntity entity, Action<TEntity> persistUpdated);
+
+        /// <summary>
+        /// Removes an entity.
+        /// </summary>
+        /// <param name="entity">The entity.</param>
+        /// <param name="persistDeleted">The repository PersistDeletedItem method.</param>
+        /// <remarks>Removes the entity from the repository and clears the cache.</remarks>
+        void Delete(TEntity entity, Action<TEntity> persistDeleted);
+
+        /// <summary>
+        /// Gets entities.
+        /// </summary>
+        /// <param name="ids">The identifiers.</param>
+        /// <param name="performGetAll">The repository PerformGetAll method.</param>
+        /// <returns>If <paramref name="ids"/> is empty, all entities, else the entities with the specified identifiers.</returns>
+        /// <remarks>Get all the entities. Either from the cache or the repository depending on the implementation.</remarks>
+        TEntity[] GetAll(TId[] ids, Func<TId[], IEnumerable<TEntity>> performGetAll);
+
+        /// <summary>
+        /// Clears the entire cache.
+        /// </summary>
+        void ClearAll();
     }
 }

src/Umbraco.Core/Cache/IRepositoryCachePolicyFactory.cs

@@ -1,9 +0,0 @@
-using Umbraco.Core.Models.EntityBase;
-
-namespace Umbraco.Core.Cache
-{
-    internal interface IRepositoryCachePolicyFactory<TEntity, TId> where TEntity : class, IAggregateRoot
-    {
-        IRepositoryCachePolicy<TEntity, TId> CreatePolicy();
-    }
-}

src/Umbraco.Core/Cache/NoRepositoryCachePolicy.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Umbraco.Core.Models.EntityBase;
+using Umbraco.Core.Scoping;
+
+namespace Umbraco.Core.Cache
+{
+    internal class NoRepositoryCachePolicy<TEntity, TId> : IRepositoryCachePolicy<TEntity, TId> 
+        where TEntity : class, IAggregateRoot
+    {
+        private static readonly NoRepositoryCachePolicy<TEntity, TId> StaticInstance = new NoRepositoryCachePolicy<TEntity, TId>();
+
+        private NoRepositoryCachePolicy()
+        { }
+
+        public static NoRepositoryCachePolicy<TEntity, TId> Instance { get { return StaticInstance; } }
+
+        public IRepositoryCachePolicy<TEntity, TId> Scoped(IRuntimeCacheProvider runtimeCache, IScope scope)
+        {
+            throw new NotImplementedException();
+        }
+
+        public TEntity Get(TId id, Func<TId, TEntity> performGet, Func<TId[], IEnumerable<TEntity>> performGetAll)
+        {
+            return performGet(id);
+        }
+
+        public TEntity GetCached(TId id)
+        {
+            return null;
+        }
+
+        public bool Exists(TId id, Func<TId, bool> performExists, Func<TId[], IEnumerable<TEntity>> performGetAll)
+        {
+            return performExists(id);
+        }
+
+        public void Create(TEntity entity, Action<TEntity> persistNew)
+        {
+            persistNew(entity);
+        }
+
+        public void Update(TEntity entity, Action<TEntity> persistUpdated)
+        {
+            persistUpdated(entity);
+        }
+
+        public void Delete(TEntity entity, Action<TEntity> persistDeleted)
+        {
+            persistDeleted(entity);
+        }
+
+        public TEntity[] GetAll(TId[] ids, Func<TId[], IEnumerable<TEntity>> performGetAll)
+        {
+            return performGetAll(ids).ToArray();
+        }
+
+        public void ClearAll()
+        { }
+    }
+}

src/Umbraco.Core/Cache/OnlySingleItemsRepositoryCachePolicyFactory.cs

@@ -1,27 +0,0 @@
-using Umbraco.Core.Models.EntityBase;
-
-namespace Umbraco.Core.Cache
-{
-    /// <summary>
-    /// Creates cache policies
-    /// </summary>
-    /// <typeparam name="TEntity"></typeparam>
-    /// <typeparam name="TId"></typeparam>
-    internal class OnlySingleItemsRepositoryCachePolicyFactory<TEntity, TId> : IRepositoryCachePolicyFactory<TEntity, TId>
-        where TEntity : class, IAggregateRoot
-    {
-        private readonly IRuntimeCacheProvider _runtimeCache;
-        private readonly RepositoryCachePolicyOptions _options;
-
-        public OnlySingleItemsRepositoryCachePolicyFactory(IRuntimeCacheProvider runtimeCache, RepositoryCachePolicyOptions options)
-        {
-            _runtimeCache = runtimeCache;
-            _options = options;
-        }
-
-        public virtual IRepositoryCachePolicy<TEntity, TId> CreatePolicy()
-        {
-            return new SingleItemsOnlyRepositoryCachePolicy<TEntity, TId>(_runtimeCache, _options);
-        }
-    }
-}

src/Umbraco.Core/Cache/RepositoryCachePolicyBase.cs

@@ -1,48 +1,51 @@
 using System;
 using System.Collections.Generic;
 using Umbraco.Core.Models.EntityBase;
+using Umbraco.Core.Scoping;
 
 namespace Umbraco.Core.Cache
 {
-    internal abstract class RepositoryCachePolicyBase<TEntity, TId> : DisposableObject, IRepositoryCachePolicy<TEntity, TId>
+    /// <summary>
+    /// A base class for repository cache policies.
+    /// </summary>
+    /// <typeparam name="TEntity">The type of the entity.</typeparam>
+    /// <typeparam name="TId">The type of the identifier.</typeparam>
+    internal abstract class RepositoryCachePolicyBase<TEntity, TId> : IRepositoryCachePolicy<TEntity, TId>
         where TEntity : class, IAggregateRoot
     {
-        private Action _action;
-
         protected RepositoryCachePolicyBase(IRuntimeCacheProvider cache)
         {
-            if (cache == null) throw new ArgumentNullException("cache");
-            
+            if (cache == null) throw new ArgumentNullException("cache");            
             Cache = cache;
         }
 
+        public abstract IRepositoryCachePolicy<TEntity, TId> Scoped(IRuntimeCacheProvider runtimeCache, IScope scope);
+
         protected IRuntimeCacheProvider Cache { get; private set; }
 
-        /// <summary>
-        /// The disposal performs the caching
-        /// </summary>
-        protected override void DisposeResources()
-        {
-            if (_action != null)
-            {
-                _action();
-            }
-        }
+        /// <inheritdoc />
+        public abstract TEntity Get(TId id, Func<TId, TEntity> performGet, Func<TId[], IEnumerable<TEntity>> performGetAll);
 
-        /// <summary>
-        /// Sets the action to execute on disposal
-        /// </summary>
-        /// <param name="action"></param>
-        protected void SetCacheAction(Action action)
-        {
-            _action = action;
-        }
+        /// <inheritdoc />
+        public abstract TEntity GetCached(TId id);
+
+        /// <inheritdoc />
+        public abstract bool Exists(TId id, Func<TId, bool> performExists, Func<TId[], IEnumerable<TEntity>> performGetAll);
+
+        /// <inheritdoc />
+        public abstract void Create(TEntity entity, Action<TEntity> persistNew);
+
+        /// <inheritdoc />
+        public abstract void Update(TEntity entity, Action<TEntity> persistUpdated);
+
+        /// <inheritdoc />
+        public abstract void Delete(TEntity entity, Action<TEntity> persistDeleted);
+
+        /// <inheritdoc />
+        public abstract TEntity[] GetAll(TId[] ids, Func<TId[], IEnumerable<TEntity>> performGetAll);
+
+        /// <inheritdoc />
+        public abstract void ClearAll();
 
-        public abstract TEntity Get(TId id, Func<TId, TEntity> getFromRepo);
-        public abstract TEntity Get(TId id);
-        public abstract bool Exists(TId id, Func<TId, bool> getFromRepo);
-        public abstract void CreateOrUpdate(TEntity entity, Action<TEntity> persistMethod);
-        public abstract void Remove(TEntity entity, Action<TEntity> persistMethod);
-        public abstract TEntity[] GetAll(TId[] ids, Func<TId[], IEnumerable<TEntity>> getFromRepo);
     }
 }

src/Umbraco.Core/Cache/RepositoryCachePolicyOptions.cs

@@ -2,6 +2,9 @@ using System;
 
 namespace Umbraco.Core.Cache
 {
+    /// <summary>
+    /// Specifies how a repository cache policy should cache entities.
+    /// </summary>
     internal class RepositoryCachePolicyOptions
     {
         /// <summary>

src/Umbraco.Core/Cache/ScopedRepositoryCachePolicy.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using Umbraco.Core.Models.EntityBase;
+using Umbraco.Core.Scoping;
+
+namespace Umbraco.Core.Cache
+{
+    internal class ScopedRepositoryCachePolicy<TEntity, TId> : IRepositoryCachePolicy<TEntity, TId>
+        where TEntity : class, IAggregateRoot
+    {
+        private readonly IRepositoryCachePolicy<TEntity, TId> _cachePolicy;
+        private readonly IRuntimeCacheProvider _globalIsolatedCache;
+        private readonly IScope _scope;
+
+        public ScopedRepositoryCachePolicy(IRepositoryCachePolicy<TEntity, TId> cachePolicy, IRuntimeCacheProvider globalIsolatedCache, IScope scope)
+        {
+            _cachePolicy = cachePolicy;
+            _globalIsolatedCache = globalIsolatedCache;
+            _scope = scope;
+        }
+
+        public IRepositoryCachePolicy<TEntity, TId> Scoped(IRuntimeCacheProvider runtimeCache, IScope scope)
+        {
+            throw new InvalidOperationException(); // obviously
+        }
+
+        public TEntity Get(TId id, Func<TId, TEntity> performGet, Func<TId[], IEnumerable<TEntity>> performGetAll)
+        {
+            // loads into the local cache only, ok for now
+            return _cachePolicy.Get(id, performGet, performGetAll);
+        }
+
+        public TEntity GetCached(TId id)
+        {
+            // loads into the local cache only, ok for now
+            return _cachePolicy.GetCached(id);
+        }
+
+        public bool Exists(TId id, Func<TId, bool> performExists, Func<TId[], IEnumerable<TEntity>> performGetAll)
+        {
+            // loads into the local cache only, ok for now
+            return _cachePolicy.Exists(id, performExists, performGetAll);
+        }
+
+        public void Create(TEntity entity, Action<TEntity> persistNew)
+        {
+            // writes into the local cache
+            _cachePolicy.Create(entity, persistNew);
+        }
+
+        public void Update(TEntity entity, Action<TEntity> persistUpdated)
+        {
+            // writes into the local cache
+            _cachePolicy.Update(entity, persistUpdated);
+        }
+
+        public void Delete(TEntity entity, Action<TEntity> persistDeleted)
+        {
+            // deletes the local cache
+            _cachePolicy.Delete(entity, persistDeleted);
+        }
+
+        public TEntity[] GetAll(TId[] ids, Func<TId[], IEnumerable<TEntity>> performGetAll)
+        {
+            // loads into the local cache only, ok for now
+            return _cachePolicy.GetAll(ids, performGetAll);
+        }
+
+        public void ClearAll()
+        {
+            // clears the local cache
+            _cachePolicy.ClearAll();
+        }
+    }
+}

src/Umbraco.Core/Cache/SingleItemsOnlyRepositoryCachePolicy.cs

@@ -1,24 +1,27 @@
-using System.Linq;
-using Umbraco.Core.Collections;
 using Umbraco.Core.Models.EntityBase;
 
 namespace Umbraco.Core.Cache
 {
     /// <summary>
-    /// A caching policy that ignores all caches for GetAll - it will only cache calls for individual items
+    /// Represents a special policy that does not cache the result of GetAll.
     /// </summary>
-    /// <typeparam name="TEntity"></typeparam>
-    /// <typeparam name="TId"></typeparam>
+    /// <typeparam name="TEntity">The type of the entity.</typeparam>
+    /// <typeparam name="TId">The type of the identifier.</typeparam>
+    /// <remarks>
+    /// <para>Overrides the default repository cache policy and does not writes the result of GetAll
+    /// to cache, but only the result of individual Gets. It does read the cache for GetAll, though.</para>
+    /// <para>Used by DictionaryRepository.</para>
+    /// </remarks>
     internal class SingleItemsOnlyRepositoryCachePolicy<TEntity, TId> : DefaultRepositoryCachePolicy<TEntity, TId>
         where TEntity : class, IAggregateRoot
     {
-        public SingleItemsOnlyRepositoryCachePolicy(IRuntimeCacheProvider cache, RepositoryCachePolicyOptions options) : base(cache, options)
+        public SingleItemsOnlyRepositoryCachePolicy(IRuntimeCacheProvider cache, RepositoryCachePolicyOptions options)
+            : base(cache, options)
+        { }
+
+        protected override void InsertEntities(TId[] ids, TEntity[] entities)
         {
-        }
-        
-        protected override void SetCacheAction(TId[] ids, TEntity[] entityCollection)
-        {            
-            //no-op
+            // nop
         }
     }
 }

src/Umbraco.Core/CacheHelper.cs

@@ -21,6 +21,10 @@ namespace Umbraco.Core
         private static readonly ICacheProvider NullRequestCache = new NullCacheProvider();
         private static readonly ICacheProvider NullStaticCache = new NullCacheProvider();
         private static readonly IRuntimeCacheProvider NullRuntimeCache = new NullCacheProvider();
+        private static readonly IsolatedRuntimeCache NullIsolatedCache = new IsolatedRuntimeCache(_ => NullRuntimeCache);
+        private static readonly CacheHelper NullCache = new CacheHelper(NullRuntimeCache, NullStaticCache, NullRequestCache, NullIsolatedCache);
+
+        public static CacheHelper NoCache { get { return NullCache; } }
         
         /// <summary>
         /// Creates a cache helper with disabled caches
@@ -31,7 +35,10 @@ namespace Umbraco.Core
         /// </remarks>
         public static CacheHelper CreateDisabledCacheHelper()
         {
-            return new CacheHelper(NullRuntimeCache, NullStaticCache, NullRequestCache, new IsolatedRuntimeCache(t => NullRuntimeCache));
+            // do *not* return NoCache
+            // NoCache is a special instance that is detected by RepositoryBase and disables all cache policies
+            // CreateDisabledCacheHelper is used in tests to use no cache, *but* keep all cache policies
+            return new CacheHelper(NullRuntimeCache, NullStaticCache, NullRequestCache, NullIsolatedCache);
         }
 
 	    /// <summary>

src/Umbraco.Core/CodeAnnotations/UmbracoUdiTypeAttribute.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace Umbraco.Core.CodeAnnotations
+{
+    [AttributeUsage(AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
+    internal class UmbracoUdiTypeAttribute : Attribute
+    {
+        public string UdiType { get; private set; }
+
+        public UmbracoUdiTypeAttribute(string udiType)
+        {
+            UdiType = udiType;
+        }
+    }
+}

src/Umbraco.Core/Configuration/CoreDebug.cs

@@ -0,0 +1,31 @@
+using System;
+
+namespace Umbraco.Core.Configuration
+{
+    internal static class CoreDebugExtensions
+    {
+        private static CoreDebug _coreDebug;
+
+        public static CoreDebug CoreDebug(this UmbracoConfig config)
+        {
+            return _coreDebug ?? (_coreDebug = new CoreDebug());
+        }
+    }
+
+    internal class CoreDebug
+    {
+        public CoreDebug()
+        {
+            var appSettings = System.Configuration.ConfigurationManager.AppSettings;
+            LogUncompletedScopes = string.Equals("true", appSettings["Umbraco.CoreDebug.LogUncompletedScopes"], StringComparison.OrdinalIgnoreCase);
+            DumpOnTimeoutThreadAbort = string.Equals("true", appSettings["Umbraco.CoreDebug.DumpOnTimeoutThreadAbort"], StringComparison.OrdinalIgnoreCase);
+        }
+
+        // when true, Scope logs the stack trace for any scope that gets disposed without being completed.
+        // this helps troubleshooting rogue scopes that we forget to complete
+        public bool LogUncompletedScopes { get; private set; }
+        // when true, the Logger creates a minidump of w3wp in ~/App_Data/MiniDump whenever it logs
+        // an error due to a ThreadAbortException that is due to a timeout.
+        public bool DumpOnTimeoutThreadAbort { get; private set; }
+    }
+}

src/Umbraco.Core/Configuration/GlobalSettings.cs

@@ -212,7 +212,7 @@ namespace Umbraco.Core.Configuration
         {
             get
             {
-                var settings = ConfigurationManager.ConnectionStrings[UmbracoConnectionName];
+                var settings = ConfigurationManager.ConnectionStrings[Constants.System.UmbracoConnectionName];
                 var connectionString = string.Empty;
 
                 if (settings != null)
@@ -241,10 +241,7 @@ namespace Umbraco.Core.Configuration
                 }
             }
         }
-
-        //TODO: Move these to constants!
-        public const string UmbracoConnectionName = "umbracoDbDSN";
-        public const string UmbracoMigrationName = "Umbraco";
+        
 
         /// <summary>
         /// Gets or sets the configuration status. This will return the version number of the currently installed umbraco instance.

src/Umbraco.Core/Configuration/UmbracoSettings/ContentElement.cs

@@ -139,6 +139,12 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
         internal CommaDelimitedConfigurationElement DisallowedUploadFiles
         {
             get { return GetOptionalDelimitedElement("disallowedUploadFiles", new[] {"ashx", "aspx", "ascx", "config", "cshtml", "vbhtml", "asmx", "air", "axd"}); }
+        }
+
+        [ConfigurationProperty("allowedUploadFiles")]
+        internal CommaDelimitedConfigurationElement AllowedUploadFiles
+        {
+            get { return GetOptionalDelimitedElement("allowedUploadFiles", new string[0]); }
         }
 
         [ConfigurationProperty("cloneXmlContent")]
@@ -159,6 +165,12 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
             get { return GetOptionalTextElement("defaultDocumentTypeProperty", "Textstring"); }
         }
 
+        [ConfigurationProperty("showDeprecatedPropertyEditors")]
+        internal InnerTextConfigurationElement<bool> ShowDeprecatedPropertyEditors
+        {
+            get { return GetOptionalTextElement("showDeprecatedPropertyEditors", false); }
+        }
+
         [ConfigurationProperty("EnableInheritedDocumentTypes")]
         internal InnerTextConfigurationElement<bool> EnableInheritedDocumentTypes
         {
@@ -171,6 +183,18 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
             get { return GetOptionalTextElement("EnableInheritedMediaTypes", true); }
         }
 
+        [ConfigurationProperty("EnablePropertyValueConverters")]
+        internal InnerTextConfigurationElement<bool> EnablePropertyValueConverters
+        {
+            get { return GetOptionalTextElement("EnablePropertyValueConverters", false); }
+        }
+
+        [ConfigurationProperty("loginBackgroundImage")]
+        internal InnerTextConfigurationElement<string> LoginBackgroundImage
+        {
+            get { return GetOptionalTextElement("loginBackgroundImage", string.Empty); }
+        }
+
         string IContentSection.NotificationEmailAddress
         {
             get { return Notifications.NotificationEmailAddress; }
@@ -289,6 +313,11 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
         IEnumerable<string> IContentSection.DisallowedUploadFiles
         {
             get { return DisallowedUploadFiles; }
+        }
+
+        IEnumerable<string> IContentSection.AllowedUploadFiles
+        {
+            get { return AllowedUploadFiles; }
         }
 
         bool IContentSection.CloneXmlContent
@@ -306,6 +335,11 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
             get { return DefaultDocumentTypeProperty; }
         }
 
+        bool IContentSection.ShowDeprecatedPropertyEditors
+        {
+            get { return ShowDeprecatedPropertyEditors; }
+        }
+
         bool IContentSection.EnableInheritedDocumentTypes
         {
             get { return EnableInheritedDocumentTypes; }
@@ -315,5 +349,14 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
         {
             get { return EnableInheritedMediaTypes; }
         }
+        bool IContentSection.EnablePropertyValueConverters
+        {
+            get { return EnablePropertyValueConverters; }
+        }
+
+        string IContentSection.LoginBackgroundImage
+        {
+            get { return LoginBackgroundImage; }
+        }
     }
 }

src/Umbraco.Core/Configuration/UmbracoSettings/ContentSectionExtensions.cs

@@ -0,0 +1,19 @@
+using System.Linq;
+
+namespace Umbraco.Core.Configuration.UmbracoSettings
+{
+    public static class ContentSectionExtensions
+    {
+        /// <summary>
+        /// Determines if file extension is allowed for upload based on (optional) white list and black list
+        /// held in settings.
+        /// Allow upload if extension is whitelisted OR if there is no whitelist and extension is NOT blacklisted.
+        /// </summary>
+        public static bool IsFileAllowedForUpload(this IContentSection contentSection, string extension)
+        {
+            return contentSection.AllowedUploadFiles.Any(x => x.InvariantEquals(extension)) ||
+                (contentSection.AllowedUploadFiles.Any() == false &&
+                contentSection.DisallowedUploadFiles.Any(x => x.InvariantEquals(extension)) == false);
+        }
+    }
+}

src/Umbraco.Core/Configuration/UmbracoSettings/IContentSection.cs

@@ -52,7 +52,9 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
 
         MacroErrorBehaviour MacroErrorBehaviour { get; }
         
-        IEnumerable<string> DisallowedUploadFiles { get; }
+        IEnumerable<string> DisallowedUploadFiles { get; }
+
+        IEnumerable<string> AllowedUploadFiles { get; }
 
         bool CloneXmlContent { get; }
 
@@ -60,8 +62,18 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
 
         string DefaultDocumentTypeProperty { get; }
 
+        /// <summary>
+        /// The default for this is false but if you would like deprecated property editors displayed 
+        /// in the data type editor you can enable this
+        /// </summary>
+        bool ShowDeprecatedPropertyEditors { get; }
+
         bool EnableInheritedDocumentTypes { get; }
 
         bool EnableInheritedMediaTypes { get; }
+
+        bool EnablePropertyValueConverters { get; }
+
+        string LoginBackgroundImage { get; }
     }
 }

src/Umbraco.Core/Configuration/UmbracoSettings/IRepository.cs

@@ -8,6 +8,7 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
         Guid Id { get;  }
         string RepositoryUrl { get; }
         string WebServiceUrl { get; }
-        bool HasCustomWebServiceUrl { get; }
+        bool HasCustomWebServiceUrl { get; }
+        string RestApiUrl { get; }
     }
 }

src/Umbraco.Core/Configuration/UmbracoSettings/RepositoryConfigExtensions.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Linq;
+
+namespace Umbraco.Core.Configuration.UmbracoSettings
+{
+    public static class RepositoryConfigExtensions
+    {
+        //Our package repo
+        private static readonly Guid RepoGuid = new Guid("65194810-1f85-11dd-bd0b-0800200c9a66");
+
+        public static IRepository GetDefault(this IRepositoriesSection repos)
+        {
+            var found = repos.Repositories.FirstOrDefault(x => x.Id == RepoGuid);
+            if (found == null)
+                throw new InvalidOperationException("No default package repository found with id " + RepoGuid);
+            return found;
+        }
+    }
+}

src/Umbraco.Core/Configuration/UmbracoSettings/RepositoryElement.cs

@@ -38,9 +38,16 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
             get
             {
                 var prop = Properties["webserviceurl"];
-                var repoUrl = this[prop] as ConfigurationElement;
-                return (repoUrl != null && repoUrl.ElementInformation.IsPresent);
+                return (string) prop.DefaultValue != (string) this[prop];                
             }
         }
+
+        [ConfigurationProperty("restapiurl", DefaultValue = "https://our.umbraco.org/webapi/packages/v1")]
+        public string RestApiUrl
+        {
+            get { return (string)base["restapiurl"]; }
+            set { base["restapiurl"] = value; }
+        }
+        
     }
 }

src/Umbraco.Core/Configuration/UmbracoVersion.cs

@@ -6,7 +6,7 @@ namespace Umbraco.Core.Configuration
 {
     public class UmbracoVersion
     {
-        private static readonly Version Version = new Version("7.5.11");
+        private static readonly Version Version = new Version("7.6.1");
 
         /// <summary>
         /// Gets the current version of Umbraco.

src/Umbraco.Core/Constants-Applications.cs

@@ -112,9 +112,15 @@
 
             public const string Languages = "languages";
 
+            public const string PartialViews = "partialViews";
+
+            public const string PartialViewMacros = "partialViewMacros";
+
+            public const string Scripts = "scripts";
+
             //TODO: Fill in the rest!
         }
-	}
+    }
 
    
 }

src/Umbraco.Core/Constants-Conventions.cs

@@ -4,7 +4,8 @@ using Umbraco.Core.Models;
 
 namespace Umbraco.Core
 {
-	public static partial class Constants
+   
+    public static partial class Constants
 	{
 		/// <summary>
 		/// Defines the identifiers for property-type alias conventions that are used within the Umbraco core.

src/Umbraco.Core/Constants-DatabaseProviders.cs

@@ -0,0 +1,12 @@
+namespace Umbraco.Core
+{
+    public static partial class Constants
+    {
+        public static class DatabaseProviders
+        {
+            public const string SqlCe = "System.Data.SqlServerCe.4.0";
+            public const string SqlServer = "System.Data.SqlClient";
+            public const string MySql = "MySql.Data.MySqlClient";
+        }
+    }
+}

src/Umbraco.Core/Constants-DeploySelector.cs

@@ -0,0 +1,17 @@
+namespace Umbraco.Core
+{    
+    public static partial class Constants
+    {
+        /// <summary>
+        /// Contains the valid selector values.
+        /// </summary>
+        public static class DeploySelector
+        {
+            public const string This = "this";
+            public const string ThisAndChildren = "this-and-children";
+            public const string ThisAndDescendants = "this-and-descendants";
+            public const string ChildrenOfThis = "children";
+            public const string DescendantsOfThis = "descendants";
+        }
+    }
+}

src/Umbraco.Core/Constants-ObjectTypes.cs

@@ -89,6 +89,11 @@ namespace Umbraco.Core
             /// </summary>
             public const string Media = "B796F64C-1F99-4FFB-B886-4BF4BC011A9C";
 
+            /// <summary>
+            /// Guid for a Document object.
+            /// </summary>
+            public static readonly Guid MediaGuid = new Guid(Media);
+
             /// <summary>
             /// Guid for the Media Recycle Bin.
             /// </summary>
@@ -109,11 +114,21 @@ namespace Umbraco.Core
             /// </summary>
             public const string Member = "39EB0F98-B348-42A1-8662-E7EB18487560";
 
+            /// <summary>
+            /// Guid for a Media Type object.
+            /// </summary>
+            public static readonly Guid MemberGuid = new Guid(Member);
+
             /// <summary>
             /// Guid for a Member Group object.
             /// </summary>
             public const string MemberGroup = "366E63B9-880F-4E13-A61C-98069B029728";
 
+            /// <summary>
+            /// Guid for a Member Group object.
+            /// </summary>
+            public static readonly Guid MemberGroupGuid = new Guid(MemberGroup);
+
             /// <summary>
             /// Guid for a Member Type object.
             /// </summary>
@@ -143,6 +158,11 @@ namespace Umbraco.Core
             /// </summary>
             public const string Template = "6FBDE604-4178-42CE-A10B-8A2600A2F07D";
 
+            /// <summary>
+            /// Guid for a Template object.
+            /// </summary>
+            public static readonly Guid TemplateTypeGuid = new Guid(Template);
+
             /// <summary>
             /// Guid for a Lock object.
             /// </summary>
@@ -152,6 +172,46 @@ namespace Umbraco.Core
             /// Guid for a Lock object.
             /// </summary>
             public static readonly Guid LockObjectGuid = new Guid(LockObject);
+
+            /// <summary>
+            /// Guid for a relation type.
+            /// </summary>
+            public const string RelationType = "B1988FAD-8675-4F47-915A-B3A602BC5D8D";
+
+            /// <summary>
+            /// Guid for a relation type.
+            /// </summary>
+            public static readonly Guid RelationTypeGuid = new Guid(RelationType);
+
+            /// <summary>
+            /// Guid for a Forms Form.
+            /// </summary>
+            public const string FormsForm = "F5A9F787-6593-46F0-B8FF-BFD9BCA9F6BB";
+
+            /// <summary>
+            /// Guid for a Forms Form.
+            /// </summary>
+            public static readonly Guid FormsFormGuid = new Guid(FormsForm);
+
+            /// <summary>
+            /// Guid for a Forms PreValue Source.
+            /// </summary>
+            public const string FormsPreValue = "42D7BF9B-A362-4FEE-B45A-674D5C064B70";
+
+            /// <summary>
+            /// Guid for a Forms PreValue Source.
+            /// </summary>
+            public static readonly Guid FormsPreValueGuid = new Guid(FormsPreValue);
+
+            /// <summary>
+            /// Guid for a Forms DataSource.
+            /// </summary>
+            public const string FormsDataSource = "CFED6CE4-9359-443E-9977-9956FEB1D867";
+
+            /// <summary>
+            /// Guid for a Forms DataSource.
+            /// </summary>
+            public static readonly Guid FormsDataSourceGuid = new Guid(FormsDataSource);
         }
     }
 }

src/Umbraco.Core/Constants-PropertyEditors.cs

@@ -42,10 +42,14 @@ namespace Umbraco.Core
             [Obsolete("GUIDs are no longer used to reference Property Editors, use the Alias constant instead. This will be removed in future versions")]
             public const string ContentPicker = "158AA029-24ED-4948-939E-C3DA209E5FBA";
 
+            
+            [Obsolete("This is an obsoleted content picker, use ContentPicker2Alias instead")]
+            public const string ContentPickerAlias = "Umbraco.ContentPickerAlias";
+
             /// <summary>
             /// Alias for the Content Picker datatype.
             /// </summary>
-            public const string ContentPickerAlias = "Umbraco.ContentPickerAlias";
+            public const string ContentPicker2Alias = "Umbraco.ContentPicker2";
 
             /// <summary>
             /// Guid for the Date datatype.
@@ -192,11 +196,15 @@ namespace Umbraco.Core
             [Obsolete("GUIDs are no longer used to reference Property Editors, use the Alias constant instead. This will be removed in future versions")]
             public const string MediaPicker = "EAD69342-F06D-4253-83AC-28000225583B";
 
+            [Obsolete("This is an obsoleted picker, use MediaPicker2Alias instead")]
+            public const string MediaPickerAlias = "Umbraco.MediaPicker";
+
             /// <summary>
             /// Alias for the Media Picker datatype.
             /// </summary>
-            public const string MediaPickerAlias = "Umbraco.MediaPicker";
+            public const string MediaPicker2Alias = "Umbraco.MediaPicker2";
 
+            [Obsolete("This is an obsoleted picker, use MediaPicker2Alias instead")]
             public const string MultipleMediaPickerAlias = "Umbraco.MultipleMediaPicker";
 
             /// <summary>
@@ -205,26 +213,32 @@ namespace Umbraco.Core
             [Obsolete("GUIDs are no longer used to reference Property Editors, use the Alias constant instead. This will be removed in future versions")]
             public const string MemberPicker = "39F533E4-0551-4505-A64B-E0425C5CE775";
 
+            [Obsolete("This is an obsoleted picker, use MemberPicker2Alias instead")]
+            public const string MemberPickerAlias = "Umbraco.MemberPicker";
+
             /// <summary>
             /// Alias for the Member Picker datatype.
             /// </summary>
-            public const string MemberPickerAlias = "Umbraco.MemberPicker";
+            public const string MemberPicker2Alias = "Umbraco.MemberPicker2";
 
             /// <summary>
             /// Alias for the Member Group Picker datatype.
             /// </summary>
             public const string MemberGroupPickerAlias = "Umbraco.MemberGroupPicker";
-
+            
             /// <summary>
             /// Guid for the Multi-Node Tree Picker datatype
             /// </summary>
             [Obsolete("GUIDs are no longer used to reference Property Editors, use the Alias constant instead. This will be removed in future versions")]
             public const string MultiNodeTreePicker = "7E062C13-7C41-4AD9-B389-41D88AEEF87C";
 
+            [Obsolete("This is an obsoleted picker, use MultiNodeTreePicker2Alias instead")]
+            public const string MultiNodeTreePickerAlias = "Umbraco.MultiNodeTreePicker";
+
             /// <summary>
             /// Alias for the Multi-Node Tree Picker datatype
             /// </summary>
-            public const string MultiNodeTreePickerAlias = "Umbraco.MultiNodeTreePicker";
+            public const string MultiNodeTreePicker2Alias = "Umbraco.MultiNodeTreePicker2";
 
             /// <summary>
             /// Guid for the Multiple Textstring datatype.
@@ -275,11 +289,14 @@ namespace Umbraco.Core
             /// </summary>
             [Obsolete("GUIDs are no longer used to reference Property Editors, use the Alias constant instead. This will be removed in future versions")]
             public const string RelatedLinks = "71B8AD1A-8DC2-425C-B6B8-FAA158075E63";
+            
+            [Obsolete("This is an obsoleted picker, use RelatedLinks2Alias instead")]
+            public const string RelatedLinksAlias = "Umbraco.RelatedLinks";
 
             /// <summary>
-            /// Alias for the Related Links datatype.
+            /// Alias for the Related Links property editor.
             /// </summary>
-            public const string RelatedLinksAlias = "Umbraco.RelatedLinks";
+            public const string RelatedLinks2Alias = "Umbraco.RelatedLinks2";
 
             /// <summary>
             /// Guid for the Slider datatype.

src/Umbraco.Core/Constants-Security.cs

@@ -0,0 +1,33 @@
+using System;
+using System.ComponentModel;
+
+namespace Umbraco.Core
+{
+    public static partial class Constants
+    {
+        public static class Security
+        {
+
+            public const string BackOfficeAuthenticationType = "UmbracoBackOffice";
+            public const string BackOfficeExternalAuthenticationType = "UmbracoExternalCookie";
+            public const string BackOfficeExternalCookieName = "UMB_EXTLOGIN";
+            public const string BackOfficeTokenAuthenticationType = "UmbracoBackOfficeToken";
+            public const string BackOfficeTwoFactorAuthenticationType = "UmbracoTwoFactorCookie";
+
+            /// <summary>
+            /// The prefix used for external identity providers for their authentication type
+            /// </summary>
+            /// <remarks>
+            /// By default we don't want to interfere with front-end external providers and their default setup, for back office the 
+            /// providers need to be setup differently and each auth type for the back office will be prefixed with this value
+            /// </remarks>
+            public const string BackOfficeExternalAuthenticationTypePrefix = "Umbraco.";
+
+            public const string StartContentNodeIdClaimType = "http://umbraco.org/2015/02/identity/claims/backoffice/startcontentnode";
+            public const string StartMediaNodeIdClaimType = "http://umbraco.org/2015/02/identity/claims/backoffice/startmedianode";
+            public const string AllowedApplicationsClaimType = "http://umbraco.org/2015/02/identity/claims/backoffice/allowedapp";
+            public const string SessionIdClaimType = "http://umbraco.org/2015/02/identity/claims/backoffice/sessionid";
+
+        }
+    }
+}

src/Umbraco.Core/Constants-System.cs

@@ -26,15 +26,9 @@
             public const int DefaultMediaListViewDataTypeId = -96;
             public const int DefaultMembersListViewDataTypeId = -97;
 
-            // identifiers for lock objects
-            public const int ServersLock = -331;
-        }
-
-        public static class DatabaseProviders
-        {
-            public const string SqlCe = "System.Data.SqlServerCe.4.0";
-            public const string SqlServer = "System.Data.SqlClient";
-            public const string MySql = "MySql.Data.MySqlClient";
+            public const string UmbracoConnectionName = "umbracoDbDSN";
+            public const string UmbracoMigrationName = "Umbraco";
         }
+        
     }
 }

src/Umbraco.Core/Constants-Web.cs

@@ -29,30 +29,6 @@ namespace Umbraco.Core
             public const string AuthCookieName = "UMB_UCONTEXT";
 
         }
-
-	    public static class Security
-	    {
-
-            public const string BackOfficeAuthenticationType = "UmbracoBackOffice";
-	        public const string BackOfficeExternalAuthenticationType = "UmbracoExternalCookie";
-            public const string BackOfficeExternalCookieName = "UMB_EXTLOGIN";
-            public const string BackOfficeTokenAuthenticationType = "UmbracoBackOfficeToken";
-            public const string BackOfficeTwoFactorAuthenticationType = "UmbracoTwoFactorCookie";
-
-            /// <summary>
-            /// The prefix used for external identity providers for their authentication type
-            /// </summary>
-            /// <remarks>
-            /// By default we don't want to interfere with front-end external providers and their default setup, for back office the 
-            /// providers need to be setup differently and each auth type for the back office will be prefixed with this value
-            /// </remarks>
-            public const string BackOfficeExternalAuthenticationTypePrefix = "Umbraco.";
-
-	        public const string StartContentNodeIdClaimType = "http://umbraco.org/2015/02/identity/claims/backoffice/startcontentnode";
-            public const string StartMediaNodeIdClaimType = "http://umbraco.org/2015/02/identity/claims/backoffice/startmedianode";
-            public const string AllowedApplicationsClaimType = "http://umbraco.org/2015/02/identity/claims/backoffice/allowedapp";
-            public const string SessionIdClaimType = "http://umbraco.org/2015/02/identity/claims/backoffice/sessionid";
-
-	    }
+        
 	}
 }

src/Umbraco.Core/CoreBootManager.cs

@@ -28,6 +28,7 @@ using Umbraco.Core.PropertyEditors.ValueConverters;
 using Umbraco.Core.Publishing;
 using Umbraco.Core.Macros;
 using Umbraco.Core.Manifest;
+using Umbraco.Core.Scoping;
 using Umbraco.Core.Services;
 using Umbraco.Core.Sync;
 using Umbraco.Core.Strings;
@@ -105,11 +106,14 @@ namespace Umbraco.Core
             LegacyParameterEditorAliasConverter.CreateMappingsForCoreEditors();
 
             //create database and service contexts for the app context
-            var dbFactory = new DefaultDatabaseFactory(GlobalSettings.UmbracoConnectionName, ProfilingLogger.Logger);
+            var dbFactory = new DefaultDatabaseFactory(Constants.System.UmbracoConnectionName, ProfilingLogger.Logger);
             Database.Mapper = new PetaPocoMapper();
 
+            var scopeProvider = new ScopeProvider(dbFactory);
+            dbFactory.ScopeProvider = scopeProvider;
+
             var dbContext = new DatabaseContext(
-                dbFactory,
+                scopeProvider,
                 ProfilingLogger.Logger,
                 SqlSyntaxProviders.CreateDefault(ProfilingLogger.Logger));
 
@@ -117,7 +121,7 @@ namespace Umbraco.Core
             dbContext.Initialize();
 
             //get the service context
-            var serviceContext = CreateServiceContext(dbContext, dbFactory);
+            var serviceContext = CreateServiceContext(dbContext, scopeProvider);
 
             //set property and singleton from response
             ApplicationContext.Current = ApplicationContext = CreateApplicationContext(dbContext, serviceContext);
@@ -160,17 +164,15 @@ namespace Umbraco.Core
         /// Creates and returns the service context for the app
         /// </summary>
         /// <param name="dbContext"></param>
-        /// <param name="dbFactory"></param>
+        /// <param name="scopeProvider"></param>
         /// <returns></returns>
-        protected virtual ServiceContext CreateServiceContext(DatabaseContext dbContext, IDatabaseFactory dbFactory)
+        protected virtual ServiceContext CreateServiceContext(DatabaseContext dbContext, IScopeProvider scopeProvider)
         {
             //default transient factory
             var msgFactory = new TransientMessagesFactory();
             return new ServiceContext(
                 new RepositoryFactory(ApplicationCache, ProfilingLogger.Logger, dbContext.SqlSyntax, UmbracoConfig.For.UmbracoSettings()),
-                new PetaPocoUnitOfWorkProvider(dbFactory),
-                new FileUnitOfWorkProvider(),
-                new PublishingStrategy(msgFactory, ProfilingLogger.Logger),
+                new PetaPocoUnitOfWorkProvider(scopeProvider),
                 ApplicationCache,
                 ProfilingLogger.Logger,
                 msgFactory);

src/Umbraco.Core/DatabaseContext.cs

@@ -4,7 +4,6 @@ using System.Data.SqlServerCe;
 using System.IO;
 using System.Linq;
 using System.Web;
-using System.Web.Configuration;
 using System.Xml.Linq;
 using Semver;
 using Umbraco.Core.Configuration;
@@ -14,6 +13,7 @@ using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.Migrations;
 using Umbraco.Core.Persistence.Migrations.Initial;
 using Umbraco.Core.Persistence.SqlSyntax;
+using Umbraco.Core.Scoping;
 using Umbraco.Core.Services;
 
 namespace Umbraco.Core
@@ -26,31 +26,42 @@ namespace Umbraco.Core
     /// </remarks>
     public class DatabaseContext
     {
-        private readonly IDatabaseFactory _factory;
+        internal readonly IScopeProviderInternal ScopeProvider;
         private readonly ILogger _logger;
         private readonly SqlSyntaxProviders _syntaxProviders;
         private bool _configured;
-        private readonly object _locker = new object();
         private string _connectionString;
         private string _providerName;
         private DatabaseSchemaResult _result;
-        private DateTime? _connectionLastChecked = null;
+        private DateTime? _connectionLastChecked;
 
         /// <summary>
         /// The number of minutes to throttle the checks to CanConnect
         /// </summary>
         private const int ConnectionCheckMinutes = 1;
 
+        #region Compatibility with 7.5
+
+        // note: the ctors accepting IDatabaseFactory are here only for backward compatibility purpose
+        //
+        // problem: IDatabaseFactory2 adds the CreateNewDatabase() method which creates a new database
+        // 'cos IDatabaseFactory CreateDatabase() is supposed to also manage the ambient thing. We
+        // want to keep these ctors for backward compatibility reasons (in case ppl use them in tests)
+        // so we need to create a scope provider (else nothing would work) and so we need a IDatabaseFactory2,
+        // so...?
+        // solution: wrap IDatabaseFactory and pretend we have a IDatabaseFactory2, it *should* work in most
+        // cases but really, it depends on what ppl are doing in their tests... yet, cannot really see any
+        // other way to do it?
+
         [Obsolete("Use the constructor specifying all dependencies instead")]
         public DatabaseContext(IDatabaseFactory factory)
             : this(factory, LoggerResolver.Current.Logger, new SqlSyntaxProviders(new ISqlSyntaxProvider[]
             {
                 new MySqlSyntaxProvider(LoggerResolver.Current.Logger),
-                new SqlCeSyntaxProvider(), 
+                new SqlCeSyntaxProvider(),
                 new SqlServerSyntaxProvider()
             }))
-        {
-        }
+        { }
 
         /// <summary>
         /// Default constructor
@@ -64,7 +75,11 @@ namespace Umbraco.Core
             if (logger == null) throw new ArgumentNullException("logger");
             if (syntaxProviders == null) throw new ArgumentNullException("syntaxProviders");
 
-            _factory = factory;
+            var asDbFactory2 = factory as IDatabaseFactory2;
+            ScopeProvider = asDbFactory2 == null
+                ? new ScopeProvider(new DatabaseFactoryWrapper(factory))
+                : new ScopeProvider(asDbFactory2);
+
             _logger = logger;
             _syntaxProviders = syntaxProviders;
         }
@@ -81,7 +96,83 @@ namespace Umbraco.Core
             _providerName = providerName;
             SqlSyntax = sqlSyntax;
             SqlSyntaxContext.SqlSyntaxProvider = SqlSyntax;
-            _factory = factory;
+
+            var asDbFactory2 = factory as IDatabaseFactory2;
+            ScopeProvider = asDbFactory2 == null
+                ? new ScopeProvider(new DatabaseFactoryWrapper(factory))
+                : new ScopeProvider(asDbFactory2);
+
+            _logger = logger;
+            _configured = true;
+        }
+
+        private class DatabaseFactoryWrapper : IDatabaseFactory2
+        {
+            private readonly IDatabaseFactory _factory;
+
+            public DatabaseFactoryWrapper(IDatabaseFactory factory)
+            {
+                _factory = factory;
+            }
+
+            public UmbracoDatabase CreateDatabase()
+            {
+                return _factory.CreateDatabase();
+            }
+
+            public UmbracoDatabase CreateNewDatabase()
+            {
+                return CreateDatabase();
+            }
+
+            public void Dispose()
+            {
+                _factory.Dispose();
+            }
+        }
+
+        #endregion
+
+        [Obsolete("Use the constructor specifying all dependencies instead")]
+        internal DatabaseContext(IScopeProviderInternal scopeProvider)
+            : this(scopeProvider, LoggerResolver.Current.Logger, new SqlSyntaxProviders(new ISqlSyntaxProvider[]
+            {
+                new MySqlSyntaxProvider(LoggerResolver.Current.Logger),
+                new SqlCeSyntaxProvider(),
+                new SqlServerSyntaxProvider()
+            }))
+        { }
+
+        /// <summary>
+        /// Default constructor
+        /// </summary>
+        /// <param name="scopeProvider"></param>
+        /// <param name="logger"></param>
+        /// <param name="syntaxProviders"></param>
+        internal DatabaseContext(IScopeProviderInternal scopeProvider, ILogger logger, SqlSyntaxProviders syntaxProviders)
+        {
+            if (scopeProvider == null) throw new ArgumentNullException("scopeProvider");
+            if (logger == null) throw new ArgumentNullException("logger");
+            if (syntaxProviders == null) throw new ArgumentNullException("syntaxProviders");
+
+            ScopeProvider = scopeProvider;
+            _logger = logger;
+            _syntaxProviders = syntaxProviders;
+        }
+
+        /// <summary>
+        /// Create a configured DatabaseContext
+        /// </summary>
+        /// <param name="scopeProvider"></param>
+        /// <param name="logger"></param>
+        /// <param name="sqlSyntax"></param>
+        /// <param name="providerName"></param>
+        internal DatabaseContext(IScopeProviderInternal scopeProvider, ILogger logger, ISqlSyntaxProvider sqlSyntax, string providerName)
+        {
+            _providerName = providerName;
+            SqlSyntax = sqlSyntax;
+            SqlSyntaxContext.SqlSyntaxProvider = SqlSyntax;
+            ScopeProvider = scopeProvider;
             _logger = logger;
             _configured = true;
         }
@@ -89,16 +180,27 @@ namespace Umbraco.Core
         public ISqlSyntaxProvider SqlSyntax { get; private set; }
 
         /// <summary>
-        /// Gets the <see cref="Database"/> object for doing CRUD operations
-        /// against custom tables that resides in the Umbraco database.
+        /// Gets an "ambient" database for doing CRUD operations against custom tables that resides in the Umbraco database.
         /// </summary>
         /// <remarks>
-        /// This should not be used for CRUD operations or queries against the
-        /// standard Umbraco tables! Use the Public services for that.
+        /// <para>Should not be used for operation against standard Umbraco tables; as services should be used instead.</para>
+        /// <para>Gets or creates an "ambient" database that is either stored in http context + available for the whole
+        /// request + auto-disposed at the end of the request, or stored in call context if there is no http context - in which
+        /// case it *must* be explicitely disposed (which will remove it from call context).</para>
         /// </remarks>
         public virtual UmbracoDatabase Database
         {
-            get { return _factory.CreateDatabase(); }
+            get
+            {
+            	if (IsDatabaseConfigured == false)
+                {
+                    throw new InvalidOperationException("Cannot create a database instance, there is no available connection string");
+                }
+
+                return ScopeProvider.GetAmbientOrNoScope().Database;
+                //var scope = ScopeProvider.AmbientScope;
+                //return scope != null ? scope.Database : ScopeProvider.CreateNoScope().Database;
+            }
         }
 
         /// <summary>
@@ -121,7 +223,7 @@ namespace Umbraco.Core
 
                 //Don't check again if the timeout period hasn't elapsed
                 //this ensures we don't keep checking the connection too many times in a row like during startup.
-                //Do check if the _connectionLastChecked is null which means we're just initializing or it could 
+                //Do check if the _connectionLastChecked is null which means we're just initializing or it could
                 //not connect last time it was checked.
                 if ((_connectionLastChecked.HasValue && (DateTime.Now - _connectionLastChecked.Value).TotalMinutes > ConnectionCheckMinutes)
                     || _connectionLastChecked.HasValue == false)
@@ -157,14 +259,14 @@ namespace Umbraco.Core
                     return _providerName;
 
                 _providerName = Constants.DatabaseProviders.SqlServer;
-                if (ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName] != null)
+                if (ConfigurationManager.ConnectionStrings[Constants.System.UmbracoConnectionName] != null)
                 {
-                    if (string.IsNullOrEmpty(ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName].ProviderName) == false)
-                        _providerName = ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName].ProviderName;
+                    if (string.IsNullOrEmpty(ConfigurationManager.ConnectionStrings[Constants.System.UmbracoConnectionName].ProviderName) == false)
+                        _providerName = ConfigurationManager.ConnectionStrings[Constants.System.UmbracoConnectionName].ProviderName;
                 }
                 else
                 {
-                    throw new InvalidOperationException("Can't find a connection string with the name '" + GlobalSettings.UmbracoConnectionName + "'");
+                    throw new NullReferenceException("Can't find a connection string with the name '" + Constants.System.UmbracoConnectionName + "'");
                 }
                 return _providerName;
             }
@@ -246,14 +348,14 @@ namespace Umbraco.Core
         /// <param name="password">Database Password</param>
         /// <param name="databaseProvider">Type of the provider to be used (Sql, Sql Azure, Sql Ce, MySql)</param>
         public void ConfigureDatabaseConnection(string server, string databaseName, string user, string password, string databaseProvider)
-        {            
+        {
             string providerName;
             var connectionString = GetDatabaseConnectionString(server, databaseName, user, password, databaseProvider, out providerName);
 
             SaveConnectionString(connectionString, providerName);
             Initialize(providerName);
         }
-        
+
         public string GetDatabaseConnectionString(string server, string databaseName, string user, string password, string databaseProvider, out string providerName)
         {
             providerName = Constants.DatabaseProviders.SqlServer;
@@ -284,18 +386,18 @@ namespace Umbraco.Core
 
         public string GetIntegratedSecurityDatabaseConnectionString(string server, string databaseName)
         {
-            return String.Format("Server={0};Database={1};Integrated Security=true", server, databaseName);            
+            return String.Format("Server={0};Database={1};Integrated Security=true", server, databaseName);
         }
 
         internal string BuildAzureConnectionString(string server, string databaseName, string user, string password)
         {
             if (server.Contains(".") && ServerStartsWithTcp(server) == false)
                 server = string.Format("tcp:{0}", server);
-            
+
             if (server.Contains(".") == false && ServerStartsWithTcp(server))
             {
-                string serverName = server.Contains(",") 
-                                        ? server.Substring(0, server.IndexOf(",", StringComparison.Ordinal)) 
+                string serverName = server.Contains(",")
+                                        ? server.Substring(0, server.IndexOf(",", StringComparison.Ordinal))
                                         : server;
 
                 var portAddition = string.Empty;
@@ -305,10 +407,10 @@ namespace Umbraco.Core
 
                 server = string.Format("{0}.database.windows.net{1}", serverName, portAddition);
             }
-            
+
             if (ServerStartsWithTcp(server) == false)
                 server = string.Format("tcp:{0}.database.windows.net", server);
-            
+
             if (server.Contains(",") == false)
                 server = string.Format("{0},1433", server);
 
@@ -345,23 +447,23 @@ namespace Umbraco.Core
         {
             //Set the connection string for the new datalayer
             var connectionStringSettings = string.IsNullOrEmpty(providerName)
-                                      ? new ConnectionStringSettings(GlobalSettings.UmbracoConnectionName,
+                                      ? new ConnectionStringSettings(Constants.System.UmbracoConnectionName,
                                                                      connectionString)
-                                      : new ConnectionStringSettings(GlobalSettings.UmbracoConnectionName,
+                                      : new ConnectionStringSettings(Constants.System.UmbracoConnectionName,
                                                                      connectionString, providerName);
 
             _connectionString = connectionString;
             _providerName = providerName;
-            
+
             var fileName = IOHelper.MapPath(string.Format("{0}/web.config", SystemDirectories.Root));
             var xml = XDocument.Load(fileName, LoadOptions.PreserveWhitespace);
             var connectionstrings = xml.Root.DescendantsAndSelf("connectionStrings").Single();
 
             // Update connectionString if it exists, or else create a new appSetting for the given key and value
-            var setting = connectionstrings.Descendants("add").FirstOrDefault(s => s.Attribute("name").Value == GlobalSettings.UmbracoConnectionName);
+            var setting = connectionstrings.Descendants("add").FirstOrDefault(s => s.Attribute("name").Value == Constants.System.UmbracoConnectionName);
             if (setting == null)
                 connectionstrings.Add(new XElement("add",
-                    new XAttribute("name", GlobalSettings.UmbracoConnectionName),
+                    new XAttribute("name", Constants.System.UmbracoConnectionName),
                     new XAttribute("connectionString", connectionStringSettings),
                     new XAttribute("providerName", providerName)));
             else
@@ -386,23 +488,23 @@ namespace Umbraco.Core
         /// </remarks>
         internal void Initialize()
         {
-            var databaseSettings = ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName];
+            var databaseSettings = ConfigurationManager.ConnectionStrings[Constants.System.UmbracoConnectionName];
             if (databaseSettings != null && string.IsNullOrWhiteSpace(databaseSettings.ConnectionString) == false && string.IsNullOrWhiteSpace(databaseSettings.ProviderName) == false)
             {
                 var providerName = Constants.DatabaseProviders.SqlServer;
                 string connString = null;
-                if (!string.IsNullOrEmpty(ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName].ProviderName))
+                if (!string.IsNullOrEmpty(ConfigurationManager.ConnectionStrings[Constants.System.UmbracoConnectionName].ProviderName))
                 {
-                    providerName = ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName].ProviderName;
-                    connString = ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName].ConnectionString;
+                    providerName = ConfigurationManager.ConnectionStrings[Constants.System.UmbracoConnectionName].ProviderName;
+                    connString = ConfigurationManager.ConnectionStrings[Constants.System.UmbracoConnectionName].ConnectionString;
                 }
                 Initialize(providerName, connString);
-                
+
             }
-            else if (ConfigurationManager.AppSettings.ContainsKey(GlobalSettings.UmbracoConnectionName) && string.IsNullOrEmpty(ConfigurationManager.AppSettings[GlobalSettings.UmbracoConnectionName]) == false)
+            else if (ConfigurationManager.AppSettings.ContainsKey(Constants.System.UmbracoConnectionName) && string.IsNullOrEmpty(ConfigurationManager.AppSettings[Constants.System.UmbracoConnectionName]) == false)
             {
                 //A valid connectionstring does not exist, but the legacy appSettings key was found, so we'll reconfigure the conn.string.
-                var legacyConnString = ConfigurationManager.AppSettings[GlobalSettings.UmbracoConnectionName];
+                var legacyConnString = ConfigurationManager.AppSettings[Constants.System.UmbracoConnectionName];
                 if (legacyConnString.ToLowerInvariant().Contains("sqlce4umbraco"))
                 {
                     ConfigureEmbeddedDatabaseConnection();
@@ -433,8 +535,8 @@ namespace Umbraco.Core
                 }
 
                 //Remove the legacy connection string, so we don't end up in a loop if something goes wrong.
-                GlobalSettings.RemoveSetting(GlobalSettings.UmbracoConnectionName);
-                
+                GlobalSettings.RemoveSetting(Constants.System.UmbracoConnectionName);
+
             }
             else
             {
@@ -453,15 +555,15 @@ namespace Umbraco.Core
             {
                 if (_syntaxProviders != null)
                 {
-                    SqlSyntax = _syntaxProviders.GetByProviderNameOrDefault(providerName);    
+                    SqlSyntax = _syntaxProviders.GetByProviderNameOrDefault(providerName);
                 }
                 else if (SqlSyntax == null)
                 {
                     throw new InvalidOperationException("No " + typeof(ISqlSyntaxProvider) + " specified or no " + typeof(SqlSyntaxProviders) + " instance specified");
                 }
-                
+
                 SqlSyntaxContext.SqlSyntaxProvider = SqlSyntax;
-                
+
                 _configured = true;
             }
             catch (Exception e)
@@ -501,7 +603,7 @@ namespace Umbraco.Core
         }
 
         internal Result CreateDatabaseSchemaAndData(ApplicationContext applicationContext)
-        {   
+        {
             try
             {
                 var readyForInstall = CheckReadyForInstall();
@@ -519,7 +621,7 @@ namespace Umbraco.Core
                 // If MySQL, we're going to ensure that database calls are maintaining proper casing as to remove the necessity for checks
                 // for case insensitive queries. In an ideal situation (which is what we're striving for), all calls would be case sensitive.
 
-                /*                
+                /*
                 var supportsCaseInsensitiveQueries = SqlSyntax.SupportsCaseInsensitiveQueries(database);
                 if (supportsCaseInsensitiveQueries  == false)
                 {
@@ -537,9 +639,9 @@ namespace Umbraco.Core
                 message = GetResultMessageForMySql();
 
                 var schemaResult = ValidateDatabaseSchema();
-                
+
                 var installedSchemaVersion = schemaResult.DetermineInstalledVersion();
-                
+
                 //If Configuration Status is empty and the determined version is "empty" its a new install - otherwise upgrade the existing
                 if (string.IsNullOrEmpty(GlobalSettings.ConfigurationStatus) && installedSchemaVersion.Equals(new Version(0, 0, 0)))
                 {
@@ -558,9 +660,9 @@ namespace Umbraco.Core
                 message = "<p>Upgrading database, this may take some time...</p>";
                 return new Result
                     {
-                        RequiresUpgrade = true, 
-                        Message = message, 
-                        Success = true, 
+                        RequiresUpgrade = true,
+                        Message = message,
+                        Success = true,
                         Percentage = "30"
                     };
             }
@@ -588,7 +690,7 @@ namespace Umbraco.Core
                 _logger.Info<DatabaseContext>("Database upgrade started");
 
                 var database = new UmbracoDatabase(_connectionString, ProviderName, _logger);
-                //var supportsCaseInsensitiveQueries = SqlSyntax.SupportsCaseInsensitiveQueries(database);                
+                //var supportsCaseInsensitiveQueries = SqlSyntax.SupportsCaseInsensitiveQueries(database);
 
                 var message = GetResultMessageForMySql();
 
@@ -596,32 +698,32 @@ namespace Umbraco.Core
 
                 var installedSchemaVersion = new SemVersion(schemaResult.DetermineInstalledVersion());
 
-                var installedMigrationVersion = schemaResult.DetermineInstalledVersionByMigrations(migrationEntryService);    
-                
+                var installedMigrationVersion = schemaResult.DetermineInstalledVersionByMigrations(migrationEntryService);
+
                 var targetVersion = UmbracoVersion.Current;
-                
+
                 //In some cases - like upgrading from 7.2.6 -> 7.3, there will be no migration information in the database and therefore it will
-                // return a version of 0.0.0 and we don't necessarily want to run all migrations from 0 -> 7.3, so we'll just ensure that the 
+                // return a version of 0.0.0 and we don't necessarily want to run all migrations from 0 -> 7.3, so we'll just ensure that the
                 // migrations are run for the target version
                 if (installedMigrationVersion == new SemVersion(new Version(0, 0, 0)) && installedSchemaVersion > new SemVersion(new Version(0, 0, 0)))
                 {
                     //set the installedMigrationVersion to be one less than the target so the latest migrations are guaranteed to execute
                     installedMigrationVersion = new SemVersion(targetVersion.SubtractRevision());
                 }
-                
+
                 //Figure out what our current installed version is. If the web.config doesn't have a version listed, then we'll use the minimum
-                // version detected between the schema installed and the migrations listed in the migration table. 
+                // version detected between the schema installed and the migrations listed in the migration table.
                 // If there is a version in the web.config, we'll take the minimum between the listed migration in the db and what
                 // is declared in the web.config.
-                
+
                 var currentInstalledVersion = string.IsNullOrEmpty(GlobalSettings.ConfigurationStatus)
                     //Take the minimum version between the detected schema version and the installed migration version
                     ? new[] {installedSchemaVersion, installedMigrationVersion}.Min()
                     //Take the minimum version between the installed migration version and the version specified in the config
                     : new[] { SemVersion.Parse(GlobalSettings.ConfigurationStatus), installedMigrationVersion }.Min();
 
-                //Ok, another edge case here. If the current version is a pre-release, 
-                // then we want to ensure all migrations for the current release are executed. 
+                //Ok, another edge case here. If the current version is a pre-release,
+                // then we want to ensure all migrations for the current release are executed.
                 if (currentInstalledVersion.Prerelease.IsNullOrWhiteSpace() == false)
                 {
                     currentInstalledVersion  = new SemVersion(currentInstalledVersion.GetVersion().SubtractRevision());
@@ -629,7 +731,7 @@ namespace Umbraco.Core
 
                 //DO the upgrade!
 
-                var runner = new MigrationRunner(migrationEntryService, _logger, currentInstalledVersion, UmbracoVersion.GetSemanticVersion(), GlobalSettings.UmbracoMigrationName);
+                var runner = new MigrationRunner(migrationEntryService, _logger, currentInstalledVersion, UmbracoVersion.GetSemanticVersion(), Constants.System.UmbracoMigrationName);
 
                 var upgraded = runner.Execute(database, true);
 
@@ -756,7 +858,7 @@ namespace Umbraco.Core
                 {
                     var datasource = dataSourcePart.Replace("|DataDirectory|", AppDomain.CurrentDomain.GetData("DataDirectory").ToString());
                     var filePath = datasource.Replace("Data Source=", string.Empty);
-                    sqlCeDatabaseExists = File.Exists(filePath);                    
+                    sqlCeDatabaseExists = File.Exists(filePath);
                 }
             }
 
@@ -770,5 +872,30 @@ namespace Umbraco.Core
 
             return true;
         }
+
+        /*
+        private class UsingDatabase : IDisposable
+        {
+            private readonly UmbracoDatabase _orig;
+            private readonly UmbracoDatabase _temp;
+
+            public UsingDatabase(UmbracoDatabase orig, UmbracoDatabase temp)
+            {
+                _orig = orig;
+                _temp = temp;
+            }
+
+            public void Dispose()
+            {
+                if (_temp != null)
+                {
+                    _temp.Dispose();
+                    if (_orig != null)
+                        DefaultDatabaseFactory.AttachAmbientDatabase(_orig);
+                }
+                GC.SuppressFinalize(this);
+            }
+        }
+        */
     }
 }

src/Umbraco.Core/Deploy/ArtifactBase.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json;
+
+namespace Umbraco.Core.Deploy
+{
+    /// <summary>
+    /// Provides a base class to all artifacts.
+    /// </summary>
+    public abstract class ArtifactBase<TUdi> : IArtifact
+        where TUdi : Udi
+    {
+        protected ArtifactBase(TUdi udi, IEnumerable<ArtifactDependency> dependencies = null)
+        {
+            if (udi == null)
+                throw new ArgumentNullException("udi");
+            Udi = udi;
+            Name = Udi.ToString();
+
+            Dependencies = dependencies ?? Enumerable.Empty<ArtifactDependency>();
+            _checksum = new Lazy<string>(GetChecksum);
+        }
+
+        private readonly Lazy<string> _checksum;
+        private IEnumerable<ArtifactDependency> _dependencies;
+
+        protected abstract string GetChecksum();
+
+        #region Abstract implementation of IArtifactSignature
+
+        Udi IArtifactSignature.Udi
+        {
+            get { return Udi; }
+        }
+
+        public TUdi Udi { get; set; }
+
+        [JsonIgnore]
+        public string Checksum
+        {
+            get { return _checksum.Value; }
+        }
+
+        public IEnumerable<ArtifactDependency> Dependencies
+        {
+            get { return _dependencies; }
+            set { _dependencies = value.OrderBy(x => x.Udi); }
+        }
+
+        #endregion
+
+        public string Name { get; set; }
+        public string Alias { get; set; }
+    }
+}

src/Umbraco.Core/Deploy/ArtifactDependency.cs

@@ -0,0 +1,40 @@
+namespace Umbraco.Core.Deploy
+{
+    /// <summary>
+    /// Represents an artifact dependency.
+    /// </summary>
+    /// <remarks>
+    /// <para>Dependencies have an order property which indicates whether it must be respected when ordering artifacts.</para>
+    /// <para>Dependencies have a mode which can be <c>Match</c> or <c>Exist</c> depending on whether the checksum should match.</para>
+    /// </remarks>
+    public class ArtifactDependency
+    {
+        /// <summary>
+        /// Initializes a new instance of the ArtifactDependency class with an entity identifier and a mode.
+        /// </summary>
+        /// <param name="udi">The entity identifier of the artifact that is a dependency.</param>
+        /// <param name="ordering">A value indicating whether the dependency is ordering.</param>
+        /// <param name="mode">The dependency mode.</param>
+        public ArtifactDependency(Udi udi, bool ordering, ArtifactDependencyMode mode)
+        {
+            Udi = udi;
+            Ordering = ordering;
+            Mode = mode;
+        }
+
+        /// <summary>
+        /// Gets the entity id of the artifact that is a dependency.
+        /// </summary>
+        public Udi Udi { get; private set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the dependency is ordering.
+        /// </summary>
+        public bool Ordering { get; private set; }
+
+        /// <summary>
+        /// Gets the dependency mode.
+        /// </summary>
+        public ArtifactDependencyMode Mode { get; private set; }
+    }
+}

src/Umbraco.Core/Deploy/ArtifactDependencyCollection.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Deploy
+{
+    /// <summary>
+    /// Represents a collection of distinct <see cref="ArtifactDependency"/>.
+    /// </summary>
+    /// <remarks>The collection cannot contain duplicates and modes are properly managed.</remarks>
+    public class ArtifactDependencyCollection : ICollection<ArtifactDependency>
+    {
+        private readonly Dictionary<Udi, ArtifactDependency> _dependencies
+            = new Dictionary<Udi, ArtifactDependency>();
+
+        public IEnumerator<ArtifactDependency> GetEnumerator()
+        {
+            return _dependencies.Values.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public void Add(ArtifactDependency item)
+        {
+            if (_dependencies.ContainsKey(item.Udi))
+            {
+                var exist = _dependencies[item.Udi];
+                if (item.Mode == ArtifactDependencyMode.Exist || item.Mode == exist.Mode)
+                    return;
+            }
+
+            _dependencies[item.Udi] = item;
+        }
+
+        public void Clear()
+        {
+            _dependencies.Clear();
+        }
+
+        public bool Contains(ArtifactDependency item)
+        {
+            return _dependencies.ContainsKey(item.Udi) &&
+                   (_dependencies[item.Udi].Mode == item.Mode || _dependencies[item.Udi].Mode == ArtifactDependencyMode.Match);
+        }
+
+        public void CopyTo(ArtifactDependency[] array, int arrayIndex)
+        {
+            _dependencies.Values.CopyTo(array, arrayIndex);
+        }
+
+        public bool Remove(ArtifactDependency item)
+        {
+            throw new NotSupportedException();
+        }
+
+        public int Count
+        {
+            get { return _dependencies.Count; }
+        }
+
+        public bool IsReadOnly
+        {
+            get { return false; }
+        }
+    }
+}

src/Umbraco.Core/Deploy/ArtifactDependencyMode.cs

@@ -0,0 +1,18 @@
+namespace Umbraco.Core.Deploy
+{
+    /// <summary>
+    /// Indicates the mode of the dependency.
+    /// </summary>
+    public enum ArtifactDependencyMode
+    {
+        /// <summary>
+        /// The dependency must match exactly.
+        /// </summary>
+        Match,
+
+        /// <summary>
+        /// The dependency must exist.
+        /// </summary>
+        Exist
+    }
+}

src/Umbraco.Core/Deploy/ArtifactDeployState.cs

@@ -0,0 +1,50 @@
+namespace Umbraco.Core.Deploy
+{
+    /// <summary>
+    /// Represent the state of an artifact being deployed.
+    /// </summary>
+    public abstract class ArtifactDeployState
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="ArtifactDeployState"/> class from an artifact and an entity.
+        /// </summary>
+        /// <typeparam name="TArtifact">The type of the artifact.</typeparam>
+        /// <typeparam name="TEntity">The type of the entity.</typeparam>
+        /// <param name="art">The artifact.</param>
+        /// <param name="entity">The entity.</param>
+        /// <param name="connector">The service connector deploying the artifact.</param>
+        /// <param name="nextPass">The next pass number.</param>
+        /// <returns>A deploying artifact.</returns>
+        public static ArtifactDeployState<TArtifact, TEntity> Create<TArtifact, TEntity>(TArtifact art, TEntity entity, IServiceConnector connector, int nextPass)
+            where TArtifact : IArtifact
+        {
+            return new ArtifactDeployState<TArtifact, TEntity>(art, entity, connector, nextPass);
+        }
+
+        /// <summary>
+        /// Gets the artifact.
+        /// </summary>
+        public IArtifact Artifact
+        {
+            get { return GetArtifactAsIArtifact(); }
+        }
+
+        /// <summary>
+        /// Gets the artifact as an <see cref="IArtifact"/>.
+        /// </summary>
+        /// <returns>The artifact, as an <see cref="IArtifact"/>.</returns>
+        /// <remarks>This is because classes that inherit from this class cannot override the Artifact property
+        /// with a property that specializes the return type, and so they need to 'new' the property.</remarks>
+        protected abstract IArtifact GetArtifactAsIArtifact();
+
+        /// <summary>
+        /// Gets or sets the service connector in charge of deploying the artifact.
+        /// </summary>
+        public IServiceConnector Connector { get; set; }
+
+        /// <summary>
+        /// Gets or sets the next pass number.
+        /// </summary>
+        public int NextPass { get; set; }
+    }
+}

src/Umbraco.Core/Deploy/ArtifactDeployStateOfTArtifactTEntity.cs

@@ -0,0 +1,48 @@
+namespace Umbraco.Core.Deploy
+{
+    /// <summary>
+    /// Represent the state of an artifact being deployed.
+    /// </summary>
+    /// <typeparam name="TArtifact">The type of the artifact.</typeparam>
+    /// <typeparam name="TEntity">The type of the entity.</typeparam>
+    public class ArtifactDeployState<TArtifact, TEntity> : ArtifactDeployState
+        where TArtifact : IArtifact
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ArtifactDeployState{TArtifact,TEntity}"/> class.
+        /// </summary>
+        public ArtifactDeployState()
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ArtifactDeployState{TArtifact,TEntity}"/> class.
+        /// </summary>
+        /// <param name="art">The artifact.</param>
+        /// <param name="entity">The entity.</param>
+        /// <param name="connector">The service connector deploying the artifact.</param>
+        /// <param name="nextPass">The next pass number.</param>
+        public ArtifactDeployState(TArtifact art, TEntity entity, IServiceConnector connector, int nextPass)
+        {
+            Artifact = art;
+            Entity = entity;
+            Connector = connector;
+            NextPass = nextPass;
+        }
+
+        /// <summary>
+        /// Gets or sets the artifact.
+        /// </summary>
+        public new TArtifact Artifact { get; set; }
+
+        /// <summary>
+        /// Gets or sets the entity.
+        /// </summary>
+        public TEntity Entity { get; set; }
+
+        /// <inheritdoc/>
+        protected sealed override IArtifact GetArtifactAsIArtifact()
+        {
+            return Artifact;
+        }
+    }
+}

src/Umbraco.Core/Deploy/ArtifactSignature.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Umbraco.Core.Deploy
+{
+    public sealed class ArtifactSignature : IArtifactSignature
+    {
+        public ArtifactSignature(Udi udi, string checksum, IEnumerable<ArtifactDependency> dependencies = null)
+        {
+            Udi = udi;
+            Checksum = checksum;
+            Dependencies = dependencies ?? Enumerable.Empty<ArtifactDependency>();
+        }
+
+        public Udi Udi { get; private set; }
+
+        public string Checksum { get; private set; }
+
+        public IEnumerable<ArtifactDependency> Dependencies { get; private set; }
+    }
+}

src/Umbraco.Core/Deploy/Difference.cs

@@ -0,0 +1,28 @@
+namespace Umbraco.Core.Deploy
+{
+    public class Difference
+    {
+        public Difference(string title, string text = null, string category = null)
+        {
+            Title = title;
+            Text = text;
+            Category = category;
+        }
+
+        public string Title { get; set; }
+        public string Text { get; set; }
+        public string Category { get; set; }
+
+        public override string ToString()
+        {
+            var s = Title;
+            if (!string.IsNullOrWhiteSpace(Category)) s += string.Format("[{0}]", Category);
+            if (!string.IsNullOrWhiteSpace(Text))
+            {
+                if (s.Length > 0) s += ":";
+                s += Text;
+            }
+            return s;
+        }
+    }
+}

src/Umbraco.Core/Deploy/Direction.cs

@@ -0,0 +1,8 @@
+namespace Umbraco.Core.Deploy
+{
+    public enum Direction
+    {
+        ToArtifact,
+        FromArtifact
+    }
+}

src/Umbraco.Core/Deploy/IArtifact.cs

@@ -0,0 +1,11 @@
+namespace Umbraco.Core.Deploy
+{
+    /// <summary>
+    /// Represents an artifact ie an object that can be transfered between environments.
+    /// </summary>
+    public interface IArtifact : IArtifactSignature
+    {
+        string Name { get; }
+        string Alias { get; }
+    }
+}

src/Umbraco.Core/Deploy/IArtifactSignature.cs

@@ -0,0 +1,41 @@
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Deploy
+{
+    /// <summary>
+    /// Represents the signature of an artifact.
+    /// </summary>
+    public interface IArtifactSignature
+    {
+        /// <summary>
+        /// Gets the entity unique identifier of this artifact.
+        /// </summary>
+        /// <remarks>
+        /// <para>The project identifier is independent from the state of the artifact, its data
+        /// values, dependencies, anything. It never changes and fully identifies the artifact.</para>
+        /// <para>What an entity uses as a unique identifier will influence what we can transfer
+        /// between environments. Eg content type "Foo" on one environment is not necessarily the
+        /// same as "Foo" on another environment, if guids are used as unique identifiers. What is
+        /// used should be documented for each entity, along with the consequences of the choice.</para>
+        /// </remarks>
+        Udi Udi { get; }
+
+        /// <summary>
+        /// Gets the checksum of this artifact.
+        /// </summary>
+        /// <remarks>
+        /// <para>The checksum depends on the artifact's properties, and on the identifiers of all its dependencies,
+        /// but not on their checksums. So the checksum changes when any of the artifact's properties changes,
+        /// or when the list of dependencies changes. But not if one of these dependencies change.</para>
+        /// <para>It is assumed that checksum collisions cannot happen ie that no two different artifact's
+        /// states will ever produce the same checksum, so that if two artifacts have the same checksum then
+        /// they are identical.</para>
+        /// </remarks>
+        string Checksum { get; }
+
+        /// <summary>
+        /// Gets the dependencies of this artifact.
+        /// </summary>
+        IEnumerable<ArtifactDependency> Dependencies { get; }
+    }
+}

src/Umbraco.Core/Deploy/IDeployContext.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Deploy
+{
+    /// <summary>
+    /// Represents a deployment context.
+    /// </summary>
+    public interface IDeployContext
+    {
+        /// <summary>
+        /// Gets the unique identifier of the deployment.
+        /// </summary>
+        Guid SessionId { get; }
+
+        /// <summary>
+        /// Gets the file source.
+        /// </summary>
+        /// <remarks>The file source is used to obtain files from the source environment.</remarks>
+        IFileSource FileSource { get; }
+
+        /// <summary>
+        /// Gets the next number in a numerical sequence.
+        /// </summary>
+        /// <returns>The next sequence number.</returns>
+        /// <remarks>Can be used to uniquely number things during a deployment.</remarks>
+        int NextSeq();
+
+        /// <summary>
+        /// Gets items.
+        /// </summary>
+        IDictionary<string, object> Items { get; }
+
+        /// <summary>
+        /// Gets item.
+        /// </summary>
+        /// <typeparam name="T">The type of the item.</typeparam>
+        /// <param name="key">The key of the item.</param>
+        /// <returns>The item with the specified key and type, if any, else null.</returns>
+        T Item<T>(string key) where T : class;
+    }
+}

src/Umbraco.Core/Deploy/IFileSource.cs

@@ -0,0 +1,91 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Umbraco.Core.Deploy
+{
+    /// <summary>
+    /// Represents a file source, ie a mean for a target environment involved in a
+    /// deployment to obtain the content of files being deployed.
+    /// </summary>
+    public interface IFileSource
+    {
+        /// <summary>
+        /// Gets the content of a file as a stream.
+        /// </summary>
+        /// <param name="udi">A file entity identifier.</param>
+        /// <returns>A stream with read access to the file content.</returns>
+        /// <remarks>
+        /// <para>Returns null if no content could be read.</para>
+        /// <para>The caller should ensure that the stream is properly closed/disposed.</para>
+        /// </remarks>
+        Stream GetFileStream(StringUdi udi);
+
+        /// <summary>
+        /// Gets the content of a file as a stream.
+        /// </summary>
+        /// <param name="udi">A file entity identifier.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A stream with read access to the file content.</returns>
+        /// <remarks>
+        /// <para>Returns null if no content could be read.</para>
+        /// <para>The caller should ensure that the stream is properly closed/disposed.</para>
+        /// </remarks>
+        Task<Stream> GetFileStreamAsync(StringUdi udi, CancellationToken token);
+
+        /// <summary>
+        /// Gets the content of a file as a string.
+        /// </summary>
+        /// <param name="udi">A file entity identifier.</param>
+        /// <returns>A string containing the file content.</returns>
+        /// <remarks>Returns null if no content could be read.</remarks>
+        string GetFileContent(StringUdi udi);
+
+        /// <summary>
+        /// Gets the content of a file as a string.
+        /// </summary>
+        /// <param name="udi">A file entity identifier.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A string containing the file content.</returns>
+        /// <remarks>Returns null if no content could be read.</remarks>
+        Task<string> GetFileContentAsync(StringUdi udi, CancellationToken token);
+
+        /// <summary>
+        /// Gets the length of a file.
+        /// </summary>
+        /// <param name="udi">A file entity identifier.</param>
+        /// <returns>The length of the file, or -1 if the file does not exist.</returns>
+        long GetFileLength(StringUdi udi);
+
+        /// <summary>
+        /// Gets the length of a file.
+        /// </summary>
+        /// <param name="udi">A file entity identifier.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>The length of the file, or -1 if the file does not exist.</returns>
+        Task<long> GetFileLengthAsync(StringUdi udi, CancellationToken token);
+
+        /// <summary>
+        /// Gets files and store them using a file store.
+        /// </summary>
+        /// <param name="udis">The udis of the files to get.</param>
+        /// <param name="fileTypes">A collection of file types which can store the files.</param>
+        void GetFiles(IEnumerable<StringUdi> udis, IFileTypeCollection fileTypes);
+
+        /// <summary>
+        /// Gets files and store them using a file store.
+        /// </summary>
+        /// <param name="udis">The udis of the files to get.</param>
+        /// <param name="fileTypes">A collection of file types which can store the files.</param>
+        /// <param name="token">A cancellation token.</param>
+        Task GetFilesAsync(IEnumerable<StringUdi> udis, IFileTypeCollection fileTypes, CancellationToken token);
+
+        ///// <summary>
+        ///// Gets the content of a file as a bytes array.
+        ///// </summary>
+        ///// <param name="Udi">A file entity identifier.</param>
+        ///// <returns>A byte array containing the file content.</returns>
+        //byte[] GetFileBytes(StringUdi Udi);
+    }
+}

src/Umbraco.Core/Deploy/IFileType.cs

@@ -0,0 +1,32 @@
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Umbraco.Core.Deploy
+{
+    public interface IFileType
+    {
+        Stream GetStream(StringUdi udi);
+
+        Task<Stream> GetStreamAsync(StringUdi udi, CancellationToken token);
+
+        Stream GetChecksumStream(StringUdi udi);
+
+        long GetLength(StringUdi udi);
+
+        void SetStream(StringUdi udi, Stream stream);
+
+        Task SetStreamAsync(StringUdi udi, Stream stream, CancellationToken token);
+
+        bool CanSetPhysical { get; }
+
+        void Set(StringUdi udi, string physicalPath, bool copy = false);
+
+        // this is not pretty as *everywhere* in Deploy we take care of ignoring
+        // the physical path and always rely on Core's virtual IFileSystem but
+        // Cloud wants to add some of these files to Git and needs the path...
+        string GetPhysicalPath(StringUdi udi);
+
+        string GetVirtualPath(StringUdi udi);
+    }
+}

src/Umbraco.Core/Deploy/IFileTypeCollection.cs

@@ -0,0 +1,9 @@
+namespace Umbraco.Core.Deploy
+{
+    public interface IFileTypeCollection
+    {
+        IFileType this[string entityType] { get; }
+
+        bool Contains(string entityType);
+    }
+}

src/Umbraco.Core/Deploy/IGridCellValueConnector.cs

@@ -0,0 +1,41 @@
+using System.Collections.Generic;
+using Umbraco.Core.Models;
+
+namespace Umbraco.Core.Deploy
+{
+    /// <summary>
+    /// Defines methods that can convert a grid cell value to / from an environment-agnostic string.
+    /// </summary>
+    /// <remarks>Grid cell values may contain values such as content identifiers, that would be local
+    /// to one environment, and need to be converted in order to be deployed.</remarks>
+    public interface IGridCellValueConnector
+    {
+        /// <summary>
+        /// Gets a value indicating whether the connector supports a specified grid editor view.
+        /// </summary>
+        /// <param name="view">The grid editor view. It needs to be the view instead of the alias as the view is really what identifies what kind of connector should be used. Alias can be anything and you can have multiple different aliases using the same kind of view.</param>
+        /// <remarks>A value indicating whether the connector supports the grid editor view.</remarks>
+        /// <remarks>Note that <paramref name="view" /> can be string.Empty to indicate the "default" connector.</remarks>
+        bool IsConnector(string view);
+
+        /// <summary>
+        /// Gets the value to be deployed from the control value as a string.
+        /// </summary>
+        /// <param name="gridControl">The control containing the value.</param>
+        /// <param name="property">The property where the control is located. Do not modify - only used for context</param>
+        /// <param name="dependencies">The dependencies of the property.</param>
+        /// <returns>The grid cell value to be deployed.</returns>
+        /// <remarks>Note that </remarks>
+        string GetValue(GridValue.GridControl gridControl, Property property, ICollection<ArtifactDependency> dependencies);
+
+        /// <summary>
+        /// Allows you to modify the value of a control being deployed.
+        /// </summary>
+        /// <param name="gridControl">The control being deployed.</param>
+        /// <param name="property">The property where the <paramref name="gridControl"/> is located. Do not modify - only used for context.</param>
+        /// <remarks>Follows the pattern of the property value connectors (<see cref="IValueConnector"/>). The SetValue method is used to modify the value of the <paramref name="gridControl"/>.</remarks>
+        /// <remarks>Note that only the <paramref name="gridControl"/> value should be modified - not the <paramref name="property"/>.</remarks>
+        /// <remarks>The <paramref name="property"/> should only be used to assist with context data relevant when setting the <paramref name="gridControl"/> value.</remarks>
+        void SetValue(GridValue.GridControl gridControl, Property property);
+    }
+}

src/Umbraco.Core/Deploy/IImageSourceParser.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Deploy
+{
+    /// <summary>
+    /// Provides methods to parse image tag sources in property values.
+    /// </summary>
+    public interface IImageSourceParser
+    {
+        /// <summary>
+        /// Parses an Umbraco property value and produces an artifact property value.
+        /// </summary>
+        /// <param name="value">The property value.</param>
+        /// <param name="dependencies">A list of dependencies.</param>
+        /// <returns>The parsed value.</returns>
+        /// <remarks>Turns src="/media/..." into src="umb://media/..." and adds the corresponding udi to the dependencies.</remarks>
+        string ToArtifact(string value, ICollection<Udi> dependencies);
+
+        /// <summary>
+        /// Parses an artifact property value and produces an Umbraco property value.
+        /// </summary>
+        /// <param name="value">The artifact property value.</param>
+        /// <returns>The parsed value.</returns>
+        /// <remarks>Turns umb://media/... into /media/....</remarks>
+        string FromArtifact(string value);
+    }
+}

src/Umbraco.Core/Deploy/ILocalLinkParser.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Deploy
+{
+    /// <summary>
+    /// Provides methods to parse local link tags in property values.
+    /// </summary>
+    public interface ILocalLinkParser
+    {
+        /// <summary>
+        /// Parses an Umbraco property value and produces an artifact property value.
+        /// </summary>
+        /// <param name="value">The property value.</param>
+        /// <param name="dependencies">A list of dependencies.</param>
+        /// <returns>The parsed value.</returns>
+        /// <remarks>Turns {{localLink:1234}} into {{localLink:umb://{type}/{id}}} and adds the corresponding udi to the dependencies.</remarks>
+        string ToArtifact(string value, ICollection<Udi> dependencies);
+
+        /// <summary>
+        /// Parses an artifact property value and produces an Umbraco property value.
+        /// </summary>
+        /// <param name="value">The artifact property value.</param>
+        /// <returns>The parsed value.</returns>
+        /// <remarks>Turns {{localLink:umb://{type}/{id}}} into {{localLink:1234}}.</remarks>
+        string FromArtifact(string value);
+    }
+}

src/Umbraco.Core/Deploy/IMacroParser.cs

@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Deploy
+{
+    public interface IMacroParser
+    {
+        /// <summary>
+        /// Parses an Umbraco property value and produces an artifact property value.
+        /// </summary>
+        /// <param name="value">Property value.</param>
+        /// <param name="dependencies">A list of dependencies.</param>
+        /// <returns>Parsed value.</returns>
+        string ToArtifact(string value, ICollection<Udi> dependencies);
+
+        /// <summary>
+        /// Parses an artifact property value and produces an Umbraco property value.
+        /// </summary>
+        /// <param name="value">Artifact property value.</param>
+        /// <returns>Parsed value.</returns>
+        string FromArtifact(string value);
+
+        /// <summary>
+        /// Tries to replace the value of the attribute/parameter with a value containing a converted identifier.
+        /// </summary>
+        /// <param name="value">Value to attempt to convert</param>
+        /// <param name="editorAlias">Alias of the editor used for the parameter</param>
+        /// <param name="dependencies">Collection to add dependencies to when performing ToArtifact</param>
+        /// <param name="direction">Indicates which action is being performed (to or from artifact)</param>
+        /// <returns>Value with converted identifiers</returns>
+        string ReplaceAttributeValue(string value, string editorAlias, ICollection<Udi> dependencies, Direction direction);
+    }
+}

src/Umbraco.Core/Deploy/IPreValueConnector.cs

@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Deploy
+{
+    /// <summary>
+    /// Defines methods that can convert a preValue to / from an environment-agnostic string.
+    /// </summary>
+    /// <remarks>PreValues may contain values such as content identifiers, that would be local
+    /// to one environment, and need to be converted in order to be deployed.</remarks>
+    public interface IPreValueConnector
+    {
+        /// <summary>
+        /// Gets the property editor aliases that the value converter supports by default.
+        /// </summary>
+        IEnumerable<string> PropertyEditorAliases { get; }
+
+        /// <summary>
+        /// Gets the environment-agnostic preValues corresponding to environment-specific preValues.
+        /// </summary>
+        /// <param name="preValues">The environment-specific preValues.</param>
+        /// <param name="dependencies">The dependencies.</param>
+        /// <returns></returns>
+        IDictionary<string, string> ConvertToDeploy(IDictionary<string, string> preValues, ICollection<ArtifactDependency> dependencies);
+
+        /// <summary>
+        /// Gets the environment-specific preValues corresponding to environment-agnostic preValues.
+        /// </summary>
+        /// <param name="preValues">The environment-agnostic preValues.</param>
+        /// <returns></returns>
+        IDictionary<string, string> ConvertToLocalEnvironment(IDictionary<string, string> preValues);
+    }
+}

src/Umbraco.Core/Deploy/IServiceConnector.cs

@@ -0,0 +1,87 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using umbraco.interfaces;
+using Umbraco.Core;
+
+namespace Umbraco.Core.Deploy
+{
+    /// <summary>
+    /// Connects to an Umbraco service.
+    /// </summary>
+    public interface IServiceConnector : IDiscoverable
+    {
+        /// <summary>
+        /// Gets an artifact.
+        /// </summary>
+        /// <param name="udi">The entity identifier of the artifact.</param>
+        /// <returns>The corresponding artifact, or null.</returns>
+        IArtifact GetArtifact(Udi udi);
+
+        /// <summary>
+        /// Gets an artifact.
+        /// </summary>
+        /// <param name="entity">The entity.</param>
+        /// <returns>The corresponding artifact.</returns>
+        IArtifact GetArtifact(object entity);
+
+        /// <summary>
+        /// Initializes processing for an artifact.
+        /// </summary>
+        /// <param name="art">The artifact.</param>
+        /// <param name="context">The deploy context.</param>
+        /// <returns>The mapped artifact.</returns>
+        ArtifactDeployState ProcessInit(IArtifact art, IDeployContext context);
+
+        /// <summary>
+        /// Processes an artifact.
+        /// </summary>
+        /// <param name="dart">The mapped artifact.</param>
+        /// <param name="context">The deploy context.</param>
+        /// <param name="pass">The processing pass number.</param>
+        void Process(ArtifactDeployState dart, IDeployContext context, int pass);
+
+        /// <summary>
+        /// Explodes a range into udis.
+        /// </summary>
+        /// <param name="range">The range.</param>
+        /// <param name="udis">The list of udis where to add the new udis.</param>
+        /// <remarks>Also, it's cool to have a method named Explode. Kaboom!</remarks>
+        void Explode(UdiRange range, List<Udi> udis);
+
+        /// <summary>
+        /// Gets a named range for a specified udi and selector.
+        /// </summary>
+        /// <param name="udi">The udi.</param>
+        /// <param name="selector">The selector.</param>
+        /// <returns>The named range for the specified udi and selector.</returns>
+        NamedUdiRange GetRange(Udi udi, string selector);
+
+        /// <summary>
+        /// Gets a named range for specified entity type, identifier and selector.
+        /// </summary>
+        /// <param name="entityType">The entity type.</param>
+        /// <param name="sid">The identifier.</param>
+        /// <param name="selector">The selector.</param>
+        /// <returns>The named range for the specified entity type, identifier and selector.</returns>
+        /// <remarks>
+        /// <para>This is temporary. At least we thought it would be, in sept. 2016. What day is it now?</para>
+        /// <para>At the moment our UI has a hard time returning proper udis, mainly because Core's tree do
+        /// not manage guids but only ints... so we have to provide a way to support it. The string id here
+        /// can be either a real string (for string udis) or an "integer as a string", using the value "-1" to
+        /// indicate the "root" i.e. an open udi.</para>
+        /// </remarks>
+        NamedUdiRange GetRange(string entityType, string sid, string selector);
+
+        /// <summary>
+        /// Compares two artifacts.
+        /// </summary>
+        /// <param name="art1">The first artifact.</param>
+        /// <param name="art2">The second artifact.</param>
+        /// <param name="differences">A collection of differences to append to, if not null.</param>
+        /// <returns>A boolean value indicating whether the artifacts are identical.</returns>
+        /// <remarks>ServiceConnectorBase{TArtifact} provides a very basic default implementation.</remarks>
+        bool Compare(IArtifact art1, IArtifact art2, ICollection<Difference> differences = null);
+    }
+
+}

src/Umbraco.Core/Deploy/IValueConnector.cs

@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using Umbraco.Core.Models;
+
+namespace Umbraco.Core.Deploy
+{
+    /// <summary>
+    /// Defines methods that can convert a property value to / from an environment-agnostic string.
+    /// </summary>
+    /// <remarks>Property values may contain values such as content identifiers, that would be local
+    /// to one environment, and need to be converted in order to be deployed. Connectors also deal
+    /// with serializing to / from string.</remarks>
+    public interface IValueConnector
+    {
+        /// <summary>
+        /// Gets the property editor aliases that the value converter supports by default.
+        /// </summary>
+        IEnumerable<string> PropertyEditorAliases { get; }
+
+        /// <summary>
+        /// Gets the deploy property corresponding to a content property.
+        /// </summary>
+        /// <param name="property">The content property.</param>
+        /// <param name="dependencies">The content dependencies.</param>
+        /// <returns>The deploy property value.</returns>
+        string GetValue(Property property, ICollection<ArtifactDependency> dependencies);
+
+        /// <summary>
+        /// Sets a content property value using a deploy property.
+        /// </summary>
+        /// <param name="content">The content item.</param>
+        /// <param name="alias">The property alias.</param>
+        /// <param name="value">The deploy property value.</param>
+        void SetValue(IContentBase content, string alias, string value);
+    }
+}

src/Umbraco.Core/Diagnostics/MiniDump.cs

@@ -0,0 +1,135 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.InteropServices;
+using Umbraco.Core.IO;
+
+namespace Umbraco.Core.Diagnostics
+{
+    // taken from https://blogs.msdn.microsoft.com/dondu/2010/10/24/writing-minidumps-in-c/
+    // and https://blogs.msdn.microsoft.com/dondu/2010/10/31/writing-minidumps-from-exceptions-in-c/
+    // which itself got it from http://blog.kalmbach-software.de/2008/12/13/writing-minidumps-in-c/
+
+    internal static class MiniDump
+    {
+        private static readonly object LockO = new object();
+
+        [Flags]
+        public enum Option : uint
+        {
+            // From dbghelp.h:
+            Normal = 0x00000000,
+            WithDataSegs = 0x00000001,
+            WithFullMemory = 0x00000002,
+            WithHandleData = 0x00000004,
+            FilterMemory = 0x00000008,
+            ScanMemory = 0x00000010,
+            WithUnloadedModules = 0x00000020,
+            WithIndirectlyReferencedMemory = 0x00000040,
+            FilterModulePaths = 0x00000080,
+            WithProcessThreadData = 0x00000100,
+            WithPrivateReadWriteMemory = 0x00000200,
+            WithoutOptionalData = 0x00000400,
+            WithFullMemoryInfo = 0x00000800,
+            WithThreadInfo = 0x00001000,
+            WithCodeSegs = 0x00002000,
+            WithoutAuxiliaryState = 0x00004000,
+            WithFullAuxiliaryState = 0x00008000,
+            WithPrivateWriteCopyMemory = 0x00010000,
+            IgnoreInaccessibleMemory = 0x00020000,
+            ValidTypeFlags = 0x0003ffff,
+        }
+
+        //typedef struct _MINIDUMP_EXCEPTION_INFORMATION {
+        //    DWORD ThreadId;
+        //    PEXCEPTION_POINTERS ExceptionPointers;
+        //    BOOL ClientPointers;
+        //} MINIDUMP_EXCEPTION_INFORMATION, *PMINIDUMP_EXCEPTION_INFORMATION;
+        [StructLayout(LayoutKind.Sequential, Pack = 4)]  // Pack=4 is important! So it works also for x64!
+        public struct MiniDumpExceptionInformation
+        {
+            public uint ThreadId;
+            public IntPtr ExceptionPointers;
+            [MarshalAs(UnmanagedType.Bool)]
+            public bool ClientPointers;
+        }
+
+        //BOOL
+        //WINAPI
+        //MiniDumpWriteDump(
+        //    __in HANDLE hProcess,
+        //    __in DWORD ProcessId,
+        //    __in HANDLE hFile,
+        //    __in MINIDUMP_TYPE DumpType,
+        //    __in_opt PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
+        //    __in_opt PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
+        //    __in_opt PMINIDUMP_CALLBACK_INFORMATION CallbackParam
+        //    );
+
+        // Overload requiring MiniDumpExceptionInformation
+        [DllImport("dbghelp.dll", EntryPoint = "MiniDumpWriteDump", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true)]
+        private static extern bool MiniDumpWriteDump(IntPtr hProcess, uint processId, SafeHandle hFile, uint dumpType, ref MiniDumpExceptionInformation expParam, IntPtr userStreamParam, IntPtr callbackParam);
+
+        // Overload supporting MiniDumpExceptionInformation == NULL
+        [DllImport("dbghelp.dll", EntryPoint = "MiniDumpWriteDump", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true)]
+        private static extern bool MiniDumpWriteDump(IntPtr hProcess, uint processId, SafeHandle hFile, uint dumpType, IntPtr expParam, IntPtr userStreamParam, IntPtr callbackParam);
+
+        [DllImport("kernel32.dll", EntryPoint = "GetCurrentThreadId", ExactSpelling = true)]
+        private static extern uint GetCurrentThreadId();
+
+        private static bool Write(SafeHandle fileHandle, Option options, bool withException = false)
+        {
+            var currentProcess = Process.GetCurrentProcess();
+            var currentProcessHandle = currentProcess.Handle;
+            var currentProcessId = (uint)currentProcess.Id;
+
+            MiniDumpExceptionInformation exp;
+
+            exp.ThreadId = GetCurrentThreadId();
+            exp.ClientPointers = false;
+            exp.ExceptionPointers = IntPtr.Zero;
+
+            if (withException)
+                exp.ExceptionPointers = Marshal.GetExceptionPointers();
+
+            var bRet = exp.ExceptionPointers == IntPtr.Zero
+                ? MiniDumpWriteDump(currentProcessHandle, currentProcessId, fileHandle, (uint) options, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero)
+                : MiniDumpWriteDump(currentProcessHandle, currentProcessId, fileHandle, (uint) options, ref exp, IntPtr.Zero, IntPtr.Zero);
+
+            return bRet;
+        }
+
+        public static bool Dump(Option options = Option.WithFullMemory, bool withException = false)
+        {
+            lock (LockO)
+            {
+                // work around "stack trace is not available while minidump debugging",
+                // by making sure a local var (that we can inspect) contains the stack trace.
+                // getting the call stack before it is unwound would require a special exception
+                // filter everywhere in our code = not!
+                var stacktrace = withException ? Environment.StackTrace : string.Empty;
+
+                var filepath = IOHelper.MapPath("~/App_Data/MiniDump");
+                if (Directory.Exists(filepath) == false)
+                    Directory.CreateDirectory(filepath);
+
+                var filename = Path.Combine(filepath, string.Format("{0:yyyyMMddTHHmmss}.{1}.dmp", DateTime.UtcNow, Guid.NewGuid().ToString("N").Substring(0, 4)));
+                using (var stream = new FileStream(filename, FileMode.Create, FileAccess.ReadWrite, FileShare.Write))
+                {
+                    return Write(stream.SafeFileHandle, options, withException);
+                }
+            }
+        }
+
+        public static bool OkToDump()
+        {
+            lock (LockO)
+            {
+                var filepath = IOHelper.MapPath("~/App_Data/MiniDump");
+                if (Directory.Exists(filepath) == false) return true;
+                var count = Directory.GetFiles(filepath, "*.dmp").Length;
+                return count < 8;
+            }
+        }
+    }
+}

src/Umbraco.Core/EnumerableExtensions.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Text;
@@ -67,22 +68,15 @@ namespace Umbraco.Core
             }
         }
 
-        /// <summary>The for each.</summary>
-        /// <param name="items">The items.</param>
-        /// <param name="func">The func.</param>
-        /// <typeparam name="TItem">item type</typeparam>
-        /// <typeparam name="TResult">Result type</typeparam>
-        /// <returns>the Results</returns>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        [Obsolete("Use a normal foreach loop instead, this adds more allocations than necessary")]
         public static TResult[] ForEach<TItem, TResult>(this IEnumerable<TItem> items, Func<TItem, TResult> func)
         {
             return items.Select(func).ToArray();
         }
 
-        /// <summary>The for each.</summary>
-        /// <param name="items">The items.</param>
-        /// <param name="action">The action.</param>
-        /// <typeparam name="TItem">Item type</typeparam>
-        /// <returns>list of TItem</returns>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        [Obsolete("Use a normal foreach loop instead, this adds more allocations than necessary")]
         public static IEnumerable<TItem> ForEach<TItem>(this IEnumerable<TItem> items, Action<TItem> action)
         {
             if (items != null)
@@ -101,6 +95,7 @@ namespace Umbraco.Core
         /// <param name="f">The select child.</param>
         /// <typeparam name="T">Item type</typeparam>
         /// <returns>list of TItem</returns>
+        [EditorBrowsable(EditorBrowsableState.Never)]
         [Obsolete("Do not use, use SelectRecursive instead which has far less potential of re-iterating an iterator which may cause significantly more SQL queries")]
         public static IEnumerable<T> FlattenList<T>(this IEnumerable<T> e, Func<T, IEnumerable<T>> f)
         {
@@ -300,6 +295,5 @@ namespace Umbraco.Core
             return list1Groups.Count == list2Groups.Count
                && list1Groups.All(g => g.Count() == list2Groups[g.Key].Count());
         }
-
     }
 }

src/Umbraco.Core/Events/CancellableEventArgs.cs

@@ -10,8 +10,8 @@ namespace Umbraco.Core.Events
 	/// Event args for that can support cancellation
 	/// </summary>
 	[HostProtection(SecurityAction.LinkDemand, SharedState = true)]
-	public class CancellableEventArgs : EventArgs
-	{
+	public class CancellableEventArgs : EventArgs, IEquatable<CancellableEventArgs>
+    {
 		private bool _cancel;
 
         public CancellableEventArgs(bool canCancel, EventMessages messages, IDictionary<string, object> additionalData)
@@ -98,6 +98,36 @@ namespace Umbraco.Core.Events
         /// This allows for a bit of flexibility in our event raising - it's not pretty but we need to maintain backwards compatibility 
         /// so we cannot change the strongly typed nature for some events.
         /// </remarks>
-        public ReadOnlyDictionary<string, object> AdditionalData { get; private set; } 
-    }
+        public ReadOnlyDictionary<string, object> AdditionalData { get; private set; }
+
+	    public bool Equals(CancellableEventArgs other)
+	    {
+	        if (ReferenceEquals(null, other)) return false;
+	        if (ReferenceEquals(this, other)) return true;
+	        return Equals(AdditionalData, other.AdditionalData);
+	    }
+
+	    public override bool Equals(object obj)
+	    {
+	        if (ReferenceEquals(null, obj)) return false;
+	        if (ReferenceEquals(this, obj)) return true;
+	        if (obj.GetType() != this.GetType()) return false;
+	        return Equals((CancellableEventArgs) obj);
+	    }
+
+	    public override int GetHashCode()
+	    {
+	        return (AdditionalData != null ? AdditionalData.GetHashCode() : 0);
+	    }
+
+	    public static bool operator ==(CancellableEventArgs left, CancellableEventArgs right)
+	    {
+	        return Equals(left, right);
+	    }
+
+	    public static bool operator !=(CancellableEventArgs left, CancellableEventArgs right)
+	    {
+	        return !Equals(left, right);
+	    }
+	}
 }

src/Umbraco.Core/Events/CancellableObjectEventArgs.cs

@@ -1,52 +1,177 @@
+using System;
+using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 using System.Security.Permissions;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.EntityBase;
 
 namespace Umbraco.Core.Events
 {
-	/// <summary>
-	/// Event args for a strongly typed object that can support cancellation
-	/// </summary>
-	/// <typeparam name="T"></typeparam>
-	[HostProtection(SecurityAction.LinkDemand, SharedState = true)]
-	public class CancellableObjectEventArgs<T> : CancellableEventArgs
-	{
-	    public CancellableObjectEventArgs(T eventObject, bool canCancel, EventMessages messages, IDictionary<string, object> additionalData)
+    /// <summary>
+    /// Used as a base class for the generic type CancellableObjectEventArgs{T} so that we can get direct 'object' access to the underlying EventObject
+    /// </summary>
+    [HostProtection(SecurityAction.LinkDemand, SharedState = true)]
+    public abstract class CancellableObjectEventArgs : CancellableEventArgs
+    {
+        protected CancellableObjectEventArgs(object eventObject, bool canCancel, EventMessages messages, IDictionary<string, object> additionalData)
             : base(canCancel, messages, additionalData)
-	    {
+        {
             EventObject = eventObject;
         }
 
-	    public CancellableObjectEventArgs(T eventObject, bool canCancel, EventMessages eventMessages)
+        protected CancellableObjectEventArgs(object eventObject, bool canCancel, EventMessages eventMessages)
             : base(canCancel, eventMessages)
         {
             EventObject = eventObject;
         }
 
-        public CancellableObjectEventArgs(T eventObject, EventMessages eventMessages)
+        protected CancellableObjectEventArgs(object eventObject, EventMessages eventMessages)
             : this(eventObject, true, eventMessages)
         {
         }
 
+        protected CancellableObjectEventArgs(object eventObject, bool canCancel)
+            : base(canCancel)
+        {
+            EventObject = eventObject;
+        }
+
+        protected CancellableObjectEventArgs(object eventObject)
+            : this(eventObject, true)
+        {
+        }
+
+        /// <summary>
+        /// Returns the object relating to the event
+        /// </summary>
+        /// <remarks>
+        /// This is protected so that inheritors can expose it with their own name
+        /// </remarks>
+        internal object EventObject { get; set; }
+
+    }
+
+    /// <summary>
+    /// Event args for a strongly typed object that can support cancellation
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    [HostProtection(SecurityAction.LinkDemand, SharedState = true)]
+    public class CancellableObjectEventArgs<T> : CancellableObjectEventArgs, IEquatable<CancellableObjectEventArgs<T>>
+    {
+        public CancellableObjectEventArgs(T eventObject, bool canCancel, EventMessages messages, IDictionary<string, object> additionalData)
+            : base(eventObject, canCancel, messages, additionalData)
+        {
+        }
+
+        public CancellableObjectEventArgs(T eventObject, bool canCancel, EventMessages eventMessages)
+            : base(eventObject, canCancel, eventMessages)
+        {
+        }
+
+        public CancellableObjectEventArgs(T eventObject, EventMessages eventMessages)
+            : base(eventObject, eventMessages)
+        {
+        }
+
         public CancellableObjectEventArgs(T eventObject, bool canCancel)
-			: base(canCancel)
-		{
-			EventObject = eventObject;
-		}
+            : base(eventObject, canCancel)
+        {
+        }
 
-		public CancellableObjectEventArgs(T eventObject)
-			: this(eventObject, true)
-		{
-		}
+        public CancellableObjectEventArgs(T eventObject)
+            : base(eventObject)
+        {
+        }
 
-		/// <summary>
-		/// Returns the object relating to the event
-		/// </summary>
-		/// <remarks>
-		/// This is protected so that inheritors can expose it with their own name
-		/// </remarks>
-		protected T EventObject { get; set; }
+        /// <summary>
+        /// Returns the object relating to the event
+        /// </summary>
+        /// <remarks>
+        /// This is protected so that inheritors can expose it with their own name
+        /// </remarks>
+        protected new T EventObject
+        {
+            get { return (T) base.EventObject; }
+            set { base.EventObject = value; }
+        }
 
-	}
+        public bool Equals(CancellableObjectEventArgs<T> other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            return base.Equals(other) && EqualityComparer<T>.Default.Equals(EventObject, other.EventObject);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((CancellableObjectEventArgs<T>)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return (base.GetHashCode() * 397) ^ EqualityComparer<T>.Default.GetHashCode(EventObject);
+            }
+        }
+
+        public static bool operator ==(CancellableObjectEventArgs<T> left, CancellableObjectEventArgs<T> right)
+        {
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(CancellableObjectEventArgs<T> left, CancellableObjectEventArgs<T> right)
+        {
+            return !Equals(left, right);
+        }
+    }
+
+    [HostProtection(SecurityAction.LinkDemand, SharedState = true)]
+    public class CancellableEnumerableObjectEventArgs<T> : CancellableObjectEventArgs<IEnumerable<T>>, IEquatable<CancellableEnumerableObjectEventArgs<T>>
+    {
+        public CancellableEnumerableObjectEventArgs(IEnumerable<T> eventObject, bool canCancel, EventMessages messages, IDictionary<string, object> additionalData)
+            : base(eventObject, canCancel, messages, additionalData)
+        { }
+
+        public CancellableEnumerableObjectEventArgs(IEnumerable<T> eventObject, bool canCancel, EventMessages eventMessages)
+            : base(eventObject, canCancel, eventMessages)
+        { }
+
+        public CancellableEnumerableObjectEventArgs(IEnumerable<T> eventObject, EventMessages eventMessages)
+            : base(eventObject, eventMessages)
+        { }
+
+        public CancellableEnumerableObjectEventArgs(IEnumerable<T> eventObject, bool canCancel)
+            : base(eventObject, canCancel)
+        { }
+
+        public CancellableEnumerableObjectEventArgs(IEnumerable<T> eventObject)
+            : base(eventObject)
+        { }
+
+        public bool Equals(CancellableEnumerableObjectEventArgs<T> other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+
+            return EventObject.SequenceEqual(other.EventObject);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((CancellableEnumerableObjectEventArgs<T>)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCodeHelper.GetHashCode(EventObject);
+        }
+    }
 }

src/Umbraco.Core/Events/CopyEventArgs.cs

@@ -1,6 +1,9 @@
+using System;
+using System.Collections.Generic;
+
 namespace Umbraco.Core.Events
 {
-    public class CopyEventArgs<TEntity> : CancellableObjectEventArgs<TEntity>
+    public class CopyEventArgs<TEntity> : CancellableObjectEventArgs<TEntity>, IEquatable<CopyEventArgs<TEntity>>
     {
         public CopyEventArgs(TEntity original, TEntity copy, bool canCancel, int parentId)
             : base(original, canCancel)
@@ -43,5 +46,42 @@ namespace Umbraco.Core.Events
         public int ParentId { get; private set; }
 
         public bool RelateToOriginal { get; set; }
+
+        public bool Equals(CopyEventArgs<TEntity> other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            return base.Equals(other) && EqualityComparer<TEntity>.Default.Equals(Copy, other.Copy) && ParentId == other.ParentId && RelateToOriginal == other.RelateToOriginal;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((CopyEventArgs<TEntity>) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hashCode = base.GetHashCode();
+                hashCode = (hashCode * 397) ^ EqualityComparer<TEntity>.Default.GetHashCode(Copy);
+                hashCode = (hashCode * 397) ^ ParentId;
+                hashCode = (hashCode * 397) ^ RelateToOriginal.GetHashCode();
+                return hashCode;
+            }
+        }
+
+        public static bool operator ==(CopyEventArgs<TEntity> left, CopyEventArgs<TEntity> right)
+        {
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(CopyEventArgs<TEntity> left, CopyEventArgs<TEntity> right)
+        {
+            return !Equals(left, right);
+        }
     }
 }

src/Umbraco.Core/Events/DeleteEventArgs.cs

@@ -1,8 +1,14 @@
+using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Umbraco.Core.Events
 {
-	public class DeleteEventArgs<TEntity> : CancellableObjectEventArgs<IEnumerable<TEntity>>
+    [SupersedeEvent(typeof(SaveEventArgs<>))]
+    [SupersedeEvent(typeof(PublishEventArgs<>))]
+    [SupersedeEvent(typeof(MoveEventArgs<>))]
+    [SupersedeEvent(typeof(CopyEventArgs<>))]
+    public class DeleteEventArgs<TEntity> : CancellableEnumerableObjectEventArgs<TEntity>, IEquatable<DeleteEventArgs<TEntity>>, IDeletingMediaFilesEventArgs
 	{
 	    /// <summary>
 	    /// Constructor accepting multiple entities that are used in the delete operation
@@ -99,10 +105,43 @@ namespace Umbraco.Core.Events
         /// <summary>
         /// A list of media files that can be added to during a deleted operation for which Umbraco will ensure are removed
         /// </summary>
-        public List<string> MediaFilesToDelete { get; private set; } 
+        public List<string> MediaFilesToDelete { get; private set; }
+
+	    public bool Equals(DeleteEventArgs<TEntity> other)
+	    {
+	        if (ReferenceEquals(null, other)) return false;
+	        if (ReferenceEquals(this, other)) return true;
+	        return base.Equals(other) && MediaFilesToDelete.SequenceEqual(other.MediaFilesToDelete);
+	    }
+
+	    public override bool Equals(object obj)
+	    {
+	        if (ReferenceEquals(null, obj)) return false;
+	        if (ReferenceEquals(this, obj)) return true;
+	        if (obj.GetType() != this.GetType()) return false;
+	        return Equals((DeleteEventArgs<TEntity>) obj);
+	    }
+
+	    public override int GetHashCode()
+	    {
+	        unchecked
+	        {
+	            return (base.GetHashCode() * 397) ^ MediaFilesToDelete.GetHashCode();
+	        }
+	    }
+
+	    public static bool operator ==(DeleteEventArgs<TEntity> left, DeleteEventArgs<TEntity> right)
+	    {
+	        return Equals(left, right);
+	    }
+
+	    public static bool operator !=(DeleteEventArgs<TEntity> left, DeleteEventArgs<TEntity> right)
+	    {
+	        return !Equals(left, right);
+	    }
 	}
 
-	public class DeleteEventArgs : CancellableEventArgs
+	public class DeleteEventArgs : CancellableEventArgs, IEquatable<DeleteEventArgs>
 	{
         public DeleteEventArgs(int id, bool canCancel, EventMessages eventMessages)
             : base(canCancel, eventMessages)
@@ -125,5 +164,38 @@ namespace Umbraco.Core.Events
 		/// Gets the Id of the object being deleted.
 		/// </summary>
 		public int Id { get; private set; }
+
+	    public bool Equals(DeleteEventArgs other)
+	    {
+	        if (ReferenceEquals(null, other)) return false;
+	        if (ReferenceEquals(this, other)) return true;
+	        return base.Equals(other) && Id == other.Id;
+	    }
+
+	    public override bool Equals(object obj)
+	    {
+	        if (ReferenceEquals(null, obj)) return false;
+	        if (ReferenceEquals(this, obj)) return true;
+	        if (obj.GetType() != this.GetType()) return false;
+	        return Equals((DeleteEventArgs) obj);
+	    }
+
+	    public override int GetHashCode()
+	    {
+	        unchecked
+	        {
+	            return (base.GetHashCode() * 397) ^ Id;
+	        }
+	    }
+
+	    public static bool operator ==(DeleteEventArgs left, DeleteEventArgs right)
+	    {
+	        return Equals(left, right);
+	    }
+
+	    public static bool operator !=(DeleteEventArgs left, DeleteEventArgs right)
+	    {
+	        return !Equals(left, right);
+	    }
 	}
 }

src/Umbraco.Core/Events/DeleteRevisionsEventArgs.cs

@@ -2,7 +2,7 @@ using System;
 
 namespace Umbraco.Core.Events
 {
-	public class DeleteRevisionsEventArgs : DeleteEventArgs
+	public class DeleteRevisionsEventArgs : DeleteEventArgs, IEquatable<DeleteRevisionsEventArgs>
 	{
 		public DeleteRevisionsEventArgs(int id, bool canCancel, Guid specificVersion = default(Guid), bool deletePriorVersions = false, DateTime dateToRetain = default(DateTime))
 			: base(id, canCancel)
@@ -31,5 +31,42 @@ namespace Umbraco.Core.Events
 		{
 			get { return SpecificVersion != default(Guid); }
 		}
+
+	    public bool Equals(DeleteRevisionsEventArgs other)
+	    {
+	        if (ReferenceEquals(null, other)) return false;
+	        if (ReferenceEquals(this, other)) return true;
+	        return base.Equals(other) && DateToRetain.Equals(other.DateToRetain) && DeletePriorVersions == other.DeletePriorVersions && SpecificVersion.Equals(other.SpecificVersion);
+	    }
+
+	    public override bool Equals(object obj)
+	    {
+	        if (ReferenceEquals(null, obj)) return false;
+	        if (ReferenceEquals(this, obj)) return true;
+	        if (obj.GetType() != this.GetType()) return false;
+	        return Equals((DeleteRevisionsEventArgs) obj);
+	    }
+
+	    public override int GetHashCode()
+	    {
+	        unchecked
+	        {
+	            int hashCode = base.GetHashCode();
+	            hashCode = (hashCode * 397) ^ DateToRetain.GetHashCode();
+	            hashCode = (hashCode * 397) ^ DeletePriorVersions.GetHashCode();
+	            hashCode = (hashCode * 397) ^ SpecificVersion.GetHashCode();
+	            return hashCode;
+	        }
+	    }
+
+	    public static bool operator ==(DeleteRevisionsEventArgs left, DeleteRevisionsEventArgs right)
+	    {
+	        return Equals(left, right);
+	    }
+
+	    public static bool operator !=(DeleteRevisionsEventArgs left, DeleteRevisionsEventArgs right)
+	    {
+	        return !Equals(left, right);
+	    }
 	}
 }

src/Umbraco.Core/Events/EventDefinition.cs

@@ -0,0 +1,73 @@
+using System;
+
+namespace Umbraco.Core.Events
+{
+    internal class EventDefinition : EventDefinitionBase
+    {
+        private readonly EventHandler _trackedEvent;
+        private readonly object _sender;
+        private readonly EventArgs _args;
+
+        public EventDefinition(EventHandler trackedEvent, object sender, EventArgs args, string eventName = null)
+            : base(sender, args, eventName)
+        {
+            _trackedEvent = trackedEvent;
+            _sender = sender;
+            _args = args;
+        }
+
+        public override void RaiseEvent()
+        {
+            if (_trackedEvent != null)
+            {
+                _trackedEvent(_sender, _args);
+            }
+        }
+    }
+
+    internal class EventDefinition<TEventArgs> : EventDefinitionBase
+    {
+        private readonly EventHandler<TEventArgs> _trackedEvent;
+        private readonly object _sender;
+        private readonly TEventArgs _args;
+
+        public EventDefinition(EventHandler<TEventArgs> trackedEvent, object sender, TEventArgs args, string eventName = null)
+            : base(sender, args, eventName)
+        {
+            _trackedEvent = trackedEvent;
+            _sender = sender;
+            _args = args;
+        }
+
+        public override void RaiseEvent()
+        {
+            if (_trackedEvent != null)
+            {
+                _trackedEvent(_sender, _args);
+            }
+        }
+    }
+
+    internal class EventDefinition<TSender, TEventArgs> : EventDefinitionBase
+    {
+        private readonly TypedEventHandler<TSender, TEventArgs> _trackedEvent;
+        private readonly TSender _sender;
+        private readonly TEventArgs _args;
+
+        public EventDefinition(TypedEventHandler<TSender, TEventArgs> trackedEvent, TSender sender, TEventArgs args, string eventName = null) 
+            : base(sender, args, eventName)
+        {
+            _trackedEvent = trackedEvent;
+            _sender = sender;
+            _args = args;
+        }
+
+        public override void RaiseEvent()
+        {
+            if (_trackedEvent != null)
+            {
+                _trackedEvent(_sender, _args);
+            }
+        }
+    }
+}

src/Umbraco.Core/Events/EventDefinitionBase.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Reflection;
+
+namespace Umbraco.Core.Events
+{
+    public abstract class EventDefinitionBase : IEventDefinition, IEquatable<EventDefinitionBase>
+    {
+        protected EventDefinitionBase(object sender, object args, string eventName = null)
+        {
+            if (sender == null) throw new ArgumentNullException("sender");
+            if (args == null) throw new ArgumentNullException("args");
+            Sender = sender;
+            Args = args;
+            EventName = eventName;
+
+            if (EventName.IsNullOrWhiteSpace())
+            {
+                var findResult = EventNameExtractor.FindEvent(sender, args, 
+                    //don't match "Ing" suffixed names
+                    exclude:EventNameExtractor.MatchIngNames);
+
+                if (findResult.Success == false)
+                    throw new AmbiguousMatchException("Could not automatically find the event name, the event name will need to be explicitly registered for this event definition. Error: " + findResult.Result.Error);
+                EventName = findResult.Result.Name;
+            }
+        }
+
+        public object Sender { get; private set; }
+        public object Args { get; private set; }
+        public string EventName { get; private set; }
+        
+        public abstract void RaiseEvent();
+
+        public bool Equals(EventDefinitionBase other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            return Args.Equals(other.Args) && string.Equals(EventName, other.EventName) && Sender.Equals(other.Sender);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((EventDefinitionBase) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = Args.GetHashCode();
+                hashCode = (hashCode * 397) ^ EventName.GetHashCode();
+                hashCode = (hashCode * 397) ^ Sender.GetHashCode();
+                return hashCode;
+            }
+        }
+
+        public static bool operator ==(EventDefinitionBase left, EventDefinitionBase right)
+        {
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(EventDefinitionBase left, EventDefinitionBase right)
+        {
+            return Equals(left, right) == false;
+        }
+    }
+}

src/Umbraco.Core/Events/EventDefinitionFilter.cs

@@ -0,0 +1,24 @@
+namespace Umbraco.Core.Events
+{
+    /// <summary>
+    /// The filter used in the <see cref="IEventDispatcher"/> GetEvents method which determines
+    /// how the result list is filtered
+    /// </summary>
+    public enum EventDefinitionFilter
+    {
+        /// <summary>
+        /// Returns all events tracked
+        /// </summary>
+        All,
+
+        /// <summary>
+        /// Deduplicates events and only returns the first duplicate instance tracked
+        /// </summary>
+        FirstIn,
+
+        /// <summary>
+        /// Deduplicates events and only returns the last duplicate instance tracked
+        /// </summary>
+        LastIn
+    }
+}

src/Umbraco.Core/Events/EventExtensions.cs

@@ -1,6 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using Umbraco.Core.Persistence.UnitOfWork;
 
 namespace Umbraco.Core.Events
 {
@@ -9,43 +12,40 @@ namespace Umbraco.Core.Events
 	/// </summary>
 	public static class EventExtensions
 	{
-        /// <summary>
-        /// Raises the event and returns a boolean value indicating if the event was cancelled
-        /// </summary>
-        /// <typeparam name="TSender"></typeparam>
-        /// <typeparam name="TArgs"></typeparam>
-        /// <param name="eventHandler"></param>
-        /// <param name="args"></param>
-        /// <param name="sender"></param>
-        /// <returns></returns>
-        public static bool IsRaisedEventCancelled<TSender, TArgs>(
-			this TypedEventHandler<TSender, TArgs> eventHandler,
-			TArgs args,
-			TSender sender)
-			where TArgs : CancellableEventArgs
-		{
-			if (eventHandler != null)
-				eventHandler(sender, args);
+        // keep these two for backward compatibility reasons but understand that
+        // they are *not* part of any scope / event dispatcher / anything...
 
+        /// <summary>
+        /// Raises a cancelable event and returns a value indicating whether the event should be cancelled.
+        /// </summary>
+        /// <typeparam name="TSender">The type of the event source.</typeparam>
+        /// <typeparam name="TArgs">The type of the event data.</typeparam>
+        /// <param name="eventHandler">The event handler.</param>
+        /// <param name="args">The event source.</param>
+        /// <param name="sender">The event data.</param>
+        /// <returns>A value indicating whether the cancelable event should be cancelled</returns>
+        /// <remarks>A cancelable event is raised by a component when it is about to perform an action that can be canceled.</remarks>
+        public static bool IsRaisedEventCancelled<TSender, TArgs>(this TypedEventHandler<TSender, TArgs> eventHandler, TArgs args, TSender sender)
+			where TArgs : CancellableEventArgs
+        {
+            if (eventHandler == null) return args.Cancel;
+			eventHandler(sender, args);
 			return args.Cancel;
 		}
-        
+
         /// <summary>
-        /// Raises the event
+        /// Raises an event.
         /// </summary>
-        /// <typeparam name="TSender"></typeparam>
-        /// <typeparam name="TArgs"></typeparam>
-        /// <param name="eventHandler"></param>
-        /// <param name="args"></param>
-        /// <param name="sender"></param>
-        public static void RaiseEvent<TSender, TArgs>(
-			this TypedEventHandler<TSender, TArgs> eventHandler,
-			TArgs args,
-			TSender sender)
-			where TArgs : EventArgs
-		{
-			if (eventHandler != null)
-				eventHandler(sender, args);
-		}
-	}
+        /// <typeparam name="TSender">The type of the event source.</typeparam>
+        /// <typeparam name="TArgs">The type of the event data.</typeparam>
+        /// <param name="eventHandler">The event handler.</param>
+        /// <param name="args">The event source.</param>
+        /// <param name="sender">The event data.</param>
+        public static void RaiseEvent<TSender, TArgs>(this TypedEventHandler<TSender, TArgs> eventHandler, TArgs args, TSender sender)
+            where TArgs : EventArgs
+        {
+            if (eventHandler == null) return;
+            eventHandler(sender, args);
+        }
+    }
 }

src/Umbraco.Core/Events/EventNameExtractor.cs

@@ -0,0 +1,159 @@
+using System;
+using System.Collections.Concurrent;
+using System.Linq;
+using System.Reflection;
+using System.Text.RegularExpressions;
+
+namespace Umbraco.Core.Events
+{
+    /// <summary>
+    /// There is actually no way to discover an event name in c# at the time of raising the event. It is possible 
+    /// to get the event name from the handler that is being executed based on the event being raised, however that is not 
+    /// what we want in this case. We need to find the event name before it is being raised - you would think that it's possible
+    /// with reflection or anything but that is not the case, the delegate that defines an event has no info attached to it, it
+    /// is literally just an event.
+    /// 
+    /// So what this does is take the sender and event args objects, looks up all public/static events on the sender that have
+    /// a generic event handler with generic arguments (but only) one, then we match the type of event arguments with the ones
+    /// being passed in. As it turns out, in our services this will work for the majority of our events! In some cases it may not
+    /// work and we'll have to supply a string but hopefully this saves a bit of magic strings. 
+    /// 
+    /// We can also write tests to validate these are all working correctly for all services.
+    /// </summary>
+    internal class EventNameExtractor
+    {
+
+        /// <summary>
+        /// Finds the event name on the sender that matches the args type
+        /// </summary>
+        /// <param name="senderType"></param>
+        /// <param name="argsType"></param>
+        /// <param name="exclude">
+        /// A filter to exclude matched event names, this filter should return true to exclude the event name from being matched
+        /// </param>
+        /// <returns>
+        /// null if not found or an ambiguous match
+        /// </returns>
+        public static Attempt<EventNameExtractorResult> FindEvent(Type senderType, Type argsType, Func<string, bool> exclude)
+        {   
+            var found = MatchedEventNames.GetOrAdd(new Tuple<Type, Type>(senderType, argsType), tuple =>
+            {
+                var events = CandidateEvents.GetOrAdd(senderType, t =>
+                {
+                    return t.GetEvents(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
+                        //we can only look for events handlers with generic types because that is the only
+                        // way that we can try to find a matching event based on the arg type passed in
+                        .Where(x => x.EventHandlerType.IsGenericType)
+                        .Select(x => new EventInfoArgs(x, x.EventHandlerType.GetGenericArguments()))
+                        //we are only looking for event handlers that have more than one generic argument
+                        .Where(x =>
+                        {
+                            if (x.GenericArgs.Length == 1) return true;
+
+                            //special case for our own TypedEventHandler
+                            if (x.EventInfo.EventHandlerType.GetGenericTypeDefinition() == typeof(TypedEventHandler<,>) && x.GenericArgs.Length == 2)
+                            {
+                                return true;
+                            }
+
+                            return false;
+                        })
+                        .ToArray();
+                });
+
+                return events.Where(x =>
+                {
+                    if (x.GenericArgs.Length == 1 && x.GenericArgs[0] == tuple.Item2)
+                        return true;
+
+                    //special case for our own TypedEventHandler
+                    if (x.EventInfo.EventHandlerType.GetGenericTypeDefinition() == typeof(TypedEventHandler<,>)
+                        && x.GenericArgs.Length == 2
+                        && x.GenericArgs[1] == tuple.Item2)
+                    {
+                        return true;
+                    }
+
+                    return false;
+                }).Select(x => x.EventInfo.Name).ToArray();
+            });
+
+            var filtered = found.Where(x => exclude(x) == false).ToArray();
+
+            if (filtered.Length == 0)
+                return Attempt.Fail(new EventNameExtractorResult(EventNameExtractorError.NoneFound));
+
+            if (filtered.Length == 1)
+                return Attempt.Succeed(new EventNameExtractorResult(filtered[0]));
+
+            //there's more than one left so it's ambiguous!
+            return Attempt.Fail(new EventNameExtractorResult(EventNameExtractorError.Ambiguous));
+        }
+
+        /// <summary>
+        /// Finds the event name on the sender that matches the args type
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="args"></param>
+        /// <param name="exclude">
+        /// A filter to exclude matched event names, this filter should return true to exclude the event name from being matched
+        /// </param>
+        /// <returns>
+        /// null if not found or an ambiguous match
+        /// </returns>
+        public static Attempt<EventNameExtractorResult> FindEvent(object sender, object args, Func<string, bool> exclude)
+        {
+            return FindEvent(sender.GetType(), args.GetType(), exclude);
+        }
+
+        /// <summary>
+        /// Return true if the event is named with an ING name such as "Saving" or "RollingBack"
+        /// </summary>
+        /// <param name="eventName"></param>
+        /// <returns></returns>
+        internal static bool MatchIngNames(string eventName)
+        {
+            var splitter = new Regex(@"(?<!^)(?=[A-Z])");
+            var words = splitter.Split(eventName);
+            if (words.Length == 0)
+                return false;
+            return words[0].EndsWith("ing");
+        }
+
+        /// <summary>
+        /// Return true if the event is not named with an ING name such as "Saving" or "RollingBack"
+        /// </summary>
+        /// <param name="eventName"></param>
+        /// <returns></returns>
+        internal static bool MatchNonIngNames(string eventName)
+        {
+            var splitter = new Regex(@"(?<!^)(?=[A-Z])");
+            var words = splitter.Split(eventName);
+            if (words.Length == 0)
+                return false;
+            return words[0].EndsWith("ing") == false;
+        }
+
+        private class EventInfoArgs
+        {
+            public EventInfo EventInfo { get; private set; }
+            public Type[] GenericArgs { get; private set; }
+
+            public EventInfoArgs(EventInfo eventInfo, Type[] genericArgs)
+            {
+                EventInfo = eventInfo;
+                GenericArgs = genericArgs;
+            }
+        }
+
+        /// <summary>
+        /// Used to cache all candidate events for a given type so we don't re-look them up
+        /// </summary>
+        private static readonly ConcurrentDictionary<Type, EventInfoArgs[]> CandidateEvents = new ConcurrentDictionary<Type, EventInfoArgs[]>();
+
+        /// <summary>
+        /// Used to cache all matched event names by (sender type + arg type) so we don't re-look them up
+        /// </summary>
+        private static readonly ConcurrentDictionary<Tuple<Type, Type>, string[]> MatchedEventNames = new ConcurrentDictionary<Tuple<Type, Type>, string[]>();
+    }
+}

src/Umbraco.Core/Events/EventNameExtractorError.cs

@@ -0,0 +1,8 @@
+namespace Umbraco.Core.Events
+{
+    internal enum EventNameExtractorError
+    {
+        NoneFound,
+        Ambiguous
+    }
+}

src/Umbraco.Core/Events/EventNameExtractorResult.cs

@@ -0,0 +1,18 @@
+namespace Umbraco.Core.Events
+{
+    internal class EventNameExtractorResult
+    {
+        public EventNameExtractorError? Error { get; private set; }
+        public string Name { get; private set; }
+
+        public EventNameExtractorResult(string name)
+        {
+            Name = name;
+        }
+
+        public EventNameExtractorResult(EventNameExtractorError error)
+        {
+            Error = error;
+        }
+    }
+}

src/Umbraco.Core/Events/ExportEventArgs.cs

@@ -1,9 +1,10 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Xml.Linq;
 
 namespace Umbraco.Core.Events
 {
-    public class ExportEventArgs<TEntity> : CancellableObjectEventArgs<IEnumerable<TEntity>>
+    public class ExportEventArgs<TEntity> : CancellableObjectEventArgs<IEnumerable<TEntity>>, IEquatable<ExportEventArgs<TEntity>>
     {
         /// <summary>
         /// Constructor accepting a single entity instance
@@ -48,5 +49,38 @@ namespace Umbraco.Core.Events
         /// Returns the xml relating to the export event
         /// </summary>
         public XElement Xml { get; private set; }
+
+        public bool Equals(ExportEventArgs<TEntity> other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            return base.Equals(other) && Equals(Xml, other.Xml);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((ExportEventArgs<TEntity>) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return (base.GetHashCode() * 397) ^ (Xml != null ? Xml.GetHashCode() : 0);
+            }
+        }
+
+        public static bool operator ==(ExportEventArgs<TEntity> left, ExportEventArgs<TEntity> right)
+        {
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(ExportEventArgs<TEntity> left, ExportEventArgs<TEntity> right)
+        {
+            return !Equals(left, right);
+        }
     }
 }

src/Umbraco.Core/Events/IDeletingMediaFilesEventArgs.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Events
+{
+    internal interface IDeletingMediaFilesEventArgs
+    {
+        List<string> MediaFilesToDelete { get; }
+    }
+}

src/Umbraco.Core/Events/IEventDefinition.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace Umbraco.Core.Events
+{
+    public interface IEventDefinition
+    {
+        object Sender { get; }
+        object Args { get; }
+        string EventName { get; }
+
+        void RaiseEvent();
+    }
+}

src/Umbraco.Core/Events/IEventDispatcher.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Events
+{
+    /// <summary>
+    /// Dispatches events from within a scope.
+    /// </summary>
+    /// <remarks>
+    /// <para>The name of the event is auto-magically discovered by matching the sender type, args type, and
+    /// eventHandler type. If the match is not unique, then the name parameter must be used to specify the
+    /// name in an explicit way.</para>
+    /// <para>What happens when an event is dispatched depends on the scope settings. It can be anything from
+    /// "trigger immediately" to "just ignore". Refer to the scope documentation for more details.</para>
+    /// </remarks>
+    public interface IEventDispatcher
+    {
+        // not sure about the Dispatch & DispatchCancelable signatures at all for now
+        // nor about the event name thing, etc - but let's keep it like this
+
+        /// <summary>
+        /// Dispatches a cancelable event.
+        /// </summary>
+        /// <param name="eventHandler">The event handler.</param>
+        /// <param name="sender">The object that raised the event.</param>
+        /// <param name="args">The event data.</param>
+        /// <param name="name">The optional name of the event.</param>
+        /// <returns>A value indicating whether the cancelable event was cancelled.</returns>
+        /// <remarks>See general remarks on the interface.</remarks>
+        bool DispatchCancelable(EventHandler eventHandler, object sender, CancellableEventArgs args, string name = null);
+
+        /// <summary>
+        /// Dispatches a cancelable event.
+        /// </summary>
+        /// <param name="eventHandler">The event handler.</param>
+        /// <param name="sender">The object that raised the event.</param>
+        /// <param name="args">The event data.</param>
+        /// <param name="name">The optional name of the event.</param>
+        /// <returns>A value indicating whether the cancelable event was cancelled.</returns>
+        /// <remarks>See general remarks on the interface.</remarks>
+        bool DispatchCancelable<TArgs>(EventHandler<TArgs> eventHandler, object sender, TArgs args, string name = null)
+            where TArgs : CancellableEventArgs;
+
+        /// <summary>
+        /// Dispatches a cancelable event.
+        /// </summary>
+        /// <param name="eventHandler">The event handler.</param>
+        /// <param name="sender">The object that raised the event.</param>
+        /// <param name="args">The event data.</param>
+        /// <param name="name">The optional name of the event.</param>
+        /// <returns>A value indicating whether the cancelable event was cancelled.</returns>
+        /// <remarks>See general remarks on the interface.</remarks>
+        bool DispatchCancelable<TSender, TArgs>(TypedEventHandler<TSender, TArgs> eventHandler, TSender sender, TArgs args, string name = null)
+            where TArgs : CancellableEventArgs;
+
+        /// <summary>
+        /// Dispatches an event.
+        /// </summary>
+        /// <param name="eventHandler">The event handler.</param>
+        /// <param name="sender">The object that raised the event.</param>
+        /// <param name="args">The event data.</param>
+        /// <param name="name">The optional name of the event.</param>
+        /// <remarks>See general remarks on the interface.</remarks>
+        void Dispatch(EventHandler eventHandler, object sender, EventArgs args, string name = null);
+
+        /// <summary>
+        /// Dispatches an event.
+        /// </summary>
+        /// <param name="eventHandler">The event handler.</param>
+        /// <param name="sender">The object that raised the event.</param>
+        /// <param name="args">The event data.</param>
+        /// <param name="name">The optional name of the event.</param>
+        /// <remarks>See general remarks on the interface.</remarks>
+        void Dispatch<TArgs>(EventHandler<TArgs> eventHandler, object sender, TArgs args, string name = null);
+
+        /// <summary>
+        /// Dispatches an event.
+        /// </summary>
+        /// <param name="eventHandler">The event handler.</param>
+        /// <param name="sender">The object that raised the event.</param>
+        /// <param name="args">The event data.</param>
+        /// <param name="name">The optional name of the event.</param>
+        /// <remarks>See general remarks on the interface.</remarks>
+        void Dispatch<TSender, TArgs>(TypedEventHandler<TSender, TArgs> eventHandler, TSender sender, TArgs args, string name = null);
+
+        /// <summary>
+        /// Notifies the dispatcher that the scope is exiting.
+        /// </summary>
+        /// <param name="completed">A value indicating whether the scope completed.</param>
+        void ScopeExit(bool completed);
+
+        /// <summary>
+        /// Gets the collected events.
+        /// </summary>
+        /// <returns>The collected events.</returns>
+        IEnumerable<IEventDefinition> GetEvents(EventDefinitionFilter filter);
+    }
+}

src/Umbraco.Core/Events/ImportEventArgs.cs

@@ -1,9 +1,10 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Xml.Linq;
 
 namespace Umbraco.Core.Events
 {
-    public class ImportEventArgs<TEntity> : CancellableObjectEventArgs<IEnumerable<TEntity>>
+    public class ImportEventArgs<TEntity> : CancellableEnumerableObjectEventArgs<TEntity>, IEquatable<ImportEventArgs<TEntity>>
     {
         /// <summary>
         /// Constructor accepting an XElement with the xml being imported
@@ -46,5 +47,38 @@ namespace Umbraco.Core.Events
         /// Returns the xml relating to the import event
         /// </summary>
         public XElement Xml { get; private set; }
+
+        public bool Equals(ImportEventArgs<TEntity> other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            return base.Equals(other) && Equals(Xml, other.Xml);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((ImportEventArgs<TEntity>) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return (base.GetHashCode() * 397) ^ (Xml != null ? Xml.GetHashCode() : 0);
+            }
+        }
+
+        public static bool operator ==(ImportEventArgs<TEntity> left, ImportEventArgs<TEntity> right)
+        {
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(ImportEventArgs<TEntity> left, ImportEventArgs<TEntity> right)
+        {
+            return !Equals(left, right);
+        }
     }
 }

src/Umbraco.Core/Events/ImportPackageEventArgs.cs

@@ -1,9 +1,10 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using Umbraco.Core.Packaging.Models;
 
 namespace Umbraco.Core.Events
 {
-    internal class ImportPackageEventArgs<TEntity> : CancellableObjectEventArgs<IEnumerable<TEntity>>
+    internal class ImportPackageEventArgs<TEntity> : CancellableEnumerableObjectEventArgs<TEntity>, IEquatable<ImportPackageEventArgs<TEntity>>
     {
         private readonly MetaData _packageMetaData;
 
@@ -21,6 +22,45 @@ namespace Umbraco.Core.Events
         public MetaData PackageMetaData
         {
             get { return _packageMetaData; }
+        }
+		
+		public IEnumerable<TEntity> InstallationSummary
+        {
+            get { return EventObject; }
+        }
+
+        public bool Equals(ImportPackageEventArgs<TEntity> other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            //TODO: MetaData for package metadata has no equality operators :/
+            return base.Equals(other) && _packageMetaData.Equals(other._packageMetaData);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((ImportPackageEventArgs<TEntity>) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return (base.GetHashCode() * 397) ^ _packageMetaData.GetHashCode();
+            }
+        }
+
+        public static bool operator ==(ImportPackageEventArgs<TEntity> left, ImportPackageEventArgs<TEntity> right)
+        {
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(ImportPackageEventArgs<TEntity> left, ImportPackageEventArgs<TEntity> right)
+        {
+            return !Equals(left, right);
         }
     }
 }

src/Umbraco.Core/Events/MigrationEventArgs.cs

@@ -7,7 +7,7 @@ using Umbraco.Core.Persistence.Migrations;
 
 namespace Umbraco.Core.Events
 {
-    public class MigrationEventArgs : CancellableObjectEventArgs<IList<IMigration>>
+    public class MigrationEventArgs : CancellableObjectEventArgs<IList<IMigration>>, IEquatable<MigrationEventArgs>
     {
         /// <summary>
         /// Constructor accepting multiple migrations that are used in the migration runner
@@ -31,13 +31,13 @@ namespace Umbraco.Core.Events
         [Obsolete("Use constructor accepting a product name instead.")]
         [EditorBrowsable(EditorBrowsableState.Never)]
         public MigrationEventArgs(IList<IMigration> eventObject, SemVersion configuredVersion, SemVersion targetVersion, bool canCancel)
-            : this(eventObject, null, configuredVersion, targetVersion, GlobalSettings.UmbracoMigrationName, canCancel)
+            : this(eventObject, null, configuredVersion, targetVersion, Constants.System.UmbracoMigrationName, canCancel)
         { }
 
         [Obsolete("Use constructor accepting SemVersion instances and a product name instead.")]
         [EditorBrowsable(EditorBrowsableState.Never)]
         public MigrationEventArgs(IList<IMigration> eventObject, Version configuredVersion, Version targetVersion, bool canCancel)
-			: this(eventObject, null, new SemVersion(configuredVersion), new SemVersion(targetVersion), GlobalSettings.UmbracoMigrationName, canCancel)
+			: this(eventObject, null, new SemVersion(configuredVersion), new SemVersion(targetVersion), Constants.System.UmbracoMigrationName, canCancel)
          { }
 
         /// <summary>
@@ -74,7 +74,7 @@ namespace Umbraco.Core.Events
             MigrationContext = migrationContext;
             ConfiguredSemVersion = configuredVersion;
             TargetSemVersion = targetVersion;
-            ProductName = GlobalSettings.UmbracoMigrationName;
+            ProductName = Constants.System.UmbracoMigrationName;
         }
 
         /// <summary>
@@ -97,13 +97,13 @@ namespace Umbraco.Core.Events
         [Obsolete("Use constructor accepting a product name instead.")]
         [EditorBrowsable(EditorBrowsableState.Never)]
         public MigrationEventArgs(IList<IMigration> eventObject, SemVersion configuredVersion, SemVersion targetVersion)
-            : this(eventObject, null, configuredVersion, targetVersion, GlobalSettings.UmbracoMigrationName, false)
+            : this(eventObject, null, configuredVersion, targetVersion, Constants.System.UmbracoMigrationName, false)
         { }
 
         [Obsolete("Use constructor accepting SemVersion instances and a product name instead.")]
         [EditorBrowsable(EditorBrowsableState.Never)]
         public MigrationEventArgs(IList<IMigration> eventObject, Version configuredVersion, Version targetVersion)
-			: this(eventObject, null, new SemVersion(configuredVersion), new SemVersion(targetVersion), GlobalSettings.UmbracoMigrationName, false)
+			: this(eventObject, null, new SemVersion(configuredVersion), new SemVersion(targetVersion), Constants.System.UmbracoMigrationName, false)
 		{ }
 
 		/// <summary>
@@ -141,5 +141,43 @@ namespace Umbraco.Core.Events
         public string ProductName { get; private set; }
 
         internal MigrationContext MigrationContext { get; private set; }
+
+        public bool Equals(MigrationEventArgs other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            return base.Equals(other) && ConfiguredSemVersion.Equals(other.ConfiguredSemVersion) && MigrationContext.Equals(other.MigrationContext) && string.Equals(ProductName, other.ProductName) && TargetSemVersion.Equals(other.TargetSemVersion);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((MigrationEventArgs) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hashCode = base.GetHashCode();
+                hashCode = (hashCode * 397) ^ ConfiguredSemVersion.GetHashCode();
+                hashCode = (hashCode * 397) ^ MigrationContext.GetHashCode();
+                hashCode = (hashCode * 397) ^ ProductName.GetHashCode();
+                hashCode = (hashCode * 397) ^ TargetSemVersion.GetHashCode();
+                return hashCode;
+            }
+        }
+
+        public static bool operator ==(MigrationEventArgs left, MigrationEventArgs right)
+        {
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(MigrationEventArgs left, MigrationEventArgs right)
+        {
+            return !Equals(left, right);
+        }
     }
 }

src/Umbraco.Core/Events/MoveEventArgs.cs

@@ -4,7 +4,7 @@ using System.Linq;
 
 namespace Umbraco.Core.Events
 {
-    public class MoveEventArgs<TEntity> : CancellableObjectEventArgs<TEntity>
+    public class MoveEventArgs<TEntity> : CancellableObjectEventArgs<TEntity>, IEquatable<MoveEventArgs<TEntity>>
     {
         /// <summary>
         /// Constructor accepting a collection of MoveEventInfo objects
@@ -123,5 +123,38 @@ namespace Umbraco.Core.Events
         /// </summary>
         [Obsolete("Retrieve the ParentId from the MoveInfoCollection property instead")]
         public int ParentId { get; private set; }
+
+        public bool Equals(MoveEventArgs<TEntity> other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            return base.Equals(other) && MoveInfoCollection.Equals(other.MoveInfoCollection);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((MoveEventArgs<TEntity>) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return (base.GetHashCode() * 397) ^ MoveInfoCollection.GetHashCode();
+            }
+        }
+
+        public static bool operator ==(MoveEventArgs<TEntity> left, MoveEventArgs<TEntity> right)
+        {
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(MoveEventArgs<TEntity> left, MoveEventArgs<TEntity> right)
+        {
+            return !Equals(left, right);
+        }
     }
 }

src/Umbraco.Core/Events/MoveEventInfo.cs

@@ -1,6 +1,9 @@
+using System;
+using System.Collections.Generic;
+
 namespace Umbraco.Core.Events
 {
-    public class MoveEventInfo<TEntity>
+    public class MoveEventInfo<TEntity> : IEquatable<MoveEventInfo<TEntity>>
     {
         public MoveEventInfo(TEntity entity, string originalPath, int newParentId)
         {
@@ -12,5 +15,41 @@ namespace Umbraco.Core.Events
         public TEntity Entity { get; set; }
         public string OriginalPath { get; set; }
         public int NewParentId { get; set; }
+
+        public bool Equals(MoveEventInfo<TEntity> other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            return EqualityComparer<TEntity>.Default.Equals(Entity, other.Entity) && NewParentId == other.NewParentId && string.Equals(OriginalPath, other.OriginalPath);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((MoveEventInfo<TEntity>) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = EqualityComparer<TEntity>.Default.GetHashCode(Entity);
+                hashCode = (hashCode * 397) ^ NewParentId;
+                hashCode = (hashCode * 397) ^ OriginalPath.GetHashCode();
+                return hashCode;
+            }
+        }
+
+        public static bool operator ==(MoveEventInfo<TEntity> left, MoveEventInfo<TEntity> right)
+        {
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(MoveEventInfo<TEntity> left, MoveEventInfo<TEntity> right)
+        {
+            return !Equals(left, right);
+        }
     }
 }

src/Umbraco.Core/Events/NewEventArgs.cs

@@ -1,8 +1,10 @@
+using System;
+using System.Collections.Generic;
 using Umbraco.Core.Models;
 
 namespace Umbraco.Core.Events
 {
-	public class NewEventArgs<TEntity> : CancellableObjectEventArgs<TEntity>
+	public class NewEventArgs<TEntity> : CancellableObjectEventArgs<TEntity>, IEquatable<NewEventArgs<TEntity>>
 	{
 
 
@@ -84,5 +86,42 @@ namespace Umbraco.Core.Events
         /// Gets or Sets the parent IContent object.
         /// </summary>
         public TEntity Parent { get; private set; }
+
+	    public bool Equals(NewEventArgs<TEntity> other)
+	    {
+	        if (ReferenceEquals(null, other)) return false;
+	        if (ReferenceEquals(this, other)) return true;
+	        return base.Equals(other) && string.Equals(Alias, other.Alias) && EqualityComparer<TEntity>.Default.Equals(Parent, other.Parent) && ParentId == other.ParentId;
+	    }
+
+	    public override bool Equals(object obj)
+	    {
+	        if (ReferenceEquals(null, obj)) return false;
+	        if (ReferenceEquals(this, obj)) return true;
+	        if (obj.GetType() != this.GetType()) return false;
+	        return Equals((NewEventArgs<TEntity>) obj);
+	    }
+
+	    public override int GetHashCode()
+	    {
+	        unchecked
+	        {
+	            int hashCode = base.GetHashCode();
+	            hashCode = (hashCode * 397) ^ Alias.GetHashCode();
+	            hashCode = (hashCode * 397) ^ EqualityComparer<TEntity>.Default.GetHashCode(Parent);
+	            hashCode = (hashCode * 397) ^ ParentId;
+	            return hashCode;
+	        }
+	    }
+
+	    public static bool operator ==(NewEventArgs<TEntity> left, NewEventArgs<TEntity> right)
+	    {
+	        return Equals(left, right);
+	    }
+
+	    public static bool operator !=(NewEventArgs<TEntity> left, NewEventArgs<TEntity> right)
+	    {
+	        return !Equals(left, right);
+	    }
 	}
 }

src/Umbraco.Core/Events/PassThroughEventDispatcher.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Umbraco.Core.Events
+{
+    /// <summary>
+    /// An IEventDispatcher that immediately raise all events.
+    /// </summary>
+    /// <remarks>This means that events will be raised during the scope transaction,
+    /// whatever happens, and the transaction could roll back in the end.</remarks>
+    internal class PassThroughEventDispatcher : IEventDispatcher
+    {
+        public bool DispatchCancelable(EventHandler eventHandler, object sender, CancellableEventArgs args, string eventName = null)
+        {
+            if (eventHandler == null) return args.Cancel;
+            eventHandler(sender, args);
+            return args.Cancel;
+        }
+
+        public bool DispatchCancelable<TArgs>(EventHandler<TArgs> eventHandler, object sender, TArgs args, string eventName = null)
+            where TArgs : CancellableEventArgs
+        {
+            if (eventHandler == null) return args.Cancel;
+            eventHandler(sender, args);
+            return args.Cancel;
+        }
+
+        public bool DispatchCancelable<TSender, TArgs>(TypedEventHandler<TSender, TArgs> eventHandler, TSender sender, TArgs args, string eventName = null)
+            where TArgs : CancellableEventArgs
+        {
+            if (eventHandler == null) return args.Cancel;
+            eventHandler(sender, args);
+            return args.Cancel;
+        }
+
+        public void Dispatch(EventHandler eventHandler, object sender, EventArgs args, string eventName = null)
+        {
+            if (eventHandler == null) return;
+            eventHandler(sender, args);
+        }
+
+        public void Dispatch<TArgs>(EventHandler<TArgs> eventHandler, object sender, TArgs args, string eventName = null)
+        {
+            if (eventHandler == null) return;
+            eventHandler(sender, args);
+        }
+
+        public void Dispatch<TSender, TArgs>(TypedEventHandler<TSender, TArgs> eventHandler, TSender sender, TArgs args, string eventName = null)
+        {
+            if (eventHandler == null) return;
+            eventHandler(sender, args);
+        }
+
+        public IEnumerable<IEventDefinition> GetEvents(EventDefinitionFilter filter)
+        {
+            return Enumerable.Empty<IEventDefinition>();
+        }
+
+        public void ScopeExit(bool completed)
+        { }
+    }
+}

src/Umbraco.Core/Events/PublishEventArgs.cs

@@ -1,8 +1,9 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 
 namespace Umbraco.Core.Events
 {
-    public class PublishEventArgs<TEntity> : CancellableObjectEventArgs<IEnumerable<TEntity>>
+    public class PublishEventArgs<TEntity> : CancellableEnumerableObjectEventArgs<TEntity>, IEquatable<PublishEventArgs<TEntity>>
     {
         /// <summary>
         /// Constructor accepting multiple entities that are used in the publish operation
@@ -101,5 +102,38 @@ namespace Umbraco.Core.Events
 		}
 
         public bool IsAllRepublished { get; private set; }
+
+        public bool Equals(PublishEventArgs<TEntity> other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            return base.Equals(other) && IsAllRepublished == other.IsAllRepublished;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((PublishEventArgs<TEntity>) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return (base.GetHashCode() * 397) ^ IsAllRepublished.GetHashCode();
+            }
+        }
+
+        public static bool operator ==(PublishEventArgs<TEntity> left, PublishEventArgs<TEntity> right)
+        {
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(PublishEventArgs<TEntity> left, PublishEventArgs<TEntity> right)
+        {
+            return !Equals(left, right);
+        }
     }
 }

src/Umbraco.Core/Events/RecycleBinEventArgs.cs

@@ -5,7 +5,7 @@ using Umbraco.Core.Models;
 
 namespace Umbraco.Core.Events
 {
-    public class RecycleBinEventArgs : CancellableEventArgs
+    public class RecycleBinEventArgs : CancellableEventArgs, IEquatable<RecycleBinEventArgs>, IDeletingMediaFilesEventArgs
     {
         public RecycleBinEventArgs(Guid nodeObjectType, Dictionary<int, IEnumerable<Property>> allPropertyData, bool emptiedSuccessfully)
             : base(false)
@@ -97,6 +97,8 @@ namespace Umbraco.Core.Events
         /// </remarks>
         public List<string> Files { get; private set; }
 
+        public List<string> MediaFilesToDelete { get { return Files; } }
+
         /// <summary>
         /// Gets the list of all property data associated with a content id
         /// </summary>
@@ -122,5 +124,44 @@ namespace Umbraco.Core.Events
         {
             get { return NodeObjectType == new Guid(Constants.ObjectTypes.Media); }
         }
+
+        public bool Equals(RecycleBinEventArgs other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            return base.Equals(other) && AllPropertyData.Equals(other.AllPropertyData) && Files.Equals(other.Files) && Ids.Equals(other.Ids) && NodeObjectType.Equals(other.NodeObjectType) && RecycleBinEmptiedSuccessfully == other.RecycleBinEmptiedSuccessfully;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((RecycleBinEventArgs) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hashCode = base.GetHashCode();
+                hashCode = (hashCode * 397) ^ AllPropertyData.GetHashCode();
+                hashCode = (hashCode * 397) ^ Files.GetHashCode();
+                hashCode = (hashCode * 397) ^ Ids.GetHashCode();
+                hashCode = (hashCode * 397) ^ NodeObjectType.GetHashCode();
+                hashCode = (hashCode * 397) ^ RecycleBinEmptiedSuccessfully.GetHashCode();
+                return hashCode;
+            }
+        }
+
+        public static bool operator ==(RecycleBinEventArgs left, RecycleBinEventArgs right)
+        {
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(RecycleBinEventArgs left, RecycleBinEventArgs right)
+        {
+            return !Equals(left, right);
+        }
     }
 }

src/Umbraco.Core/Events/RollbackEventArgs.cs

@@ -17,5 +17,7 @@ namespace Umbraco.Core.Events
 		{
 			get { return EventObject; }
 		}
+
+
 	}
 }

src/Umbraco.Core/Events/SaveEventArgs.cs

@@ -1,8 +1,9 @@
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Umbraco.Core.Events
 {
-	public class SaveEventArgs<TEntity> : CancellableObjectEventArgs<IEnumerable<TEntity>>
+	public class SaveEventArgs<TEntity> : CancellableEnumerableObjectEventArgs<TEntity>
 	{
         /// <summary>
         /// Constructor accepting multiple entities that are used in the saving operation

src/Umbraco.Core/Events/ScopeEventDispatcher.cs

@@ -0,0 +1,44 @@
+using Umbraco.Core.IO;
+
+namespace Umbraco.Core.Events
+{
+    /// <summary>
+    /// An IEventDispatcher that queues events, and raise them when the scope
+    /// exits and has been completed.
+    /// </summary>
+    internal class ScopeEventDispatcher : ScopeEventDispatcherBase
+    {
+        public ScopeEventDispatcher()
+            : base(true)
+        { }
+
+        protected override void ScopeExitCompleted()
+        {
+            // processing only the last instance of each event...
+            // this is probably far from perfect, because if eg a content is saved in a list
+            // and then as a single content, the two events will probably not be de-duplicated,
+            // but it's better than nothing
+
+            foreach (var e in GetEvents(EventDefinitionFilter.LastIn))
+            {
+                e.RaiseEvent();
+
+                // separating concerns means that this should probably not be here,
+                // but then where should it be (without making things too complicated)?
+                var delete = e.Args as IDeletingMediaFilesEventArgs;
+                if (delete != null && delete.MediaFilesToDelete.Count > 0)
+                    MediaFileSystem.DeleteMediaFiles(delete.MediaFilesToDelete);
+            }
+        }
+
+        private MediaFileSystem _mediaFileSystem;
+
+        private MediaFileSystem MediaFileSystem
+        {
+            get
+            {
+                return _mediaFileSystem ?? (_mediaFileSystem = FileSystemProviderManager.Current.MediaFileSystem);
+            }
+        }
+    }
+}

src/Umbraco.Core/Events/ScopeEventDispatcherBase.cs

@@ -0,0 +1,347 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Events
+{
+    /// <summary>
+    /// An IEventDispatcher that queues events.
+    /// </summary>
+    /// <remarks>
+    /// <para>Can raise, or ignore, cancelable events, depending on option.</para>
+    /// <para>Implementations must override ScopeExitCompleted to define what
+    /// to do with the events when the scope exits and has been completed.</para>
+    /// <para>If the scope exits without being completed, events are ignored.</para>
+    /// </remarks>
+    public abstract class ScopeEventDispatcherBase : IEventDispatcher
+    {
+        //events will be enlisted in the order they are raised
+        private List<IEventDefinition> _events;
+        private readonly bool _raiseCancelable;
+
+        protected ScopeEventDispatcherBase(bool raiseCancelable)
+        {
+            _raiseCancelable = raiseCancelable;
+        }
+
+        private List<IEventDefinition> Events { get { return _events ?? (_events = new List<IEventDefinition>()); } }
+
+        public bool DispatchCancelable(EventHandler eventHandler, object sender, CancellableEventArgs args, string eventName = null)
+        {
+            if (eventHandler == null) return args.Cancel;
+            if (_raiseCancelable == false) return args.Cancel;
+            eventHandler(sender, args);
+            return args.Cancel;
+        }
+
+        public bool DispatchCancelable<TArgs>(EventHandler<TArgs> eventHandler, object sender, TArgs args, string eventName = null)
+            where TArgs : CancellableEventArgs
+        {
+            if (eventHandler == null) return args.Cancel;
+            if (_raiseCancelable == false) return args.Cancel;
+            eventHandler(sender, args);
+            return args.Cancel;
+        }
+
+        public bool DispatchCancelable<TSender, TArgs>(TypedEventHandler<TSender, TArgs> eventHandler, TSender sender, TArgs args, string eventName = null)
+            where TArgs : CancellableEventArgs
+        {
+            if (eventHandler == null) return args.Cancel;
+            if (_raiseCancelable == false) return args.Cancel;
+            eventHandler(sender, args);
+            return args.Cancel;
+        }
+
+        public void Dispatch(EventHandler eventHandler, object sender, EventArgs args, string eventName = null)
+        {
+            if (eventHandler == null) return;
+            Events.Add(new EventDefinition(eventHandler, sender, args, eventName));
+        }
+
+        public void Dispatch<TArgs>(EventHandler<TArgs> eventHandler, object sender, TArgs args, string eventName = null)
+        {
+            if (eventHandler == null) return;
+            Events.Add(new EventDefinition<TArgs>(eventHandler, sender, args, eventName));
+        }
+
+        public void Dispatch<TSender, TArgs>(TypedEventHandler<TSender, TArgs> eventHandler, TSender sender, TArgs args, string eventName = null)
+        {
+            if (eventHandler == null) return;
+            Events.Add(new EventDefinition<TSender, TArgs>(eventHandler, sender, args, eventName));
+        }
+
+        public IEnumerable<IEventDefinition> GetEvents(EventDefinitionFilter filter)
+        {
+            if (_events == null)
+                return Enumerable.Empty<IEventDefinition>();
+            
+            switch (filter)
+            {
+                case EventDefinitionFilter.All:
+                    return FilterSupersededAndUpdateToLatestEntity(_events);
+                case EventDefinitionFilter.FirstIn:
+                    var l1 = new OrderedHashSet<IEventDefinition>();
+                    foreach (var e in _events)
+                    {
+                        l1.Add(e);
+                    }
+                    return FilterSupersededAndUpdateToLatestEntity(l1);
+                case EventDefinitionFilter.LastIn:
+                    var l2 = new OrderedHashSet<IEventDefinition>(keepOldest: false);
+                    foreach (var e in _events)
+                    {
+                        l2.Add(e);
+                    }
+                    return FilterSupersededAndUpdateToLatestEntity(l2);
+                default:
+                    throw new ArgumentOutOfRangeException("filter", filter, null);
+            }
+        }
+        
+        private class EventDefinitionTypeData
+        {
+            public IEventDefinition EventDefinition { get; set; }
+            public Type EventArgType { get; set; }
+            public SupersedeEventAttribute[] SupersedeAttributes { get; set; }
+        }
+        
+        /// <summary>
+        /// This will iterate over the events (latest first) and filter out any events or entities in event args that are included 
+        /// in more recent events that Supersede previous ones. For example, If an Entity has been Saved and then Deleted, we don't want
+        /// to raise the Saved event (well actually we just don't want to include it in the args for that saved event)
+        /// </summary>
+        /// <param name="events"></param>
+        /// <returns></returns>
+        private static IEnumerable<IEventDefinition> FilterSupersededAndUpdateToLatestEntity(IReadOnlyList<IEventDefinition> events)
+        {
+            //used to keep the 'latest' entity and associated event definition data
+            var allEntities = new List<Tuple<IEntity, EventDefinitionTypeData>>();
+
+            //tracks all CancellableObjectEventArgs instances in the events which is the only type of args we can work with
+            var cancelableArgs = new List<CancellableObjectEventArgs>();
+
+            var result = new List<IEventDefinition>();
+
+            //This will eagerly load all of the event arg types and their attributes so we don't have to continuously look this data up
+            var allArgTypesWithAttributes = events.Select(x => x.Args.GetType())
+                .Distinct()
+                .ToDictionary(x => x, x => x.GetCustomAttributes<SupersedeEventAttribute>(false).ToArray());
+               
+            //Iterate all events and collect the actual entities in them and relates them to their corresponding EventDefinitionTypeData
+            //we'll process the list in reverse because events are added in the order they are raised and we want to filter out
+            //any entities from event args that are not longer relevant 
+            //(i.e. if an item is Deleted after it's Saved, we won't include the item in the Saved args)
+            for (var index = events.Count - 1; index >= 0; index--)
+            {
+                var eventDefinition = events[index];
+
+                var argType = eventDefinition.Args.GetType();
+                var attributes = allArgTypesWithAttributes[eventDefinition.Args.GetType()];
+
+                var meta = new EventDefinitionTypeData
+                {
+                    EventDefinition = eventDefinition,
+                    EventArgType = argType,
+                    SupersedeAttributes = attributes
+                };
+
+                var args = eventDefinition.Args as CancellableObjectEventArgs;
+                if (args != null)
+                {
+                    var list = TypeHelper.CreateGenericEnumerableFromObject(args.EventObject);
+
+                    if (list == null)
+                    {
+                        //extract the event object
+                        var obj = args.EventObject as IEntity;
+                        if (obj != null)
+                        {
+                            //Now check if this entity already exists in other event args that supersede this current event arg type
+                            if (IsFiltered(obj, meta, allEntities) == false)
+                            {
+                                //if it's not filtered we can adde these args to the response
+                                cancelableArgs.Add(args);
+                                result.Add(eventDefinition);
+                                //track the entity
+                                allEntities.Add(Tuple.Create(obj, meta));
+                            }
+                        }
+                        else
+                        {
+                            //Can't retrieve the entity so cant' filter or inspect, just add to the output
+                            result.Add(eventDefinition);                            
+                        }
+                    }
+                    else
+                    {
+                        var toRemove = new List<IEntity>();
+                        foreach (var entity in list)
+                        {
+                            //extract the event object
+                            var obj = entity as IEntity;
+                            if (obj != null)
+                            {
+                                //Now check if this entity already exists in other event args that supersede this current event arg type
+                                if (IsFiltered(obj, meta, allEntities))
+                                {
+                                    //track it to be removed
+                                    toRemove.Add(obj);
+                                }
+                                else
+                                {
+                                    //track the entity, it's not filtered
+                                    allEntities.Add(Tuple.Create(obj, meta));
+                                }
+                            }
+                            else
+                            {
+                                //we don't need to do anything here, we can't cast to IEntity so we cannot filter, so it will just remain in the list
+                            }
+                        }
+
+                        //remove anything that has been filtered
+                        foreach (var entity in toRemove)
+                        {
+                            list.Remove(entity);
+                        }
+
+                        //track the event and include in the response if there's still entities remaining in the list
+                        if (list.Count > 0)
+                        {
+                            if (toRemove.Count > 0)
+                            {
+                                //re-assign if the items have changed
+                                args.EventObject = list;
+                            }
+                            cancelableArgs.Add(args);
+                            result.Add(eventDefinition);
+                        }
+                    }
+                }
+                else
+                {
+                    //it's not a cancelable event arg so we just include it in the result
+                    result.Add(eventDefinition);
+                }
+            }
+
+            //Now we'll deal with ensuring that only the latest(non stale) entities are used throughout all event args
+            UpdateToLatestEntities(allEntities, cancelableArgs);
+
+            //we need to reverse the result since we've been adding by latest added events first!
+            result.Reverse();
+
+            return result;
+        }
+
+        private static void UpdateToLatestEntities(IEnumerable<Tuple<IEntity, EventDefinitionTypeData>> allEntities, IEnumerable<CancellableObjectEventArgs> cancelableArgs)
+        {
+            //Now we'll deal with ensuring that only the latest(non stale) entities are used throughout all event args
+
+            var latestEntities = new OrderedHashSet<IEntity>(keepOldest: true);
+            foreach (var entity in allEntities.OrderByDescending(entity => entity.Item1.UpdateDate))
+            {
+                latestEntities.Add(entity.Item1);
+            }
+
+            foreach (var args in cancelableArgs)
+            {
+                var list = TypeHelper.CreateGenericEnumerableFromObject(args.EventObject);
+                if (list == null)
+                {
+                    //try to find the args entity in the latest entity - based on the equality operators, this will 
+                    //match by Id since that is the default equality checker for IEntity. If one is found, than it is 
+                    //the most recent entity instance so update the args with that instance so we don't emit a stale instance.
+                    var foundEntity = latestEntities.FirstOrDefault(x => Equals(x, args.EventObject));
+                    if (foundEntity != null)
+                    {
+                        args.EventObject = foundEntity;
+                    }
+                }
+                else
+                {
+                    var updated = false;
+
+                    for (int i = 0; i < list.Count; i++)
+                    {
+                        //try to find the args entity in the latest entity - based on the equality operators, this will 
+                        //match by Id since that is the default equality checker for IEntity. If one is found, than it is 
+                        //the most recent entity instance so update the args with that instance so we don't emit a stale instance.
+                        var foundEntity = latestEntities.FirstOrDefault(x => Equals(x, list[i]));
+                        if (foundEntity != null)
+                        {
+                            list[i] = foundEntity;
+                            updated = true;
+                        }
+                    }
+
+                    if (updated)
+                    {
+                        args.EventObject = list;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// This will check against all of the processed entity/events (allEntities) to see if this entity already exists in 
+        /// event args that supersede the event args being passed in and if so returns true.
+        /// </summary>
+        /// <param name="entity"></param>
+        /// <param name="eventDef"></param>
+        /// <param name="allEntities"></param>
+        /// <returns></returns>
+        private static bool IsFiltered(
+            IEntity entity,
+            EventDefinitionTypeData eventDef,
+            List<Tuple<IEntity, EventDefinitionTypeData>> allEntities)
+        {
+            var argType = eventDef.EventDefinition.Args.GetType();
+
+            //check if the entity is found in any processed event data that could possible supersede this one
+            var foundByEntity = allEntities
+                .Where(x => x.Item2.SupersedeAttributes.Length > 0
+                            //if it's the same arg type than it cannot supersede                
+                            && x.Item2.EventArgType != argType
+                            && Equals(x.Item1, entity))
+                .ToArray();
+
+            //no args have been processed with this entity so it should not be filtered
+            if (foundByEntity.Length == 0)
+                return false;
+
+            if (argType.IsGenericType)
+            {
+                var supercededBy = foundByEntity
+                    .FirstOrDefault(x =>
+                        x.Item2.SupersedeAttributes.Any(y =>
+                            //if the attribute type is a generic type def then compare with the generic type def of the event arg
+                                (y.SupersededEventArgsType.IsGenericTypeDefinition && y.SupersededEventArgsType == argType.GetGenericTypeDefinition())
+                                //if the attribute type is not a generic type def then compare with the normal type of the event arg
+                                || (y.SupersededEventArgsType.IsGenericTypeDefinition == false && y.SupersededEventArgsType == argType)));
+                return supercededBy != null;
+            }
+            else
+            {
+                var supercededBy = foundByEntity
+                    .FirstOrDefault(x =>
+                        x.Item2.SupersedeAttributes.Any(y =>
+                            //since the event arg type is not a generic type, then we just compare type 1:1
+                                y.SupersededEventArgsType == argType));
+                return supercededBy != null;
+            }
+        }
+
+        public void ScopeExit(bool completed)
+        {
+            if (_events == null) return;
+            if (completed)
+                ScopeExitCompleted();
+            _events.Clear();
+        }
+
+        protected abstract void ScopeExitCompleted();
+    }
+}

src/Umbraco.Core/Events/ScopeLifespanMessagesFactory.cs

@@ -0,0 +1,58 @@
+using System;
+using Umbraco.Core.Scoping;
+
+namespace Umbraco.Core.Events
+{
+    /// <summary>
+    /// Stores the instance of EventMessages in the current scope.
+    /// </summary>
+    internal class ScopeLifespanMessagesFactory : IEventMessagesFactory
+    {
+        public const string ContextKey = "Umbraco.Core.Events.ScopeLifespanMessagesFactory";
+
+        private readonly IHttpContextAccessor _contextAccessor;
+        private readonly IScopeProviderInternal _scopeProvider;
+
+        public static ScopeLifespanMessagesFactory Current { get; private set; }
+
+        public ScopeLifespanMessagesFactory(IHttpContextAccessor contextAccesor, IScopeProvider scopeProvider)
+        {
+            if (contextAccesor == null) throw new ArgumentNullException("contextAccesor");
+            if (scopeProvider == null) throw new ArgumentNullException("scopeProvider");
+            if (scopeProvider is IScopeProviderInternal == false) throw new ArgumentException("Not IScopeProviderInternal.", "scopeProvider");
+            _contextAccessor = contextAccesor;
+            _scopeProvider = (IScopeProviderInternal) scopeProvider;
+            Current = this;
+        }
+
+        public EventMessages Get()
+        {
+            var messages = GetFromHttpContext();
+            if (messages != null) return messages;
+
+            var scope = _scopeProvider.GetAmbientOrNoScope();
+            return scope.Messages;
+        }
+
+        public EventMessages GetFromHttpContext()
+        {
+            if (_contextAccessor == null || _contextAccessor.Value == null) return null;
+            return (EventMessages)_contextAccessor.Value.Items[ContextKey];
+        }
+
+        public EventMessages TryGet()
+        {
+            var messages = GetFromHttpContext();
+            if (messages != null) return messages;
+
+            var scope = _scopeProvider.AmbientScope;
+            return scope == null ? null : scope.MessagesOrNull;
+        }
+
+        public void Set(EventMessages messages)
+        {
+            if (_contextAccessor.Value == null) return;
+            _contextAccessor.Value.Items[ContextKey] = messages;
+        }
+    }
+}