Merge remote-tracking branch 'origin/netcore/dev' into netcore/feature/AB3970-membership-providers

# Conflicts:
#	src/Umbraco.Web/Editors/Filters/MemberSaveModelValidator.cs
#	src/Umbraco.Web/Editors/Filters/MemberSaveValidationAttribute.cs

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/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;
@@ -53,12 +52,13 @@ namespace Umbraco.Core.Manifest
             _localizationService = localizationService;
             _validators = validators ?? throw new ArgumentNullException(nameof(validators));
             _filters = filters ?? throw new ArgumentNullException(nameof(filters));
+            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));
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
             _ioHelper = ioHelper;
-            if (string.IsNullOrWhiteSpace(path)) throw new ArgumentNullOrEmptyException(nameof(path));
 
             Path = path;
-            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+
 
         }
 
@@ -170,8 +170,8 @@ namespace Umbraco.Core.Manifest
         /// </summary>
         public 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, _ioHelper, _dataTypeService, _localizationService),

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/Install/DatabaseBuilder.cs

@@ -5,7 +5,6 @@ using System.Linq;
 using System.Xml.Linq;
 using Umbraco.Core.Composing;
 using Umbraco.Core.Configuration;
-using Umbraco.Core.Exceptions;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Migrations.Upgrade;
@@ -291,8 +290,10 @@ namespace Umbraco.Core.Migrations.Install
         /// <param name="logger">A logger.</param>
         private static void SaveConnectionString(string connectionString, string providerName, IIOHelper ioHelper, 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(ioHelper.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

@@ -6,6 +6,7 @@ using Umbraco.Core.Migrations.Upgrade.Common;
 using Umbraco.Core.Migrations.Upgrade.V_8_0_0;
 using Umbraco.Core.Migrations.Upgrade.V_8_0_1;
 using Umbraco.Core.Migrations.Upgrade.V_8_1_0;
+using Umbraco.Core.Migrations.Upgrade.V_8_6_0;
 
 namespace Umbraco.Core.Migrations.Upgrade
 {
@@ -183,6 +184,9 @@ namespace Umbraco.Core.Migrations.Upgrade
             To<RenameUserLoginDtoDateIndex>("{0372A42B-DECF-498D-B4D1-6379E907EB94}");
             To<FixContentNuCascade>("{5B1E0D93-F5A3-449B-84BA-65366B84E2D4}");
 
+            // to 8.6.0
+            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/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);
         }
@@ -240,8 +239,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/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
@@ -42,7 +41,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;
 
@@ -62,9 +62,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/PropertyType.cs

@@ -2,6 +2,7 @@
 using System.Diagnostics;
 using System.Linq;
 using System.Runtime.Serialization;
+using Umbraco.Core.Composing;
 using Umbraco.Core.Models.Entities;
 using Umbraco.Core.Strings;
 
@@ -25,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>
@@ -168,7 +171,6 @@ namespace Umbraco.Core.Models
             set => SetPropertyValueAndDetectChanges(value, ref _propertyGroupId, nameof(PropertyGroupId));
         }
 
-
         /// <inheritdoc />
         [DataMember]
         public bool Mandatory
@@ -178,6 +180,14 @@ namespace Umbraco.Core.Models
         }
 
 
+        /// <inheritdoc />
+        [DataMember]
+        public string MandatoryMessage
+        {
+            get => _mandatoryMessage;
+            set => SetPropertyValueAndDetectChanges(value, ref _mandatoryMessage, nameof(MandatoryMessage));
+        }
+
         /// <inheritdoc />
         [DataMember]
         public int SortOrder
@@ -194,6 +204,17 @@ 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));
+        }
+
         /// <inheritdoc />
         public ContentVariation Variations
         {

src/Umbraco.Core/Packaging/PackageDataInstallation.cs

@@ -785,7 +785,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/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

@@ -296,10 +296,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

@@ -924,32 +924,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

@@ -424,32 +424,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.");
             }
         }
 

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

@@ -5,7 +5,6 @@ using NPoco;
 using NPoco.FluentMappings;
 using Umbraco.Core.Composing;
 using Umbraco.Core.Configuration;
-using Umbraco.Core.Exceptions;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence.FaultHandling;
 using Umbraco.Core.Persistence.Mappers;
@@ -62,8 +61,8 @@ namespace Umbraco.Core.Persistence
         /// <remarks>Used by the other ctor and in tests.</remarks>
         public UmbracoDatabaseFactory(string connectionStringName, ILogger logger, Lazy<IMapperCollection> mappers, Configs configs)
         {
-            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/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
@@ -50,8 +49,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;
             }
         }
@@ -60,7 +60,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);
         }
@@ -68,7 +70,8 @@ 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") ?? ValueIsInvalid, new[] { "value" });

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

