Merge remote-tracking branch 'origin/v8/dev' into v8/feature/media-tracking

# Conflicts:
#	src/Umbraco.Core/Migrations/Upgrade/UmbracoPlan.cs
#	src/Umbraco.Core/Models/RelationType.cs
#	src/Umbraco.Web/PropertyEditors/NestedContentPropertyEditor.cs
#	src/Umbraco.Web/UmbracoComponentRenderer.cs

src/Umbraco.Core/Collections/ConcurrentHashSet.cs

@@ -70,7 +70,23 @@ namespace Umbraco.Core.Collections
         /// The number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
         /// </returns>
         /// <filterpriority>2</filterpriority>
-        public int Count => GetThreadSafeClone().Count;
+        public int Count
+        {
+            get
+            {
+                try
+                {
+                    _instanceLocker.EnterReadLock();
+                    return _innerSet.Count;
+                }
+                finally
+                {
+                    if (_instanceLocker.IsReadLockHeld)
+                        _instanceLocker.ExitReadLock();
+                }
+
+            }
+        }
 
         /// <summary>
         /// Gets a value indicating whether the <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only.
@@ -105,8 +121,7 @@ namespace Umbraco.Core.Collections
         /// <returns></returns>
         public bool TryAdd(T item)
         {
-            var clone = GetThreadSafeClone();
-            if (clone.Contains(item)) return false;
+            if (Contains(item)) return false;
             try
             {
                 _instanceLocker.EnterWriteLock();
@@ -150,7 +165,16 @@ namespace Umbraco.Core.Collections
         /// <param name="item">The object to locate in the <see cref="T:System.Collections.Generic.ICollection`1"/>.</param>
         public bool Contains(T item)
         {
-            return GetThreadSafeClone().Contains(item);
+            try
+            {
+                _instanceLocker.EnterReadLock();
+                return _innerSet.Contains(item);
+            }
+            finally
+            {
+                if (_instanceLocker.IsReadLockHeld)
+                    _instanceLocker.ExitReadLock();
+            }
         }
 
         /// <summary>
@@ -168,13 +192,13 @@ namespace Umbraco.Core.Collections
             HashSet<T> clone = null;
             try
             {
-                _instanceLocker.EnterWriteLock();
+                _instanceLocker.EnterReadLock();
                 clone = new HashSet<T>(_innerSet, _innerSet.Comparer);
             }
             finally
             {
-                if (_instanceLocker.IsWriteLockHeld)
-                    _instanceLocker.ExitWriteLock();
+                if (_instanceLocker.IsReadLockHeld)
+                    _instanceLocker.ExitReadLock();
             }
             return clone;
         }

src/Umbraco.Core/Collections/ObservableDictionary.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
+using System.Runtime.Serialization;
 
 namespace Umbraco.Core.Collections
 {
@@ -26,7 +27,7 @@ namespace Umbraco.Core.Collections
         /// <param name="equalityComparer">The equality comparer to use when comparing keys, or null to use the default comparer.</param>
         public ObservableDictionary(Func<TValue, TKey> keySelector, IEqualityComparer<TKey> equalityComparer = null)
         {
-            KeySelector = keySelector ?? throw new ArgumentException("keySelector");
+            KeySelector = keySelector ?? throw new ArgumentException(nameof(keySelector));
             Indecies = new Dictionary<TKey, int>(equalityComparer);
         }
 
@@ -36,7 +37,7 @@ namespace Umbraco.Core.Collections
         {
             var key = KeySelector(item);
             if (Indecies.ContainsKey(key))
-                throw new DuplicateKeyException(key.ToString());
+                throw new ArgumentException($"An element with the same key '{key}' already exists in the dictionary.", nameof(item));
 
             if (index != Count)
             {
@@ -91,7 +92,7 @@ namespace Umbraco.Core.Collections
             {
                 //confirm key matches
                 if (!KeySelector(value).Equals(key))
-                    throw new InvalidOperationException("Key of new value does not match");
+                    throw new InvalidOperationException("Key of new value does not match.");
 
                 if (!Indecies.ContainsKey(key))
                 {
@@ -118,7 +119,7 @@ namespace Umbraco.Core.Collections
 
             //confirm key matches
             if (!KeySelector(value).Equals(key))
-                throw new InvalidOperationException("Key of new value does not match");
+                throw new InvalidOperationException("Key of new value does not match.");
 
             this[Indecies[key]] = value;
             return true;
@@ -155,12 +156,12 @@ namespace Umbraco.Core.Collections
         {
             if (!Indecies.ContainsKey(currentKey))
             {
-                throw new InvalidOperationException("No item with the key " + currentKey + "was found in the collection");
+                throw new InvalidOperationException($"No item with the key '{currentKey}' was found in the dictionary.");
             }
 
             if (ContainsKey(newKey))
             {
-                throw new DuplicateKeyException(newKey.ToString());
+                throw new ArgumentException($"An element with the same key '{newKey}' already exists in the dictionary.", nameof(newKey));
             }
 
             var currentIndex = Indecies[currentKey];
@@ -234,16 +235,5 @@ namespace Umbraco.Core.Collections
         }
 
         #endregion
-
-        internal class DuplicateKeyException : Exception
-        {
-            public DuplicateKeyException(string key)
-                : base("Attempted to insert duplicate key \"" + key + "\" in collection.")
-            {
-                Key = key;
-            }
-
-            public string Key { get; }
-        }
     }
 }

src/Umbraco.Core/Composing/Composers.cs

@@ -18,19 +18,52 @@ namespace Umbraco.Core.Composing
         private readonly Composition _composition;
         private readonly IProfilingLogger _logger;
         private readonly IEnumerable<Type> _composerTypes;
+        private readonly IEnumerable<Attribute> _enableDisableAttributes;
 
         private const int LogThresholdMilliseconds = 100;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="Composers"/> class.
+        /// Initializes a new instance of the <see cref="Composers" /> class.
         /// </summary>
         /// <param name="composition">The composition.</param>
-        /// <param name="composerTypes">The composer types.</param>
-        /// <param name="logger">A profiling logger.</param>
+        /// <param name="composerTypes">The <see cref="IComposer" /> types.</param>
+        /// <param name="logger">The profiling logger.</param>
+        [Obsolete("This overload only gets the EnableComposer/DisableComposer attributes from the composerTypes assemblies.")]
         public Composers(Composition composition, IEnumerable<Type> composerTypes, IProfilingLogger logger)
+            : this(composition, composerTypes, Enumerable.Empty<Attribute>(), logger)
+        {
+            var enableDisableAttributes = new List<Attribute>();
+
+            var assemblies = composerTypes.Select(t => t.Assembly).Distinct();
+            foreach (var assembly in assemblies)
+            {
+                enableDisableAttributes.AddRange(assembly.GetCustomAttributes(typeof(EnableComposerAttribute)));
+                enableDisableAttributes.AddRange(assembly.GetCustomAttributes(typeof(DisableComposerAttribute)));
+            }
+
+            _enableDisableAttributes = enableDisableAttributes;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Composers" /> class.
+        /// </summary>
+        /// <param name="composition">The composition.</param>
+        /// <param name="composerTypes">The <see cref="IComposer" /> types.</param>
+        /// <param name="enableDisableAttributes">The <see cref="EnableComposerAttribute" /> and/or <see cref="DisableComposerAttribute" /> attributes.</param>
+        /// <param name="logger">The profiling logger.</param>
+        /// <exception cref="ArgumentNullException">composition
+        /// or
+        /// composerTypes
+        /// or
+        /// enableDisableAttributes
+        /// or
+        /// logger</exception>
+
+        public Composers(Composition composition, IEnumerable<Type> composerTypes, IEnumerable<Attribute> enableDisableAttributes, IProfilingLogger logger)
         {
             _composition = composition ?? throw new ArgumentNullException(nameof(composition));
             _composerTypes = composerTypes ?? throw new ArgumentNullException(nameof(composerTypes));
+            _enableDisableAttributes = enableDisableAttributes ?? throw new ArgumentNullException(nameof(enableDisableAttributes));
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         }
 
@@ -103,7 +136,7 @@ namespace Umbraco.Core.Composing
                 .ToList();
 
             // enable or disable composers
-            EnableDisableComposers(composerTypeList);
+            EnableDisableComposers(_enableDisableAttributes, composerTypeList);
 
             void GatherInterfaces<TAttribute>(Type type, Func<TAttribute, Type> getTypeInAttribute, HashSet<Type> iset, List<Type> set2)
                 where TAttribute : Attribute
@@ -218,7 +251,7 @@ namespace Umbraco.Core.Composing
             return text.ToString();
         }
 
-        private static void EnableDisableComposers(ICollection<Type> types)
+        private static void EnableDisableComposers(IEnumerable<Attribute> enableDisableAttributes, ICollection<Type> types)
         {
             var enabled = new Dictionary<Type, EnableInfo>();
 
@@ -240,20 +273,16 @@ namespace Umbraco.Core.Composing
                 enableInfo.Weight = weight2;
             }
 
-            var assemblies = types.Select(x => x.Assembly).Distinct();
-            foreach (var assembly in assemblies)
+            foreach (var attr in enableDisableAttributes.OfType<EnableComposerAttribute>())
             {
-                foreach (var attr in assembly.GetCustomAttributes<EnableComposerAttribute>())
-                {
-                    var type = attr.EnabledType;
-                    UpdateEnableInfo(type, 2, enabled, true);
-                }
+                var type = attr.EnabledType;
+                UpdateEnableInfo(type, 2, enabled, true);
+            }
 
-                foreach (var attr in assembly.GetCustomAttributes<DisableComposerAttribute>())
-                {
-                    var type = attr.DisabledType;
-                    UpdateEnableInfo(type, 2, enabled, false);
-                }
+            foreach (var attr in enableDisableAttributes.OfType<DisableComposerAttribute>())
+            {
+                var type = attr.DisabledType;
+                UpdateEnableInfo(type, 2, enabled, false);
             }
 
             foreach (var composerType in types)

src/Umbraco.Core/Composing/LightInject/LightInjectException.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Runtime.Serialization;
 using System.Text;
 
 namespace Umbraco.Core.Composing.LightInject
@@ -6,20 +7,51 @@ namespace Umbraco.Core.Composing.LightInject
     /// <summary>
     /// Represents errors that occur due to LightInject.
     /// </summary>
+    /// <seealso cref="System.Exception" />
+    [Serializable]
     public class LightInjectException : Exception
     {
-        public LightInjectException(string message)
-            : base(message)
-        { }
-
-        public LightInjectException(string message, Exception innerException)
-            : base(message, innerException)
-        { }
-
         private const string LightInjectUnableToResolveType = "Unable to resolve type:";
         private const string LightInjectUnresolvedDependency = "Unresolved dependency ";
         private const string LightInjectRequestedDependency = "[Requested dependency:";
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LightInjectException" /> class.
+        /// </summary>
+        public LightInjectException()
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LightInjectException" /> class.
+        /// </summary>
+        /// <param name="message">The message that describes the error.</param>
+        public LightInjectException(string message)
+            : base(message)
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LightInjectException" /> class.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or a null reference (<see langword="Nothing" /> in Visual Basic) if no inner exception is specified.</param>
+        public LightInjectException(string message, Exception innerException)
+            : base(message, innerException)
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LightInjectException"/> class.
+        /// </summary>
+        /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> that contains contextual information about the source or destination.</param>
+        protected LightInjectException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        { }
+
+        /// <summary>
+        /// Tries to throw the exception with additional details.
+        /// </summary>
+        /// <param name="e">The exception.</param>
+        /// <exception cref="Umbraco.Core.Composing.LightInject.LightInjectException"></exception>
         public static void TryThrow(Exception e)
         {
             var ex = e as InvalidOperationException;
@@ -32,6 +64,12 @@ namespace Umbraco.Core.Composing.LightInject
             throw new LightInjectException(sb.ToString(), e);
         }
 
+        /// <summary>
+        /// Tries to throw the exception with additional details.
+        /// </summary>
+        /// <param name="e">The exception.</param>
+        /// <param name="implementingType">The implementing type.</param>
+        /// <exception cref="Umbraco.Core.Composing.LightInject.LightInjectException"></exception>
         public static void TryThrow(Exception e, Type implementingType)
         {
             var ex = e as InvalidOperationException;
@@ -45,6 +83,11 @@ namespace Umbraco.Core.Composing.LightInject
             throw new LightInjectException(sb.ToString(), e);
         }
 
+        /// <summary>
+        /// Writes the details.
+        /// </summary>
+        /// <param name="ex">The exception.</param>
+        /// <param name="sb">The <see cref="StringBuilder" /> to write the details to.</param>
         private static void WriteDetails(InvalidOperationException ex, StringBuilder sb)
         {
             ex = ex.InnerException as InvalidOperationException;

src/Umbraco.Core/Composing/TypeLoader.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.Serialization;
 using System.Text;
 using System.Threading;
 using System.Web;
@@ -505,6 +506,49 @@ namespace Umbraco.Core.Composing
 
         #endregion
 
+        #region Get Assembly Attributes
+
+        /// <summary>
+        /// Gets the assembly attributes of the specified type <typeparamref name="T" />.
+        /// </summary>
+        /// <typeparam name="T">The attribute type.</typeparam>
+        /// <returns>
+        /// The assembly attributes of the specified type <typeparamref name="T" />.
+        /// </returns>
+        public IEnumerable<T> GetAssemblyAttributes<T>()
+            where T : Attribute
+        {
+            return AssembliesToScan.SelectMany(a => a.GetCustomAttributes<T>()).ToList();
+        }
+
+        /// <summary>
+        /// Gets all the assembly attributes.
+        /// </summary>
+        /// <returns>
+        /// All assembly attributes.
+        /// </returns>
+        public IEnumerable<Attribute> GetAssemblyAttributes()
+        {
+            return AssembliesToScan.SelectMany(a => a.GetCustomAttributes()).ToList();
+        }
+
+        /// <summary>
+        /// Gets the assembly attributes of the specified <paramref name="attributeTypes" />.
+        /// </summary>
+        /// <param name="attributeTypes">The attribute types.</param>
+        /// <returns>
+        /// The assembly attributes of the specified types.
+        /// </returns>
+        /// <exception cref="ArgumentNullException">attributeTypes</exception>
+        public IEnumerable<Attribute> GetAssemblyAttributes(params Type[] attributeTypes)
+        {
+            if (attributeTypes == null) throw new ArgumentNullException(nameof(attributeTypes));
+
+            return AssembliesToScan.SelectMany(a => attributeTypes.SelectMany(at => a.GetCustomAttributes(at))).ToList();
+        }
+
+        #endregion
+
         #region Get Types
 
         /// <summary>
@@ -813,11 +857,44 @@ namespace Umbraco.Core.Composing
         }
 
         /// <summary>
-        /// Represents the error that occurs when a type was not found in the cache type
-        /// list with the specified TypeResolutionKind.
+        /// Represents the error that occurs when a type was not found in the cache type list with the specified TypeResolutionKind.
         /// </summary>
+        /// <seealso cref="System.Exception" />
+        [Serializable]
         internal class CachedTypeNotFoundInFileException : Exception
-        { }
+        {
+            /// <summary>
+            /// Initializes a new instance of the <see cref="CachedTypeNotFoundInFileException" /> class.
+            /// </summary>
+            public CachedTypeNotFoundInFileException()
+            { }
+
+            /// <summary>
+            /// Initializes a new instance of the <see cref="CachedTypeNotFoundInFileException" /> class.
+            /// </summary>
+            /// <param name="message">The message that describes the error.</param>
+            public CachedTypeNotFoundInFileException(string message)
+                : base(message)
+            { }
+
+            /// <summary>
+            /// Initializes a new instance of the <see cref="CachedTypeNotFoundInFileException" /> class.
+            /// </summary>
+            /// <param name="message">The error message that explains the reason for the exception.</param>
+            /// <param name="innerException">The exception that is the cause of the current exception, or a null reference (<see langword="Nothing" /> in Visual Basic) if no inner exception is specified.</param>
+            public CachedTypeNotFoundInFileException(string message, Exception innerException)
+                : base(message, innerException)
+            { }
+
+            /// <summary>
+            /// Initializes a new instance of the <see cref="CachedTypeNotFoundInFileException" /> class.
+            /// </summary>
+            /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> that holds the serialized object data about the exception being thrown.</param>
+            /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> that contains contextual information about the source or destination.</param>
+            protected CachedTypeNotFoundInFileException(SerializationInfo info, StreamingContext context)
+                : base(info, context)
+            { }
+        }
 
         #endregion
     }

src/Umbraco.Core/Constants-Conventions.cs

@@ -221,7 +221,8 @@ namespace Umbraco.Core
                             FailedPasswordAttempts,
                             new PropertyType(PropertyEditors.Aliases.Label, ValueStorageType.Integer, true, FailedPasswordAttempts)
                             {
-                                Name = FailedPasswordAttemptsLabel
+                                Name = FailedPasswordAttemptsLabel,
+                                DataTypeId = Constants.DataTypes.LabelInt
                             }
                         },
                         {
@@ -242,35 +243,40 @@ namespace Umbraco.Core
                             LastLockoutDate,
                             new PropertyType(PropertyEditors.Aliases.Label, ValueStorageType.Date, true, LastLockoutDate)
                             {
-                                Name = LastLockoutDateLabel
+                                Name = LastLockoutDateLabel,
+                                DataTypeId = Constants.DataTypes.LabelDateTime
                             }
                         },
                         {
                             LastLoginDate,
                             new PropertyType(PropertyEditors.Aliases.Label, ValueStorageType.Date, true, LastLoginDate)
                             {
-                                Name = LastLoginDateLabel
+                                Name = LastLoginDateLabel,
+                                DataTypeId = Constants.DataTypes.LabelDateTime
                             }
                         },
                         {
                             LastPasswordChangeDate,
                             new PropertyType(PropertyEditors.Aliases.Label, ValueStorageType.Date, true, LastPasswordChangeDate)
                             {
-                                Name = LastPasswordChangeDateLabel
+                                Name = LastPasswordChangeDateLabel,
+                                DataTypeId = Constants.DataTypes.LabelDateTime
                             }
                         },
                         {
                             PasswordAnswer,
                             new PropertyType(PropertyEditors.Aliases.Label, ValueStorageType.Nvarchar, true, PasswordAnswer)
                             {
-                                Name = PasswordAnswerLabel
+                                Name = PasswordAnswerLabel,
+                                DataTypeId = Constants.DataTypes.LabelString
                             }
                         },
                         {
                             PasswordQuestion,
                             new PropertyType(PropertyEditors.Aliases.Label, ValueStorageType.Nvarchar, true, PasswordQuestion)
                             {
-                                Name = PasswordQuestionLabel
+                                Name = PasswordQuestionLabel,
+                                DataTypeId = Constants.DataTypes.LabelString
                             }
                         }
                     };

src/Umbraco.Core/ContentExtensions.cs

@@ -13,6 +13,7 @@ using Umbraco.Core.IO;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.Entities;
 using Umbraco.Core.Models.Membership;
+using Umbraco.Core.PropertyEditors;
 using Umbraco.Core.Services;
 using Umbraco.Core.Services.Implement;
 
@@ -23,6 +24,8 @@ namespace Umbraco.Core
         // this ain't pretty
         private static IMediaFileSystem _mediaFileSystem;
         private static IMediaFileSystem MediaFileSystem => _mediaFileSystem ?? (_mediaFileSystem = Current.MediaFileSystem);
+        private static readonly PropertyEditorCollection _propertyEditors;
+        private static PropertyEditorCollection PropertyEditors = _propertyEditors ?? (_propertyEditors = Current.PropertyEditors);
 
         #region IContent
 
@@ -162,14 +165,12 @@ namespace Umbraco.Core
             // Fixes https://github.com/umbraco/Umbraco-CMS/issues/3937 - Assigning a new file to an
             // existing IMedia with extension SetValue causes exception 'Illegal characters in path'
             string oldpath = null;
-            if (property.GetValue(culture, segment) is string svalue)
+            var value = property.GetValue(culture, segment);
+
+            if (PropertyEditors.TryGet(propertyTypeAlias, out var editor)
+                && editor is IDataEditorWithMediaPath dataEditor)
             {
-                if (svalue.DetectIsJson())
-                {
-                    // the property value is a JSON serialized image crop data set - grab the "src" property as the file source
-                    var jObject = JsonConvert.DeserializeObject<JObject>(svalue);
-                    svalue = jObject != null ? jObject.GetValueAsString("src") : svalue;
-                }
+                var svalue = dataEditor.GetMediaPath(value);
                 oldpath = MediaFileSystem.GetRelativePath(svalue);
             }
 

src/Umbraco.Core/EnumExtensions.cs

@@ -41,5 +41,43 @@ namespace Umbraco.Core
 
             return (num & nums) > 0;
         }
+
+        /// <summary>
+        /// Sets a flag of the given input enum
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="input">Enum to set flag of</param>
+        /// <param name="flag">Flag to set</param>
+        /// <returns>A new enum with the flag set</returns>
+        public static T SetFlag<T>(this T input, T flag)
+             where T : Enum
+        {
+            var i = Convert.ToUInt64(input);
+            var f = Convert.ToUInt64(flag);
+
+            // bitwise OR to set flag f of enum i
+            var result = i | f;
+            
+            return (T)Enum.ToObject(typeof(T), result);
+        }
+
+        /// <summary>
+        /// Unsets a flag of the given input enum
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="input">Enum to unset flag of</param>
+        /// <param name="flag">Flag to unset</param>
+        /// <returns>A new enum with the flag unset</returns>
+        public static T UnsetFlag<T>(this T input, T flag)
+             where T : Enum
+        {
+            var i = Convert.ToUInt64(input);
+            var f = Convert.ToUInt64(flag);
+
+            // bitwise AND combined with bitwise complement to unset flag f of enum i
+            var result = i & ~f;
+            
+            return (T)Enum.ToObject(typeof(T), result);
+        }
     }
 }

