working on U4-5927 - this extends the base event class to have EventMessages which event consumers can add to, the trick is that there is a factory for these EventMessages, in a web context, the factory is a request based factory so that during a request all instances of the EventMessages are the same instance. All services then accept an instance of IEventMessagesFactory which they can then use when raising events. We'll then use this to send messages to the UI. Not sure if i should make this a resolver yet or not. Still a WIP!!

src/Umbraco.Core/CoreBootManager.cs

@@ -7,6 +7,7 @@ using System.Web;
 using AutoMapper;
 using Umbraco.Core.Cache;
 using Umbraco.Core.Configuration;
+using Umbraco.Core.Events;
 using Umbraco.Core.Exceptions;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
@@ -164,7 +165,9 @@ namespace Umbraco.Core
                 new FileUnitOfWorkProvider(),
                 new PublishingStrategy(),
                 ApplicationCache,
-                ProfilingLogger.Logger);
+                ProfilingLogger.Logger,
+                //default transient factory
+                new TransientMessagesFactory());
         }
 
         /// <summary>

src/Umbraco.Core/Events/CancellableEventArgs.cs

@@ -3,7 +3,7 @@ using System.Security.Permissions;
 
 namespace Umbraco.Core.Events
 {
-	/// <summary>
+    /// <summary>
 	/// Event args for that can support cancellation
 	/// </summary>
 	[HostProtection(SecurityAction.LinkDemand, SharedState = true)]
@@ -11,15 +11,30 @@ namespace Umbraco.Core.Events
 	{
 		private bool _cancel;
 
-		public CancellableEventArgs(bool canCancel)
+        public CancellableEventArgs(bool canCancel, EventMessages eventMessages)
+        {
+            if (eventMessages == null) throw new ArgumentNullException("eventMessages");
+            CanCancel = canCancel;
+            Messages = eventMessages;
+        }
+
+        public CancellableEventArgs(bool canCancel)
 		{
 			CanCancel = canCancel;
-		}
+            //create a standalone messages
+            Messages = new EventMessages();
+        }
 
-		public CancellableEventArgs()
+        public CancellableEventArgs(EventMessages eventMessages)
+            : this(true, eventMessages)
+        {
+        }
+
+        public CancellableEventArgs()
 			: this(true)
 		{
 		}
+
 		/// <summary>
 		/// Flag to determine if this instance will support being cancellable
 		/// </summary>
@@ -32,7 +47,7 @@ namespace Umbraco.Core.Events
 		{
 			get
 			{
-				if (!CanCancel)
+				if (CanCancel == false)
 				{
 					throw new InvalidOperationException("This event argument class does not support cancelling.");
 				}
@@ -40,12 +55,17 @@ namespace Umbraco.Core.Events
 			}
 			set
 			{
-				if (!CanCancel)
+				if (CanCancel == false)
 				{
 					throw new InvalidOperationException("This event argument class does not support cancelling.");
 				}
 				_cancel = value;
 			}
 		}
-	}
+
+        /// <summary>
+        /// Returns the EventMessages object which is used to add messages to the message collection for this event
+        /// </summary>
+        public EventMessages Messages { get; private set; }
+    }
 }

src/Umbraco.Core/Events/CancellableObjectEventArgs.cs