@@ -45,7 +45,7 @@ namespace Umbraco.Core.PropertyEditors.Validators
             {
                 if (value.ToString().DetectIsEmptyJson())
                 {
-                    
+
                     yield return new ValidationResult(_textService?.Localize("validation", "invalidEmpty") ?? ValueCannotBeEmpty, new[] { "value" });
                 }
 

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/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;
         private readonly IUmbracoVersion _umbracoVersion;

src/Umbraco.Core/Security/BackOfficeUserStore.cs

@@ -5,7 +5,6 @@ using System.Linq;
 using System.Threading.Tasks;
 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;
@@ -208,7 +207,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;
 
@@ -320,7 +320,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);
@@ -339,7 +339,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;
@@ -370,7 +370,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(UserLoginInfoWrapper.Wrap(login)).ToArray();
@@ -404,7 +404,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);
 
@@ -425,7 +426,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

@@ -2884,7 +2884,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);
 
@@ -2899,7 +2900,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))
             {

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

@@ -592,10 +592,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

@@ -1220,7 +1220,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);
 
@@ -1234,7 +1235,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

@@ -61,7 +61,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

@@ -6,7 +6,6 @@ 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.Querying;
@@ -102,7 +101,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

@@ -3,7 +3,6 @@ using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
 using Umbraco.Core.Composing;
-using Umbraco.Core.Exceptions;
 using Umbraco.Core.IO;
 using Umbraco.Core.Strings;
 
@@ -106,7 +105,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);
         }
@@ -119,7 +119,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/Strings/IUrlSegmentProvider.cs

@@ -1,27 +0,0 @@
-using System.Globalization;
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Strings
-{
-    /// <summary>
-    /// Provides url segments for content.
-    /// </summary>
-    /// <remarks>Url segments should comply with IETF RFCs regarding content, encoding, etc.</remarks>
-    public interface IUrlSegmentProvider
-    {
-        /// <summary>
-        /// Gets the url segment for a specified content and culture.
-        /// </summary>
-        /// <param name="content">The content.</param>
-        /// <param name="culture">The culture.</param>
-        /// <returns>The url segment.</returns>
-        /// <remarks>This is for when Umbraco is capable of managing more than one url
-        /// per content, in 1-to-1 multilingual configurations. Then there would be one
-        /// url per culture.</remarks>
-        string GetUrlSegment(IContentBase content, string culture = null);
-
-        // TODO: For the 301 tracking, we need to add another extended interface to this so that
-        // the RedirectTrackingEventHandler can ask the IUrlSegmentProvider if the URL is changing.
-        // Currently the way it works is very hacky, see notes in: RedirectTrackingEventHandler.ContentService_Publishing
-    }
-}

src/Umbraco.Core/Strings/UrlSegmentProviderCollection.cs

@@ -1,12 +0,0 @@
-using System.Collections.Generic;
-using Umbraco.Core.Composing;
-
-namespace Umbraco.Core.Strings
-{
-    public class UrlSegmentProviderCollection : BuilderCollectionBase<IUrlSegmentProvider>
-    {
-        public UrlSegmentProviderCollection(IEnumerable<IUrlSegmentProvider> items)
-            : base(items)
-        { }
-    }
-}

src/Umbraco.Core/Strings/UrlSegmentProviderCollectionBuilder.cs

@@ -1,9 +0,0 @@
-using Umbraco.Core.Composing;
-
-namespace Umbraco.Core.Strings
-{
-    public class UrlSegmentProviderCollectionBuilder : OrderedCollectionBuilderBase<UrlSegmentProviderCollectionBuilder, UrlSegmentProviderCollection, IUrlSegmentProvider>
-    {
-        protected override UrlSegmentProviderCollectionBuilder This => this;
-    }
-}

src/Umbraco.Core/Umbraco.Core.csproj

@@ -188,6 +188,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" />
@@ -239,8 +240,6 @@
     <Compile Include="Services\Implement\PropertyValidationService.cs" />
     <Compile Include="StringExtensions.cs" />
     <Compile Include="Strings\DefaultUrlSegmentProvider.cs" />
-    <Compile Include="Strings\IUrlSegmentProvider.cs" />
-    <Compile Include="Strings\UrlSegmentProviderCollection.cs" />
     <Compile Include="Sync\RefreshInstructionEnvelope.cs" />
     <Compile Include="TypeExtensions.cs" />
     <Compile Include="TypeLoaderExtensions.cs" />
@@ -795,7 +794,6 @@
     <Compile Include="Compose\ManifestWatcherComponent.cs" />
     <Compile Include="Compose\RelateOnCopyComponent.cs" />
     <Compile Include="Compose\RelateOnTrashComponent.cs" />
-    <Compile Include="Strings\UrlSegmentProviderCollectionBuilder.cs" />
     <Compile Include="Sync\ApplicationUrlHelper.cs" />
     <Compile Include="Sync\DatabaseServerMessenger.cs" />
     <Compile Include="Sync\RefreshInstruction.cs" />