src/Umbraco.Core/Exceptions/ArgumentNullOrEmptyException.cs

@@ -1,16 +1,24 @@
 using System;
+using System.Runtime.Serialization;
 
 namespace Umbraco.Core.Exceptions
 {
     /// <summary>
-    /// The exception that is thrown when a null reference, or an empty argument,
-    /// is passed to a method that does not accept it as a valid argument.
+    /// The exception that is thrown when a null reference, or an empty argument, is passed to a method that does not accept it as a valid argument.
     /// </summary>
+    /// <seealso cref="System.ArgumentNullException" />
+    [Obsolete("Throw an ArgumentNullException when the parameter is null or an ArgumentException when its empty instead.")]
+    [Serializable]
     public class ArgumentNullOrEmptyException : ArgumentNullException
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="ArgumentNullOrEmptyException"/> class
-        /// with the name of the parameter that caused this exception.
+        /// Initializes a new instance of the <see cref="ArgumentNullOrEmptyException" /> class.
+        /// </summary>
+        public ArgumentNullOrEmptyException()
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ArgumentNullOrEmptyException" /> class with the name of the parameter that caused this exception.
         /// </summary>
         /// <param name="paramName">The named of the parameter that caused the exception.</param>
         public ArgumentNullOrEmptyException(string paramName)
@@ -18,13 +26,30 @@ namespace Umbraco.Core.Exceptions
         { }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="ArgumentNullOrEmptyException"/> class
-        /// with a specified error message and the name of the parameter that caused this exception.
+        /// Initializes a new instance of the <see cref="ArgumentNullOrEmptyException" /> class with a specified error message and the name of the parameter that caused this exception.
         /// </summary>
         /// <param name="paramName">The named of the parameter that caused the exception.</param>
         /// <param name="message">A message that describes the error.</param>
         public ArgumentNullOrEmptyException(string paramName, string message)
             : base(paramName, message)
         { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ArgumentNullOrEmptyException" /> class.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for this exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or a null reference (<see langword="Nothing" /> in Visual Basic) if no inner exception is specified.</param>
+        public ArgumentNullOrEmptyException(string message, Exception innerException)
+            : base(message, innerException)
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ArgumentNullOrEmptyException" /> class.
+        /// </summary>
+        /// <param name="info">The object that holds the serialized object data.</param>
+        /// <param name="context">An object that describes the source or destination of the serialized data.</param>
+        protected ArgumentNullOrEmptyException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        { }
     }
 }

src/Umbraco.Core/Exceptions/AuthorizationException.cs

@@ -1,14 +1,45 @@
 using System;
+using System.Runtime.Serialization;
 
 namespace Umbraco.Core.Exceptions
 {
+    /// <summary>
+    /// The exception that is thrown when authorization failed.
+    /// </summary>
+    /// <seealso cref="System.Exception" />
+    [Serializable]
     public class AuthorizationException : Exception
     {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AuthorizationException" /> class.
+        /// </summary>
         public AuthorizationException()
         { }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AuthorizationException" /> class.
+        /// </summary>
+        /// <param name="message">The message that describes the error.</param>
         public AuthorizationException(string message)
             : base(message)
         { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AuthorizationException" /> class.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or a null reference (<see langword="Nothing" /> in Visual Basic) if no inner exception is specified.</param>
+        public AuthorizationException(string message, Exception innerException)
+            : base(message, innerException)
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AuthorizationException" /> class.
+        /// </summary>
+        /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> that contains contextual information about the source or destination.</param>
+        protected AuthorizationException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        { }
     }
 }

src/Umbraco.Core/Exceptions/BootFailedException.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Runtime.Serialization;
 using System.Text;
 
 namespace Umbraco.Core.Exceptions
@@ -6,6 +7,8 @@ namespace Umbraco.Core.Exceptions
     /// <summary>
     /// An exception that is thrown if the Umbraco application cannot boot.
     /// </summary>
+    /// <seealso cref="System.Exception" />
+    [Serializable]
     public class BootFailedException : Exception
     {
         /// <summary>
@@ -14,27 +17,47 @@ namespace Umbraco.Core.Exceptions
         public const string DefaultMessage = "Boot failed: Umbraco cannot run. See Umbraco's log file for more details.";
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="Exception"/> class with a specified error message.
+        /// Initializes a new instance of the <see cref="BootFailedException" /> class.
         /// </summary>
-        /// <param name="message">The message that describes the error. </param>
+        public BootFailedException()
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Exception" /> class with a specified error message.
+        /// </summary>
+        /// <param name="message">The message that describes the error.</param>
         public BootFailedException(string message)
             : base(message)
         { }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="Exception"/> class with a specified error message
+        /// Initializes a new instance of the <see cref="Exception" /> class with a specified error message
         /// and a reference to the inner exception which is the cause of this exception.
         /// </summary>
-        /// <param name="message">The message that describes the error. </param>
-        /// <param name="inner">The inner exception, or null.</param>
-        public BootFailedException(string message, Exception inner)
-            : base(message, inner)
+        /// <param name="message">The message that describes the error.</param>
+        /// <param name="innerException">The inner exception, or null.</param>
+        public BootFailedException(string message, Exception innerException)
+            : base(message, innerException)
         { }
 
         /// <summary>
-        /// Rethrows a captured <see cref="BootFailedException"/>.
+        /// Initializes a new instance of the <see cref="BootFailedException" /> class.
         /// </summary>
-        /// <remarks>The exception can be null, in which case a default message is used.</remarks>
+        /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> that contains contextual information about the source or destination.</param>
+        protected BootFailedException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        { }
+
+        /// <summary>
+        /// Rethrows a captured <see cref="BootFailedException" />.
+        /// </summary>
+        /// <param name="bootFailedException">The boot failed exception.</param>
+        /// <exception cref="Umbraco.Core.Exceptions.BootFailedException">
+        /// </exception>
+        /// <remarks>
+        /// The exception can be null, in which case a default message is used.
+        /// </remarks>
         public static void Rethrow(BootFailedException bootFailedException)
         {
             if (bootFailedException == null)

src/Umbraco.Core/Exceptions/ConnectionException.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace Umbraco.Core.Exceptions
-{
-    internal class ConnectionException : Exception
-    {
-        public ConnectionException(string message, Exception innerException) : base(message, innerException)
-        {
-
-        }
-    }
-}

src/Umbraco.Core/Exceptions/DataOperationException.cs

@@ -1,21 +1,98 @@
 using System;
+using System.Runtime.Serialization;
 
 namespace Umbraco.Core.Exceptions
 {
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    /// <seealso cref="System.Exception" />
+    [Serializable]
     internal class DataOperationException<T> : Exception
+        where T : Enum
     {
+        /// <summary>
+        /// Gets the operation.
+        /// </summary>
+        /// <value>
+        /// The operation.
+        /// </value>
+        /// <remarks>
+        /// This object should be serializable to prevent a <see cref="SerializationException" /> to be thrown.
+        /// </remarks>
         public T Operation { get; private set; }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DataOperationException{T}" /> class.
+        /// </summary>
+        public DataOperationException()
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DataOperationException{T}" /> class.
+        /// </summary>
+        /// <param name="message">The message that describes the error.</param>
+        public DataOperationException(string message)
+            : base(message)
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DataOperationException{T}" /> class.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or a null reference (<see langword="Nothing" /> in Visual Basic) if no inner exception is specified.</param>
+        public DataOperationException(string message, Exception innerException)
+            : base(message, innerException)
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DataOperationException{T}" /> class.
+        /// </summary>
+        /// <param name="operation">The operation.</param>
+        public DataOperationException(T operation)
+            : this(operation, "Data operation exception: " + operation)
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DataOperationException{T}" /> class.
+        /// </summary>
+        /// <param name="operation">The operation.</param>
+        /// <param name="message">The message.</param>
         public DataOperationException(T operation, string message)
             : base(message)
         {
             Operation = operation;
         }
 
-        public DataOperationException(T operation)
-            : base("Data operation exception: " + operation)
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DataOperationException{T}" /> class.
+        /// </summary>
+        /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> that contains contextual information about the source or destination.</param>
+        /// <exception cref="ArgumentNullException">info</exception>
+        protected DataOperationException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
         {
-            Operation = operation;
+            Operation = (T)Enum.Parse(typeof(T), info.GetString(nameof(Operation)));
+        }
+
+        /// <summary>
+        /// When overridden in a derived class, sets the <see cref="T:System.Runtime.Serialization.SerializationInfo" /> with information about the exception.
+        /// </summary>
+        /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> that contains contextual information about the source or destination.</param>
+        /// <exception cref="ArgumentNullException">info</exception>
+        public override void GetObjectData(SerializationInfo info, StreamingContext context)
+        {
+            if (info == null)
+            {
+                throw new ArgumentNullException(nameof(info));
+            }
+
+            info.AddValue(nameof(Operation), Enum.GetName(typeof(T), Operation));
+
+            base.GetObjectData(info, context);
         }
     }
 }

src/Umbraco.Core/Exceptions/InvalidCompositionException.cs

@@ -1,44 +1,126 @@
 using System;
+using System.Runtime.Serialization;
 
 namespace Umbraco.Core.Exceptions
 {
+    /// <summary>
+    /// The exception that is thrown when a composition is invalid.
+    /// </summary>
+    /// <seealso cref="System.Exception" />
+    [Serializable]
     public class InvalidCompositionException : Exception
     {
-        public InvalidCompositionException(string contentTypeAlias, string addedCompositionAlias, string[] propertyTypeAliass)
-        {
-            ContentTypeAlias = contentTypeAlias;
-            AddedCompositionAlias = addedCompositionAlias;
-            PropertyTypeAliases = propertyTypeAliass;
-        }
+        /// <summary>
+        /// Gets the content type alias.
+        /// </summary>
+        /// <value>
+        /// The content type alias.
+        /// </value>
+        public string ContentTypeAlias { get; }
 
-        public InvalidCompositionException(string contentTypeAlias, string[] propertyTypeAliass)
-        {
-            ContentTypeAlias = contentTypeAlias;
-            PropertyTypeAliases = propertyTypeAliass;
-        }
+        /// <summary>
+        /// Gets the added composition alias.
+        /// </summary>
+        /// <value>
+        /// The added composition alias.
+        /// </value>
+        public string AddedCompositionAlias { get; }
 
-        public string ContentTypeAlias { get; private set; }
+        /// <summary>
+        /// Gets the property type aliases.
+        /// </summary>
+        /// <value>
+        /// The property type aliases.
+        /// </value>
+        public string[] PropertyTypeAliases { get; }
 
-        public string AddedCompositionAlias { get; private set; }
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InvalidCompositionException" /> class.
+        /// </summary>
+        public InvalidCompositionException()
+        { }
 
-        public string[] PropertyTypeAliases { get; private set; }
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InvalidCompositionException" /> class.
+        /// </summary>
+        /// <param name="contentTypeAlias">The content type alias.</param>
+        /// <param name="propertyTypeAliases">The property type aliases.</param>
+        public InvalidCompositionException(string contentTypeAlias, string[] propertyTypeAliases)
+            : this(contentTypeAlias, null, propertyTypeAliases)
+        { }
 
-        public override string Message
-        {
-            get
-            {
-                return AddedCompositionAlias.IsNullOrWhiteSpace()
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InvalidCompositionException" /> class.
+        /// </summary>
+        /// <param name="contentTypeAlias">The content type alias.</param>
+        /// <param name="addedCompositionAlias">The added composition alias.</param>
+        /// <param name="propertyTypeAliases">The property type aliases.</param>
+        public InvalidCompositionException(string contentTypeAlias, string addedCompositionAlias, string[] propertyTypeAliases)
+            : this(addedCompositionAlias.IsNullOrWhiteSpace()
                     ? string.Format(
                         "ContentType with alias '{0}' has an invalid composition " +
                         "and there was a conflict on the following PropertyTypes: '{1}'. " +
                         "PropertyTypes must have a unique alias across all Compositions in order to compose a valid ContentType Composition.",
-                        ContentTypeAlias, string.Join(", ", PropertyTypeAliases))
+                        contentTypeAlias, string.Join(", ", propertyTypeAliases))
                     : string.Format(
                         "ContentType with alias '{0}' was added as a Composition to ContentType with alias '{1}', " +
                         "but there was a conflict on the following PropertyTypes: '{2}'. " +
                         "PropertyTypes must have a unique alias across all Compositions in order to compose a valid ContentType Composition.",
-                        AddedCompositionAlias, ContentTypeAlias, string.Join(", ", PropertyTypeAliases));
+                        addedCompositionAlias, contentTypeAlias, string.Join(", ", propertyTypeAliases)))
+        {
+            ContentTypeAlias = contentTypeAlias;
+            AddedCompositionAlias = addedCompositionAlias;
+            PropertyTypeAliases = propertyTypeAliases;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InvalidCompositionException" /> class.
+        /// </summary>
+        /// <param name="message">The message that describes the error.</param>
+        public InvalidCompositionException(string message)
+            : base(message)
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InvalidCompositionException" /> class.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or a null reference (<see langword="Nothing" /> in Visual Basic) if no inner exception is specified.</param>
+        public InvalidCompositionException(string message, Exception innerException)
+            : base(message, innerException)
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InvalidCompositionException" /> class.
+        /// </summary>
+        /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> that contains contextual information about the source or destination.</param>
+        protected InvalidCompositionException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+            ContentTypeAlias = info.GetString(nameof(ContentTypeAlias));
+            AddedCompositionAlias = info.GetString(nameof(AddedCompositionAlias));
+            PropertyTypeAliases = (string[])info.GetValue(nameof(PropertyTypeAliases), typeof(string[]));
+        }
+
+        /// <summary>
+        /// When overridden in a derived class, sets the <see cref="T:System.Runtime.Serialization.SerializationInfo" /> with information about the exception.
+        /// </summary>
+        /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> that contains contextual information about the source or destination.</param>
+        /// <exception cref="ArgumentNullException">info</exception>
+        public override void GetObjectData(SerializationInfo info, StreamingContext context)
+        {
+            if (info == null)
+            {
+                throw new ArgumentNullException(nameof(info));
             }
+
+            info.AddValue(nameof(ContentTypeAlias), ContentTypeAlias);
+            info.AddValue(nameof(AddedCompositionAlias), AddedCompositionAlias);
+            info.AddValue(nameof(PropertyTypeAliases), PropertyTypeAliases);
+
+            base.GetObjectData(info, context);
         }
     }
 }

src/Umbraco.Core/Exceptions/PanicException.cs

@@ -4,25 +4,42 @@ using System.Runtime.Serialization;
 namespace Umbraco.Core.Exceptions
 {
     /// <summary>
-    /// Internal exception that in theory should never ben thrown, it is only thrown in circumstances that should never happen
+    /// Represents an internal exception that in theory should never been thrown, it is only thrown in circumstances that should never happen.
     /// </summary>
+    /// <seealso cref="System.Exception" />
     [Serializable]
-    internal class PanicException : Exception
+    public class PanicException : Exception
     {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PanicException" /> class.
+        /// </summary>
         public PanicException()
-        {
-        }
+        { }
 
-        public PanicException(string message) : base(message)
-        {
-        }
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PanicException" /> class.
+        /// </summary>
+        /// <param name="message">The message that describes the error.</param>
+        public PanicException(string message)
+            : base(message)
+        { }
 
-        public PanicException(string message, Exception innerException) : base(message, innerException)
-        {
-        }
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PanicException" /> class.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or a null reference (<see langword="Nothing" /> in Visual Basic) if no inner exception is specified.</param>
+        public PanicException(string message, Exception innerException)
+            : base(message, innerException)
+        { }
 
-        protected PanicException(SerializationInfo info, StreamingContext context) : base(info, context)
-        {
-        }
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PanicException" /> class.
+        /// </summary>
+        /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> that contains contextual information about the source or destination.</param>
+        protected PanicException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        { }
     }
 }

src/Umbraco.Core/Exceptions/WontImplementException.cs

@@ -1,27 +1,52 @@
 using System;
+using System.Runtime.Serialization;
 
 namespace Umbraco.Core.Exceptions
 {
     /// <summary>
     /// The exception that is thrown when a requested method or operation is not, and will not be, implemented.
     /// </summary>
-    /// <remarks>The <see cref="NotImplementedException"/> is to be used when some code is not implemented,
+    /// <remarks>
+    /// The <see cref="NotImplementedException" /> is to be used when some code is not implemented,
     /// but should eventually be implemented (i.e. work in progress) and is reported by tools such as ReSharper.
     /// This exception is to be used when some code is not implemented, and is not meant to be, for whatever
-    /// reason.</remarks>
+    /// reason.
+    /// </remarks>
+    /// <seealso cref="System.NotImplementedException" />
+    [Serializable]
+    [Obsolete("If a method or operation is not, and will not be, implemented, it is invalid or not supported, so we should throw either an InvalidOperationException or NotSupportedException instead.")]
     public class WontImplementException : NotImplementedException
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="WontImplementException"/> class.
+        /// Initializes a new instance of the <see cref="WontImplementException" /> class.
         /// </summary>
         public WontImplementException()
         { }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="WontImplementException"/> class with a specified reason message.
+        /// Initializes a new instance of the <see cref="WontImplementException" /> class with a specified reason message.
         /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
         public WontImplementException(string message)
             : base(message)
         { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="WontImplementException" /> class.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="inner">The exception that is the cause of the current exception. If the <paramref name="inner" /> parameter is not <see langword="null" />, the current exception is raised in a <see langword="catch" /> block that handles the inner exception.</param>
+        public WontImplementException(string message, Exception inner)
+            : base(message, inner)
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="WontImplementException" /> class.
+        /// </summary>
+        /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> that contains contextual information about the source or destination.</param>
+        protected WontImplementException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        { }
     }
 }

src/Umbraco.Core/IMainDom.cs

@@ -14,6 +14,9 @@ namespace Umbraco.Core
         /// <summary>
         /// Gets a value indicating whether the current domain is the main domain.
         /// </summary>
+        /// <remarks>
+        /// When the first call is made to this there will generally be some logic executed to acquire a distributed lock lease.
+        /// </remarks>
         bool IsMainDom { get; }
 
         /// <summary>
@@ -35,4 +38,4 @@ namespace Umbraco.Core
         /// is guaranteed to execute before the AppDomain releases the main domain status.</remarks>
         bool Register(Action install, Action release, int weight = 100);
     }
-}
+}

src/Umbraco.Core/IO/FileSecurityException.cs

@@ -1,20 +1,46 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.Runtime.Serialization;
 
 namespace Umbraco.Core.IO
 {
+    /// <summary>
+    /// The exception that is thrown when the caller does not have the required permission to access a file.
+    /// </summary>
+    /// <seealso cref="System.Exception" />
+    [Obsolete("Throw an UnauthorizedAccessException instead.")]
+    [Serializable]
     public class FileSecurityException : Exception
     {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FileSecurityException" /> class.
+        /// </summary>
         public FileSecurityException()
-        {
+        { }
 
-        }
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FileSecurityException" /> class.
+        /// </summary>
+        /// <param name="message">The message that describes the error.</param>
+        public FileSecurityException(string message)
+            : base(message)
+        { }
 
-        public FileSecurityException(string message) : base(message)
-        {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FileSecurityException" /> class.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or a null reference (<see langword="Nothing" /> in Visual Basic) if no inner exception is specified.</param>
+        public FileSecurityException(string message, Exception innerException)
+            : base(message, innerException)
+        { }
 
-        }
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FileSecurityException" /> class.
+        /// </summary>
+        /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> that contains contextual information about the source or destination.</param>
+        protected FileSecurityException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        { }
     }
 }

src/Umbraco.Core/IO/MediaFileSystem.cs

@@ -1,15 +1,10 @@
 using System;
 using System.Collections.Generic;
-using System.Configuration;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
-using Umbraco.Core.Composing;
-using Umbraco.Core.Configuration;
 using Umbraco.Core.Configuration.UmbracoSettings;