@@ -12,7 +12,18 @@ namespace Umbraco.Core.Events
 	public class CancellableObjectEventArgs<T> : CancellableEventArgs
 	{
 
-		public CancellableObjectEventArgs(T eventObject, bool canCancel)
+        public CancellableObjectEventArgs(T eventObject, bool canCancel, EventMessages eventMessages)
+            : base(canCancel, eventMessages)
+        {
+            EventObject = eventObject;
+        }
+
+        public CancellableObjectEventArgs(T eventObject, EventMessages eventMessages)
+            : this(eventObject, true, eventMessages)
+        {
+        }
+
+        public CancellableObjectEventArgs(T eventObject, bool canCancel)
 			: base(canCancel)
 		{
 			EventObject = eventObject;

src/Umbraco.Core/Events/EventExtensions.cs

@@ -7,16 +7,16 @@ 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>(
+        /// <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)

src/Umbraco.Core/Events/EventMessage.cs

@@ -0,0 +1,22 @@
+namespace Umbraco.Core.Events
+{
+    /// <summary>
+    /// An event message
+    /// </summary>
+    public sealed class EventMessage
+    {        
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EventMessage"/> class.
+        /// </summary>
+        public EventMessage(string category, string message, EventMessageType messageType = EventMessageType.Default)
+        {
+            Category = category;
+            Message = message;
+            MessageType = messageType;
+        }
+
+        public string Category { get; private set; }
+        public string Message { get; private set; }
+        public EventMessageType MessageType { get; private set; }
+    }
+}

src/Umbraco.Core/Events/EventMessages.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Events
+{
+    /// <summary>
+    /// Default transient event messages collection
+    /// </summary>
+    public sealed class EventMessages
+    {
+        private readonly List<EventMessage> _msgs = new List<EventMessage>();
+
+        public void Add(EventMessage msg)
+        {
+            _msgs.Add(msg);
+        }
+
+        public IEnumerable<EventMessage> GetAll()
+        {
+            return _msgs;
+        }
+    }
+}

src/Umbraco.Core/Events/IEventMessagesFactory.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Events
+{
+    public interface IEventMessagesFactory
+    {
+        EventMessages CreateMessages();
+    }
+
+    /// <summary>
+    /// A simple/default transient messages factory
+    /// </summary>
+    internal class TransientMessagesFactory : IEventMessagesFactory
+    {
+        public EventMessages CreateMessages()
+        {
+            return new EventMessages();
+        }
+    }
+}

src/Umbraco.Core/Events/MessageType.cs

@@ -0,0 +1,14 @@
+namespace Umbraco.Core.Events
+{
+    /// <summary>
+    /// The type of event message
+    /// </summary>
+    public enum EventMessageType
+    {
+        Default = 0,
+        Info = 1,
+        Error = 2,
+        Success = 3,        
+        Warning = 4
+    }
+}

src/Umbraco.Core/Events/MoveEventArgs.cs

@@ -4,20 +4,6 @@ using System.Linq;
 
 namespace Umbraco.Core.Events
 {
-    public class MoveEventInfo<TEntity>
-    {
-        public MoveEventInfo(TEntity entity, string originalPath, int newParentId)
-        {
-            Entity = entity;
-            OriginalPath = originalPath;
-            NewParentId = newParentId;
-        }
-
-        public TEntity Entity { get; set; }
-        public string OriginalPath { get; set; }
-        public int NewParentId { get; set; }
-    }
-
     public class MoveEventArgs<TEntity> : CancellableObjectEventArgs<TEntity>
     {
         /// <summary>

src/Umbraco.Core/Events/MoveEventInfo.cs

@@ -0,0 +1,16 @@
+namespace Umbraco.Core.Events
+{
+    public class MoveEventInfo<TEntity>
+    {
+        public MoveEventInfo(TEntity entity, string originalPath, int newParentId)
+        {
+            Entity = entity;
+            OriginalPath = originalPath;
+            NewParentId = newParentId;
+        }
+
+        public TEntity Entity { get; set; }
+        public string OriginalPath { get; set; }
+        public int NewParentId { get; set; }
+    }
+}

src/Umbraco.Core/Events/NewEventArgs.cs

@@ -4,7 +4,39 @@ namespace Umbraco.Core.Events
 {
 	public class NewEventArgs<TEntity> : CancellableObjectEventArgs<TEntity>
 	{
-		public NewEventArgs(TEntity eventObject, bool canCancel, string @alias, int parentId) : base(eventObject, canCancel)
+
+
+        public NewEventArgs(TEntity eventObject, bool canCancel, string @alias, int parentId, EventMessages eventMessages)
+            : base(eventObject, canCancel, eventMessages)
+        {
+            Alias = alias;
+            ParentId = parentId;
+        }
+
+        public NewEventArgs(TEntity eventObject, bool canCancel, string @alias, TEntity parent, EventMessages eventMessages)
+            : base(eventObject, canCancel, eventMessages)
+        {
+            Alias = alias;
+            Parent = parent;
+        }
+
+        public NewEventArgs(TEntity eventObject, string @alias, int parentId, EventMessages eventMessages) 
+            : base(eventObject, eventMessages)
+        {
+            Alias = alias;
+            ParentId = parentId;
+        }
+
+        public NewEventArgs(TEntity eventObject, string @alias, TEntity parent, EventMessages eventMessages)
+            : base(eventObject, eventMessages)
+        {
+            Alias = alias;
+            Parent = parent;
+        }
+
+
+
+        public NewEventArgs(TEntity eventObject, bool canCancel, string @alias, int parentId) : base(eventObject, canCancel)
 		{
 			Alias = alias;
 			ParentId = parentId;

src/Umbraco.Core/Services/AuditService.cs

@@ -1,4 +1,5 @@
 using System;
+using Umbraco.Core.Events;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Persistence;
@@ -8,8 +9,8 @@ namespace Umbraco.Core.Services
 {
     public sealed class AuditService : RepositoryService, IAuditService
     {
-        public AuditService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger)
-            : base(provider, repositoryFactory, logger)
+        public AuditService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
         {
         }
 

src/Umbraco.Core/Services/ContentService.cs

@@ -38,37 +38,15 @@ namespace Umbraco.Core.Services
         //for example, the Move method needs to be locked but this calls the Save method which also needs to be locked.
         private static readonly ReaderWriterLockSlim Locker = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
 
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public ContentService()
-            : this(new RepositoryFactory(ApplicationContext.Current.ApplicationCache, LoggerResolver.Current.Logger, SqlSyntaxContext.SqlSyntaxProvider, UmbracoConfig.For.UmbracoSettings()))
-        { }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public ContentService(RepositoryFactory repositoryFactory)
-            : this(new PetaPocoUnitOfWorkProvider(LoggerResolver.Current.Logger), repositoryFactory, new PublishingStrategy())
-        { }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public ContentService(IDatabaseUnitOfWorkProvider provider)
-            : this(provider, new RepositoryFactory(ApplicationContext.Current.ApplicationCache, LoggerResolver.Current.Logger, SqlSyntaxContext.SqlSyntaxProvider, UmbracoConfig.For.UmbracoSettings()), new PublishingStrategy())
-        { }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public ContentService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory)
-            : this(provider, repositoryFactory, new PublishingStrategy())
-        { }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public ContentService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, IPublishingStrategy publishingStrategy)
-            : base(provider, repositoryFactory, LoggerResolver.Current.Logger)
-        {
-            if (publishingStrategy == null) throw new ArgumentNullException("publishingStrategy");
-            _dataTypeService = new DataTypeService(UowProvider, RepositoryFactory);
-            _userService = new UserService(UowProvider, RepositoryFactory);
-        }
-
-        public ContentService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IPublishingStrategy publishingStrategy, IDataTypeService dataTypeService, IUserService userService)
-            : base(provider, repositoryFactory, logger)
+        public ContentService(
+            IDatabaseUnitOfWorkProvider provider, 
+            RepositoryFactory repositoryFactory, 
+            ILogger logger,
+            IEventMessagesFactory eventMessagesFactory,
+            IPublishingStrategy publishingStrategy, 
+            IDataTypeService dataTypeService, 
+            IUserService userService)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
         {
             if (publishingStrategy == null) throw new ArgumentNullException("publishingStrategy");
             if (dataTypeService == null) throw new ArgumentNullException("dataTypeService");

src/Umbraco.Core/Services/ContentTypeService.cs

@@ -32,28 +32,8 @@ namespace Umbraco.Core.Services
         //for example, the Move method needs to be locked but this calls the Save method which also needs to be locked.
         private static readonly ReaderWriterLockSlim Locker = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
 
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public ContentTypeService(IContentService contentService, IMediaService mediaService)
-			: this(new PetaPocoUnitOfWorkProvider(LoggerResolver.Current.Logger), new RepositoryFactory(), contentService, mediaService)
-        {}
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public ContentTypeService( RepositoryFactory repositoryFactory, IContentService contentService, IMediaService mediaService)
-            : this(new PetaPocoUnitOfWorkProvider(), repositoryFactory, contentService, mediaService)
-        { }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public ContentTypeService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, IContentService contentService, IMediaService mediaService)
-            : base(provider, repositoryFactory, LoggerResolver.Current.Logger)
-        {
-            if (contentService == null) throw new ArgumentNullException("contentService");
-            if (mediaService == null) throw new ArgumentNullException("mediaService");
-	        _contentService = contentService;
-            _mediaService = mediaService;
-        }
-
-        public ContentTypeService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IContentService contentService, IMediaService mediaService)
-            : base(provider, repositoryFactory, logger)
+        public ContentTypeService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory, IContentService contentService, IMediaService mediaService)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
         {
             if (contentService == null) throw new ArgumentNullException("contentService");
             if (mediaService == null) throw new ArgumentNullException("mediaService");

src/Umbraco.Core/Services/ContentTypeServiceBase.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
+using Umbraco.Core.Events;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.EntityBase;
@@ -10,8 +11,8 @@ namespace Umbraco.Core.Services
 {
     public class ContentTypeServiceBase : RepositoryService
     {
-        public ContentTypeServiceBase(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger)
-            : base(provider, repositoryFactory, logger)
+        public ContentTypeServiceBase(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
         {
         }
 

src/Umbraco.Core/Services/DataTypeService.cs

@@ -21,31 +21,8 @@ namespace Umbraco.Core.Services
     public class DataTypeService : RepositoryService, IDataTypeService
     {
 
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public DataTypeService()
-            : this(new RepositoryFactory())
-        {}
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public DataTypeService(RepositoryFactory repositoryFactory)
-			: this(new PetaPocoUnitOfWorkProvider(), repositoryFactory)
-        {
-        }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public DataTypeService(IDatabaseUnitOfWorkProvider provider)
-            : this(provider, new RepositoryFactory())
-        {
-        }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-		public DataTypeService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory)
-            : this(provider, repositoryFactory, LoggerResolver.Current.Logger)
-        {
-        }
-
-        public DataTypeService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger)
-            : base(provider, repositoryFactory, logger)
+        public DataTypeService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
         {
         }
 

src/Umbraco.Core/Services/DomainService.cs

@@ -12,8 +12,8 @@ namespace Umbraco.Core.Services
 {
     public class DomainService : RepositoryService, IDomainService
     {
-        public DomainService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger)
-            : base(provider, repositoryFactory, logger)
+        public DomainService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
         {
         }
 

src/Umbraco.Core/Services/EntityService.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using Umbraco.Core.Cache;
 using Umbraco.Core.CodeAnnotations;
+using Umbraco.Core.Events;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.EntityBase;
@@ -18,10 +19,10 @@ namespace Umbraco.Core.Services
         private readonly Dictionary<string, Tuple<UmbracoObjectTypes, Func<int, IUmbracoEntity>>> _supportedObjectTypes;
         
 
-        public EntityService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger,
+        public EntityService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory,
            IContentService contentService, IContentTypeService contentTypeService, IMediaService mediaService, IDataTypeService dataTypeService,
            IMemberService memberService, IMemberTypeService memberTypeService, IRuntimeCacheProvider runtimeCache)
-            : base(provider, repositoryFactory, logger)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
         {
             _runtimeCache = runtimeCache;
             IContentTypeService contentTypeService1 = contentTypeService;

src/Umbraco.Core/Services/ExternalLoginService.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Microsoft.AspNet.Identity;
+using Umbraco.Core.Events;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models.Identity;
 using Umbraco.Core.Persistence;
@@ -11,8 +12,8 @@ namespace Umbraco.Core.Services
 {
     public class ExternalLoginService : RepositoryService, IExternalLoginService
     {
-        public ExternalLoginService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger)
-            : base(provider, repositoryFactory, logger)
+        public ExternalLoginService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
         {
         }
 

src/Umbraco.Core/Services/LocalizationService.cs

@@ -18,26 +18,10 @@ namespace Umbraco.Core.Services
     /// </summary>
     public class LocalizationService : RepositoryService, ILocalizationService
     {
+        
 
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public LocalizationService()
-            : this(new RepositoryFactory(ApplicationContext.Current.ApplicationCache, LoggerResolver.Current.Logger, SqlSyntaxContext.SqlSyntaxProvider, UmbracoConfig.For.UmbracoSettings()))
-        { }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public LocalizationService(RepositoryFactory repositoryFactory)
-            : this(new PetaPocoUnitOfWorkProvider(LoggerResolver.Current.Logger), repositoryFactory, LoggerResolver.Current.Logger)
-        {
-        }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public LocalizationService(IDatabaseUnitOfWorkProvider provider)
-            : this(provider, new RepositoryFactory(ApplicationContext.Current.ApplicationCache, LoggerResolver.Current.Logger, SqlSyntaxContext.SqlSyntaxProvider, UmbracoConfig.For.UmbracoSettings()), LoggerResolver.Current.Logger)
-        {
-        }
-
-        public LocalizationService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger)
-            : base(provider, repositoryFactory, logger)
+        public LocalizationService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
         {
         }
 

src/Umbraco.Core/Services/MacroService.cs

@@ -20,26 +20,8 @@ namespace Umbraco.Core.Services
     public class MacroService : RepositoryService, IMacroService
     {
 
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public MacroService()
-            : this(new PetaPocoUnitOfWorkProvider(), new RepositoryFactory())
-        {
-        }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public MacroService(IDatabaseUnitOfWorkProvider provider)
-            : this(provider, new RepositoryFactory())
-        {
-        }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public MacroService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory)
-            : this(provider, repositoryFactory, LoggerResolver.Current.Logger)
-        {
-        }
-
-        public MacroService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger)
-            : base(provider, repositoryFactory, logger)
+        public MacroService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
         {
         }
 

src/Umbraco.Core/Services/MediaService.cs

@@ -35,29 +35,9 @@ namespace Umbraco.Core.Services
         private readonly EntityXmlSerializer _entitySerializer = new EntityXmlSerializer();
         private readonly IDataTypeService _dataTypeService;
         private readonly IUserService _userService;
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public MediaService(RepositoryFactory repositoryFactory)
-            : this(new PetaPocoUnitOfWorkProvider(), repositoryFactory)
-        {
-        }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public MediaService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory)
-            : base(provider, repositoryFactory, LoggerResolver.Current.Logger)
-        {
-            _dataTypeService = new DataTypeService(provider, repositoryFactory);
-            _userService = new UserService(provider, repositoryFactory);
-        }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public MediaService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, IDataTypeService dataTypeService, IUserService userService)
-            : this(provider, repositoryFactory, LoggerResolver.Current.Logger, dataTypeService, userService)
-        {
-        }
-
-        public MediaService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IDataTypeService dataTypeService, IUserService userService)
-            : base(provider, repositoryFactory, logger)
+        
+        public MediaService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory, IDataTypeService dataTypeService, IUserService userService)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
         {
             if (dataTypeService == null) throw new ArgumentNullException("dataTypeService");
             if (userService == null) throw new ArgumentNullException("userService");

src/Umbraco.Core/Services/MemberGroupService.cs

@@ -14,26 +14,8 @@ namespace Umbraco.Core.Services
     public class MemberGroupService : RepositoryService, IMemberGroupService
     {
 
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public MemberGroupService(RepositoryFactory repositoryFactory)
-            : this(new PetaPocoUnitOfWorkProvider(), repositoryFactory)
-        {
-        }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public MemberGroupService(IDatabaseUnitOfWorkProvider provider)
-            : this(provider, new RepositoryFactory())
-        {
-        }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public MemberGroupService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory)
-            : this(provider, repositoryFactory, LoggerResolver.Current.Logger)
-        {            
-        }
-
-        public MemberGroupService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger)
-            : base(provider, repositoryFactory, logger)
+        public MemberGroupService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
         {
             //Proxy events!
             MemberGroupRepository.SavedMemberGroup += MemberGroupRepository_SavedMemberGroup;

src/Umbraco.Core/Services/MemberService.cs

@@ -30,37 +30,9 @@ namespace Umbraco.Core.Services
         private readonly EntityXmlSerializer _entitySerializer = new EntityXmlSerializer();
         private readonly IDataTypeService _dataTypeService;
         private static readonly ReaderWriterLockSlim Locker = new ReaderWriterLockSlim();
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public MemberService(RepositoryFactory repositoryFactory, IMemberGroupService memberGroupService)
-            : this(new PetaPocoUnitOfWorkProvider(), repositoryFactory, memberGroupService)
-        {
-        }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public MemberService(IDatabaseUnitOfWorkProvider provider, IMemberGroupService memberGroupService)
-            : this(provider, new RepositoryFactory(), memberGroupService)
-        {
-        }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public MemberService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, IMemberGroupService memberGroupService)
-            : base(provider, repositoryFactory, LoggerResolver.Current.Logger)
-        {
-            if (memberGroupService == null) throw new ArgumentNullException("memberGroupService");
-            _memberGroupService = memberGroupService;
-            _dataTypeService = new DataTypeService(provider, repositoryFactory);
-        }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public MemberService(IDatabaseUnitOfWorkProvider provider, IMemberGroupService memberGroupService, IDataTypeService dataTypeService)
-            : this(provider, new RepositoryFactory(), LoggerResolver.Current.Logger, memberGroupService, dataTypeService)
-        {
-
-        }
-
-        public MemberService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IMemberGroupService memberGroupService, IDataTypeService dataTypeService)
-            : base(provider, repositoryFactory, logger)
+        
+        public MemberService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory, IMemberGroupService memberGroupService, IDataTypeService dataTypeService)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
         {
             if (memberGroupService == null) throw new ArgumentNullException("memberGroupService");
             if (dataTypeService == null) throw new ArgumentNullException("dataTypeService");

src/Umbraco.Core/Services/MemberTypeService.cs

@@ -17,25 +17,10 @@ namespace Umbraco.Core.Services
         private readonly IMemberService _memberService;
 
         private static readonly ReaderWriterLockSlim Locker = new ReaderWriterLockSlim();
+        
 
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public MemberTypeService(IMemberService memberService)
-            : this(new PetaPocoUnitOfWorkProvider(), new RepositoryFactory(), memberService)
-        {}
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public MemberTypeService(RepositoryFactory repositoryFactory, IMemberService memberService)
-            : this(new PetaPocoUnitOfWorkProvider(), repositoryFactory, memberService)
-        { }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public MemberTypeService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, IMemberService memberService)
-            : this(provider, repositoryFactory, LoggerResolver.Current.Logger, memberService)
-        {
-        }
-
-        public MemberTypeService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IMemberService memberService)
-            : base(provider, repositoryFactory, logger)
+        public MemberTypeService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory, IMemberService memberService)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
         {
             if (memberService == null) throw new ArgumentNullException("memberService");
             _memberService = memberService;

src/Umbraco.Core/Services/MigrationEntryService.cs

@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using Semver;
+using Umbraco.Core.Events;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Persistence;
@@ -15,8 +16,8 @@ namespace Umbraco.Core.Services
     /// </summary>
     public sealed class MigrationEntryService : RepositoryService, IMigrationEntryService
     {
-        public MigrationEntryService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger)
-            : base(provider, repositoryFactory, logger)
+        public MigrationEntryService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
         {
         }
 

src/Umbraco.Core/Services/PublicAccessService.cs

@@ -12,8 +12,8 @@ namespace Umbraco.Core.Services
 {
     public class PublicAccessService : RepositoryService, IPublicAccessService
     {
-        public PublicAccessService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger)
-            : base(provider, repositoryFactory, logger)
+        public PublicAccessService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
         {
         }
 

src/Umbraco.Core/Services/RelationService.cs

@@ -14,15 +14,9 @@ namespace Umbraco.Core.Services
     public class RelationService : RepositoryService, IRelationService
     {
         private readonly IEntityService _entityService;
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public RelationService(IDatabaseUnitOfWorkProvider uowProvider, RepositoryFactory repositoryFactory, IEntityService entityService)
-            : this(uowProvider, repositoryFactory, LoggerResolver.Current.Logger, entityService)
-        {
-        }
-
-        public RelationService(IDatabaseUnitOfWorkProvider uowProvider, RepositoryFactory repositoryFactory, ILogger logger, IEntityService entityService)
-            : base(uowProvider, repositoryFactory, logger)
+        
+        public RelationService(IDatabaseUnitOfWorkProvider uowProvider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory, IEntityService entityService)
+            : base(uowProvider, repositoryFactory, logger, eventMessagesFactory)
         {
             if (entityService == null) throw new ArgumentNullException("entityService");
             _entityService = entityService;

src/Umbraco.Core/Services/RepositoryService.cs

@@ -1,4 +1,5 @@
 using System;
+using Umbraco.Core.Events;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.UnitOfWork;
@@ -11,15 +12,18 @@ namespace Umbraco.Core.Services
     public abstract class RepositoryService : IService
     {
         protected ILogger Logger { get; private set; }
+        protected IEventMessagesFactory EventMessagesFactory { get; private set; }
         protected RepositoryFactory RepositoryFactory { get; private set; }
         protected IDatabaseUnitOfWorkProvider UowProvider { get; private set; }
 
-        protected RepositoryService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger)
+        protected RepositoryService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory)
         {
             if (provider == null) throw new ArgumentNullException("provider");
             if (repositoryFactory == null) throw new ArgumentNullException("repositoryFactory");
             if (logger == null) throw new ArgumentNullException("logger");
+            if (eventMessagesFactory == null) throw new ArgumentNullException("eventMessagesFactory");
             Logger = logger;
+            EventMessagesFactory = eventMessagesFactory;
             RepositoryFactory = repositoryFactory;
             UowProvider = provider;
         }

src/Umbraco.Core/Services/ServerRegistrationService.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Umbraco.Core.Events;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Persistence;
@@ -20,8 +21,9 @@ namespace Umbraco.Core.Services
         /// <param name="uowProvider">A UnitOfWork provider.</param>
         /// <param name="repositoryFactory">A repository factory.</param>
         /// <param name="logger">A logger.</param>
-        public ServerRegistrationService(IDatabaseUnitOfWorkProvider uowProvider, RepositoryFactory repositoryFactory, ILogger logger)
-            : base(uowProvider, repositoryFactory, logger)
+        /// <param name="eventMessagesFactory"></param>
+        public ServerRegistrationService(IDatabaseUnitOfWorkProvider uowProvider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory)
+            : base(uowProvider, repositoryFactory, logger, eventMessagesFactory)
         { }
 
         /// <summary>

src/Umbraco.Core/Services/ServiceContext.cs

@@ -8,6 +8,7 @@ using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.UnitOfWork;
 using Umbraco.Core.Publishing;
 using umbraco.interfaces;
+using Umbraco.Core.Events;
 
 namespace Umbraco.Core.Services
 {
@@ -136,17 +137,27 @@ namespace Umbraco.Core.Services
         /// <param name="publishingStrategy"></param>
         /// <param name="cache"></param>
         /// <param name="logger"></param>
+        /// <param name="eventMessagesFactory"></param>
         public ServiceContext(
             RepositoryFactory repositoryFactory,
             IDatabaseUnitOfWorkProvider dbUnitOfWorkProvider, 
             IUnitOfWorkProvider fileUnitOfWorkProvider, 
             BasePublishingStrategy publishingStrategy, 
             CacheHelper cache, 
-            ILogger logger)
+            ILogger logger,
+            IEventMessagesFactory eventMessagesFactory)
         {
+            if (repositoryFactory == null) throw new ArgumentNullException("repositoryFactory");
+            if (dbUnitOfWorkProvider == null) throw new ArgumentNullException("dbUnitOfWorkProvider");
+            if (fileUnitOfWorkProvider == null) throw new ArgumentNullException("fileUnitOfWorkProvider");
+            if (publishingStrategy == null) throw new ArgumentNullException("publishingStrategy");
+            if (cache == null) throw new ArgumentNullException("cache");
+            if (logger == null) throw new ArgumentNullException("logger");
+            if (eventMessagesFactory == null) throw new ArgumentNullException(nameof(eventMessagesFactory));
+
             BuildServiceCache(dbUnitOfWorkProvider, fileUnitOfWorkProvider, publishingStrategy, cache,
                               repositoryFactory,
-                              logger);
+                              logger, eventMessagesFactory);
         }
 
         /// <summary>
@@ -158,28 +169,29 @@ namespace Umbraco.Core.Services
             BasePublishingStrategy publishingStrategy,
             CacheHelper cache,
             RepositoryFactory repositoryFactory,
-            ILogger logger)
+            ILogger logger,
+            IEventMessagesFactory eventMessagesFactory)
         {
             var provider = dbUnitOfWorkProvider;
             var fileProvider = fileUnitOfWorkProvider;
 
             if (_migrationEntryService == null)
-                _migrationEntryService = new Lazy<IMigrationEntryService>(() => new MigrationEntryService(provider, repositoryFactory, logger));
+                _migrationEntryService = new Lazy<IMigrationEntryService>(() => new MigrationEntryService(provider, repositoryFactory, logger, eventMessagesFactory));
 
             if (_externalLoginService == null)
-                _externalLoginService = new Lazy<IExternalLoginService>(() => new ExternalLoginService(provider, repositoryFactory, logger));
+                _externalLoginService = new Lazy<IExternalLoginService>(() => new ExternalLoginService(provider, repositoryFactory, logger, eventMessagesFactory));
 
             if (_publicAccessService == null)
-                _publicAccessService = new Lazy<IPublicAccessService>(() => new PublicAccessService(provider, repositoryFactory, logger));
+                _publicAccessService = new Lazy<IPublicAccessService>(() => new PublicAccessService(provider, repositoryFactory, logger, eventMessagesFactory));
 
             if (_taskService == null)
-                _taskService = new Lazy<ITaskService>(() => new TaskService(provider, repositoryFactory, logger));
+                _taskService = new Lazy<ITaskService>(() => new TaskService(provider, repositoryFactory, logger, eventMessagesFactory));
 
             if (_domainService == null)
-                _domainService = new Lazy<IDomainService>(() => new DomainService(provider, repositoryFactory, logger));
+                _domainService = new Lazy<IDomainService>(() => new DomainService(provider, repositoryFactory, logger, eventMessagesFactory));
 
             if (_auditService == null)
-                _auditService = new Lazy<IAuditService>(() => new AuditService(provider, repositoryFactory, logger));
+                _auditService = new Lazy<IAuditService>(() => new AuditService(provider, repositoryFactory, logger, eventMessagesFactory));
 
             if (_localizedTextService == null)
             {
@@ -222,43 +234,43 @@ namespace Umbraco.Core.Services
                 _notificationService = new Lazy<INotificationService>(() => new NotificationService(provider, _userService.Value, _contentService.Value, logger));
 
             if (_serverRegistrationService == null)
-                _serverRegistrationService = new Lazy<IServerRegistrationService>(() => new ServerRegistrationService(provider, repositoryFactory, logger));
+                _serverRegistrationService = new Lazy<IServerRegistrationService>(() => new ServerRegistrationService(provider, repositoryFactory, logger, eventMessagesFactory));
 
             if (_userService == null)
-                _userService = new Lazy<IUserService>(() => new UserService(provider, repositoryFactory, logger));
+                _userService = new Lazy<IUserService>(() => new UserService(provider, repositoryFactory, logger, eventMessagesFactory));
 
             if (_memberService == null)
-                _memberService = new Lazy<IMemberService>(() => new MemberService(provider, repositoryFactory, logger, _memberGroupService.Value, _dataTypeService.Value));
+                _memberService = new Lazy<IMemberService>(() => new MemberService(provider, repositoryFactory, logger, eventMessagesFactory, _memberGroupService.Value, _dataTypeService.Value));
 
             if (_contentService == null)
-                _contentService = new Lazy<IContentService>(() => new ContentService(provider, repositoryFactory, logger, publishingStrategy, _dataTypeService.Value, _userService.Value));
+                _contentService = new Lazy<IContentService>(() => new ContentService(provider, repositoryFactory, logger, eventMessagesFactory, publishingStrategy, _dataTypeService.Value, _userService.Value));
 
             if (_mediaService == null)
-                _mediaService = new Lazy<IMediaService>(() => new MediaService(provider, repositoryFactory, logger, _dataTypeService.Value, _userService.Value));
+                _mediaService = new Lazy<IMediaService>(() => new MediaService(provider, repositoryFactory, logger, eventMessagesFactory, _dataTypeService.Value, _userService.Value));
 
             if (_contentTypeService == null)
-                _contentTypeService = new Lazy<IContentTypeService>(() => new ContentTypeService(provider, repositoryFactory, logger, _contentService.Value, _mediaService.Value));
+                _contentTypeService = new Lazy<IContentTypeService>(() => new ContentTypeService(provider, repositoryFactory, logger, eventMessagesFactory, _contentService.Value, _mediaService.Value));
 
             if (_dataTypeService == null)
-                _dataTypeService = new Lazy<IDataTypeService>(() => new DataTypeService(provider, repositoryFactory, logger));
+                _dataTypeService = new Lazy<IDataTypeService>(() => new DataTypeService(provider, repositoryFactory, logger, eventMessagesFactory));
 
             if (_fileService == null)
                 _fileService = new Lazy<IFileService>(() => new FileService(fileProvider, provider, repositoryFactory));
 
             if (_localizationService == null)
-                _localizationService = new Lazy<ILocalizationService>(() => new LocalizationService(provider, repositoryFactory, logger));
+                _localizationService = new Lazy<ILocalizationService>(() => new LocalizationService(provider, repositoryFactory, logger, eventMessagesFactory));
 
             if (_packagingService == null)
                 _packagingService = new Lazy<IPackagingService>(() => new PackagingService(logger, _contentService.Value, _contentTypeService.Value, _mediaService.Value, _macroService.Value, _dataTypeService.Value, _fileService.Value, _localizationService.Value, _userService.Value, repositoryFactory, provider));
 
             if (_entityService == null)
                 _entityService = new Lazy<IEntityService>(() => new EntityService(
-                    provider, repositoryFactory, logger, 
+                    provider, repositoryFactory, logger, eventMessagesFactory, 
                     _contentService.Value, _contentTypeService.Value, _mediaService.Value, _dataTypeService.Value, _memberService.Value, _memberTypeService.Value,
                     cache.RuntimeCache));
 
             if (_relationService == null)
-                _relationService = new Lazy<IRelationService>(() => new RelationService(provider, repositoryFactory, logger, _entityService.Value));
+                _relationService = new Lazy<IRelationService>(() => new RelationService(provider, repositoryFactory, logger, eventMessagesFactory, _entityService.Value));
 
             if (_treeService == null)
                 _treeService = new Lazy<IApplicationTreeService>(() => new ApplicationTreeService(logger, cache));
@@ -267,16 +279,16 @@ namespace Umbraco.Core.Services
                 _sectionService = new Lazy<ISectionService>(() => new SectionService(_userService.Value, _treeService.Value, provider, cache));
 
             if (_macroService == null)
-                _macroService = new Lazy<IMacroService>(() => new MacroService(provider, repositoryFactory, logger));
+                _macroService = new Lazy<IMacroService>(() => new MacroService(provider, repositoryFactory, logger, eventMessagesFactory));
 
             if (_memberTypeService == null)
-                _memberTypeService = new Lazy<IMemberTypeService>(() => new MemberTypeService(provider, repositoryFactory, logger, _memberService.Value));
+                _memberTypeService = new Lazy<IMemberTypeService>(() => new MemberTypeService(provider, repositoryFactory, logger, eventMessagesFactory, _memberService.Value));
 
             if (_tagService == null)
-                _tagService = new Lazy<ITagService>(() => new TagService(provider, repositoryFactory, logger));
+                _tagService = new Lazy<ITagService>(() => new TagService(provider, repositoryFactory, logger, eventMessagesFactory));
 
             if (_memberGroupService == null)
-                _memberGroupService = new Lazy<IMemberGroupService>(() => new MemberGroupService(provider, repositoryFactory, logger));
+                _memberGroupService = new Lazy<IMemberGroupService>(() => new MemberGroupService(provider, repositoryFactory, logger, eventMessagesFactory));
 
         }
 

src/Umbraco.Core/Services/TagService.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Umbraco.Core.Events;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Persistence;
@@ -16,32 +17,9 @@ namespace Umbraco.Core.Services
     /// </remarks>
     public class TagService : RepositoryService, ITagService
     {
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public TagService()
-            : this(new RepositoryFactory())
-        {}
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public TagService(RepositoryFactory repositoryFactory)
-            : this(new PetaPocoUnitOfWorkProvider(), repositoryFactory)
-        {
-        }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public TagService(IDatabaseUnitOfWorkProvider provider)
-            : this(provider, new RepositoryFactory())
-        {
-        }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public TagService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory)
-            : this(provider, repositoryFactory, LoggerResolver.Current.Logger)
-        {
-        }
-
-        public TagService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger)
-            : base(provider, repositoryFactory, logger)
+      
+        public TagService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
         {
         }
 

src/Umbraco.Core/Services/TaskService.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
+using Umbraco.Core.Events;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Persistence;
@@ -11,8 +12,8 @@ namespace Umbraco.Core.Services
 {
     public class TaskService : RepositoryService, ITaskService
     {
-        public TaskService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger)
-            : base(provider, repositoryFactory, logger)
+        public TaskService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
         {
         }
 

src/Umbraco.Core/Services/UserService.cs

@@ -17,25 +17,8 @@ namespace Umbraco.Core.Services
     /// </summary>
     public class UserService : RepositoryService, IUserService
     {
-      
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public UserService(RepositoryFactory repositoryFactory)
-            : this(new PetaPocoUnitOfWorkProvider(), repositoryFactory)
-        { }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public UserService(IDatabaseUnitOfWorkProvider provider)
-            : this(provider, new RepositoryFactory())
-        { }
-
-        [Obsolete("Use the constructors that specify all dependencies instead")]
-        public UserService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory)
-            : base(provider, repositoryFactory, LoggerResolver.Current.Logger)
-        {
-        }
-
-        public UserService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger)
-            : base(provider, repositoryFactory, logger)
+        public UserService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
         {
         }
 

src/Umbraco.Core/Standalone/ServiceContextManager.cs

@@ -2,6 +2,7 @@
 using System.Diagnostics;
 using Umbraco.Core.Cache;
 using Umbraco.Core.Configuration;