-using Umbraco.Core.Exceptions;
 using Umbraco.Core.Logging;
-using Umbraco.Core.Media;
 using Umbraco.Core.Models;
 
 namespace Umbraco.Core.IO
@@ -92,7 +87,8 @@ namespace Umbraco.Core.IO
         {
             if (content == null) throw new ArgumentNullException(nameof(content));
             if (propertyType == null) throw new ArgumentNullException(nameof(propertyType));
-            if (string.IsNullOrWhiteSpace(filename)) throw new ArgumentNullOrEmptyException(nameof(filename));
+            if (filename == null) throw new ArgumentNullException(nameof(filename));
+            if (string.IsNullOrWhiteSpace(filename)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(filename));
             if (filestream == null) throw new ArgumentNullException(nameof(filestream));
 
             // clear the old file, if any
@@ -111,7 +107,8 @@ namespace Umbraco.Core.IO
         {
             if (content == null) throw new ArgumentNullException(nameof(content));
             if (propertyType == null) throw new ArgumentNullException(nameof(propertyType));
-            if (string.IsNullOrWhiteSpace(sourcepath)) throw new ArgumentNullOrEmptyException(nameof(sourcepath));
+            if (sourcepath == null) throw new ArgumentNullException(nameof(sourcepath));
+            if (string.IsNullOrWhiteSpace(sourcepath)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(sourcepath));
 
             // ensure we have a file to copy
             if (FileExists(sourcepath) == false) return null;

src/Umbraco.Core/IO/PhysicalFileSystem.cs

@@ -3,7 +3,6 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using Umbraco.Core.Composing;
-using Umbraco.Core.Exceptions;
 using System.Threading;
 using Umbraco.Core.Logging;
 
@@ -39,9 +38,11 @@ namespace Umbraco.Core.IO
 
         public PhysicalFileSystem(string rootPath, string rootUrl)
         {
-            if (string.IsNullOrEmpty(rootPath)) throw new ArgumentNullOrEmptyException(nameof(rootPath));
-            if (string.IsNullOrEmpty(rootUrl)) throw new ArgumentNullOrEmptyException(nameof(rootUrl));
-            if (rootPath.StartsWith("~/")) throw new ArgumentException("The rootPath argument cannot be a virtual path and cannot start with '~/'");
+            if (rootPath == null) throw new ArgumentNullException(nameof(rootPath));
+            if (string.IsNullOrEmpty(rootPath)) throw new ArgumentException("Value can't be empty.", nameof(rootPath));
+            if (rootUrl == null) throw new ArgumentNullException(nameof(rootUrl));
+            if (string.IsNullOrEmpty(rootUrl)) throw new ArgumentException("Value can't be empty.", nameof(rootUrl));
+            if (rootPath.StartsWith("~/")) throw new ArgumentException("Value can't be a virtual path and start with '~/'.", nameof(rootPath));
 
             // rootPath should be... rooted, as in, it's a root path!
             if (Path.IsPathRooted(rootPath) == false)
@@ -314,7 +315,7 @@ namespace Umbraco.Core.IO
 
             // nothing prevents us to reach the file, security-wise, yet it is outside
             // this filesystem's root - throw
-            throw new FileSecurityException("File '" + opath + "' is outside this filesystem's root.");
+            throw new UnauthorizedAccessException("File '" + opath + "' is outside this filesystem's root.");
         }
 
         /// <summary>

src/Umbraco.Core/MainDom.cs

@@ -15,25 +15,26 @@ namespace Umbraco.Core
     /// <para>When an AppDomain starts, it tries to acquire the main domain status.</para>
     /// <para>When an AppDomain stops (eg the application is restarting) it should release the main domain status.</para>
     /// </remarks>
-    internal class MainDom : IMainDom, IRegisteredObject
+    internal class MainDom : IMainDom, IRegisteredObject, IDisposable
     {
         #region Vars
 
         private readonly ILogger _logger;
 
         // our own lock for local consistency
-        private readonly object _locko = new object();
+        private object _locko = new object();
 
         // async lock representing the main domain lock
-        private readonly AsyncLock _asyncLock;
-        private IDisposable _asyncLocker;
+        private readonly SystemLock _systemLock;
+        private IDisposable _systemLocker;
 
         // event wait handle used to notify current main domain that it should
         // release the lock because a new domain wants to be the main domain
         private readonly EventWaitHandle _signal;
 
+        private bool _isInitialized;
         // indicates whether...
-        private volatile bool _isMainDom; // we are the main domain
+        private bool _isMainDom; // we are the main domain
         private volatile bool _signaled; // we have been signaled
 
         // actions to run before releasing the main domain
@@ -48,13 +49,13 @@ namespace Umbraco.Core
         // initializes a new instance of MainDom
         public MainDom(ILogger logger)
         {
+            HostingEnvironment.RegisterObject(this);
+
             _logger = logger;
 
-            var appId = string.Empty;
             // HostingEnvironment.ApplicationID is null in unit tests, making ReplaceNonAlphanumericChars fail
-            if (HostingEnvironment.ApplicationID != null)
-                appId = HostingEnvironment.ApplicationID.ReplaceNonAlphanumericChars(string.Empty);
-
+            var appId = HostingEnvironment.ApplicationID?.ReplaceNonAlphanumericChars(string.Empty) ?? string.Empty;
+            
             // combining with the physical path because if running on eg IIS Express,
             // two sites could have the same appId even though they are different.
             //
@@ -64,11 +65,11 @@ namespace Umbraco.Core
             // we *cannot* use the process ID here because when an AppPool restarts it is
             // a new process for the same application path
 
-            var appPath = HostingEnvironment.ApplicationPhysicalPath;
+            var appPath = HostingEnvironment.ApplicationPhysicalPath?.ToLowerInvariant() ?? string.Empty;
             var hash = (appId + ":::" + appPath).GenerateHash<SHA1>();
 
             var lockName = "UMBRACO-" + hash + "-MAINDOM-LCK";
-            _asyncLock = new AsyncLock(lockName);
+            _systemLock = new SystemLock(lockName);
 
             var eventName = "UMBRACO-" + hash + "-MAINDOM-EVT";
             _signal = new EventWaitHandle(false, EventResetMode.AutoReset, eventName);
@@ -99,6 +100,12 @@ namespace Umbraco.Core
             lock (_locko)
             {
                 if (_signaled) return false;
+                if (_isMainDom == false)
+                {
+                    _logger.Warn<MainDom>("Register called when MainDom has not been acquired");
+                    return false;
+                }
+
                 install?.Invoke();
                 if (release != null)
                     _callbacks.Add(new KeyValuePair<int, Action>(weight, release));
@@ -118,64 +125,65 @@ namespace Umbraco.Core
                 if (_signaled) return;
                 if (_isMainDom == false) return; // probably not needed
                 _signaled = true;
-            }
 
-            try
-            {
-                _logger.Info<MainDom>("Stopping ({SignalSource})", source);
-                foreach (var callback in _callbacks.OrderBy(x => x.Key).Select(x => x.Value))
+                try
                 {
-                    try
+                    _logger.Info<MainDom>("Stopping ({SignalSource})", source);
+                    foreach (var callback in _callbacks.OrderBy(x => x.Key).Select(x => x.Value))
                     {
-                        callback(); // no timeout on callbacks
+                        try
+                        {
+                            callback(); // no timeout on callbacks
+                        }
+                        catch (Exception e)
+                        {
+                            _logger.Error<MainDom>(e, "Error while running callback");
+                            continue;
+                        }
                     }
-                    catch (Exception e)
-                    {
-                        _logger.Error<MainDom>(e, "Error while running callback, remaining callbacks will not run.");
-                        throw;
-                    }
-
+                    _logger.Debug<MainDom>("Stopped ({SignalSource})", source);
                 }
-                _logger.Debug<MainDom>("Stopped ({SignalSource})", source);
-            }
-            finally
-            {
-                // in any case...
-                _isMainDom = false;
-                _asyncLocker.Dispose();
-                _logger.Info<MainDom>("Released ({SignalSource})", source);
+                finally
+                {
+                    // in any case...
+                    _isMainDom = false;
+                    _systemLocker?.Dispose();
+                    _logger.Info<MainDom>("Released ({SignalSource})", source);
+                }
+
             }
         }
 
         // acquires the main domain
-        internal bool Acquire()
+        private bool Acquire()
         {
-            lock (_locko) // we don't want the hosting environment to interfere by signaling
+            // if signaled, too late to acquire, give up
+            // the handler is not installed so that would be the hosting environment
+            if (_signaled)
             {
-                // if signaled, too late to acquire, give up
-                // the handler is not installed so that would be the hosting environment
-                if (_signaled)
-                {
-                    _logger.Info<MainDom>("Cannot acquire (signaled).");
-                    return false;
-                }
+                _logger.Info<MainDom>("Cannot acquire (signaled).");
+                return false;
+            }
 
-                _logger.Info<MainDom>("Acquiring.");
+            _logger.Info<MainDom>("Acquiring.");
 
-                // signal other instances that we want the lock, then wait one the lock,
-                // which may timeout, and this is accepted - see comments below
+            // signal other instances that we want the lock, then wait one the lock,
+            // which may timeout, and this is accepted - see comments below
 
-                // signal, then wait for the lock, then make sure the event is
-                // reset (maybe there was noone listening..)
-                _signal.Set();
+            // signal, then wait for the lock, then make sure the event is
+            // reset (maybe there was noone listening..)
+            _signal.Set();
 
-                // if more than 1 instance reach that point, one will get the lock
-                // and the other one will timeout, which is accepted
-
-                //TODO: This can throw a TimeoutException - in which case should this be in a try/finally to ensure the signal is always reset?
-                _asyncLocker = _asyncLock.Lock(LockTimeoutMilliseconds);
-                _isMainDom = true;
+            // if more than 1 instance reach that point, one will get the lock
+            // and the other one will timeout, which is accepted
 
+            //This can throw a TimeoutException - in which case should this be in a try/finally to ensure the signal is always reset.
+            try
+            {
+                _systemLocker = _systemLock.Lock(LockTimeoutMilliseconds);
+            }
+            finally
+            {
                 // we need to reset the event, because otherwise we would end up
                 // signaling ourselves and committing suicide immediately.
                 // only 1 instance can reach that point, but other instances may
@@ -183,35 +191,58 @@ namespace Umbraco.Core
                 // which is accepted
 
                 _signal.Reset();
-
-                //WaitOneAsync (ext method) will wait for a signal without blocking the main thread, the waiting is done on a background thread
-
-                _signal.WaitOneAsync()
-                    .ContinueWith(_ => OnSignal("signal"));
-
-                HostingEnvironment.RegisterObject(this);
-
-                _logger.Info<MainDom>("Acquired.");
-                return true;
             }
+            
+            //WaitOneAsync (ext method) will wait for a signal without blocking the main thread, the waiting is done on a background thread
+
+            _signal.WaitOneAsync()
+                .ContinueWith(_ => OnSignal("signal"));
+
+            _logger.Info<MainDom>("Acquired.");
+            return true;
         }
 
         /// <summary>
         /// Gets a value indicating whether the current domain is the main domain.
         /// </summary>
-        public bool IsMainDom => _isMainDom;
+        public bool IsMainDom => LazyInitializer.EnsureInitialized(ref _isMainDom, ref _isInitialized, ref _locko, () => Acquire());
 
         // IRegisteredObject
         void IRegisteredObject.Stop(bool immediate)
         {
-            try
+            OnSignal("environment"); // will run once
+
+            // The web app is stopping, need to wind down
+            Dispose(true);
+
+            HostingEnvironment.UnregisterObject(this);
+        }
+
+        #region IDisposable Support
+
+        // This code added to correctly implement the disposable pattern.
+
+        private bool disposedValue = false; // To detect redundant calls
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!disposedValue)
             {
-                OnSignal("environment"); // will run once
-            }
-            finally
-            {
-                HostingEnvironment.UnregisterObject(this);
+                if (disposing)
+                {
+                    _signal?.Close();
+                    _signal?.Dispose();
+                }
+
+                disposedValue = true;
             }
         }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        #endregion
     }
 }

src/Umbraco.Core/Manifest/ManifestParser.cs

@@ -5,7 +5,6 @@ using System.Linq;
 using System.Text;
 using Newtonsoft.Json;
 using Umbraco.Core.Cache;
-using Umbraco.Core.Exceptions;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 using Umbraco.Core.PropertyEditors;
@@ -42,7 +41,8 @@ namespace Umbraco.Core.Manifest
             _cache = appCaches.RuntimeCache;
             _validators = validators ?? throw new ArgumentNullException(nameof(validators));
             _filters = filters ?? throw new ArgumentNullException(nameof(filters));
-            if (string.IsNullOrWhiteSpace(path)) throw new ArgumentNullOrEmptyException(nameof(path));
+            if (path == null) throw new ArgumentNullException(nameof(path));
+            if (string.IsNullOrWhiteSpace(path)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(path));
             Path = path;
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         }
@@ -155,8 +155,8 @@ namespace Umbraco.Core.Manifest
         /// </summary>
         internal PackageManifest ParseManifest(string text)
         {
-            if (string.IsNullOrWhiteSpace(text))
-                throw new ArgumentNullOrEmptyException(nameof(text));
+            if (text == null) throw new ArgumentNullException(nameof(text));
+            if (string.IsNullOrWhiteSpace(text)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(text));
 
             var manifest = JsonConvert.DeserializeObject<PackageManifest>(text,
                 new DataEditorConverter(_logger),

src/Umbraco.Core/Migrations/DataLossException.cs

@@ -1,22 +0,0 @@
-using System;
-
-namespace Umbraco.Core.Migrations
-{
-    /// <summary>
-    /// Used if a migration has executed but the whole process has failed and cannot be rolled back
-    /// </summary>
-    internal class DataLossException : Exception
-    {
-        public DataLossException(string msg)
-            : base(msg)
-        {
-
-        }
-
-        public DataLossException(string msg, Exception inner)
-            : base(msg, inner)
-        {
-
-        }
-    }
-}

src/Umbraco.Core/Migrations/Expressions/Delete/DeleteBuilder.cs

@@ -1,4 +1,4 @@
-using Umbraco.Core.Exceptions;
+using System;
 using Umbraco.Core.Migrations.Expressions.Common;
 using Umbraco.Core.Migrations.Expressions.Delete.Column;
 using Umbraco.Core.Migrations.Expressions.Delete.Constraint;
@@ -39,8 +39,9 @@ namespace Umbraco.Core.Migrations.Expressions.Delete
         /// <inheritdoc />
         public IExecutableBuilder KeysAndIndexes(string tableName, bool local = true, bool foreign = true)
         {
-            if (tableName.IsNullOrWhiteSpace())
-                throw new ArgumentNullOrEmptyException(nameof(tableName));
+            if (tableName == null) throw new ArgumentNullException(nameof(tableName));
+            if (string.IsNullOrWhiteSpace(tableName)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(tableName));
+
             return new DeleteKeysAndIndexesBuilder(_context) { TableName = tableName, DeleteLocal = local, DeleteForeign = foreign };
         }
 

src/Umbraco.Core/Migrations/IncompleteMigrationExpressionException.cs

@@ -1,28 +1,49 @@
 using System;
+using System.Runtime.Serialization;
 
 namespace Umbraco.Core.Migrations
 {
     /// <summary>
-    /// Represents errors that occurs when a migration exception is not executed.
+    /// The exception that is thrown when a migration expression is not executed.
     /// </summary>
     /// <remarks>
-    /// <para>Migration expression such as Alter.Table(...).Do() *must* end with Do() else they are
-    /// not executed. When a non-executed expression is detected, an IncompleteMigrationExpressionException
-    /// is thrown.</para>
+    /// Migration expressions such as Alter.Table(...).Do() must end with Do(), else they are not executed.
+    /// When a non-executed expression is detected, an IncompleteMigrationExpressionException is thrown.
     /// </remarks>
+    /// <seealso cref="System.Exception" />
+    [Serializable]
     public class IncompleteMigrationExpressionException : Exception
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="IncompleteMigrationExpressionException"/> class.
+        /// Initializes a new instance of the <see cref="IncompleteMigrationExpressionException" /> class.
         /// </summary>
         public IncompleteMigrationExpressionException()
         { }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="IncompleteMigrationExpressionException"/> class with a message.
+        /// Initializes a new instance of the <see cref="IncompleteMigrationExpressionException" /> class with a message.
         /// </summary>
+        /// <param name="message">The message that describes the error.</param>
         public IncompleteMigrationExpressionException(string message)
             : base(message)
         { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="IncompleteMigrationExpressionException" /> class.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or a null reference (<see langword="Nothing" /> in Visual Basic) if no inner exception is specified.</param>
+        public IncompleteMigrationExpressionException(string message, Exception innerException)
+            : base(message, innerException)
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="IncompleteMigrationExpressionException" /> class.
+        /// </summary>
+        /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> that contains contextual information about the source or destination.</param>
+        protected IncompleteMigrationExpressionException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        { }
     }
 }

src/Umbraco.Core/Migrations/Install/DatabaseBuilder.cs

@@ -5,7 +5,6 @@ using System.IO;
 using System.Linq;
 using System.Xml.Linq;
 using Umbraco.Core.Configuration;
-using Umbraco.Core.Exceptions;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Migrations.Upgrade;
@@ -278,8 +277,10 @@ namespace Umbraco.Core.Migrations.Install
         /// <param name="logger">A logger.</param>
         private static void SaveConnectionString(string connectionString, string providerName, ILogger logger)
         {
-            if (string.IsNullOrWhiteSpace(connectionString)) throw new ArgumentNullOrEmptyException(nameof(connectionString));
-            if (string.IsNullOrWhiteSpace(providerName)) throw new ArgumentNullOrEmptyException(nameof(providerName));
+            if (connectionString == null) throw new ArgumentNullException(nameof(connectionString));
+            if (string.IsNullOrWhiteSpace(connectionString)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(connectionString));
+            if (providerName == null) throw new ArgumentNullException(nameof(providerName));
+            if (string.IsNullOrWhiteSpace(providerName)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(providerName));
 
             var fileSource = "web.config";
             var fileName = IOHelper.MapPath(SystemDirectories.Root +"/" + fileSource);

src/Umbraco.Core/Migrations/MigrationPlan.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Umbraco.Core.Exceptions;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Scoping;
 using Type = System.Type;
@@ -25,7 +24,9 @@ namespace Umbraco.Core.Migrations
         /// <param name="name">The name of the plan.</param>
         public MigrationPlan(string name)
         {
-            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentNullOrEmptyException(nameof(name));
+            if (name == null) throw new ArgumentNullException(nameof(name));
+            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(name));
+
             Name = name;
         }
 
@@ -43,7 +44,8 @@ namespace Umbraco.Core.Migrations
         private MigrationPlan Add(string sourceState, string targetState, Type migration)
         {
             if (sourceState == null) throw new ArgumentNullException(nameof(sourceState));
-            if (string.IsNullOrWhiteSpace(targetState)) throw new ArgumentNullOrEmptyException(nameof(targetState));
+            if (targetState == null) throw new ArgumentNullException(nameof(targetState));
+            if (string.IsNullOrWhiteSpace(targetState)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(targetState));
             if (sourceState == targetState) throw new ArgumentException("Source and target state cannot be identical.");
             if (migration == null) throw new ArgumentNullException(nameof(migration));
             if (!migration.Implements<IMigration>()) throw new ArgumentException($"Type {migration.Name} does not implement IMigration.", nameof(migration));
@@ -135,10 +137,12 @@ namespace Umbraco.Core.Migrations
         /// </summary>
         public MigrationPlan ToWithClone(string startState, string endState, string targetState)
         {
-            if (string.IsNullOrWhiteSpace(startState)) throw new ArgumentNullOrEmptyException(nameof(startState));
-            if (string.IsNullOrWhiteSpace(endState)) throw new ArgumentNullOrEmptyException(nameof(endState));
-            if (string.IsNullOrWhiteSpace(targetState)) throw new ArgumentNullOrEmptyException(nameof(targetState));
-
+            if (startState == null) throw new ArgumentNullException(nameof(startState));
+            if (string.IsNullOrWhiteSpace(startState)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(startState));
+            if (endState == null) throw new ArgumentNullException(nameof(endState));
+            if (string.IsNullOrWhiteSpace(endState)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(endState));
+            if (targetState == null) throw new ArgumentNullException(nameof(targetState));
+            if (string.IsNullOrWhiteSpace(targetState)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(targetState));
             if (startState == endState) throw new ArgumentException("Start and end states cannot be identical.");
 
             startState = startState.Trim();
@@ -317,7 +321,7 @@ namespace Umbraco.Core.Migrations
                 // throw a raw exception here: this should never happen as the plan has
                 // been validated - this is just a paranoid safety test
                 if (!_transitions.TryGetValue(origState, out transition))
-                    throw new Exception($"Unknown state \"{origState}\".");
+                    throw new InvalidOperationException($"Unknown state \"{origState}\".");
             }
 
             // prepare and de-duplicate post-migrations, only keeping the 1st occurence
@@ -339,7 +343,7 @@ namespace Umbraco.Core.Migrations
             // safety check - again, this should never happen as the plan has been validated,
             // and this is just a paranoid safety test
             if (origState != _finalState)
-                throw new Exception($"Internal error, reached state {origState} which is not final state {_finalState}");
+                throw new InvalidOperationException($"Internal error, reached state {origState} which is not final state {_finalState}");
 
             return origState;
         }
@@ -358,7 +362,7 @@ namespace Umbraco.Core.Migrations
             var states = new List<string> { origState };
 
             if (!_transitions.TryGetValue(origState, out var transition))
-                throw new Exception($"Unknown state \"{origState}\".");
+                throw new InvalidOperationException($"Unknown state \"{origState}\".");
 
             while (transition != null)
             {
@@ -373,12 +377,12 @@ namespace Umbraco.Core.Migrations
                 }
 
                 if (!_transitions.TryGetValue(origState, out transition))
-                    throw new Exception($"Unknown state \"{origState}\".");
+                    throw new InvalidOperationException($"Unknown state \"{origState}\".");
             }
 
             // safety check
             if (origState != (toState ?? _finalState))
-                throw new Exception($"Internal error, reached state {origState} which is not state {toState ?? _finalState}");
+                throw new InvalidOperationException($"Internal error, reached state {origState} which is not state {toState ?? _finalState}");
 
             return states;
         }