+using Umbraco.Core.Events;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.Mappers;
@@ -68,7 +69,8 @@ namespace Umbraco.Core.Standalone
                         new FileUnitOfWorkProvider(),
                         new PublishingStrategy(),
                         cacheHelper,
-                        new DebugDiagnosticsLogger());
+                        new DebugDiagnosticsLogger(),
+                        new TransientMessagesFactory());
 
                     //initialize the DatabaseContext
                     dbContext.Initialize(_providerName);

src/Umbraco.Core/Umbraco.Core.csproj

@@ -313,10 +313,16 @@
     <Compile Include="Events\CancellableObjectEventArgs.cs" />
     <Compile Include="Events\DeleteRevisionsEventArgs.cs" />
     <Compile Include="Events\EventExtensions.cs" />
+    <Compile Include="Events\EventMessage.cs" />
+    <Compile Include="Events\EventMessages.cs" />
+    <Compile Include="Events\EventMessagesFactoryResolver.cs" />
     <Compile Include="Events\ExportEventArgs.cs" />
+    <Compile Include="Events\IEventMessagesFactory.cs" />
     <Compile Include="Events\ImportEventArgs.cs" />
     <Compile Include="Events\ImportPackageEventArgs.cs" />
+    <Compile Include="Events\MessageType.cs" />
     <Compile Include="Events\MigrationEventArgs.cs" />