@@ -417,7 +421,7 @@ namespace Umbraco.Core.Migrations
             public override string ToString()
             {
                 return MigrationType == typeof(NoopMigration)
-                    ? $"{(SourceState == "" ? "<empty>" : SourceState)} --> {TargetState}"
+                    ? $"{(SourceState == string.Empty ? "<empty>" : SourceState)} --> {TargetState}"
                     : $"{SourceState} -- ({MigrationType.FullName}) --> {TargetState}";
             }
         }

src/Umbraco.Core/Migrations/Upgrade/UmbracoPlan.cs

@@ -183,9 +183,11 @@ namespace Umbraco.Core.Migrations.Upgrade
             To<RenameUserLoginDtoDateIndex>("{0372A42B-DECF-498D-B4D1-6379E907EB94}");
             To<FixContentNuCascade>("{5B1E0D93-F5A3-449B-84BA-65366B84E2D4}");
 
-            // to 8.5.0...
+            // to 8.6.0...
             To<UpdateRelationTypeTable>("{4759A294-9860-46BC-99F9-B4C975CAE580}");
             To<AddNewRelationTypes>("{0BC866BC-0665-487A-9913-0290BD0169AD}");
+            To<AddPropertyTypeValidationMessageColumns>("{3D67D2C8-5E65-47D0-A9E1-DC2EE0779D6B}");
+            
 
             //FINAL
         }

src/Umbraco.Core/Migrations/Upgrade/V_8_6_0/AddPropertyTypeValidationMessageColumns.cs

@@ -0,0 +1,20 @@
+using System.Linq;
+using Umbraco.Core.Persistence.Dtos;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_6_0
+{
+    public class AddPropertyTypeValidationMessageColumns : MigrationBase
+    {
+        public AddPropertyTypeValidationMessageColumns(IMigrationContext context)
+            : base(context)
+        { }
+
+        public override void Migrate()
+        {
+            var columns = SqlSyntax.GetColumnsInSchema(Context.Database).ToList();
+
+            AddColumnIfNotExists<PropertyTypeDto>(columns, "mandatoryMessage");
+            AddColumnIfNotExists<PropertyTypeDto>(columns, "validationRegExpMessage");
+        }
+    }
+}

src/Umbraco.Core/Models/ContentBase.cs

@@ -4,8 +4,6 @@ using System.Collections.Specialized;
 using System.Diagnostics;
 using System.Linq;
 using System.Runtime.Serialization;
-using Umbraco.Core.Composing;
-using Umbraco.Core.Exceptions;
 using Umbraco.Core.Models.Entities;
 
 namespace Umbraco.Core.Models