+    <Compile Include="Events\MoveEventInfo.cs" />
     <Compile Include="Events\PublishEventArgs.cs" />
     <Compile Include="Events\RecycleBinEventArgs.cs" />
     <Compile Include="Events\TypedEventHandler.cs" />

src/Umbraco.Tests/Mvc/UmbracoViewPageTests.cs

@@ -18,6 +18,7 @@ using Umbraco.Core.Services;
 using Umbraco.Web.Security;
 using umbraco.BusinessLogic;
 using Umbraco.Core;
+using Umbraco.Core.Events;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.PublishedContent;
 using Umbraco.Tests.PublishedContent;
@@ -400,6 +401,7 @@ namespace Umbraco.Tests.Mvc
                     new Mock<IDatabaseUnitOfWorkProvider>().Object,
                     new RepositoryFactory(CacheHelper.CreateDisabledCacheHelper(), logger, Mock.Of<ISqlSyntaxProvider>(), umbracoSettings),
                     logger,
+                    new TransientMessagesFactory(),
                     new Mock<IEntityService>().Object),
                 new Mock<IMemberGroupService>().Object,
                 new Mock<IMemberTypeService>().Object,

src/Umbraco.Tests/Persistence/BaseTableByTableTest.cs

@@ -6,6 +6,7 @@ using Umbraco.Core;
 using Umbraco.Core.Cache;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Configuration.UmbracoSettings;
+using Umbraco.Core.Events;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models.Rdbms;
 using Umbraco.Core.ObjectResolution;
@@ -59,7 +60,7 @@ namespace Umbraco.Tests.Persistence
                 //assign the db context
                 dbContext,
                 //assign the service context
-                new ServiceContext(repositoryFactory, new PetaPocoUnitOfWorkProvider(_logger), new FileUnitOfWorkProvider(), new PublishingStrategy(), cacheHelper, _logger),                
+                new ServiceContext(repositoryFactory, new PetaPocoUnitOfWorkProvider(_logger), new FileUnitOfWorkProvider(), new PublishingStrategy(), cacheHelper, _logger, new TransientMessagesFactory()),                
                 cacheHelper,
                 new ProfilingLogger(_logger, Mock.Of<IProfiler>()))
                 {

src/Umbraco.Tests/Services/ThreadSafetyServiceTest.cs

@@ -18,6 +18,7 @@ using Umbraco.Tests.TestHelpers;
 using Umbraco.Tests.TestHelpers.Entities;
 using umbraco.editorControls.tinyMCE3;
 using umbraco.interfaces;
+using Umbraco.Core.Events;
 
 namespace Umbraco.Tests.Services
 {
@@ -55,7 +56,8 @@ namespace Umbraco.Tests.Services
                 new FileUnitOfWorkProvider(), 
                 new PublishingStrategy(), 
                 cacheHelper, 
-                Logger);
+                Logger,
+                new TransientMessagesFactory());
 
 			CreateTestData();
 		}