@@ -229,8 +227,8 @@ namespace Umbraco.Core.Models
 
         private void ClearCultureInfo(string culture)
         {
-            if (culture.IsNullOrWhiteSpace())
-                throw new ArgumentNullOrEmptyException(nameof(culture));
+            if (culture == null) throw new ArgumentNullException(nameof(culture));
+            if (string.IsNullOrWhiteSpace(culture)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(culture));
 
             if (_cultureInfos == null) return;
             _cultureInfos.Remove(culture);

src/Umbraco.Core/Models/ContentCultureInfos.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using Umbraco.Core.Exceptions;
 using Umbraco.Core.Models.Entities;
 
 namespace Umbraco.Core.Models
@@ -18,7 +17,9 @@ namespace Umbraco.Core.Models
         /// </summary>
         public ContentCultureInfos(string culture)
         {
-            if (culture.IsNullOrWhiteSpace()) throw new ArgumentNullOrEmptyException(nameof(culture));
+            if (culture == null) throw new ArgumentNullException(nameof(culture));
+            if (string.IsNullOrWhiteSpace(culture)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(culture));
+
             Culture = culture;
         }
 

src/Umbraco.Core/Models/ContentCultureInfosCollection.cs

@@ -1,8 +1,6 @@
 using System;
-using System.Collections.Generic;
 using System.Collections.Specialized;
 using Umbraco.Core.Collections;
-using Umbraco.Core.Exceptions;
 
 namespace Umbraco.Core.Models
 {
@@ -23,7 +21,9 @@ namespace Umbraco.Core.Models
         /// </summary>
         public void AddOrUpdate(string culture, string name, DateTime date)
         {
-            if (culture.IsNullOrWhiteSpace()) throw new ArgumentNullOrEmptyException(nameof(culture));
+            if (culture == null) throw new ArgumentNullException(nameof(culture));
+            if (string.IsNullOrWhiteSpace(culture)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(culture));
+
             culture = culture.ToLowerInvariant();
 
             if (TryGetValue(culture, out var item))

src/Umbraco.Core/Models/ContentRepositoryExtensions.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Umbraco.Core.Exceptions;
 
 namespace Umbraco.Core.Models
 {
@@ -103,11 +102,11 @@ namespace Umbraco.Core.Models
 
         public static void SetPublishInfo(this IContent content, string culture, string name, DateTime date)
         {
-            if (string.IsNullOrWhiteSpace(name))
-                throw new ArgumentNullOrEmptyException(nameof(name));
+            if (name == null) throw new ArgumentNullException(nameof(name));
+            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(name));
 
-            if (culture.IsNullOrWhiteSpace())
-                throw new ArgumentNullOrEmptyException(nameof(culture));
+            if (culture == null) throw new ArgumentNullException(nameof(culture));
+            if (string.IsNullOrWhiteSpace(culture)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(culture));
 
             content.PublishCultureInfos.AddOrUpdate(culture, name, date);
         }
@@ -153,11 +152,11 @@ namespace Umbraco.Core.Models
 
         public static void SetCultureInfo(this IContentBase content, string culture, string name, DateTime date)
         {
-            if (name.IsNullOrWhiteSpace())
-                throw new ArgumentNullOrEmptyException(nameof(name));
+            if (name == null) throw new ArgumentNullException(nameof(name));
+            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(name));
 
-            if (culture.IsNullOrWhiteSpace())
-                throw new ArgumentNullOrEmptyException(nameof(culture));
+            if (culture == null) throw new ArgumentNullException(nameof(culture));
+            if (string.IsNullOrWhiteSpace(culture)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(culture));
 
             content.CultureInfos.AddOrUpdate(culture, name, date);
         }
@@ -276,8 +275,8 @@ namespace Umbraco.Core.Models
         /// <returns></returns>
         public static bool ClearPublishInfo(this IContent content, string culture)
         {
-            if (culture.IsNullOrWhiteSpace())
-                throw new ArgumentNullOrEmptyException(nameof(culture));
+            if (culture == null) throw new ArgumentNullException(nameof(culture));
+            if (string.IsNullOrWhiteSpace(culture)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(culture));
 
             var removed = content.PublishCultureInfos.Remove(culture);
             if (removed)

src/Umbraco.Core/Models/Entities/EntitySlim.cs

@@ -66,7 +66,7 @@ namespace Umbraco.Core.Models.Entities
         public int ParentId { get; set; }
 
         /// <inheritdoc />
-        public void SetParent(ITreeEntity parent) => throw new WontImplementException();
+        public void SetParent(ITreeEntity parent) => throw new InvalidOperationException("This property won't be implemented.");
 
         /// <inheritdoc />
         [DataMember]
@@ -116,7 +116,7 @@ namespace Umbraco.Core.Models.Entities
         /// <inheritdoc />
         public object DeepClone()
         {
-            throw new WontImplementException();
+            throw new InvalidOperationException("This method won't be implemented.");
         }
 
         #endregion
@@ -128,47 +128,47 @@ namespace Umbraco.Core.Models.Entities
 
         public bool IsDirty()
         {
-            throw new WontImplementException();
+            throw new InvalidOperationException("This method won't be implemented.");
         }
 
         public bool IsPropertyDirty(string propName)
         {
-            throw new WontImplementException();
+            throw new InvalidOperationException("This method won't be implemented.");
         }
 
         public IEnumerable<string> GetDirtyProperties()
         {
-            throw new WontImplementException();
+            throw new InvalidOperationException("This method won't be implemented.");
         }
 
         public void ResetDirtyProperties()
         {
-            throw new WontImplementException();
+            throw new InvalidOperationException("This method won't be implemented.");
         }
 
         public bool WasDirty()
         {
-            throw new WontImplementException();
+            throw new InvalidOperationException("This method won't be implemented.");
         }
 
         public bool WasPropertyDirty(string propertyName)
         {
-            throw new WontImplementException();
+            throw new InvalidOperationException("This method won't be implemented.");
         }
 
         public void ResetWereDirtyProperties()
         {
-            throw new WontImplementException();
+            throw new InvalidOperationException("This method won't be implemented.");
         }
 
         public void ResetDirtyProperties(bool rememberDirty)
         {
-            throw new WontImplementException();
+            throw new InvalidOperationException("This method won't be implemented.");
         }
 
         public IEnumerable<string> GetWereDirtyProperties()
         {
-            throw new WontImplementException();
+            throw new InvalidOperationException("This method won't be implemented.");
         }
 
         #endregion

src/Umbraco.Core/Models/MediaExtensions.cs

@@ -1,10 +1,8 @@
-using System;
-using System.Linq;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
+using System.Linq;
+using Umbraco.Core.Composing;
 using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.Logging;
-using Umbraco.Core.PropertyEditors.ValueConverters;
+using Umbraco.Core.PropertyEditors;
 
 namespace Umbraco.Core.Models
 {
@@ -18,29 +16,12 @@ namespace Umbraco.Core.Models
             if (!media.Properties.TryGetValue(propertyAlias, out var property))
                 return string.Empty;
 
-            // TODO: would need to be adjusted to variations, when media become variants
-            if (!(property.GetValue() is string jsonString))
-                return string.Empty;
-
-            if (property.PropertyType.PropertyEditorAlias == Constants.PropertyEditors.Aliases.UploadField)
-                return jsonString;
-
-            if (property.PropertyType.PropertyEditorAlias == Constants.PropertyEditors.Aliases.ImageCropper)
+            if (Current.PropertyEditors.TryGet(property.PropertyType.PropertyEditorAlias, out var editor)
+                && editor is IDataEditorWithMediaPath dataEditor)
             {
-                if (jsonString.DetectIsJson() == false)
-                    return jsonString;
-
-                try
-                {
-                    var json = JsonConvert.DeserializeObject<JObject>(jsonString);
-                    if (json["src"] != null)
-                        return json["src"].Value<string>();
-                }
-                catch (Exception ex)
-                {
-                    logger.Error<ImageCropperValueConverter>(ex, "Could not parse the string '{JsonString}' to a json object", jsonString);
-                    return string.Empty;
-                }
+                // TODO: would need to be adjusted to variations, when media become variants
+                var value = property.GetValue();
+                return dataEditor.GetMediaPath(value);
             }
 
             // Without knowing what it is, just adding a string here might not be very nice

src/Umbraco.Core/Models/Member.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Runtime.Serialization;
 using Umbraco.Core.Composing;
-using Umbraco.Core.Exceptions;
 using Umbraco.Core.Logging;
 
 namespace Umbraco.Core.Models
@@ -43,7 +42,8 @@ namespace Umbraco.Core.Models
         public Member(string name, IMemberType contentType)
             : base(name, -1, contentType, new PropertyCollection())
         {
-            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentNullOrEmptyException(nameof(name));
+            if (name == null) throw new ArgumentNullException(nameof(name));
+            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(name));
 
             IsApproved = true;
 
@@ -63,9 +63,12 @@ namespace Umbraco.Core.Models
         public Member(string name, string email, string username, IMemberType contentType, bool isApproved = true)
             : base(name, -1, contentType, new PropertyCollection())
         {
-            if (string.IsNullOrWhiteSpace(email)) throw new ArgumentNullOrEmptyException(nameof(email));
-            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentNullOrEmptyException(nameof(name));
-            if (string.IsNullOrWhiteSpace(username)) throw new ArgumentNullOrEmptyException(nameof(username));
+            if (name == null) throw new ArgumentNullException(nameof(name));
+            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(name));
+            if (email == null) throw new ArgumentNullException(nameof(email));
+            if (string.IsNullOrWhiteSpace(email)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(email));
+            if (username == null) throw new ArgumentNullException(nameof(username));
+            if (string.IsNullOrWhiteSpace(username)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(username));
 
             _email = email;
             _username = username;

src/Umbraco.Core/Models/PagedResult.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Runtime.Serialization;
 
 namespace Umbraco.Core.Models
@@ -9,7 +8,7 @@ namespace Umbraco.Core.Models
     /// </summary>
     /// <typeparam name="T"></typeparam>
     [DataContract(Name = "pagedCollection", Namespace = "")]
-    public class PagedResult<T>
+    public abstract class PagedResult
     {
         public PagedResult(long totalItems, long pageNumber, long pageSize)
         {
@@ -39,9 +38,6 @@ namespace Umbraco.Core.Models
         [DataMember(Name = "totalItems")]
         public long TotalItems { get; private set; }
 
-        [DataMember(Name = "items")]
-        public IEnumerable<T> Items { get; set; }
-
         /// <summary>
         /// Calculates the skip size based on the paged parameters specified
         /// </summary>

src/Umbraco.Core/Models/PagedResultOfT.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+
+namespace Umbraco.Core.Models
+{
+    /// <summary>
+    /// Represents a paged result for a model collection
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    [DataContract(Name = "pagedCollection", Namespace = "")]
+    public class PagedResult<T> : PagedResult
+    {
+        public PagedResult(long totalItems, long pageNumber, long pageSize)
+            : base(totalItems, pageNumber, pageSize)
+        { }
+
+        [DataMember(Name = "items")]
+        public IEnumerable<T> Items { get; set; }
+    }
+}

src/Umbraco.Core/Models/PropertyType.cs

@@ -26,8 +26,10 @@ namespace Umbraco.Core.Models
         private string _propertyEditorAlias;
         private ValueStorageType _valueStorageType;
         private bool _mandatory;
+        private string _mandatoryMessage;
         private int _sortOrder;
         private string _validationRegExp;
+        private string _validationRegExpMessage;
         private ContentVariation _variations;
 
         /// <summary>
@@ -183,7 +185,7 @@ namespace Umbraco.Core.Models
         }
 
         /// <summary>
-        /// Gets of sets a value indicating whether a value for this property type is required.
+        /// Gets or sets a value indicating whether a value for this property type is required.
         /// </summary>
         [DataMember]
         public bool Mandatory
@@ -192,6 +194,16 @@ namespace Umbraco.Core.Models
             set => SetPropertyValueAndDetectChanges(value, ref _mandatory, nameof(Mandatory));
         }
 
+        /// <summary>
+        /// Gets or sets the custom validation message used when a value for this PropertyType is required
+        /// </summary>
+        [DataMember]
+        public string MandatoryMessage
+        {
+            get => _mandatoryMessage;
+            set => SetPropertyValueAndDetectChanges(value, ref _mandatoryMessage, nameof(MandatoryMessage));
+        }
+
         /// <summary>
         /// Gets of sets the sort order of the property type.
         /// </summary>
@@ -212,6 +224,16 @@ namespace Umbraco.Core.Models
             set => SetPropertyValueAndDetectChanges(value, ref _validationRegExp, nameof(ValidationRegExp));
         }
 
+        /// <summary>
+        /// Gets or sets the custom validation message used when a pattern for this PropertyType must be matched
+        /// </summary>
+        [DataMember]
+        public string ValidationRegExpMessage
+        {
+            get => _validationRegExpMessage;
+            set => SetPropertyValueAndDetectChanges(value, ref _validationRegExpMessage, nameof(ValidationRegExpMessage));
+        }
+
         /// <summary>
         /// Gets or sets the content variation of the property type.
         /// </summary>

src/Umbraco.Core/Models/PublishedContent/ModelType.cs

@@ -20,7 +20,9 @@ namespace Umbraco.Core.Models.PublishedContent
     {
         private ModelType(string contentTypeAlias)
         {
-            if (string.IsNullOrWhiteSpace(contentTypeAlias)) throw new ArgumentNullOrEmptyException(nameof(contentTypeAlias));
+            if (contentTypeAlias == null) throw new ArgumentNullException(nameof(contentTypeAlias));
+            if (string.IsNullOrWhiteSpace(contentTypeAlias)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(contentTypeAlias));
+
             ContentTypeAlias = contentTypeAlias;
             Name = "{" + ContentTypeAlias + "}";
         }

src/Umbraco.Core/Models/PublishedContent/PublishedCultureInfos.cs

@@ -1,5 +1,4 @@
 using System;
-using Umbraco.Core.Exceptions;
 
 namespace Umbraco.Core.Models.PublishedContent
 {
@@ -13,7 +12,8 @@ namespace Umbraco.Core.Models.PublishedContent
         /// </summary>
         public PublishedCultureInfo(string culture, string name, string urlSegment, DateTime date)
         {
-            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentNullOrEmptyException(nameof(name));
+            if (name == null) throw new ArgumentNullException(nameof(name));
+            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(name));
 
             Culture = culture ?? throw new ArgumentNullException(nameof(culture));
             Name = name;

src/Umbraco.Core/Models/PublishedContent/PublishedModelAttribute.cs

@@ -1,5 +1,4 @@
 using System;
-using Umbraco.Core.Exceptions;
 
 namespace Umbraco.Core.Models.PublishedContent
 {
@@ -19,7 +18,9 @@ namespace Umbraco.Core.Models.PublishedContent
         /// <param name="contentTypeAlias">The content type alias.</param>
         public PublishedModelAttribute(string contentTypeAlias)
         {
-            if (string.IsNullOrWhiteSpace(contentTypeAlias)) throw new ArgumentNullOrEmptyException(nameof(contentTypeAlias));
+            if (contentTypeAlias == null) throw new ArgumentNullException(nameof(contentTypeAlias));
+            if (string.IsNullOrWhiteSpace(contentTypeAlias)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(contentTypeAlias));
+
             ContentTypeAlias = contentTypeAlias;
         }
 

src/Umbraco.Core/Models/RelationType.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Runtime.Serialization;
-using Umbraco.Core.Exceptions;
 using Umbraco.Core.Models.Entities;
 
 namespace Umbraco.Core.Models

src/Umbraco.Core/Packaging/PackageDataInstallation.cs

@@ -787,7 +787,14 @@ namespace Umbraco.Core.Packaging
                     Mandatory = property.Element("Mandatory") != null
                         ? property.Element("Mandatory").Value.ToLowerInvariant().Equals("true")
                         : false,
+                    MandatoryMessage = property.Element("MandatoryMessage") != null
+                        ? (string)property.Element("MandatoryMessage")
+                        : string.Empty,
+
                     ValidationRegExp = (string)property.Element("Validation"),
+                    ValidationRegExpMessage = property.Element("ValidationRegExpMessage") != null
+                        ? (string)property.Element("ValidationRegExpMessage")
+                        : string.Empty,
                     SortOrder = sortOrder,
                     Variations = property.Element("Variations") != null
                         ? (ContentVariation)Enum.Parse(typeof(ContentVariation), property.Element("Variations").Value)

src/Umbraco.Core/Persistence/Dtos/PropertyTypeDto.cs

@@ -43,10 +43,20 @@ namespace Umbraco.Core.Persistence.Dtos
         [Constraint(Default = "0")]
         public bool Mandatory { get; set; }
 
+        [Column("mandatoryMessage")]
+        [NullSetting(NullSetting = NullSettings.Null)]
+        [Length(500)]
+        public string MandatoryMessage { get; set; }
+
         [Column("validationRegExp")]
         [NullSetting(NullSetting = NullSettings.Null)]
         public string ValidationRegExp { get; set; }
 
+        [Column("validationRegExpMessage")]
+        [NullSetting(NullSetting = NullSettings.Null)]
+        [Length(500)]
+        public string ValidationRegExpMessage { get; set; }
+
         [Column("Description")]
         [NullSetting(NullSetting = NullSettings.Null)]
         [Length(2000)]

src/Umbraco.Core/Persistence/Dtos/PropertyTypeReadOnlyDto.cs

@@ -32,9 +32,15 @@ namespace Umbraco.Core.Persistence.Dtos
         [Column("mandatory")]
         public bool Mandatory { get; set; }
 
+        [Column("mandatoryMessage")]
+        public string MandatoryMessage { get; set; }
+
         [Column("validationRegExp")]
         public string ValidationRegExp { get; set; }
 
+        [Column("validationRegExpMessage")]
+        public string ValidationRegExpMessage { get; set; }
+
         [Column("Description")]
         public string Description { get; set; }
 

src/Umbraco.Core/Persistence/EntityNotFoundException.cs

@@ -1,38 +1,96 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using System.Runtime.Serialization;
 
 namespace Umbraco.Core.Persistence
 {
-
-    // TODO: Would be good to use this exception type anytime we cannot find an entity
-
     /// <summary>
-    /// An exception used to indicate that an umbraco entity could not be found
+    /// An exception used to indicate that an Umbraco entity could not be found.
     /// </summary>
+    /// <seealso cref="System.Exception" />
+    [Obsolete("Instead of throwing an exception, return null or an HTTP 404 status code instead.")]
+    [Serializable]
     public class EntityNotFoundException : Exception
     {
+        /// <summary>
+        /// Gets the identifier.
+        /// </summary>
+        /// <value>
+        /// The identifier.
+        /// </value>
+        /// <remarks>
+        /// This object should be serializable to prevent a <see cref="SerializationException" /> to be thrown.
+        /// </remarks>
         public object Id { get; private set; }
-        private readonly string _msg;
 
-        public EntityNotFoundException(object id, string msg)
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EntityNotFoundException" /> class.
+        /// </summary>
+        public EntityNotFoundException()
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EntityNotFoundException" /> class.
+        /// </summary>
+        /// <param name="id">The identifier.</param>
+        /// <param name="message">The message.</param>
+        public EntityNotFoundException(object id, string message)
+            : base(message)
         {
             Id = id;
-            _msg = msg;
         }
 
-        public EntityNotFoundException(string msg)
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EntityNotFoundException" /> class.
+        /// </summary>
+        /// <param name="message">The message that describes the error.</param>
+        public EntityNotFoundException(string message)
+            : base(message)
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EntityNotFoundException" /> class.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or a null reference (<see langword="Nothing" /> in Visual Basic) if no inner exception is specified.</param>
+        public EntityNotFoundException(string message, Exception innerException)
+            : base(message, innerException)
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EntityNotFoundException" /> class.
+        /// </summary>
+        /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> that contains contextual information about the source or destination.</param>
+        protected EntityNotFoundException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
         {
-            _msg = msg;
+            Id = info.GetValue(nameof(Id), typeof(object));
         }
 
-        public override string Message
+        /// <summary>
+        /// When overridden in a derived class, sets the <see cref="T:System.Runtime.Serialization.SerializationInfo" /> with information about the exception.
+        /// </summary>
+        /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> that contains contextual information about the source or destination.</param>
+        /// <exception cref="ArgumentNullException">info</exception>
+        public override void GetObjectData(SerializationInfo info, StreamingContext context)
         {
-            get { return _msg; }
+            if (info == null)
+            {
+                throw new ArgumentNullException(nameof(info));
+            }
+
+            info.AddValue(nameof(Id), Id);
+
+            base.GetObjectData(info, context);
         }
 
+        /// <summary>
+        /// Returns a <see cref="System.String" /> that represents this instance.
+        /// </summary>
+        /// <returns>
+        /// A <see cref="System.String" /> that represents this instance.
+        /// </returns>
         public override string ToString()
         {
             var result = base.ToString();

src/Umbraco.Core/Persistence/Factories/ContentBaseFactory.cs

@@ -1,17 +1,15 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text.RegularExpressions;
 using Umbraco.Core.Models;
 using Umbraco.Core.Persistence.Dtos;
 using Umbraco.Core.Persistence.Repositories;
+using Umbraco.Core.PropertyEditors;
 
 namespace Umbraco.Core.Persistence.Factories
 {
     internal class ContentBaseFactory
     {
-        private static readonly Regex MediaPathPattern = new Regex(@"(/media/.+?)(?:['""]|$)", RegexOptions.Compiled);
-
         /// <summary>
         /// Builds an IContent item from a dto and content type.
         /// </summary>
@@ -189,7 +187,7 @@ namespace Umbraco.Core.Persistence.Factories
         /// <summary>
         /// Builds a dto from an IMedia item.
         /// </summary>
-        public static MediaDto BuildDto(IMedia entity)
+        public static MediaDto BuildDto(PropertyEditorCollection propertyEditors, IMedia entity)
         {
             var contentDto = BuildContentDto(entity, Constants.ObjectTypes.Media);
 
@@ -197,7 +195,7 @@ namespace Umbraco.Core.Persistence.Factories
             {
                 NodeId = entity.Id,
                 ContentDto = contentDto,
-                MediaVersionDto = BuildMediaVersionDto(entity, contentDto)
+                MediaVersionDto = BuildMediaVersionDto(propertyEditors, entity, contentDto)
             };
 
             return dto;
@@ -291,12 +289,20 @@ namespace Umbraco.Core.Persistence.Factories
             return dto;
         }
 
-        private static MediaVersionDto BuildMediaVersionDto(IMedia entity, ContentDto contentDto)
+        private static MediaVersionDto BuildMediaVersionDto(PropertyEditorCollection propertyEditors, IMedia entity, ContentDto contentDto)
         {
             // try to get a path from the string being stored for media
             // TODO: only considering umbracoFile
 
-            TryMatch(entity.GetValue<string>("umbracoFile"), out var path);
+            string path = null;
+
+            if (entity.Properties.TryGetValue(Constants.Conventions.Media.File, out var property)
+                && propertyEditors.TryGet(property.PropertyType.PropertyEditorAlias, out var editor)
+                && editor is IDataEditorWithMediaPath dataEditor)
+            {
+                var value = property.GetValue();
+                path = dataEditor.GetMediaPath(value);
+            }
 
             var dto = new MediaVersionDto
             {
@@ -308,22 +314,5 @@ namespace Umbraco.Core.Persistence.Factories
 
             return dto;
         }
-
-        // TODO: this should NOT be here?!
-        // more dark magic ;-(
-        internal static bool TryMatch(string text, out string path)
-        {
-            // In v8 we should allow exposing this via the property editor in a much nicer way so that the property editor
-            // can tell us directly what any URL is for a given property if it contains an asset
-
-            path = null;
-            if (string.IsNullOrWhiteSpace(text)) return false;
-
-            var m = MediaPathPattern.Match(text);
-            if (!m.Success || m.Groups.Count != 2) return false;
-
-            path = m.Groups[1].Value;
-            return true;
-        }
     }
 }

src/Umbraco.Core/Persistence/Factories/PropertyGroupFactory.cs

@@ -60,8 +60,10 @@ namespace Umbraco.Core.Persistence.Factories
                             propertyType.Key = typeDto.UniqueId;
                             propertyType.Name = typeDto.Name;
                             propertyType.Mandatory = typeDto.Mandatory;
+                            propertyType.MandatoryMessage = typeDto.MandatoryMessage;
                             propertyType.SortOrder = typeDto.SortOrder;
                             propertyType.ValidationRegExp = typeDto.ValidationRegExp;
+                            propertyType.ValidationRegExpMessage = typeDto.ValidationRegExpMessage;
                             propertyType.PropertyGroupId = new Lazy<int>(() => tempGroupDto.Id);
                             propertyType.CreateDate = createDate;
                             propertyType.UpdateDate = updateDate;
@@ -124,9 +126,11 @@ namespace Umbraco.Core.Persistence.Factories
                 DataTypeId = propertyType.DataTypeId,
                 Description = propertyType.Description,
                 Mandatory = propertyType.Mandatory,
+                MandatoryMessage = propertyType.MandatoryMessage,
                 Name = propertyType.Name,
                 SortOrder = propertyType.SortOrder,
                 ValidationRegExp = propertyType.ValidationRegExp,
+                ValidationRegExpMessage = propertyType.ValidationRegExpMessage,
                 UniqueId = propertyType.Key,
                 Variations = (byte)propertyType.Variations
             };

src/Umbraco.Core/Persistence/FaultHandling/RetryLimitExceededException.cs

@@ -4,59 +4,51 @@ using System.Runtime.Serialization;
 namespace Umbraco.Core.Persistence.FaultHandling
 {
     /// <summary>
-    /// The special type of exception that provides managed exit from a retry loop. The user code can use this
-    /// exception to notify the retry policy that no further retry attempts are required.
+    /// The special type of exception that provides managed exit from a retry loop. The user code can use this exception to notify the retry policy that no further retry attempts are required.
     /// </summary>
+    /// <seealso cref="System.Exception" />
     [Serializable]
     public sealed class RetryLimitExceededException : Exception
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="RetryLimitExceededException"/> class with a default error message.
+        /// Initializes a new instance of the <see cref="RetryLimitExceededException" /> class with a default error message.
         /// </summary>
         public RetryLimitExceededException()
-            : this("RetryLimitExceeded")
-        {
-        }
+            : base()
+        { }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="RetryLimitExceededException"/> class with a specified error message.
+        /// Initializes a new instance of the <see cref="RetryLimitExceededException" /> class with a specified error message.
         /// </summary>
         /// <param name="message">The message that describes the error.</param>
         public RetryLimitExceededException(string message)
             : base(message)
-        {
-        }
+        { }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="RetryLimitExceededException"/> class with a reference to the inner exception
-        /// that is the cause of this exception.
+        /// Initializes a new instance of the <see cref="RetryLimitExceededException" /> class with a reference to the inner exception that is the cause of this exception.
         /// </summary>
         /// <param name="innerException">The exception that is the cause of the current exception.</param>
         public RetryLimitExceededException(Exception innerException)
-            : base(innerException != null ? innerException.Message : "RetryLimitExceeded", innerException)
-        {
-        }
+            : base(null, innerException)
+        { }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="RetryLimitExceededException"/> class.
+        /// Initializes a new instance of the <see cref="RetryLimitExceededException" /> class.
         /// </summary>
         /// <param name="message">The message that describes the error.</param>
         /// <param name="innerException">The exception that is the cause of the current exception.</param>
         public RetryLimitExceededException(string message, Exception innerException)
             : base(message, innerException)
-        {
-        }
+        { }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="RetryLimitExceededException"/> class.
+        /// Initializes a new instance of the <see cref="RetryLimitExceededException" /> class.
         /// </summary>
-        /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
-        /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
-        /// <exception cref="T:System.ArgumentNullException">The <paramref name="info"/> parameter is null.</exception>
-        /// <exception cref="T:System.Runtime.Serialization.SerializationException">The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0).</exception>
+        /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> that contains contextual information about the source or destination.</param>
         private RetryLimitExceededException(SerializationInfo info, StreamingContext context)
             : base(info, context)
-        {
-        }
+        { }
     }
 }

src/Umbraco.Core/Persistence/Mappers/PropertyTypeMapper.cs

@@ -24,9 +24,11 @@ namespace Umbraco.Core.Persistence.Mappers
             DefineMap<PropertyType, PropertyTypeDto>(nameof(PropertyType.DataTypeId), nameof(PropertyTypeDto.DataTypeId));
             DefineMap<PropertyType, PropertyTypeDto>(nameof(PropertyType.Description), nameof(PropertyTypeDto.Description));
             DefineMap<PropertyType, PropertyTypeDto>(nameof(PropertyType.Mandatory), nameof(PropertyTypeDto.Mandatory));
+            DefineMap<PropertyType, PropertyTypeDto>(nameof(PropertyType.MandatoryMessage), nameof(PropertyTypeDto.MandatoryMessage));
             DefineMap<PropertyType, PropertyTypeDto>(nameof(PropertyType.Name), nameof(PropertyTypeDto.Name));
             DefineMap<PropertyType, PropertyTypeDto>(nameof(PropertyType.SortOrder), nameof(PropertyTypeDto.SortOrder));
             DefineMap<PropertyType, PropertyTypeDto>(nameof(PropertyType.ValidationRegExp), nameof(PropertyTypeDto.ValidationRegExp));
+            DefineMap<PropertyType, PropertyTypeDto>(nameof(PropertyType.ValidationRegExpMessage), nameof(PropertyTypeDto.ValidationRegExpMessage));
             DefineMap<PropertyType, DataTypeDto>(nameof(PropertyType.PropertyEditorAlias), nameof(DataTypeDto.EditorAlias));
             DefineMap<PropertyType, DataTypeDto>(nameof(PropertyType.ValueStorageType), nameof(DataTypeDto.DbType));
         }

src/Umbraco.Core/Persistence/Repositories/Implement/ContentTypeCommonRepository.cs

@@ -297,10 +297,12 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
                 Id = dto.Id,
                 Key = dto.UniqueId,
                 Mandatory = dto.Mandatory,
+                MandatoryMessage = dto.MandatoryMessage,
                 Name = dto.Name,
                 PropertyGroupId = groupId.HasValue ? new Lazy<int>(() => groupId.Value) : null,
                 SortOrder = dto.SortOrder,
                 ValidationRegExp = dto.ValidationRegExp,
+                ValidationRegExpMessage = dto.ValidationRegExpMessage,
                 Variations = (ContentVariation)dto.Variations
             };
         }

src/Umbraco.Core/Persistence/Repositories/Implement/DocumentRepository.cs

@@ -944,32 +944,32 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
 
             protected override IEnumerable<IContent> PerformGetByQuery(IQuery<IContent> query)
             {
-                throw new WontImplementException();
+                throw new InvalidOperationException("This method won't be implemented.");
             }
 
             protected override IEnumerable<string> GetDeleteClauses()
             {
-                throw new WontImplementException();
+                throw new InvalidOperationException("This method won't be implemented.");
             }
 
             protected override void PersistNewItem(IContent entity)
             {
-                throw new WontImplementException();
+                throw new InvalidOperationException("This method won't be implemented.");
             }
 
             protected override void PersistUpdatedItem(IContent entity)
             {
-                throw new WontImplementException();
+                throw new InvalidOperationException("This method won't be implemented.");
             }
 
             protected override Sql<ISqlContext> GetBaseQuery(bool isCount)
             {
-                throw new WontImplementException();
+                throw new InvalidOperationException("This method won't be implemented.");
             }
 
             protected override string GetBaseWhereClause()
             {
-                throw new WontImplementException();
+                throw new InvalidOperationException("This method won't be implemented.");
             }
         }
 

src/Umbraco.Core/Persistence/Repositories/Implement/EntityContainerRepository.cs

@@ -3,7 +3,6 @@ using System.Collections.Generic;
 using System.Linq;
 using NPoco;
 using Umbraco.Core.Cache;
-using Umbraco.Core.Exceptions;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Persistence.Dtos;
@@ -129,6 +128,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
 
         protected override void PersistDeletedItem(EntityContainer entity)
         {
+            if (entity == null) throw new ArgumentNullException(nameof(entity));
             EnsureContainerType(entity);
 
             var nodeDto = Database.FirstOrDefault<NodeDto>(Sql().SelectAll()
@@ -162,9 +162,11 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
 
         protected override void PersistNewItem(EntityContainer entity)
         {
+            if (entity == null) throw new ArgumentNullException(nameof(entity));
             EnsureContainerType(entity);
 
-            if (string.IsNullOrWhiteSpace(entity.Name)) throw new ArgumentNullOrEmptyException("entity.Name");
+            if (entity.Name == null) throw new InvalidOperationException("Entity name can't be null.");
+            if (string.IsNullOrWhiteSpace(entity.Name)) throw new InvalidOperationException("Entity name can't be empty or consist only of white-space characters.");
             entity.Name = entity.Name.Trim();
 
             // guard against duplicates
@@ -184,7 +186,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
                     .Where<NodeDto>(dto => dto.NodeId == entity.ParentId && dto.NodeObjectType == entity.ContainerObjectType));
 
                 if (parentDto == null)
-                    throw new NullReferenceException("Could not find parent container with id " + entity.ParentId);
+                    throw new InvalidOperationException("Could not find parent container with id " + entity.ParentId);
 
                 level = parentDto.Level;
                 path = parentDto.Path;
@@ -223,10 +225,12 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
         //
         protected override void PersistUpdatedItem(EntityContainer entity)
         {
+            if (entity == null) throw new ArgumentNullException(nameof(entity));
             EnsureContainerType(entity);
 
+            if (entity.Name == null) throw new InvalidOperationException("Entity name can't be null.");
+            if (string.IsNullOrWhiteSpace(entity.Name)) throw new InvalidOperationException("Entity name can't be empty or consist only of white-space characters.");
             entity.Name = entity.Name.Trim();
-            if (string.IsNullOrWhiteSpace(entity.Name)) throw new ArgumentNullOrEmptyException("entity.Name");
 
             // find container to update
             var nodeDto = Database.FirstOrDefault<NodeDto>(Sql().SelectAll()
@@ -255,7 +259,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
                         .Where<NodeDto>(dto => dto.NodeId == entity.ParentId && dto.NodeObjectType == entity.ContainerObjectType));
 
                     if (parent == null)
-                        throw new NullReferenceException("Could not find parent container with id " + entity.ParentId);
+                        throw new InvalidOperationException("Could not find parent container with id " + entity.ParentId);
 
                     nodeDto.Level = Convert.ToInt16(parent.Level + 1);
                     nodeDto.Path = parent.Path + "," + nodeDto.NodeId;

src/Umbraco.Core/Persistence/Repositories/Implement/MediaRepository.cs

@@ -230,7 +230,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
             entity.SanitizeEntityPropertiesForXmlStorage();
 
             // create the dto
-            var dto = ContentBaseFactory.BuildDto(entity);
+            var dto = ContentBaseFactory.BuildDto(PropertyEditors, entity);
 
             // derive path and level from parent
             var parent = GetParentNodeDto(entity.ParentId);
@@ -321,7 +321,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
             }
 
             // create the dto
-            var dto = ContentBaseFactory.BuildDto(entity);
+            var dto = ContentBaseFactory.BuildDto(PropertyEditors, entity);
 
             // update the node dto
             var nodeDto = dto.ContentDto.NodeDto;
@@ -431,32 +431,32 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
 
             protected override IEnumerable<IMedia> PerformGetByQuery(IQuery<IMedia> query)
             {
-                throw new WontImplementException();
+                throw new InvalidOperationException("This method won't be implemented.");
             }
 
             protected override IEnumerable<string> GetDeleteClauses()
             {
-                throw new WontImplementException();
+                throw new InvalidOperationException("This method won't be implemented.");
             }
 
             protected override void PersistNewItem(IMedia entity)
             {
-                throw new WontImplementException();
+                throw new InvalidOperationException("This method won't be implemented.");
             }
 
             protected override void PersistUpdatedItem(IMedia entity)
             {
-                throw new WontImplementException();
+                throw new InvalidOperationException("This method won't be implemented.");
             }
 
             protected override Sql<ISqlContext> GetBaseQuery(bool isCount)
             {
-                throw new WontImplementException();
+                throw new InvalidOperationException("This method won't be implemented.");
             }
 
             protected override string GetBaseWhereClause()
             {
-                throw new WontImplementException();
+                throw new InvalidOperationException("This method won't be implemented.");
             }
         }
 
@@ -548,6 +548,6 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
             media.ResetDirtyProperties(false);
             return media;
         }
-        
+
     }
 }

src/Umbraco.Core/Persistence/Repositories/Implement/MemberTypeRepository.cs

@@ -225,8 +225,17 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
                 if (builtinProperties.ContainsKey(propertyType.Alias))
                 {
                     //this reset's its current data type reference which will be re-assigned based on the property editor assigned on the next line
-                    propertyType.DataTypeId = 0;
-                    propertyType.DataTypeKey = default;
+                    var propDefinition = builtinProperties[propertyType.Alias];
+                    if (propDefinition != null)
+                    {
+                        propertyType.DataTypeId = propDefinition.DataTypeId;
+                        propertyType.DataTypeKey = propDefinition.DataTypeKey;
+                    }
+                    else
+                    {
+                        propertyType.DataTypeId = 0;
+                        propertyType.DataTypeKey = default;
+                    }
                 }
             }
         }

src/Umbraco.Core/Persistence/Repositories/Implement/PermissionRepository.cs

@@ -252,27 +252,27 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
 
         protected override ContentPermissionSet PerformGet(int id)
         {
-            throw new WontImplementException();
+            throw new InvalidOperationException("This method won't be implemented.");
         }
 
         protected override IEnumerable<ContentPermissionSet> PerformGetAll(params int[] ids)
         {
-            throw new WontImplementException();
+            throw new InvalidOperationException("This method won't be implemented.");
         }
 
         protected override IEnumerable<ContentPermissionSet> PerformGetByQuery(IQuery<ContentPermissionSet> query)
         {
-            throw new WontImplementException();
+            throw new InvalidOperationException("This method won't be implemented.");
         }
 
         protected override Sql<ISqlContext> GetBaseQuery(bool isCount)
         {
-            throw new WontImplementException();
+            throw new InvalidOperationException("This method won't be implemented.");
         }
 
         protected override string GetBaseWhereClause()
         {
-            throw new WontImplementException();
+            throw new InvalidOperationException("This method won't be implemented.");
         }
 
         protected override IEnumerable<string> GetDeleteClauses()
@@ -280,11 +280,11 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
             return new List<string>();
         }
 
-        protected override Guid NodeObjectTypeId => throw new WontImplementException();
+        protected override Guid NodeObjectTypeId => throw new InvalidOperationException("This property won't be implemented.");
 
         protected override void PersistDeletedItem(ContentPermissionSet entity)
         {
-            throw new WontImplementException();
+            throw new InvalidOperationException("This method won't be implemented.");
         }
 
         #endregion

src/Umbraco.Core/Persistence/Repositories/Implement/SimpleGetRepository.cs

@@ -75,19 +75,19 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
 
         protected sealed override IEnumerable<string> GetDeleteClauses()
         {
-            throw new WontImplementException();
+            throw new InvalidOperationException("This method won't be implemented.");
         }
 
-        protected sealed override Guid NodeObjectTypeId => throw new WontImplementException();
+        protected sealed override Guid NodeObjectTypeId => throw new InvalidOperationException("This property won't be implemented.");
 
         protected sealed override void PersistNewItem(TEntity entity)
         {
-            throw new WontImplementException();
+            throw new InvalidOperationException("This method won't be implemented.");
         }
 
         protected sealed override void PersistUpdatedItem(TEntity entity)
         {
-            throw new WontImplementException();
+            throw new InvalidOperationException("This method won't be implemented.");
         }
 
         #endregion

src/Umbraco.Core/Persistence/Repositories/Implement/UserGroupRepository.cs

@@ -286,7 +286,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
             return list;
         }
 
-        protected override Guid NodeObjectTypeId => throw new WontImplementException();
+        protected override Guid NodeObjectTypeId => throw new InvalidOperationException("This property won't be implemented.");
 
         protected override void PersistNewItem(IUserGroup entity)
         {
@@ -370,35 +370,35 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
 
             protected override UserGroupWithUsers PerformGet(int id)
             {
-                throw new WontImplementException();
+                throw new InvalidOperationException("This method won't be implemented.");
             }
 
             protected override IEnumerable<UserGroupWithUsers> PerformGetAll(params int[] ids)
             {
-                throw new WontImplementException();
+                throw new InvalidOperationException("This method won't be implemented.");
             }
 
             protected override IEnumerable<UserGroupWithUsers> PerformGetByQuery(IQuery<UserGroupWithUsers> query)
             {
-                throw new WontImplementException();
+                throw new InvalidOperationException("This method won't be implemented.");
             }
 
             protected override Sql<ISqlContext> GetBaseQuery(bool isCount)
             {
-                throw new WontImplementException();
+                throw new InvalidOperationException("This method won't be implemented.");
             }
 
             protected override string GetBaseWhereClause()
             {
-                throw new WontImplementException();
+                throw new InvalidOperationException("This method won't be implemented.");
             }
 
             protected override IEnumerable<string> GetDeleteClauses()
             {
-                throw new WontImplementException();
+                throw new InvalidOperationException("This method won't be implemented.");
             }
 
-            protected override Guid NodeObjectTypeId => throw new WontImplementException();
+            protected override Guid NodeObjectTypeId => throw new InvalidOperationException("This property won't be implemented.");
 
             #endregion
 

src/Umbraco.Core/Persistence/UmbracoDatabaseFactory.cs

@@ -4,7 +4,6 @@ using System.Data.Common;
 using System.Threading;
 using NPoco;
 using NPoco.FluentMappings;
-using Umbraco.Core.Exceptions;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence.FaultHandling;
 using Umbraco.Core.Persistence.Mappers;
@@ -61,8 +60,8 @@ namespace Umbraco.Core.Persistence
         /// <remarks>Used by the other ctor and in tests.</remarks>
         public UmbracoDatabaseFactory(string connectionStringName, ILogger logger, Lazy<IMapperCollection> mappers)
         {
-            if (string.IsNullOrWhiteSpace(connectionStringName))
-                throw new ArgumentNullOrEmptyException(nameof(connectionStringName));
+            if (connectionStringName == null) throw new ArgumentNullException(nameof(connectionStringName));
+            if (string.IsNullOrWhiteSpace(connectionStringName)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(connectionStringName));
 
             _mappers = mappers ?? throw new ArgumentNullException(nameof(mappers));
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));

src/Umbraco.Core/PropertyEditors/ConfigurationFieldAttribute.cs

@@ -1,5 +1,4 @@
 using System;
-using Umbraco.Core.Exceptions;
 
 namespace Umbraco.Core.PropertyEditors
 {
@@ -28,13 +27,15 @@ namespace Umbraco.Core.PropertyEditors
         /// <param name="view">The view to use to render the field editor.</param>
         public ConfigurationFieldAttribute(string key, string name, string view)
         {
-            if (string.IsNullOrWhiteSpace(key)) throw new ArgumentNullOrEmptyException(nameof(key));
+            if (key == null) throw new ArgumentNullException(nameof(key));
+            if (string.IsNullOrWhiteSpace(key)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(key));
+            if (name == null) throw new ArgumentNullException(nameof(name));
+            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(name));
+            if (view == null) throw new ArgumentNullException(nameof(view));
+            if (string.IsNullOrWhiteSpace(view)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(view));
+
             Key = key;
-
-            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentNullOrEmptyException(nameof(name));
             Name = name;
-
-            if (string.IsNullOrWhiteSpace(view)) throw new ArgumentNullOrEmptyException(nameof(view));
             View = view;
         }
 
@@ -47,10 +48,12 @@ namespace Umbraco.Core.PropertyEditors
         /// from the name of the property marked with this attribute.</remarks>
         public ConfigurationFieldAttribute(string name, string view)
         {
-            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentNullOrEmptyException(nameof(name));
-            Name = name;
+            if (name == null) throw new ArgumentNullException(nameof(name));
+            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(name));
+            if (view == null) throw new ArgumentNullException(nameof(view));
+            if (string.IsNullOrWhiteSpace(view)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(view));
 
-            if (string.IsNullOrWhiteSpace(view)) throw new ArgumentNullOrEmptyException(nameof(view));
+            Name = name;
             View = view;
         }
 

src/Umbraco.Core/PropertyEditors/DataEditorAttribute.cs

@@ -1,5 +1,4 @@
 using System;
-using Umbraco.Core.Exceptions;
 
 namespace Umbraco.Core.PropertyEditors
 {
@@ -53,17 +52,17 @@ namespace Umbraco.Core.PropertyEditors
         /// </remarks>
         public DataEditorAttribute(string alias, EditorType type, string name, string view)
         {
-            if ((type & ~(EditorType.PropertyValue | EditorType.MacroParameter)) > 0)
-                throw new ArgumentOutOfRangeException(nameof(type), $"Not a valid {typeof(EditorType)} value.");
+            if (alias == null) throw new ArgumentNullException(nameof(alias));
+            if (string.IsNullOrWhiteSpace(alias)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(alias));
+            if ((type & ~(EditorType.PropertyValue | EditorType.MacroParameter)) > 0) throw new ArgumentOutOfRangeException(nameof(type), type, $"Not a valid {typeof(EditorType)} value.");
+            if (name == null) throw new ArgumentNullException(nameof(name));
+            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(name));
+            if (view == null) throw new ArgumentNullException(nameof(view));
+            if (string.IsNullOrWhiteSpace(view)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(view));
+
             Type = type;
-
-            if (string.IsNullOrWhiteSpace(alias)) throw new ArgumentNullOrEmptyException(nameof(alias));
             Alias = alias;
-
-            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentNullOrEmptyException(nameof(name));
             Name = name;
-
-            if (string.IsNullOrWhiteSpace(view)) throw new ArgumentNullOrEmptyException(nameof(view));
             View = view == NullView ? null : view;
         }
 
@@ -100,8 +99,10 @@ namespace Umbraco.Core.PropertyEditors
             get => _valueType;
             set
             {
-                if (string.IsNullOrWhiteSpace(value)) throw new ArgumentNullOrEmptyException(nameof(value));
-                if (!ValueTypes.IsValue(value)) throw new ArgumentOutOfRangeException(nameof(value), $"Not a valid {typeof(ValueTypes)} value.");
+                if (value == null) throw new ArgumentNullException(nameof(value));
+                if (string.IsNullOrWhiteSpace(value)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(value));
+                if (!ValueTypes.IsValue(value)) throw new ArgumentOutOfRangeException(nameof(value), value, $"Not a valid {typeof(ValueTypes)} value.");
+
                 _valueType = value;
             }
         }

src/Umbraco.Core/PropertyEditors/IDataEditorWithMediaPath.cs

@@ -0,0 +1,19 @@
+namespace Umbraco.Core.PropertyEditors
+{
+    /// <summary>
+    /// Must be implemented by property editors that store media and return media paths
+    /// </summary>
+    /// <remarks>
+    /// Currently there are only 2x core editors that do this: upload and image cropper.
+    /// It would be possible for developers to know implement their own media property editors whereas previously this was not possible.
+    /// </remarks>
+    public interface IDataEditorWithMediaPath
+    {
+        /// <summary>
+        /// Returns the media path for the value stored for a property
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        string GetMediaPath(object value);
+    }
+}

src/Umbraco.Core/PropertyEditors/IValueFormatValidator.cs

@@ -21,4 +21,4 @@ namespace Umbraco.Core.PropertyEditors
         /// </remarks>
         IEnumerable<ValidationResult> ValidateFormat(object value, string valueType, string format);
     }
-}
+}

src/Umbraco.Core/PropertyEditors/IValueRequiredValidator.cs

@@ -19,4 +19,4 @@ namespace Umbraco.Core.PropertyEditors
         /// </remarks>
         IEnumerable<ValidationResult> ValidateRequired(object value, string valueType);
     }
-}
+}

src/Umbraco.Core/PropertyEditors/Validators/RegexValidator.cs

@@ -3,7 +3,6 @@ using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 using System.Text.RegularExpressions;
 using Umbraco.Core.Composing;
-using Umbraco.Core.Exceptions;
 using Umbraco.Core.Services;
 
 namespace Umbraco.Core.PropertyEditors.Validators
@@ -48,8 +47,9 @@ namespace Umbraco.Core.PropertyEditors.Validators
             get => _regex;
             set
             {
-                if (string.IsNullOrWhiteSpace(value))
-                    throw new ArgumentNullOrEmptyException(nameof(value));
+                if (value == null) throw new ArgumentNullException(nameof(value));
+                if (string.IsNullOrWhiteSpace(value)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(value));
+
                 _regex = value;
             }
         }
@@ -58,7 +58,9 @@ namespace Umbraco.Core.PropertyEditors.Validators
         public IEnumerable<ValidationResult> Validate(object value, string valueType, object dataTypeConfiguration)
         {
             if (_regex == null)
+            {
                 throw new InvalidOperationException("The validator has not been configured.");
+            }
 
             return ValidateFormat(value, valueType, _regex);
         }
@@ -66,9 +68,12 @@ namespace Umbraco.Core.PropertyEditors.Validators
         /// <inheritdoc cref="IValueFormatValidator.ValidateFormat"/>
         public IEnumerable<ValidationResult> ValidateFormat(object value, string valueType, string format)
         {
-            if (string.IsNullOrWhiteSpace(format)) throw new ArgumentNullOrEmptyException(nameof(format));
+            if (format == null) throw new ArgumentNullException(nameof(format));
+            if (string.IsNullOrWhiteSpace(format)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(format));
             if (value == null || !new Regex(format).IsMatch(value.ToString()))
+            {
                 yield return new ValidationResult(_textService.Localize("validation", "invalidPattern"), new[] { "value" });
+            }
         }
     }
 }

src/Umbraco.Core/PropertyEditors/Validators/RequiredValidator.cs