src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs

@@ -30,6 +30,7 @@ using Umbraco.Web.PublishedCache.XmlPublishedCache;
 using Umbraco.Web.Routing;
 using Umbraco.Web.Security;
 using umbraco.BusinessLogic;
+using Umbraco.Core.Events;
 
 namespace Umbraco.Tests.TestHelpers
 {
@@ -79,7 +80,7 @@ namespace Umbraco.Tests.TestHelpers
                 //assign the db context
                 new DatabaseContext(dbFactory, Logger, SqlSyntax, "System.Data.SqlServerCe.4.0"),
                 //assign the service context
-                new ServiceContext(repositoryFactory, new PetaPocoUnitOfWorkProvider(dbFactory), new FileUnitOfWorkProvider(), new PublishingStrategy(), cacheHelper, Logger),
+                new ServiceContext(repositoryFactory, new PetaPocoUnitOfWorkProvider(dbFactory), new FileUnitOfWorkProvider(), new PublishingStrategy(), cacheHelper, Logger, new TransientMessagesFactory()),
                 cacheHelper,
                 ProfilingLogger)
             {

src/Umbraco.Tests/TestHelpers/BaseUmbracoApplicationTest.cs

@@ -19,6 +19,7 @@ using Umbraco.Core.Services;
 using Umbraco.Web;
 using Umbraco.Web.Models.Mapping;
 using umbraco.BusinessLogic;
+using Umbraco.Core.Events;
 using ObjectExtensions = Umbraco.Core.ObjectExtensions;
 
 namespace Umbraco.Tests.TestHelpers
@@ -157,7 +158,7 @@ namespace Umbraco.Tests.TestHelpers
                 new DatabaseContext(new DefaultDatabaseFactory(Core.Configuration.GlobalSettings.UmbracoConnectionName, Logger),
                     Logger, sqlSyntax, "System.Data.SqlServerCe.4.0"),
                 //assign the service context
-                new ServiceContext(repoFactory, new PetaPocoUnitOfWorkProvider(Logger), new FileUnitOfWorkProvider(), new PublishingStrategy(), CacheHelper, Logger),
+                new ServiceContext(repoFactory, new PetaPocoUnitOfWorkProvider(Logger), new FileUnitOfWorkProvider(), new PublishingStrategy(), CacheHelper, Logger, new TransientMessagesFactory()),
                 CacheHelper,
                 ProfilingLogger)
             {

src/Umbraco.Web/RequestLifespanMessagesFactory.cs

@@ -0,0 +1,28 @@
+using System;
+using Umbraco.Core.Events;
+
+namespace Umbraco.Web
+{
+    /// <summary>
+    /// Stores the instance of EventMessages in the current request so all events will share the same instance
+    /// </summary>
+    internal class RequestLifespanMessagesFactory : IEventMessagesFactory
+    {
+        private readonly IUmbracoContextAccessor _ctxAccessor;
+
+        public RequestLifespanMessagesFactory(IUmbracoContextAccessor ctxAccessor)
+        {
+            if (ctxAccessor == null) throw new ArgumentNullException("ctxAccessor");
+            _ctxAccessor = ctxAccessor;
+        }
+
+        public EventMessages CreateMessages()
+        {
+            if (_ctxAccessor.Value.HttpContext.Items[typeof (RequestLifespanMessagesFactory).Name] == null)
+            {
+                _ctxAccessor.Value.HttpContext.Items[typeof(RequestLifespanMessagesFactory).Name] = new EventMessages();
+            }
+            return (EventMessages)_ctxAccessor.Value.HttpContext.Items[typeof (RequestLifespanMessagesFactory).Name];
+        }
+    }
+}

src/Umbraco.Web/Standalone/ServiceContextManager.cs

@@ -3,6 +3,7 @@ using System.Diagnostics;
 using Umbraco.Core;
 using Umbraco.Core.Cache;
 using Umbraco.Core.Configuration;
+using Umbraco.Core.Events;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.Mappers;
@@ -62,7 +63,8 @@ namespace Umbraco.Web.Standalone
                         new FileUnitOfWorkProvider(),
                         new PublishingStrategy(),
                         cacheHelper,
-                        new DebugDiagnosticsLogger());
+                        new DebugDiagnosticsLogger(),
+                        new TransientMessagesFactory());
 
                     //initialize the DatabaseContext
                     dbContext.Initialize(_providerName);