@@ -35,14 +35,17 @@ namespace Umbraco.Core.PropertyEditors.Validators
         {
             if (value == null)
             {
-                yield return new ValidationResult(_textService.Localize("validation", "invalidNull"), new[] {"value"});
+                yield return new ValidationResult(_textService.Localize("validation", "invalidNull"), new[] { "value" });
                 yield break;
             }
 
             if (valueType.InvariantEquals(ValueTypes.Json))
             {
                 if (value.ToString().DetectIsEmptyJson())
+                {
                     yield return new ValidationResult(_textService.Localize("validation", "invalidEmpty"), new[] { "value" });
+                }
+
                 yield break;
             }
 

src/Umbraco.Core/ReflectionUtilities.cs

@@ -3,7 +3,6 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Reflection.Emit;
-using Umbraco.Core.Exceptions;
 
 namespace Umbraco.Core
 {
@@ -29,10 +28,14 @@ namespace Umbraco.Core
         /// <typeparam name="TDeclaring">The declaring type.</typeparam>
         /// <typeparam name="TValue">The field type.</typeparam>
         /// <param name="fieldName">The name of the field.</param>
-        /// <returns>A field getter function.</returns>
-        /// <exception cref="ArgumentNullOrEmptyException">Occurs when <paramref name="fieldName"/> is null or empty.</exception>
-        /// <exception cref="InvalidOperationException">Occurs when the field does not exist.</exception>
-        /// <exception cref="ArgumentException">Occurs when <typeparamref name="TValue"/> does not match the type of the field.</exception>
+        /// <returns>
+        /// A field getter function.
+        /// </returns>
+        /// <exception cref="ArgumentNullException">fieldName</exception>
+        /// <exception cref="ArgumentException">Value can't be empty or consist only of white-space characters. - <paramref name="fieldName" />
+        /// or
+        /// Value type <typeparamref name="TValue" /> does not match field <typeparamref name="TDeclaring" />.<paramref name="fieldName" /> type.</exception>
+        /// <exception cref="InvalidOperationException">Could not find field <typeparamref name="TDeclaring" />.<paramref name="fieldName" />.</exception>
         public static Func<TDeclaring, TValue> EmitFieldGetter<TDeclaring, TValue>(string fieldName)
         {
             var field = GetField<TDeclaring, TValue>(fieldName);
@@ -45,10 +48,14 @@ namespace Umbraco.Core
         /// <typeparam name="TDeclaring">The declaring type.</typeparam>
         /// <typeparam name="TValue">The field type.</typeparam>
         /// <param name="fieldName">The name of the field.</param>
-        /// <returns>A field setter action.</returns>
-        /// <exception cref="ArgumentNullOrEmptyException">Occurs when <paramref name="fieldName"/> is null or empty.</exception>
-        /// <exception cref="InvalidOperationException">Occurs when the field does not exist.</exception>
-        /// <exception cref="ArgumentException">Occurs when <typeparamref name="TValue"/> does not match the type of the field.</exception>
+        /// <returns>
+        /// A field setter action.
+        /// </returns>
+        /// <exception cref="ArgumentNullException">fieldName</exception>
+        /// <exception cref="ArgumentException">Value can't be empty or consist only of white-space characters. - <paramref name="fieldName" />
+        /// or
+        /// Value type <typeparamref name="TValue" /> does not match field <typeparamref name="TDeclaring" />.<paramref name="fieldName" /> type.</exception>
+        /// <exception cref="InvalidOperationException">Could not find field <typeparamref name="TDeclaring" />.<paramref name="fieldName" />.</exception>
         public static Action<TDeclaring, TValue> EmitFieldSetter<TDeclaring, TValue>(string fieldName)
         {
             var field = GetField<TDeclaring, TValue>(fieldName);
@@ -61,19 +68,36 @@ namespace Umbraco.Core
         /// <typeparam name="TDeclaring">The declaring type.</typeparam>
         /// <typeparam name="TValue">The field type.</typeparam>
         /// <param name="fieldName">The name of the field.</param>
-        /// <returns>A field getter and setter functions.</returns>
-        /// <exception cref="ArgumentNullOrEmptyException">Occurs when <paramref name="fieldName"/> is null or empty.</exception>
-        /// <exception cref="InvalidOperationException">Occurs when the field does not exist.</exception>
-        /// <exception cref="ArgumentException">Occurs when <typeparamref name="TValue"/> does not match the type of the field.</exception>
+        /// <returns>
+        /// A field getter and setter functions.
+        /// </returns>
+        /// <exception cref="ArgumentNullException">fieldName</exception>
+        /// <exception cref="ArgumentException">Value can't be empty or consist only of white-space characters. - <paramref name="fieldName" />
+        /// or
+        /// Value type <typeparamref name="TValue" /> does not match field <typeparamref name="TDeclaring" />.<paramref name="fieldName" /> type.</exception>
+        /// <exception cref="InvalidOperationException">Could not find field <typeparamref name="TDeclaring" />.<paramref name="fieldName" />.</exception>
         public static (Func<TDeclaring, TValue>, Action<TDeclaring, TValue>) EmitFieldGetterAndSetter<TDeclaring, TValue>(string fieldName)
         {
             var field = GetField<TDeclaring, TValue>(fieldName);
             return (EmitFieldGetter<TDeclaring, TValue>(field), EmitFieldSetter<TDeclaring, TValue>(field));
         }
 
+        /// <summary>
+        /// Gets the field.
+        /// </summary>
+        /// <typeparam name="TDeclaring">The type of the declaring.</typeparam>
+        /// <typeparam name="TValue">The type of the value.</typeparam>
+        /// <param name="fieldName">Name of the field.</param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentNullException">fieldName</exception>
+        /// <exception cref="ArgumentException">Value can't be empty or consist only of white-space characters. - <paramref name="fieldName" />
+        /// or
+        /// Value type <typeparamref name="TValue" /> does not match field <typeparamref name="TDeclaring" />.<paramref name="fieldName" /> type.</exception>
+        /// <exception cref="InvalidOperationException">Could not find field <typeparamref name="TDeclaring" />.<paramref name="fieldName" />.</exception>
         private static FieldInfo GetField<TDeclaring, TValue>(string fieldName)
         {
-            if (string.IsNullOrWhiteSpace(fieldName)) throw new ArgumentNullOrEmptyException(nameof(fieldName));
+            if (fieldName == null) throw new ArgumentNullException(nameof(fieldName));
+            if (string.IsNullOrWhiteSpace(fieldName)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(fieldName));
 
             // get the field
             var field = typeof(TDeclaring).GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
@@ -120,13 +144,18 @@ namespace Umbraco.Core
         /// <typeparam name="TValue">The property type.</typeparam>
         /// <param name="propertyName">The name of the property.</param>
         /// <param name="mustExist">A value indicating whether the property and its getter must exist.</param>
-        /// <returns>A property getter function. If <paramref name="mustExist"/> is <c>false</c>, returns null when the property or its getter does not exist.</returns>
-        /// <exception cref="ArgumentNullOrEmptyException">Occurs when <paramref name="propertyName"/> is null or empty.</exception>
-        /// <exception cref="InvalidOperationException">Occurs when the property or its getter does not exist.</exception>
-        /// <exception cref="ArgumentException">Occurs when <typeparamref name="TValue"/> does not match the type of the property.</exception>
+        /// <returns>
+        /// A property getter function. If <paramref name="mustExist" /> is <c>false</c>, returns null when the property or its getter does not exist.
+        /// </returns>
+        /// <exception cref="ArgumentNullException">propertyName</exception>
+        /// <exception cref="ArgumentException">Value can't be empty or consist only of white-space characters. - <paramref name="propertyName" />
+        /// or
+        /// Value type <typeparamref name="TValue" /> does not match property <typeparamref name="TDeclaring" />.<paramref name="propertyName" /> type.</exception>
+        /// <exception cref="InvalidOperationException">Could not find property getter for <typeparamref name="TDeclaring" />.<paramref name="propertyName" />.</exception>
         public static Func<TDeclaring, TValue> EmitPropertyGetter<TDeclaring, TValue>(string propertyName, bool mustExist = true)
         {
-            if (string.IsNullOrWhiteSpace(propertyName)) throw new ArgumentNullOrEmptyException(nameof(propertyName));
+            if (propertyName == null) throw new ArgumentNullException(nameof(propertyName));
+            if (string.IsNullOrWhiteSpace(propertyName)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(propertyName));
 
             var property = typeof(TDeclaring).GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
 
@@ -146,13 +175,18 @@ namespace Umbraco.Core
         /// <typeparam name="TValue">The property type.</typeparam>
         /// <param name="propertyName">The name of the property.</param>
         /// <param name="mustExist">A value indicating whether the property and its setter must exist.</param>
-        /// <returns>A property setter function. If <paramref name="mustExist"/> is <c>false</c>, returns null when the property or its setter does not exist.</returns>
-        /// <exception cref="ArgumentNullOrEmptyException">Occurs when <paramref name="propertyName"/> is null or empty.</exception>
-        /// <exception cref="InvalidOperationException">Occurs when the property or its setter does not exist.</exception>
-        /// <exception cref="ArgumentException">Occurs when <typeparamref name="TValue"/> does not match the type of the property.</exception>
+        /// <returns>
+        /// A property setter function. If <paramref name="mustExist" /> is <c>false</c>, returns null when the property or its setter does not exist.
+        /// </returns>
+        /// <exception cref="ArgumentNullException">propertyName</exception>
+        /// <exception cref="ArgumentException">Value can't be empty or consist only of white-space characters. - <paramref name="propertyName" />
+        /// or
+        /// Value type <typeparamref name="TValue" /> does not match property <typeparamref name="TDeclaring" />.<paramref name="propertyName" /> type.</exception>
+        /// <exception cref="InvalidOperationException">Could not find property setter for <typeparamref name="TDeclaring" />.<paramref name="propertyName" />.</exception>
         public static Action<TDeclaring, TValue> EmitPropertySetter<TDeclaring, TValue>(string propertyName, bool mustExist = true)
         {
-            if (string.IsNullOrWhiteSpace(propertyName)) throw new ArgumentNullOrEmptyException(nameof(propertyName));
+            if (propertyName == null) throw new ArgumentNullException(nameof(propertyName));
+            if (string.IsNullOrWhiteSpace(propertyName)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(propertyName));
 
             var property = typeof(TDeclaring).GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
 
@@ -172,13 +206,18 @@ namespace Umbraco.Core
         /// <typeparam name="TValue">The property type.</typeparam>
         /// <param name="propertyName">The name of the property.</param>
         /// <param name="mustExist">A value indicating whether the property and its getter and setter must exist.</param>
-        /// <returns>A property getter and setter functions. If <paramref name="mustExist"/> is <c>false</c>, returns null when the property or its getter or setter does not exist.</returns>
-        /// <exception cref="ArgumentNullOrEmptyException">Occurs when <paramref name="propertyName"/> is null or empty.</exception>
-        /// <exception cref="InvalidOperationException">Occurs when the property or its getter or setter does not exist.</exception>
-        /// <exception cref="ArgumentException">Occurs when <typeparamref name="TValue"/> does not match the type of the property.</exception>
+        /// <returns>
+        /// A property getter and setter functions. If <paramref name="mustExist" /> is <c>false</c>, returns null when the property or its getter or setter does not exist.
+        /// </returns>
+        /// <exception cref="ArgumentNullException">propertyName</exception>
+        /// <exception cref="ArgumentException">Value can't be empty or consist only of white-space characters. - <paramref name="propertyName" />
+        /// or
+        /// Value type <typeparamref name="TValue" /> does not match property <typeparamref name="TDeclaring" />.<paramref name="propertyName" /> type.</exception>
+        /// <exception cref="InvalidOperationException">Could not find property getter and setter for <typeparamref name="TDeclaring" />.<paramref name="propertyName" />.</exception>
         public static (Func<TDeclaring, TValue>, Action<TDeclaring, TValue>) EmitPropertyGetterAndSetter<TDeclaring, TValue>(string propertyName, bool mustExist = true)
         {
-            if (string.IsNullOrWhiteSpace(propertyName)) throw new ArgumentNullOrEmptyException(nameof(propertyName));
+            if (propertyName == null) throw new ArgumentNullException(nameof(propertyName));
+            if (string.IsNullOrWhiteSpace(propertyName)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(propertyName));
 
             var property = typeof(TDeclaring).GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
 
@@ -402,13 +441,17 @@ namespace Umbraco.Core
         /// <typeparam name="TLambda">A lambda representing the method.</typeparam>
         /// <param name="methodName">The name of the method.</param>
         /// <param name="mustExist">A value indicating whether the constructor must exist.</param>
-        /// <returns>The method. If <paramref name="mustExist"/> is <c>false</c>, returns null when the method does not exist.</returns>
+        /// <returns>
+        /// The method. If <paramref name="mustExist" /> is <c>false</c>, returns null when the method does not exist.
+        /// </returns>
+        /// <exception cref="ArgumentNullException">methodName</exception>
+        /// <exception cref="ArgumentException">Value can't be empty or consist only of white-space characters. - <paramref name="methodName" />
+        /// or
+        /// Occurs when <typeparamref name="TLambda" /> does not match the method signature..</exception>
+        /// <exception cref="InvalidOperationException">Occurs when no proper method with name <paramref name="methodName" /> could be found.</exception>
         /// <remarks>
-        /// <para>The method arguments are determined by <typeparamref name="TLambda"/> generic arguments.</para>
+        /// The method arguments are determined by <typeparamref name="TLambda" /> generic arguments.
         /// </remarks>
-        /// <exception cref="ArgumentNullOrEmptyException">Occurs when <paramref name="methodName"/> is null or empty.</exception>
-        /// <exception cref="InvalidOperationException">Occurs when no proper method with name <paramref name="methodName"/> could be found.</exception>
-        /// <exception cref="ArgumentException">Occurs when Occurs when <typeparamref name="TLambda"/> does not match the method signature.</exception>
         public static TLambda EmitMethod<TDeclaring, TLambda>(string methodName, bool mustExist = true)
         {
             return EmitMethod<TLambda>(typeof(TDeclaring), methodName, mustExist);
@@ -421,16 +464,21 @@ namespace Umbraco.Core
         /// <param name="declaring">The declaring type.</param>
         /// <param name="methodName">The name of the method.</param>
         /// <param name="mustExist">A value indicating whether the constructor must exist.</param>
-        /// <returns>The method. If <paramref name="mustExist"/> is <c>false</c>, returns null when the method does not exist.</returns>
+        /// <returns>
+        /// The method. If <paramref name="mustExist" /> is <c>false</c>, returns null when the method does not exist.
+        /// </returns>
+        /// <exception cref="ArgumentNullException">methodName</exception>
+        /// <exception cref="ArgumentException">Value can't be empty or consist only of white-space characters. - <paramref name="methodName" />
+        /// or
+        /// Occurs when <typeparamref name="TLambda" /> does not match the method signature..</exception>
+        /// <exception cref="InvalidOperationException">Occurs when no proper method with name <paramref name="methodName" /> could be found.</exception>
         /// <remarks>
-        /// <para>The method arguments are determined by <typeparamref name="TLambda"/> generic arguments.</para>
+        /// The method arguments are determined by <typeparamref name="TLambda" /> generic arguments.
         /// </remarks>
-        /// <exception cref="ArgumentNullOrEmptyException">Occurs when <paramref name="methodName"/> is null or empty.</exception>
-        /// <exception cref="InvalidOperationException">Occurs when no proper method with name <paramref name="methodName"/> could be found.</exception>
-        /// <exception cref="ArgumentException">Occurs when Occurs when <typeparamref name="TLambda"/> does not match the method signature.</exception>
         public static TLambda EmitMethod<TLambda>(Type declaring, string methodName, bool mustExist = true)
         {
-            if (string.IsNullOrWhiteSpace(methodName)) throw new ArgumentNullOrEmptyException(nameof(methodName));
+            if (methodName == null) throw new ArgumentNullException(nameof(methodName));
+            if (string.IsNullOrWhiteSpace(methodName)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(methodName));
 
             var (lambdaDeclaring, lambdaParameters, lambdaReturned) = AnalyzeLambda<TLambda>(true, out var isFunction);
 
@@ -510,17 +558,21 @@ namespace Umbraco.Core
         /// <typeparam name="TLambda">A lambda representing the method.</typeparam>
         /// <param name="methodName">The name of the method.</param>
         /// <param name="mustExist">A value indicating whether the constructor must exist.</param>
-        /// <returns>The method. If <paramref name="mustExist"/> is <c>false</c>, returns null when the method does not exist.</returns>
+        /// <returns>
+        /// The method. If <paramref name="mustExist" /> is <c>false</c>, returns null when the method does not exist.
+        /// </returns>
+        /// <exception cref="ArgumentNullException">methodName</exception>
+        /// <exception cref="ArgumentException">Value can't be empty or consist only of white-space characters. - <paramref name="methodName" />
+        /// or
+        /// Occurs when <typeparamref name="TLambda" /> does not match the method signature..</exception>
+        /// <exception cref="InvalidOperationException">Occurs when no proper method with name <paramref name="methodName" /> could be found.</exception>
         /// <remarks>
-        /// <para>The method arguments are determined by <typeparamref name="TLambda"/> generic arguments.</para>
+        /// The method arguments are determined by <typeparamref name="TLambda" /> generic arguments.
         /// </remarks>
-        /// <exception cref="ArgumentNullOrEmptyException">Occurs when <paramref name="methodName"/> is null or empty.</exception>
-        /// <exception cref="InvalidOperationException">Occurs when no proper method with name <paramref name="methodName"/> could be found.</exception>
-        /// <exception cref="ArgumentException">Occurs when Occurs when <typeparamref name="TLambda"/> does not match the method signature.</exception>
         public static TLambda EmitMethod<TLambda>(string methodName, bool mustExist = true)
         {
-            if (string.IsNullOrWhiteSpace(methodName))
-                throw new ArgumentNullOrEmptyException(nameof(methodName));
+            if (methodName == null) throw new ArgumentNullException(nameof(methodName));
+            if (string.IsNullOrWhiteSpace(methodName)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(methodName));
 
             // validate lambda type
             var (lambdaDeclaring, lambdaParameters, lambdaReturned) = AnalyzeLambda<TLambda>(false, out var isFunction);

src/Umbraco.Core/Runtime/CoreRuntime.cs

@@ -27,6 +27,17 @@ namespace Umbraco.Core.Runtime
         private IFactory _factory;
         private RuntimeState _state;
 
+        [Obsolete("Use the ctor with all parameters instead")]
+        public CoreRuntime()
+        {
+        }
+
+        public CoreRuntime(ILogger logger, IMainDom mainDom)
+        {
+            MainDom = mainDom;
+            Logger = logger;
+        }
+
         /// <summary>
         /// Gets the logger.
         /// </summary>
@@ -45,14 +56,22 @@ namespace Umbraco.Core.Runtime
         /// <inheritdoc />
         public IRuntimeState State => _state;
 
+        public IMainDom MainDom { get; private set; }
+
         /// <inheritdoc/>
         public virtual IFactory Boot(IRegister register)
         {
             // create and register the essential services
             // ie the bare minimum required to boot
 
+#pragma warning disable CS0618 // Type or member is obsolete
             // loggers
-            var logger = Logger = GetLogger();
+            // TODO: Removes this in netcore, this is purely just backwards compat ugliness
+            var logger = GetLogger();
+            if (logger != Logger)
+                Logger = logger;
+#pragma warning restore CS0618 // Type or member is obsolete
+
             var profiler = Profiler = GetProfiler();
             var profilingLogger = ProfilingLogger = new ProfilingLogger(logger, profiler);
 
@@ -125,12 +144,16 @@ namespace Umbraco.Core.Runtime
                     Level = RuntimeLevel.Boot
                 };
 
-                // main dom
-                var mainDom = new MainDom(Logger);
+                // TODO: remove this in netcore, this is purely backwards compat hacks with the empty ctor
+                if (MainDom == null)
+                {
+                    MainDom = new MainDom(Logger);
+                }
+                
 
                 // create the composition
                 composition = new Composition(register, typeLoader, ProfilingLogger, _state, configs);
-                composition.RegisterEssentials(Logger, Profiler, ProfilingLogger, mainDom, appCaches, databaseFactory, typeLoader, _state);
+                composition.RegisterEssentials(Logger, Profiler, ProfilingLogger, MainDom, appCaches, databaseFactory, typeLoader, _state);
 
                 // run handlers
                 RuntimeOptions.DoRuntimeEssentials(composition, appCaches, typeLoader, databaseFactory);
@@ -140,15 +163,21 @@ namespace Umbraco.Core.Runtime
                 Compose(composition);
 
                 // acquire the main domain - if this fails then anything that should be registered with MainDom will not operate
-                AcquireMainDom(mainDom);
+                AcquireMainDom(MainDom);
 
                 // determine our runtime level
                 DetermineRuntimeLevel(databaseFactory, ProfilingLogger);
 
                 // get composers, and compose
                 var composerTypes = ResolveComposerTypes(typeLoader);
-                composition.WithCollectionBuilder<ComponentCollectionBuilder>();
-                var composers = new Composers(composition, composerTypes, ProfilingLogger);
+
+                IEnumerable<Attribute> enableDisableAttributes;
+                using (ProfilingLogger.DebugDuration<CoreRuntime>("Scanning enable/disable composer attributes"))
+                {
+                    enableDisableAttributes = typeLoader.GetAssemblyAttributes(typeof(EnableComposerAttribute), typeof(DisableComposerAttribute));
+                }   
+
+                var composers = new Composers(composition, composerTypes, enableDisableAttributes, ProfilingLogger);
                 composers.Compose();
 
                 // create the factory
@@ -157,6 +186,8 @@ namespace Umbraco.Core.Runtime
                 // create & initialize the components
                 _components = _factory.GetInstance<ComponentCollection>();
                 _components.Initialize();
+
+
             }
             catch (Exception e)
             {
@@ -218,13 +249,13 @@ namespace Umbraco.Core.Runtime
                 IOHelper.SetRootDirectory(path);
         }
 
-        private bool AcquireMainDom(MainDom mainDom)
+        private bool AcquireMainDom(IMainDom mainDom)
         {
             using (var timer = ProfilingLogger.DebugDuration<CoreRuntime>("Acquiring MainDom.", "Acquired."))
             {
                 try
                 {
-                    return mainDom.Acquire();
+                    return mainDom.IsMainDom;
                 }
                 catch
                 {
@@ -301,11 +332,9 @@ namespace Umbraco.Core.Runtime
         protected virtual IEnumerable<Type> GetComposerTypes(TypeLoader typeLoader)
             => typeLoader.GetTypes<IComposer>();
 
-        /// <summary>
-        /// Gets a logger.
-        /// </summary>
+        [Obsolete("Don't use this method, the logger should be injected into the " + nameof(CoreRuntime))]
         protected virtual ILogger GetLogger()
-            => SerilogLogger.CreateWithDefaultConfiguration();
+            => Logger ?? SerilogLogger.CreateWithDefaultConfiguration(); // TODO: Remove this in netcore, this purely just backwards compat ugliness
 
         /// <summary>
         /// Gets a profiler.

src/Umbraco.Core/RuntimeState.cs

@@ -1,8 +1,8 @@
 using System;
-using System.Collections.Generic;
 using System.Threading;
 using System.Web;
 using Semver;
+using Umbraco.Core.Collections;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.Exceptions;
@@ -22,7 +22,7 @@ namespace Umbraco.Core
         private readonly ILogger _logger;
         private readonly IUmbracoSettingsSection _settings;
         private readonly IGlobalSettings _globalSettings;
-        private readonly HashSet<string> _applicationUrls = new HashSet<string>();
+        private readonly ConcurrentHashSet<string> _applicationUrls = new ConcurrentHashSet<string>();
         private readonly Lazy<IMainDom> _mainDom;
         private readonly Lazy<IServerRegistrar> _serverRegistrar;
 

src/Umbraco.Core/Security/BackOfficeUserStore.cs

@@ -6,7 +6,6 @@ using System.Threading.Tasks;
 using System.Web.Security;
 using Microsoft.AspNet.Identity;
 using Umbraco.Core.Configuration;
-using Umbraco.Core.Exceptions;
 using Umbraco.Core.Mapping;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.Identity;
@@ -217,7 +216,8 @@ namespace Umbraco.Core.Security
         {
             ThrowIfDisposed();
             if (user == null) throw new ArgumentNullException(nameof(user));
-            if (string.IsNullOrEmpty(passwordHash)) throw new ArgumentNullOrEmptyException(nameof(passwordHash));
+            if (passwordHash == null) throw new ArgumentNullException(nameof(passwordHash));
+            if (string.IsNullOrEmpty(passwordHash)) throw new ArgumentException("Value can't be empty.", nameof(passwordHash));
 
             user.PasswordHash = passwordHash;
 
@@ -329,7 +329,7 @@ namespace Umbraco.Core.Security
         {
             ThrowIfDisposed();
             if (user == null) throw new ArgumentNullException(nameof(user));
-            if (login == null) throw new ArgumentNullException("login");
+            if (login == null) throw new ArgumentNullException(nameof(login));
 
             var logins = user.Logins;
             var instance = new IdentityUserLogin(login.LoginProvider, login.ProviderKey, user.Id);
@@ -348,7 +348,7 @@ namespace Umbraco.Core.Security
         {
             ThrowIfDisposed();
             if (user == null) throw new ArgumentNullException(nameof(user));
-            if (login == null) throw new ArgumentNullException("login");
+            if (login == null) throw new ArgumentNullException(nameof(login));
 
             var provider = login.LoginProvider;
             var key = login.ProviderKey;
@@ -379,7 +379,7 @@ namespace Umbraco.Core.Security
         public Task<BackOfficeIdentityUser> FindAsync(UserLoginInfo login)
         {
             ThrowIfDisposed();
-            if (login == null) throw new ArgumentNullException("login");
+            if (login == null) throw new ArgumentNullException(nameof(login));
 
             //get all logins associated with the login id
             var result = _externalLoginService.Find(login).ToArray();
@@ -413,7 +413,8 @@ namespace Umbraco.Core.Security
         {
             ThrowIfDisposed();
             if (user == null) throw new ArgumentNullException(nameof(user));
-            if (string.IsNullOrWhiteSpace(roleName)) throw new ArgumentException("Value cannot be null or whitespace.", "roleName");
+            if (roleName == null) throw new ArgumentNullException(nameof(roleName));
+            if (string.IsNullOrWhiteSpace(roleName)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(roleName));
 
             var userRole = user.Roles.SingleOrDefault(r => r.RoleId == roleName);
 
@@ -434,7 +435,8 @@ namespace Umbraco.Core.Security
         {
             ThrowIfDisposed();
             if (user == null) throw new ArgumentNullException(nameof(user));
-            if (string.IsNullOrWhiteSpace(roleName)) throw new ArgumentException("Value cannot be null or whitespace.", "roleName");
+            if (roleName == null) throw new ArgumentNullException(nameof(roleName));
+            if (string.IsNullOrWhiteSpace(roleName)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(roleName));
 
             var userRole = user.Roles.SingleOrDefault(r => r.RoleId == roleName);
 

src/Umbraco.Core/Services/Implement/ContentService.cs

@@ -2885,7 +2885,8 @@ namespace Umbraco.Core.Services.Implement
 
         private IContentType GetContentType(IScope scope, string contentTypeAlias)
         {
-            if (string.IsNullOrWhiteSpace(contentTypeAlias)) throw new ArgumentNullOrEmptyException(nameof(contentTypeAlias));
+            if (contentTypeAlias == null) throw new ArgumentNullException(nameof(contentTypeAlias));
+            if (string.IsNullOrWhiteSpace(contentTypeAlias)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(contentTypeAlias));
 
             scope.ReadLock(Constants.Locks.ContentTypes);
 
@@ -2900,7 +2901,8 @@ namespace Umbraco.Core.Services.Implement
 
         private IContentType GetContentType(string contentTypeAlias)
         {
-            if (string.IsNullOrWhiteSpace(contentTypeAlias)) throw new ArgumentNullOrEmptyException(nameof(contentTypeAlias));
+            if (contentTypeAlias == null) throw new ArgumentNullException(nameof(contentTypeAlias));
+            if (string.IsNullOrWhiteSpace(contentTypeAlias)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(contentTypeAlias));
 
             using (var scope = ScopeProvider.CreateScope(autoComplete: true))
             {
@@ -3083,7 +3085,7 @@ namespace Umbraco.Core.Services.Implement
             var version = GetVersion(versionId);
 
             //Good ole null checks
-            if (content == null || version == null)
+            if (content == null || version == null || content.Trashed)
             {
                 return new OperationResult(OperationResultType.FailedCannot, evtMsgs);
             }

src/Umbraco.Core/Services/Implement/ContentTypeServiceBaseOfTRepositoryTItemTService.cs

@@ -595,10 +595,9 @@ namespace Umbraco.Core.Services.Implement
         public TItem Copy(TItem original, string alias, string name, TItem parent)
         {
             if (original == null) throw new ArgumentNullException(nameof(original));
-            if (string.IsNullOrWhiteSpace(alias)) throw new ArgumentNullOrEmptyException(nameof(alias));
-
-            if (parent != null && parent.HasIdentity == false)
-                throw new InvalidOperationException("Parent must have an identity.");
+            if (alias == null) throw new ArgumentNullException(nameof(alias));
+            if (string.IsNullOrWhiteSpace(alias)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(alias));
+            if (parent != null && parent.HasIdentity == false) throw new InvalidOperationException("Parent must have an identity.");
 
             // this is illegal
             //var originalb = (ContentTypeCompositionBase)original;

src/Umbraco.Core/Services/Implement/EntityXmlSerializer.cs

@@ -360,7 +360,9 @@ namespace Umbraco.Core.Services.Implement
                                                    new XElement("Definition", definition.Key),
                                                    new XElement("Tab", propertyGroup == null ? "" : propertyGroup.Name),
                                                    new XElement("Mandatory", propertyType.Mandatory.ToString()),
+                                                   new XElement("MandatoryMessage", propertyType.MandatoryMessage),
                                                    new XElement("Validation", propertyType.ValidationRegExp),
+                                                   new XElement("ValidationRegExpMessage", propertyType.ValidationRegExpMessage),
                                                    new XElement("Description", new XCData(propertyType.Description)));
                 genericProperties.Add(genericProperty);
             }
@@ -487,7 +489,9 @@ namespace Umbraco.Core.Services.Implement
                                                    new XElement("Tab", propertyGroup == null ? "" : propertyGroup.Name),
                                                    new XElement("SortOrder", propertyType.SortOrder),
                                                    new XElement("Mandatory", propertyType.Mandatory.ToString()),
+                                                   propertyType.MandatoryMessage != null ? new XElement("MandatoryMessage", propertyType.MandatoryMessage) : null,
                                                    propertyType.ValidationRegExp != null ? new XElement("Validation", propertyType.ValidationRegExp) : null,
+                                                   propertyType.ValidationRegExpMessage != null ? new XElement("ValidationRegExpMessage", propertyType.ValidationRegExpMessage) : null,
                                                    propertyType.Description != null ? new XElement("Description", new XCData(propertyType.Description)) : null,
                                                    new XElement("Variations", propertyType.Variations.ToString()));
 

src/Umbraco.Core/Services/Implement/MediaService.cs

@@ -5,7 +5,6 @@ using System.Globalization;
 using System.IO;
 using System.Linq;
 using Umbraco.Core.Events;
-using Umbraco.Core.Exceptions;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
@@ -1340,7 +1339,8 @@ namespace Umbraco.Core.Services.Implement
 
         private IMediaType GetMediaType(string mediaTypeAlias)
         {
-            if (string.IsNullOrWhiteSpace(mediaTypeAlias)) throw new ArgumentNullOrEmptyException(nameof(mediaTypeAlias));
+            if (mediaTypeAlias == null) throw new ArgumentNullException(nameof(mediaTypeAlias));
+            if (string.IsNullOrWhiteSpace(mediaTypeAlias)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(mediaTypeAlias));
 
             using (var scope = ScopeProvider.CreateScope())
             {
@@ -1350,7 +1350,7 @@ namespace Umbraco.Core.Services.Implement
                 var mediaType = _mediaTypeRepository.Get(query).FirstOrDefault();
 
                 if (mediaType == null)
-                    throw new Exception($"No MediaType matching the passed in Alias: '{mediaTypeAlias}' was found"); // causes rollback // causes rollback
+                    throw new InvalidOperationException($"No media type matched the specified alias '{mediaTypeAlias}'.");
 
                 scope.Complete();
                 return mediaType;

src/Umbraco.Core/Services/Implement/MemberService.cs

@@ -1344,7 +1344,8 @@ namespace Umbraco.Core.Services.Implement
 
         private IMemberType GetMemberType(IScope scope, string memberTypeAlias)
         {
-            if (string.IsNullOrWhiteSpace(memberTypeAlias)) throw new ArgumentNullOrEmptyException(nameof(memberTypeAlias));
+            if (memberTypeAlias == null) throw new ArgumentNullException(nameof(memberTypeAlias));
+            if (string.IsNullOrWhiteSpace(memberTypeAlias)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(memberTypeAlias));
 
             scope.ReadLock(Constants.Locks.MemberTypes);
 
@@ -1358,7 +1359,8 @@ namespace Umbraco.Core.Services.Implement
 
         private IMemberType GetMemberType(string memberTypeAlias)
         {
-            if (string.IsNullOrWhiteSpace(memberTypeAlias)) throw new ArgumentNullOrEmptyException(nameof(memberTypeAlias));
+            if (memberTypeAlias == null) throw new ArgumentNullException(nameof(memberTypeAlias));
+            if (string.IsNullOrWhiteSpace(memberTypeAlias)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(memberTypeAlias));
 
             using (var scope = ScopeProvider.CreateScope(autoComplete: true))
             {

src/Umbraco.Core/Services/Implement/PackagingService.cs

@@ -57,7 +57,7 @@ namespace Umbraco.Core.Services.Implement
             }
             catch (HttpRequestException ex)
             {
-                throw new ConnectionException("An error occurring downloading the package from " + url, ex);
+                throw new HttpRequestException("An error occurring downloading the package from " + url, ex);
             }
 
             //successful

src/Umbraco.Core/Services/Implement/UserService.cs

@@ -1,15 +1,11 @@
 using System;
 using System.Collections.Generic;
-using System.ComponentModel;
 using System.Data.Common;
-using System.Data.SqlClient;
-using System.Data.SqlServerCe;
 using System.Globalization;
 using System.Linq;
 using System.Linq.Expressions;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Events;
-using Umbraco.Core.Exceptions;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models.Membership;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
@@ -17,7 +13,6 @@ using Umbraco.Core.Persistence.Querying;
 using Umbraco.Core.Persistence.Repositories;
 using Umbraco.Core.Persistence.Repositories.Implement;
 using Umbraco.Core.Scoping;
-using Umbraco.Core.Security; 
 
 namespace Umbraco.Core.Services.Implement
 {
@@ -107,7 +102,8 @@ namespace Umbraco.Core.Services.Implement
         /// <returns><see cref="IUser"/></returns>
         private IUser CreateUserWithIdentity(string username, string email, string passwordValue, bool isApproved = true)
         {
-            if (string.IsNullOrWhiteSpace(username)) throw new ArgumentNullOrEmptyException(nameof(username));
+            if (username == null) throw new ArgumentNullException(nameof(username));
+            if (string.IsNullOrWhiteSpace(username)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(username));
 
             // TODO: PUT lock here!!
 

src/Umbraco.Core/StringExtensions.cs

@@ -10,9 +10,7 @@ using System.Text;
 using System.Text.RegularExpressions;
 using System.Web.Security;
 using Newtonsoft.Json;
-using Umbraco.Core.Configuration;
 using Umbraco.Core.Composing;
-using Umbraco.Core.Exceptions;
 using Umbraco.Core.IO;
 using Umbraco.Core.Strings;
 
@@ -1091,7 +1089,8 @@ namespace Umbraco.Core
         /// <returns>The safe url segment.</returns>
         public static string ToUrlSegment(this string text)
         {
-            if (string.IsNullOrWhiteSpace(text)) throw new ArgumentNullOrEmptyException(nameof(text));
+            if (text == null) throw new ArgumentNullException(nameof(text));
+            if (string.IsNullOrWhiteSpace(text)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(text));
 
             return Current.ShortStringHelper.CleanStringForUrlSegment(text);
         }
@@ -1104,7 +1103,8 @@ namespace Umbraco.Core
         /// <returns>The safe url segment.</returns>
         public static string ToUrlSegment(this string text, string culture)
         {
-            if (string.IsNullOrWhiteSpace(text)) throw new ArgumentNullOrEmptyException(nameof(text));
+            if (text == null) throw new ArgumentNullException(nameof(text));
+            if (string.IsNullOrWhiteSpace(text)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(text));
 
             return Current.ShortStringHelper.CleanStringForUrlSegment(text, culture);
         }

src/Umbraco.Core/SystemLock.cs

@@ -21,18 +21,18 @@ namespace Umbraco.Core
     // been closed, the Semaphore system object is destroyed - so in any case
     // an iisreset should clean up everything
     //
-    internal class AsyncLock
+    internal class SystemLock
     {
         private readonly SemaphoreSlim _semaphore;
         private readonly Semaphore _semaphore2;
         private readonly IDisposable _releaser;
         private readonly Task<IDisposable> _releaserTask;
 
-        public AsyncLock()
-            : this (null)
+        public SystemLock()
+            : this(null)
         { }
 
-        public AsyncLock(string name)
+        public SystemLock(string name)
         {
             // WaitOne() waits until count > 0 then decrements count
             // Release() increments count
@@ -67,35 +67,6 @@ namespace Umbraco.Core
                 : new NamedSemaphoreReleaser(_semaphore2);
         }
 
-        //NOTE: We don't use the "Async" part of this lock at all
-        //TODO: Remove this and rename this class something like SystemWideLock, then we can re-instate this logic if we ever need an Async lock again
-
-        //public Task<IDisposable> LockAsync()
-        //{
-        //    var wait = _semaphore != null
-        //        ? _semaphore.WaitAsync()
-        //        : _semaphore2.WaitOneAsync();
-
-        //    return wait.IsCompleted
-        //        ? _releaserTask ?? Task.FromResult(CreateReleaser()) // anonymous vs named
-        //        : wait.ContinueWith((_, state) => (((AsyncLock) state).CreateReleaser()),
-        //            this, CancellationToken.None,
-        //            TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
-        //}
-
-        //public Task<IDisposable> LockAsync(int millisecondsTimeout)
-        //{
-        //    var wait = _semaphore != null
-        //        ? _semaphore.WaitAsync(millisecondsTimeout)
-        //        : _semaphore2.WaitOneAsync(millisecondsTimeout);
-
-        //    return wait.IsCompleted
-        //        ? _releaserTask ?? Task.FromResult(CreateReleaser()) // anonymous vs named
-        //        : wait.ContinueWith((_, state) => (((AsyncLock)state).CreateReleaser()),
-        //            this, CancellationToken.None,
-        //            TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
-        //}
-
         public IDisposable Lock()
         {
             if (_semaphore != null)
@@ -121,14 +92,18 @@ namespace Umbraco.Core
         private class NamedSemaphoreReleaser : CriticalFinalizerObject, IDisposable
         {
             private readonly Semaphore _semaphore;
-            private GCHandle _handle;
 
             internal NamedSemaphoreReleaser(Semaphore semaphore)
             {
                 _semaphore = semaphore;
-                _handle = GCHandle.Alloc(_semaphore);
             }
 
+            #region IDisposable Support
+
+            // This code added to correctly implement the disposable pattern.
+
+            private bool disposedValue = false; // To detect redundant calls
+
             public void Dispose()
             {
                 Dispose(true);
@@ -137,10 +112,22 @@ namespace Umbraco.Core
 
             private void Dispose(bool disposing)
             {
-                // critical
-                _handle.Free();
-                _semaphore.Release();
-                _semaphore.Dispose();
+                if (!disposedValue)
+                {
+                    try
+                    {
+                        _semaphore.Release();
+                    }
+                    finally
+                    {
+                        try
+                        {
+                            _semaphore.Dispose();
+                        }
+                        catch { }
+                    }
+                    disposedValue = true;
+                }
             }
 
             // we WANT to release the semaphore because it's a system object, ie a critical
@@ -171,6 +158,9 @@ namespace Umbraco.Core
                     // we do NOT want the finalizer to throw - never ever
                 }
             }
+
+            #endregion
+
         }
 
         private class SemaphoreSlimReleaser : IDisposable

src/Umbraco.Core/Umbraco.Core.csproj

@@ -128,7 +128,7 @@
     </Compile>
     -->
     <Compile Include="AssemblyExtensions.cs" />
-    <Compile Include="AsyncLock.cs" />
+    <Compile Include="SystemLock.cs" />
     <Compile Include="Attempt.cs" />
     <Compile Include="AttemptOfTResult.cs" />
     <Compile Include="AttemptOfTResultTStatus.cs" />
@@ -263,6 +263,7 @@
     <Compile Include="Migrations\Upgrade\V_8_0_0\RenameMediaVersionTable.cs" />
     <Compile Include="Migrations\Upgrade\V_8_0_0\DataTypes\ValueListPreValueMigrator.cs" />
     <Compile Include="Migrations\Upgrade\V_8_0_0\DataTypes\UmbracoSliderPreValueMigrator.cs" />
+    <Compile Include="Migrations\Upgrade\V_8_6_0\AddPropertyTypeValidationMessageColumns.cs" />
     <Compile Include="Migrations\Upgrade\V_8_1_0\FixContentNuCascade.cs" />
     <Compile Include="Migrations\Upgrade\V_8_1_0\RenameUserLoginDtoDateIndex.cs" />
     <Compile Include="Migrations\Upgrade\V_8_0_1\ChangeNuCacheJsonFormat.cs" />
@@ -276,6 +277,7 @@
     <Compile Include="Models\Entities\IMediaEntitySlim.cs" />
     <Compile Include="Models\Entities\IMemberEntitySlim.cs" />
     <Compile Include="Models\Entities\MediaEntitySlim.cs" />
+    <Compile Include="Models\PagedResult.cs" />
     <Compile Include="Models\Entities\MemberEntitySlim.cs" />
     <Compile Include="Models\PublishedContent\ILivePublishedModelFactory.cs" />
     <Compile Include="Models\PublishedContent\IPublishedContentType.cs" />
@@ -285,6 +287,7 @@
     <Compile Include="PropertyEditors\DataValueReferenceFactoryCollectionBuilder.cs" />
     <Compile Include="PropertyEditors\IDataValueReference.cs" />
     <Compile Include="PropertyEditors\IDataValueReferenceFactory.cs" />
+    <Compile Include="PropertyEditors\IDataEditorWithMediaPath.cs" />
     <Compile Include="PropertyEditors\IIgnoreUserStartNodesConfig.cs" />
     <Compile Include="PublishedContentExtensions.cs" />
     <Compile Include="Models\PublishedContent\UrlMode.cs" />
@@ -686,7 +689,6 @@
     <Compile Include="Exceptions\ArgumentNullOrEmptyException.cs" />
     <Compile Include="Exceptions\AuthorizationException.cs" />
     <Compile Include="Exceptions\BootFailedException.cs" />
-    <Compile Include="Exceptions\ConnectionException.cs" />
     <Compile Include="Exceptions\DataOperationException.cs" />
     <Compile Include="Exceptions\InvalidCompositionException.cs" />
     <Compile Include="Composing\LightInject\LightInjectException.cs" />
@@ -854,7 +856,7 @@
     <Compile Include="Models\Packaging\InstallationSummary.cs" />
     <Compile Include="Models\Packaging\PackageAction.cs" />
     <Compile Include="Models\Packaging\PreInstallWarnings.cs" />
-    <Compile Include="Models\PagedResult.cs" />
+    <Compile Include="Models\PagedResultOfT.cs" />
     <Compile Include="Models\PartialView.cs" />
     <Compile Include="Models\PartialViewType.cs" />
     <Compile Include="Models\Property.cs" />
@@ -1071,7 +1073,6 @@
     <Compile Include="Persistence\Mappers\UserGroupMapper.cs" />
     <Compile Include="Persistence\Mappers\UserMapper.cs" />
     <Compile Include="Persistence\Mappers\UserSectionMapper.cs" />
-    <Compile Include="Migrations\DataLossException.cs" />
     <Compile Include="Migrations\IMigration.cs" />
     <Compile Include="Migrations\IMigrationContext.cs" />
     <Compile Include="Migrations\IMigrationExpression.cs" />

src/Umbraco.Core/Xml/UmbracoXPathPathSyntaxParser.cs

@@ -1,9 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Umbraco.Core.Exceptions;
 
 namespace Umbraco.Core.Xml
 {
@@ -37,7 +34,8 @@ namespace Umbraco.Core.Xml
             // allowed 'inline', not just at the beginning... whether or not we want to support that is up
             // for discussion.
 
-            if (string.IsNullOrWhiteSpace(xpathExpression)) throw new ArgumentNullOrEmptyException(nameof(xpathExpression));
+            if (xpathExpression == null) throw new ArgumentNullException(nameof(xpathExpression));
+            if (string.IsNullOrWhiteSpace(xpathExpression)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(xpathExpression));
             if (getPath == null) throw new ArgumentNullException(nameof(getPath));
             if (publishedContentExists == null) throw new ArgumentNullException(nameof(publishedContentExists));
 

src/Umbraco.Core/Xml/XmlHelper.cs

@@ -4,9 +4,7 @@ using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
 using System.Xml;
-using System.Xml.Linq;
 using System.Xml.XPath;
-using Umbraco.Core.Exceptions;
 using Umbraco.Core.IO;
 
 namespace Umbraco.Core.Xml
@@ -25,9 +23,10 @@ namespace Umbraco.Core.Xml
         /// <param name="value"></param>
         public static void SetAttribute(XmlDocument xml, XmlNode n, string name, string value)
         {
-            if (xml == null) throw new ArgumentNullException("xml");
-            if (n == null) throw new ArgumentNullException("n");
-            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentNullOrEmptyException(nameof(name));
+            if (xml == null) throw new ArgumentNullException(nameof(xml));
+            if (n == null) throw new ArgumentNullException(nameof(n));
+            if (name == null) throw new ArgumentNullException(nameof(name));
+            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(name));
 
             if (n.Attributes == null)
             {
@@ -229,8 +228,9 @@ namespace Umbraco.Core.Xml
         /// <returns>a XmlAttribute</returns>
         public static XmlAttribute AddAttribute(XmlDocument xd, string name, string value)
         {
-            if (xd == null) throw new ArgumentNullException("xd");
-            if (string.IsNullOrEmpty(name)) throw new ArgumentNullOrEmptyException(nameof(name));
+            if (xd == null) throw new ArgumentNullException(nameof(xd));
+            if (name == null) throw new ArgumentNullException(nameof(name));
+            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(name));
 
             var temp = xd.CreateAttribute(name);
             temp.Value = value;
@@ -246,8 +246,9 @@ namespace Umbraco.Core.Xml
         /// <returns>a XmlNode</returns>
         public static XmlNode AddTextNode(XmlDocument xd, string name, string value)
         {
-            if (xd == null) throw new ArgumentNullException("xd");
-            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentNullOrEmptyException(nameof(name));
+            if (xd == null) throw new ArgumentNullException(nameof(xd));
+            if (name == null) throw new ArgumentNullException(nameof(name));
+            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(name));
 
             var temp = xd.CreateNode(XmlNodeType.Element, name, "");
             temp.AppendChild(xd.CreateTextNode(value));
@@ -264,9 +265,10 @@ namespace Umbraco.Core.Xml
         /// <returns>a XmlNode</returns>
         public static XmlNode SetTextNode(XmlDocument xd, XmlNode parent, string name, string value)
         {
-            if (xd == null) throw new ArgumentNullException("xd");
-            if (parent == null) throw new ArgumentNullException("parent");
-            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentNullOrEmptyException(nameof(name));
+            if (xd == null) throw new ArgumentNullException(nameof(xd));
+            if (parent == null) throw new ArgumentNullException(nameof(parent));
+            if (name == null) throw new ArgumentNullException(nameof(name));
+            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(name));
 
             var child = parent.SelectSingleNode(name);
             if (child != null)
@@ -289,7 +291,8 @@ namespace Umbraco.Core.Xml
         {
             if (xd == null) throw new ArgumentNullException(nameof(xd));
             if (parent == null) throw new ArgumentNullException(nameof(parent));
-            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value cannot be null or whitespace.", nameof(name));
+            if (name == null) throw new ArgumentNullException(nameof(name));
+            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(name));
 
             var child = parent.SelectSingleNode(name) ?? xd.CreateNode(XmlNodeType.Element, name, "");
             child.InnerXml = value;
@@ -305,8 +308,9 @@ namespace Umbraco.Core.Xml
         /// <returns>A XmlNode</returns>
         public static XmlNode AddCDataNode(XmlDocument xd, string name, string value)
         {
-            if (xd == null) throw new ArgumentNullException("xd");
-            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentNullOrEmptyException(nameof(name));
+            if (xd == null) throw new ArgumentNullException(nameof(xd));
+            if (name == null) throw new ArgumentNullException(nameof(name));
+            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(name));
 
             var temp = xd.CreateNode(XmlNodeType.Element, name, "");
             temp.AppendChild(xd.CreateCDataSection(value));
@@ -323,9 +327,10 @@ namespace Umbraco.Core.Xml
         /// <returns>a XmlNode</returns>
         public static XmlNode SetCDataNode(XmlDocument xd, XmlNode parent, string name, string value)
         {
-            if (xd == null) throw new ArgumentNullException("xd");
-            if (parent == null) throw new ArgumentNullException("parent");
-            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentNullOrEmptyException(nameof(name));
+            if (xd == null) throw new ArgumentNullException(nameof(xd));
+            if (parent == null) throw new ArgumentNullException(nameof(parent));
+            if (name == null) throw new ArgumentNullException(nameof(name));
+            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(name));
 
             var child = parent.SelectSingleNode(name);
             if (child != null)