src/Umbraco.Web/Umbraco.Web.csproj

@@ -304,6 +304,7 @@
     <Compile Include="HtmlHelperBackOfficeExtensions.cs" />
     <Compile Include="Media\EmbedProviders\Flickr.cs" />
     <Compile Include="PropertyEditors\DatePreValueEditor.cs" />
+    <Compile Include="RequestLifespanMessagesFactory.cs" />
     <Compile Include="Scheduling\LatchedBackgroundTaskBase.cs" />
     <Compile Include="Security\Identity\ExternalSignInAutoLinkOptions.cs" />
     <Compile Include="Security\Identity\GetUserSecondsMiddleWare.cs" />

src/Umbraco.Web/WebBootManager.cs

@@ -38,6 +38,10 @@ using Umbraco.Web.Scheduling;
 using Umbraco.Web.UI.JavaScript;
 using Umbraco.Web.WebApi;
 using umbraco.BusinessLogic;
+using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence.UnitOfWork;
+using Umbraco.Core.Publishing;
+using Umbraco.Core.Services;
 using GlobalSettings = Umbraco.Core.Configuration.GlobalSettings;
 using ProfilingViewEngine = Umbraco.Core.Profiling.ProfilingViewEngine;
 
@@ -71,6 +75,25 @@ namespace Umbraco.Web
             _isForTesting = isForTesting;
         }
 
+        /// <summary>
+        /// Creates and returns the service context for the app
+        /// </summary>
+        /// <param name="dbContext"></param>
+        /// <param name="dbFactory"></param>
+        /// <returns></returns>
+        protected override ServiceContext CreateServiceContext(DatabaseContext dbContext, IDatabaseFactory dbFactory)
+        {
+            return new ServiceContext(
+                new RepositoryFactory(ApplicationCache, ProfilingLogger.Logger, dbContext.SqlSyntax, UmbracoConfig.For.UmbracoSettings()),
+                new PetaPocoUnitOfWorkProvider(dbFactory),
+                new FileUnitOfWorkProvider(),
+                new PublishingStrategy(),
+                ApplicationCache,
+                ProfilingLogger.Logger,
+                //use a request based messaging factory
+                new RequestLifespanMessagesFactory(new SingletonUmbracoContextAccessor()));
+        }
+
         /// <summary>
         /// Initialize objects before anything during the boot cycle happens
         /// </summary>
@@ -157,15 +180,7 @@ namespace Umbraco.Web
             //Set the profiler to be the web profiler
             ProfilerResolver.Current.SetProfiler(new WebProfiler());
         }
-
-        /// <summary>
-        /// Adds custom types to the ApplicationEventsResolver
-        /// </summary>
-        protected override void InitializeApplicationEventsResolver()
-        {
-            base.InitializeApplicationEventsResolver();
-        }
-
+        
         /// <summary>
         /// Ensure that the OnApplicationStarted methods of the IApplicationEvents are called
         /// </summary>
@@ -285,7 +300,6 @@ namespace Umbraco.Web
             }
         }
 
-
         private void RouteLocalApiController(Type controller, string umbracoPath)
         {
             var meta = PluginController.GetMetadata(controller);
@@ -307,6 +321,7 @@ namespace Umbraco.Web
             }
             route.DataTokens.Add("umbraco", "api"); //ensure the umbraco token is set
         }
+
         private void RouteLocalSurfaceController(Type controller, string umbracoPath)
         {
             var meta = PluginController.GetMetadata(controller);
@@ -473,7 +488,6 @@ namespace Umbraco.Web
                 new DefaultCultureDictionaryFactory());
         }
 
-
         private void OnInstanceOnBuildingEmptyIndexOnStartup(object sender, BuildingEmptyIndexOnStartupEventArgs args)
         {
             //store the indexer that needs rebuilding because it's empty for when the boot process