diff --git a/.travis.yml b/.travis.yml
index 7641e940bd..c64f120bc2 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,8 +1,8 @@
 language: csharp
 
-mono: 5.2.0
+mono: 5.8.0
 dotnet: 2.0.0
-dist: trusty
+dist: bionic
 
 
 install:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ce01fcdb1d..427270e728 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,69 @@ Date format: (year/month/day)
 
 ## Change Log
 
+### V4.6.4 (2019/05/28)
+
+#### Bugfixes
+
+- [#3392](https://github.com/NLog/NLog/pull/3392) NLog.Schema: Added missing defaultAction attribute on filters element in XSD (@304NotModified)
+- [#3415](https://github.com/NLog/NLog/pull/3415) AsyncWrapper in Blocking Mode can cause deadlock (@snakefoot)
+
+#### Features
+
+- [#3430](https://github.com/NLog/NLog/pull/3430) Added "Properties" property on Logger for reading and editing properties.(@snakefoot, @304NotModified)
+- [#3423](https://github.com/NLog/NLog/pull/3423) ${all-event-properties}: Added IncludeEmptyValues option (@304NotModified)
+- [#3394](https://github.com/NLog/NLog/pull/3394) ${when}, support for non-string values (@304NotModified)
+- [#3398](https://github.com/NLog/NLog/pull/3398) ${whenEmpty} support for non-string values (@snakefoot, @304NotModified)
+- [#3391](https://github.com/NLog/NLog/pull/3391) Added ${environment-user} (@snakefoot)
+- [#3389](https://github.com/NLog/NLog/pull/3389) Log4JXmlEventLayout - Added support for configuration of Parameters (@snakefoot)
+- [#3411](https://github.com/NLog/NLog/pull/3411) LoggingConfigurationParser - Recognize LoggingRule.RuleName property (@snakefoot)
+
+#### Improvements
+
+- [#3393](https://github.com/NLog/NLog/pull/3393) Update package descriptions to note the issues with <PackageReference> (@304NotModified)
+- [#3409](https://github.com/NLog/NLog/pull/3409) Various XSD improvements (NLog.Schema package) (@304NotModified)
+
+#### Performance
+
+- [#3398](https://github.com/NLog/NLog/pull/3398) ${whenEmpty} faster rendering of string values (@snakefoot, @304NotModified)
+- [#3405](https://github.com/NLog/NLog/pull/3405) FilteringTargetWrapper: Add support for batch writing (@snakefoot, @304NotModified)
+- [#3405](https://github.com/NLog/NLog/pull/3405) PostFilteringTargetWrapper: performance optimizations (@snakefoot, @304NotModified)
+- [#3435](https://github.com/NLog/NLog/pull/3435) Async / buffering wrapper: Improve performance when blocking (@snakefoot)
+- [#3434](https://github.com/NLog/NLog/pull/3434) ObjectReflectionCache - Skip property-reflection for IFormattable (@snakefoot)
+
+### V4.6.3 (2019/04/30)
+
+#### Bugfixes
+
+- [#3345](https://github.com/NLog/NLog/pull/3345) Fixed potential memory issue and message duplication with large strings (@snakefoot)
+- [#3316](https://github.com/NLog/NLog/pull/3316) TargetWithContext - serialize MDC and MDLC values properly (@304NotModified)
+
+#### Features
+
+- [#3298](https://github.com/NLog/NLog/pull/3298) Added WithProperty and SetProperty on Logger (@snakefoot)
+- [#3329](https://github.com/NLog/NLog/pull/3329) ${EventProperties} - Added ObjectPath for rendering nested property (@snakefoot, @304NotModified)
+- [#3337](https://github.com/NLog/NLog/pull/3337) ${ShortDate} added support for IRawValue + IStringValueRenderer (@snakefoot)
+- [#3328](https://github.com/NLog/NLog/pull/3328) Added truncate ambient property, e.g. ${message:truncate=80} (@snakefoot)
+- [#3278](https://github.com/NLog/NLog/pull/3278) ConsoleTarget & ColoredConsoleTarget  - Added AutoFlush and improve default flush behavior (@snakefoot)
+
+#### Improvements
+
+- [#3322](https://github.com/NLog/NLog/pull/3322) FileTarget - Introduced EnableFileDeleteSimpleMonitor without FileSystemWatcher for non-Windows (@snakefoot)
+- [#3332](https://github.com/NLog/NLog/pull/3332) LogFactory - GetLogger should validate name of logger (@snakefoot)
+- [#3320](https://github.com/NLog/NLog/pull/3320) FallbackGroupTarget - Fixed potential issue with WINDOWS_PHONE (@snakefoot)
+- [#3261](https://github.com/NLog/NLog/pull/3261) NLog config file loading: use process name (e.g. applicationname.exe.nlog) when app.config is not available (@snakefoot)
+
+#### Performance
+
+- [#3311](https://github.com/NLog/NLog/pull/3311) Split string - avoid allocation of object array. Added StringHelpers.SplitAndTrimTokens (@snakefoot)
+- [#3305](https://github.com/NLog/NLog/pull/3305) AppSettingLayoutRenderer - Mark as ThreadSafe and ThreadAgnostic (@snakefoot)
+
+#### Misc
+
+- [#3338](https://github.com/NLog/NLog/pull/3338) Update docs of various context classes (@304NotModified)
+- [#3288](https://github.com/NLog/NLog/pull/3288) Move NLogPackageLoaders for better unittest debugging experience of NLog (@304NotModified)
+- [#3274](https://github.com/NLog/NLog/pull/3274) Make HttpNetworkSender mockable, add unit test, introduce NSubsitute (@304NotModified)
+- 10 pull requests with refactorings (@snakefoot, @304NotModified)
 
 ### V4.6.2 (2019/04/02)
 
diff --git a/README.md b/README.md
index 93b1834649..5fd8ca1fe7 100644
--- a/README.md
+++ b/README.md
@@ -7,12 +7,12 @@
 [![license](https://img.shields.io/github/license/mashape/apistatus.svg)]()
 
 
-[![](https://sonarcloud.io/api/project_badges/measure?project=nlog&metric=ncloc)](https://sonarcloud.io/dashboard/?id=nlog) 
-[![](https://sonarcloud.io/api/project_badges/measure?project=nlog&metric=bugs)](https://sonarcloud.io/dashboard/?id=nlog) 
-[![](https://sonarcloud.io/api/project_badges/measure?project=nlog&metric=vulnerabilities)](https://sonarcloud.io/dashboard/?id=nlog) 
-[![](https://sonarcloud.io/api/project_badges/measure?project=nlog&metric=code_smells)](https://sonarcloud.io/project/issues?id=nlog&resolved=false&types=CODE_SMELL) 
-[![](https://sonarcloud.io/api/project_badges/measure?project=nlog&metric=duplicated_lines_density)](https://sonarcloud.io/component_measures/domain/Duplications?id=nlog) 
-[![](https://sonarcloud.io/api/project_badges/measure?project=nlog&metric=sqale_debt_ratio)](https://sonarcloud.io/dashboard/?id=nlog) 
+[![](https://sonarcloud.io/api/project_badges/measure?project=nlog&metric=ncloc&branch=dev)](https://sonarcloud.io/dashboard/?id=nlog&branch=dev) 
+[![](https://sonarcloud.io/api/project_badges/measure?project=nlog&metric=bugs&branch=dev)](https://sonarcloud.io/dashboard/?id=nlog&branch=dev) 
+[![](https://sonarcloud.io/api/project_badges/measure?project=nlog&metric=vulnerabilities&branch=dev)](https://sonarcloud.io/dashboard/?id=nlog&branch=dev) 
+[![](https://sonarcloud.io/api/project_badges/measure?project=nlog&metric=code_smells&branch=dev)](https://sonarcloud.io/project/issues?id=nlog&resolved=false&types=CODE_SMELL&branch=dev) 
+[![](https://sonarcloud.io/api/project_badges/measure?project=nlog&metric=duplicated_lines_density&branch=dev)](https://sonarcloud.io/component_measures/domain/Duplications?id=nlog&branch=dev) 
+[![](https://sonarcloud.io/api/project_badges/measure?project=nlog&metric=sqale_debt_ratio&branch=dev)](https://sonarcloud.io/dashboard/?id=nlog&branch=dev) 
 [![codecov.io](https://codecov.io/github/NLog/NLog/coverage.svg?branch=dev)](https://codecov.io/github/NLog/NLog?branch=dev)
 
 <!--
diff --git a/build.ps1 b/build.ps1
index ffab2e7776..f57e4508d9 100644
--- a/build.ps1
+++ b/build.ps1
@@ -5,7 +5,7 @@ dotnet --version
 # dotnet restore .\src\NLog\
 # dotnet pack .\src\NLog\  --configuration release --include-symbols -o ..\..\artifacts
 
-$versionPrefix = "4.6.2"
+$versionPrefix = "4.6.4"
 $versionSuffix = ""
 $versionFile = $versionPrefix + "." + ${env:APPVEYOR_BUILD_NUMBER}
 $versionProduct = $versionPrefix;
@@ -18,13 +18,15 @@ if ($env:APPVEYOR_PULL_REQUEST_NUMBER)
    $versionSuffix = "PR" + $env:APPVEYOR_PULL_REQUEST_NUMBER
 }
 
-# download nuget.exe
-
-$sourceNugetExe = "https://dist.nuget.org/win-x86-commandline/latest/nuget.exe"
 $targetNugetExe = "tools\nuget.exe"
-Invoke-WebRequest $sourceNugetExe -OutFile $targetNugetExe
+if (-Not (test-path $targetNugetExe))
+{
+	# download nuget.exe
+	$sourceNugetExe = "https://dist.nuget.org/win-x86-commandline/latest/nuget.exe"
+	Invoke-WebRequest $sourceNugetExe -OutFile $targetNugetExe
+}
 
-msbuild /t:Restore,Pack .\src\NLog\ /p:targetFrameworks='"net45;net40-client;net35;netstandard1.3;netstandard1.5;netstandard2.0;sl4;sl5;wp8;monoandroid44;xamarinios10"' /p:VersionPrefix=$versionPrefix /p:VersionSuffix=$versionSuffix /p:FileVersion=$versionFile /p:ProductVersion=$versionProduct /p:Configuration=Release /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg /p:PackageOutputPath=..\..\artifacts /verbosity:minimal
+msbuild /t:Restore,Pack .\src\NLog\ /p:targetFrameworks='"net45;net40-client;net35;netstandard1.3;netstandard1.5;netstandard2.0;sl4;sl5;wp8;monoandroid44;xamarinios10"' /p:VersionPrefix=$versionPrefix /p:VersionSuffix=$versionSuffix /p:FileVersion=$versionFile /p:ProductVersion=$versionProduct /p:Configuration=Release /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg /p:PackageOutputPath=..\..\artifacts /verbosity:minimal /maxcpucount
 if (-Not $LastExitCode -eq 0)
 	{ exit $LastExitCode }
 
@@ -32,7 +34,7 @@ function create-package($packageName)
 {
 
 	$path = ".\src\$packageName\"
-	msbuild /t:Restore,Pack $path /p:VersionPrefix=$versionPrefix /p:VersionSuffix=$versionSuffix /p:FileVersion=$versionFile /p:ProductVersion=$versionProduct /p:Configuration=Release /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg /p:PackageOutputPath=..\..\artifacts /verbosity:minimal
+	msbuild /t:Restore,Pack $path /p:VersionPrefix=$versionPrefix /p:VersionSuffix=$versionSuffix /p:FileVersion=$versionFile /p:ProductVersion=$versionProduct /p:Configuration=Release /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg /p:PackageOutputPath=..\..\artifacts /verbosity:minimal  /maxcpucount
 	if (-Not $LastExitCode -eq 0)
 		{ exit $LastExitCode }
 
diff --git a/src/NLog/Attributes/LogLevelTypeConverter.cs b/src/NLog/Attributes/LogLevelTypeConverter.cs
new file mode 100644
index 0000000000..911d09c2ae
--- /dev/null
+++ b/src/NLog/Attributes/LogLevelTypeConverter.cs
@@ -0,0 +1,91 @@
+// 
+// Copyright (c) 2004-2019 Jaroslaw Kowalski <jaak@jkowalski.net>, Kim Christensen, Julian Verdurmen
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without 
+// modification, are permitted provided that the following conditions 
+// are met:
+// 
+// * Redistributions of source code must retain the above copyright notice, 
+//   this list of conditions and the following disclaimer. 
+// 
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution. 
+// 
+// * Neither the name of Jaroslaw Kowalski nor the names of its 
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission. 
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
+// THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+namespace NLog.Attributes
+{
+    using System;
+    using System.ComponentModel;
+    using System.Globalization;
+
+    /// <summary>
+    /// Support <see cref="NLog.LogLevel"/> implementation of <see cref="IConvertible"/>
+    /// </summary>
+    public class LogLevelTypeConverter : TypeConverter
+    {
+        /// <inheritdoc/>
+        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+        {
+            return sourceType == typeof(string) || IsNumericType(sourceType) || base.CanConvertFrom(context, sourceType);
+        }
+
+        /// <inheritdoc/>
+        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+        {
+            if (value?.GetType() == typeof(string))
+                return LogLevel.FromString(value.ToString());
+            else if (IsNumericType(value?.GetType()))
+                return LogLevel.FromOrdinal(Convert.ToInt32(value));
+            else 
+                return base.ConvertFrom(context, culture, value);
+        }
+
+        /// <inheritdoc/>
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+        {
+            return destinationType == typeof(string) || IsNumericType(destinationType) || base.CanConvertTo(context, destinationType);
+        }
+
+        /// <inheritdoc/>
+        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
+        {
+            if (value is LogLevel logLevel)
+            {
+                if (destinationType == typeof(string))
+                    return logLevel.ToString();
+                else if (IsNumericType(destinationType))
+                    return Convert.ChangeType(logLevel.Ordinal, destinationType, culture);
+            }
+            return base.ConvertTo(context, culture, value, destinationType);
+        }
+
+        private static bool IsNumericType(Type sourceType)
+        {
+            return sourceType == typeof(int) ||
+                sourceType == typeof(uint) ||
+                sourceType == typeof(long) ||
+                sourceType == typeof(ulong) ||
+                sourceType == typeof(short) ||
+                sourceType == typeof(ushort);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/NLog/Common/LogEventInfoBuffer.cs b/src/NLog/Common/LogEventInfoBuffer.cs
index 44f4e9fed6..14dc14b5a0 100644
--- a/src/NLog/Common/LogEventInfoBuffer.cs
+++ b/src/NLog/Common/LogEventInfoBuffer.cs
@@ -65,10 +65,15 @@ public LogEventInfoBuffer(int size, bool growAsNeeded, int growLimit)
         }
 
         /// <summary>
-        /// Gets the number of items in the array.
+        /// Gets the capacity of the buffer
         /// </summary>
         public int Size => _buffer.Length;
 
+        /// <summary>
+        /// Gets the number of items in the buffer
+        /// </summary>
+        internal int Count { get { lock (_lockObject) return _count; } }
+
         /// <summary>
         /// Adds the specified log event to the buffer.
         /// </summary>
diff --git a/src/NLog/Conditions/ConditionMethodExpression.cs b/src/NLog/Conditions/ConditionMethodExpression.cs
index 5ea14bba36..eafe988f9c 100644
--- a/src/NLog/Conditions/ConditionMethodExpression.cs
+++ b/src/NLog/Conditions/ConditionMethodExpression.cs
@@ -186,7 +186,7 @@ public override string ToString()
         protected override object EvaluateNode(LogEventInfo context)
         {
             int parameterOffset = _acceptsLogEvent ? 1 : 0;
-            int parameterDefaults = _lateBoundMethodDefaultParameters != null ? _lateBoundMethodDefaultParameters.Length : 0;
+            int parameterDefaults = _lateBoundMethodDefaultParameters?.Length ?? 0;
 
             var callParameters = new object[MethodParameters.Count + parameterOffset + parameterDefaults];
 
diff --git a/src/NLog/Config/LoggerNameMatcher.cs b/src/NLog/Config/LoggerNameMatcher.cs
index 7bdc10ad09..e84ada3b1e 100644
--- a/src/NLog/Config/LoggerNameMatcher.cs
+++ b/src/NLog/Config/LoggerNameMatcher.cs
@@ -89,15 +89,25 @@ public static LoggerNameMatcher Create(string loggerNamePattern)
                     return new ContainsLoggerNameMatcher(loggerNamePattern);
                 if (starPos2 < 0)
                 {
-                    if (starPos1 == 0)
-                        return new EndsWithLoggerNameMatcher(loggerNamePattern);
-                    if (starPos1 == loggerNamePattern.Length - 1)
-                        return new StartsWithLoggerNameMatcher(loggerNamePattern);
+                    var loggerNameMatcher = CreateStartsOrEndsWithLoggerNameMatcher(loggerNamePattern, starPos1);
+                    if (loggerNameMatcher != null)
+                    {
+                        return loggerNameMatcher;
+                    }
                 }
             }
             return new MultiplePatternLoggerNameMatcher(loggerNamePattern);
         }
 
+        private static LoggerNameMatcher CreateStartsOrEndsWithLoggerNameMatcher(string loggerNamePattern, int starPos1)
+        {
+            if (starPos1 == 0)
+                return new EndsWithLoggerNameMatcher(loggerNamePattern);
+            if (starPos1 == loggerNamePattern.Length - 1)
+                return new StartsWithLoggerNameMatcher(loggerNamePattern);
+            return null;
+        }
+
         /// <summary>
         /// Returns the argument passed to <see cref="LoggerNameMatcher.Create(string)"/>
         /// </summary>
diff --git a/src/NLog/Config/LoggingConfiguration.cs b/src/NLog/Config/LoggingConfiguration.cs
index 0c91d3844c..fe3817b5f8 100644
--- a/src/NLog/Config/LoggingConfiguration.cs
+++ b/src/NLog/Config/LoggingConfiguration.cs
@@ -48,8 +48,7 @@ namespace NLog.Config
     using NLog.Targets.Wrappers;
 
     /// <summary>
-    /// Keeps logging configuration and provides simple API
-    /// to modify it.
+    /// Keeps logging configuration and provides simple API to modify it.
     /// </summary>
     ///<remarks>This class is thread-safe.<c>.ToList()</c> is used for that purpose.</remarks>
     public class LoggingConfiguration
@@ -62,7 +61,7 @@ public class LoggingConfiguration
         /// <summary>
         /// Variables defined in xml or in API. name is case case insensitive. 
         /// </summary>
-        private readonly Dictionary<string, SimpleLayout> _variables = new Dictionary<string, SimpleLayout>(StringComparer.OrdinalIgnoreCase);
+        private readonly ThreadSafeDictionary<string, SimpleLayout> _variables = new ThreadSafeDictionary<string, SimpleLayout>(StringComparer.OrdinalIgnoreCase);
 
         /// <summary>
         /// Gets the factory that will be configured
@@ -372,7 +371,7 @@ public void AddRuleForOneLevel(LogLevel level, Target target, string loggerNameP
         }
 
         /// <summary>
-        /// Add a rule for alle loglevels.
+        /// Add a rule for all loglevels.
         /// </summary>
         /// <param name="targetName">Name of the target to be written when the rule matches.</param>
         /// <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
@@ -388,7 +387,7 @@ public void AddRuleForAllLevels(string targetName, string loggerNamePattern = "*
         }
 
         /// <summary>
-        /// Add a rule for alle loglevels.
+        /// Add a rule for all loglevels.
         /// </summary>
         /// <param name="target">Target to be written to when the rule matches.</param>
         /// <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
@@ -399,7 +398,7 @@ public void AddRuleForAllLevels(Target target, string loggerNamePattern = "*")
         }
 
         /// <summary>
-        /// Add a rule for alle loglevels.
+        /// Add a rule for all loglevels.
         /// </summary>
         /// <param name="target">Target to be written to when the rule matches.</param>
         /// <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
@@ -482,6 +481,34 @@ public virtual LoggingConfiguration Reload()
             return this;
         }
 
+        internal LoggingConfiguration ReloadNewConfig()
+        {
+            var newConfig = Reload();
+            if (newConfig != null)
+            {
+                //problem: XmlLoggingConfiguration.Initialize eats exception with invalid XML. ALso XmlLoggingConfiguration.Reload never returns null.
+                //therefor we check the InitializeSucceeded property.
+
+                if (newConfig is XmlLoggingConfiguration xmlConfig && xmlConfig.InitializeSucceeded != true)
+                {
+                    InternalLogger.Warn("NLog Config Reload() failed. Invalid XML?");
+                    return null;
+                }
+
+                var logFactory = LogFactory ?? LogManager.LogFactory;
+                if (logFactory.KeepVariablesOnReload)
+                {
+                    var currentConfig = logFactory._config ?? this;
+                    if (!ReferenceEquals(newConfig, currentConfig))
+                    {
+                        newConfig.CopyVariables(currentConfig.Variables);
+                    }
+                }
+            }
+
+            return newConfig;
+        }
+
         /// <summary>
         /// Removes the specified named target.
         /// </summary>
@@ -497,20 +524,7 @@ public void RemoveTarget(string name)
 
             if (!string.IsNullOrEmpty(name) || removedTarget != null)
             {
-                var loggingRules = GetLoggingRulesThreadSafe();
-
-                foreach (var rule in loggingRules)
-                {
-                    var targetList = rule.GetTargetsThreadSafe();
-                    foreach (var target in targetList)
-                    {
-                        if (ReferenceEquals(removedTarget, target) || (!string.IsNullOrEmpty(name) && target.Name == name))
-                        {
-                            removedTargets.Add(target);
-                            rule.RemoveTargetThreadSafe(target);
-                        }
-                    }
-                }
+                CleanupRulesForRemovedTarget(name, removedTarget, removedTargets);
             }
 
             if (removedTargets.Count > 0)
@@ -540,6 +554,24 @@ public void RemoveTarget(string name)
             }
         }
 
+        private void CleanupRulesForRemovedTarget(string name, Target removedTarget, HashSet<Target> removedTargets)
+        {
+            var loggingRules = GetLoggingRulesThreadSafe();
+
+            foreach (var rule in loggingRules)
+            {
+                var targetList = rule.GetTargetsThreadSafe();
+                foreach (var target in targetList)
+                {
+                    if (ReferenceEquals(removedTarget, target) || (!string.IsNullOrEmpty(name) && target.Name == name))
+                    {
+                        removedTargets.Add(target);
+                        rule.RemoveTargetThreadSafe(target);
+                    }
+                }
+            }
+        }
+
         /// <summary>
         /// Installs target-specific objects on current system.
         /// </summary>
@@ -759,11 +791,6 @@ internal void InitializeAll()
             }
         }
 
-        internal void EnsureInitialized()
-        {
-            InitializeAll();
-        }
-
         private List<IInstallable> GetInstallableItems()
         {
             return _configItems.OfType<IInstallable>().ToList();
@@ -785,10 +812,7 @@ private List<ISupportsInitialize> GetSupportsInitializes(bool reverse = false)
         /// <param name="masterVariables">Master variables dictionary</param>
         internal void CopyVariables(IDictionary<string, SimpleLayout> masterVariables)
         {
-            foreach (var variable in masterVariables)
-            {
-                Variables[variable.Key] = variable.Value;
-            }
+            _variables.CopyFrom(masterVariables);
         }
 
         /// <summary>
@@ -825,44 +849,41 @@ internal void CheckUnusedTargets()
             ReadOnlyCollection<Target> configuredNamedTargets = ConfiguredNamedTargets; //assign to variable because `ConfiguredNamedTargets` computes a new list every time.
             InternalLogger.Debug("Unused target checking is started... Rule Count: {0}, Target Count: {1}", LoggingRules.Count, configuredNamedTargets.Count);
 
-            HashSet<string> targetNamesAtRules = new HashSet<string>(GetLoggingRulesThreadSafe().SelectMany(r => r.Targets).Select(t => t.Name));
+            var targetNamesAtRules = new HashSet<string>(GetLoggingRulesThreadSafe().SelectMany(r => r.Targets).Select(t => t.Name));
             var wrappedTargets = configuredNamedTargets.OfType<WrapperTargetBase>().ToLookup(wt => wt.WrappedTarget, wt => wt);
             var compoundTargets = configuredNamedTargets.OfType<CompoundTargetBase>().SelectMany(wt => wt.Targets.Select(t => new KeyValuePair<Target, Target>(t, wt))).ToLookup(p => p.Key, p => p.Value);
 
-            int unusedCount = configuredNamedTargets.Count((target) =>
+            bool IsUnusedInList<T>(Target target1, ILookup<Target, T> targets)
+            where T:Target
             {
-                if (targetNamesAtRules.Contains(target.Name))
-                    return false;
-
-                if (wrappedTargets.Contains(target))
+                if (targets.Contains(target1))
                 {
-                    foreach (var wrapperTarget in wrappedTargets[target])
+                    foreach (var wrapperTarget in targets[target1])
                     {
                         if (targetNamesAtRules.Contains(wrapperTarget.Name))
                             return false;
 
                         if (wrappedTargets.Contains(wrapperTarget))
-                            return false;   // Double nested targets are too complicated
+                            return false;
 
                         if (compoundTargets.Contains(wrapperTarget))
-                            return false;   // Double nested targets are too complicated
+                            return false;
                     }
                 }
 
-                if (compoundTargets.Contains(target))
-                {
-                    foreach (var wrapperTarget in compoundTargets[target])
-                    {
-                        if (targetNamesAtRules.Contains(wrapperTarget.Name))
-                            return false;
+                return true;
+            }
 
-                        if (wrappedTargets.Contains(wrapperTarget))
-                            return false;   // Double nested targets are too complicated
+            int unusedCount = configuredNamedTargets.Count((target) =>
+            {
+                if (targetNamesAtRules.Contains(target.Name))
+                    return false;
 
-                        if (compoundTargets.Contains(wrapperTarget))
-                            return false;   // Double nested targets are too complicated
-                    }
-                }
+                if (!IsUnusedInList(target, wrappedTargets))
+                    return false;
+
+                if (!IsUnusedInList(target, compoundTargets))
+                    return false;
 
                 InternalLogger.Warn("Unused target detected. Add a rule for this target to the configuration. TargetName: {0}", target.Name);
                 return true;
diff --git a/src/NLog/Config/LoggingConfigurationParser.cs b/src/NLog/Config/LoggingConfigurationParser.cs
index 93b1b1dcb7..76ca91b02a 100644
--- a/src/NLog/Config/LoggingConfigurationParser.cs
+++ b/src/NLog/Config/LoggingConfigurationParser.cs
@@ -590,6 +590,9 @@ private LoggingRule ParseRuleElement(ILoggingConfigurationElement loggerElement)
                         else
                             ruleName = childProperty.Value;
                         break;
+                    case "RULENAME":
+                        ruleName = childProperty.Value; // Legacy Style
+                        break;
                     case "LOGGER":
                         namePattern = childProperty.Value;
                         break;
@@ -610,8 +613,8 @@ private LoggingRule ParseRuleElement(ILoggingConfigurationElement loggerElement)
                         break;
                     case "LEVELS":
                         {
-                            string[] tokens = CleanSpaces(childProperty.Value).Split(',');
-                            enableLevels = tokens.Where(t => !string.IsNullOrEmpty(t)).Select(LogLevelFromString);
+                            string[] tokens = childProperty.Value.SplitAndTrimTokens(',');
+                            enableLevels = tokens.Select(LogLevelFromString);
                             break;
                         }
                     case "MINLEVEL":
@@ -680,12 +683,8 @@ private void ParseLoggingRuleTargets(string writeTargets, LoggingRule rule)
             if (string.IsNullOrEmpty(writeTargets))
                 return;
 
-            foreach (string t in writeTargets.Split(','))
+            foreach (string targetName in writeTargets.SplitAndTrimTokens(','))
             {
-                string targetName = t.Trim();
-                if (string.IsNullOrEmpty(targetName))
-                    continue;
-
                 Target target = FindTargetByName(targetName);
                 if (target != null)
                 {
@@ -1025,6 +1024,11 @@ private void SetPropertyFromElement(object o, ILoggingConfigurationElement eleme
                 return;
             }
 
+            if (SetFilterFromElement(o, propInfo, element))
+            {
+                return;
+            }
+
             SetItemFromElement(o, propInfo, element);
         }
 
@@ -1069,16 +1073,29 @@ private object ParseArrayItemFromElement(Type elementType, ILoggingConfiguration
             return arrayItem;
         }
 
-        private bool SetLayoutFromElement(object o, PropertyInfo propInfo, ILoggingConfigurationElement layoutElement)
+        private bool SetLayoutFromElement(object o, PropertyInfo propInfo, ILoggingConfigurationElement element)
         {
-            Layout layout = TryCreateLayoutInstance(layoutElement, propInfo.PropertyType);
+            var layout = TryCreateLayoutInstance(element, propInfo.PropertyType);
 
             // and is a Layout and 'type' attribute has been specified
             if (layout != null)
             {
-                ConfigureObjectFromAttributes(layout, layoutElement, true);
-                ConfigureObjectFromElement(layout, layoutElement);
-                propInfo.SetValue(o, layout, null);
+                SetItemOnProperty(o, propInfo, element, layout);
+                return true;
+            }
+
+            return false;
+        }
+        
+        private bool SetFilterFromElement(object o, PropertyInfo propInfo, ILoggingConfigurationElement element)
+        {
+            var type = propInfo.PropertyType;
+
+            Filter filter = TryCreateFilterInstance(element, type);
+            // and is a Filter and 'type' attribute has been specified
+            if (filter != null)
+            {
+                SetItemOnProperty(o, propInfo, element, filter);
                 return true;
             }
 
@@ -1087,8 +1104,19 @@ private bool SetLayoutFromElement(object o, PropertyInfo propInfo, ILoggingConfi
 
         private Layout TryCreateLayoutInstance(ILoggingConfigurationElement element, Type type)
         {
-            // Check if it is a Layout
-            if (!typeof(Layout).IsAssignableFrom(type))
+            return TryCreateInstance(element, type, _configurationItemFactory.Layouts);
+        } 
+        
+        private Filter TryCreateFilterInstance(ILoggingConfigurationElement element, Type type)
+        {
+            return TryCreateInstance(element, type, _configurationItemFactory.Filters);
+        }
+
+        private T TryCreateInstance<T>(ILoggingConfigurationElement element, Type type, INamedItemFactory<T, Type> factory)
+            where T : class
+        {
+            // Check if correct type
+            if (!IsAssignableFrom<T>(type))
                 return null;
 
             // Check if the 'type' attribute has been specified
@@ -1096,7 +1124,19 @@ private Layout TryCreateLayoutInstance(ILoggingConfigurationElement element, Typ
             if (layoutTypeName == null)
                 return null;
 
-            return _configurationItemFactory.Layouts.CreateInstance(ExpandSimpleVariables(layoutTypeName));
+            return factory.CreateInstance(ExpandSimpleVariables(layoutTypeName));
+        }
+
+        private static bool IsAssignableFrom<T>(Type type)
+        {
+            return typeof(T).IsAssignableFrom(type);
+        }
+
+        private void SetItemOnProperty(object o, PropertyInfo propInfo, ILoggingConfigurationElement element, object properyValue)
+        {
+            ConfigureObjectFromAttributes(properyValue, element, true);
+            ConfigureObjectFromElement(properyValue, element);
+            propInfo.SetValue(o, properyValue, null);
         }
 
         private void SetItemFromElement(object o, PropertyInfo propInfo, ILoggingConfigurationElement element)
@@ -1228,18 +1268,6 @@ private static string StripOptionalNamespacePrefix(string attributeValue)
             return attributeValue.Substring(p + 1);
         }
 
-        /// <summary>
-        /// Remove all spaces, also in between text. 
-        /// </summary>
-        /// <param name="s">text</param>
-        /// <returns>text without spaces</returns>
-        /// <remarks>Tabs and other whitespace is not removed!</remarks>
-        private static string CleanSpaces(string s)
-        {
-            s = s.Replace(" ", string.Empty); // get rid of the whitespace
-            return s;
-        }
-
         private static string GetName(Target target)
         {
             return string.IsNullOrEmpty(target.Name) ? target.GetType().Name : target.Name;
diff --git a/src/NLog/Config/LoggingConfigurationWatchableFileLoader.cs b/src/NLog/Config/LoggingConfigurationWatchableFileLoader.cs
index 38324f7c50..a535e6949e 100644
--- a/src/NLog/Config/LoggingConfigurationWatchableFileLoader.cs
+++ b/src/NLog/Config/LoggingConfigurationWatchableFileLoader.cs
@@ -156,16 +156,9 @@ internal void ReloadConfigOnTimer(object state)
                         return;
                     }
 
-                    newConfig = oldConfig.Reload();
-
-                    //problem: XmlLoggingConfiguration.Initialize eats exception with invalid XML. ALso XmlLoggingConfiguration.Reload never returns null.
-                    //therefor we check the InitializeSucceeded property.
-
-                    if (newConfig is XmlLoggingConfiguration xmlConfig && xmlConfig.InitializeSucceeded != true)
-                    {
-                        InternalLogger.Warn("NLog Config Reload() failed. Invalid XML?");
+                    newConfig = oldConfig.ReloadNewConfig();
+                    if (newConfig == null)
                         return;
-                    }
                 }
                 catch (Exception exception)
                 {
@@ -183,18 +176,10 @@ internal void ReloadConfigOnTimer(object state)
                 {
                     TryUnwatchConfigFile();
 
-                    if (newConfig != null)
-                    {
-                        if (_logFactory.KeepVariablesOnReload && _logFactory._config != null)
-                        {
-                            newConfig.CopyVariables(_logFactory._config.Variables);
-                        }
-
-                        _logFactory.Configuration = newConfig;  // Triggers LogFactory to call Activated(...) that adds file-watch again
+                    _logFactory.Configuration = newConfig;  // Triggers LogFactory to call Activated(...) that adds file-watch again
 
-                        _logFactory?.NotifyConfigurationReloaded(new LoggingConfigurationReloadedEventArgs(true));
-                    }
-                }
+                    _logFactory?.NotifyConfigurationReloaded(new LoggingConfigurationReloadedEventArgs(true));
+                 }
                 catch (Exception exception)
                 {
                     if (exception.MustBeRethrownImmediately())
diff --git a/src/NLog/Config/LoggingRule.cs b/src/NLog/Config/LoggingRule.cs
index 7b218840d7..7eb63dc60c 100644
--- a/src/NLog/Config/LoggingRule.cs
+++ b/src/NLog/Config/LoggingRule.cs
@@ -165,6 +165,7 @@ public string LoggerNamePattern
         /// <summary>
         /// Gets the collection of log levels enabled by this rule.
         /// </summary>
+        [NLogConfigurationIgnoreProperty]
         public ReadOnlyCollection<LogLevel> Levels
         {
             get
@@ -182,8 +183,9 @@ public ReadOnlyCollection<LogLevel> Levels
                 return levels.AsReadOnly();
             }
         }
+
         /// <summary>
-        /// Default action if all filters won't match
+        /// Default action if none of the filters match
         /// </summary>
         public FilterResult DefaultFilterResult { get; set; } = FilterResult.Neutral;
 
diff --git a/src/NLog/Config/NLogXmlElement.cs b/src/NLog/Config/NLogXmlElement.cs
index c2da7b4f98..2c224bb06f 100644
--- a/src/NLog/Config/NLogXmlElement.cs
+++ b/src/NLog/Config/NLogXmlElement.cs
@@ -239,14 +239,9 @@ private void ParseAttributes(XmlReader reader, bool nestedElement)
             {
                 do
                 {
-                    if (!nestedElement)
+                    if (!nestedElement && IsSpecialXmlAttribute(reader))
                     {
-                        if (reader.LocalName?.Equals("xmlns", StringComparison.OrdinalIgnoreCase) == true)
-                            continue;
-                        if (reader.Prefix?.Equals("xsi", StringComparison.OrdinalIgnoreCase) == true)
-                            continue;
-                        if (reader.Prefix?.Equals("xmlns", StringComparison.OrdinalIgnoreCase) == true)
-                            continue;
+                        continue;
                     }
 
                     if (!AttributeValues.ContainsKey(reader.LocalName))
@@ -263,5 +258,19 @@ private void ParseAttributes(XmlReader reader, bool nestedElement)
                 reader.MoveToElement();
             }
         }
+
+        /// <summary>
+        /// Special attribute we could ignore
+        /// </summary>
+        private static bool IsSpecialXmlAttribute(XmlReader reader)
+        {
+            if (reader.LocalName?.Equals("xmlns", StringComparison.OrdinalIgnoreCase) == true)
+                return true;
+            if (reader.Prefix?.Equals("xsi", StringComparison.OrdinalIgnoreCase) == true)
+                return true;
+            if (reader.Prefix?.Equals("xmlns", StringComparison.OrdinalIgnoreCase) == true)
+                return true;
+            return false;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/NLog/Config/XmlLoggingConfiguration.cs b/src/NLog/Config/XmlLoggingConfiguration.cs
index e03a40fe61..719a989854 100644
--- a/src/NLog/Config/XmlLoggingConfiguration.cs
+++ b/src/NLog/Config/XmlLoggingConfiguration.cs
@@ -293,7 +293,7 @@ public override IEnumerable<string> FileNamesToWatch
         public override LoggingConfiguration Reload()
         {
             if (!string.IsNullOrEmpty(_originalFileName))
-                return new XmlLoggingConfiguration(_originalFileName);
+                return new XmlLoggingConfiguration(_originalFileName, LogFactory);
             else
                 return base.Reload();
         }
@@ -459,7 +459,7 @@ private void ParseNLogElement(ILoggingConfigurationElement nlogElement, string f
             nlogElement.AssertName("nlog");
 
             bool autoReload = nlogElement.GetOptionalBooleanValue("autoReload", autoReloadDefault);
-            if (filePath != null)
+            if (!string.IsNullOrEmpty(filePath))
                 _fileMustAutoReloadLookup[GetFileLookupKey(filePath)] = autoReload;
 
             try
@@ -483,8 +483,8 @@ protected override bool ParseNLogSection(ILoggingConfigurationElement configSect
             if (configSection.MatchesName("include"))
             {
                 string filePath = _currentFilePath.Peek();
-                bool autoLoad = filePath != null && _fileMustAutoReloadLookup[GetFileLookupKey(filePath)];
-                ParseIncludeElement(configSection, filePath != null ? Path.GetDirectoryName(filePath) : null, autoLoad);
+                bool autoLoad = !string.IsNullOrEmpty(filePath) && _fileMustAutoReloadLookup[GetFileLookupKey(filePath)];
+                ParseIncludeElement(configSection, !string.IsNullOrEmpty(filePath) ? Path.GetDirectoryName(filePath) : null, autoLoad);
                 return true;
             }
             else
diff --git a/src/NLog/Filters/ConditionBasedFilter.cs b/src/NLog/Filters/ConditionBasedFilter.cs
index 5b6be277e9..a629008e8f 100644
--- a/src/NLog/Filters/ConditionBasedFilter.cs
+++ b/src/NLog/Filters/ConditionBasedFilter.cs
@@ -55,6 +55,8 @@ public class ConditionBasedFilter : Filter
         [RequiredParameter]
         public ConditionExpression Condition { get; set; }
 
+        internal FilterResult DefaultFilterResult { get; set; } = FilterResult.Neutral;
+
         /// <summary>
         /// Checks whether log event should be logged or not.
         /// </summary>
@@ -72,7 +74,7 @@ protected override FilterResult Check(LogEventInfo logEvent)
                 return Action;
             }
 
-            return FilterResult.Neutral;
+            return DefaultFilterResult;
         }
     }
 }
diff --git a/src/NLog/GDC.cs b/src/NLog/GDC.cs
index b96a60cc67..b2ac32d5de 100644
--- a/src/NLog/GDC.cs
+++ b/src/NLog/GDC.cs
@@ -37,7 +37,7 @@ namespace NLog
     using Config;
 
     /// <summary>
-    /// Global Diagnostics Context - used for log4net compatibility.
+    /// Global Diagnostics Context
     /// </summary>
     /// <remarks>This class was marked as obsolete on NLog 2.0 and it may be removed in a future release.</remarks>
     [Obsolete("Use GlobalDiagnosticsContext class instead. Marked obsolete on NLog 2.0")]
diff --git a/src/NLog/GlobalDiagnosticsContext.cs b/src/NLog/GlobalDiagnosticsContext.cs
index d8b0488e30..93cfda99ce 100644
--- a/src/NLog/GlobalDiagnosticsContext.cs
+++ b/src/NLog/GlobalDiagnosticsContext.cs
@@ -43,6 +43,7 @@ namespace NLog
     /// </summary>
     public static class GlobalDiagnosticsContext
     {
+        private static readonly object _lockObject = new object();
         private static Dictionary<string, object> _dict = new Dictionary<string, object>();
         private static Dictionary<string, object> _dictReadOnly;  // Reset cache on change
 
@@ -63,7 +64,7 @@ public static void Set(string item, string value)
         /// <param name="value">Item value.</param>
         public static void Set(string item, object value)
         {
-            lock (_dict)
+            lock (_lockObject)
             {
                 bool requireCopyOnWrite = _dictReadOnly != null && !_dict.ContainsKey(item); // Overwiting existing value is ok (no resize)
                 GetWritableDict(requireCopyOnWrite)[item] = value;
@@ -129,7 +130,7 @@ public static bool Contains(string item)
         /// <param name="item">Item name.</param>
         public static void Remove(string item)
         {
-            lock (_dict)
+            lock (_lockObject)
             {
                 bool requireCopyOnWrite = _dictReadOnly != null && _dict.ContainsKey(item);
                 GetWritableDict(requireCopyOnWrite).Remove(item);
@@ -141,7 +142,7 @@ public static void Remove(string item)
         /// </summary>
         public static void Clear()
         {
-            lock (_dict)
+            lock (_lockObject)
             {
                 bool requireCopyOnWrite = _dictReadOnly != null && _dict.Count > 0;
                 GetWritableDict(requireCopyOnWrite, true).Clear();
@@ -153,7 +154,7 @@ public static void Clear()
             var readOnly = _dictReadOnly;
             if (readOnly == null)
             {
-                lock (_dict)
+                lock (_lockObject)
                 {
                     readOnly = _dictReadOnly = _dict;
                 }
diff --git a/src/NLog/Internal/CollectionExtensions.cs b/src/NLog/Internal/CollectionExtensions.cs
new file mode 100644
index 0000000000..85b82310e7
--- /dev/null
+++ b/src/NLog/Internal/CollectionExtensions.cs
@@ -0,0 +1,77 @@
+// 
+// Copyright (c) 2004-2019 Jaroslaw Kowalski <jaak@jkowalski.net>, Kim Christensen, Julian Verdurmen
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without 
+// modification, are permitted provided that the following conditions 
+// are met:
+// 
+// * Redistributions of source code must retain the above copyright notice, 
+//   this list of conditions and the following disclaimer. 
+// 
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution. 
+// 
+// * Neither the name of Jaroslaw Kowalski nor the names of its 
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission. 
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
+// THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+using System;
+using System.Collections.Generic;
+using JetBrains.Annotations;
+
+namespace NLog.Internal
+{
+    internal static class CollectionExtensions
+    {
+        /// <summary>
+        /// Memory optimized filtering
+        /// </summary>
+        /// <remarks>Passing state too avoid delegate capture and memory-allocations.</remarks>
+        [NotNull]
+        public static IList<TItem> Filter<TItem, TState>([NotNull] this IList<TItem> items, TState state, Func<TItem, TState, bool> filter)
+        {
+            var hasIgnoredLogEvents = false;
+            IList<TItem> filterLogEvents = null;
+            for (var i = 0; i < items.Count; ++i)
+            {
+                var item = items[i];
+                if (filter(item, state))
+                {
+                    if (hasIgnoredLogEvents && filterLogEvents == null)
+                    {
+                        filterLogEvents = new List<TItem>();
+                    }
+
+                    filterLogEvents?.Add(item);
+                }
+                else
+                {
+                    if (!hasIgnoredLogEvents && i > 0)
+                    {
+                        filterLogEvents = new List<TItem>();
+                        for (var j = 0; j < i; ++j)
+                            filterLogEvents.Add(items[j]);
+                    }
+                    hasIgnoredLogEvents = true;
+                }
+            }
+            return filterLogEvents ?? (hasIgnoredLogEvents ? ArrayHelper.Empty<TItem>() : items);
+        }
+    }
+}
diff --git a/src/NLog/Internal/EnvironmentHelper.cs b/src/NLog/Internal/EnvironmentHelper.cs
index f42cd8ad95..668a8f041b 100644
--- a/src/NLog/Internal/EnvironmentHelper.cs
+++ b/src/NLog/Internal/EnvironmentHelper.cs
@@ -82,7 +82,7 @@ internal static string GetSafeEnvironmentVariable(string name)
             {
                 string s = Environment.GetEnvironmentVariable(name);
 
-                if (s == null || s.Length == 0)
+                if (string.IsNullOrEmpty(s))
                 {
                     return null;
                 }
diff --git a/src/NLog/Internal/Fakeables/AppDomainWrapper.cs b/src/NLog/Internal/Fakeables/AppDomainWrapper.cs
index df90f7e475..b1a4424f14 100644
--- a/src/NLog/Internal/Fakeables/AppDomainWrapper.cs
+++ b/src/NLog/Internal/Fakeables/AppDomainWrapper.cs
@@ -118,7 +118,7 @@ private static string[] LookupPrivateBinPath(AppDomain appDomain)
             string privateBinPath = appDomain.SetupInformation.PrivateBinPath;
             return string.IsNullOrEmpty(privateBinPath)
                                     ? ArrayHelper.Empty<string>()
-                                    : privateBinPath.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
+                                    : privateBinPath.SplitAndTrimTokens(';');
 #else
             return ArrayHelper.Empty<string>();
 #endif
diff --git a/src/NLog/Internal/FileAppenders/BaseFileAppender.cs b/src/NLog/Internal/FileAppenders/BaseFileAppender.cs
index 5000351c0b..0ed3daeb9c 100644
--- a/src/NLog/Internal/FileAppenders/BaseFileAppender.cs
+++ b/src/NLog/Internal/FileAppenders/BaseFileAppender.cs
@@ -67,7 +67,7 @@ protected BaseFileAppender(string fileName, ICreateFileParameters createParamete
         /// Gets the path of the file, including file extension.
         /// </summary>
         /// <value>The name of the file.</value>
-        public string FileName { get; private set; }
+        public string FileName { get; }
 
         /// <summary>
         /// Gets or sets the creation time for a file associated with the appender. The time returned is in Coordinated  
@@ -316,5 +316,28 @@ private void UpdateCreationTime()
 #endif
             }
         }
+
+
+        protected static bool MonitorForEnableFileDeleteEvent(string fileName, ref DateTime lastSimpleMonitorCheckTimeUtc)
+        {
+            long ticksDelta = DateTime.UtcNow.Ticks - lastSimpleMonitorCheckTimeUtc.Ticks;
+            if (ticksDelta > TimeSpan.TicksPerSecond || ticksDelta < -TimeSpan.TicksPerSecond)
+            {
+                lastSimpleMonitorCheckTimeUtc = DateTime.UtcNow;
+                try
+                {
+                    if (!File.Exists(fileName))
+                    {
+                        return true;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    InternalLogger.Error(ex, "Failed to check if File.Exists {0}", fileName);
+                    return true;
+                }
+            }
+            return false;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/NLog/Internal/FileAppenders/CountingSingleProcessFileAppender.cs b/src/NLog/Internal/FileAppenders/CountingSingleProcessFileAppender.cs
index 004db18957..b46f55b760 100644
--- a/src/NLog/Internal/FileAppenders/CountingSingleProcessFileAppender.cs
+++ b/src/NLog/Internal/FileAppenders/CountingSingleProcessFileAppender.cs
@@ -48,8 +48,9 @@ internal class CountingSingleProcessFileAppender : BaseFileAppender
         public static readonly IFileAppenderFactory TheFactory = new Factory();
 
         private FileStream _file;
-
         private long _currentFileLength;
+        private readonly bool _enableFileDeleteSimpleMonitor;
+        private DateTime _lastSimpleMonitorCheckTimeUtc;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="CountingSingleProcessFileAppender" /> class.
@@ -62,6 +63,8 @@ public CountingSingleProcessFileAppender(string fileName, ICreateFileParameters
             var fileInfo = new FileInfo(fileName);
             _currentFileLength = fileInfo.Exists ? fileInfo.Length : 0;
             _file = CreateFileStream(false);
+            _enableFileDeleteSimpleMonitor = parameters.EnableFileDeleteSimpleMonitor;
+            _lastSimpleMonitorCheckTimeUtc = OpenTimeUtc;
         }
 
         /// <summary>
@@ -135,6 +138,13 @@ public override void Write(byte[] bytes, int offset, int count)
                 return;
             }
 
+            if (_enableFileDeleteSimpleMonitor && MonitorForEnableFileDeleteEvent(FileName, ref _lastSimpleMonitorCheckTimeUtc))
+            {
+                _file.Dispose();
+                _file = CreateFileStream(false);
+                _currentFileLength = _file.Length;
+            }
+
             _currentFileLength += count;
             _file.Write(bytes, offset, count);
         }
diff --git a/src/NLog/Internal/FileAppenders/FileAppenderCache.cs b/src/NLog/Internal/FileAppenders/FileAppenderCache.cs
index a41b9f22b5..8b8e42735c 100644
--- a/src/NLog/Internal/FileAppenders/FileAppenderCache.cs
+++ b/src/NLog/Internal/FileAppenders/FileAppenderCache.cs
@@ -324,20 +324,17 @@ private BaseFileAppender CreateAppender(string fileName, int freeSpot)
         /// </summary>
         public void CloseAppenders(string reason)
         {
-            if (_appenders != null)
+            for (int i = 0; i < _appenders.Length; ++i)
             {
-                for (int i = 0; i < _appenders.Length; ++i)
+                var oldAppender = _appenders[i];
+                if (oldAppender == null)
                 {
-                    var oldAppender = _appenders[i];
-                    if (oldAppender == null)
-                    {
-                        break;
-                    }
-
-                    CloseAppender(oldAppender, reason, true);
-                    _appenders[i] = null;
-                    oldAppender.Dispose();  // Dispose of Archive Mutex
+                    break;
                 }
+
+                CloseAppender(oldAppender, reason, true);
+                _appenders[i] = null;
+                oldAppender.Dispose();  // Dispose of Archive Mutex
             }
         }
 
diff --git a/src/NLog/Internal/FileAppenders/ICreateFileParameters.cs b/src/NLog/Internal/FileAppenders/ICreateFileParameters.cs
index e9d490be21..485bc8201d 100644
--- a/src/NLog/Internal/FileAppenders/ICreateFileParameters.cs
+++ b/src/NLog/Internal/FileAppenders/ICreateFileParameters.cs
@@ -95,5 +95,10 @@ internal interface ICreateFileParameters
         /// Should archive mutex be created?
         /// </summary>
         bool IsArchivingEnabled { get; }
+
+        /// <summary>
+        /// Should manual simple detection of file deletion be enabled?
+        /// </summary>
+        bool EnableFileDeleteSimpleMonitor { get; }
     }
 }
diff --git a/src/NLog/Internal/FileAppenders/SingleProcessFileAppender.cs b/src/NLog/Internal/FileAppenders/SingleProcessFileAppender.cs
index 5e96428ecf..d366227741 100644
--- a/src/NLog/Internal/FileAppenders/SingleProcessFileAppender.cs
+++ b/src/NLog/Internal/FileAppenders/SingleProcessFileAppender.cs
@@ -49,6 +49,8 @@ internal class SingleProcessFileAppender : BaseFileAppender
         public static readonly IFileAppenderFactory TheFactory = new Factory();
 
         private FileStream _file;
+        private readonly bool _enableFileDeleteSimpleMonitor;
+        private DateTime _lastSimpleMonitorCheckTimeUtc;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="SingleProcessFileAppender" /> class.
@@ -58,6 +60,8 @@ internal class SingleProcessFileAppender : BaseFileAppender
         public SingleProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters)
         {
             _file = CreateFileStream(false);
+            _enableFileDeleteSimpleMonitor = parameters.EnableFileDeleteSimpleMonitor;
+            _lastSimpleMonitorCheckTimeUtc = OpenTimeUtc;
         }
 
         /// <summary>
@@ -73,6 +77,12 @@ public override void Write(byte[] bytes, int offset, int count)
                 return;
             }
 
+            if (_enableFileDeleteSimpleMonitor && MonitorForEnableFileDeleteEvent(FileName, ref _lastSimpleMonitorCheckTimeUtc))
+            {
+                _file.Dispose();
+                _file = CreateFileStream(false);
+            }
+
             _file.Write(bytes, offset, count);
         }
 
diff --git a/src/NLog/Internal/FileAppenders/WindowsMultiProcessFileAppender.cs b/src/NLog/Internal/FileAppenders/WindowsMultiProcessFileAppender.cs
index 8a79c5947d..26c92cb982 100644
--- a/src/NLog/Internal/FileAppenders/WindowsMultiProcessFileAppender.cs
+++ b/src/NLog/Internal/FileAppenders/WindowsMultiProcessFileAppender.cs
@@ -210,7 +210,7 @@ public override void Flush()
         public override long? GetFileLength()
         {
             var fileChars = GetFileCharacteristics();
-            return fileChars != null ? fileChars.FileLength : (long?)null;
+            return fileChars?.FileLength;
         }
 
         private FileCharacteristics GetFileCharacteristics()
diff --git a/src/NLog/Internal/FilePathLayout.cs b/src/NLog/Internal/FilePathLayout.cs
index 601ffb6558..1417f208a2 100644
--- a/src/NLog/Internal/FilePathLayout.cs
+++ b/src/NLog/Internal/FilePathLayout.cs
@@ -102,38 +102,54 @@ public FilePathLayout(Layout layout, bool cleanupInvalidChars, FilePathKind file
             //do we have to the the layout?
             if (cleanupInvalidChars || _filePathKind == FilePathKind.Unknown)
             {
-                //check if fixed 
-                var pathLayout2 = layout as SimpleLayout;
-                if (pathLayout2 != null)
-                {
-                    var isFixedText = pathLayout2.IsFixedText;
-                    if (isFixedText)
-                    {
-                        _cleanedFixedResult = pathLayout2.FixedText;
-                        if (cleanupInvalidChars)
-                        {
-                            //clean first
-                            _cleanedFixedResult = CleanupInvalidFilePath(_cleanedFixedResult);
-                        }
-                    }
+                _cleanedFixedResult = CreateCleanedFixedResult(cleanupInvalidChars, layout);
+                _filePathKind = DetectKind(layout, _filePathKind);
+            }
 
-                    //detect absolute
-                    if (_filePathKind == FilePathKind.Unknown)
-                    {
-                        _filePathKind = DetectFilePathKind(pathLayout2);
-                    }
-                }
-                else
+            if (_filePathKind == FilePathKind.Relative)
+            {
+                _baseDir = LogFactory.CurrentAppDomain.BaseDirectory;
+            }
+
+        }
+
+        private static FilePathKind DetectKind(Layout layout, FilePathKind currentFilePathKind)
+        {
+            if (layout is SimpleLayout simpleLayout)
+            {
+                //detect absolute
+                if (currentFilePathKind == FilePathKind.Unknown)
                 {
-                    _filePathKind = FilePathKind.Unknown;
+                    return DetectFilePathKind(simpleLayout);
                 }
             }
+            else
+            {
+                return FilePathKind.Unknown;
+            }
 
-            if (_filePathKind == FilePathKind.Relative)
+            return currentFilePathKind;
+        }
+
+        private static string CreateCleanedFixedResult(bool cleanupInvalidChars, Layout layout)
+        {
+            if (layout is SimpleLayout simpleLayout)
             {
-                _baseDir = LogFactory.CurrentAppDomain.BaseDirectory;
+                var isFixedText = simpleLayout.IsFixedText;
+                if (isFixedText)
+                {
+                    var cleanedFixedResult = simpleLayout.FixedText;
+                    if (cleanupInvalidChars)
+                    {
+                        //clean first
+                        cleanedFixedResult = CleanupInvalidFilePath(cleanedFixedResult);
+                    }
+
+                    return cleanedFixedResult;
+                }
             }
 
+            return null;
         }
 
         public Layout GetLayout()
@@ -174,11 +190,10 @@ private string GetRenderedFileName(LogEventInfo logEvent, System.Text.StringBuil
 
                 _layout.RenderAppendBuilder(logEvent, reusableBuilder);
 
-                if (_cachedPrevRawFileName != null)
+                if (_cachedPrevRawFileName != null && reusableBuilder.EqualTo(_cachedPrevRawFileName))
                 {
                     // If old filename matches the newly rendered, then no need to call StringBuilder.ToString()
-                    if (reusableBuilder.EqualTo(_cachedPrevRawFileName))
-                        return _cachedPrevRawFileName;
+                    return _cachedPrevRawFileName;
                 }
 
                 _cachedPrevRawFileName = reusableBuilder.ToString();
@@ -226,7 +241,7 @@ public string Render(LogEventInfo logEvent)
         }
 
         internal string RenderWithBuilder(LogEventInfo logEvent, System.Text.StringBuilder reusableBuilder = null)
-        { 
+        {
             var rawFileName = GetRenderedFileName(logEvent, reusableBuilder);
             if (string.IsNullOrEmpty(rawFileName))
             {
@@ -252,13 +267,13 @@ internal string RenderWithBuilder(LogEventInfo logEvent, System.Text.StringBuild
         /// </summary>
         internal static FilePathKind DetectFilePathKind(Layout pathLayout)
         {
-            var simpleLayout = pathLayout as SimpleLayout;
-            if (simpleLayout == null)
+            if (pathLayout is SimpleLayout simpleLayout)
             {
-                return FilePathKind.Unknown;
+                return DetectFilePathKind(simpleLayout);
             }
 
-            return DetectFilePathKind(simpleLayout);
+            return FilePathKind.Unknown;
+
         }
 
         /// <summary>
@@ -283,7 +298,7 @@ internal static FilePathKind DetectFilePathKind(string path, bool isFixedText =
                 if (length >= 1)
                 {
                     var firstChar = path[0];
-                    if (firstChar == Path.DirectorySeparatorChar || firstChar == Path.AltDirectorySeparatorChar)
+                    if (IsAbsoluteStartChar(firstChar))
                         return FilePathKind.Absolute;
 
                     if (firstChar == '.') //. and ..
@@ -299,7 +314,7 @@ internal static FilePathKind DetectFilePathKind(string path, bool isFixedText =
                             return FilePathKind.Absolute;
                     }
 
-                    if (!isFixedText && path.StartsWith("${", StringComparison.OrdinalIgnoreCase))
+                    if (IsLayoutRenderer(path, isFixedText))
                     {
                         //if first part is a layout, then unknown
                         return FilePathKind.Unknown;
@@ -312,6 +327,16 @@ internal static FilePathKind DetectFilePathKind(string path, bool isFixedText =
             return FilePathKind.Unknown;
         }
 
+        private static bool IsLayoutRenderer(string path, bool isFixedText)
+        {
+            return !isFixedText && path.StartsWith("${", StringComparison.OrdinalIgnoreCase);
+        }
+
+        private static bool IsAbsoluteStartChar(char firstChar)
+        {
+            return firstChar == Path.DirectorySeparatorChar || firstChar == Path.AltDirectorySeparatorChar;
+        }
+
         private static string CleanupInvalidFilePath(string filePath)
         {
 #if !SILVERLIGHT || WINDOWS_PHONE
diff --git a/src/NLog/Internal/LoggerConfiguration.cs b/src/NLog/Internal/LoggerConfiguration.cs
index 39abc87794..919eacbeef 100644
--- a/src/NLog/Internal/LoggerConfiguration.cs
+++ b/src/NLog/Internal/LoggerConfiguration.cs
@@ -46,9 +46,8 @@ internal class LoggerConfiguration
         /// Initializes a new instance of the <see cref="LoggerConfiguration" /> class.
         /// </summary>
         /// <param name="targetsByLevel">The targets by level.</param>
-        /// <param name="exceptionLoggingOldStyle">  Use the old exception log handling of NLog 3.0? 
-        /// </param>
-        public LoggerConfiguration(TargetWithFilterChain[] targetsByLevel, bool exceptionLoggingOldStyle = false)
+        /// <param name="exceptionLoggingOldStyle">  Use the old exception log handling of NLog 3.0?</param>
+        public LoggerConfiguration(TargetWithFilterChain[] targetsByLevel, bool exceptionLoggingOldStyle)
         {
             _targetsByLevel = targetsByLevel;
 #pragma warning disable 618
@@ -61,7 +60,7 @@ public LoggerConfiguration(TargetWithFilterChain[] targetsByLevel, bool exceptio
         /// </summary>
         /// <remarks>This method was marked as obsolete before NLog 4.3.11 and it  will be removed in NLog 5.</remarks>
         [Obsolete("This property marked obsolete before v4.3.11 and it will be removed in NLog 5.")]
-        public bool ExceptionLoggingOldStyle { get; private set; }
+        public bool ExceptionLoggingOldStyle { get; }
 
         /// <summary>
         /// Gets targets for the specified level.
@@ -74,24 +73,7 @@ public TargetWithFilterChain GetTargetsForLevel(LogLevel level)
             {
                 return null;
             }
-
             return _targetsByLevel[level.Ordinal];
         }
-
-        /// <summary>
-        /// Determines whether the specified level is enabled.
-        /// </summary>
-        /// <param name="level">The level.</param>
-        /// <returns>
-        /// A value of <c>true</c> if the specified level is enabled; otherwise, <c>false</c>.
-        /// </returns>
-        public bool IsEnabled(LogLevel level)
-        {
-            if (level == LogLevel.Off)
-            {
-                return false;
-            }
-            return _targetsByLevel[level.Ordinal] != null;
-        }
     }
 }
diff --git a/src/NLog/Internal/MruCache.cs b/src/NLog/Internal/MruCache.cs
index 1ec56eb590..99669e1449 100644
--- a/src/NLog/Internal/MruCache.cs
+++ b/src/NLog/Internal/MruCache.cs
@@ -115,7 +115,7 @@ private void PruneCache()
 
                 oldestGeneration = long.MaxValue;
 
-                long elementGeneration = 0;
+                long elementGeneration;
                 foreach (var element in _dictionary)
                 {
                     elementGeneration = element.Value.Version;
diff --git a/src/NLog/Internal/MultiFileWatcher.cs b/src/NLog/Internal/MultiFileWatcher.cs
index ce36264a88..7dc3f82af1 100644
--- a/src/NLog/Internal/MultiFileWatcher.cs
+++ b/src/NLog/Internal/MultiFileWatcher.cs
@@ -131,7 +131,7 @@ internal void Watch(string fileName)
             var directory = Path.GetDirectoryName(fileName);
             if (!Directory.Exists(directory))
             {
-                InternalLogger.Warn("Cannot watch {0} for changes as it doesn't exist", directory);
+                InternalLogger.Warn("Cannot watch file {0} for changes as directory {1} doesn't exist", fileName, directory);
                 return;
             }
 
diff --git a/src/NLog/Internal/NetworkSenders/TcpNetworkSender.cs b/src/NLog/Internal/NetworkSenders/TcpNetworkSender.cs
index 75cfe29951..841a536966 100644
--- a/src/NLog/Internal/NetworkSenders/TcpNetworkSender.cs
+++ b/src/NLog/Internal/NetworkSenders/TcpNetworkSender.cs
@@ -319,15 +319,12 @@ private void SocketOperationCompleted(object sender, SocketAsyncEventArgs e)
 
                 if (e.SocketError != SocketError.Success)
                 {
-                    _pendingError = new IOException($"Error: " + e.SocketError);
+                    _pendingError = new IOException("Error: " + e.SocketError);
                 }
 
                 e.Dispose();
 
-                if (asyncContinuation != null)
-                {
-                    asyncContinuation(_pendingError);
-                }
+                asyncContinuation?.Invoke(_pendingError);
             }
 
             ProcessNextQueuedItem();
diff --git a/src/NLog/Internal/ObjectReflectionCache.cs b/src/NLog/Internal/ObjectReflectionCache.cs
index 3635118516..418f63242f 100644
--- a/src/NLog/Internal/ObjectReflectionCache.cs
+++ b/src/NLog/Internal/ObjectReflectionCache.cs
@@ -53,6 +53,34 @@ internal class ObjectReflectionCache
 
         public ObjectPropertyList LookupObjectProperties(object value)
         {
+            if (TryLookupExpandoObject(value, out var propertyValues))
+            {
+                return propertyValues;
+            }
+
+            var objectType = value.GetType();
+            var propertyInfos = BuildObjectPropertyInfos(value, objectType);
+            _objectTypeCache.TryAddValue(objectType, propertyInfos);
+            return new ObjectPropertyList(value, propertyInfos.Properties, propertyInfos.FastLookup);
+        }
+
+        public bool TryLookupExpandoObject(object value, out ObjectPropertyList objectPropertyList)
+        {
+            if (value is IDictionary<string, object> expando)
+            {
+                objectPropertyList = new ObjectPropertyList(expando);
+                return true;
+            }
+
+#if DYNAMIC_OBJECT
+            if (value is DynamicObject d)
+            {
+                var dictionary = DynamicObjectToDict(d);
+                objectPropertyList = new ObjectPropertyList(dictionary);
+                return true;
+            }
+#endif
+
             Type objectType = value.GetType();
             if (_objectTypeCache.TryGetValue(objectType, out var propertyInfos))
             {
@@ -62,7 +90,8 @@ public ObjectPropertyList LookupObjectProperties(object value)
                     propertyInfos = new ObjectPropertyInfos(propertyInfos.Properties, fastLookup);
                     _objectTypeCache.TryAddValue(objectType, propertyInfos);
                 }
-                return new ObjectPropertyList(value, propertyInfos.Properties, propertyInfos.FastLookup);
+                objectPropertyList = new ObjectPropertyList(value, propertyInfos.Properties, propertyInfos.FastLookup);
+                return true;
             }
 
             if (_objectTypeOverride.Count > 0)
@@ -74,32 +103,53 @@ public ObjectPropertyList LookupObjectProperties(object value)
                     {
                         var objectProperties = objectReflection.Invoke(value);
                         if (objectProperties?.Count > 0)
-                            return new ObjectPropertyList(objectProperties);
+                        {
+                            objectPropertyList = new ObjectPropertyList(objectProperties);
+                            return true;
+                        }
 
                         // object.ToString() since no properties
                         propertyInfos = ObjectPropertyInfos.SimpleToString;
-                        return new ObjectPropertyList(value, propertyInfos.Properties, propertyInfos.FastLookup);
+                        objectPropertyList = new ObjectPropertyList(value, propertyInfos.Properties, propertyInfos.FastLookup);
+                        return true;
                     }
                 }
             }
 
-#if DYNAMIC_OBJECT
-            if (value is DynamicObject d)
+            if (TryExtractExpandoObject(objectType, out propertyInfos))
             {
-                var dictionary = DynamicObjectToDict(d);
-                return new ObjectPropertyList(dictionary);
+                _objectTypeCache.TryAddValue(objectType, propertyInfos);
+                objectPropertyList = new ObjectPropertyList(value, propertyInfos.Properties, propertyInfos.FastLookup);
+                return true;
             }
-#endif
 
-            propertyInfos = BuildObjectPropertyInfos(value, objectType);
-            _objectTypeCache.TryAddValue(objectType, propertyInfos);
-            return new ObjectPropertyList(value, propertyInfos.Properties, propertyInfos.FastLookup);
+            objectPropertyList = default(ObjectPropertyList);
+            return false;
+        }
+
+        private static bool TryExtractExpandoObject(Type objectType, out ObjectPropertyInfos propertyInfos)
+        {
+            foreach (var interfaceType in objectType.GetInterfaces())
+            {
+                if (interfaceType.IsGenericType() && interfaceType.GetGenericTypeDefinition() == typeof(IDictionary<,>))
+                {
+                    if (interfaceType.GetGenericArguments()[0] == typeof(string))
+                    {
+                        var dictionaryEnumerator = (IDictionaryEnumerator)Activator.CreateInstance(typeof(DictionaryEnumerator<,>).MakeGenericType(interfaceType.GetGenericArguments()));
+                        propertyInfos = new ObjectPropertyInfos(null, new[] { new FastPropertyLookup(string.Empty, TypeCode.Object, (o, p) => dictionaryEnumerator.GetEnumerator(o)) });
+                        return true;
+                    }
+                }
+            }
+
+            propertyInfos = default(ObjectPropertyInfos);
+            return false;
         }
 
         private static ObjectPropertyInfos BuildObjectPropertyInfos(object value, Type objectType)
         {
             ObjectPropertyInfos propertyInfos;
-            if (ConvertToString(objectType))
+            if (ConvertSimpleToString(objectType))
             {
                 propertyInfos = ObjectPropertyInfos.SimpleToString;
             }
@@ -125,12 +175,9 @@ private static ObjectPropertyInfos BuildObjectPropertyInfos(object value, Type o
             return propertyInfos;
         }
 
-        private static bool ConvertToString(Type objectType)
+        private static bool ConvertSimpleToString(Type objectType)
         {
-            if (objectType == typeof(Guid))
-                return true;
-
-            if (objectType == typeof(TimeSpan))
+            if (typeof(IFormattable).IsAssignableFrom(objectType))
                 return true;
 
             if (typeof(Uri).IsAssignableFrom(objectType))
@@ -206,16 +253,18 @@ private static FastPropertyLookup[] BuildFastLookup(PropertyInfo[] properties, b
 
         public struct ObjectPropertyList : IEnumerable<ObjectPropertyList.PropertyValue>
         {
+            internal static readonly StringComparer NameComparer = StringComparer.Ordinal;
+            private static readonly FastPropertyLookup[] CreateIDictionaryEnumerator = new[] { new FastPropertyLookup(string.Empty, TypeCode.Object, (o, p) => ((IDictionary<string, object>)o).GetEnumerator()) };
             private readonly object _object;
             private readonly PropertyInfo[] _properties;
-            private readonly ObjectReflectionCache.FastPropertyLookup[] _fastLookup;
+            private readonly FastPropertyLookup[] _fastLookup;
 
             public struct PropertyValue
             {
-                readonly public string Name;
-                readonly public object Value;
-                public TypeCode TypeCode => _typecode == TypeCode.Object ? Convert.GetTypeCode(Value) : (Value == null ? TypeCode.Empty : _typecode);
-                readonly private TypeCode _typecode;
+                public readonly string Name;
+                public readonly object Value;
+                public TypeCode TypeCode => Value == null ? TypeCode.Empty : _typecode;
+                private readonly TypeCode _typecode;
 
                 public PropertyValue(string name, object value, TypeCode typeCode)
                 {
@@ -223,9 +272,23 @@ public PropertyValue(string name, object value, TypeCode typeCode)
                     Value = value;
                     _typecode = typeCode;
                 }
+
+                public PropertyValue(object owner, PropertyInfo propertyInfo)
+                {
+                    Name = propertyInfo.Name;
+                    Value = propertyInfo.GetValue(owner, null);
+                    _typecode = TypeCode.Object;
+                }
+
+                public PropertyValue(object owner, FastPropertyLookup fastProperty)
+                {
+                    Name = fastProperty.Name;
+                    Value = fastProperty.ValueLookup(owner, null);
+                    _typecode = fastProperty.TypeCode;
+                }
             }
 
-            public int Count => _fastLookup?.Length ?? _properties?.Length ?? (_object as ICollection)?.Count ?? (_object as ICollection<KeyValuePair<string, object>>)?.Count ?? 0;
+            public bool ConvertToString => _properties?.Length == 0;
 
             internal ObjectPropertyList(object value, PropertyInfo[] properties, FastPropertyLookup[] fastLookup)
             {
@@ -238,7 +301,88 @@ public ObjectPropertyList(IDictionary<string, object> value)
             {
                 _object = value;    // Expando objects
                 _properties = null;
-                _fastLookup = null;
+                _fastLookup = CreateIDictionaryEnumerator;
+            }
+
+            public bool TryGetPropertyValue(string name, out PropertyValue propertyValue)
+            {
+                if (_properties != null)
+                {
+                    if (_fastLookup != null)
+                    {
+                        return TryFastLookupPropertyValue(name, out propertyValue);
+                    }
+                    else
+                    {
+                        return TrySlowLookupPropertyValue(name, out propertyValue);
+                    }
+                }
+                else if (_object is IDictionary<string, object> expandoObject)
+                {
+                    if (expandoObject.TryGetValue(name, out var objectValue))
+                    {
+                        propertyValue = new PropertyValue(name, objectValue, TypeCode.Object);
+                        return true;
+                    }
+                    propertyValue = default(PropertyValue);
+                    return false;
+                }
+                else
+                {
+                    return TryListLookupPropertyValue(name, out propertyValue);
+                }
+            }
+
+            /// <summary>
+            /// Scans properties for name (Skips string-compare and value-lookup until finding match)
+            /// </summary>
+            private bool TryFastLookupPropertyValue(string name, out PropertyValue propertyValue)
+            {
+                int nameHashCode = NameComparer.GetHashCode(name);
+                foreach (var fastProperty in _fastLookup)
+                {
+                    if (fastProperty.NameHashCode == nameHashCode && NameComparer.Equals(fastProperty.Name, name))
+                    {
+                        propertyValue = new PropertyValue(_object, fastProperty);
+                        return true;
+                    }
+                }
+                propertyValue = default(PropertyValue);
+                return false;
+            }
+
+            /// <summary>
+            /// Scans properties for name (Skips property value lookup until finding match)
+            /// </summary>
+            private bool TrySlowLookupPropertyValue(string name, out PropertyValue propertyValue)
+            {
+                foreach (var propInfo in _properties)
+                {
+                    if (NameComparer.Equals(propInfo.Name, name))
+                    {
+                        propertyValue = new PropertyValue(_object, propInfo);
+                        return true;
+                    }
+                }
+                propertyValue = default(PropertyValue);
+                return false;
+            }
+
+            /// <summary>
+            /// Scans properties for name
+            /// </summary>
+            private bool TryListLookupPropertyValue(string name, out PropertyValue propertyValue)
+            {
+                foreach (var item in this)
+                {
+                    if (NameComparer.Equals(item.Name, name))
+                    {
+                        propertyValue = item;
+                        return true;
+                    }
+                }
+                propertyValue = default(PropertyValue);
+                return false;
             }
 
             public override string ToString()
@@ -251,7 +395,7 @@ public Enumerator GetEnumerator()
                 if (_properties != null)
                     return new Enumerator(_object, _properties, _fastLookup);
                 else
-                    return new Enumerator((_object as IDictionary<string, object>).GetEnumerator());
+                    return new Enumerator((IEnumerator<KeyValuePair<string, object>>)_fastLookup[0].ValueLookup(_object, null));
             }
 
             IEnumerator<PropertyValue> IEnumerable<PropertyValue>.GetEnumerator() => GetEnumerator();
@@ -290,9 +434,9 @@ public PropertyValue Current
                         try
                         {
                             if (_fastLookup != null)
-                                return new PropertyValue(_fastLookup[_index].Name, _fastLookup[_index].ValueLookup(_owner, null), _fastLookup[_index].TypeCode);
+                                return new PropertyValue(_owner, _fastLookup[_index]);
                             else if (_properties != null)
-                                return new PropertyValue(_properties[_index].Name, _properties[_index].GetValue(_owner, null), TypeCode.Object);
+                                return new PropertyValue(_owner, _properties[_index]);
                             else
                                 return new PropertyValue(_enumerator.Current.Key, _enumerator.Current.Value, TypeCode.Object);
                         }
@@ -334,12 +478,14 @@ internal struct FastPropertyLookup
             public readonly string Name;
             public readonly ReflectionHelpers.LateBoundMethod ValueLookup;
             public readonly TypeCode TypeCode;
+            public readonly int NameHashCode;
 
             public FastPropertyLookup(string name, TypeCode typeCode, ReflectionHelpers.LateBoundMethod valueLookup)
             {
                 Name = name;
                 ValueLookup = valueLookup;
                 TypeCode = typeCode;
+                NameHashCode = ObjectPropertyList.NameComparer.GetHashCode(name);
             }
         }
 
@@ -396,5 +542,30 @@ public override DynamicMetaObject FallbackGetMember(DynamicMetaObject target, Dy
             }
         }
 #endif
+
+        private interface IDictionaryEnumerator
+        {
+            IEnumerator<KeyValuePair<string,object>> GetEnumerator(object value);
+        }
+
+        private static readonly IDictionary<string, object> EmptyDictionary = new NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary<string, object>();
+
+        internal sealed class DictionaryEnumerator<TKey, TValue> : IDictionaryEnumerator
+        {
+            public IEnumerator<KeyValuePair<string, object>> GetEnumerator(object value)
+            {
+                if (value is IDictionary<TKey, TValue> dictionary)
+                {
+                    return YieldEnumerator(dictionary);
+                }
+                return EmptyDictionary.GetEnumerator();
+            }
+
+            private IEnumerator<KeyValuePair<string, object>> YieldEnumerator(IDictionary<TKey,TValue> dictionary)
+            {
+                foreach (var item in dictionary)
+                    yield return new KeyValuePair<string, object>(item.Key.ToString(), item.Value);
+            }
+        }
     }
 }
diff --git a/src/NLog/Internal/PropertiesDictionary.cs b/src/NLog/Internal/PropertiesDictionary.cs
index 59a6881872..cd486266b2 100644
--- a/src/NLog/Internal/PropertiesDictionary.cs
+++ b/src/NLog/Internal/PropertiesDictionary.cs
@@ -466,15 +466,7 @@ protected MessageTemplateParameter CurrentParameter
                     }
                     if (_eventEnumeratorCreated)
                     {
-                        string parameterName;
-                        try
-                        {
-                            parameterName = XmlHelper.XmlConvertToString(_eventEnumerator.Current.Key ?? string.Empty);
-                        }
-                        catch
-                        {
-                            parameterName = "";
-                        }
+                        string parameterName = XmlHelper.XmlConvertToString(_eventEnumerator.Current.Key ?? string.Empty) ?? string.Empty;
                         return new MessageTemplateParameter(parameterName, _eventEnumerator.Current.Value.Value, null, CaptureType.Unknown);
                     }
                     throw new InvalidOperationException();
@@ -495,7 +487,7 @@ public bool MoveNext()
                         _messagePropertiesEnumerator = _dictionary._eventProperties.Count - 1;
                     }
 
-                    if (_dictionary._eventProperties != null && _dictionary._eventProperties.Count > 0)
+                    if (HasEventProperties(_dictionary))
                     {
                         _messagePropertiesEnumerator = null;
                         _eventEnumerator = _dictionary._eventProperties.GetEnumerator();
@@ -509,7 +501,7 @@ public bool MoveNext()
                 {
                     return MoveNextValidEventProperty();
                 }
-                if (_dictionary._messageProperties != null && _dictionary._messageProperties.Count > 0)
+                if (HasMessageProperties(_dictionary))
                 {
                     // Move forward to a key that is not overriden
                     _messagePropertiesEnumerator = FindNextValidMessagePropertyIndex(0);
@@ -519,7 +511,7 @@ public bool MoveNext()
                     }
                 }
 
-                if (_dictionary._eventProperties != null && _dictionary._eventProperties.Count > 0)
+                if (HasEventProperties(_dictionary))
                 {
                     _eventEnumerator = _dictionary._eventProperties.GetEnumerator();
                     _eventEnumeratorCreated = true;
@@ -529,6 +521,16 @@ public bool MoveNext()
                 return false;
             }
 
+            private static bool HasMessageProperties(PropertiesDictionary propertiesDictionary)
+            {
+                return propertiesDictionary._messageProperties != null && propertiesDictionary._messageProperties.Count > 0;
+            }
+
+            private static bool HasEventProperties(PropertiesDictionary propertiesDictionary)
+            {
+                return propertiesDictionary._eventProperties != null && propertiesDictionary._eventProperties.Count > 0;
+            }
+
             private bool MoveNextValidEventProperty()
             {
                 while (_eventEnumerator.MoveNext())
diff --git a/src/NLog/Internal/PropertyHelper.cs b/src/NLog/Internal/PropertyHelper.cs
index bc9aadda9a..f9138a1082 100644
--- a/src/NLog/Internal/PropertyHelper.cs
+++ b/src/NLog/Internal/PropertyHelper.cs
@@ -260,9 +260,9 @@ private static bool TryGetEnumValue(Type resultType, string value, out object re
             {
                 ulong union = 0;
 
-                foreach (string v in value.Split(','))
+                foreach (string v in value.SplitAndTrimTokens(','))
                 {
-                    FieldInfo enumField = resultType.GetField(v.Trim(), BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.FlattenHierarchy | BindingFlags.Public);
+                    FieldInfo enumField = resultType.GetField(v, BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.FlattenHierarchy | BindingFlags.Public);
                     if (enumField == null)
                     {
                         throw new NLogConfigurationException($"Invalid enumeration value '{value}'.");
@@ -330,27 +330,24 @@ private static bool TrySpecialConversion(Type type, string value, out object new
         /// <returns></returns>
         private static bool TryFlatListConversion(Type type, string valueRaw, out object newValue)
         {
-            if (type.IsGenericType())
+            if (type.IsGenericType() && TryCreateCollectionObject(type, valueRaw, out var newList, out var collectionAddMethod, out var propertyType))
             {
-                if (TryCreateCollectionObject(type, valueRaw, out var newList, out var collectionAddMethod, out var propertyType))
+                var values = valueRaw.SplitQuoted(',', '\'', '\\');
+                foreach (var value in values)
                 {
-                    var values = valueRaw.SplitQuoted(',', '\'', '\\');
-                    foreach (var value in values)
+                    if (!(TryGetEnumValue(propertyType, value, out newValue, false)
+                          || TrySpecialConversion(propertyType, value, out newValue)
+                          || TryImplicitConversion(propertyType, value, out newValue)
+                          || TryTypeConverterConversion(propertyType, value, out newValue)))
                     {
-                        if (!(TryGetEnumValue(propertyType, value, out newValue, false)
-                               || TrySpecialConversion(propertyType, value, out newValue)
-                               || TryImplicitConversion(propertyType, value, out newValue)
-                               || TryTypeConverterConversion(propertyType, value, out newValue)))
-                        {
-                            newValue = Convert.ChangeType(value, propertyType, CultureInfo.InvariantCulture);
-                        }
-
-                        collectionAddMethod.Invoke(newList, new object[] { newValue });
+                        newValue = Convert.ChangeType(value, propertyType, CultureInfo.InvariantCulture);
                     }
 
-                    newValue = newList;
-                    return true;
+                    collectionAddMethod.Invoke(newList, new object[] { newValue });
                 }
+
+                newValue = newList;
+                return true;
             }
 
             newValue = null;
diff --git a/src/NLog/Internal/SortHelpers.cs b/src/NLog/Internal/SortHelpers.cs
index 4d0908b6a9..0242f78cf1 100644
--- a/src/NLog/Internal/SortHelpers.cs
+++ b/src/NLog/Internal/SortHelpers.cs
@@ -69,8 +69,7 @@ internal static class SortHelpers
             foreach (var input in inputs)
             {
                 var keyValue = keySelector(input);
-                List<TValue> eventsInBucket;
-                if (!buckets.TryGetValue(keyValue, out eventsInBucket))
+                if (!buckets.TryGetValue(keyValue, out var eventsInBucket))
                 {
                     eventsInBucket = new List<TValue>();
                     buckets.Add(keyValue, eventsInBucket);
@@ -126,22 +125,12 @@ internal static class SortHelpers
                     if (!keyComparer.Equals(singleBucketKey, keyValue))
                     {
                         // Multiple buckets needed, allocate full dictionary
-                        buckets = new Dictionary<TKey, IList<TValue>>(keyComparer);
-                        var bucket = new List<TValue>(i);
-                        for (int j = 0; j < i; j++)
-                        {
-                            bucket.Add(inputs[j]);
-                        }
-                        buckets[singleBucketKey] = bucket;
-                        bucket = new List<TValue>();
-                        bucket.Add(inputs[i]);
-                        buckets[keyValue] = bucket;
+                        buckets = CreateBucketDictionaryWithValue(inputs, keyComparer, i, singleBucketKey, keyValue);
                     }
                 }
                 else
                 {
-                    IList<TValue> eventsInBucket;
-                    if (!buckets.TryGetValue(keyValue, out eventsInBucket))
+                    if (!buckets.TryGetValue(keyValue, out var eventsInBucket))
                     {
                         eventsInBucket = new List<TValue>();
                         buckets.Add(keyValue, eventsInBucket);
@@ -160,6 +149,21 @@ internal static class SortHelpers
             }
         }
 
+        private static Dictionary<TKey, IList<TValue>> CreateBucketDictionaryWithValue<TValue, TKey>(IList<TValue> inputs, IEqualityComparer<TKey> keyComparer, int currentIndex, TKey singleBucketKey, TKey keyValue)
+        {
+            var buckets = new Dictionary<TKey, IList<TValue>>(keyComparer);
+            var bucket = new List<TValue>(currentIndex);
+            for (int i = 0; i < currentIndex; i++)
+            {
+                bucket.Add(inputs[i]);
+            }
+
+            buckets[singleBucketKey] = bucket;
+            bucket = new List<TValue> {inputs[currentIndex]};
+            buckets[keyValue] = bucket;
+            return buckets;
+        }
+
         /// <summary>
         /// Single-Bucket optimized readonly dictionary. Uses normal internally Dictionary if multiple buckets are needed.
         ///
diff --git a/src/NLog/Internal/StackTraceUsageUtils.cs b/src/NLog/Internal/StackTraceUsageUtils.cs
index 66f4e840be..8ab989b14e 100644
--- a/src/NLog/Internal/StackTraceUsageUtils.cs
+++ b/src/NLog/Internal/StackTraceUsageUtils.cs
@@ -156,7 +156,7 @@ public static string GetClassFullName()
             className = GetClassFullName(stackFrame);
 #else
             var stackTrace = Environment.StackTrace;
-            var stackTraceLines = stackTrace.Replace("\r", "").Split(new[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
+            var stackTraceLines = stackTrace.Replace("\r", "").SplitAndTrimTokens('\n');
             for (int i = 0; i < stackTraceLines.Length; ++i)
             {
                 var callingClassAndMethod = stackTraceLines[i].Split(new[] { " ", "<>", "(", ")" }, StringSplitOptions.RemoveEmptyEntries)[1];
diff --git a/src/NLog/Internal/StringBuilderExt.cs b/src/NLog/Internal/StringBuilderExt.cs
index 87150ccfd6..c489928b0e 100644
--- a/src/NLog/Internal/StringBuilderExt.cs
+++ b/src/NLog/Internal/StringBuilderExt.cs
@@ -32,6 +32,7 @@
 // 
 
 using System;
+using System.Globalization;
 using System.IO;
 using System.Text;
 using NLog.MessageTemplates;
@@ -157,7 +158,7 @@ public static void CopyToStream(this StringBuilder builder, MemoryStream ms, Enc
 #if !SILVERLIGHT
             if (transformBuffer != null)
             {
-                int charCount = 0;
+                int charCount;
                 int byteCount = encoding.GetMaxByteCount(builder.Length);
                 ms.SetLength(ms.Position + byteCount);
                 for (int i = 0; i < builder.Length; i += transformBuffer.Length)
@@ -333,28 +334,28 @@ internal static void Append4DigitsZeroPadded(this StringBuilder builder, int num
         /// <summary>
         /// Apend a int type (byte, int) as string
         /// </summary>
-        internal static void AppendIntegerAsString(this StringBuilder sb, object value, TypeCode objTypeCode)
+        internal static void AppendIntegerAsString(this StringBuilder sb, IConvertible value, TypeCode objTypeCode)
         {
             switch (objTypeCode)
             {
-                case TypeCode.Byte: sb.AppendInvariant((byte)value); break;
-                case TypeCode.SByte: sb.AppendInvariant((sbyte)value); break;
-                case TypeCode.Int16: sb.AppendInvariant((short)value); break;
-                case TypeCode.Int32: sb.AppendInvariant((int)value); break;
+                case TypeCode.Byte: sb.AppendInvariant(value.ToByte(CultureInfo.InvariantCulture)); break;
+                case TypeCode.SByte: sb.AppendInvariant(value.ToSByte(CultureInfo.InvariantCulture)); break;
+                case TypeCode.Int16: sb.AppendInvariant(value.ToInt16(CultureInfo.InvariantCulture)); break;
+                case TypeCode.Int32: sb.AppendInvariant(value.ToInt32(CultureInfo.InvariantCulture)); break;
                 case TypeCode.Int64:
                     {
-                        long int64 = (long)value;
+                        long int64 = value.ToInt64(CultureInfo.InvariantCulture);
                         if (int64 < int.MaxValue && int64 > int.MinValue)
                             sb.AppendInvariant((int)int64);
                         else
                             sb.Append(int64);
                     }
                     break;
-                case TypeCode.UInt16: sb.AppendInvariant((ushort)value); break;
-                case TypeCode.UInt32: sb.AppendInvariant((uint)value); break;
+                case TypeCode.UInt16: sb.AppendInvariant(value.ToUInt16(CultureInfo.InvariantCulture)); break;
+                case TypeCode.UInt32: sb.AppendInvariant(value.ToUInt32(CultureInfo.InvariantCulture)); break;
                 case TypeCode.UInt64:
                     {
-                        ulong uint64 = (ulong)value;
+                        ulong uint64 = value.ToUInt64(CultureInfo.InvariantCulture);
                         if (uint64 < uint.MaxValue)
                             sb.AppendInvariant((uint)uint64);
                         else
diff --git a/src/NLog/Internal/StringBuilderPool.cs b/src/NLog/Internal/StringBuilderPool.cs
index 69348e21d5..7195d30d5e 100644
--- a/src/NLog/Internal/StringBuilderPool.cs
+++ b/src/NLog/Internal/StringBuilderPool.cs
@@ -99,12 +99,10 @@ private void Release(StringBuilder stringBuilder, int poolIndex)
                 {
                     stringBuilder = new StringBuilder(maxBuilderCapacity / 2);
                 }
-            } 
-            else
-            {
-                stringBuilder.Length = 0;
             }
 
+            stringBuilder.Length = 0;
+
             if (poolIndex == -1)
             {
                 _fastPool = stringBuilder;
diff --git a/src/NLog/Internal/StringHelpers.cs b/src/NLog/Internal/StringHelpers.cs
index c2d410d874..c1a80ffb63 100644
--- a/src/NLog/Internal/StringHelpers.cs
+++ b/src/NLog/Internal/StringHelpers.cs
@@ -32,7 +32,6 @@
 // 
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using JetBrains.Annotations;
 
@@ -51,7 +50,6 @@ public static class StringHelpers
         [ContractAnnotation("value:null => true")]
         internal static bool IsNullOrWhiteSpace(string value)
         {
-
 #if NET3_5
 
             if (value == null) return true;
@@ -61,5 +59,25 @@ internal static bool IsNullOrWhiteSpace(string value)
             return string.IsNullOrWhiteSpace(value);
 #endif
         }
+
+        internal static string[] SplitAndTrimTokens(this string value, char delimiter)
+        {
+            if (IsNullOrWhiteSpace(value))
+                return ArrayHelper.Empty<string>();
+
+            if (value.IndexOf(delimiter) == -1)
+            {
+                return new[] { value.Trim() };
+            }
+
+            var result = value.Split(new char[] { delimiter }, StringSplitOptions.RemoveEmptyEntries);
+            for (int i = 0; i < result.Length; ++i)
+            {
+                result[i] = result[i].Trim();
+                if (string.IsNullOrEmpty(result[i]))
+                    return result.Where(s => !IsNullOrWhiteSpace(s)).Select(s => s.Trim()).ToArray();
+            }
+            return result;
+        }
     }
 }
diff --git a/src/NLog/Internal/ThreadSafeDictionary.cs b/src/NLog/Internal/ThreadSafeDictionary.cs
new file mode 100644
index 0000000000..811576600c
--- /dev/null
+++ b/src/NLog/Internal/ThreadSafeDictionary.cs
@@ -0,0 +1,230 @@
+// 
+// Copyright (c) 2004-2019 Jaroslaw Kowalski <jaak@jkowalski.net>, Kim Christensen, Julian Verdurmen
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without 
+// modification, are permitted provided that the following conditions 
+// are met:
+// 
+// * Redistributions of source code must retain the above copyright notice, 
+//   this list of conditions and the following disclaimer. 
+// 
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution. 
+// 
+// * Neither the name of Jaroslaw Kowalski nor the names of its 
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission. 
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
+// THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+namespace NLog.Internal
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+
+    internal class ThreadSafeDictionary<TKey, TValue> : IDictionary<TKey, TValue>
+    {
+        private readonly object _lockObject = new object();
+        private readonly IEqualityComparer<TKey> _comparer;
+        private Dictionary<TKey, TValue> _dict;
+        private Dictionary<TKey, TValue> _dictReadOnly;  // Reset cache on change
+
+        public ThreadSafeDictionary()
+            :this(EqualityComparer<TKey>.Default)
+        {
+        }
+
+        public ThreadSafeDictionary(IEqualityComparer<TKey> comparer)
+        {
+            _comparer = comparer;
+            _dict = new Dictionary<TKey, TValue>(_comparer);
+        }
+
+        public ThreadSafeDictionary(ThreadSafeDictionary<TKey, TValue> source)
+        {
+            _comparer = source._comparer;
+            _dict = source.GetReadOnlyDict();
+            GetWritableDict();  // Clone
+        }
+
+        public TValue this[TKey key]
+        {
+            get => GetReadOnlyDict()[key];
+            set
+            {
+                lock (_lockObject)
+                {
+                    GetWritableDict()[key] = value;
+                }
+            }
+        }
+
+        public ICollection<TKey> Keys => GetReadOnlyDict().Keys;
+
+        public ICollection<TValue> Values => GetReadOnlyDict().Values;
+
+        public int Count => GetReadOnlyDict().Count;
+
+        public bool IsReadOnly => false;
+
+        public void Add(TKey key, TValue value)
+        {
+            lock (_lockObject)
+            {
+                GetWritableDict().Add(key, value);
+            }
+        }
+
+        public void Add(KeyValuePair<TKey, TValue> item)
+        {
+            lock (_lockObject)
+            {
+                GetWritableDict().Add(item.Key, item.Value);
+            }
+        }
+
+        public void Clear()
+        {
+            lock (_lockObject)
+            {
+                GetWritableDict(true);
+            }
+        }
+
+        public bool Contains(KeyValuePair<TKey, TValue> item)
+        {
+            return GetReadOnlyDict().Contains(item);
+        }
+
+        public bool ContainsKey(TKey key)
+        {
+            return GetReadOnlyDict().ContainsKey(key);
+        }
+
+        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
+        {
+           ((IDictionary<TKey,TValue>)GetReadOnlyDict()).CopyTo(array, arrayIndex);
+        }
+
+        public void CopyFrom(IDictionary<TKey, TValue> source)
+        {
+            if (!ReferenceEquals(this, source) && source?.Count > 0)
+            {
+                lock (_lockObject)
+                {
+                    var destDict = GetWritableDict();
+                    foreach (var item in source)
+                        destDict[item.Key] = item.Value;
+                }
+            }
+        }
+
+        public bool Remove(TKey key)
+        {
+            lock (_lockObject)
+            {
+                return GetWritableDict().Remove(key);
+            }
+        }
+
+        public bool Remove(KeyValuePair<TKey, TValue> item)
+        {
+            lock (_lockObject)
+            {
+                return GetWritableDict().Remove(item);
+            }
+        }
+
+        public bool TryGetValue(TKey key, out TValue value)
+        {
+            return GetReadOnlyDict().TryGetValue(key, out value);
+        }
+
+        IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
+        {
+            return GetReadOnlyDict().GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetReadOnlyDict().GetEnumerator();
+        }
+
+        public Enumerator GetEnumerator()
+        {
+            return new Enumerator(GetReadOnlyDict().GetEnumerator());
+        }
+
+        public struct Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>
+        {
+            Dictionary<TKey, TValue>.Enumerator _enumerator;
+
+            public Enumerator(Dictionary<TKey, TValue>.Enumerator enumerator)
+            {
+                _enumerator = enumerator;
+            }
+
+            public KeyValuePair<TKey, TValue> Current => _enumerator.Current;
+
+            object IEnumerator.Current => _enumerator.Current;
+
+            public void Dispose()
+            {
+                _enumerator.Dispose();
+            }
+
+            public bool MoveNext()
+            {
+                return _enumerator.MoveNext();
+            }
+
+            void IEnumerator.Reset()
+            {
+                ((IEnumerator)_enumerator).Reset();
+            }
+        }
+
+        private Dictionary<TKey, TValue> GetReadOnlyDict()
+        {
+            var readOnly = _dictReadOnly;
+            if (readOnly == null)
+            {
+                lock (_lockObject)
+                {
+                    readOnly = _dictReadOnly = _dict;
+                }
+            }
+            return readOnly;
+        }
+
+        private IDictionary<TKey, TValue> GetWritableDict(bool clearDictionary = false)
+        {
+            var newDict = new Dictionary<TKey, TValue>(clearDictionary ? 0 : _dict.Count + 1, _comparer);
+            if (!clearDictionary)
+            {
+                // Less allocation with enumerator than Dictionary-constructor
+                foreach (var item in _dict)
+                    newDict[item.Key] = item.Value;
+            }
+            _dict = newDict;
+            _dictReadOnly = null;
+            return newDict;
+        }
+    }
+}
diff --git a/src/NLog/Internal/UrlHelper.cs b/src/NLog/Internal/UrlHelper.cs
index 8be94da97f..6db31323fc 100644
--- a/src/NLog/Internal/UrlHelper.cs
+++ b/src/NLog/Internal/UrlHelper.cs
@@ -42,7 +42,7 @@ namespace NLog.Internal
     internal static class UrlHelper
     {
         [Flags]
-        public enum EscapeEncodingFlag
+        public enum EscapeEncodingOptions
         {
             None = 0,
             /// <summary>Allow UnreservedMarks instead of ReservedMarks, as specified by chosen RFC</summary>
@@ -62,16 +62,16 @@ public enum EscapeEncodingFlag
         /// </summary>
         /// <param name="source">unicode string-data to be encoded</param>
         /// <param name="target">target for the encoded result</param>
-        /// <param name="flags"><see cref="EscapeEncodingFlag"/>s for how to perform the encoding</param>
-        public static void EscapeDataEncode(string source, StringBuilder target, EscapeEncodingFlag flags)
+        /// <param name="options"><see cref="EscapeEncodingOptions"/>s for how to perform the encoding</param>
+        public static void EscapeDataEncode(string source, StringBuilder target, EscapeEncodingOptions options)
         {
             if (string.IsNullOrEmpty(source))
                 return;
 
           
-            bool isLowerCaseHex = (flags & EscapeEncodingFlag.LowerCaseHex) == EscapeEncodingFlag.LowerCaseHex;
-            bool isSpaceAsPlus = (flags & EscapeEncodingFlag.SpaceAsPlus) == EscapeEncodingFlag.SpaceAsPlus;
-            bool isNLogLegacy = (flags & EscapeEncodingFlag.NLogLegacy) == EscapeEncodingFlag.NLogLegacy;
+            bool isLowerCaseHex = Contains(options, EscapeEncodingOptions.LowerCaseHex);
+            bool isSpaceAsPlus = Contains(options, EscapeEncodingOptions.SpaceAsPlus);
+            bool isNLogLegacy = Contains(options, EscapeEncodingOptions.NLogLegacy);
 
             char[] charArray = null;
             byte[] byteArray = null;
@@ -90,7 +90,7 @@ public static void EscapeDataEncode(string source, StringBuilder target, EscapeE
                     continue;
                 }
 
-                if (IsAllowedChar(flags, ch))
+                if (IsAllowedChar(options, ch))
                 {
                     continue;
                 }
@@ -113,6 +113,11 @@ public static void EscapeDataEncode(string source, StringBuilder target, EscapeE
             }
         }
 
+        private static bool Contains(EscapeEncodingOptions options, EscapeEncodingOptions option)
+        {
+            return (options & option) == option;
+        }
+
         /// <summary>
         /// Convert the wide-char into utf8-bytes, and then escape
         /// </summary>
@@ -157,13 +162,13 @@ private static void HandleLegacyEncoding(StringBuilder target, char ch, char[] h
         /// <summary>
         /// Is allowed?
         /// </summary>
-        /// <param name="flags"></param>
+        /// <param name="options"></param>
         /// <param name="ch"></param>
         /// <returns></returns>
-        private static bool IsAllowedChar(EscapeEncodingFlag flags, char ch)
+        private static bool IsAllowedChar(EscapeEncodingOptions options, char ch)
         {
-            bool isUriString = (flags & EscapeEncodingFlag.UriString) == EscapeEncodingFlag.UriString;
-            bool isLegacyRfc2396 = (flags & EscapeEncodingFlag.LegacyRfc2396) == EscapeEncodingFlag.LegacyRfc2396;
+            bool isUriString = (options & EscapeEncodingOptions.UriString) == EscapeEncodingOptions.UriString;
+            bool isLegacyRfc2396 = (options & EscapeEncodingOptions.LegacyRfc2396) == EscapeEncodingOptions.LegacyRfc2396;
             if (isUriString)
             {
                 if (!isLegacyRfc2396 && RFC3986UnreservedMarks.IndexOf(ch) >= 0)
@@ -203,16 +208,16 @@ private static bool IsSimpleCharOrNumber(char ch)
             { '0', '1', '2', '3', '4', '5', '6', '7',
             '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
 
-        public static EscapeEncodingFlag GetUriStringEncodingFlags(bool escapeDataNLogLegacy, bool spaceAsPlus, bool escapeDataRfc3986)
+        public static EscapeEncodingOptions GetUriStringEncodingFlags(bool escapeDataNLogLegacy, bool spaceAsPlus, bool escapeDataRfc3986)
         {
-            EscapeEncodingFlag encodingFlags = EscapeEncodingFlag.UriString;
+            EscapeEncodingOptions encodingOptions = EscapeEncodingOptions.UriString;
             if (escapeDataNLogLegacy)
-                encodingFlags |= EscapeEncodingFlag.LowerCaseHex | EscapeEncodingFlag.NLogLegacy;
+                encodingOptions |= EscapeEncodingOptions.LowerCaseHex | EscapeEncodingOptions.NLogLegacy;
             else if (!escapeDataRfc3986)
-                encodingFlags |= EscapeEncodingFlag.LowerCaseHex | EscapeEncodingFlag.LegacyRfc2396;
+                encodingOptions |= EscapeEncodingOptions.LowerCaseHex | EscapeEncodingOptions.LegacyRfc2396;
             if (spaceAsPlus)
-                encodingFlags |= EscapeEncodingFlag.SpaceAsPlus;
-            return encodingFlags;
+                encodingOptions |= EscapeEncodingOptions.SpaceAsPlus;
+            return encodingOptions;
         }
     }
 }
diff --git a/src/NLog/Internal/XmlHelper.cs b/src/NLog/Internal/XmlHelper.cs
index d6250f154e..7e8684bbee 100644
--- a/src/NLog/Internal/XmlHelper.cs
+++ b/src/NLog/Internal/XmlHelper.cs
@@ -34,10 +34,10 @@
 namespace NLog.Internal
 {
     using System;
+    using System.Globalization;
     using System.Text;
     using System.Text.RegularExpressions;
     using System.Xml;
-    using NLog.Internal;
 
     /// <summary>
     ///  Helper class for XML
@@ -172,8 +172,7 @@ private static bool SmallAndNoEscapeNeeded(string text, bool xmlEncodeNewlines)
         /// <returns>Object value converted to string</returns>
         internal static string XmlConvertToStringSafe(object value)
         {
-            TypeCode objTypeCode = Convert.GetTypeCode(value);
-            return XmlConvertToString(value, objTypeCode, true);
+            return XmlConvertToString(value, true);
         }
 
         /// <summary>
@@ -183,8 +182,7 @@ internal static string XmlConvertToStringSafe(object value)
         /// <returns>Object value converted to string</returns>
         internal static string XmlConvertToString(object value)
         {
-            TypeCode objTypeCode = Convert.GetTypeCode(value);
-            return XmlConvertToString(value, objTypeCode, false);
+            return XmlConvertToString(value, false);
         }
 
         /// <summary>
@@ -271,6 +269,38 @@ StringBuilder CreateStringBuilder(int i)
             }
         }
 
+        private static string XmlConvertToString(object value, bool safeConversion)
+        {
+            try
+            {
+                IConvertible convertibleValue = value as IConvertible;
+                TypeCode objTypeCode = value == null ? TypeCode.Empty : (convertibleValue?.GetTypeCode() ?? TypeCode.Object);
+                if (objTypeCode != TypeCode.Object)
+                {
+                    return XmlConvertToString(convertibleValue, objTypeCode, safeConversion);
+                }
+
+                return XmlConvertToStringInvariant(value, safeConversion);
+            }
+            catch
+            {
+                return safeConversion ? "" : null;
+            }
+        }
+
+        private static string XmlConvertToStringInvariant(object value, bool safeConversion)
+        {
+            try
+            {
+                string valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
+                return safeConversion ? RemoveInvalidXmlChars(valueString) : valueString;
+            }
+            catch
+            {
+                return safeConversion ? "" : null;
+            }
+        }
+
         /// <summary>
         /// Converts object value to invariant format (understood by JavaScript)
         /// </summary>
@@ -278,7 +308,7 @@ StringBuilder CreateStringBuilder(int i)
         /// <param name="objTypeCode">Object TypeCode</param>
         /// <param name="safeConversion">Check and remove unusual unicode characters from the result string.</param>
         /// <returns>Object value converted to string</returns>
-        internal static string XmlConvertToString(object value, TypeCode objTypeCode, bool safeConversion = false)
+        internal static string XmlConvertToString(IConvertible value, TypeCode objTypeCode, bool safeConversion = false)
         {
             if (value == null)
             {
@@ -288,57 +318,47 @@ internal static string XmlConvertToString(object value, TypeCode objTypeCode, bo
             switch (objTypeCode)
             {
                 case TypeCode.Boolean:
-                    return XmlConvert.ToString((bool)value);   // boolean as lowercase
+                    return XmlConvert.ToString(value.ToBoolean(CultureInfo.InvariantCulture));   // boolean as lowercase
                 case TypeCode.Byte:
-                    return XmlConvert.ToString((byte)value);
+                    return XmlConvert.ToString(value.ToByte(CultureInfo.InvariantCulture));
                 case TypeCode.SByte:
-                    return XmlConvert.ToString((sbyte)value);
+                    return XmlConvert.ToString(value.ToSByte(CultureInfo.InvariantCulture));
                 case TypeCode.Int16:
-                    return XmlConvert.ToString((short)value);
+                    return XmlConvert.ToString(value.ToInt16(CultureInfo.InvariantCulture));
                 case TypeCode.Int32:
-                    return XmlConvert.ToString((int)value);
+                    return XmlConvert.ToString(value.ToInt32(CultureInfo.InvariantCulture));
                 case TypeCode.Int64:
-                    return XmlConvert.ToString((long)value);
+                    return XmlConvert.ToString(value.ToInt64(CultureInfo.InvariantCulture));
                 case TypeCode.UInt16:
-                    return XmlConvert.ToString((ushort)value);
+                    return XmlConvert.ToString(value.ToUInt16(CultureInfo.InvariantCulture));
                 case TypeCode.UInt32:
-                    return XmlConvert.ToString((uint)value);
+                    return XmlConvert.ToString(value.ToUInt32(CultureInfo.InvariantCulture));
                 case TypeCode.UInt64:
-                    return XmlConvert.ToString((ulong)value);
+                    return XmlConvert.ToString(value.ToUInt64(CultureInfo.InvariantCulture));
                 case TypeCode.Single:
                     {
-                        float singleValue = (float)value;
-                        if (float.IsInfinity(singleValue))
-                            return Convert.ToString(singleValue, System.Globalization.CultureInfo.InvariantCulture); // Infinity instead of INF
-                        else
-                            return XmlConvert.ToString(singleValue);    // 8 digits scale
+                        float singleValue = value.ToSingle(CultureInfo.InvariantCulture);
+                        return float.IsInfinity(singleValue) ?
+                            Convert.ToString(singleValue, CultureInfo.InvariantCulture) :
+                            XmlConvert.ToString(singleValue);
                     }
                 case TypeCode.Double:
                     {
-                        double doubleValue = (double)value;
-                        if (double.IsInfinity(doubleValue))
-                            return Convert.ToString(doubleValue, System.Globalization.CultureInfo.InvariantCulture); // Infinity instead of INF
-                        else
-                            return XmlConvert.ToString(doubleValue);    // 16 digits scale
+                        double doubleValue = value.ToDouble(CultureInfo.InvariantCulture);
+                        return double.IsInfinity(doubleValue) ?
+                            Convert.ToString(doubleValue, CultureInfo.InvariantCulture) :
+                            XmlConvert.ToString(doubleValue);
                     }
                 case TypeCode.Decimal:
-                    return XmlConvert.ToString((decimal)value);
+                    return XmlConvert.ToString(value.ToDecimal(CultureInfo.InvariantCulture));
                 case TypeCode.DateTime:
-                    return XmlConvert.ToString((DateTime)value, XmlDateTimeSerializationMode.Utc);
+                    return XmlConvert.ToString(value.ToDateTime(CultureInfo.InvariantCulture), XmlDateTimeSerializationMode.Utc);
                 case TypeCode.Char:
-                    return XmlConvert.ToString((char)value);
+                    return XmlConvert.ToString(value.ToChar(CultureInfo.InvariantCulture));
                 case TypeCode.String:
-                    return safeConversion ? RemoveInvalidXmlChars((string)value) : (string)value;
+                    return safeConversion ? RemoveInvalidXmlChars(value.ToString(CultureInfo.InvariantCulture)) : value.ToString(CultureInfo.InvariantCulture);
                 default:
-                    try
-                    {
-                        string valueString = Convert.ToString(value, System.Globalization.CultureInfo.InvariantCulture);
-                        return safeConversion ? RemoveInvalidXmlChars(valueString) : valueString;
-                    }
-                    catch
-                    {
-                        return null;
-                    }
+                    return XmlConvertToStringInvariant(value, safeConversion);
             }
         }
 
diff --git a/src/NLog/LayoutRenderers/AllEventPropertiesLayoutRenderer.cs b/src/NLog/LayoutRenderers/AllEventPropertiesLayoutRenderer.cs
index 306b434689..1489e490bd 100644
--- a/src/NLog/LayoutRenderers/AllEventPropertiesLayoutRenderer.cs
+++ b/src/NLog/LayoutRenderers/AllEventPropertiesLayoutRenderer.cs
@@ -31,6 +31,8 @@
 // THE POSSIBILITY OF SUCH DAMAGE.
 // 
 
+using System.Collections;
+
 namespace NLog.LayoutRenderers
 {
     using System;
@@ -70,6 +72,14 @@ public AllEventPropertiesLayoutRenderer()
         /// <docgen category='Rendering Options' order='10' />
         public string Separator { get; set; }
 
+        /// <summary>
+        /// Get or set if empty values should be included.
+        ///
+        /// A value is empty when null or in case of a string, null or empty string.
+        /// </summary>
+        [DefaultValue(false)]
+        public bool IncludeEmptyValues { get; set; } = false;
+
 #if NET4_5
 
         /// <summary>
@@ -101,7 +111,7 @@ public string Format
 
                 _format = value;
 
-                var formatSplit = _format.Split(new [] { "[key]", "[value]" }, StringSplitOptions.None);
+                var formatSplit = _format.Split(new[] { "[key]", "[value]" }, StringSplitOptions.None);
                 if (formatSplit.Length == 3)
                 {
                     _beforeKey = formatSplit[0];
@@ -129,7 +139,12 @@ protected override void Append(StringBuilder builder, LogEventInfo logEvent)
                 var formatProvider = GetFormatProvider(logEvent);
 
                 bool first = true;
-                foreach (var property in GetProperties(logEvent))
+                IEnumerable<KeyValuePair<object, object>> properties = GetProperties(logEvent);
+                if (!IncludeEmptyValues)
+                {
+                    properties = properties.Where(p => !IsEmptyPropertyValue(p.Value));
+                }
+                foreach (var property in properties)
                 {
                     if (!first)
                     {
@@ -158,6 +173,16 @@ protected override void Append(StringBuilder builder, LogEventInfo logEvent)
             }
         }
 
+        private static bool IsEmptyPropertyValue(object value)
+        {
+            if (value is string s)
+            {
+                return string.IsNullOrEmpty(s);
+            }
+
+            return value == null;
+        }
+
 #if NET4_5
 
         /// <summary>
@@ -183,6 +208,7 @@ protected override void Append(StringBuilder builder, LogEventInfo logEvent)
         {
             var properties = logEvent.Properties;
 #if NET4_5
+
             if (IncludeCallerInformation)
             {
                 return properties;
diff --git a/src/NLog/LayoutRenderers/AssemblyVersionLayoutRenderer.cs b/src/NLog/LayoutRenderers/AssemblyVersionLayoutRenderer.cs
index de6f08ac4a..3b87d77aed 100644
--- a/src/NLog/LayoutRenderers/AssemblyVersionLayoutRenderer.cs
+++ b/src/NLog/LayoutRenderers/AssemblyVersionLayoutRenderer.cs
@@ -148,7 +148,7 @@ private string ApplyFormatToVersion(string version)
                 return version;
             }
 
-            var versionParts = version.Split('.');
+            var versionParts = version.SplitAndTrimTokens('.');
             version = Format.Replace("major", versionParts[0])
                 .Replace("minor", versionParts.Length > 1 ? versionParts[1] : "0")
                 .Replace("build", versionParts.Length > 2 ? versionParts[2] : "0")
diff --git a/src/NLog/LayoutRenderers/EnvironmentUserLayoutRenderer.cs b/src/NLog/LayoutRenderers/EnvironmentUserLayoutRenderer.cs
new file mode 100644
index 0000000000..acd50ed139
--- /dev/null
+++ b/src/NLog/LayoutRenderers/EnvironmentUserLayoutRenderer.cs
@@ -0,0 +1,136 @@
+// 
+// Copyright (c) 2004-2019 Jaroslaw Kowalski <jaak@jkowalski.net>, Kim Christensen, Julian Verdurmen
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without 
+// modification, are permitted provided that the following conditions 
+// are met:
+// 
+// * Redistributions of source code must retain the above copyright notice, 
+//   this list of conditions and the following disclaimer. 
+// 
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution. 
+// 
+// * Neither the name of Jaroslaw Kowalski nor the names of its 
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission. 
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
+// THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+#if !NETSTANDARD1_0 && !SILVERLIGHT
+
+namespace NLog.LayoutRenderers
+{
+    using System;
+    using System.ComponentModel;
+    using System.Text;
+    using NLog.Common;
+    using NLog.Config;
+    using NLog.Internal;
+
+    /// <summary>
+    /// Thread identity information (username).
+    /// </summary>
+    [LayoutRenderer("environment-user")]
+    [ThreadSafe]
+    public class EnvironmentUserLayoutRenderer : LayoutRenderer, IStringValueRenderer
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EnvironmentUserLayoutRenderer" /> class.
+        /// </summary>
+        public EnvironmentUserLayoutRenderer()
+        {
+            UserName = true;
+            Domain = false;
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether username should be included.
+        /// </summary>
+        /// <docgen category='Rendering Options' order='10' />
+        [DefaultValue(true)]
+        public bool UserName { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether domain name should be included.
+        /// </summary>
+        /// <docgen category='Rendering Options' order='10' />
+        [DefaultValue(false)]
+        public bool Domain { get; set; }
+
+        /// <summary>
+        /// Gets or sets the default value to be used when the User is not set.
+        /// </summary>
+        /// <docgen category='Rendering Options' order='10' />
+        [DefaultValue("UserUnknown")]
+        public string DefaultUser { get; set; } = "UserUnknown";
+
+        /// <summary>
+        /// Gets or sets the default value to be used when the Domain is not set.
+        /// </summary>
+        /// <docgen category='Rendering Options' order='10' />
+        [DefaultValue("DomainUnknown")]
+        public string DefaultDomain { get; set; } = "DomainUnknown";
+
+        /// <inheritdoc/>
+        protected override void Append(StringBuilder builder, LogEventInfo logEvent)
+        {
+            builder.Append(GetStringValue());
+        }
+
+        /// <inheritdoc/>
+        string IStringValueRenderer.GetFormattedString(LogEventInfo logEvent) => GetStringValue();
+
+        private string GetStringValue()
+        {
+            if (UserName)
+            {
+                return Domain ? string.Concat(GetDomainName(), "\\", GetUserName()) : GetUserName();
+            }
+            else
+            {
+                return Domain ? GetDomainName() : string.Empty;
+            }
+        }
+
+        string GetUserName()
+        {
+            return GetValueSafe(() => Environment.UserName, DefaultUser);
+        }
+
+        string GetDomainName()
+        {
+            return GetValueSafe(() => Environment.UserDomainName, DefaultDomain);
+        }
+
+        private string GetValueSafe(Func<string> getValue, string defaultValue)
+        {
+            try
+            {
+                var value = getValue();
+                return string.IsNullOrEmpty(value) ? (defaultValue ?? string.Empty) : value;
+            }
+            catch (Exception ex)
+            {
+                InternalLogger.Warn(ex, "Failed to lookup Environment-User. Fallback value={0}", defaultValue);
+                return defaultValue ?? string.Empty;
+            }
+        }
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/src/NLog/LayoutRenderers/EventPropertiesLayoutRenderer.cs b/src/NLog/LayoutRenderers/EventPropertiesLayoutRenderer.cs
index 5acd926c14..66658b0578 100644
--- a/src/NLog/LayoutRenderers/EventPropertiesLayoutRenderer.cs
+++ b/src/NLog/LayoutRenderers/EventPropertiesLayoutRenderer.cs
@@ -68,10 +68,24 @@ public class EventPropertiesLayoutRenderer : LayoutRenderer, IRawValue, IStringV
         /// <docgen category='Rendering Options' order='100' />
         public CultureInfo Culture { get; set; } = CultureInfo.InvariantCulture;
 
+        /// <summary>
+        /// Gets or sets the object-property-navigation-path for lookup of nested property
+        /// </summary>
+        /// <docgen category='Rendering Options' order='20' />
+        public string ObjectPath
+        {
+            get => _objectPropertyPath?.Length > 0 ? string.Join(".", _objectPropertyPath) : null;
+            set => _objectPropertyPath = StringHelpers.IsNullOrWhiteSpace(value) ? null : value.SplitAndTrimTokens('.');
+        }
+        private string[] _objectPropertyPath;
+
+        private ObjectReflectionCache ObjectReflectionCache => _objectReflectionCache ?? (_objectReflectionCache = new ObjectReflectionCache());
+        private ObjectReflectionCache _objectReflectionCache;
+
         /// <inheritdoc/>
         protected override void Append(StringBuilder builder, LogEventInfo logEvent)
         {
-            if (GetValue(logEvent, out var value))
+            if (TryGetValue(logEvent, out var value))
             {
                 var formatProvider = GetFormatProvider(logEvent, Culture);
                 builder.AppendFormattedValue(value, Format, formatProvider);
@@ -81,24 +95,56 @@ protected override void Append(StringBuilder builder, LogEventInfo logEvent)
         /// <inheritdoc/>
         bool IRawValue.TryGetRawValue(LogEventInfo logEvent, out object value)
         {
-            GetValue(logEvent, out value);
+            TryGetValue(logEvent, out value);
             return true;
         }
 
         /// <inheritdoc/>
         string IStringValueRenderer.GetFormattedString(LogEventInfo logEvent) => GetStringValue(logEvent);
 
-        private bool GetValue(LogEventInfo logEvent, out object value)
+        private bool TryGetValue(LogEventInfo logEvent, out object value)
         {
             value = null;
-            return logEvent.HasProperties && logEvent.Properties.TryGetValue(Item, out value);
+
+            if (!logEvent.HasProperties)
+                return false;
+
+            if (!logEvent.Properties.TryGetValue(Item, out value))
+                return false;
+
+            if (_objectPropertyPath != null && !TryGetObjectProperty(ref value))
+                return false;
+
+            return true;
+        }
+
+        private bool TryGetObjectProperty(ref object value)
+        {
+            var objectReflectionCache = ObjectReflectionCache;
+            for (int i = 0; i < _objectPropertyPath.Length; ++i)
+            {
+                if (value == null)
+                    return false;
+
+                var eventProperties = objectReflectionCache.LookupObjectProperties(value);
+                if (eventProperties.TryGetPropertyValue(_objectPropertyPath[i], out var propertyValue))
+                {
+                    value = propertyValue.Value;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            return true;
         }
 
         private string GetStringValue(LogEventInfo logEvent)
         {
             if (Format != MessageTemplates.ValueFormatter.FormatAsJson)
             {
-                if (GetValue(logEvent, out var value))
+                if (TryGetValue(logEvent, out var value))
                 {
                     string stringValue = FormatHelper.TryFormatToString(value, Format, GetFormatProvider(logEvent, Culture));
                     return stringValue;
diff --git a/src/NLog/LayoutRenderers/ExceptionLayoutRenderer.cs b/src/NLog/LayoutRenderers/ExceptionLayoutRenderer.cs
index d9189aa1e0..aac3f9d49a 100644
--- a/src/NLog/LayoutRenderers/ExceptionLayoutRenderer.cs
+++ b/src/NLog/LayoutRenderers/ExceptionLayoutRenderer.cs
@@ -409,7 +409,7 @@ protected virtual void AppendSerializeObject(StringBuilder sb, Exception ex)
         private static List<ExceptionRenderingFormat> CompileFormat(string formatSpecifier)
         {
             List<ExceptionRenderingFormat> formats = new List<ExceptionRenderingFormat>();
-            string[] parts = formatSpecifier.Replace(" ", string.Empty).Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
+            string[] parts = formatSpecifier.SplitAndTrimTokens(',');
 
             foreach (string s in parts)
             {
diff --git a/src/NLog/LayoutRenderers/GdcLayoutRenderer.cs b/src/NLog/LayoutRenderers/GdcLayoutRenderer.cs
index b947189ec2..0211a3fb69 100644
--- a/src/NLog/LayoutRenderers/GdcLayoutRenderer.cs
+++ b/src/NLog/LayoutRenderers/GdcLayoutRenderer.cs
@@ -39,7 +39,7 @@ namespace NLog.LayoutRenderers
     using NLog.Internal;
 
     /// <summary>
-    /// Global Diagnostics Context item. Provided for compatibility with log4net.
+    /// Render a Global Diagnostics Context item. See <see cref="GlobalDiagnosticsContext"/>
     /// </summary>
     [LayoutRenderer("gdc")]
     [ThreadAgnostic]
diff --git a/src/NLog/LayoutRenderers/Log4JXmlEventLayoutRenderer.cs b/src/NLog/LayoutRenderers/Log4JXmlEventLayoutRenderer.cs
index 03b74e205f..efae684bb5 100644
--- a/src/NLog/LayoutRenderers/Log4JXmlEventLayoutRenderer.cs
+++ b/src/NLog/LayoutRenderers/Log4JXmlEventLayoutRenderer.cs
@@ -370,15 +370,20 @@ private static void AppendException(LogEventInfo logEvent, XmlWriter xtw)
 
         private void AppendParameters(LogEventInfo logEvent, XmlWriter xtw)
         {
-            if (Parameters.Count > 0)
+            for (int i = 0; i < Parameters?.Count; ++i)
             {
-                foreach (NLogViewerParameterInfo parameter in Parameters)
-                {
-                    xtw.WriteStartElement("log4j", "data", dummyNamespace);
-                    xtw.WriteAttributeSafeString("name", parameter.Name);
-                    xtw.WriteAttributeSafeString("value", parameter.Layout.Render(logEvent));
-                    xtw.WriteEndElement();
-                }
+                var parameter = Parameters[i];
+                if (string.IsNullOrEmpty(parameter?.Name))
+                    continue;
+
+                var parameterValue = parameter.Layout?.Render(logEvent) ?? string.Empty;
+                if (!parameter.IncludeEmptyValue && string.IsNullOrEmpty(parameterValue))
+                    continue;
+
+                xtw.WriteStartElement("log4j", "data", dummyNamespace);
+                xtw.WriteAttributeSafeString("name", parameter.Name);
+                xtw.WriteAttributeSafeString("value", parameterValue);
+                xtw.WriteEndElement();
             }
         }
 
diff --git a/src/NLog/LayoutRenderers/MdcLayoutRenderer.cs b/src/NLog/LayoutRenderers/MdcLayoutRenderer.cs
index 8b3e54c2f1..9de15a09a7 100644
--- a/src/NLog/LayoutRenderers/MdcLayoutRenderer.cs
+++ b/src/NLog/LayoutRenderers/MdcLayoutRenderer.cs
@@ -38,7 +38,7 @@ namespace NLog.LayoutRenderers
     using NLog.Internal;
 
     /// <summary>
-    /// Mapped Diagnostic Context item. Provided for compatibility with log4net.
+    /// Render a Mapped Diagnostic Context item, See <see cref="MappedDiagnosticsContext"/>
     /// </summary>
     [LayoutRenderer("mdc")]
     [ThreadSafe]
diff --git a/src/NLog/LayoutRenderers/MdlcLayoutRenderer.cs b/src/NLog/LayoutRenderers/MdlcLayoutRenderer.cs
index 587d098593..88b6c51c5c 100644
--- a/src/NLog/LayoutRenderers/MdlcLayoutRenderer.cs
+++ b/src/NLog/LayoutRenderers/MdlcLayoutRenderer.cs
@@ -39,7 +39,8 @@ namespace NLog.LayoutRenderers
     using NLog.Internal;
 
     /// <summary>
-    /// Mapped Diagnostic Logical Context item (based on CallContext).
+    /// Render a Mapped Diagnostic Logical Context item (based on CallContext).
+    /// See <see cref="MappedDiagnosticsLogicalContext"/>
     /// </summary>
     [LayoutRenderer("mdlc")]
     [ThreadSafe]
diff --git a/src/NLog/LayoutRenderers/NdcLayoutRenderer.cs b/src/NLog/LayoutRenderers/NdcLayoutRenderer.cs
index 2d81047735..2510ed772f 100644
--- a/src/NLog/LayoutRenderers/NdcLayoutRenderer.cs
+++ b/src/NLog/LayoutRenderers/NdcLayoutRenderer.cs
@@ -38,7 +38,8 @@ namespace NLog.LayoutRenderers
     using NLog.Config;
 
     /// <summary>
-    /// Nested Diagnostic Context item. Provided for compatibility with log4net.
+    /// Render a Nested Diagnostic Context item.
+    /// See <see cref="NestedDiagnosticsContext"/>
     /// </summary>
     [LayoutRenderer("ndc")]
     [ThreadSafe]
@@ -81,7 +82,7 @@ protected override void Append(StringBuilder builder, LogEventInfo logEvent)
         {
             if (TopFrames == 1)
             {
-                // Allows fast rendering of ${ndc:topframes=1}
+                // Allows fast rendering of topframes=1
                 var topFrame = NestedDiagnosticsContext.PeekObject();
                 if (topFrame != null)
                     AppendAsString(topFrame, GetFormatProvider(logEvent), builder);
diff --git a/src/NLog/LayoutRenderers/NdlcLayoutRenderer.cs b/src/NLog/LayoutRenderers/NdlcLayoutRenderer.cs
index 558df66db7..7188a4f642 100644
--- a/src/NLog/LayoutRenderers/NdlcLayoutRenderer.cs
+++ b/src/NLog/LayoutRenderers/NdlcLayoutRenderer.cs
@@ -39,7 +39,8 @@ namespace NLog.LayoutRenderers
     using NLog.Config;
 
     /// <summary>
-    /// <see cref="NestedDiagnosticsLogicalContext"/> Renderer (Async scope)
+    /// Render a Nested Diagnostic Logical Context item (Async scope)
+    /// See <see cref="NestedDiagnosticsLogicalContext"/>
     /// </summary>
     [LayoutRenderer("ndlc")]
     [ThreadSafe]
@@ -82,7 +83,7 @@ protected override void Append(StringBuilder builder, LogEventInfo logEvent)
         {
             if (TopFrames == 1)
             {
-                // Allows fast rendering of ${ndlc:topframes=1}
+                // Allows fast rendering of topframes=1
                 var topFrame = NestedDiagnosticsLogicalContext.PeekObject();
                 if (topFrame != null)
                     AppendAsString(topFrame, GetFormatProvider(logEvent), builder);
diff --git a/src/NLog/LayoutRenderers/ProcessNameLayoutRenderer.cs b/src/NLog/LayoutRenderers/ProcessNameLayoutRenderer.cs
index 32d2a5aafb..2071512fed 100644
--- a/src/NLog/LayoutRenderers/ProcessNameLayoutRenderer.cs
+++ b/src/NLog/LayoutRenderers/ProcessNameLayoutRenderer.cs
@@ -63,15 +63,7 @@ public class ProcessNameLayoutRenderer : LayoutRenderer
         /// <param name="logEvent">Logging event.</param>
         protected override void Append(StringBuilder builder, LogEventInfo logEvent)
         {
-            string output;
-            if (FullName)
-            {
-                output = ProcessIDHelper.Instance.CurrentProcessFilePath;
-            }
-            else
-            {
-                output = ProcessIDHelper.Instance.CurrentProcessBaseName;
-            }
+            var output = FullName ? ProcessIDHelper.Instance.CurrentProcessFilePath : ProcessIDHelper.Instance.CurrentProcessBaseName;
             builder.Append(output);
         }
     }
diff --git a/src/NLog/LayoutRenderers/ShortDateLayoutRenderer.cs b/src/NLog/LayoutRenderers/ShortDateLayoutRenderer.cs
index 752805404d..2903488697 100644
--- a/src/NLog/LayoutRenderers/ShortDateLayoutRenderer.cs
+++ b/src/NLog/LayoutRenderers/ShortDateLayoutRenderer.cs
@@ -38,6 +38,7 @@ namespace NLog.LayoutRenderers
     using System.Globalization;
     using System.Text;
     using NLog.Config;
+    using NLog.Internal;
 
     /// <summary>
     /// The short date in a sortable format yyyy-MM-dd.
@@ -45,7 +46,7 @@ namespace NLog.LayoutRenderers
     [LayoutRenderer("shortdate")]
     [ThreadAgnostic]
     [ThreadSafe]
-    public class ShortDateLayoutRenderer : LayoutRenderer
+    public class ShortDateLayoutRenderer : LayoutRenderer, IRawValue, IStringValueRenderer
     {
         /// <summary>
         /// Gets or sets a value indicating whether to output UTC time instead of local time.
@@ -63,11 +64,13 @@ public class ShortDateLayoutRenderer : LayoutRenderer
         /// <param name="logEvent">Logging event.</param>
         protected override void Append(StringBuilder builder, LogEventInfo logEvent)
         {
-            var timestamp = logEvent.TimeStamp;
-            if (UniversalTime)
-            {
-                timestamp = timestamp.ToUniversalTime();
-            }
+            string formattedDate = GetStringValue(logEvent);
+            builder.Append(formattedDate);
+        }
+
+        private string GetStringValue(LogEventInfo logEvent)
+        {
+            DateTime timestamp = GetValue(logEvent);
 
             var cachedDateFormatted = _cachedDateFormatted;
             if (cachedDateFormatted.Date != timestamp.Date)
@@ -76,9 +79,27 @@ protected override void Append(StringBuilder builder, LogEventInfo logEvent)
                 _cachedDateFormatted = cachedDateFormatted = new CachedDateFormatted(timestamp.Date, formatTime);
             }
 
-            builder.Append(cachedDateFormatted.FormattedDate);
+            return cachedDateFormatted.FormattedDate;
+        }
+
+        private DateTime GetValue(LogEventInfo logEvent)
+        {
+            var timestamp = logEvent.TimeStamp;
+            if (UniversalTime)
+            {
+                timestamp = timestamp.ToUniversalTime();
+            }
+            return timestamp;
+        }
+
+        bool IRawValue.TryGetRawValue(LogEventInfo logEvent, out object value)
+        {
+            value = GetValue(logEvent).Date;    // Only Date-part
+            return true;
         }
 
+        string IStringValueRenderer.GetFormattedString(LogEventInfo logEvent) => GetStringValue(logEvent);
+
         private class CachedDateFormatted
         {
             public CachedDateFormatted(DateTime date, string formattedDate)
diff --git a/src/NLog/LayoutRenderers/VariableLayoutRenderer.cs b/src/NLog/LayoutRenderers/VariableLayoutRenderer.cs
index cb509f10bb..f2427f9f36 100644
--- a/src/NLog/LayoutRenderers/VariableLayoutRenderer.cs
+++ b/src/NLog/LayoutRenderers/VariableLayoutRenderer.cs
@@ -87,15 +87,8 @@ protected override void InitializeLayoutRenderer()
         private bool TryGetLayout(out SimpleLayout layout)
         {
             layout = null;
-            if (Name != null)
-            {
-                //don't use LogManager (locking, recursion)
-                if (LoggingConfiguration?.Variables?.TryGetValue(Name, out layout) == true)
-                {
-                    return true;
-                }
-            }
-            return false;
+            //Note: don't use LogManager (locking, recursion)
+            return Name != null && LoggingConfiguration?.Variables?.TryGetValue(Name, out layout) == true;
         }
 
 
diff --git a/src/NLog/LayoutRenderers/Wrappers/JsonEncodeLayoutRendererWrapper.cs b/src/NLog/LayoutRenderers/Wrappers/JsonEncodeLayoutRendererWrapper.cs
index ea46037e64..18631f6312 100644
--- a/src/NLog/LayoutRenderers/Wrappers/JsonEncodeLayoutRendererWrapper.cs
+++ b/src/NLog/LayoutRenderers/Wrappers/JsonEncodeLayoutRendererWrapper.cs
@@ -75,14 +75,11 @@ public JsonEncodeLayoutRendererWrapper()
         protected override void RenderInnerAndTransform(LogEventInfo logEvent, StringBuilder builder, int orgLength)
         {
             Inner.RenderAppendBuilder(logEvent, builder);
-            if (JsonEncode && builder.Length > orgLength)
+            if (JsonEncode && builder.Length > orgLength && RequiresJsonEncode(builder, orgLength))
             {
-                if (RequiresJsonEncode(builder, orgLength))
-                {
-                    var str = builder.ToString(orgLength, builder.Length - orgLength);
-                    builder.Length = orgLength;
-                    Targets.DefaultJsonSerializer.AppendStringEscape(builder, str, EscapeUnicode);
-                }
+                var str = builder.ToString(orgLength, builder.Length - orgLength);
+                builder.Length = orgLength;
+                Targets.DefaultJsonSerializer.AppendStringEscape(builder, str, EscapeUnicode);
             }
         }
 
diff --git a/src/NLog/LayoutRenderers/Wrappers/LeftLayoutRendererWrapper.cs b/src/NLog/LayoutRenderers/Wrappers/LeftLayoutRendererWrapper.cs
index f23f831754..1fd0077837 100644
--- a/src/NLog/LayoutRenderers/Wrappers/LeftLayoutRendererWrapper.cs
+++ b/src/NLog/LayoutRenderers/Wrappers/LeftLayoutRendererWrapper.cs
@@ -41,6 +41,7 @@ namespace NLog.LayoutRenderers.Wrappers
     /// Left part of a text
     /// </summary>
     [LayoutRenderer("left")]
+    [AmbientProperty("Truncate")]
     [AppDomainFixedOutput]
     [ThreadAgnostic]
     [ThreadSafe]
@@ -53,6 +54,14 @@ public sealed class LeftLayoutRendererWrapper : WrapperLayoutRendererBase
         [RequiredParameter]
         public int Length { get; set; }
 
+        /// <summary>
+        /// Same as <see cref="Length"/>-property, so it can be used as ambient property.
+        /// </summary>
+        /// <example>
+        /// ${message:truncate=80}
+        /// </example>
+        public int Truncate { get => Length; set => Length = value; }
+
         /// <inheritdoc/>
         protected override void RenderInnerAndTransform(LogEventInfo logEvent, StringBuilder builder, int orgLength)
         {
diff --git a/src/NLog/LayoutRenderers/Wrappers/ReplaceNewLinesLayoutRendererWrapper.cs b/src/NLog/LayoutRenderers/Wrappers/ReplaceNewLinesLayoutRendererWrapper.cs
index 64e802face..77e6acc5f8 100644
--- a/src/NLog/LayoutRenderers/Wrappers/ReplaceNewLinesLayoutRendererWrapper.cs
+++ b/src/NLog/LayoutRenderers/Wrappers/ReplaceNewLinesLayoutRendererWrapper.cs
@@ -75,7 +75,7 @@ protected override void RenderInnerAndTransform(LogEventInfo logEvent, StringBui
                 {
                     string str = builder.ToString(orgLength, builder.Length - orgLength);
                     str = str.Replace(newLine, Replacement);
-                    if (newLine != "\n" && !(Replacement?.IndexOf('\n') >= 0) && str.IndexOf('\n') >= 0)
+                    if (newLine != "\n" && !HasUnixNewline(Replacement) && HasUnixNewline(str))
                         str = str.Replace("\n", Replacement);   // Recognize Unix-Newline on Windows-platform
                     builder.Length = orgLength;
                     builder.Append(str);
@@ -83,6 +83,11 @@ protected override void RenderInnerAndTransform(LogEventInfo logEvent, StringBui
             }
         }
 
+        private static bool HasUnixNewline(string str)
+        {
+            return str != null && str.IndexOf('\n') >= 0;
+        }
+
         /// <inheritdoc/>
         [Obsolete("Inherit from WrapperLayoutRendererBase and override RenderInnerAndTransform() instead. Marked obsolete in NLog 4.6")]
         protected override void TransformFormattedMesssage(StringBuilder target)
diff --git a/src/NLog/LayoutRenderers/Wrappers/TrimWhiteSpaceLayoutRendererWrapper.cs b/src/NLog/LayoutRenderers/Wrappers/TrimWhiteSpaceLayoutRendererWrapper.cs
index 9c04b1a965..5d75f6dd0e 100644
--- a/src/NLog/LayoutRenderers/Wrappers/TrimWhiteSpaceLayoutRendererWrapper.cs
+++ b/src/NLog/LayoutRenderers/Wrappers/TrimWhiteSpaceLayoutRendererWrapper.cs
@@ -84,14 +84,11 @@ protected override void TransformFormattedMesssage(StringBuilder target)
         private static void TransformTrimWhiteSpaces(StringBuilder builder, int startPos)
         {
             builder.TrimRight(startPos);  // Fast
-            if (builder.Length > startPos)
+            if (builder.Length > startPos && char.IsWhiteSpace(builder[startPos]))
             {
-                if (char.IsWhiteSpace(builder[startPos]))
-                {
-                    var str = builder.ToString(startPos, builder.Length - startPos);
-                    builder.Length = startPos;
-                    builder.Append(str.Trim());
-                }
+                var str = builder.ToString(startPos, builder.Length - startPos);
+                builder.Length = startPos;
+                builder.Append(str.Trim());
             }
         }
     }
diff --git a/src/NLog/LayoutRenderers/Wrappers/UrlEncodeLayoutRendererWrapper.cs b/src/NLog/LayoutRenderers/Wrappers/UrlEncodeLayoutRendererWrapper.cs
index b1921349bc..a4b8aa4c2b 100644
--- a/src/NLog/LayoutRenderers/Wrappers/UrlEncodeLayoutRendererWrapper.cs
+++ b/src/NLog/LayoutRenderers/Wrappers/UrlEncodeLayoutRendererWrapper.cs
@@ -83,9 +83,9 @@ protected override string Transform(string text)
         {
             if (!string.IsNullOrEmpty(text))
             {
-                UrlHelper.EscapeEncodingFlag encodingFlags = UrlHelper.GetUriStringEncodingFlags(EscapeDataNLogLegacy, SpaceAsPlus, EscapeDataRfc3986);
+                UrlHelper.EscapeEncodingOptions encodingOptions = UrlHelper.GetUriStringEncodingFlags(EscapeDataNLogLegacy, SpaceAsPlus, EscapeDataRfc3986);
                 System.Text.StringBuilder sb = new System.Text.StringBuilder(text.Length + 20);
-                UrlHelper.EscapeDataEncode(text, sb, encodingFlags);
+                UrlHelper.EscapeDataEncode(text, sb, encodingOptions);
                 return sb.ToString();
             }
             return string.Empty;
diff --git a/src/NLog/LayoutRenderers/Wrappers/WhenEmptyLayoutRendererWrapper.cs b/src/NLog/LayoutRenderers/Wrappers/WhenEmptyLayoutRendererWrapper.cs
index 13a304550a..505bc0f140 100644
--- a/src/NLog/LayoutRenderers/Wrappers/WhenEmptyLayoutRendererWrapper.cs
+++ b/src/NLog/LayoutRenderers/Wrappers/WhenEmptyLayoutRendererWrapper.cs
@@ -36,6 +36,7 @@ namespace NLog.LayoutRenderers.Wrappers
     using System;
     using System.Text;
     using NLog.Config;
+    using NLog.Internal;
     using NLog.Layouts;
 
     /// <summary>
@@ -43,11 +44,12 @@ namespace NLog.LayoutRenderers.Wrappers
     /// </summary>
     [LayoutRenderer("whenEmpty")]
     [AmbientProperty("WhenEmpty")]
-    [AppDomainFixedOutput]
     [ThreadAgnostic]
     [ThreadSafe]
-    public sealed class WhenEmptyLayoutRendererWrapper : WrapperLayoutRendererBuilderBase
+    public sealed class WhenEmptyLayoutRendererWrapper : WrapperLayoutRendererBuilderBase, IRawValue, IStringValueRenderer
     {
+        private bool _skipStringValueRenderer;
+
         /// <summary>
         /// Gets or sets the layout to be rendered when original layout produced empty result.
         /// </summary>
@@ -60,6 +62,7 @@ protected override void InitializeLayoutRenderer()
         {
             base.InitializeLayoutRenderer();
             WhenEmpty?.Initialize(LoggingConfiguration);
+            _skipStringValueRenderer = !TryGetStringValue(out _, out _);
         }
 
         /// <inheritdoc/>
@@ -73,6 +76,66 @@ protected override void RenderInnerAndTransform(LogEventInfo logEvent, StringBui
             WhenEmpty.RenderAppendBuilder(logEvent, builder);
         }
 
+        string IStringValueRenderer.GetFormattedString(LogEventInfo logEvent)
+        {
+            if (_skipStringValueRenderer)
+            {
+                return null;
+            }
+
+            if (TryGetStringValue(out var innerLayout, out var whenEmptyLayout))
+            {
+                var innerValue = innerLayout.Render(logEvent);
+                if (!string.IsNullOrEmpty(innerValue))
+                {
+                    return innerValue;
+                }
+
+                // render WhenEmpty when the inner layout was empty
+                return whenEmptyLayout.Render(logEvent);
+            }
+
+            _skipStringValueRenderer = true;
+            return null;
+        }
+
+        private bool TryGetStringValue(out SimpleLayout innerLayout, out SimpleLayout whenEmptyLayout)
+        {
+            whenEmptyLayout = WhenEmpty as SimpleLayout;
+            innerLayout = Inner as SimpleLayout;
+
+            return IsStringLayout(innerLayout) && IsStringLayout(whenEmptyLayout);
+        }
+
+        private static bool IsStringLayout(SimpleLayout innerLayout)
+        {
+            return innerLayout != null && (innerLayout.IsFixedText || innerLayout.IsSimpleStringText);
+        }
+
+        bool IRawValue.TryGetRawValue(LogEventInfo logEvent, out object value)
+        {
+            if (Inner.TryGetRawValue(logEvent, out var innerValue))
+            {
+                if (innerValue != null && !innerValue.Equals(string.Empty))
+                {
+                    value = innerValue;
+                    return true;
+                }
+            }
+            else
+            {
+                var innerResult = Inner.Render(logEvent); // Beware this can be very expensive call
+                if (!string.IsNullOrEmpty(innerResult))
+                {
+                    value = null;
+                    return false;
+                }
+            }
+
+            // render WhenEmpty when the inner layout was empty
+            return WhenEmpty.TryGetRawValue(logEvent, out value);
+        }
+
         /// <inheritdoc/>
         [Obsolete("Inherit from WrapperLayoutRendererBase and override RenderInnerAndTransform() instead. Marked obsolete in NLog 4.6")]
         protected override void TransformFormattedMesssage(StringBuilder target)
diff --git a/src/NLog/LayoutRenderers/Wrappers/WhenLayoutRendererWrapper.cs b/src/NLog/LayoutRenderers/Wrappers/WhenLayoutRendererWrapper.cs
index b63e6864c4..651283b163 100644
--- a/src/NLog/LayoutRenderers/Wrappers/WhenLayoutRendererWrapper.cs
+++ b/src/NLog/LayoutRenderers/Wrappers/WhenLayoutRendererWrapper.cs
@@ -38,6 +38,7 @@ namespace NLog.LayoutRenderers.Wrappers
     using NLog.Conditions;
     using NLog.Config;
     using NLog.Layouts;
+    using NLog.Internal;
 
     /// <summary>
     /// Only outputs the inner layout when the specified condition has been met.
@@ -46,7 +47,7 @@ namespace NLog.LayoutRenderers.Wrappers
     [AmbientProperty("When")]
     [ThreadAgnostic]
     [ThreadSafe]
-    public sealed class WhenLayoutRendererWrapper : WrapperLayoutRendererBuilderBase
+    public sealed class WhenLayoutRendererWrapper : WrapperLayoutRendererBuilderBase, IRawValue
     {
         /// <summary>
         /// Gets or sets the condition that must be met for the <see cref="WrapperLayoutRendererBase.Inner"/> layout to be printed.
@@ -67,13 +68,13 @@ protected override void Append(StringBuilder builder, LogEventInfo logEvent)
             int orgLength = builder.Length;
             try
             {
-                if (When == null || true.Equals(When.Evaluate(logEvent)))
+                if (ShouldRenderInner(logEvent))
                 {
                     Inner?.RenderAppendBuilder(logEvent, builder);
                 }
-                else if (Else != null)
+                else
                 {
-                    Else.RenderAppendBuilder(logEvent, builder);
+                    Else?.RenderAppendBuilder(logEvent, builder);
                 }
             }
             catch
@@ -83,10 +84,37 @@ protected override void Append(StringBuilder builder, LogEventInfo logEvent)
             }
         }
 
+        private bool ShouldRenderInner(LogEventInfo logEvent)
+        {
+            return When == null || true.Equals(When.Evaluate(logEvent));
+        }
+
         /// <inheritdoc/>
         [Obsolete("Inherit from WrapperLayoutRendererBase and override RenderInnerAndTransform() instead. Marked obsolete in NLog 4.6")]
         protected override void TransformFormattedMesssage(StringBuilder target)
         {
         }
+
+        /// <inheritdoc />
+        public bool TryGetRawValue(LogEventInfo logEvent, out object value)
+        {
+            if (ShouldRenderInner(logEvent))
+            {
+                return TryGetRawValueFromLayout(logEvent, Inner, out value);
+            }
+
+            return TryGetRawValueFromLayout(logEvent, Else, out value);
+        }
+
+        private static bool TryGetRawValueFromLayout(LogEventInfo logEvent, Layout layout, out object value)
+        {
+            if (layout == null)
+            {
+                value = null;
+                return false;
+            }
+
+            return layout.TryGetRawValue(logEvent, out value);
+        }
     }
 }
diff --git a/src/NLog/Layouts/JsonAttribute.cs b/src/NLog/Layouts/JsonAttribute.cs
index 44f7d0d5ac..599587eef4 100644
--- a/src/NLog/Layouts/JsonAttribute.cs
+++ b/src/NLog/Layouts/JsonAttribute.cs
@@ -41,6 +41,7 @@ namespace NLog.Layouts
     [NLogConfigurationItem]
     [ThreadAgnostic]
     [ThreadSafe]
+    [AppDomainFixedOutput]
     public class JsonAttribute
     {
         /// <summary>
diff --git a/src/NLog/Layouts/JsonLayout.cs b/src/NLog/Layouts/JsonLayout.cs
index 9cbe34c079..363074548f 100644
--- a/src/NLog/Layouts/JsonLayout.cs
+++ b/src/NLog/Layouts/JsonLayout.cs
@@ -80,9 +80,9 @@ public bool SerializeObject(object value, StringBuilder builder)
                     return _converter.SerializeObject(value, builder);
             }
 
-            public bool SerializeObjectNoLimit(object value, StringBuilder builder)
+            public void SerializeObjectNoLimit(object value, StringBuilder builder)
             {
-                return _converter.SerializeObject(value, builder);
+                _converter.SerializeObject(value, builder);
             }
         }
 
diff --git a/src/NLog/Layouts/Log4JXmlEventLayout.cs b/src/NLog/Layouts/Log4JXmlEventLayout.cs
index f5a13d9644..83c06b47e0 100644
--- a/src/NLog/Layouts/Log4JXmlEventLayout.cs
+++ b/src/NLog/Layouts/Log4JXmlEventLayout.cs
@@ -33,9 +33,11 @@
 
 namespace NLog.Layouts
 {
+    using System.Collections.Generic;
     using System.Text;
     using NLog.Config;
     using NLog.LayoutRenderers;
+    using NLog.Targets;
 
     /// <summary>
     /// A specialized layout that renders Log4j-compatible XML events.
@@ -55,12 +57,22 @@ public class Log4JXmlEventLayout : Layout, IIncludeContext
         public Log4JXmlEventLayout()
         {
             Renderer = new Log4JXmlEventLayoutRenderer();
+            Parameters = new List<NLogViewerParameterInfo>();
+            Renderer.Parameters = Parameters;
         }
 
         /// <summary>
         /// Gets the <see cref="Log4JXmlEventLayoutRenderer"/> instance that renders log events.
         /// </summary>
-        public Log4JXmlEventLayoutRenderer Renderer { get; private set; }
+        public Log4JXmlEventLayoutRenderer Renderer { get; }
+
+        /// <summary>
+        /// Gets the collection of parameters. Each parameter contains a mapping
+        /// between NLog layout and a named parameter.
+        /// </summary>
+        /// <docgen category='Payload Options' order='10' />
+        [ArrayParameter(typeof(NLogViewerParameterInfo), "parameter")]
+        public IList<NLogViewerParameterInfo> Parameters { get => Renderer.Parameters; set => Renderer.Parameters = value;  }
 
         /// <summary>
         /// Gets or sets a value indicating whether to include contents of the <see cref="MappedDiagnosticsContext"/> dictionary.
diff --git a/src/NLog/Layouts/SimpleLayout.cs b/src/NLog/Layouts/SimpleLayout.cs
index ee4dccf334..3893952fe7 100644
--- a/src/NLog/Layouts/SimpleLayout.cs
+++ b/src/NLog/Layouts/SimpleLayout.cs
@@ -332,13 +332,10 @@ internal override bool TryGetRawValue(LogEventInfo logEvent, out object rawValue
             {
                 if (_rawValueRenderer != null)
                 {
-                    if (!ThreadAgnostic || MutableUnsafe)
+                    if ((!ThreadAgnostic || MutableUnsafe) && logEvent.TryGetCachedLayoutValue(this, out _))
                     {
-                        if (logEvent.TryGetCachedLayoutValue(this, out _))
-                        {
-                            rawValue = null;
-                            return false;    // Raw-Value has been precalculated, so not available
-                        }
+                        rawValue = null;
+                        return false;    // Raw-Value has been precalculated, so not available
                     }
 
                     var success = _rawValueRenderer.TryGetRawValue(logEvent, out rawValue);
diff --git a/src/NLog/Layouts/XmlElementBase.cs b/src/NLog/Layouts/XmlElementBase.cs
index 1cc3df76a0..34cbf510d5 100644
--- a/src/NLog/Layouts/XmlElementBase.cs
+++ b/src/NLog/Layouts/XmlElementBase.cs
@@ -373,8 +373,9 @@ private void AppendLogEventXmlProperties(LogEventInfo logEventInfo, StringBuilde
                 {
                     if (string.IsNullOrEmpty(key))
                         continue;
+
                     object propertyValue = MappedDiagnosticsContext.GetObject(key);
-                    AppendXmlPropertyValue(key, propertyValue, Convert.GetTypeCode(propertyValue), sb, orgLength);
+                    AppendXmlPropertyValue(key, propertyValue, sb, orgLength);
                 }
             }
 
@@ -385,8 +386,9 @@ private void AppendLogEventXmlProperties(LogEventInfo logEventInfo, StringBuilde
                 {
                     if (string.IsNullOrEmpty(key))
                         continue;
+
                     object propertyValue = MappedDiagnosticsLogicalContext.GetObject(key);
-                    AppendXmlPropertyValue(key, propertyValue, Convert.GetTypeCode(propertyValue), sb, orgLength);
+                    AppendXmlPropertyValue(key, propertyValue, sb, orgLength);
                 }
             }
 #endif
@@ -416,19 +418,18 @@ private void AppendLogEventProperties(LogEventInfo logEventInfo, StringBuilder s
                     propertyValue = Convert.ToString(prop.Value ?? string.Empty,
                         logEventInfo.FormatProvider ?? LoggingConfiguration?.DefaultCultureInfo);
 
-                AppendXmlPropertyObjectValue(prop.Name, propertyValue, Convert.GetTypeCode(propertyValue), sb, orgLength,
-                    default(SingleItemOptimizedHashSet<object>), 0);
+                AppendXmlPropertyObjectValue(prop.Name, propertyValue, sb, orgLength, default(SingleItemOptimizedHashSet<object>), 0);
             }
         }
 
-        private bool AppendXmlPropertyObjectValue(string propName, object propertyValue, TypeCode objTypeCode, StringBuilder sb, int orgLength, SingleItemOptimizedHashSet<object> objectsInPath, int depth, bool ignorePropertiesElementName = false)
+        private bool AppendXmlPropertyObjectValue(string propName, object propertyValue, StringBuilder sb, int orgLength, SingleItemOptimizedHashSet<object> objectsInPath, int depth, bool ignorePropertiesElementName = false)
         {
-            if (propertyValue == null)
-                objTypeCode = TypeCode.Empty;
-
+            IConvertible convertibleValue = propertyValue as IConvertible;
+            TypeCode objTypeCode = propertyValue == null ? TypeCode.Empty : (convertibleValue?.GetTypeCode() ?? TypeCode.Object);
             if (objTypeCode != TypeCode.Object)
             {
-                AppendXmlPropertyValue(propName, propertyValue, objTypeCode, sb, orgLength, false, ignorePropertiesElementName);
+                string xmlValueString = XmlHelper.XmlConvertToString(convertibleValue, objTypeCode, true);
+                AppendXmlPropertyValue(propName, xmlValueString, sb, orgLength, false, ignorePropertiesElementName);
             }
             else
             {
@@ -456,19 +457,21 @@ private bool AppendXmlPropertyObjectValue(string propName, object propertyValue,
                         AppendXmlDictionaryObject(propName, dict, sb, orgLength, objectsInPath, nextDepth, ignorePropertiesElementName);
                     }
                 }
-                else if (propertyValue is IDictionary<string, object> expando)
+                else if (propertyValue is System.Collections.IEnumerable collection)
                 {
-                    using (StartCollectionScope(ref objectsInPath, expando))
+                    if (_objectReflectionCache.TryLookupExpandoObject(propertyValue, out var propertyValues))
                     {
-                        var propertyValues = new ObjectReflectionCache.ObjectPropertyList(expando);
-                        AppendXmlObjectPropertyValues(propName, ref propertyValues, sb, orgLength, ref objectsInPath, nextDepth, ignorePropertiesElementName);
+                        using (new SingleItemOptimizedHashSet<object>.SingleItemScopedInsert(propertyValue, ref objectsInPath, false, _referenceEqualsComparer))
+                        {
+                            AppendXmlObjectPropertyValues(propName, ref propertyValues, sb, orgLength, ref objectsInPath, nextDepth, ignorePropertiesElementName);
+                        }
                     }
-                }
-                else if (propertyValue is System.Collections.IEnumerable collection)
-                {
-                    using (StartCollectionScope(ref objectsInPath, collection))
+                    else
                     {
-                        AppendXmlCollectionObject(propName, collection, sb, orgLength, objectsInPath, nextDepth, ignorePropertiesElementName);
+                        using (StartCollectionScope(ref objectsInPath, collection))
+                        {
+                            AppendXmlCollectionObject(propName, collection, sb, orgLength, objectsInPath, nextDepth, ignorePropertiesElementName);
+                        }
                     }
                 }
                 else
@@ -491,7 +494,7 @@ private static SingleItemOptimizedHashSet<object>.SingleItemScopedInsert StartCo
 
         private void AppendXmlCollectionObject(string propName, System.Collections.IEnumerable collection, StringBuilder sb, int orgLength, SingleItemOptimizedHashSet<object> objectsInPath, int depth, bool ignorePropertiesElementName)
         {
-            string propNameElement = AppendXmlPropertyValue(propName, null, TypeCode.Empty, sb, orgLength, true);
+            string propNameElement = AppendXmlPropertyValue(propName, string.Empty, sb, orgLength, true);
             if (!string.IsNullOrEmpty(propNameElement))
             {
                 foreach (var item in collection)
@@ -500,7 +503,7 @@ private void AppendXmlCollectionObject(string propName, System.Collections.IEnum
                     if (beforeValueLength > MaxXmlLength)
                         break;
 
-                    if (!AppendXmlPropertyObjectValue(PropertiesCollectionItemName, item, Convert.GetTypeCode(item), sb, orgLength, objectsInPath, depth, true))
+                    if (!AppendXmlPropertyObjectValue(PropertiesCollectionItemName, item, sb, orgLength, objectsInPath, depth, true))
                     {
                         sb.Length = beforeValueLength;
                     }
@@ -511,7 +514,7 @@ private void AppendXmlCollectionObject(string propName, System.Collections.IEnum
 
         private void AppendXmlDictionaryObject(string propName, System.Collections.IDictionary dictionary, StringBuilder sb, int orgLength, SingleItemOptimizedHashSet<object> objectsInPath, int depth, bool ignorePropertiesElementName)
         {
-            string propNameElement = AppendXmlPropertyValue(propName, null, TypeCode.Empty, sb, orgLength, true, ignorePropertiesElementName);
+            string propNameElement = AppendXmlPropertyValue(propName, string.Empty, sb, orgLength, true, ignorePropertiesElementName);
             if (!string.IsNullOrEmpty(propNameElement))
             {
                 foreach (var item in new DictionaryEntryEnumerable(dictionary))
@@ -520,7 +523,7 @@ private void AppendXmlDictionaryObject(string propName, System.Collections.IDict
                     if (beforeValueLength > MaxXmlLength)
                         break;
 
-                    if (!AppendXmlPropertyObjectValue(item.Key?.ToString(), item.Value, Convert.GetTypeCode(item.Value), sb, orgLength, objectsInPath, depth))
+                    if (!AppendXmlPropertyObjectValue(item.Key?.ToString(), item.Value, sb, orgLength, objectsInPath, depth))
                     {
                         sb.Length = beforeValueLength;
                     }
@@ -531,13 +534,13 @@ private void AppendXmlDictionaryObject(string propName, System.Collections.IDict
 
         private void AppendXmlObjectPropertyValues(string propName, ref ObjectReflectionCache.ObjectPropertyList propertyValues, StringBuilder sb, int orgLength, ref SingleItemOptimizedHashSet<object> objectsInPath, int depth, bool ignorePropertiesElementName = false)
         {
-            if (propertyValues.Count == 0)
+            if (propertyValues.ConvertToString)
             {
-                AppendXmlPropertyValue(propName, propertyValues.ToString(), TypeCode.String, sb, orgLength, false, ignorePropertiesElementName);
+                AppendXmlPropertyValue(propName, propertyValues.ToString(), sb, orgLength, false, ignorePropertiesElementName);
             }
             else
             {
-                string propNameElement = AppendXmlPropertyValue(propName, null, TypeCode.Empty, sb, orgLength, true, ignorePropertiesElementName);
+                string propNameElement = AppendXmlPropertyValue(propName, string.Empty, sb, orgLength, true, ignorePropertiesElementName);
                 if (!string.IsNullOrEmpty(propNameElement))
                 {
                     foreach (var property in propertyValues)
@@ -546,9 +549,18 @@ private void AppendXmlObjectPropertyValues(string propName, ref ObjectReflection
                         if (beforeValueLength > MaxXmlLength)
                             break;
 
-                        if (!AppendXmlPropertyObjectValue(property.Name, property.Value, property.TypeCode, sb, orgLength, objectsInPath, depth))
+                        var propertyTypeCode = property.TypeCode;
+                        if (propertyTypeCode != TypeCode.Object)
                         {
-                            sb.Length = beforeValueLength;
+                            string xmlValueString = XmlHelper.XmlConvertToString((IConvertible)property.Value, propertyTypeCode, true);
+                            AppendXmlPropertyStringValue(property.Name, xmlValueString, sb, orgLength, false, ignorePropertiesElementName);
+                        }
+                        else
+                        {
+                            if (!AppendXmlPropertyObjectValue(property.Name, property.Value, sb, orgLength, objectsInPath, depth))
+                            {
+                                sb.Length = beforeValueLength;
+                            }
                         }
                     }
                     AppendClosingPropertyTag(propNameElement, sb, ignorePropertiesElementName);
@@ -556,7 +568,13 @@ private void AppendXmlObjectPropertyValues(string propName, ref ObjectReflection
             }
         }
 
-        private string AppendXmlPropertyValue(string propName, object propertyValue, TypeCode objTypeCode, StringBuilder sb, int orgLength, bool ignoreValue = false, bool ignorePropertiesElementName = false)
+        private string AppendXmlPropertyValue(string propName, object propertyValue, StringBuilder sb, int orgLength, bool ignoreValue = false, bool ignorePropertiesElementName = false)
+        {
+            string xmlValueString = ignoreValue ? string.Empty : XmlHelper.XmlConvertToStringSafe(propertyValue);
+            return AppendXmlPropertyStringValue(propName, xmlValueString, sb, orgLength, ignoreValue, ignorePropertiesElementName);
+        }
+
+        private string AppendXmlPropertyStringValue(string propName, string xmlValueString, StringBuilder sb, int orgLength, bool ignoreValue = false, bool ignorePropertiesElementName = false)
         {
             if (string.IsNullOrEmpty(PropertiesElementName))
                 return string.Empty; // Not supported 
@@ -598,7 +616,6 @@ private string AppendXmlPropertyValue(string propName, object propertyValue, Typ
 
             if (!ignoreValue)
             {
-                string xmlValueString = XmlHelper.XmlConvertToString(propertyValue, objTypeCode, true);
                 if (RenderAttribute(sb, PropertiesElementValueAttribute, xmlValueString))
                 {
                     sb.Append("/>");
diff --git a/src/NLog/LogFactory.cs b/src/NLog/LogFactory.cs
index 026d223c4d..26493a5ae5 100644
--- a/src/NLog/LogFactory.cs
+++ b/src/NLog/LogFactory.cs
@@ -381,7 +381,7 @@ public Logger GetCurrentClassLogger(Type loggerType)
 #else
             var className = StackTraceUsageUtils.GetClassFullName(new StackFrame(1, false));
 #endif
-            return GetLogger(className, loggerType);
+            return GetLoggerThreadSafe(className, loggerType);
         }
 
         /// <summary>
@@ -392,7 +392,7 @@ public Logger GetCurrentClassLogger(Type loggerType)
         /// are not guaranteed to return the same logger reference.</returns>
         public Logger GetLogger(string name)
         {
-            return GetLogger(new LoggerCacheKey(name, typeof(Logger)));
+            return GetLoggerThreadSafe(name, Logger.DefaultLoggerType);
         }
 
         /// <summary>
@@ -404,7 +404,7 @@ public Logger GetLogger(string name)
         /// are not guaranteed to return the same logger reference.</returns>
         public T GetLogger<T>(string name) where T : Logger
         {
-            return (T)GetLogger(new LoggerCacheKey(name, typeof(T)));
+            return (T)GetLoggerThreadSafe(name, typeof(T));
         }
 
         /// <summary>
@@ -416,7 +416,7 @@ public Logger GetLogger(string name)
         /// same argument aren't guaranteed to return the same logger reference.</returns>
         public Logger GetLogger(string name, Type loggerType)
         {
-            return GetLogger(new LoggerCacheKey(name, loggerType));
+            return GetLoggerThreadSafe(name, loggerType);
         }
 
         /// <summary>
@@ -431,7 +431,6 @@ public void ReconfigExistingLoggers()
             lock (_syncRoot)
             {
                 _config?.InitializeAll();
-
                 loggers = _loggerCache.GetLoggers();
             }
 
@@ -510,7 +509,7 @@ public void Flush(AsyncContinuation asyncContinuation, TimeSpan timeout)
             try
             {
                 InternalLogger.Trace("LogFactory.Flush({0})", timeout);
-                LoggingConfiguration loggingConfiguration = null;
+                LoggingConfiguration loggingConfiguration;
                 lock (_syncRoot)
                 {
                     loggingConfiguration = _config; // Flush should not attempt to auto-load Configuration
@@ -739,8 +738,9 @@ internal LoggerConfiguration GetConfigurationForLogger(string name, LoggingConfi
             }
 
 #pragma warning disable 618
-            return new LoggerConfiguration(targetsByLevel, configuration != null && configuration.ExceptionLoggingOldStyle);
+            var exceptionLoggingOldStyle = configuration?.ExceptionLoggingOldStyle == true;
 #pragma warning restore 618
+            return new LoggerConfiguration(targetsByLevel, exceptionLoggingOldStyle);
         }
 
         /// <summary>
@@ -887,8 +887,13 @@ public void ResetCandidateConfigFilePath()
             _candidateConfigFilePaths = null;
         }
 
-        private Logger GetLogger(LoggerCacheKey cacheKey)
+        private Logger GetLoggerThreadSafe(string name, Type loggerType)
         {
+            if (name == null)
+                throw new ArgumentNullException(nameof(name), "Name of logger cannot be null");
+
+            LoggerCacheKey cacheKey = new LoggerCacheKey(name, loggerType ?? typeof(Logger));
+
             lock (_syncRoot)
             {
                 Logger existingLogger = _loggerCache.Retrieve(cacheKey);
@@ -898,49 +903,44 @@ private Logger GetLogger(LoggerCacheKey cacheKey)
                     return existingLogger;
                 }
 
-                Logger newLogger;
-                if (cacheKey.ConcreteType != null && cacheKey.ConcreteType != typeof(Logger))
+                Logger newLogger = CreateNewLogger(cacheKey.ConcreteType);
+                if (newLogger == null)
                 {
-                    try
-                    {
-                        newLogger = CreateCustomLoggerType(cacheKey.ConcreteType);
-                        if (newLogger == null)
-                        {
-                            // Creating default instance of logger if instance of specified type cannot be created.
-                            newLogger = CreateDefaultLogger(ref cacheKey);
-                        }
-                    }
-                    catch (Exception ex)
-                    {
-                        InternalLogger.Error(ex, "GetLogger / GetCurrentClassLogger. Cannot create instance of type '{0}'. It should have an default contructor.", cacheKey.ConcreteType);
+                    cacheKey = new LoggerCacheKey(cacheKey.Name, typeof(Logger));
+                    newLogger = new Logger();
+                }
 
-                        if (ex.MustBeRethrown())
-                        {
-                            throw;
-                        }
+                newLogger.Initialize(name, GetConfigurationForLogger(name, Configuration), this);
+                _loggerCache.InsertOrUpdate(cacheKey, newLogger);
+                return newLogger;
+            }
+        }
 
-                        // Creating default instance of logger if instance of specified type cannot be created.
-                        newLogger = CreateDefaultLogger(ref cacheKey);
-                    }
-                }
-                else
+        internal Logger CreateNewLogger(Type loggerType)
+        {
+            Logger newLogger;
+            if (loggerType != null && loggerType != typeof(Logger))
+            {
+                try
                 {
-                    newLogger = new Logger();
+                    newLogger = CreateCustomLoggerType(loggerType);
                 }
-
-                if (cacheKey.ConcreteType != null)
+                catch (Exception ex)
                 {
-                    newLogger.Initialize(cacheKey.Name, GetConfigurationForLogger(cacheKey.Name, Configuration), this);
+                    InternalLogger.Error(ex, "GetLogger / GetCurrentClassLogger. Cannot create instance of type '{0}'. It should have an default contructor.", loggerType);
+                    if (ex.MustBeRethrown())
+                    {
+                        throw;
+                    }
+                    newLogger = null;
                 }
-
-                // TODO: Clarify what is the intention when cacheKey.ConcreteType = null.
-                //      At the moment, a logger typeof(Logger) will be created but the ConcreteType 
-                //      will remain null and inserted into the cache. 
-                //      Should we set cacheKey.ConcreteType = typeof(Logger) for default loggers?
-
-                _loggerCache.InsertOrUpdate(cacheKey, newLogger);
-                return newLogger;
             }
+            else
+            {
+                newLogger = new Logger();
+            }
+
+            return newLogger;
         }
 
         private Logger CreateCustomLoggerType(Type customLoggerType)
@@ -978,14 +978,6 @@ private Logger CreateCustomLoggerType(Type customLoggerType)
             }
         }
 
-        private static Logger CreateDefaultLogger(ref LoggerCacheKey cacheKey)
-        {
-            cacheKey = new LoggerCacheKey(cacheKey.Name, typeof(Logger));
-
-            var newLogger = new Logger();
-            return newLogger;
-        }
-
         /// <summary>
         /// Loads logging configuration from file (Currently only XML configuration files supported)
         /// </summary>
@@ -1004,7 +996,7 @@ public LogFactory LoadConfiguration(string configFile)
         /// <summary>
         /// Logger cache key.
         /// </summary>
-        internal struct LoggerCacheKey : IEquatable<LoggerCacheKey>
+        private struct LoggerCacheKey : IEquatable<LoggerCacheKey>
         {
             public readonly string Name;
             public readonly Type ConcreteType;
diff --git a/src/NLog/LogLevel.cs b/src/NLog/LogLevel.cs
index c582f2f7c7..9f115ce5f8 100644
--- a/src/NLog/LogLevel.cs
+++ b/src/NLog/LogLevel.cs
@@ -35,11 +35,12 @@ namespace NLog
 {
     using System;
     using System.Collections.Generic;
-    using NLog.Internal;
+    using System.ComponentModel;
 
     /// <summary>
     /// Defines available log levels.
     /// </summary>
+    [TypeConverter(typeof(Attributes.LogLevelTypeConverter))]
     public sealed class LogLevel : IComparable, IEquatable<LogLevel>, IConvertible
     {
         /// <summary>
@@ -464,7 +465,10 @@ string IConvertible.ToString(IFormatProvider provider)
 
         object IConvertible.ToType(Type conversionType, IFormatProvider provider)
         {
-            return Convert.ChangeType(_ordinal, conversionType, provider);
+            if (conversionType == typeof(string))
+                return Name;
+            else
+                return Convert.ChangeType(_ordinal, conversionType, provider);
         }
 
         ushort IConvertible.ToUInt16(IFormatProvider provider)
diff --git a/src/NLog/Logger-generated.cs b/src/NLog/Logger-generated.cs
index dca69f96fc..f177e21523 100644
--- a/src/NLog/Logger-generated.cs
+++ b/src/NLog/Logger-generated.cs
@@ -48,7 +48,7 @@ public partial class Logger
         /// <returns>A value of <see langword="true" /> if logging is enabled for the <c>Trace</c> level, otherwise it returns <see langword="false" />.</returns>
         public bool IsTraceEnabled
         {
-            get { return _isTraceEnabled; }
+            get { return _contextLogger._isTraceEnabled; }
         }
 
         /// <summary>
@@ -57,7 +57,7 @@ public bool IsTraceEnabled
         /// <returns>A value of <see langword="true" /> if logging is enabled for the <c>Debug</c> level, otherwise it returns <see langword="false" />.</returns>
         public bool IsDebugEnabled
         {
-            get { return _isDebugEnabled; }
+            get { return _contextLogger._isDebugEnabled; }
         }
 
         /// <summary>
@@ -66,7 +66,7 @@ public bool IsDebugEnabled
         /// <returns>A value of <see langword="true" /> if logging is enabled for the <c>Info</c> level, otherwise it returns <see langword="false" />.</returns>
         public bool IsInfoEnabled
         {
-            get { return _isInfoEnabled; }
+            get { return _contextLogger._isInfoEnabled; }
         }
 
         /// <summary>
@@ -75,7 +75,7 @@ public bool IsInfoEnabled
         /// <returns>A value of <see langword="true" /> if logging is enabled for the <c>Warn</c> level, otherwise it returns <see langword="false" />.</returns>
         public bool IsWarnEnabled
         {
-            get { return _isWarnEnabled; }
+            get { return _contextLogger._isWarnEnabled; }
         }
 
         /// <summary>
@@ -84,7 +84,7 @@ public bool IsWarnEnabled
         /// <returns>A value of <see langword="true" /> if logging is enabled for the <c>Error</c> level, otherwise it returns <see langword="false" />.</returns>
         public bool IsErrorEnabled
         {
-            get { return _isErrorEnabled; }
+            get { return _contextLogger._isErrorEnabled; }
         }
 
         /// <summary>
@@ -93,7 +93,7 @@ public bool IsErrorEnabled
         /// <returns>A value of <see langword="true" /> if logging is enabled for the <c>Fatal</c> level, otherwise it returns <see langword="false" />.</returns>
         public bool IsFatalEnabled
         {
-            get { return _isFatalEnabled; }
+            get { return _contextLogger._isFatalEnabled; }
         }
 
 
diff --git a/src/NLog/Logger-generated.tt b/src/NLog/Logger-generated.tt
index 8d5ed2e236..6d0f28b191 100644
--- a/src/NLog/Logger-generated.tt
+++ b/src/NLog/Logger-generated.tt
@@ -55,7 +55,7 @@ namespace NLog
     var levels = new string[]{"Trace", "Debug", "Info", "Warn", "Error", "Fatal"};
 
     foreach(var level in levels)
-    { 
+    {
 #>
         /// <summary>
         /// Gets a value indicating whether logging is enabled for the <c><#=level#></c> level.
@@ -63,7 +63,7 @@ namespace NLog
         /// <returns>A value of <see langword="true" /> if logging is enabled for the <c><#=level#></c> level, otherwise it returns <see langword="false" />.</returns>
         public bool Is<#=level#>Enabled
         {
-            get { return _is<#=level#>Enabled; }
+            get { return _contextLogger._is<#=level#>Enabled; }
         }
 
 <#
diff --git a/src/NLog/Logger.cs b/src/NLog/Logger.cs
index 2537904d2a..ca727f952c 100644
--- a/src/NLog/Logger.cs
+++ b/src/NLog/Logger.cs
@@ -34,12 +34,13 @@
 namespace NLog
 {
     using System;
+    using System.Collections.Generic;
     using System.ComponentModel;
-    using NLog.Internal;
-
 #if NET4_5
     using System.Threading.Tasks;
 #endif
+    using JetBrains.Annotations;
+    using NLog.Internal;
 
     /// <summary>
     /// Provides logging interface and utility functions.
@@ -47,9 +48,10 @@ namespace NLog
     [CLSCompliant(true)]
     public partial class Logger : ILogger
     {
-        private readonly Type _loggerType = typeof(Logger);
-
-        private volatile LoggerConfiguration _configuration;
+        internal static readonly Type DefaultLoggerType = typeof(Logger);
+        private Logger _contextLogger;
+        private ThreadSafeDictionary<string, object> _contextProperties;
+        private LoggerConfiguration _configuration;
         private volatile bool _isTraceEnabled;
         private volatile bool _isDebugEnabled;
         private volatile bool _isInfoEnabled;
@@ -62,6 +64,7 @@ public partial class Logger : ILogger
         /// </summary>
         protected internal Logger()
         {
+            _contextLogger = this;
         }
 
         /// <summary>
@@ -79,6 +82,15 @@ protected internal Logger()
         /// </summary>
         public LogFactory Factory { get; private set; }
 
+        /// <summary>
+        /// Collection of context properties for the Logger. The logger will append it for all log events
+        /// </summary>
+        /// <remarks>
+        /// It is recommended to use <see cref="WithProperty(string, object)"/> for modifying context properties
+        /// when same named logger is used at multiple locations or shared by different thread contexts.
+        /// </remarks>
+        public IDictionary<string, object> Properties => _contextProperties ?? System.Threading.Interlocked.CompareExchange(ref _contextProperties, CreateContextPropertiesDictionary(null), null) ?? _contextProperties;
+
         /// <summary>
         /// Gets a value indicating whether logging is enabled for the specified level.
         /// </summary>
@@ -94,17 +106,69 @@ public bool IsEnabled(LogLevel level)
             return GetTargetsForLevel(level) != null;
         }
 
+        /// <summary>
+        /// Creates new logger that automatically appends the specified property to all log events (without changing current logger)
+        /// </summary>
+        /// <param name="propertyKey">Property Name</param>
+        /// <param name="propertyValue">Property Value</param>
+        /// <returns>New Logger object that automatically appends specified property</returns>
+        public Logger WithProperty(string propertyKey, object propertyValue)
+        {
+            if (string.IsNullOrEmpty(propertyKey))
+                throw new ArgumentException(nameof(propertyKey));
+
+            Logger newLogger = Factory.CreateNewLogger(GetType()) ?? new Logger();
+            newLogger.Initialize(Name, _configuration, Factory);
+            newLogger._contextProperties = CreateContextPropertiesDictionary(_contextProperties);
+            newLogger._contextProperties[propertyKey] = propertyValue;
+            newLogger._contextLogger = _contextLogger;  // Use the LoggerConfiguration of the parent Logger
+            return newLogger;
+        }
+
+        /// <summary>
+        /// Updates the specified context property for the current logger. The logger will append it for all log events.
+        ///
+        /// It could be rendered with ${event-properties:YOURNAME}
+        ///
+        /// With <see cref="Properties"/> property, all properties could be changed. 
+        /// </summary>
+        /// <remarks>
+        /// Will affect all locations/contexts that makes use of the same named logger object.
+        /// </remarks>
+        /// <param name="propertyKey">Property Name</param>
+        /// <param name="propertyValue">Property Value</param>
+        /// <remarks>
+        /// It is recommended to use <see cref="WithProperty(string, object)"/> for modifying context properties
+        /// when same named logger is used at multiple locations or shared by different thread contexts.
+        /// </remarks>
+        public void SetProperty(string propertyKey, object propertyValue)
+        {
+            if (string.IsNullOrEmpty(propertyKey))
+                throw new ArgumentException(nameof(propertyKey));
+
+            Properties[propertyKey] = propertyValue;
+        }
+
+        private static ThreadSafeDictionary<string, object> CreateContextPropertiesDictionary(ThreadSafeDictionary<string, object> contextProperties)
+        {
+            contextProperties = contextProperties != null
+                ? new ThreadSafeDictionary<string, object>(contextProperties)
+                : new ThreadSafeDictionary<string, object>();
+            return contextProperties;
+        }
+
         /// <summary>
         /// Writes the specified diagnostic message.
         /// </summary>
         /// <param name="logEvent">Log event.</param>
         public void Log(LogEventInfo logEvent)
         {
-            if (IsEnabled(logEvent.Level))
+            var targetsForLevel = IsEnabled(logEvent.Level) ? GetTargetsForLevel(logEvent.Level) : null;
+            if (targetsForLevel != null)
             {
                 if (logEvent.LoggerName == null)
                     logEvent.LoggerName = Name;
-                WriteToTargets(logEvent);
+                WriteToTargets(logEvent, targetsForLevel);
             }
         }
 
@@ -115,11 +179,12 @@ public void Log(LogEventInfo logEvent)
         /// <param name="logEvent">Log event.</param>
         public void Log(Type wrapperType, LogEventInfo logEvent)
         {
-            if (IsEnabled(logEvent.Level))
+            var targetsForLevel = IsEnabled(logEvent.Level) ? GetTargetsForLevel(logEvent.Level) : null;
+            if (targetsForLevel != null)
             {
                 if (logEvent.LoggerName == null)
                     logEvent.LoggerName = Name;
-                WriteToTargets(wrapperType, logEvent);
+                WriteToTargets(wrapperType, logEvent, targetsForLevel);
             }
         }
 
@@ -197,10 +262,10 @@ public void LogException(LogLevel level, [Localizable(false)] string message, Ex
         /// <param name="args">Arguments to format.</param>
         [MessageTemplateFormatMethod("message")]
         public void Log(LogLevel level, IFormatProvider formatProvider, [Localizable(false)] string message, params object[] args)
-        { 
+        {
             if (IsEnabled(level))
             {
-                WriteToTargets(level, formatProvider, message, args); 
+                WriteToTargets(level, formatProvider, message, args);
             }
         }
 
@@ -209,8 +274,8 @@ public void Log(LogLevel level, IFormatProvider formatProvider, [Localizable(fal
         /// </summary>
         /// <param name="level">The log level.</param>
         /// <param name="message">Log message.</param>
-        public void Log(LogLevel level, [Localizable(false)] string message) 
-        { 
+        public void Log(LogLevel level, [Localizable(false)] string message)
+        {
             if (IsEnabled(level))
             {
                 WriteToTargets(level, null, message);
@@ -224,8 +289,8 @@ public void Log(LogLevel level, [Localizable(false)] string message)
         /// <param name="message">A <see langword="string" /> containing format items.</param>
         /// <param name="args">Arguments to format.</param>
         [MessageTemplateFormatMethod("message")]
-        public void Log(LogLevel level, [Localizable(false)] string message, params object[] args) 
-        { 
+        public void Log(LogLevel level, [Localizable(false)] string message, params object[] args)
+        {
             if (IsEnabled(level))
             {
                 WriteToTargets(level, message, args);
@@ -291,10 +356,10 @@ public void Log(LogLevel level, Exception exception, IFormatProvider formatProvi
         /// <param name="argument">The argument to format.</param>
         [MessageTemplateFormatMethod("message")]
         public void Log<TArgument>(LogLevel level, IFormatProvider formatProvider, [Localizable(false)] string message, TArgument argument)
-        { 
+        {
             if (IsEnabled(level))
             {
-                WriteToTargets(level, formatProvider, message, new object[] { argument }); 
+                WriteToTargets(level, formatProvider, message, new object[] { argument });
             }
         }
 
@@ -325,11 +390,11 @@ public void Log<TArgument>(LogLevel level, [Localizable(false)] string message,
         /// <param name="argument1">The first argument to format.</param>
         /// <param name="argument2">The second argument to format.</param>
         [MessageTemplateFormatMethod("message")]
-        public void Log<TArgument1, TArgument2>(LogLevel level, IFormatProvider formatProvider, [Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2) 
-        { 
+        public void Log<TArgument1, TArgument2>(LogLevel level, IFormatProvider formatProvider, [Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2)
+        {
             if (IsEnabled(level))
             {
-                WriteToTargets(level, formatProvider, message, new object[] { argument1, argument2 }); 
+                WriteToTargets(level, formatProvider, message, new object[] { argument1, argument2 });
             }
         }
 
@@ -344,7 +409,7 @@ public void Log<TArgument>(LogLevel level, [Localizable(false)] string message,
         /// <param name="argument2">The second argument to format.</param>
         [MessageTemplateFormatMethod("message")]
         public void Log<TArgument1, TArgument2>(LogLevel level, [Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2)
-        { 
+        {
             if (IsEnabled(level))
             {
                 WriteToTargets(level, message, new object[] { argument1, argument2 });
@@ -364,11 +429,11 @@ public void Log<TArgument>(LogLevel level, [Localizable(false)] string message,
         /// <param name="argument2">The second argument to format.</param>
         /// <param name="argument3">The third argument to format.</param>
         [MessageTemplateFormatMethod("message")]
-        public void Log<TArgument1, TArgument2, TArgument3>(LogLevel level, IFormatProvider formatProvider, [Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3) 
-        { 
+        public void Log<TArgument1, TArgument2, TArgument3>(LogLevel level, IFormatProvider formatProvider, [Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3)
+        {
             if (IsEnabled(level))
             {
-                WriteToTargets(level, formatProvider, message, new object[] { argument1, argument2, argument3 }); 
+                WriteToTargets(level, formatProvider, message, new object[] { argument1, argument2, argument3 });
             }
         }
 
@@ -385,32 +450,30 @@ public void Log<TArgument>(LogLevel level, [Localizable(false)] string message,
         /// <param name="argument3">The third argument to format.</param>
         [MessageTemplateFormatMethod("message")]
         public void Log<TArgument1, TArgument2, TArgument3>(LogLevel level, [Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3)
-        { 
+        {
             if (IsEnabled(level))
             {
                 WriteToTargets(level, message, new object[] { argument1, argument2, argument3 });
             }
         }
 
-        private void WriteToTargets(LogLevel level, Exception ex, [Localizable(false)] string message, object[] args)
-        {
-            LoggerImpl.Write(_loggerType, GetTargetsForLevel(level), PrepareLogEventInfo(LogEventInfo.Create(level, Name, ex, Factory.DefaultCultureInfo, message, args)), Factory);
-        }
-
-        private void WriteToTargets(LogLevel level, Exception ex, IFormatProvider formatProvider, [Localizable(false)] string message, object[] args)
-        {
-            LoggerImpl.Write(_loggerType, GetTargetsForLevel(level), PrepareLogEventInfo(LogEventInfo.Create(level, Name, ex, formatProvider, message, args)), Factory);
-        }
-
-
         private LogEventInfo PrepareLogEventInfo(LogEventInfo logEvent)
         {
             if (logEvent.FormatProvider == null)
             {
                 logEvent.FormatProvider = Factory.DefaultCultureInfo;
             }
+            if (_contextProperties != null)
+            {
+                foreach (var property in _contextProperties)
+                {
+                    if (!logEvent.Properties.ContainsKey(property.Key))
+                    {
+                        logEvent.Properties[property.Key] = property.Value;
+                    }
+                }
+            }
             return logEvent;
-
         }
 
         #endregion
@@ -557,38 +620,71 @@ internal void Initialize(string name, LoggerConfiguration loggerConfiguration, L
             SetConfiguration(loggerConfiguration);
         }
 
-        internal void WriteToTargets(LogLevel level, IFormatProvider formatProvider, [Localizable(false)] string message, object[] args)
+        private void WriteToTargets(LogLevel level, [Localizable(false)] string message, object[] args)
+        {
+            WriteToTargets(level, Factory.DefaultCultureInfo, message, args);
+        }
+
+        private void WriteToTargets(LogLevel level, IFormatProvider formatProvider, [Localizable(false)] string message, object[] args)
         {
-            LoggerImpl.Write(_loggerType, GetTargetsForLevel(level), PrepareLogEventInfo(LogEventInfo.Create(level, Name, formatProvider, message, args)), Factory);
+            var targetsForLevel = GetTargetsForLevel(level);
+            if (targetsForLevel != null)
+            {
+                var logEvent = LogEventInfo.Create(level, Name, formatProvider, message, args);
+                WriteToTargets(logEvent, targetsForLevel);
+            }
         }
 
         private void WriteToTargets(LogLevel level, IFormatProvider formatProvider, [Localizable(false)] string message)
         {
-            // please note that this overload calls the overload of LogEventInfo.Create with object[] parameter on purpose -
-            // to avoid unnecessary string.Format (in case of calling Create(LogLevel, string, IFormatProvider, object))
-            var logEvent = LogEventInfo.Create(level, Name, formatProvider, message, (object[])null);
-            LoggerImpl.Write(_loggerType, GetTargetsForLevel(level), PrepareLogEventInfo(logEvent), Factory);
+            var targetsForLevel = GetTargetsForLevel(level);
+            if (targetsForLevel != null)
+            {
+                // please note that this overload calls the overload of LogEventInfo.Create with object[] parameter on purpose -
+                // to avoid unnecessary string.Format (in case of calling Create(LogLevel, string, IFormatProvider, object))
+                var logEvent = LogEventInfo.Create(level, Name, formatProvider, message, (object[])null);
+                WriteToTargets(logEvent, targetsForLevel);
+            }
         }
 
         private void WriteToTargets<T>(LogLevel level, IFormatProvider formatProvider, T value)
         {
-            var logEvent = PrepareLogEventInfo(LogEventInfo.Create(level, Name, formatProvider, value));
-            LoggerImpl.Write(_loggerType, GetTargetsForLevel(level), logEvent, Factory);
+            var targetsForLevel = GetTargetsForLevel(level);
+            if (targetsForLevel != null)
+            {
+                var logEvent = LogEventInfo.Create(level, Name, formatProvider, value);
+                WriteToTargets(logEvent, targetsForLevel);
+            }
         }
 
-        internal void WriteToTargets(LogLevel level, [Localizable(false)] string message, object[] args)
+        private void WriteToTargets(LogLevel level, Exception ex, [Localizable(false)] string message, object[] args)
         {
-            WriteToTargets(level, Factory.DefaultCultureInfo, message, args);
+            var targetsForLevel = GetTargetsForLevel(level);
+            if (targetsForLevel != null)
+            {
+                var logEvent = LogEventInfo.Create(level, Name, ex, Factory.DefaultCultureInfo, message, args);
+                WriteToTargets(logEvent, targetsForLevel);
+            }
         }
 
-        private void WriteToTargets(LogEventInfo logEvent)
+        private void WriteToTargets(LogLevel level, Exception ex, IFormatProvider formatProvider, [Localizable(false)] string message, object[] args)
+        {
+            var targetsForLevel = GetTargetsForLevel(level);
+            if (targetsForLevel != null)
+            {
+                var logEvent = LogEventInfo.Create(level, Name, ex, formatProvider, message, args);
+                WriteToTargets(logEvent, targetsForLevel);
+            }
+        }
+
+        private void WriteToTargets([NotNull] LogEventInfo logEvent, [NotNull] TargetWithFilterChain targetsForLevel)
         {
-            LoggerImpl.Write(_loggerType, GetTargetsForLevel(logEvent.Level), PrepareLogEventInfo(logEvent), Factory);
+            LoggerImpl.Write(DefaultLoggerType, targetsForLevel, PrepareLogEventInfo(logEvent), Factory);
         }
 
-        private void WriteToTargets(Type wrapperType, LogEventInfo logEvent)
+        private void WriteToTargets(Type wrapperType, [NotNull] LogEventInfo logEvent, [NotNull] TargetWithFilterChain targetsForLevel)
         {
-            LoggerImpl.Write(wrapperType ?? _loggerType, GetTargetsForLevel(logEvent.Level), PrepareLogEventInfo(logEvent), Factory);
+            LoggerImpl.Write(wrapperType ?? DefaultLoggerType, targetsForLevel, PrepareLogEventInfo(logEvent), Factory);
         }
 
         internal void SetConfiguration(LoggerConfiguration newConfiguration)
@@ -596,19 +692,22 @@ internal void SetConfiguration(LoggerConfiguration newConfiguration)
             _configuration = newConfiguration;
 
             // pre-calculate 'enabled' flags
-            _isTraceEnabled = newConfiguration.IsEnabled(LogLevel.Trace);
-            _isDebugEnabled = newConfiguration.IsEnabled(LogLevel.Debug);
-            _isInfoEnabled = newConfiguration.IsEnabled(LogLevel.Info);
-            _isWarnEnabled = newConfiguration.IsEnabled(LogLevel.Warn);
-            _isErrorEnabled = newConfiguration.IsEnabled(LogLevel.Error);
-            _isFatalEnabled = newConfiguration.IsEnabled(LogLevel.Fatal);
+            _isTraceEnabled = IsEnabled(LogLevel.Trace);
+            _isDebugEnabled = IsEnabled(LogLevel.Debug);
+            _isInfoEnabled = IsEnabled(LogLevel.Info);
+            _isWarnEnabled = IsEnabled(LogLevel.Warn);
+            _isErrorEnabled = IsEnabled(LogLevel.Error);
+            _isFatalEnabled = IsEnabled(LogLevel.Fatal);
 
             OnLoggerReconfigured(EventArgs.Empty);
         }
 
         private TargetWithFilterChain GetTargetsForLevel(LogLevel level)
         {
-            return _configuration.GetTargetsForLevel(level);
+            if (ReferenceEquals(_contextLogger, this))
+                return _configuration.GetTargetsForLevel(level);
+            else
+                return _contextLogger.GetTargetsForLevel(level);    // Use the LoggerConfiguration of the parent Logger
         }
 
         /// <summary>
@@ -617,11 +716,7 @@ private TargetWithFilterChain GetTargetsForLevel(LogLevel level)
         /// <param name="e">Event arguments</param>
         protected virtual void OnLoggerReconfigured(EventArgs e)
         {
-            var reconfigured = LoggerReconfigured;
-            if (reconfigured != null)
-            {
-                reconfigured(this, e);
-            }
+            LoggerReconfigured?.Invoke(this, e);
         }
     }
 }
diff --git a/src/NLog/LoggerImpl.cs b/src/NLog/LoggerImpl.cs
index 99debbfe4d..21d4a1e886 100644
--- a/src/NLog/LoggerImpl.cs
+++ b/src/NLog/LoggerImpl.cs
@@ -51,15 +51,10 @@ internal static class LoggerImpl
         private const int StackTraceSkipMethods = 0;
 
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly", Justification = "Using 'NLog' in message.")]
-        internal static void Write([NotNull] Type loggerType, TargetWithFilterChain targets, LogEventInfo logEvent, LogFactory factory)
+        internal static void Write([NotNull] Type loggerType, [NotNull] TargetWithFilterChain targetsForLevel, LogEventInfo logEvent, LogFactory factory)
         {
-            if (targets == null)
-            {
-                return;
-            }
-
 #if !NETSTANDARD1_0 || NETSTANDARD1_5
-            StackTraceUsage stu = targets.GetStackTraceUsage();
+            StackTraceUsage stu = targetsForLevel.GetStackTraceUsage();
             if (stu != StackTraceUsage.None && !logEvent.HasStackTrace)
             {
 #if NETSTANDARD1_5
@@ -89,7 +84,7 @@ internal static void Write([NotNull] Type loggerType, TargetWithFilterChain targ
                 };
             }
 
-            if (targets.NextInChain == null && logEvent.CanLogEventDeferMessageFormat())
+            if (targetsForLevel.NextInChain == null && logEvent.CanLogEventDeferMessageFormat())
             {
                 // Change MessageFormatter so it writes directly to StringBuilder without string-allocation
                 logEvent.MessageFormatter = LogMessageTemplateFormatter.DefaultAutoSingleTarget.MessageFormatter;
@@ -97,7 +92,7 @@ internal static void Write([NotNull] Type loggerType, TargetWithFilterChain targ
 
             IList<Filter> prevFilterChain = null;
             FilterResult prevFilterResult = FilterResult.Neutral;
-            for (var t = targets; t != null; t = t.NextInChain)
+            for (var t = targetsForLevel; t != null; t = t.NextInChain)
             {
                 FilterResult result = ReferenceEquals(prevFilterChain, t.FilterChain) ?
                     prevFilterResult : GetFilterResult(t.FilterChain, logEvent, t.DefaultResult);
diff --git a/src/NLog/MDC.cs b/src/NLog/MDC.cs
index e5f9ffd5c9..ec1c97992b 100644
--- a/src/NLog/MDC.cs
+++ b/src/NLog/MDC.cs
@@ -37,7 +37,7 @@ namespace NLog
     using Config;
 
     /// <summary>
-    /// Mapped Diagnostics Context - used for log4net compatibility.
+    /// Mapped Diagnostics Context
     /// </summary>
     /// <remarks>This class marked as obsolete before NLog 2.0 and it may be removed in a future release.</remarks>
     [Obsolete("Use MappedDiagnosticsContext class instead. Marked obsolete on NLog 2.0")]
diff --git a/src/NLog/MappedDiagnosticsContext.cs b/src/NLog/MappedDiagnosticsContext.cs
index c0517de074..38c2412e61 100644
--- a/src/NLog/MappedDiagnosticsContext.cs
+++ b/src/NLog/MappedDiagnosticsContext.cs
@@ -44,7 +44,6 @@ namespace NLog
     /// <summary>
     /// Mapped Diagnostics Context - a thread-local structure that keeps a dictionary
     /// of strings and provides methods to output them in layouts. 
-    /// Mostly for compatibility with log4net.
     /// </summary>
     public static class MappedDiagnosticsContext
     {
@@ -52,10 +51,7 @@ public static class MappedDiagnosticsContext
 
         private static readonly IDictionary<string, object> EmptyDefaultDictionary = new SortHelpers.ReadOnlySingleBucketDictionary<string, object>();
 
-        /// <summary>
-        /// 
-        /// </summary>
-        private class ItemRemover : IDisposable
+        private sealed class ItemRemover : IDisposable
         {
             private readonly string _item;
             private bool _disposed;
diff --git a/src/NLog/MappedDiagnosticsLogicalContext.cs b/src/NLog/MappedDiagnosticsLogicalContext.cs
index 5edd936f34..98e2f24c7d 100644
--- a/src/NLog/MappedDiagnosticsLogicalContext.cs
+++ b/src/NLog/MappedDiagnosticsLogicalContext.cs
@@ -51,7 +51,7 @@ namespace NLog
     /// </remarks>
     public static class MappedDiagnosticsLogicalContext
     {
-        private class ItemRemover : IDisposable
+        private sealed class ItemRemover : IDisposable
         {
             private readonly string _item1;
 #if NET4_5
diff --git a/src/NLog/MessageTemplates/MessageTemplateParameter.cs b/src/NLog/MessageTemplates/MessageTemplateParameter.cs
index f9b76f3a22..d9018f2076 100644
--- a/src/NLog/MessageTemplates/MessageTemplateParameter.cs
+++ b/src/NLog/MessageTemplates/MessageTemplateParameter.cs
@@ -87,10 +87,9 @@ public struct MessageTemplateParameter
                     case "8": return 8;
                     case "9": return 9;
                     default:
-                        if (Name?.Length >= 1 && Name[0] >= '0' && Name[0] <= '9')
+                        if (Name?.Length >= 1 && Name[0] >= '0' && Name[0] <= '9' && int.TryParse(Name, out var parameterIndex))
                         {
-                            if (int.TryParse(Name, out var parameterIndex))
-                                return parameterIndex;
+                            return parameterIndex;
                         }
                         return null;
                 }
diff --git a/src/NLog/MessageTemplates/TemplateEnumerator.cs b/src/NLog/MessageTemplates/TemplateEnumerator.cs
index 008d82c500..97ab115a03 100644
--- a/src/NLog/MessageTemplates/TemplateEnumerator.cs
+++ b/src/NLog/MessageTemplates/TemplateEnumerator.cs
@@ -221,22 +221,10 @@ private string ParseName(out int parameterIndex)
                     {
                         // Non-allocating positional hole-name-parsing
                         parameterIndex = parsed;
-                        switch (parameterIndex)
-                        {
-                            case 0: return "0";
-                            case 1: return "1";
-                            case 2: return "2";
-                            case 3: return "3";
-                            case 4: return "4";
-                            case 5: return "5";
-                            case 6: return "6";
-                            case 7: return "7";
-                            case 8: return "8";
-                            case 9: return "9";
-                        }
-                        return parameterIndex.ToString(System.Globalization.CultureInfo.InvariantCulture);
+                        return ParameterIndexToString(parameterIndex);
                     }
-                    else if (c == ' ')
+
+                    if (c == ' ')
                     {
                         SkipSpaces();
                         c = Peek();
@@ -251,6 +239,25 @@ private string ParseName(out int parameterIndex)
             return ReadUntil(HoleDelimiters);
         }
 
+        private static string ParameterIndexToString(int parameterIndex)
+        {
+            switch (parameterIndex)
+            {
+                case 0: return "0";
+                case 1: return "1";
+                case 2: return "2";
+                case 3: return "3";
+                case 4: return "4";
+                case 5: return "5";
+                case 6: return "6";
+                case 7: return "7";
+                case 8: return "8";
+                case 9: return "9";
+            }
+
+            return parameterIndex.ToString(System.Globalization.CultureInfo.InvariantCulture);
+        }
+
         /// <summary>
         /// Parse format after hole name/index. Handle the escaped { and } in the format. Don't read the last }
         /// </summary>
diff --git a/src/NLog/MessageTemplates/ValueFormatter.cs b/src/NLog/MessageTemplates/ValueFormatter.cs
index d8ca215e7e..bb40d19461 100644
--- a/src/NLog/MessageTemplates/ValueFormatter.cs
+++ b/src/NLog/MessageTemplates/ValueFormatter.cs
@@ -34,6 +34,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Text;
 using NLog.Config;
 using NLog.Internal;
@@ -108,7 +109,7 @@ public bool FormatValue(object value, string format, CaptureType captureType, IF
         /// <returns></returns>
         public bool FormatObject(object value, string format, IFormatProvider formatProvider, StringBuilder builder)
         {
-            if (SerializeSimpleObject(value, format, formatProvider, builder))
+            if (SerializeSimpleObject(value, format, formatProvider, builder, false))
             {
                 return true;
             }
@@ -119,26 +120,18 @@ public bool FormatObject(object value, string format, IFormatProvider formatProv
                 return SerializeWithoutCyclicLoop(collection, format, formatProvider, builder, default(SingleItemOptimizedHashSet<object>), 0);
             }
 
-            builder.Append(Convert.ToString(value, formatProvider));
+            SerializeConvertToString(value, formatProvider, builder);
             return true;
         }
 
         /// <summary>
         /// Try serialising a scalar (string, int, NULL) or simple type (IFormattable)
         /// </summary>
-        /// <param name="value"></param>
-        /// <param name="format"></param>
-        /// <param name="formatProvider"></param>
-        /// <param name="builder"></param>
-        /// <returns></returns>
-        private bool SerializeSimpleObject(object value, string format, IFormatProvider formatProvider, StringBuilder builder)
+        private bool SerializeSimpleObject(object value, string format, IFormatProvider formatProvider, StringBuilder builder, bool convertToString = true)
         {
             if (value is string stringValue)
             {
-                bool includeQuotes = format != LiteralFormatSymbol;
-                if (includeQuotes) builder.Append('"');
-                builder.Append(stringValue);
-                if (includeQuotes) builder.Append('"');
+                SerializeStringObject(stringValue, format, builder);
                 return true;
             }
 
@@ -148,66 +141,104 @@ private bool SerializeSimpleObject(object value, string format, IFormatProvider
                 return true;
             }
 
-            IFormattable formattable;
-            if (!string.IsNullOrEmpty(format) && (formattable = value as IFormattable) != null)
+            // Optimize for types that are pretty much invariant in all cultures when no format-string
+            if (value is IConvertible convertibleValue)
             {
-                builder.Append(formattable.ToString(format, formatProvider));
+                SerializeConvertibleObject(convertibleValue, format, formatProvider, builder);
                 return true;
             }
             else
             {
-                // Optimize for types that are pretty much invariant in all cultures when no format-string
-                TypeCode objTypeCode = Convert.GetTypeCode(value);
-                switch (objTypeCode)
+                if (!string.IsNullOrEmpty(format) && value is IFormattable formattable)
                 {
-                    case TypeCode.Boolean:
-                        {
-                            builder.Append(((bool)value) ? "true" : "false");
-                            return true;
-                        }
-                    case TypeCode.Char:
+                    builder.Append(formattable.ToString(format, formatProvider));
+                    return true;
+                }
+
+                if (convertToString)
+                {
+                    SerializeConvertToString(value, formatProvider, builder);
+                    return true;
+                }
+
+                return false;
+            }
+        }
+
+        private void SerializeConvertibleObject(IConvertible value, string format, IFormatProvider formatProvider, StringBuilder builder)
+        {
+            TypeCode convertibleTypeCode = value.GetTypeCode();
+            if (convertibleTypeCode == TypeCode.String)
+            {
+                SerializeStringObject(value.ToString(), format, builder);
+                return;
+            }
+
+            if (!string.IsNullOrEmpty(format) && value is IFormattable formattable)
+            {
+                builder.Append(formattable.ToString(format, formatProvider));
+                return;
+            }
+
+            switch (convertibleTypeCode)
+            {
+                case TypeCode.Boolean:
+                    {
+                        builder.Append(value.ToBoolean(CultureInfo.InvariantCulture) ? "true" : "false");
+                        break;
+                    }
+                case TypeCode.Char:
+                    {
+                        bool includeQuotes = format != LiteralFormatSymbol;
+                        if (includeQuotes) builder.Append('"');
+                        builder.Append(value.ToChar(CultureInfo.InvariantCulture));
+                        if (includeQuotes) builder.Append('"');
+                        break;
+                    }
+
+                case TypeCode.Byte:
+                case TypeCode.SByte:
+                case TypeCode.Int16:
+                case TypeCode.Int32:
+                case TypeCode.Int64:
+                case TypeCode.UInt16:
+                case TypeCode.UInt32:
+                case TypeCode.UInt64:
+                    {
+                        if (value is Enum enumValue)
                         {
-                            bool includeQuotes = format != LiteralFormatSymbol;
-                            if (includeQuotes) builder.Append('"');
-                            builder.Append((char)value);
-                            if (includeQuotes) builder.Append('"');
-                            return true;
+                            AppendEnumAsString(builder, enumValue);
                         }
-
-                    case TypeCode.Byte:
-                    case TypeCode.SByte:
-                    case TypeCode.Int16:
-                    case TypeCode.Int32:
-                    case TypeCode.Int64:
-                    case TypeCode.UInt16:
-                    case TypeCode.UInt32:
-                    case TypeCode.UInt64:
+                        else
                         {
-                            Enum enumValue;
-                            if ((enumValue = value as Enum) != null)
-                            {
-                                AppendEnumAsString(builder, enumValue);
-                            }
-                            else
-                            {
-                                builder.AppendIntegerAsString(value, objTypeCode);
-                            }
+                            builder.AppendIntegerAsString(value, convertibleTypeCode);
                         }
-                        return true;
-
-                    case TypeCode.Object:   // Guid, TimeSpan, DateTimeOffset
-                    default:                // Single, Double, Decimal, etc.
                         break;
-                }
+                    }
+
+                case TypeCode.Object:   // Guid, TimeSpan, DateTimeOffset
+                default:                // Single, Double, Decimal, etc.
+                    SerializeConvertToString(value, formatProvider, builder);
+                    break;
             }
+        }
 
-            return false;
+        private static void SerializeConvertToString(object value, IFormatProvider formatProvider, StringBuilder builder)
+        {
+            builder.Append(Convert.ToString(value, formatProvider));
+        }
+
+        private static void SerializeStringObject(string stringValue, string format, StringBuilder builder)
+        {
+            bool includeQuotes = format != LiteralFormatSymbol;
+            if (includeQuotes) builder.Append('"');
+            builder.Append(stringValue);
+            if (includeQuotes) builder.Append('"');
         }
 
         private void AppendEnumAsString(StringBuilder sb, Enum value)
         {
-            string textValue;
-            if (!_enumCache.TryGetValue(value, out textValue))
+            if (!_enumCache.TryGetValue(value, out var textValue))
             {
                 textValue = value.ToString();
                 _enumCache.TryAddValue(value, textValue);
@@ -265,15 +296,9 @@ private bool SerializeDictionaryObject(IDictionary dictionary, string format, IF
 
                 if (separator) builder.Append(", ");
 
-                if (item.Key is string || !(item.Key is IEnumerable))
-                    FormatObject(item.Key, format, formatProvider, builder);
-                else
-                    SerializeWithoutCyclicLoop((IEnumerable)item.Key, format, formatProvider, builder, objectsInPath, depth + 1);
+                SerializeCollectionItem(item.Key, format, formatProvider, builder, ref objectsInPath, depth);
                 builder.Append("=");
-                if (item.Value is string || !(item.Value is IEnumerable))
-                    FormatObject(item.Value, format, formatProvider, builder);
-                else
-                    SerializeWithoutCyclicLoop((IEnumerable)item.Value, format, formatProvider, builder, objectsInPath, depth + 1);
+                SerializeCollectionItem(item.Value, format, formatProvider, builder, ref objectsInPath, depth);
                 separator = true;
             }
             return true;
@@ -289,16 +314,23 @@ private bool SerializeCollectionObject(IEnumerable collection, string format, IF
 
                 if (separator) builder.Append(", ");
 
-                if (item is string || !(item is IEnumerable))
-                    FormatObject(item, format, formatProvider, builder);
-                else
-                    SerializeWithoutCyclicLoop((IEnumerable)item, format, formatProvider, builder, objectsInPath, depth + 1);
+                SerializeCollectionItem(item, format, formatProvider, builder, ref objectsInPath, depth);
 
                 separator = true;
             }
             return true;
         }
 
+        private void SerializeCollectionItem(object item, string format, IFormatProvider formatProvider, StringBuilder builder, ref SingleItemOptimizedHashSet<object> objectsInPath, int depth)
+        {
+            if (item is IConvertible convertible)
+                SerializeConvertibleObject(convertible, format, formatProvider, builder);
+            else if (item is IEnumerable enumerable)
+                SerializeWithoutCyclicLoop(enumerable, format, formatProvider, builder, objectsInPath, depth + 1);
+            else
+                SerializeSimpleObject(item, format, formatProvider, builder);
+        }
+
         /// <summary>
         /// Convert a value to a string with format and append to <paramref name="builder"/>.
         /// </summary>
diff --git a/src/NLog/NDC.cs b/src/NLog/NDC.cs
index 5e5b99a776..2282091e03 100644
--- a/src/NLog/NDC.cs
+++ b/src/NLog/NDC.cs
@@ -36,7 +36,7 @@ namespace NLog
     using System;
 
     /// <summary>
-    /// Nested Diagnostics Context - for log4net compatibility.
+    /// Nested Diagnostics Context
     /// </summary>
     /// <remarks>This class marked as obsolete on NLog 2.0 and it may be removed in a future release.</remarks>
     [Obsolete("Use NestedDiagnosticsContext class instead. Marked obsolete on NLog 2.0")]
diff --git a/src/NLog/NLog.csproj b/src/NLog/NLog.csproj
index 04022ec2b5..e660eb71f2 100644
--- a/src/NLog/NLog.csproj
+++ b/src/NLog/NLog.csproj
@@ -31,10 +31,34 @@ For ASP.NET Core, check: https://www.nuget.org/packages/NLog.Web.AspNetCore
     <Copyright>Copyright (c) 2004-$(CurrentYear) NLog Project - https://nlog-project.org/ </Copyright>
     
     <PackageReleaseNotes>
+
 Bugfixes:
 
-- Fix escaping nested close brackets when parsing layout renderers (@lobster2012-user)
-- NLog config - Fixed bug where empty xml-elements were ignored (@snakefoot, @jonreis)
+- NLog.Schema: Added missing defaultAction attribute on filters element in XSD (@304NotModified)
+- AsyncWrapper in Blocking Mode can cause deadlock (@snakefoot)
+
+Features:
+
+- Added &quot;Properties&quot; property on Logger for reading and editing properties.(@snakefoot, @304NotModified)
+- ${all-event-properties}: Added IncludeEmptyValues option (@304NotModified)
+- ${when}, support for non-string values (@304NotModified)
+- ${whenEmpty} support for non-string values (@snakefoot, @304NotModified)
+- Added ${environment-user} (@snakefoot)
+- Log4JXmlEventLayout - Added support for configuration of Parameters (@snakefoot)
+- LoggingConfigurationParser - Recognize LoggingRule.RuleName property (@snakefoot)
+
+Improvements:
+
+- Update package descriptions to note the issues with &lt;PackageReference&gt; (@304NotModified)
+- Various XSD improvements (NLog.Schema package) (@304NotModified)
+
+Performance:
+
+- ${whenEmpty} faster rendering of string values (@snakefoot, @304NotModified)
+- FilteringTargetWrapper: Add support for batch writing (@snakefoot, @304NotModified)
+- PostFilteringTargetWrapper: performance optimizations (@snakefoot, @304NotModified)
+- Async / buffering wrapper: Improve performance when blocking (@snakefoot)
+- ObjectReflectionCache - Skip property-reflection for IFormattable (@snakefoot)
 
 Full changelog: https://github.com/NLog/NLog/blob/master/CHANGELOG.md
 
@@ -266,6 +290,7 @@ For all config options and platform support, check https://nlog-project.org/conf
   <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard1.3' ">
     <PackageReference Include="Microsoft.Extensions.PlatformAbstractions" Version="1.0.0" />
     <PackageReference Include="System.ComponentModel.Primitives" Version="4.1.0" />
+    <PackageReference Include="System.ComponentModel.TypeConverter" Version="4.1.0" />
     <PackageReference Include="System.Data.Common" Version="4.1.0" />
     <PackageReference Include="System.Diagnostics.StackTrace" Version="4.0.1" />
     <PackageReference Include="System.Net.NameResolution" Version="4.0.0" />
diff --git a/src/NLog/NestedDiagnosticsContext.cs b/src/NLog/NestedDiagnosticsContext.cs
index 683b1103d6..17aff8f041 100644
--- a/src/NLog/NestedDiagnosticsContext.cs
+++ b/src/NLog/NestedDiagnosticsContext.cs
@@ -42,7 +42,6 @@ namespace NLog
     /// <summary>
     /// Nested Diagnostics Context - a thread-local structure that keeps a stack
     /// of strings and provides methods to output them in layouts
-    /// Mostly for compatibility with log4net.
     /// </summary>
     public static class NestedDiagnosticsContext
     {
diff --git a/src/NLog/Targets/AsyncTaskTarget.cs b/src/NLog/Targets/AsyncTaskTarget.cs
index 6c7afd6e72..d14ed09e5f 100644
--- a/src/NLog/Targets/AsyncTaskTarget.cs
+++ b/src/NLog/Targets/AsyncTaskTarget.cs
@@ -372,17 +372,9 @@ private void TaskStartNext(object previousTask, bool fullBatchCompleted)
             {
                 lock (SyncRoot)
                 {
-                    if (previousTask != null)
-                    {
-                        // Task Completed
-                        if (_previousTask != null && !ReferenceEquals(previousTask, _previousTask))
-                            break;  // Other Task is already running
-                    }
-                    else
+                    if (CheckOtherTask(previousTask))
                     {
-                        // Task Queue Timer
-                        if (_previousTask?.IsCompleted == false)
-                            break;  // Other Task is already running
+                        break;  // Other Task is already running
                     }
 
                     if (!IsInitialized)
@@ -417,6 +409,24 @@ private void TaskStartNext(object previousTask, bool fullBatchCompleted)
             } while (!_requestQueue.IsEmpty || previousTask != null);
         }
 
+        private bool CheckOtherTask(object previousTask)
+        {
+            if (previousTask != null)
+            {
+                // Task Completed
+                if (_previousTask != null && !ReferenceEquals(previousTask, _previousTask))
+                    return true;
+            }
+            else
+            {
+                // Task Queue Timer
+                if (_previousTask?.IsCompleted == false)
+                    return true;
+            }
+
+            return false;
+        }
+
         /// <summary>
         /// Generates recursive task-chain to perform retry of writing logevents with increasing retry-delay
         /// </summary>
@@ -689,12 +699,9 @@ private void TaskTimeout(object state)
                     {
                         if (previousTask.Status != TaskStatus.Canceled &&
                             previousTask.Status != TaskStatus.Faulted &&
-                            previousTask.Status != TaskStatus.RanToCompletion)
+                            previousTask.Status != TaskStatus.RanToCompletion && !previousTask.Wait(100))
                         {
-                            if (!previousTask.Wait(100))
-                            {
-                                InternalLogger.Debug("{0} WriteAsyncTask had timeout. Task did not cancel properly: {1}.", Name, previousTask.Status);
-                            }
+                            InternalLogger.Debug("{0} WriteAsyncTask had timeout. Task did not cancel properly: {1}.", Name, previousTask.Status);
                         }
 
                         Exception actualException = ExtractActualException(previousTask.Exception);
diff --git a/src/NLog/Targets/DatabaseParameterInfo.cs b/src/NLog/Targets/DatabaseParameterInfo.cs
index f4ed276743..155b30f358 100644
--- a/src/NLog/Targets/DatabaseParameterInfo.cs
+++ b/src/NLog/Targets/DatabaseParameterInfo.cs
@@ -167,7 +167,7 @@ public DbTypeSetter(Type dbParameterType, string dbTypeName)
                 _dbTypeName = dbTypeName;
                 if (!StringHelpers.IsNullOrWhiteSpace(dbTypeName))
                 {
-                    string[] dbTypeNames = dbTypeName.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries);
+                    string[] dbTypeNames = dbTypeName.SplitAndTrimTokens('.');
                     if (dbTypeNames.Length > 1 && !string.Equals(dbTypeNames[0], nameof(System.Data.DbType), StringComparison.OrdinalIgnoreCase))
                     {
                         PropertyInfo propInfo = dbParameterType.GetProperty(dbTypeNames[0], BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);
diff --git a/src/NLog/Targets/DatabaseTarget.cs b/src/NLog/Targets/DatabaseTarget.cs
index 914406b2ca..46a9785146 100644
--- a/src/NLog/Targets/DatabaseTarget.cs
+++ b/src/NLog/Targets/DatabaseTarget.cs
@@ -380,32 +380,7 @@ protected override void InitializeTarget()
 
             if (ConnectionString != null)
             {
-                try
-                {
-                    var connectionString = BuildConnectionString(LogEventInfo.CreateNullEvent());
-                    var dbConnectionStringBuilder = new DbConnectionStringBuilder { ConnectionString = connectionString };
-                    if (dbConnectionStringBuilder.TryGetValue("provider connection string", out var connectionStringValue))
-                    {
-                        // Special Entity Framework Connection String
-                        if (dbConnectionStringBuilder.TryGetValue("provider", out var providerValue))
-                        {
-                            // Provider was overriden by ConnectionString
-                            providerName = providerValue.ToString()?.Trim() ?? string.Empty;
-                        }
-
-                        // ConnectionString was overriden by ConnectionString :)
-                        ConnectionString = SimpleLayout.Escape(connectionStringValue.ToString());
-                    }
-                }
-                catch (Exception ex)
-                {
-#if !NETSTANDARD
-                    if (!string.IsNullOrEmpty(ConnectionStringName))
-                        InternalLogger.Warn(ex, "DatabaseTarget(Name={0}): DbConnectionStringBuilder failed to parse '{1}' ConnectionString", Name, ConnectionStringName);
-                    else
-#endif
-                        InternalLogger.Warn(ex, "DatabaseTarget(Name={0}): DbConnectionStringBuilder failed to parse ConnectionString", Name);
-                }
+                providerName = InitConnectionString(providerName);
             }
 
 #if !NETSTANDARD
@@ -416,16 +391,7 @@ protected override void InitializeTarget()
 
             if (!string.IsNullOrEmpty(providerName))
             {
-                try
-                {
-                    ProviderFactory = DbProviderFactories.GetFactory(providerName);
-                    foundProvider = true;
-                }
-                catch (Exception ex)
-                {
-                    InternalLogger.Error(ex, "DatabaseTarget(Name={0}): DbProviderFactories failed to get factory from ProviderName={1}", Name, providerName);
-                    throw;
-                }
+                foundProvider = InitProviderFactory(providerName);
             }
 #endif
 
@@ -447,7 +413,56 @@ protected override void InitializeTarget()
             }
         }
 
+        private string InitConnectionString(string providerName)
+        {
+            try
+            {
+                var connectionString = BuildConnectionString(LogEventInfo.CreateNullEvent());
+                var dbConnectionStringBuilder = new DbConnectionStringBuilder {ConnectionString = connectionString};
+                if (dbConnectionStringBuilder.TryGetValue("provider connection string", out var connectionStringValue))
+                {
+                    // Special Entity Framework Connection String
+                    if (dbConnectionStringBuilder.TryGetValue("provider", out var providerValue))
+                    {
+                        // Provider was overriden by ConnectionString
+                        providerName = providerValue.ToString()?.Trim() ?? string.Empty;
+                    }
+
+                    // ConnectionString was overriden by ConnectionString :)
+                    ConnectionString = SimpleLayout.Escape(connectionStringValue.ToString());
+                }
+            }
+            catch (Exception ex)
+            {
 #if !NETSTANDARD
+                if (!string.IsNullOrEmpty(ConnectionStringName))
+                    InternalLogger.Warn(ex, "DatabaseTarget(Name={0}): DbConnectionStringBuilder failed to parse '{1}' ConnectionString", Name, ConnectionStringName);
+                else
+#endif
+                    InternalLogger.Warn(ex, "DatabaseTarget(Name={0}): DbConnectionStringBuilder failed to parse ConnectionString", Name);
+            }
+
+            return providerName;
+        }
+
+#if !NETSTANDARD
+        private bool InitProviderFactory(string providerName)
+        {
+            bool foundProvider;
+            try
+            {
+                ProviderFactory = DbProviderFactories.GetFactory(providerName);
+                foundProvider = true;
+            }
+            catch (Exception ex)
+            {
+                InternalLogger.Error(ex, "DatabaseTarget(Name={0}): DbProviderFactories failed to get factory from ProviderName={1}", Name, providerName);
+                throw;
+            }
+
+            return foundProvider;
+        }
+
         private string GetProviderNameFromDbProviderFactories(string providerName)
         {
             string dbProvider = DBProvider?.Trim() ?? string.Empty;
@@ -759,23 +774,7 @@ private void RunInstallCommands(InstallationContext installationContext, IEnumer
             {
                 foreach (var commandInfo in commands)
                 {
-                    string cs;
-
-                    if (commandInfo.ConnectionString != null)
-                    {
-                        // if there is connection string specified on the command info, use it
-                        cs = RenderLogEvent(commandInfo.ConnectionString, logEvent);
-                    }
-                    else if (InstallConnectionString != null)
-                    {
-                        // next, try InstallConnectionString
-                        cs = RenderLogEvent(InstallConnectionString, logEvent);
-                    }
-                    else
-                    {
-                        // if it's not defined, fall back to regular connection string
-                        cs = BuildConnectionString(logEvent);
-                    }
+                    var connectionString = GetConnectionStringFromCommand(commandInfo, logEvent);
 
                     // Set ConnectionType if it has not been initialized already
                     if (ConnectionType == null)
@@ -783,7 +782,7 @@ private void RunInstallCommands(InstallationContext installationContext, IEnumer
                         SetConnectionType();
                     }
 
-                    EnsureConnectionOpen(cs);
+                    EnsureConnectionOpen(connectionString);
 
                     string commandText = RenderLogEvent(commandInfo.Text, logEvent);
 
@@ -823,6 +822,28 @@ private void RunInstallCommands(InstallationContext installationContext, IEnumer
             }
         }
 
+        private string GetConnectionStringFromCommand(DatabaseCommandInfo commandInfo, LogEventInfo logEvent)
+        {
+            string connectionString;
+            if (commandInfo.ConnectionString != null)
+            {
+                // if there is connection string specified on the command info, use it
+                connectionString = RenderLogEvent(commandInfo.ConnectionString, logEvent);
+            }
+            else if (InstallConnectionString != null)
+            {
+                // next, try InstallConnectionString
+                connectionString = RenderLogEvent(InstallConnectionString, logEvent);
+            }
+            else
+            {
+                // if it's not defined, fall back to regular connection string
+                connectionString = BuildConnectionString(logEvent);
+            }
+
+            return connectionString;
+        }
+
         /// <summary>
         /// Create database parameter
         /// </summary>
diff --git a/src/NLog/Targets/DefaultJsonSerializer.cs b/src/NLog/Targets/DefaultJsonSerializer.cs
index 5b145d2696..d130be1056 100644
--- a/src/NLog/Targets/DefaultJsonSerializer.cs
+++ b/src/NLog/Targets/DefaultJsonSerializer.cs
@@ -113,7 +113,8 @@ public string SerializeObject(object value, JsonSerializeOptions options)
             }
             else
             {
-                TypeCode objTypeCode = Convert.GetTypeCode(value);
+                IConvertible convertibleValue = value as IConvertible;
+                TypeCode objTypeCode = convertibleValue?.GetTypeCode() ?? TypeCode.Object;
                 if (objTypeCode != TypeCode.Object && objTypeCode != TypeCode.Char && StringHelpers.IsNullOrWhiteSpace(options.Format) && options.FormatProvider == null)
                 {
                     Enum enumValue;
@@ -123,8 +124,8 @@ public string SerializeObject(object value, JsonSerializeOptions options)
                     }
                     else
                     {
-                        string xmlStr = XmlHelper.XmlConvertToString(value, objTypeCode);
-                        if (SkipQuotes(value, objTypeCode))
+                        string xmlStr = XmlHelper.XmlConvertToString(convertibleValue, objTypeCode);
+                        if (SkipQuotes(convertibleValue, objTypeCode))
                         {
                             return xmlStr;
                         }
@@ -166,96 +167,106 @@ public bool SerializeObject(object value, StringBuilder destination)
         /// <returns>Object serialized succesfully (true/false).</returns>
         public bool SerializeObject(object value, StringBuilder destination, JsonSerializeOptions options)
         {
-            return SerializeObject(value, Convert.GetTypeCode(value), destination, options, default(SingleItemOptimizedHashSet<object>), 0);
+            return SerializeObject(value, destination, options, default(SingleItemOptimizedHashSet<object>), 0);
         }
 
         /// <summary>
         /// Serialization of the object in JSON format to the destination StringBuilder
         /// </summary>
         /// <param name="value">The object to serialize to JSON.</param>
-        /// <param name="objTypeCode">The TypeCode for the object to serialize.</param>
         /// <param name="destination">Write the resulting JSON to this destination.</param>
         /// <param name="options">serialisation options</param>
         /// <param name="objectsInPath">The objects in path (Avoid cyclic reference loop).</param>
         /// <param name="depth">The current depth (level) of recursion.</param>
         /// <returns>Object serialized succesfully (true/false).</returns>
-        private bool SerializeObject(object value, TypeCode objTypeCode, StringBuilder destination, JsonSerializeOptions options,
-                SingleItemOptimizedHashSet<object> objectsInPath, int depth)
+        private bool SerializeObject(object value, StringBuilder destination, JsonSerializeOptions options, SingleItemOptimizedHashSet<object> objectsInPath, int depth)
         {
-            if (objTypeCode == TypeCode.Object && objectsInPath.Contains(value))
+            int originalLength = destination.Length;
+
+            try
             {
-                return false; // detected reference loop, skip serialization
-            }
+                if (SerializeSimpleObjectValue(value, destination, options))
+                {
+                    return true;
+                }
 
-            if (value == null)
+                return SerializeObjectWithReflection(value, destination, options, ref objectsInPath, depth);
+            }
+            catch
             {
-                destination.Append("null");
+                destination.Length = originalLength;
+                return false;
             }
-            else if (objTypeCode == TypeCode.String)
+        }
+
+        private bool SerializeObjectWithReflection(object value, StringBuilder destination, JsonSerializeOptions options, ref SingleItemOptimizedHashSet<object> objectsInPath, int depth)
+        {
+            int originalLength = destination.Length;
+            if (originalLength > MaxJsonLength)
             {
-                destination.Append('"');
-                AppendStringEscape(destination, value.ToString(), options.EscapeUnicode);
-                destination.Append('"');
+                return false;
             }
-            else if (objTypeCode != TypeCode.Object)
+
+            if (objectsInPath.Contains(value))
             {
-                return SerializeWithTypeCode(value, objTypeCode, destination, options, ref objectsInPath, depth);
+                return false;
             }
-            else if (value is IDictionary dict)
+
+            if (value is IDictionary dict)
             {
                 using (StartCollectionScope(ref objectsInPath, dict))
                 {
                     SerializeDictionaryObject(dict, destination, options, objectsInPath, depth);
+                    return true;
                 }
             }
-            else if (value is IDictionary<string, object> expando)
+
+            if (value is IEnumerable enumerable)
             {
-                // Special case for Expando-objects
-                using (StartCollectionScope(ref objectsInPath, expando))
+                if (_objectReflectionCache.TryLookupExpandoObject(value, out var propertyValues))
                 {
-                    return SerializeObjectProperties(new ObjectReflectionCache.ObjectPropertyList(expando), destination, options, objectsInPath, depth);
+                    if (propertyValues.ConvertToString || depth >= options.MaxRecursionLimit)
+                    {
+                        return SerializeObjectAsString(value, destination, options);
+                    }
+                    else
+                    {
+                        using (new SingleItemOptimizedHashSet<object>.SingleItemScopedInsert(value, ref objectsInPath, false, _referenceEqualsComparer))
+                        {
+                            return SerializeObjectProperties(propertyValues, destination, options, objectsInPath, depth);
+                        }
+                    }
                 }
-            }
-            else if (value is IEnumerable enumerable)
-            {
+
                 using (StartCollectionScope(ref objectsInPath, value))
                 {
                     SerializeCollectionObject(enumerable, destination, options, objectsInPath, depth);
+                    return true;
                 }
             }
             else
             {
-                return SerializeWithTypeCode(value, objTypeCode, destination, options, ref objectsInPath, depth);
+                return SerializeObjectWithProperties(value, destination, options, ref objectsInPath, depth);
             }
-            return true;
         }
 
-        private bool SerializeWithTypeCode(object value, TypeCode objTypeCode, StringBuilder destination, JsonSerializeOptions options, ref SingleItemOptimizedHashSet<object> objectsInPath, int depth)
+        private bool SerializeSimpleObjectValue(object value, StringBuilder destination, JsonSerializeOptions options, bool forceToString = false)
         {
-            var hasFormat = !StringHelpers.IsNullOrWhiteSpace(options.Format);
-            if ((options.FormatProvider != null || hasFormat) && (value is IFormattable formattable))
+            var convertibleValue = value as IConvertible;
+            var objTypeCode = value == null ? TypeCode.Empty : (convertibleValue?.GetTypeCode() ?? TypeCode.Object);
+            if (objTypeCode != TypeCode.Object)
             {
-                return SerializeWithFormatProvider(value, objTypeCode, destination, options, formattable, options.Format, hasFormat);
+                SerializeSimpleTypeCodeValue(convertibleValue, objTypeCode, destination, options, forceToString);
+                return true;
             }
-            else
+
+            if (value is DateTimeOffset)
             {
-                if (objTypeCode == TypeCode.Object)
-                {
-                    if (value is DateTimeOffset)
-                    {
-                        QuoteValue(destination, $"{value:yyyy-MM-dd HH:mm:ss zzz}");
-                        return true;
-                    }
-                    else
-                    {
-                        return SerializeObjectWithProperties(value, destination, options, ref objectsInPath, depth);
-                    }
-                }
-                else
-                {
-                    return SerializeSimpleTypeCodeValue(value, objTypeCode, destination, options);
-                }
+                QuoteValue(destination, $"{value:yyyy-MM-dd HH:mm:ss zzz}");
+                return true;
             }
+
+            return false;   // Not simple
         }
 
         private static SingleItemOptimizedHashSet<object>.SingleItemScopedInsert StartCollectionScope(ref SingleItemOptimizedHashSet<object> objectsInPath, object value)
@@ -263,41 +274,23 @@ private static SingleItemOptimizedHashSet<object>.SingleItemScopedInsert StartCo
             return new SingleItemOptimizedHashSet<object>.SingleItemScopedInsert(value, ref objectsInPath, true, _referenceEqualsComparer);
         }
 
-        private bool SerializeWithFormatProvider(object value, TypeCode objTypeCode, StringBuilder destination, JsonSerializeOptions options, IFormattable formattable, string format, bool hasFormat)
+        private void SerializeWithFormatProvider(IFormattable formattable, bool includeQuotes, StringBuilder destination, JsonSerializeOptions options, bool hasFormat)
         {
-            int originalLength = destination.Length;
-
-            try
+            if (includeQuotes)
             {
-                bool includeQuotes = !SkipQuotes(value, objTypeCode);
-                if (includeQuotes)
-                {
-                    destination.Append('"');
-                }
-
-                if (hasFormat)
-                {
-                    var formatProvider = options.FormatProvider ?? _defaultFormatProvider;
-                    destination.AppendFormat(formatProvider, string.Concat("{0:", format, "}"), value);
-                }
-                else
-                {
-                    //format provider passed without FormatProvider
-                    var str = formattable.ToString("", options.FormatProvider);
-                    AppendStringEscape(destination, str, options.EscapeUnicode);
-                }
+                destination.Append('"');
+            }
 
-                if (includeQuotes)
-                {
-                    destination.Append('"');
-                }
+            var formatProvider = options.FormatProvider ?? (hasFormat ? _defaultFormatProvider : null);
+            var str = formattable.ToString(hasFormat ? options.Format : "", formatProvider);
+            if (includeQuotes)
+                AppendStringEscape(destination, str, options.EscapeUnicode);
+            else
+                destination.Append(str);
 
-                return true;
-            }
-            catch
+            if (includeQuotes)
             {
-                destination.Length = originalLength;
-                return false;
+                destination.Append('"');
             }
         }
 
@@ -327,10 +320,9 @@ private void SerializeDictionaryObject(IDictionary dictionary, StringBuilder des
                 }
 
                 var itemKey = item.Key;
-                var itemKeyTypeCode = Convert.GetTypeCode(itemKey);
                 if (options.QuoteKeys)
                 {
-                    if (!SerializeObjectAsString(itemKey, itemKeyTypeCode, destination, options))
+                    if (!SerializeObjectAsString(itemKey, destination, options))
                     {
                         destination.Length = originalLength;
                         continue;
@@ -338,7 +330,7 @@ private void SerializeDictionaryObject(IDictionary dictionary, StringBuilder des
                 }
                 else
                 {
-                    if (!SerializeObject(itemKey, itemKeyTypeCode, destination, options, objectsInPath, nextDepth))
+                    if (!SerializeObject(itemKey, destination, options, objectsInPath, nextDepth))
                     {
                         destination.Length = originalLength;
                         continue;
@@ -361,8 +353,7 @@ private void SerializeDictionaryObject(IDictionary dictionary, StringBuilder des
 
                 //only serialize, if key and value are serialized without error (e.g. due to reference loop)
                 var itemValue = item.Value;
-                var itemValueTypeCode = Convert.GetTypeCode(itemValue);
-                if (!SerializeObject(itemValue, itemValueTypeCode, destination, options, objectsInPath, nextDepth))
+                if (!SerializeObject(itemValue, destination, options, objectsInPath, nextDepth))
                 {
                     destination.Length = originalLength;
                 }
@@ -419,7 +410,7 @@ private void SerializeCollectionObject(IEnumerable value, StringBuilder destinat
                     destination.Append(',');
                 }
 
-                if (!SerializeObject(val, Convert.GetTypeCode(val), destination, options, objectsInPath, nextDepth))
+                if (!SerializeObject(val, destination, options, objectsInPath, nextDepth))
                 {
                     destination.Length = originalLength;
                 }
@@ -433,15 +424,10 @@ private void SerializeCollectionObject(IEnumerable value, StringBuilder destinat
 
         private bool SerializeObjectWithProperties(object value, StringBuilder destination, JsonSerializeOptions options, ref SingleItemOptimizedHashSet<object> objectsInPath, int depth)
         {
-            int originalLength = destination.Length;
-            if (originalLength > MaxJsonLength)
-            {
-                return false;
-            }
-
             if (depth < options.MaxRecursionLimit)
             {
-                try
+                var objectPropertyList = _objectReflectionCache.LookupObjectProperties(value);
+                if (!objectPropertyList.ConvertToString)
                 {
                     if (ReferenceEquals(options, instance._serializeOptions) && value is Exception)
                     {
@@ -449,66 +435,69 @@ private bool SerializeObjectWithProperties(object value, StringBuilder destinati
                         options = instance._exceptionSerializeOptions;
                     }
 
-                    var objectPropertyList = _objectReflectionCache.LookupObjectProperties(value);
                     using (new SingleItemOptimizedHashSet<object>.SingleItemScopedInsert(value, ref objectsInPath, false, _referenceEqualsComparer))
                     {
                         return SerializeObjectProperties(objectPropertyList, destination, options, objectsInPath, depth);
                     }
                 }
-                catch
-                {
-                    //nothing to add, so return is OK
-                    destination.Length = originalLength;
-                    return false;
-                }
-            }
-            else
-            {
-                return SerializeObjectAsString(value, TypeCode.Object, destination, options);
             }
+
+            return SerializeObjectAsString(value, destination, options);
         }
 
-        private bool SerializeSimpleTypeCodeValue(object value, TypeCode objTypeCode, StringBuilder destination, JsonSerializeOptions options, bool forceQuotes = false)
+        private void SerializeSimpleTypeCodeValue(IConvertible value, TypeCode objTypeCode, StringBuilder destination, JsonSerializeOptions options, bool forceToString = false)
         {
-            if (objTypeCode == TypeCode.String || objTypeCode == TypeCode.Char)
+            if (value == null)
+            {
+                destination.Append(forceToString ? "\"\"" : "null");
+            }
+            else if (objTypeCode == TypeCode.String || objTypeCode == TypeCode.Char)
             {
                 destination.Append('"');
                 AppendStringEscape(destination, value.ToString(), options.EscapeUnicode);
                 destination.Append('"');
             }
-            else if (IsNumericTypeCode(objTypeCode, false))
-            {
-                if (!options.EnumAsInteger && value is Enum enumValue)
-                {
-                    QuoteValue(destination, EnumAsString(enumValue));
-                }
-                else
-                {
-                    if (forceQuotes)
-                        destination.Append('"');
-                    destination.AppendIntegerAsString(value, objTypeCode);
-                    if (forceQuotes)
-                        destination.Append('"');
-                }
-            }
             else
             {
-                string str = XmlHelper.XmlConvertToString(value, objTypeCode);
-                if (str == null)
+                var hasFormat = !StringHelpers.IsNullOrWhiteSpace(options.Format);
+                if ((options.FormatProvider != null || hasFormat) && (value is IFormattable formattable))
                 {
-                    return false;
+                    bool includeQuotes = forceToString || objTypeCode == TypeCode.Object || !SkipQuotes(value, objTypeCode);
+                    SerializeWithFormatProvider(formattable, includeQuotes, destination, options, hasFormat);
                 }
-
-                if (!forceQuotes && SkipQuotes(value, objTypeCode))
+                else if (IsNumericTypeCode(objTypeCode, false))
                 {
-                    destination.Append(str);
+                    SerializeSimpleNumericValue(value, objTypeCode, destination, options, forceToString);
                 }
                 else
                 {
-                    QuoteValue(destination, str);
+                    string str = XmlHelper.XmlConvertToString(value, objTypeCode);
+                    if (!forceToString && str != null && SkipQuotes(value, objTypeCode))
+                    {
+                        destination.Append(str);
+                    }
+                    else
+                    {
+                        QuoteValue(destination, str);
+                    }
                 }
             }
-            return true;
+        }
+
+        private void SerializeSimpleNumericValue(IConvertible value, TypeCode objTypeCode, StringBuilder destination, JsonSerializeOptions options, bool forceToString)
+        {
+            if (!options.EnumAsInteger && value is Enum enumValue)
+            {
+                QuoteValue(destination, EnumAsString(enumValue));
+            }
+            else
+            {
+                if (forceToString)
+                    destination.Append('"');
+                destination.AppendIntegerAsString(value, objTypeCode);
+                if (forceToString)
+                    destination.Append('"');
+            }
         }
 
         private static CultureInfo CreateFormatProvider()
@@ -551,7 +540,7 @@ private string EnumAsString(Enum value)
         /// <summary>
         /// No quotes needed for this type?
         /// </summary>
-        private static bool SkipQuotes(object value, TypeCode objTypeCode)
+        private static bool SkipQuotes(IConvertible value, TypeCode objTypeCode)
         {
             switch (objTypeCode)
             {
@@ -563,12 +552,12 @@ private static bool SkipQuotes(object value, TypeCode objTypeCode)
                 case TypeCode.Decimal: return true;
                 case TypeCode.Double:
                     {
-                        double dblValue = (double)value;
+                        double dblValue = value.ToDouble(CultureInfo.InvariantCulture);
                         return !double.IsNaN(dblValue) && !double.IsInfinity(dblValue);
                     }
                 case TypeCode.Single:
                     {
-                        float floatValue = (float)value;
+                        float floatValue = value.ToSingle(CultureInfo.InvariantCulture);
                         return !float.IsNaN(floatValue) && !float.IsInfinity(floatValue);
                     }
                 default:
@@ -708,15 +697,9 @@ private static bool EscapeChar(char ch, bool escapeUnicode)
                 return escapeUnicode && ch > 127;
         }
 
-        private bool SerializeObjectProperties(ObjectReflectionCache.ObjectPropertyList objectPropertyList,StringBuilder destination, JsonSerializeOptions options,
+        private bool SerializeObjectProperties(ObjectReflectionCache.ObjectPropertyList objectPropertyList, StringBuilder destination, JsonSerializeOptions options,
             SingleItemOptimizedHashSet<object> objectsInPath, int depth)
         {
-            if (objectPropertyList.Count == 0)
-            { 
-                //no props
-                return SerializeObjectAsString(objectPropertyList.ToString(), TypeCode.Object, destination, options);
-            }
-
             destination.Append('{');
 
             bool first = true;
@@ -743,19 +726,28 @@ private static bool EscapeChar(char ch, bool escapeUnicode)
                         }
                         destination.Append(':');
 
-                        if (!SerializeObject(propertyValue.Value, propertyValue.TypeCode, destination, options, objectsInPath, depth + 1))
+                        var objTypeCode = propertyValue.TypeCode;
+                        if (objTypeCode != TypeCode.Object)
                         {
-                            destination.Length = originalLength;
+                            SerializeSimpleTypeCodeValue((IConvertible)propertyValue.Value, objTypeCode, destination, options);
+                            first = false;
                         }
                         else
                         {
-                            first = false;
+                            if (!SerializeObject(propertyValue.Value, destination, options, objectsInPath, depth + 1))
+                            {
+                                destination.Length = originalLength;
+                            }
+                            else
+                            {
+                                first = false;
+                            }
                         }
                     }
                 }
                 catch
                 {
-                    //skip this property
+                    // skip single property
                     destination.Length = originalLength;
                 }
             }
@@ -769,25 +761,34 @@ private static bool HasNameAndValue(ObjectReflectionCache.ObjectPropertyList.Pro
             return propertyValue.Name != null && propertyValue.Value != null;
         }
 
-        private bool SerializeObjectAsString(object value, TypeCode objTypeCode, StringBuilder destination, JsonSerializeOptions options)
+        private bool SerializeObjectAsString(object value, StringBuilder destination, JsonSerializeOptions options)
         {
+            var originalLength = destination.Length;
+
             try
             {
-                if (objTypeCode == TypeCode.Object)
+                if (SerializeSimpleObjectValue(value, destination, options, true))
                 {
-                    var str = Convert.ToString(value, CultureInfo.InvariantCulture);
-                    destination.Append('"');
-                    AppendStringEscape(destination, str, options.EscapeUnicode);
-                    destination.Append('"');
                     return true;
                 }
-                else
+
+                var hasFormat = !StringHelpers.IsNullOrWhiteSpace(options.Format);
+                if ((options.FormatProvider != null || hasFormat) && (value is IFormattable formattable))
                 {
-                    return SerializeSimpleTypeCodeValue(value, objTypeCode, destination, options, true);
+                    SerializeWithFormatProvider(formattable, true, destination, options, hasFormat);
+                    return true;
                 }
+
+                var str = Convert.ToString(value, CultureInfo.InvariantCulture);
+                destination.Append('"');
+                AppendStringEscape(destination, str, options.EscapeUnicode);
+                destination.Append('"');
+                return true;
             }
             catch
             {
+                // skip bad object
+                destination.Length = originalLength;
                 return false;
             }
         }
diff --git a/src/NLog/Targets/FileArchiveModes/FileArchiveModeRolling.cs b/src/NLog/Targets/FileArchiveModes/FileArchiveModeRolling.cs
index 5f7d0ef3c3..96dc8be51a 100644
--- a/src/NLog/Targets/FileArchiveModes/FileArchiveModeRolling.cs
+++ b/src/NLog/Targets/FileArchiveModes/FileArchiveModeRolling.cs
@@ -107,19 +107,16 @@ public IEnumerable<DateAndSequenceArchive> CheckArchiveCleanup(string archiveFil
 
             existingArchiveFiles.Sort((x, y) => x.Sequence.CompareTo(y.Sequence));
 
-            if (maxArchiveFiles > 0)
+            if (maxArchiveFiles > 0 && existingArchiveFiles.Count > maxArchiveFiles)
             {
-                if (existingArchiveFiles.Count > maxArchiveFiles)
+                for (int i = 0; i < existingArchiveFiles.Count; i++)
                 {
-                    for (int i = 0; i < existingArchiveFiles.Count; i++)
-                    {
-                        if (existingArchiveFiles[i].Sequence == int.MinValue || existingArchiveFiles[i].Sequence == int.MaxValue)
-                            continue;
+                    if (existingArchiveFiles[i].Sequence == int.MinValue || existingArchiveFiles[i].Sequence == int.MaxValue)
+                        continue;
 
-                        if ((i + 1) > maxArchiveFiles)
-                        {
-                            yield return existingArchiveFiles[i];
-                        }
+                    if (i + 1 > maxArchiveFiles)
+                    {
+                        yield return existingArchiveFiles[i];
                     }
                 }
             }
diff --git a/src/NLog/Targets/FileTarget.cs b/src/NLog/Targets/FileTarget.cs
index b24cb573c1..4e1a371700 100644
--- a/src/NLog/Targets/FileTarget.cs
+++ b/src/NLog/Targets/FileTarget.cs
@@ -440,7 +440,6 @@ public bool ConcurrentWrites
             get
             {
 #if SupportsMutex
-
                 return _concurrentWrites ?? PlatformDetector.SupportsSharableMutex;
 #else
                 return _concurrentWrites ?? false;  // Better user experience for mobile platforms
@@ -740,11 +739,14 @@ private void RefreshArchiveFilePatternToWatch(string fileName, LogEventInfo logE
             {
                 _fileAppenderCache.CheckCloseAppenders -= AutoCloseAppendersAfterArchive;
 
-                if (KeepFileOpen)
-                    _fileAppenderCache.CheckCloseAppenders += AutoCloseAppendersAfterArchive;
+                bool mustWatchArchiving = IsArchivingEnabled && KeepFileOpen && ConcurrentWrites;
+                bool mustWatchActiveFile = KeepFileOpen && EnableFileDelete && !NetworkWrites && !ReplaceFileContentsOnEachWrite && !EnableFileDeleteSimpleMonitor;
+                if (mustWatchArchiving || mustWatchActiveFile)
+                {
+                    _fileAppenderCache.CheckCloseAppenders += AutoCloseAppendersAfterArchive;   // Activates FileSystemWatcher
+                }
 
 #if !SILVERLIGHT && !__IOS__ && !__ANDROID__ && !NETSTANDARD1_3
-                bool mustWatchArchiving = IsArchivingEnabled && ConcurrentWrites && KeepFileOpen;
                 if (mustWatchArchiving)
                 {
                     string fileNamePattern = GetArchiveFileNamePattern(fileName, logEvent);
@@ -901,6 +903,12 @@ private IFileAppenderFactory GetFileAppenderFactory()
 
         private bool IsArchivingEnabled => ArchiveAboveSize != ArchiveAboveSizeDisabled || ArchiveEvery != FileArchivePeriod.None;
 
+        private bool IsSimpleKeepFileOpen => KeepFileOpen && !NetworkWrites && !ReplaceFileContentsOnEachWrite && !ConcurrentWrites;
+
+        private bool EnableFileDeleteSimpleMonitor => EnableFileDelete && !PlatformDetector.IsWin32 && IsSimpleKeepFileOpen;
+
+        bool ICreateFileParameters.EnableFileDeleteSimpleMonitor => EnableFileDeleteSimpleMonitor;
+
         /// <summary>
         /// Initializes file logging by creating data structures that
         /// enable efficient multi-file logging.
@@ -1281,7 +1289,7 @@ private void FlushCurrentFileWrites(string currentFileName, LogEventInfo firstLo
         private void ArchiveFile(string fileName, string archiveFileName)
         {
             string archiveFolderPath = Path.GetDirectoryName(archiveFileName);
-            if (!Directory.Exists(archiveFolderPath))
+            if (archiveFolderPath != null && !Directory.Exists(archiveFolderPath))
                 Directory.CreateDirectory(archiveFolderPath);
 
             if (string.Equals(fileName, archiveFileName, StringComparison.OrdinalIgnoreCase))
@@ -1327,13 +1335,10 @@ private void ArchiveFileAppendExisting(string fileName, string archiveFileName)
                 //clear old content
                 fileStream.SetLength(0);
 
-                if (EnableFileDelete)
+                if (EnableFileDelete && !DeleteOldArchiveFile(fileName))
                 {
                     // Attempt to delete file to reset File-Creation-Time (Delete under file-lock)
-                    if (!DeleteOldArchiveFile(fileName))
-                    {
-                        fileShare &= ~FileShare.Delete;  // Retry after having released file-lock
-                    }
+                    fileShare &= ~FileShare.Delete;  // Retry after having released file-lock
                 }
 
                 fileStream.Close(); // This flushes the content, too.
@@ -1359,7 +1364,7 @@ private void ArchiveFileMove(string fileName, string archiveFileName)
             }
             catch (IOException ex)
             {
-                if (KeepFileOpen && !ConcurrentWrites)
+                if (IsSimpleKeepFileOpen)
                     throw;  // No need to retry, when only single process access
 
                 if (!EnableFileDelete && KeepFileOpen)
@@ -1503,7 +1508,7 @@ private string GetArchiveDateFormatString(string defaultFormat)
                     return previousLogEventTimestamp;
                 }
 
-                if (!AutoFlush && KeepFileOpen && !ConcurrentWrites && !NetworkWrites && previousLogEventTimestamp < lastWriteTimeSource)
+                if (!AutoFlush && IsSimpleKeepFileOpen && previousLogEventTimestamp < lastWriteTimeSource)
                 {
                     InternalLogger.Trace("FileTarget(Name={0}): Using previous LogEvent-TimeStamp {1}, because AutoFlush=false affects File-LastModified {2}", Name, previousLogEventTimestamp, lastWriteTimeSource);
                     return previousLogEventTimestamp;
@@ -1638,13 +1643,10 @@ private string GenerateArchiveFileNameAfterCleanup(string fileName, FileInfo fil
                     }
                 }
 
-                if (initializedNewFile)
+                if (initializedNewFile && string.Equals(Path.GetDirectoryName(archiveFilePattern), fileInfo.DirectoryName, StringComparison.OrdinalIgnoreCase))
                 {
-                    if (string.Equals(Path.GetDirectoryName(archiveFilePattern), fileInfo.DirectoryName, StringComparison.OrdinalIgnoreCase))
-                    {
-                        DeleteOldArchiveFile(fileName);
-                        return null;
-                    }
+                    DeleteOldArchiveFile(fileName);
+                    return null;
                 }
             }
 
@@ -1940,7 +1942,7 @@ private string GetArchiveFileNameBasedOnTime(string fileName, LogEventInfo logEv
             }
 
             // Linux FileSystems doesn't always have file-birth-time, so NLog tries to provide a little help
-            DateTime? fallbackTimeSourceLinux = (previousLogEventTimestamp != DateTime.MinValue && KeepFileOpen && !ConcurrentWrites && !NetworkWrites) ? previousLogEventTimestamp : (DateTime?)null;
+            DateTime? fallbackTimeSourceLinux = (previousLogEventTimestamp != DateTime.MinValue && IsSimpleKeepFileOpen) ? previousLogEventTimestamp : (DateTime?)null;
             var creationTimeSource = _fileAppenderCache.GetFileCreationTimeSource(fileName, fallbackTimeSourceLinux);
             if (creationTimeSource == null)
             {
@@ -1951,7 +1953,7 @@ private string GetArchiveFileNameBasedOnTime(string fileName, LogEventInfo logEv
             {
                 if (TruncateArchiveTime(previousLogEventTimestamp, FileArchivePeriod.Minute) < TruncateArchiveTime(creationTimeSource.Value, FileArchivePeriod.Minute) && PlatformDetector.IsUnix)
                 {
-                    if (KeepFileOpen && !ConcurrentWrites && !NetworkWrites)
+                    if (IsSimpleKeepFileOpen)
                     {
                         InternalLogger.Debug("FileTarget(Name={0}): Adjusted file creation time from {1} to {2}. Linux FileSystem probably don't support file birthtime.", Name, creationTimeSource, previousLogEventTimestamp);
                         creationTimeSource = previousLogEventTimestamp;
@@ -2160,17 +2162,13 @@ private void WriteToFile(string fileName, ArraySegment<byte> bytes, bool initial
         /// <returns>The DateTime of the previous log event for this file (DateTime.MinValue if just initialized).</returns>
         private DateTime InitializeFile(string fileName, LogEventInfo logEvent)
         {
-            if (_initializedFiles.Count != 0 && _previousLogEventTimestamp.HasValue && _previousLogFileName == fileName)
+            if (_initializedFiles.Count != 0 && _previousLogEventTimestamp.HasValue && _previousLogFileName == fileName && logEvent.TimeStamp == _previousLogEventTimestamp.Value)
             {
-                if (logEvent.TimeStamp == _previousLogEventTimestamp.Value)
-                {
-                    return _previousLogEventTimestamp.Value;
-                }
+                return _previousLogEventTimestamp.Value;
             }
 
             var now = logEvent.TimeStamp;
-            DateTime lastTime;
-            if (!_initializedFiles.TryGetValue(fileName, out lastTime))
+            if (!_initializedFiles.TryGetValue(fileName, out var lastTime))
             {
                 ProcessOnStartup(fileName, logEvent);
 
@@ -2214,12 +2212,9 @@ private void FinalizeFile(string fileName, bool isArchiving = false)
         private void WriteFooter(string fileName)
         {
             ArraySegment<byte> footerBytes = GetLayoutBytes(Footer);
-            if (footerBytes.Count > 0)
+            if (footerBytes.Count > 0 && File.Exists(fileName))
             {
-                if (File.Exists(fileName))
-                {
-                    WriteToFile(fileName, footerBytes, false);
-                }
+                WriteToFile(fileName, footerBytes, false);
             }
         }
 
@@ -2258,19 +2253,16 @@ private void ProcessOnStartup(string fileName, LogEventInfo logEvent)
             }
 
             string archiveFilePattern = GetArchiveFileNamePattern(fileName, logEvent);
-            if (!string.IsNullOrEmpty(archiveFilePattern))
+            if (!string.IsNullOrEmpty(archiveFilePattern) && FileArchiveModeFactory.ShouldDeleteOldArchives(MaxArchiveFiles))
             {
-                if (FileArchiveModeFactory.ShouldDeleteOldArchives(MaxArchiveFiles))
+                var fileArchiveStyle = GetFileArchiveHelper(archiveFilePattern);
+                if (fileArchiveStyle.AttemptCleanupOnInitializeFile(archiveFilePattern, MaxArchiveFiles))
                 {
-                    var fileArchiveStyle = GetFileArchiveHelper(archiveFilePattern);
-                    if (fileArchiveStyle.AttemptCleanupOnInitializeFile(archiveFilePattern, MaxArchiveFiles))
+                    var existingArchiveFiles = fileArchiveStyle.GetExistingArchiveFiles(archiveFilePattern);
+                    var cleanupArchiveFiles = fileArchiveStyle.CheckArchiveCleanup(archiveFilePattern, existingArchiveFiles, MaxArchiveFiles);
+                    foreach (var oldFile in cleanupArchiveFiles)
                     {
-                        var existingArchiveFiles = fileArchiveStyle.GetExistingArchiveFiles(archiveFilePattern);
-                        var cleanupArchiveFiles = fileArchiveStyle.CheckArchiveCleanup(archiveFilePattern, existingArchiveFiles, MaxArchiveFiles);
-                        foreach (var oldFile in cleanupArchiveFiles)
-                        {
-                            DeleteOldArchiveFile(oldFile.FileName);
-                        }
+                        DeleteOldArchiveFile(oldFile.FileName);
                     }
                 }
             }
diff --git a/src/NLog/Targets/LogReceiverWebServiceTarget.cs b/src/NLog/Targets/LogReceiverWebServiceTarget.cs
index 148b0e539a..e3b41a4136 100644
--- a/src/NLog/Targets/LogReceiverWebServiceTarget.cs
+++ b/src/NLog/Targets/LogReceiverWebServiceTarget.cs
@@ -258,26 +258,7 @@ private NLogEvents TranslateLogEvents(IList<AsyncLogEventInfo> logEvents)
 
             if (IncludeEventProperties)
             {
-                for (int i = 0; i < logEvents.Count; ++i)
-                {
-                    var ev = logEvents[i].LogEvent;
-
-                    if (ev.HasProperties)
-                    {
-                        // add all event-level property names in 'LayoutNames' collection.
-                        foreach (var prop in ev.Properties)
-                        {
-                            string propName = prop.Key as string;
-                            if (propName != null)
-                            {
-                                if (!networkLogEvents.LayoutNames.Contains(propName))
-                                {
-                                    networkLogEvents.LayoutNames.Add(propName);
-                                }
-                            }
-                        }
-                    }
-                }
+                AddEventProperties(logEvents, networkLogEvents);
             }
 
             networkLogEvents.Events = new NLogEvent[logEvents.Count];
@@ -290,6 +271,26 @@ private NLogEvents TranslateLogEvents(IList<AsyncLogEventInfo> logEvents)
             return networkLogEvents;
         }
 
+        private static void AddEventProperties(IList<AsyncLogEventInfo> logEvents, NLogEvents networkLogEvents)
+        {
+            for (int i = 0; i < logEvents.Count; ++i)
+            {
+                var ev = logEvents[i].LogEvent;
+
+                if (ev.HasProperties)
+                {
+                    // add all event-level property names in 'LayoutNames' collection.
+                    foreach (var prop in ev.Properties)
+                    {
+                        if (prop.Key is string propName && !networkLogEvents.LayoutNames.Contains(propName))
+                        {
+                            networkLogEvents.LayoutNames.Add(propName);
+                        }
+                    }
+                }
+            }
+        }
+
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Client is disposed asynchronously.")]
         private void Send(NLogEvents events, IList<AsyncLogEventInfo> asyncContinuations, AsyncContinuation flushContinuations)
         {
diff --git a/src/NLog/Targets/MailTarget.cs b/src/NLog/Targets/MailTarget.cs
index 5d6d95a7e6..0816367a9b 100644
--- a/src/NLog/Targets/MailTarget.cs
+++ b/src/NLog/Targets/MailTarget.cs
@@ -170,19 +170,16 @@ public Layout From
             get
             {
 #if !__ANDROID__ && !__IOS__ && !NETSTANDARD
-                if (UseSystemNetMailSettings)
-                {
-                    // In contrary to other settings, System.Net.Mail.SmtpClient doesn't read the 'From' attribute from the system.net/mailSettings/smtp section in the config file.
-                    // Thus, when UseSystemNetMailSettings is enabled we have to read the configuration section of system.net/mailSettings/smtp to initialize the 'From' address.
-                    // It will do so only if the 'From' attribute in system.net/mailSettings/smtp is not empty.
+                
+                // In contrary to other settings, System.Net.Mail.SmtpClient doesn't read the 'From' attribute from the system.net/mailSettings/smtp section in the config file.
+                // Thus, when UseSystemNetMailSettings is enabled we have to read the configuration section of system.net/mailSettings/smtp to initialize the 'From' address.
+                // It will do so only if the 'From' attribute in system.net/mailSettings/smtp is not empty.
 
-                    //only use from config when not set in current
-                    if (_from == null)
-                    {
-                        var from = SmtpSection.From;
-                        if (from == null) return null;
-                        return from;
-                    }
+                //only use from config when not set in current
+                if (UseSystemNetMailSettings && _from == null)
+                {
+                    var from = SmtpSection.From;
+                    return from;
                 }
 #endif
                 return _from;
@@ -681,7 +678,7 @@ private static bool AddAddresses(MailAddressCollection mailAddressCollection, La
             var added = false;
             if (layout != null)
             {
-                foreach (string mail in layout.Render(logEvent).Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
+                foreach (string mail in layout.Render(logEvent).SplitAndTrimTokens(';'))
                 {
                     mailAddressCollection.Add(mail);
                     added = true;
diff --git a/src/NLog/Targets/NLogViewerParameterInfo.cs b/src/NLog/Targets/NLogViewerParameterInfo.cs
index 1fa7e52ec3..d4a5fe1335 100644
--- a/src/NLog/Targets/NLogViewerParameterInfo.cs
+++ b/src/NLog/Targets/NLogViewerParameterInfo.cs
@@ -40,6 +40,9 @@ namespace NLog.Targets
     /// Represents a parameter to a NLogViewer target.
     /// </summary>
     [NLogConfigurationItem]
+    [ThreadAgnostic]
+    [ThreadSafe]
+    [AppDomainFixedOutput]
     public class NLogViewerParameterInfo
     {
         /// <summary>
@@ -62,5 +65,11 @@ public NLogViewerParameterInfo()
         /// <docgen category='Parameter Options' order='10' />
         [RequiredParameter]
         public Layout Layout { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether an attribute with empty value should be included in the output
+        /// </summary>
+        /// <docgen category='Parameter Options' order='100' />
+        public bool IncludeEmptyValue { get; set; } = true;
     }
 }
diff --git a/src/NLog/Targets/NetworkTarget.cs b/src/NLog/Targets/NetworkTarget.cs
index 9f341b68da..80491ae684 100644
--- a/src/NLog/Targets/NetworkTarget.cs
+++ b/src/NLog/Targets/NetworkTarget.cs
@@ -228,17 +228,16 @@ public NetworkTarget(string name) : this()
         /// <param name="asyncContinuation">The asynchronous continuation.</param>
         protected override void FlushAsync(AsyncContinuation asyncContinuation)
         {
-            int remainingCount = 0;
+            int remainingCount;
 
-            AsyncContinuation continuation =
-                ex =>
+            void Continuation(Exception ex)
+            {
+                // ignore exception
+                if (Interlocked.Decrement(ref remainingCount) == 0)
                 {
-                    // ignore exception
-                    if (Interlocked.Decrement(ref remainingCount) == 0)
-                    {
-                        asyncContinuation(null);
-                    }
-                };
+                    asyncContinuation(null);
+                }
+            }
 
             lock (_openNetworkSenders)
             {
@@ -254,7 +253,7 @@ protected override void FlushAsync(AsyncContinuation asyncContinuation)
                     // and invoke continuation at the very end
                     foreach (var openSender in _openNetworkSenders)
                     {
-                        openSender.FlushAsync(continuation);
+                        openSender.FlushAsync(Continuation);
                     }
                 }
             }
@@ -467,10 +466,8 @@ private LinkedListNode<NetworkSender> GetCachedNetworkSender(string address)
         {
             lock (_currentSenderCache)
             {
-                LinkedListNode<NetworkSender> senderNode;
-
                 // already have address
-                if (_currentSenderCache.TryGetValue(address, out senderNode))
+                if (_currentSenderCache.TryGetValue(address, out var senderNode))
                 {
                     senderNode.Value.CheckSocket();
                     return senderNode;
@@ -535,15 +532,10 @@ private void ReleaseCachedConnection(LinkedListNode<NetworkSender> senderNode)
                     }
                 }
 
-                LinkedListNode<NetworkSender> sender2;
-
                 // make sure the current sender for this address is the one we want to remove
-                if (_currentSenderCache.TryGetValue(networkSender.Address, out sender2))
+                if (_currentSenderCache.TryGetValue(networkSender.Address, out var sender2) && ReferenceEquals(senderNode, sender2))
                 {
-                    if (ReferenceEquals(senderNode, sender2))
-                    {
-                        _currentSenderCache.Remove(networkSender.Address);
-                    }
+                    _currentSenderCache.Remove(networkSender.Address);
                 }
             }
         }
@@ -568,15 +560,14 @@ private void ChunkedSend(NetworkSender sender, byte[] buffer, AsyncContinuation
             {
                 int pos = 0;
 
-                AsyncContinuation sendNextChunk = null;
-
-                sendNextChunk = ex =>
+                void SendNextChunk(Exception ex)
                 {
                     if (ex != null)
                     {
                         continuation(ex);
                         return;
                     }
+
                     InternalLogger.Trace("NetworkTarget(Name={0}): Sending chunk, position: {1}, length: {2}", Name, pos, tosend);
                     if (tosend <= 0)
                     {
@@ -607,10 +598,10 @@ private void ChunkedSend(NetworkSender sender, byte[] buffer, AsyncContinuation
                     tosend -= chunksize;
                     pos += chunksize;
 
-                    sender.Send(buffer, pos0, chunksize, sendNextChunk);
-                };
+                    sender.Send(buffer, pos0, chunksize, SendNextChunk);
+                }
 
-                sendNextChunk(null);
+                SendNextChunk(null);
             }
         }
     }
diff --git a/src/NLog/Targets/Target.cs b/src/NLog/Targets/Target.cs
index aeae15fcb2..58ae68e050 100644
--- a/src/NLog/Targets/Target.cs
+++ b/src/NLog/Targets/Target.cs
@@ -192,10 +192,9 @@ public void Flush(AsyncContinuation asyncContinuation)
         /// </param>
         public void PrecalculateVolatileLayouts(LogEventInfo logEvent)
         {
-            if (_allLayoutsAreThreadAgnostic)
+            if (_allLayoutsAreThreadAgnostic && (!_oneLayoutIsMutableUnsafe || logEvent.IsLogEventMutableSafe()))
             {
-                if (!_oneLayoutIsMutableUnsafe || logEvent.IsLogEventMutableSafe())
-                    return;
+                return;
             }
 
             // Not all Layouts support concurrent threads, so we have to protect them
@@ -492,15 +491,12 @@ internal void Close()
         /// <param name="disposing">True to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
         protected virtual void Dispose(bool disposing)
         {
-            if (disposing)
+            if (disposing && _isInitialized)
             {
-                if (_isInitialized)
+                _isInitialized = false;
+                if (_initializeException == null)
                 {
-                    _isInitialized = false;
-                    if (_initializeException == null)
-                    {
-                        CloseTarget();
-                    }
+                    CloseTarget();
                 }
             }
         }
@@ -707,8 +703,7 @@ protected void MergeEventProperties(LogEventInfo logEvent)
             //an Enumerator. Switching to a for-loop avoids the memory allocation.
             for (int i = 0; i < logEvent.Parameters.Length; ++i)
             {
-                var logEventParameter = logEvent.Parameters[i] as LogEventInfo;
-                if (logEventParameter != null && logEventParameter.HasProperties)
+                if (logEvent.Parameters[i] is LogEventInfo logEventParameter && logEventParameter.HasProperties)
                 {
                     foreach (var key in logEventParameter.Properties.Keys)
                     {
@@ -761,14 +756,11 @@ protected string RenderLogEvent(Layout layout, LogEventInfo logEvent)
 
         private static bool TryGetCachedValue(Layout layout, LogEventInfo logEvent, out string value)
         {
-            if (!layout.ThreadAgnostic || layout.MutableUnsafe)
+            if ((!layout.ThreadAgnostic || layout.MutableUnsafe) && logEvent.TryGetCachedLayoutValue(layout, out var value2))
             {
-                if (logEvent.TryGetCachedLayoutValue(layout, out var value2))
                 {
-                    {
-                        value = value2?.ToString() ?? string.Empty;
-                        return true;
-                    }
+                    value = value2?.ToString() ?? string.Empty;
+                    return true;
                 }
             }
 
diff --git a/src/NLog/Targets/TargetWithContext.cs b/src/NLog/Targets/TargetWithContext.cs
index 49a794083a..dde3e3af98 100644
--- a/src/NLog/Targets/TargetWithContext.cs
+++ b/src/NLog/Targets/TargetWithContext.cs
@@ -50,7 +50,7 @@ public abstract class TargetWithContext : TargetWithLayout, IIncludeContext
         /// <docgen category='Layout Options' order='1' />
         public sealed override Layout Layout
         {
-            get { return _contextLayout; }
+            get => _contextLayout;
             set
             {
                 if (_contextLayout != null)
@@ -172,21 +172,15 @@ protected bool ShouldIncludeProperties(LogEventInfo logEvent)
             }
 
 #if !SILVERLIGHT
-            if (IncludeMdlc)
+            if (IncludeMdlc && !CombineProperties(logEvent, _contextLayout.MdlcLayout, ref combinedProperties))
             {
-                if (!CombineProperties(logEvent, _contextLayout.MdlcLayout, ref combinedProperties))
-                {
-                    combinedProperties = CaptureContextMdlc(logEvent, combinedProperties);
-                }
+                combinedProperties = CaptureContextMdlc(logEvent, combinedProperties);
             }
 #endif
 
-            if (IncludeMdc)
+            if (IncludeMdc && !CombineProperties(logEvent, _contextLayout.MdcLayout, ref combinedProperties))
             {
-                if (!CombineProperties(logEvent, _contextLayout.MdcLayout, ref combinedProperties))
-                {
-                    combinedProperties = CaptureContextMdc(logEvent, combinedProperties);
-                }
+                combinedProperties = CaptureContextMdc(logEvent, combinedProperties);
             }
 
             if (IncludeGdc)
@@ -267,8 +261,7 @@ private bool CombineProperties(LogEventInfo logEvent, Layout contextLayout, ref
                 return false;
             }
 
-            var contextProperties = value as IDictionary<string, object>;
-            if (contextProperties != null)
+            if (value is IDictionary<string, object> contextProperties)
             {
                 if (combinedProperties != null)
                 {
@@ -473,7 +466,7 @@ private bool TryGetContextPropertyValue(LogEventInfo logEvent, TargetPropertyWit
                 object value = MappedDiagnosticsContext.GetObject(name);
                 if (SerializeMdcItem(logEvent, name, value, out var serializedValue))
                 {
-                    AddContextProperty(logEvent, name, value, checkForDuplicates, contextProperties);
+                    AddContextProperty(logEvent, name, serializedValue, checkForDuplicates, contextProperties);
                 }
             }
             return contextProperties;
@@ -518,7 +511,7 @@ protected virtual bool SerializeMdcItem(LogEventInfo logEvent, string name, obje
                 object value = MappedDiagnosticsLogicalContext.GetObject(name);
                 if (SerializeMdlcItem(logEvent, name, value, out var serializedValue))
                 {
-                    AddContextProperty(logEvent, name, value, checkForDuplicates, contextProperties);
+                    AddContextProperty(logEvent, name, serializedValue, checkForDuplicates, contextProperties);
                 }
             }
             return contextProperties;
diff --git a/src/NLog/Targets/WebServiceTarget.cs b/src/NLog/Targets/WebServiceTarget.cs
index f8ce3ae095..11020ec17f 100644
--- a/src/NLog/Targets/WebServiceTarget.cs
+++ b/src/NLog/Targets/WebServiceTarget.cs
@@ -487,12 +487,12 @@ private Uri BuildWebServiceUrl(object[] parameterValues)
             }
 
             //if the protocol is HttpGet, we need to add the parameters to the query string of the url
-            string queryParameters = string.Empty;
+            string queryParameters;
             using (var targetBuilder = OptimizeBufferReuse ? ReusableLayoutBuilder.Allocate() : ReusableLayoutBuilder.None)
             {
                 StringBuilder sb = targetBuilder.Result ?? new StringBuilder();
-                UrlHelper.EscapeEncodingFlag encodingFlags = UrlHelper.GetUriStringEncodingFlags(EscapeDataNLogLegacy, false, EscapeDataRfc3986);
-                BuildWebServiceQueryParameters(parameterValues, sb, encodingFlags);
+                UrlHelper.EscapeEncodingOptions encodingOptions = UrlHelper.GetUriStringEncodingFlags(EscapeDataNLogLegacy, false, EscapeDataRfc3986);
+                BuildWebServiceQueryParameters(parameterValues, sb, encodingOptions);
                 queryParameters = sb.ToString();
             }
 
@@ -511,7 +511,7 @@ private Uri BuildWebServiceUrl(object[] parameterValues)
             return builder.Uri;
         }
 
-        private void BuildWebServiceQueryParameters(object[] parameterValues, StringBuilder sb, UrlHelper.EscapeEncodingFlag encodingFlags)
+        private void BuildWebServiceQueryParameters(object[] parameterValues, StringBuilder sb, UrlHelper.EscapeEncodingOptions encodingOptions)
         {
             string separator = string.Empty;
             for (int i = 0; i < Parameters.Count; i++)
@@ -522,7 +522,7 @@ private void BuildWebServiceQueryParameters(object[] parameterValues, StringBuil
                 string parameterValue = XmlHelper.XmlConvertToString(parameterValues[i]);
                 if (!string.IsNullOrEmpty(parameterValue))
                 {
-                    UrlHelper.EscapeDataEncode(parameterValue, sb, encodingFlags);
+                    UrlHelper.EscapeDataEncode(parameterValue, sb, encodingOptions);
                 }
                 separator = "&";
             }
@@ -605,11 +605,11 @@ protected virtual void InitRequest(HttpWebRequest request)
 
         private class HttpPostFormEncodedFormatter : HttpPostTextFormatterBase
         {
-            readonly UrlHelper.EscapeEncodingFlag _encodingFlags;
+            readonly UrlHelper.EscapeEncodingOptions _encodingOptions;
 
             public HttpPostFormEncodedFormatter(WebServiceTarget target) : base(target)
             {
-                _encodingFlags = UrlHelper.GetUriStringEncodingFlags(target.EscapeDataNLogLegacy, true, target.EscapeDataRfc3986);
+                _encodingOptions = UrlHelper.GetUriStringEncodingFlags(target.EscapeDataNLogLegacy, true, target.EscapeDataRfc3986);
             }
 
             protected override string GetContentType(WebServiceTarget target)
@@ -619,7 +619,7 @@ protected override string GetContentType(WebServiceTarget target)
 
             protected override void WriteStringContent(StringBuilder builder, object[] parameterValues)
             {
-                Target.BuildWebServiceQueryParameters(parameterValues, builder, _encodingFlags);
+                Target.BuildWebServiceQueryParameters(parameterValues, builder, _encodingOptions);
             }
         }
 
diff --git a/src/NLog/Targets/Wrappers/AsyncRequestQueue-T.cs b/src/NLog/Targets/Wrappers/AsyncRequestQueue-T.cs
index d40b6d2b74..19288f4ce0 100644
--- a/src/NLog/Targets/Wrappers/AsyncRequestQueue-T.cs
+++ b/src/NLog/Targets/Wrappers/AsyncRequestQueue-T.cs
@@ -94,8 +94,8 @@ public override bool Enqueue(AsyncLogEventInfo logEventInfo)
 
                         case AsyncTargetWrapperOverflowAction.Grow:
                             InternalLogger.Debug("The overflow action is Grow, adding element anyway");
-                            RequestLimit *= 2;
                             OnLogEventQueueGrows(RequestCount + 1);
+                            RequestLimit *= 2;
                             break;
 
                         case AsyncTargetWrapperOverflowAction.Block:
diff --git a/src/NLog/Targets/Wrappers/BufferingTargetWrapper.cs b/src/NLog/Targets/Wrappers/BufferingTargetWrapper.cs
index 3e7e712d67..df3cd4e2b1 100644
--- a/src/NLog/Targets/Wrappers/BufferingTargetWrapper.cs
+++ b/src/NLog/Targets/Wrappers/BufferingTargetWrapper.cs
@@ -187,10 +187,7 @@ protected override void CloseTarget()
                 _flushTimer = null;
                 if (currentTimer.WaitForDispose(TimeSpan.FromSeconds(1)))
                 {
-                    lock (_lockObject)
-                    {
-                        WriteEventsInBuffer("Closing Target");
-                    }
+                    WriteEventsInBuffer("Closing Target");
                 }
             }
 
@@ -218,28 +215,34 @@ protected override void Write(AsyncLogEventInfo logEvent)
             }
             else
             {
-                if (FlushTimeout > 0)
+                if (FlushTimeout > 0 && (SlidingTimeout || count == 1))
                 {
                     // reset the timer on first item added to the buffer or whenever SlidingTimeout is set to true
-                    if (SlidingTimeout || count == 1)
-                    {
-                        _flushTimer.Change(FlushTimeout, -1);
-                    }
+                    _flushTimer.Change(FlushTimeout, -1);
                 }
             }
         }
 
         private void FlushCallback(object state)
         {
+            bool lockTaken = false;
+
             try
             {
-                lock (_lockObject)
+                int timeoutMilliseconds = Math.Min(FlushTimeout / 2, 100);
+                lockTaken = Monitor.TryEnter(_lockObject, timeoutMilliseconds);
+                if (lockTaken)
                 {
                     if (_flushTimer == null)
                         return;
 
                     WriteEventsInBuffer(null);
                 }
+                else
+                {
+                    if (_buffer.Count > 0)
+                        _flushTimer?.Change(FlushTimeout, -1);   // Schedule new retry timer
+                }
             }
             catch (Exception exception)
             {
@@ -250,6 +253,13 @@ private void FlushCallback(object state)
                     throw;  // Throwing exceptions here will crash the entire application (.NET 2.0 behavior)
                 }
             }
+            finally
+            {
+                if (lockTaken)
+                {
+                    Monitor.Exit(_lockObject);
+                }
+            }
         }
 
         private void WriteEventsInBuffer(string reason)
diff --git a/src/NLog/Targets/Wrappers/ConcurrentRequestQueue.cs b/src/NLog/Targets/Wrappers/ConcurrentRequestQueue.cs
index d7791184b5..c67d7f1ed4 100644
--- a/src/NLog/Targets/Wrappers/ConcurrentRequestQueue.cs
+++ b/src/NLog/Targets/Wrappers/ConcurrentRequestQueue.cs
@@ -79,6 +79,7 @@ public ConcurrentRequestQueue(int requestLimit, AsyncTargetWrapperOverflowAction
         public override bool Enqueue(AsyncLogEventInfo logEventInfo)
         {
             long currentCount = Interlocked.Increment(ref _count);
+            bool queueWasEmpty = currentCount == 1;  // Inserted first item in empty queue
             if (currentCount > RequestLimit)
             {
                 InternalLogger.Debug("Async queue is full");
@@ -91,33 +92,37 @@ public override bool Enqueue(AsyncLogEventInfo logEventInfo)
                                 if (_logEventInfoQueue.TryDequeue(out var lostItem))
                                 {
                                     InternalLogger.Debug("Discarding one element from queue");
-                                    currentCount = Interlocked.Decrement(ref _count);
+                                    queueWasEmpty = Interlocked.Decrement(ref _count) == 1 || queueWasEmpty;
                                     OnLogEventDropped(lostItem.LogEvent);
-                                break;
+                                    break;
                                 }
                                 currentCount = Interlocked.Read(ref _count);
+                                queueWasEmpty = true;
                             } while (currentCount > RequestLimit);
                         }
                         break;
                     case AsyncTargetWrapperOverflowAction.Block:
                         {
-                            currentCount = WaitForBelowRequestLimit();
+                            WaitForBelowRequestLimit();
+                            queueWasEmpty = true;
                         }
                         break;
                     case AsyncTargetWrapperOverflowAction.Grow:
                         {
+                            InternalLogger.Debug("The overflow action is Grow, adding element anyway");
                             OnLogEventQueueGrows(currentCount);
+                            RequestLimit *= 2;
                         }
                         break;
                 }
             }
             _logEventInfoQueue.Enqueue(logEventInfo);
-            return currentCount == 1;
+            return queueWasEmpty;
         }
 
-        private long WaitForBelowRequestLimit()
+        private void WaitForBelowRequestLimit()
         {
-            long currentCount = 0;
+            long currentCount;
             bool lockTaken = false;
             try
             {
@@ -127,27 +132,15 @@ private long WaitForBelowRequestLimit()
                 // If yield did not help, then wait on a lock
                 while (currentCount > RequestLimit)
                 {
+                    Interlocked.Decrement(ref _count);
+                    InternalLogger.Debug("Blocking because the overflow action is Block...");
                     if (!lockTaken)
-                    {
-                        InternalLogger.Debug("Blocking because the overflow action is Block...");
                         Monitor.Enter(_logEventInfoQueue);
-                        lockTaken = true;
-                        InternalLogger.Trace("Entered critical section.");
-                    }
                     else
-                    {
-                        InternalLogger.Debug("Blocking because the overflow action is Block...");
-                        if (!Monitor.Wait(_logEventInfoQueue, 100))
-                            lockTaken = false;
-                        else
-                            InternalLogger.Trace("Entered critical section.");
-                    }
-                    currentCount = Interlocked.Read(ref _count);
-                }
-
-                if (lockTaken)
-                {
-                    Monitor.PulseAll(_logEventInfoQueue);
+                        Monitor.Wait(_logEventInfoQueue);
+                    lockTaken = true;
+                    InternalLogger.Trace("Entered critical section.");
+                    currentCount = Interlocked.Increment(ref _count);
                 }
             }
             finally
@@ -155,8 +148,6 @@ private long WaitForBelowRequestLimit()
                 if (lockTaken)
                     Monitor.Exit(_logEventInfoQueue);
             }
-
-            return currentCount;
         }
 
         private long TrySpinWaitForLowerCount()
@@ -231,11 +222,16 @@ public override void DequeueBatch(int count, IList<AsyncLogEventInfo> result)
 
             if (dequeueBatch)
             {
-                bool lockTaken = Monitor.TryEnter(_logEventInfoQueue);    // Try to throttle
+                bool lockTaken = false;
+                if (result.Count == count)
+                {
+                    Monitor.Enter(_logEventInfoQueue);    // Only try throttle when falling behind
+                    lockTaken = true;
+                }
+
                 try
                 {
-                    for (int i = 0; i < result.Count; ++i)
-                        Interlocked.Decrement(ref _count);
+                    Interlocked.Add(ref _count, -result.Count);
                     if (lockTaken)
                         Monitor.PulseAll(_logEventInfoQueue);
                 }
diff --git a/src/NLog/Targets/Wrappers/FallbackGroupTarget.cs b/src/NLog/Targets/Wrappers/FallbackGroupTarget.cs
index acbeadcdae..69797515cd 100644
--- a/src/NLog/Targets/Wrappers/FallbackGroupTarget.cs
+++ b/src/NLog/Targets/Wrappers/FallbackGroupTarget.cs
@@ -31,6 +31,8 @@
 // THE POSSIBILITY OF SUCH DAMAGE.
 // 
 
+using System.Diagnostics.CodeAnalysis;
+
 namespace NLog.Targets.Wrappers
 {
     using System.Threading;
@@ -114,6 +116,7 @@ protected override void WriteAsyncThreadSafe(AsyncLogEventInfo logEvent)
         /// resets the target to the first target
         /// stored in <see cref="Targets"/>.
         /// </remarks>
+        [SuppressMessage("ReSharper", "AccessToModifiedClosure")]
         protected override void Write(AsyncLogEventInfo logEvent)
         {
             AsyncContinuation continuation = null;
@@ -127,11 +130,13 @@ protected override void Write(AsyncLogEventInfo logEvent)
                         // success
                         if (ReturnToFirstOnSuccess)
                         {
-#if !SILVERLIGHT || WINDOWS_PHONEs
+#pragma warning disable S1066 // Collapsible "if" statements should be merged
+#if !SILVERLIGHT || WINDOWS_PHONE
                             if (Interlocked.Read(ref _currentTarget) != 0)
 #else
                             if (Interlocked.CompareExchange(ref _currentTarget, 0, 0) != 0)
 #endif
+#pragma warning restore S1066 // Collapsible "if" statements should be merged
                             {
                                 InternalLogger.Debug("FallbackGroup(Name={0}): Target '{1}' succeeded. Returning to the first one.", Name, Targets[targetToInvoke]);
                                 Interlocked.Exchange(ref _currentTarget, 0);
diff --git a/src/NLog/Targets/Wrappers/FilteringTargetWrapper.cs b/src/NLog/Targets/Wrappers/FilteringTargetWrapper.cs
index 0e8404f6e0..0242a10734 100644
--- a/src/NLog/Targets/Wrappers/FilteringTargetWrapper.cs
+++ b/src/NLog/Targets/Wrappers/FilteringTargetWrapper.cs
@@ -34,10 +34,12 @@
 namespace NLog.Targets.Wrappers
 {
     using System;
-    using Common;
-    using Conditions;
-    using Config;
-    using Internal;
+    using System.Collections.Generic;
+    using NLog.Common;
+    using NLog.Conditions;
+    using NLog.Config;
+    using NLog.Filters;
+    using NLog.Internal;
 
     /// <summary>
     /// Filters log entries based on a condition.
@@ -59,8 +61,6 @@ namespace NLog.Targets.Wrappers
     [Target("FilteringWrapper", IsWrapper = true)]
     public class FilteringTargetWrapper : WrapperTargetBase
     {
-        private static readonly object boxedBooleanTrue = true;
-
         /// <summary>
         /// Initializes a new instance of the <see cref="FilteringTargetWrapper" /> class.
         /// </summary>
@@ -90,7 +90,6 @@ public FilteringTargetWrapper(Target wrappedTarget, ConditionExpression conditio
         {
             WrappedTarget = wrappedTarget;
             Condition = condition;
-            OptimizeBufferReuse = GetType() == typeof(FilteringTargetWrapper);  // Class not sealed, reduce breaking changes
         }
 
         /// <summary>
@@ -98,8 +97,25 @@ public FilteringTargetWrapper(Target wrappedTarget, ConditionExpression conditio
         /// to the wrapped target.
         /// </summary>
         /// <docgen category='Filtering Options' order='10' />
+        public ConditionExpression Condition { get => (Filter as ConditionBasedFilter)?.Condition; set => Filter = CreateFilter(value); }
+
+        /// <summary>
+        /// Gets or sets the filter. Log events who evaluates to <see cref="FilterResult.Ignore"/> will be discarded
+        /// </summary>
+        /// <docgen category='Filtering Options' order='10' />
         [RequiredParameter]
-        public ConditionExpression Condition { get; set; }
+        public Filter Filter { get; set; }
+
+        /// <inheritdoc/>
+        protected override void InitializeTarget()
+        {
+            base.InitializeTarget();
+
+            if (!OptimizeBufferReuse && WrappedTarget != null && WrappedTarget.OptimizeBufferReuse)
+            {
+                OptimizeBufferReuse = GetType() == typeof(FilteringTargetWrapper); // Class not sealed, reduce breaking changes
+            }
+        }
 
         /// <summary>
         /// Checks the condition against the passed log event.
@@ -109,8 +125,7 @@ public FilteringTargetWrapper(Target wrappedTarget, ConditionExpression conditio
         /// <param name="logEvent">Log event.</param>
         protected override void Write(AsyncLogEventInfo logEvent)
         {
-            object v = Condition.Evaluate(logEvent.LogEvent);
-            if (boxedBooleanTrue.Equals(v))
+            if (ShouldLogEvent(logEvent, Filter))
             {
                 WrappedTarget.WriteAsyncLogEvent(logEvent);
             }
@@ -119,5 +134,35 @@ protected override void Write(AsyncLogEventInfo logEvent)
                 logEvent.Continuation(null);
             }
         }
+
+        /// <inheritdoc/>
+        protected override void Write(IList<AsyncLogEventInfo> logEvents)
+        {
+            var filterLogEvents = logEvents.Filter(Filter, ShouldLogEvent);
+            WrappedTarget.WriteAsyncLogEvents(filterLogEvents);
+        }
+
+        private static bool ShouldLogEvent(AsyncLogEventInfo logEvent, Filter filter)
+        {
+            var filterResult = filter.GetFilterResult(logEvent.LogEvent);
+            if (filterResult != FilterResult.Ignore && filterResult != FilterResult.IgnoreFinal)
+            {
+                return true;
+            }
+            else
+            {
+                logEvent.Continuation(null);
+                return false;
+            }
+        }
+
+        private static ConditionBasedFilter CreateFilter(ConditionExpression value)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+            return new ConditionBasedFilter { Condition = value, DefaultFilterResult = FilterResult.Ignore };
+        }
     }
 }
diff --git a/src/NLog/Targets/Wrappers/ImpersonatingTargetWrapper.cs b/src/NLog/Targets/Wrappers/ImpersonatingTargetWrapper.cs
index 2687d5f813..42ac08f5ab 100644
--- a/src/NLog/Targets/Wrappers/ImpersonatingTargetWrapper.cs
+++ b/src/NLog/Targets/Wrappers/ImpersonatingTargetWrapper.cs
@@ -52,8 +52,8 @@ namespace NLog.Targets.Wrappers
     [Target("ImpersonatingWrapper", IsWrapper = true)]
     public class ImpersonatingTargetWrapper : WrapperTargetBase
     {
-        private WindowsIdentity newIdentity;
-        private IntPtr duplicateTokenHandle = IntPtr.Zero;
+        private WindowsIdentity _newIdentity;
+        private IntPtr _duplicateTokenHandle = IntPtr.Zero;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ImpersonatingTargetWrapper" /> class.
@@ -138,7 +138,7 @@ protected override void InitializeTarget()
         {
             if (!RevertToSelf)
             {
-                newIdentity = CreateWindowsIdentity(out duplicateTokenHandle);
+                _newIdentity = CreateWindowsIdentity(out _duplicateTokenHandle);
             }
 
             using (DoImpersonate())
@@ -157,16 +157,16 @@ protected override void CloseTarget()
                 base.CloseTarget();
             }
 
-            if (duplicateTokenHandle != IntPtr.Zero)
+            if (_duplicateTokenHandle != IntPtr.Zero)
             {
-                NativeMethods.CloseHandle(duplicateTokenHandle);
-                duplicateTokenHandle = IntPtr.Zero;
+                NativeMethods.CloseHandle(_duplicateTokenHandle);
+                _duplicateTokenHandle = IntPtr.Zero;
             }
 
-            if (newIdentity != null)
+            if (_newIdentity != null)
             {
-                newIdentity.Dispose();
-                newIdentity = null;
+                _newIdentity.Dispose();
+                _newIdentity = null;
             }
         }
 
@@ -229,7 +229,7 @@ private IDisposable DoImpersonate()
                 return new ContextReverter(WindowsIdentity.Impersonate(IntPtr.Zero));
             }
 
-            return new ContextReverter(newIdentity.Impersonate());
+            return new ContextReverter(_newIdentity.Impersonate());
         }
 
         //
@@ -239,7 +239,6 @@ private IDisposable DoImpersonate()
         private WindowsIdentity CreateWindowsIdentity(out IntPtr handle)
         {
             // initialize tokens
-            IntPtr logonHandle;
 
             if (!NativeMethods.LogonUser(
                 UserName,
@@ -247,7 +246,7 @@ private WindowsIdentity CreateWindowsIdentity(out IntPtr handle)
                 Password,
                 (int)LogOnType,
                 (int)LogOnProvider,
-                out logonHandle))
+                out var logonHandle))
             {
                 throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());
             }
@@ -268,9 +267,9 @@ private WindowsIdentity CreateWindowsIdentity(out IntPtr handle)
         /// Helper class which reverts the given <see cref="WindowsImpersonationContext"/> 
         /// to its original value as part of <see cref="IDisposable.Dispose"/>.
         /// </summary>
-        internal class ContextReverter : IDisposable
+        internal sealed class ContextReverter : IDisposable
         {
-            private readonly WindowsImpersonationContext wic;
+            private readonly WindowsImpersonationContext _impersonationContext;
 
             /// <summary>
             /// Initializes a new instance of the <see cref="ContextReverter" /> class.
@@ -278,7 +277,7 @@ internal class ContextReverter : IDisposable
             /// <param name="windowsImpersonationContext">The windows impersonation context.</param>
             public ContextReverter(WindowsImpersonationContext windowsImpersonationContext)
             {
-                wic = windowsImpersonationContext;
+                _impersonationContext = windowsImpersonationContext;
             }
 
             /// <summary>
@@ -286,7 +285,7 @@ public ContextReverter(WindowsImpersonationContext windowsImpersonationContext)
             /// </summary>
             public void Dispose()
             {
-                wic.Undo();
+                _impersonationContext.Undo();
             }
         }
     }
diff --git a/src/NLog/Targets/Wrappers/PostFilteringTargetWrapper.cs b/src/NLog/Targets/Wrappers/PostFilteringTargetWrapper.cs
index 016178a285..8110bef2b7 100644
--- a/src/NLog/Targets/Wrappers/PostFilteringTargetWrapper.cs
+++ b/src/NLog/Targets/Wrappers/PostFilteringTargetWrapper.cs
@@ -35,10 +35,10 @@ namespace NLog.Targets.Wrappers
 {
     using System;
     using System.Collections.Generic;
-    using Common;
-    using Conditions;
-    using Config;
-    using Internal;
+    using NLog.Common;
+    using NLog.Conditions;
+    using NLog.Config;
+    using NLog.Internal;
 
     /// <summary>
     /// Filters buffered log entries based on a set of conditions that are evaluated on a group of events.
@@ -75,18 +75,17 @@ public class PostFilteringTargetWrapper : WrapperTargetBase
         /// <summary>
         /// Initializes a new instance of the <see cref="PostFilteringTargetWrapper" /> class.
         /// </summary>
-        public PostFilteringTargetWrapper() : this(null)
+        public PostFilteringTargetWrapper()
+            : this(null)
         {
-            Rules = new List<FilteringRule>();
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="PostFilteringTargetWrapper" /> class.
         /// </summary>
         public PostFilteringTargetWrapper(Target wrappedTarget)
+            : this(null, wrappedTarget)
         {
-            Rules = new List<FilteringRule>();
-            WrappedTarget = wrappedTarget;
         }
 
         /// <summary>
@@ -95,9 +94,10 @@ public PostFilteringTargetWrapper(Target wrappedTarget)
         /// <param name="name">Name of the target.</param>
         /// <param name="wrappedTarget">The wrapped target.</param>
         public PostFilteringTargetWrapper(string name, Target wrappedTarget)
-            : this(wrappedTarget)
         {
             Name = name;
+            WrappedTarget = wrappedTarget;
+            Rules = new List<FilteringRule>();
         }
 
         /// <summary>
@@ -115,6 +115,23 @@ public PostFilteringTargetWrapper(string name, Target wrappedTarget)
         [ArrayParameter(typeof(FilteringRule), "when")]
         public IList<FilteringRule> Rules { get; private set; }
 
+        /// <inheritdoc/>
+        protected override void InitializeTarget()
+        {
+            base.InitializeTarget();
+
+            if (!OptimizeBufferReuse && WrappedTarget != null && WrappedTarget.OptimizeBufferReuse)
+            {
+                OptimizeBufferReuse = GetType() == typeof(PostFilteringTargetWrapper); // Class not sealed, reduce breaking changes
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override void Write(AsyncLogEventInfo logEvent)
+        {
+            Write((IList<AsyncLogEventInfo>)new[] { logEvent });  // Single LogEvent should also work
+        }
+
         /// <summary>
         /// NOTE! Obsolete, instead override Write(IList{AsyncLogEventInfo} logEvents)
         /// 
@@ -138,69 +155,65 @@ protected override void Write(AsyncLogEventInfo[] logEvents)
         /// <param name="logEvents">Array of log events to be post-filtered.</param>
         protected override void Write(IList<AsyncLogEventInfo> logEvents)
         {
-            ConditionExpression resultFilter = null;
-
             InternalLogger.Trace("PostFilteringWrapper(Name={0}): Running on {1} events", Name, logEvents.Count);
 
-            // evaluate all the rules to get the filtering condition
-            for (int i = 0; i < logEvents.Count; ++i)
+            var resultFilter = EvaluateAllRules(logEvents) ?? DefaultFilter;
+            if (resultFilter == null)
             {
-                foreach (FilteringRule rule in Rules)
-                {
-                    object v = rule.Exists.Evaluate(logEvents[i].LogEvent);
-
-                    if (boxedTrue.Equals(v))
-                    {
-                        InternalLogger.Trace("PostFilteringWrapper(Name={0}): Rule matched: {1}", Name, rule.Exists);
-
-                        resultFilter = rule.Filter;
-                        break;
-                    }
-                }
-
-                if (resultFilter != null)
-                {
-                    break;
-                }
+                WrappedTarget.WriteAsyncLogEvents(logEvents);
             }
-
-            if (resultFilter == null)
+            else
             {
-                resultFilter = DefaultFilter;
+                InternalLogger.Trace("PostFilteringWrapper(Name={0}): Filter to apply: {1}", Name, resultFilter);
+                var resultBuffer = logEvents.Filter(resultFilter, ApplyFilter);
+                InternalLogger.Trace("PostFilteringWrapper(Name={0}): After filtering: {1} events.", Name, resultBuffer.Count);
+                if (resultBuffer.Count > 0)
+                {
+                    InternalLogger.Trace("PostFilteringWrapper(Name={0}): Sending to {1}", Name, WrappedTarget);
+                    WrappedTarget.WriteAsyncLogEvents(resultBuffer);
+                }
             }
+        }
 
-            if (resultFilter == null)
+        private static bool ApplyFilter(AsyncLogEventInfo logEvent, ConditionExpression resultFilter)
+        {
+            object v = resultFilter.Evaluate(logEvent.LogEvent);
+            if (boxedTrue.Equals(v))
             {
-                WrappedTarget.WriteAsyncLogEvents(logEvents);
+                return true;
             }
             else
             {
-                InternalLogger.Trace("PostFilteringWrapper(Name={0}): Filter to apply: {1}", Name, resultFilter);
+                logEvent.Continuation(null);
+                return false;
+            }
+        }
 
-                // apply the condition to the buffer
-                var resultBuffer = new List<AsyncLogEventInfo>();
+        /// <summary>
+        /// Evaluate all the rules to get the filtering condition
+        /// </summary>
+        /// <param name="logEvents"></param>
+        /// <returns></returns>
+        private ConditionExpression EvaluateAllRules(IList<AsyncLogEventInfo> logEvents)
+        {
+            if (Rules.Count == 0)
+                return null;
 
-                for (int i = 0; i < logEvents.Count; ++i)
+            for (int i = 0; i < logEvents.Count; ++i)
+            {
+                for (int j = 0; j < Rules.Count; ++j)
                 {
-                    object v = resultFilter.Evaluate(logEvents[i].LogEvent);
+                    var rule = Rules[j];
+                    object v = rule.Exists.Evaluate(logEvents[i].LogEvent);
                     if (boxedTrue.Equals(v))
                     {
-                        resultBuffer.Add(logEvents[i]);
-                    }
-                    else
-                    {
-                        // anything not passed down will be notified about successful completion
-                        logEvents[i].Continuation(null);
+                        InternalLogger.Trace("PostFilteringWrapper(Name={0}): Rule matched: {1}", Name, rule.Exists);
+                        return rule.Filter;
                     }
                 }
-
-                InternalLogger.Trace("PostFilteringWrapper(Name={0}): After filtering: {1} events.", Name, resultBuffer.Count);
-                if (resultBuffer.Count > 0)
-                {
-                    InternalLogger.Trace("PostFilteringWrapper(Name={0}): Sending to {1}", Name, WrappedTarget);
-                    WrappedTarget.WriteAsyncLogEvents(resultBuffer);
-                }
             }
+
+            return null;
         }
     }
 }
diff --git a/src/NuGet/NLog.Config/NLog.Config.nuspec b/src/NuGet/NLog.Config/NLog.Config.nuspec
index c6b1a3c67b..af0626694a 100644
--- a/src/NuGet/NLog.Config/NLog.Config.nuspec
+++ b/src/NuGet/NLog.Config/NLog.Config.nuspec
@@ -10,8 +10,20 @@
     <authors>Kim Christensen, Julian Verdurmen</authors>
     <owners>Kim Christenen, Julian Verdurmen </owners>
     <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <summary>Configuration file for NLog. </summary>
-    <description>Xml file to get started with configuring NLog. This package is not mandatory to get started with NLog: the configuration file can created manually and the configuration can be created programmatically.  </description>
+    <summary>Configuration file for NLog to get started.</summary>
+    <description>NLog.config file to get started with configuring NLog.
+This package is not mandatory to get started with NLog: the configuration file can
+created manually (read specs here: https://github.com/NLog/NLog/wiki/Configuration-file) 
+or the configuration can be created programmatically. (read more here: https://github.com/NLog/NLog/wiki/Configuration-API) 
+
+Note: Unfortunately this package won't work well when using &lt;PackageReference&gt; 
+
+Advised to:
+
+- download manually: https://raw.githubusercontent.com/NLog/NLog/dev/src/NuGet/NLog.Config/content/NLog.config
+- set "Copy To Output Directory" to "Copy if newer"
+
+</description>
     <language>en-US</language>
     <iconUrl>https://nlog-project.org/NConfig.png</iconUrl>
     <projectUrl>https://nlog-project.org/</projectUrl>
@@ -22,7 +34,7 @@
       <dependency id="NLog" version="$BuildVersion$" />
       <dependency id="NLog.Schema" version="$BuildVersion$" />
     </dependencies>
-    <tags>nlog, xml, config</tags>
+    <tags>nlog, xml, config, nlog.config</tags>
     <contentFiles>
       <files include="**/*.*" buildAction="None" copyToOutput="true" flatten="true" />
     </contentFiles>
diff --git a/src/NuGet/NLog.Schema/NLog.Schema.nuspec b/src/NuGet/NLog.Schema/NLog.Schema.nuspec
index 31ab5992fa..803cf32792 100644
--- a/src/NuGet/NLog.Schema/NLog.Schema.nuspec
+++ b/src/NuGet/NLog.Schema/NLog.Schema.nuspec
@@ -10,7 +10,10 @@
     <summary>Enables Intellisense(TM) when editing NLog.config.</summary>
     <description>XSD file to enables Intellisense(TM) when editing NLog configuration files, for example in Visual Studio.  
 
-Note: extensions to NLog will report XSD errors. Those can be ignored safely.  </description>
+Notes:
+- Extensions could report XSD errors. Those errors could be ignored safely.  
+- Unfortunately this package won't work well when using &lt;PackageReference&gt;. You could download the lastest XSD from here: https://nlog-project.org/schemas/NLog.xsd 
+</description>
     <releaseNotes>NLog $BuildVersion$</releaseNotes>
     <language>en-US</language>
     <iconUrl>https://nlog-project.org/NConfig.png</iconUrl>
diff --git a/tests/NLog.UnitTests/Config/ReloadTests.cs b/tests/NLog.UnitTests/Config/ReloadTests.cs
index d6c1fc4cf9..47e5010a78 100644
--- a/tests/NLog.UnitTests/Config/ReloadTests.cs
+++ b/tests/NLog.UnitTests/Config/ReloadTests.cs
@@ -583,6 +583,11 @@ public void TestKeepVariablesOnReload()
             Assert.Equal("new_value", logFactory.Configuration.Variables["var1"].OriginalText);
             Assert.Equal("keep_value", logFactory.Configuration.Variables["var2"].OriginalText);
             Assert.Equal("new_value3", logFactory.Configuration.Variables["var3"].OriginalText);
+
+            logFactory.Configuration = configuration.ReloadNewConfig();
+            Assert.Equal("new_value", logFactory.Configuration.Variables["var1"].OriginalText);
+            Assert.Equal("keep_value", logFactory.Configuration.Variables["var2"].OriginalText);
+            Assert.Equal("new_value3", logFactory.Configuration.Variables["var3"].OriginalText);
         }
 
         [Fact]
@@ -602,6 +607,10 @@ public void TestResetVariablesOnReload()
             configLoader.ReloadConfigOnTimer(configuration);
             Assert.Equal("", logFactory.Configuration.Variables["var1"].OriginalText);
             Assert.Equal("keep_value", logFactory.Configuration.Variables["var2"].OriginalText);
+
+            logFactory.Configuration = configuration.ReloadNewConfig();
+            Assert.Equal("", logFactory.Configuration.Variables["var1"].OriginalText);
+            Assert.Equal("keep_value", logFactory.Configuration.Variables["var2"].OriginalText);
         }
 
         [Fact]
diff --git a/tests/NLog.UnitTests/Internal/ExpandoTestDictionary.cs b/tests/NLog.UnitTests/Internal/ExpandoTestDictionary.cs
new file mode 100644
index 0000000000..1d286802f7
--- /dev/null
+++ b/tests/NLog.UnitTests/Internal/ExpandoTestDictionary.cs
@@ -0,0 +1,112 @@
+// 
+// Copyright (c) 2004-2019 Jaroslaw Kowalski <jaak@jkowalski.net>, Kim Christensen, Julian Verdurmen
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without 
+// modification, are permitted provided that the following conditions 
+// are met:
+// 
+// * Redistributions of source code must retain the above copyright notice, 
+//   this list of conditions and the following disclaimer. 
+// 
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution. 
+// 
+// * Neither the name of Jaroslaw Kowalski nor the names of its 
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission. 
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
+// THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+namespace NLog.UnitTests.Internal
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// Special Expando-Object that has custom object-value (Similar to JObject)
+    /// </summary>
+    internal class ExpandoTestDictionary : IDictionary<string, IConvertible>
+    {
+        private readonly Dictionary<string, IConvertible> _properties = new Dictionary<string, IConvertible>();
+
+        public IConvertible this[string key] { get => ((IDictionary<string, IConvertible>)_properties)[key]; set => ((IDictionary<string, IConvertible>)_properties)[key] = value; }
+
+        public ICollection<string> Keys => ((IDictionary<string, IConvertible>)_properties).Keys;
+
+        public ICollection<IConvertible> Values => ((IDictionary<string, IConvertible>)_properties).Values;
+
+        public int Count => ((IDictionary<string, IConvertible>)_properties).Count;
+
+        public bool IsReadOnly => ((IDictionary<string, IConvertible>)_properties).IsReadOnly;
+
+        public void Add(string key, IConvertible value)
+        {
+            ((IDictionary<string, IConvertible>)_properties).Add(key, value);
+        }
+
+        public void Add(KeyValuePair<string, IConvertible> item)
+        {
+            ((IDictionary<string, IConvertible>)_properties).Add(item);
+        }
+
+        public void Clear()
+        {
+            ((IDictionary<string, IConvertible>)_properties).Clear();
+        }
+
+        public bool Contains(KeyValuePair<string, IConvertible> item)
+        {
+            return ((IDictionary<string, IConvertible>)_properties).Contains(item);
+        }
+
+        public bool ContainsKey(string key)
+        {
+            return ((IDictionary<string, IConvertible>)_properties).ContainsKey(key);
+        }
+
+        public void CopyTo(KeyValuePair<string, IConvertible>[] array, int arrayIndex)
+        {
+            ((IDictionary<string, IConvertible>)_properties).CopyTo(array, arrayIndex);
+        }
+
+        public IEnumerator<KeyValuePair<string, IConvertible>> GetEnumerator()
+        {
+            return ((IDictionary<string, IConvertible>)_properties).GetEnumerator();
+        }
+
+        public bool Remove(string key)
+        {
+            return ((IDictionary<string, IConvertible>)_properties).Remove(key);
+        }
+
+        public bool Remove(KeyValuePair<string, IConvertible> item)
+        {
+            return ((IDictionary<string, IConvertible>)_properties).Remove(item);
+        }
+
+        public bool TryGetValue(string key, out IConvertible value)
+        {
+            return ((IDictionary<string, IConvertible>)_properties).TryGetValue(key, out value);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((IDictionary<string, IConvertible>)_properties).GetEnumerator();
+        }
+    }
+}
diff --git a/tests/NLog.UnitTests/Internal/StringHelpersTests.cs b/tests/NLog.UnitTests/Internal/StringHelpersTests.cs
index 8cfbfe6de1..7d418ac1fc 100644
--- a/tests/NLog.UnitTests/Internal/StringHelpersTests.cs
+++ b/tests/NLog.UnitTests/Internal/StringHelpersTests.cs
@@ -54,5 +54,25 @@ public void IsNullOrWhiteSpaceTest(string input, bool result)
         {
             Assert.Equal(result, StringHelpers.IsNullOrWhiteSpace(input));
         }
+
+        [Theory]
+        [InlineData("", new string [0])]
+        [InlineData("  ", new string[0])]
+        [InlineData(" , ", new string[0])]
+        [InlineData("a", new string[] { "a" })]
+        [InlineData("a ", new string[] { "a" })]
+        [InlineData(" a", new string[] { "a" })]
+        [InlineData(" a,", new string[] { "a" })]
+        [InlineData(" a, ", new string[] { "a" })]
+        [InlineData("a,b", new string[] { "a", "b" })]
+        [InlineData("a ,b", new string[] { "a", "b" })]
+        [InlineData(" a ,b", new string[] { "a", "b" })]
+        [InlineData(" a , b ", new string[] { "a", "b" })]
+        [InlineData(" a b ", new string[] { "a b" })]
+        public void SplitAndTrimToken(string input, string[] expected)
+        {
+            var result = input.SplitAndTrimTokens(',');
+            Assert.Equal(expected, result);
+        }
     }
 }
diff --git a/tests/NLog.UnitTests/Internal/UrlHelperTests.cs b/tests/NLog.UnitTests/Internal/UrlHelperTests.cs
index e1718e91c5..7d0c291976 100644
--- a/tests/NLog.UnitTests/Internal/UrlHelperTests.cs
+++ b/tests/NLog.UnitTests/Internal/UrlHelperTests.cs
@@ -77,10 +77,10 @@ public void UrlEncodeTest(string input, bool spaceAsPlus, string result)
         public void EscapeDataEncodeTestRfc2396(string input, bool spaceAsPlus, string result)
         {
             System.Text.StringBuilder builder = new System.Text.StringBuilder(input.Length + 20);
-            UrlHelper.EscapeEncodingFlag encodingFlags = UrlHelper.EscapeEncodingFlag.LowerCaseHex | UrlHelper.EscapeEncodingFlag.LegacyRfc2396 | UrlHelper.EscapeEncodingFlag.UriString;
+            UrlHelper.EscapeEncodingOptions encodingOptions = UrlHelper.EscapeEncodingOptions.LowerCaseHex | UrlHelper.EscapeEncodingOptions.LegacyRfc2396 | UrlHelper.EscapeEncodingOptions.UriString;
             if (spaceAsPlus)
-                encodingFlags |= UrlHelper.EscapeEncodingFlag.SpaceAsPlus;
-            UrlHelper.EscapeDataEncode(input, builder, encodingFlags);
+                encodingOptions |= UrlHelper.EscapeEncodingOptions.SpaceAsPlus;
+            UrlHelper.EscapeDataEncode(input, builder, encodingOptions);
             Assert.Equal(result, builder.ToString());
             Assert.Equal(input.Replace('+', ' '), DecodeUrlString(builder.ToString()));
         }
@@ -97,10 +97,10 @@ public void EscapeDataEncodeTestRfc2396(string input, bool spaceAsPlus, string r
         public void EscapeDataEncodeTestRfc3986(string input, bool spaceAsPlus, string result)
         {
             System.Text.StringBuilder builder = new System.Text.StringBuilder(input.Length + 20);
-            UrlHelper.EscapeEncodingFlag encodingFlags = UrlHelper.EscapeEncodingFlag.None;
+            UrlHelper.EscapeEncodingOptions encodingOptions = UrlHelper.EscapeEncodingOptions.None;
             if (spaceAsPlus)
-                encodingFlags |= UrlHelper.EscapeEncodingFlag.SpaceAsPlus;
-            UrlHelper.EscapeDataEncode(input, builder, encodingFlags);
+                encodingOptions |= UrlHelper.EscapeEncodingOptions.SpaceAsPlus;
+            UrlHelper.EscapeDataEncode(input, builder, encodingOptions);
             Assert.Equal(result, builder.ToString());
             Assert.Equal(input.Replace('+', ' '), DecodeUrlString(builder.ToString()));
         }
diff --git a/tests/NLog.UnitTests/LayoutRenderers/CallSiteTests.cs b/tests/NLog.UnitTests/LayoutRenderers/CallSiteTests.cs
index 28db36a2bb..25599d54d2 100644
--- a/tests/NLog.UnitTests/LayoutRenderers/CallSiteTests.cs
+++ b/tests/NLog.UnitTests/LayoutRenderers/CallSiteTests.cs
@@ -406,11 +406,7 @@ public void GivenOneSkipFrameDefined_WhenLogging_ShouldSkipOneUserStackFrame()
             AssertDebugLastMessage("debug", "NLog.UnitTests.LayoutRenderers.CallSiteTests.GivenOneSkipFrameDefined_WhenLogging_ShouldSkipOneUserStackFrame msg");
         }
 
-#if MONO
-        [Fact(Skip = "Not working under MONO - not sure if unit test is wrong, or the code")]
-#else
         [Fact]
-#endif
         public void CleanMethodNamesOfAnonymousDelegatesTest()
         {
             LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
@@ -443,11 +439,7 @@ public void CleanMethodNamesOfAnonymousDelegatesTest()
             }
         }
 
-#if MONO
-        [Fact(Skip = "Not working under MONO - not sure if unit test is wrong, or the code")]
-#else
         [Fact]
-#endif
         public void DontCleanMethodNamesOfAnonymousDelegatesTest()
         {
             LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
@@ -481,11 +473,7 @@ public void DontCleanMethodNamesOfAnonymousDelegatesTest()
             }
         }
 
-#if MONO
-        [Fact(Skip = "Not working under MONO - not sure if unit test is wrong, or the code")]
-#else
         [Fact]
-#endif
         public void CleanClassNamesOfAnonymousDelegatesTest()
         {
             LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
@@ -518,11 +506,7 @@ public void CleanClassNamesOfAnonymousDelegatesTest()
             }
         }
 
-#if MONO
-        [Fact(Skip = "Not working under MONO - not sure if unit test is wrong, or the code")]
-#else
         [Fact]
-#endif
         public void DontCleanClassNamesOfAnonymousDelegatesTest()
         {
             LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
diff --git a/tests/NLog.UnitTests/LayoutRenderers/EnvironmentUserLayoutRendererTests.cs b/tests/NLog.UnitTests/LayoutRenderers/EnvironmentUserLayoutRendererTests.cs
new file mode 100644
index 0000000000..d6a8a5565e
--- /dev/null
+++ b/tests/NLog.UnitTests/LayoutRenderers/EnvironmentUserLayoutRendererTests.cs
@@ -0,0 +1,65 @@
+// 
+// Copyright (c) 2004-2019 Jaroslaw Kowalski <jaak@jkowalski.net>, Kim Christensen, Julian Verdurmen
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without 
+// modification, are permitted provided that the following conditions 
+// are met:
+// 
+// * Redistributions of source code must retain the above copyright notice, 
+//   this list of conditions and the following disclaimer. 
+// 
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution. 
+// 
+// * Neither the name of Jaroslaw Kowalski nor the names of its 
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission. 
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
+// THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+namespace NLog.UnitTests.LayoutRenderers
+{
+    using System;
+    using NLog.Layouts;
+    using Xunit;
+
+    public class EnvironmentUserLayoutRendererTests
+    {
+        [Fact]
+        public void EnvironmentUserTest()
+        {
+            var userName = Environment.GetEnvironmentVariable("USERNAME");
+            if (string.IsNullOrEmpty(userName))
+                userName = Environment.GetEnvironmentVariable("USER") ?? string.Empty;
+
+            Layout layout = "${environment-user}";
+            var result = layout.Render(LogEventInfo.CreateNullEvent());
+            if (!string.IsNullOrEmpty(userName))
+            {
+                Assert.Equal(userName, result);
+
+                var userDomainName = Environment.GetEnvironmentVariable("USERDOMAIN") ?? string.Empty;
+                if (!string.IsNullOrEmpty(userDomainName))
+                {
+                    layout = "${environment-user:domain=true}";
+                    result = layout.Render(LogEventInfo.CreateNullEvent());
+                    Assert.Equal(userDomainName + "\\" + userName, result);
+                }
+            }
+        }
+    }
+}
diff --git a/tests/NLog.UnitTests/LayoutRenderers/EventPropertiesTests.cs b/tests/NLog.UnitTests/LayoutRenderers/EventPropertiesTests.cs
index f92acb7884..81b9d5c892 100644
--- a/tests/NLog.UnitTests/LayoutRenderers/EventPropertiesTests.cs
+++ b/tests/NLog.UnitTests/LayoutRenderers/EventPropertiesTests.cs
@@ -127,5 +127,30 @@ public void JsonFormat()
             logEvent.Properties["prop1"] = new string[] { "Hello", "World" };
             Assert.Equal("[\"Hello\",\"World\"]", layout.Render(logEvent));
         }
+
+        [Theory]
+        [InlineData("prop1", "", "{ Id = 1, id = 2, Name = test, Nested = { Id = 3 } }")]
+        [InlineData("prop1", "Id", "1")]
+        [InlineData("prop1", "id", "2")] //correct casing
+        [InlineData("prop1", "Nested.Id", "3")]
+        [InlineData("prop1", "Id.Wrong", "")] //don't crash on nesting
+        [InlineData("prop1", "Name", "test")]
+        [InlineData("prop1", "Name ", "test")] // trimend
+        [InlineData("prop1", "NameWrong", "")]
+        public void ObjectPathNestedProperty(string item, string objectPath, string expectedValue)
+        {
+            Layout layout = "${event-properties:" + item + ":objectpath=" + objectPath + "}";
+            layout.Initialize(null);
+
+            // Slow Uncached Lookup
+            LogEventInfo logEvent = LogEventInfo.Create(LogLevel.Info, "logger1", "message1");
+            logEvent.Properties["prop1"] = new { Id = 1, id = 2, Name = "test", Nested = new { Id = 3 } };
+            Assert.Equal(expectedValue, layout.Render(logEvent));
+
+            // Fast Cached Lookup
+            LogEventInfo logEvent2 = LogEventInfo.Create(LogLevel.Info, "logger1", "message1");
+            logEvent2.Properties["prop1"] = new { Id = 1, id = 2, Name = "test", Nested = new { Id = 3 } };
+            Assert.Equal(expectedValue, layout.Render(logEvent2));
+        }
     }
 }
\ No newline at end of file
diff --git a/tests/NLog.UnitTests/LayoutRenderers/IdentityTests.cs b/tests/NLog.UnitTests/LayoutRenderers/IdentityTests.cs
index 66507406ea..b1e62d2790 100644
--- a/tests/NLog.UnitTests/LayoutRenderers/IdentityTests.cs
+++ b/tests/NLog.UnitTests/LayoutRenderers/IdentityTests.cs
@@ -31,18 +31,15 @@
 // THE POSSIBILITY OF SUCH DAMAGE.
 // 
 
-using System;
-using NLog.Common;
-using NLog.Config;
-using NLog.Targets;
-using NLog.Targets.Wrappers;
-using NLog.UnitTests.Common;
-using NLog.UnitTests.Targets.Wrappers;
-
 namespace NLog.UnitTests.LayoutRenderers
 {
+    using System;
     using System.Security.Principal;
     using System.Threading;
+    using NLog.Common;
+    using NLog.Config;
+    using NLog.Targets.Wrappers;
+    using NLog.UnitTests.Common;
     using Xunit;
 
     public class IdentityTests : NLogTestBase
@@ -56,7 +53,10 @@ public void WindowsIdentityTest()
         {
 #if NETSTANDARD
             if (IsTravis())
+            {
+                Console.WriteLine("[SKIP] IdentityTests.WindowsIdentityTest NetStandard on Travis not supporting WindowsIdentity");
                 return; // NetCore on Travis not supporting WindowsIdentity
+            }
 #endif
 
             var userDomainName = Environment.GetEnvironmentVariable("USERDOMAIN") ?? string.Empty;
diff --git a/tests/NLog.UnitTests/LayoutRenderers/Log4JXmlTests.cs b/tests/NLog.UnitTests/LayoutRenderers/Log4JXmlTests.cs
index 6f2752b4dc..6038966887 100644
--- a/tests/NLog.UnitTests/LayoutRenderers/Log4JXmlTests.cs
+++ b/tests/NLog.UnitTests/LayoutRenderers/Log4JXmlTests.cs
@@ -31,19 +31,20 @@
 // THE POSSIBILITY OF SUCH DAMAGE.
 // 
 
-using System.Collections.Generic;
-using NLog.Config;
-
 namespace NLog.UnitTests.LayoutRenderers
 {
-    using System.Threading;
-    using System.Diagnostics;
     using System;
-    using System.Xml;
-    using System.Reflection;
+    using System.Collections.Generic;
+    using System.Diagnostics;
     using System.IO;
-    using Xunit;
+    using System.Reflection;
+    using System.Threading;
+    using System.Xml;
+    using NLog.Config;
     using NLog.Internal;
+    using NLog.Layouts;
+    using NLog.Targets;
+    using Xunit;
 
     public class Log4JXmlTests : NLogTestBase
     {
@@ -53,8 +54,8 @@ public void Log4JXmlTest()
             LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
             <nlog throwExceptions='true'>
                 <targets>
-        <target name='debug' type='Debug' layout='${log4jxmlevent:includeCallSite=true:includeSourceInfo=true:includeNdlc=true:includeMdc=true:IncludeNdc=true:includeMdlc=true:IncludeAllProperties=true:ndcItemSeparator=\:\::includenlogdata=true:loggerName=${logger}}' />
-       </targets>
+                    <target name='debug' type='Debug' layout='${log4jxmlevent:includeCallSite=true:includeSourceInfo=true:includeNdlc=true:includeMdc=true:IncludeNdc=true:includeMdlc=true:IncludeAllProperties=true:ndcItemSeparator=\:\::includenlogdata=true:loggerName=${logger}}' />
+                </targets>
                 <rules>
                     <logger name='*' minlevel='Debug' writeTo='debug' />
                 </rules>
@@ -235,6 +236,35 @@ public void Log4JXmlTest()
             }
         }
 
+        [Fact]
+        void Log4JXmlEventLayoutParameterTest()
+        {
+            var log4jLayout = new Log4JXmlEventLayout()
+            {
+                Parameters =
+                {
+                    new NLogViewerParameterInfo
+                    {
+                        Name = "mt",
+                        Layout = "${message:raw=true}",
+                    }
+                },
+            };
+            log4jLayout.Renderer.AppInfo = "MyApp";
+            var logEventInfo = new LogEventInfo
+            {
+                LoggerName = "MyLOgger",
+                TimeStamp = new DateTime(2010, 01, 01, 12, 34, 56, DateTimeKind.Utc),
+                Level = LogLevel.Info,
+                Message = "hello, {0}",
+                Parameters = new[] { "world" },
+            };
+
+            var threadid = Environment.CurrentManagedThreadId;
+            var machinename = Environment.MachineName;
+            Assert.Equal($"<log4j:event logger=\"MyLOgger\" level=\"INFO\" timestamp=\"1262349296000\" thread=\"{threadid}\"><log4j:message>hello, world</log4j:message><log4j:properties><log4j:data name=\"mt\" value=\"hello, {{0}}\" /><log4j:data name=\"log4japp\" value=\"MyApp\" /><log4j:data name=\"log4jmachinename\" value=\"{machinename}\" /></log4j:properties></log4j:event>", log4jLayout.Render(logEventInfo)); 
+        }
+
         [Fact]
         void BadXmlValueTest()
         {
diff --git a/tests/NLog.UnitTests/LayoutRenderers/LogLevelTests.cs b/tests/NLog.UnitTests/LayoutRenderers/LogLevelTests.cs
index a34e46c2f2..fbd72e1905 100644
--- a/tests/NLog.UnitTests/LayoutRenderers/LogLevelTests.cs
+++ b/tests/NLog.UnitTests/LayoutRenderers/LogLevelTests.cs
@@ -132,16 +132,24 @@ public void LogLevelGetTypeCodeTest()
         [Theory]
         [InlineData(typeof(int), 2)]
         [InlineData(typeof(uint), (uint)2)]
+        [InlineData(typeof(string), "Info")]
         public void LogLevelConvertTest(Type type, object expected)
         {
             // Arrange
-            var logLevel = LogLevel.Info;
-
+            IConvertible logLevel = LogLevel.Info;
+            var logConverter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(LogLevel));
+                
             // Act
-            var result = Convert.ChangeType(logLevel, type);
+            var changeTypeResult = Convert.ChangeType(logLevel, type);
+            var changeToResult = logLevel.ToType(type, System.Globalization.CultureInfo.CurrentCulture);
+            var convertToResult = logConverter.CanConvertTo(type) ? logConverter.ConvertTo(logLevel, type) : null;
+            var convertFromResult = logConverter.CanConvertFrom(expected.GetType()) ? logConverter.ConvertFrom(expected) : null;
 
             // Assert
-            Assert.Equal(expected, result);
+            Assert.Equal(expected, changeTypeResult);
+            Assert.Equal(expected, changeToResult);
+            Assert.Equal(expected, convertToResult);
+            Assert.Equal(logLevel, convertFromResult);
         }
     }
 }
\ No newline at end of file
diff --git a/tests/NLog.UnitTests/LayoutRenderers/Wrappers/LeftLayoutRendererWrapperTests.cs b/tests/NLog.UnitTests/LayoutRenderers/Wrappers/LeftLayoutRendererWrapperTests.cs
index 49cb6e12dc..9f6d3dbaf7 100644
--- a/tests/NLog.UnitTests/LayoutRenderers/Wrappers/LeftLayoutRendererWrapperTests.cs
+++ b/tests/NLog.UnitTests/LayoutRenderers/Wrappers/LeftLayoutRendererWrapperTests.cs
@@ -39,15 +39,19 @@ namespace NLog.UnitTests.LayoutRenderers.Wrappers
     public class LeftLayoutRendererWrapperTests
     {
         [Theory]
-        [InlineData(":length=2", "12")]
-        [InlineData(":length=1000", "1234567890")]
-        [InlineData(":length=-1", "")]
-        [InlineData(":length=0", "")]
-        public void LeftWrapperTest(string options, string expected)
+        [InlineData(2, "12")]
+        [InlineData(1000, "1234567890")]
+        [InlineData(-1, "")]
+        [InlineData(0, "")]
+        public void LeftWrapperTest(int length, string expected)
         {
-            SimpleLayout l = $"${{left:${{message}}{options}}}";
+            SimpleLayout l = $"${{left:${{message}}:length={length}}}";
             var result = l.Render(LogEventInfo.Create(LogLevel.Debug, "substringTest", "1234567890"));
             Assert.Equal(expected, result);
+
+            l = $"${{message:truncate={length}}}";
+            result = l.Render(LogEventInfo.Create(LogLevel.Debug, "substringTest", "1234567890"));
+            Assert.Equal(expected, result);
         }
     }
 }
\ No newline at end of file
diff --git a/tests/NLog.UnitTests/LayoutRenderers/Wrappers/WhenEmptyTests.cs b/tests/NLog.UnitTests/LayoutRenderers/Wrappers/WhenEmptyTests.cs
index 6521b42f8b..f29319c86f 100644
--- a/tests/NLog.UnitTests/LayoutRenderers/Wrappers/WhenEmptyTests.cs
+++ b/tests/NLog.UnitTests/LayoutRenderers/Wrappers/WhenEmptyTests.cs
@@ -31,8 +31,11 @@
 // THE POSSIBILITY OF SUCH DAMAGE.
 // 
 
+using NLog.Internal;
+
 namespace NLog.UnitTests.LayoutRenderers.Wrappers
 {
+    using System;
     using NLog;
     using NLog.Layouts;
     using Xunit;
@@ -73,5 +76,45 @@ public void WhenEmpty_MissingInner_ShouldNotThrow()
             var le = LogEventInfo.Create(LogLevel.Info, "logger", "message");
             Assert.Equal("api.log", l.Render(le));
         }
+
+        [Fact]
+        public void WhenDbNullRawValueShouldWork()
+        {
+            SimpleLayout l = @"${event-properties:prop1:whenEmpty=${db-null}}";
+            {
+                var le = LogEventInfo.Create(LogLevel.Info, "logger", "message");
+                le.Properties["prop1"] = 1;
+                var success = l.TryGetRawValue(le, out var rawValue);
+                Assert.True(success);
+                Assert.Equal(1, rawValue);
+            }
+            // empty log message
+            {
+                var le = LogEventInfo.Create(LogLevel.Info, "logger", "message");
+                var success = l.TryGetRawValue(le, out var rawValue);
+                Assert.True(success);
+                Assert.Equal(DBNull.Value, rawValue);
+            }
+
+        }
+
+        [Theory]
+        [InlineData("message", "message")]
+        [InlineData("", "default")]
+        public void GetStringValueShouldWork(string message, string expected)
+        {
+            // Arrange
+            SimpleLayout layout = @"${message:whenEmpty=default}";
+            var stringValueRenderer = (IStringValueRenderer)layout.Renderers[0];
+            var logEvent = LogEventInfo.Create(LogLevel.Info, "logger", message);
+
+            // Act
+            var result = stringValueRenderer.GetFormattedString(logEvent);
+
+            // Assert
+            Assert.Equal(expected, result);
+
+
+        }
     }
 }
\ No newline at end of file
diff --git a/tests/NLog.UnitTests/LayoutRenderers/Wrappers/WhenTests.cs b/tests/NLog.UnitTests/LayoutRenderers/Wrappers/WhenTests.cs
index c74e937285..bb4630f926 100644
--- a/tests/NLog.UnitTests/LayoutRenderers/Wrappers/WhenTests.cs
+++ b/tests/NLog.UnitTests/LayoutRenderers/Wrappers/WhenTests.cs
@@ -31,6 +31,7 @@
 // THE POSSIBILITY OF SUCH DAMAGE.
 // 
 
+using System;
 using NLog.Config;
 
 namespace NLog.UnitTests.LayoutRenderers.Wrappers
@@ -203,5 +204,49 @@ private static void WhenNumericAndPropertyConditionTest_inner(SimpleLayout l, ob
             le.Properties["Elapsed"] = time;
             Assert.Equal(fast ? "Fast" : "Slow", l.Render(le));
         }
+
+        [Theory]
+        [InlineData("logger", "DBNullValue", true)]
+        [InlineData("logger1", null, false)]
+        public void WhenDbNullRawValueShouldWork(string loggername, object expectedValue, bool expectedSuccess)
+        {
+            expectedValue = OptionalConvert(expectedValue);
+
+            //else cannot be invoked ambiently. First param is inner
+            SimpleLayout l = @"${when:${db-null}:when=logger=='logger':else=better}";
+
+            var le = LogEventInfo.Create(LogLevel.Info, loggername, "message");
+            var success = l.TryGetRawValue(le, out var result);
+
+            Assert.Equal(expectedValue, result);
+            Assert.Equal(expectedSuccess, success);
+        }       
+        [Theory]
+        [InlineData("logger1", "DBNullValue", true)]
+        [InlineData("logger", null, false)]
+        public void WhenDbNullRawValueShouldWorkElse(string loggername, object expectedValue, bool expectedSuccess)
+        {
+
+            expectedValue = OptionalConvert(expectedValue);
+
+            //else cannot be invoked ambiently. First param is inner
+            SimpleLayout l = @"${when:something:when=logger=='logger':else=${db-null}}";
+
+            var le = LogEventInfo.Create(LogLevel.Info, loggername, "message");
+            var success = l.TryGetRawValue(le, out var result);
+
+            Assert.Equal(expectedValue, result);
+            Assert.Equal(expectedSuccess, success);
+        }
+
+        private static object OptionalConvert(object expectedValue)
+        {
+            if (expectedValue is string s && s == "DBNullValue")
+            {
+                expectedValue = DBNull.Value;
+            }
+
+            return expectedValue;
+        }
     }
 }
\ No newline at end of file
diff --git a/tests/NLog.UnitTests/Layouts/AllEventPropertiesTests.cs b/tests/NLog.UnitTests/Layouts/AllEventPropertiesTests.cs
index 61fd97f261..04d52a27e9 100644
--- a/tests/NLog.UnitTests/Layouts/AllEventPropertiesTests.cs
+++ b/tests/NLog.UnitTests/Layouts/AllEventPropertiesTests.cs
@@ -48,7 +48,7 @@ public void AllParametersAreSetToDefault()
         {
             var renderer = new AllEventPropertiesLayoutRenderer();
             var ev = BuildLogEventWithProperties();
-            
+
             var result = renderer.Render(ev);
 
             Assert.Equal("a=1, hello=world, 17=100", result);
@@ -141,8 +141,8 @@ public void AllEventWithFluent_without_callerInformation()
                 .Write();
 
 
-            AssertDebugLastMessage("m","Test=InfoWrite, coolness=200%, a=not b");
-            
+            AssertDebugLastMessage("m", "Test=InfoWrite, coolness=200%, a=not b");
+
         }
 
 #if NET3_5 || NET4_0
@@ -169,7 +169,7 @@ public void AllEventWithFluent_with_callerInformation()
                 </nlog>");
 
             LogManager.Configuration = configuration;
-      
+
             var logger = LogManager.GetCurrentClassLogger();
             logger.Debug()
                 .Message("This is a test fluent message '{0}'.", DateTime.Now.Ticks)
@@ -183,6 +183,31 @@ public void AllEventWithFluent_with_callerInformation()
             AssertDebugLastMessageContains("m", "CallerLineNumber=");
         }
 
+        [Theory]
+        [InlineData(null, "a=1, hello=world, 17=100, notempty=0")]
+        [InlineData(false, "a=1, hello=world, 17=100, notempty=0")]
+        [InlineData(true, "a=1, hello=world, 17=100, empty1=, empty2=, notempty=0")]
+        public void IncludeEmptyValuesTest(bool? includeEmptyValues, string expected)
+        {
+            // Arrange
+            var renderer = new AllEventPropertiesLayoutRenderer();
+            if (includeEmptyValues != null)
+            {
+                renderer.IncludeEmptyValues = includeEmptyValues.Value;
+            }
+
+            var ev = BuildLogEventWithProperties();
+            ev.Properties["empty1"] = null;
+            ev.Properties["empty2"] = "";
+            ev.Properties["notempty"] = 0;
+
+            // Act
+            var result = renderer.Render(ev);
+
+            // Assert
+            Assert.Equal(expected, result);
+        }
+
         private static LogEventInfo BuildLogEventWithProperties()
         {
             var ev = new LogEventInfo();
diff --git a/tests/NLog.UnitTests/LogFactoryTests.cs b/tests/NLog.UnitTests/LogFactoryTests.cs
index a844b6af6f..f5a2b20bc3 100644
--- a/tests/NLog.UnitTests/LogFactoryTests.cs
+++ b/tests/NLog.UnitTests/LogFactoryTests.cs
@@ -384,5 +384,12 @@ public void SuspendAndResumeLogging_OutOfOrder()
             factory.ResumeLogging();
             Assert.True(factory.IsLoggingEnabled());
         }
+
+        [Fact]
+        public void LogFactory_GetLoggerWithNull_ShouldThrow()
+        {
+            LogFactory factory = new LogFactory();
+            Assert.Throws<ArgumentNullException>(() => factory.GetLogger(null));
+        }
     }
 }
diff --git a/tests/NLog.UnitTests/LogManagerTests.cs b/tests/NLog.UnitTests/LogManagerTests.cs
index 5993323da0..c859cd43cb 100644
--- a/tests/NLog.UnitTests/LogManagerTests.cs
+++ b/tests/NLog.UnitTests/LogManagerTests.cs
@@ -81,7 +81,7 @@ public void GarbageCollection2Test()
             WeakReference wr = GetWeakReferenceToTemporaryLogger();
 
             // nobody's holding a reference to this Logger anymore, so GC.Collect(2) should free it
-            GC.Collect();
+            GC.Collect(2, GCCollectionMode.Forced, true);
             Assert.False(wr.IsAlive);
         }
 
diff --git a/tests/NLog.UnitTests/LoggerTests.cs b/tests/NLog.UnitTests/LoggerTests.cs
index c4d63a18d5..e76d879fc2 100644
--- a/tests/NLog.UnitTests/LoggerTests.cs
+++ b/tests/NLog.UnitTests/LoggerTests.cs
@@ -2390,5 +2390,86 @@ public void LogEventTemplateShouldHaveProperties_even_when_changed()
             Assert.Equal("b", props["A"]);
             Assert.Equal(1, props.Count);
         }
+
+        static Logger GetContextLoggerFromTemporary(string loggerName)
+        {
+            var globalLogger = LogManager.GetLogger(loggerName);
+            var loggerStage1 = globalLogger.WithProperty("Stage", 1);
+            globalLogger.Trace("{Stage}", "Connected");
+            return loggerStage1;
+        }
+
+        [Fact]
+        public void LogEventTemplateShouldOverrideProperties()
+        {
+            string uniqueLoggerName = Guid.NewGuid().ToString();
+
+            var config = new LoggingConfiguration();
+            var target = new MyTarget();
+            config.LoggingRules.Add(new LoggingRule(uniqueLoggerName, LogLevel.Trace, target));
+            LogManager.Configuration = config;
+            Logger loggerStage1 = GetContextLoggerFromTemporary(uniqueLoggerName);
+            GC.Collect();   // Try and free globalLogger
+            var loggerStage2 = loggerStage1.WithProperty("Stage", 2);
+            Assert.Single(target.LastEvent.Properties);
+            AssertContainsInDictionary(target.LastEvent.Properties, "Stage", "Connected");
+            loggerStage1.Trace("Login attempt from {userid}", "kermit");
+            Assert.Equal(2, target.LastEvent.Properties.Count);
+            AssertContainsInDictionary(target.LastEvent.Properties, "Stage", 1);
+            AssertContainsInDictionary(target.LastEvent.Properties, "userid", "kermit");
+            loggerStage2.Trace("Login succesful for {userid}", "kermit");
+            Assert.Equal(2, target.LastEvent.Properties.Count);
+            AssertContainsInDictionary(target.LastEvent.Properties, "Stage", 2);
+            AssertContainsInDictionary(target.LastEvent.Properties, "userid", "kermit");
+            loggerStage2.Trace("{Stage}", "Disconnected");
+            Assert.Single(target.LastEvent.Properties);
+            AssertContainsInDictionary(target.LastEvent.Properties, "Stage", "Disconnected");
+        }
+
+        [Fact]
+        public void LoggerWithPropertyShouldInheritLogLevel()
+        {
+            string uniqueLoggerName = Guid.NewGuid().ToString();
+
+            var config = new LoggingConfiguration();
+            var target = new MyTarget();
+            config.LoggingRules.Add(new LoggingRule(uniqueLoggerName, LogLevel.Trace, target));
+            LogManager.Configuration = config;
+            Logger loggerStage1 = GetContextLoggerFromTemporary(uniqueLoggerName);
+            GC.Collect();   // Try and free globalLogger
+            Assert.Single(target.LastEvent.Properties);
+            AssertContainsInDictionary(target.LastEvent.Properties, "Stage", "Connected");
+            LogManager.Configuration.LoggingRules[0].DisableLoggingForLevel(LogLevel.Trace);
+            LogManager.ReconfigExistingLoggers();   // Refreshes the configuration of globalLogger
+            var loggerStage2 = loggerStage1.WithProperty("Stage", 2);
+            loggerStage2.Trace("Login attempt from {userid}", "kermit");
+            AssertContainsInDictionary(target.LastEvent.Properties, "Stage", "Connected");  // Verify nothing writtne
+            loggerStage2.Debug("{Stage}", "Disconnected");
+            AssertContainsInDictionary(target.LastEvent.Properties, "Stage", "Disconnected");
+        }
+
+        [Fact]
+        public void LoggerSetPropertyChangesCurrentLogger()
+        {
+            string uniqueLoggerName = Guid.NewGuid().ToString();
+
+            var config = new LoggingConfiguration();
+            var target = new MyTarget();
+            config.LoggingRules.Add(new LoggingRule(uniqueLoggerName, LogLevel.Trace, target));
+            LogManager.Configuration = config;
+            var globalLogger = LogManager.GetLogger(uniqueLoggerName);
+            globalLogger.SetProperty("Stage", 1);
+            globalLogger.Trace("Login attempt from {userid}", "kermit");
+            AssertContainsInDictionary(target.LastEvent.Properties, "Stage", 1);
+            var loggerStage2 = globalLogger.WithProperty("Stage", 2);
+            loggerStage2.Trace("Hello from {userid}", "kermit");
+            AssertContainsInDictionary(target.LastEvent.Properties, "Stage", 2);
+            globalLogger.SetProperty("Stage", 4);
+            loggerStage2.SetProperty("Stage", 3);
+            loggerStage2.Trace("Goodbye from {userid}", "kermit");
+            AssertContainsInDictionary(target.LastEvent.Properties, "Stage", 3);
+            globalLogger.Trace("Logoff by {userid}", "kermit");
+            AssertContainsInDictionary(target.LastEvent.Properties, "Stage", 4);
+        }
     }
 }
diff --git a/tests/NLog.UnitTests/NLog.UnitTests.csproj b/tests/NLog.UnitTests/NLog.UnitTests.csproj
index ed53c99d29..cc149b735e 100644
--- a/tests/NLog.UnitTests/NLog.UnitTests.csproj
+++ b/tests/NLog.UnitTests/NLog.UnitTests.csproj
@@ -54,7 +54,7 @@
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp2.0' ">
     <PackageReference Include="System.Data.SqlClient" Version="4.6.0" />
-    <PackageReference Include="Microsoft.Data.Sqlite" Version="2.2.3" />
+    <PackageReference Include="Microsoft.Data.Sqlite" Version="2.2.4" />
     <PackageReference Include="System.ServiceModel.NetTcp" Version="4.4.0" />
     <PackageReference Include="System.ServiceModel.Primitives" Version="4.4.0" />
     <PackageReference Include="System.ServiceModel.Security" Version="4.4.0" />
diff --git a/tests/NLog.UnitTests/Targets/AsyncTaskTargetTest.cs b/tests/NLog.UnitTests/Targets/AsyncTaskTargetTest.cs
index c42635cb92..77f91eb5b8 100644
--- a/tests/NLog.UnitTests/Targets/AsyncTaskTargetTest.cs
+++ b/tests/NLog.UnitTests/Targets/AsyncTaskTargetTest.cs
@@ -35,19 +35,20 @@ namespace NLog.UnitTests.Targets
 {
 #if !NET3_5
     using System;
+    using System.Collections.Concurrent;
     using System.Collections.Generic;
     using System.Threading;
     using System.Threading.Tasks;
-    using Xunit;
     using NLog.Config;
     using NLog.Targets;
+    using Xunit;
 
     public class AsyncTaskTargetTest : NLogTestBase
     {
         class AsyncTaskTestTarget : AsyncTaskTarget
         {
             private readonly AutoResetEvent _writeEvent = new AutoResetEvent(false);
-            internal readonly Queue<string> Logs = new Queue<string>();
+            internal readonly ConcurrentQueue<string> Logs = new ConcurrentQueue<string>();
             internal int WriteTasks => _writeTasks;
             protected int _writeTasks;
 
@@ -105,25 +106,35 @@ public void AsyncTaskTarget_TestLogging()
         {
             ILogger logger = LogManager.GetCurrentClassLogger();
 
-            var asyncTarget = new AsyncTaskTestTarget { Layout = "${threadid}|${level}|${message}" };
+            var asyncTarget = new AsyncTaskTestTarget { Layout = "${threadid}|${level}|${message}|${mdlc:item=Test}" };
 
             SimpleConfigurator.ConfigureForTargetLogging(asyncTarget, LogLevel.Trace);
             NLog.Common.InternalLogger.LogLevel = LogLevel.Off;
 
-            logger.Trace("TTT");
-            logger.Debug("DDD");
-            logger.Info("III");
-            logger.Warn("WWW");
-            logger.Error("EEE");
-            logger.Fatal("FFF");
+            int managedThreadId = 0;
+            Task task;
+            using (MappedDiagnosticsLogicalContext.SetScoped("Test", 42))
+            {
+                task = Task.Run(() =>
+                {
+                    managedThreadId = Thread.CurrentThread.ManagedThreadId;
+                    logger.Trace("TTT");
+                    logger.Debug("DDD");
+                    logger.Info("III");
+                    logger.Warn("WWW");
+                    logger.Error("EEE");
+                    logger.Fatal("FFF");
+                });
+            }
             Assert.True(asyncTarget.WaitForWriteEvent());
             Assert.NotEmpty(asyncTarget.Logs);
+            task.Wait();
             LogManager.Flush();
-            Assert.True(asyncTarget.Logs.Count == 6);
-            while (asyncTarget.Logs.Count > 0)
+            Assert.Equal(6, asyncTarget.Logs.Count);
+            while (asyncTarget.Logs.TryDequeue(out var logEventMessage))
             {
-                string logEventMessage = asyncTarget.Logs.Dequeue();
-                Assert.Equal(0, logEventMessage.IndexOf(Thread.CurrentThread.ManagedThreadId.ToString() + "|"));
+                Assert.Equal(0, logEventMessage.IndexOf(managedThreadId.ToString() + "|"));
+                Assert.EndsWith("|42", logEventMessage);
             }
 
             LogManager.Configuration = null;
@@ -150,9 +161,8 @@ public void AsyncTaskTarget_TestAsyncException()
             Assert.Equal(LogLevel.MaxLevel.Ordinal, asyncTarget.Logs.Count);
 
             int ordinal = 0;
-            while (asyncTarget.Logs.Count > 0)
+            while (asyncTarget.Logs.TryDequeue(out var logEventMessage))
             {
-                string logEventMessage = asyncTarget.Logs.Dequeue();
                 var logLevel = LogLevel.FromString(logEventMessage);
                 Assert.NotEqual(LogLevel.Debug, logLevel);
                 Assert.Equal(ordinal++, logLevel.Ordinal);
@@ -187,10 +197,9 @@ public void AsyncTaskTarget_TestTimeout()
                 Assert.True(asyncTarget.WaitForWriteEvent());
                 Assert.NotEmpty(asyncTarget.Logs);
                 LogManager.Flush();
-                Assert.True(asyncTarget.Logs.Count == 5);
-                while (asyncTarget.Logs.Count > 0)
+                Assert.Equal(5, asyncTarget.Logs.Count);
+                while (asyncTarget.Logs.TryDequeue(out var logEventMessage))
                 {
-                    string logEventMessage = asyncTarget.Logs.Dequeue();
                     Assert.Equal(-1, logEventMessage.IndexOf("Debug|"));
                 }
 
@@ -221,9 +230,8 @@ public void AsyncTaskTarget_TestRetryAsyncException()
             Assert.Equal(LogLevel.MaxLevel.Ordinal + 4, asyncTarget.WriteTasks);
 
             int ordinal = 0;
-            while (asyncTarget.Logs.Count > 0)
+            while (asyncTarget.Logs.TryDequeue(out var logEventMessage))
             {
-                string logEventMessage = asyncTarget.Logs.Dequeue();
                 var logLevel = LogLevel.FromString(logEventMessage);
                 Assert.NotEqual(LogLevel.Debug, logLevel);
                 Assert.Equal(ordinal++, logLevel.Ordinal);
@@ -257,9 +265,8 @@ public void AsyncTaskTarget_TestRetryException()
             Assert.Equal(LogLevel.MaxLevel.Ordinal + 4, asyncTarget.WriteTasks);
 
             int ordinal = 0;
-            while (asyncTarget.Logs.Count > 0)
+            while (asyncTarget.Logs.TryDequeue(out var logEventMessage))
             {
-                string logEventMessage = asyncTarget.Logs.Dequeue();
                 var logLevel = LogLevel.FromString(logEventMessage);
                 Assert.NotEqual(LogLevel.Debug, logLevel);
                 Assert.Equal(ordinal++, logLevel.Ordinal);
@@ -293,9 +300,8 @@ public void AsyncTaskTarget_TestBatchWriting()
             Assert.Equal(LogLevel.MaxLevel.Ordinal / 2, asyncTarget.WriteTasks);
 
             int ordinal = 0;
-            while (asyncTarget.Logs.Count > 0)
+            while (asyncTarget.Logs.TryDequeue(out var logEventMessage))
             {
-                string logEventMessage = asyncTarget.Logs.Dequeue();
                 var logLevel = LogLevel.FromString(logEventMessage);
                 Assert.Equal(ordinal++, logLevel.Ordinal);
             }
@@ -327,9 +333,8 @@ public void AsyncTaskTarget_TestFakeBatchWriting()
             Assert.Equal(LogLevel.MaxLevel.Ordinal + 1, asyncTarget.WriteTasks);
 
             int ordinal = 0;
-            while (asyncTarget.Logs.Count > 0)
+            while (asyncTarget.Logs.TryDequeue(out var logEventMessage))
             {
-                string logEventMessage = asyncTarget.Logs.Dequeue();
                 var logLevel = LogLevel.FromString(logEventMessage);
                 Assert.Equal(ordinal++, logLevel.Ordinal);
             }
@@ -379,14 +384,16 @@ public void AsyncTaskTarget_TestThrottleOnTaskDelay()
 
             SimpleConfigurator.ConfigureForTargetLogging(asyncTarget, LogLevel.Trace);
 
-            for (int i = 0; i < 50; ++i)
+            for (int i = 0; i < 5; ++i)
             {
-                logger.Log(LogLevel.Info, i.ToString());
-                Thread.Sleep(20);
+                for (int j = 0; j < 10; ++j)
+                {
+                    logger.Log(LogLevel.Info, i.ToString());
+                    Thread.Sleep(20);
+                }
+                Assert.True(asyncTarget.WaitForWriteEvent());
             }
 
-            Assert.True(asyncTarget.WaitForWriteEvent(0));
-
             Assert.True(asyncTarget.Logs.Count > 25, $"{asyncTarget.Logs.Count} LogEvents are too few after {asyncTarget.WriteTasks} writes");
             Assert.True(asyncTarget.WriteTasks < 20, $"{asyncTarget.WriteTasks} writes are too many.");
         }
diff --git a/tests/NLog.UnitTests/Targets/DatabaseTargetTests.cs b/tests/NLog.UnitTests/Targets/DatabaseTargetTests.cs
index 8e6059ccf7..7f080b1b2d 100644
--- a/tests/NLog.UnitTests/Targets/DatabaseTargetTests.cs
+++ b/tests/NLog.UnitTests/Targets/DatabaseTargetTests.cs
@@ -654,6 +654,7 @@ public static IEnumerable<object[]> ConvertFromStringTestCases()
             yield return new object[] { "${db-null}", DbType.DateTime, DBNull.Value };
             yield return new object[] { "${event-properties:userid}", DbType.Int32, 0 };
             yield return new object[] { "${date:universalTime=true:format=yyyy-MM:norawvalue=true}", DbType.DateTime, DateTime.SpecifyKind(DateTime.UtcNow.Date.AddDays(-DateTime.UtcNow.Day + 1), DateTimeKind.Unspecified)};
+            yield return new object[] { "${shortdate:universalTime=true}", DbType.DateTime, DateTime.UtcNow.Date };
         }
 
         [Fact]
diff --git a/tests/NLog.UnitTests/Targets/DefaultJsonSerializerTestsBase.cs b/tests/NLog.UnitTests/Targets/DefaultJsonSerializerTestsBase.cs
index 22a951f21f..d6440878fc 100644
--- a/tests/NLog.UnitTests/Targets/DefaultJsonSerializerTestsBase.cs
+++ b/tests/NLog.UnitTests/Targets/DefaultJsonSerializerTestsBase.cs
@@ -272,6 +272,16 @@ public void SerializeTrickyDict_Test()
             Assert.Equal("{\"key1\":13,\"key 2\":1.3}", actual);
         }
 
+        [Fact]
+        public void SerializeExpandoDict_Test()
+        {
+            IDictionary<string, IConvertible> dictionary = new Internal.ExpandoTestDictionary();
+            dictionary.Add("key 2", 1.3m);
+            dictionary.Add("level", LogLevel.Info);
+            var actual = SerializeObject(dictionary);
+            Assert.Equal("{\"key 2\":1.3, \"level\":{\"Name\":\"Info\", \"Ordinal\":2}}", actual);
+        }
+
         [Fact]
         public void SerializeIntegerKeyDict_Test()
         {
@@ -338,7 +348,7 @@ public void SerializeEnum_Test()
         [Fact]
         public void SerializeFlagEnum_Test()
         {
-            var val = UrlHelper.EscapeEncodingFlag.LegacyRfc2396 | UrlHelper.EscapeEncodingFlag.LowerCaseHex;
+            var val = UrlHelper.EscapeEncodingOptions.LegacyRfc2396 | UrlHelper.EscapeEncodingOptions.LowerCaseHex;
             var actual = SerializeObject(val);
             Assert.Equal("\"LegacyRfc2396, LowerCaseHex\"", actual);
         }
diff --git a/tests/NLog.UnitTests/Targets/FileTargetTests.cs b/tests/NLog.UnitTests/Targets/FileTargetTests.cs
index 99ca251a1a..594432b8e9 100644
--- a/tests/NLog.UnitTests/Targets/FileTargetTests.cs
+++ b/tests/NLog.UnitTests/Targets/FileTargetTests.cs
@@ -120,17 +120,20 @@ public void SimpleFileTest(bool concurrentWrites, bool keepFileOpen, bool networ
             }
         }
 
-#if !MONO
         [Theory]
-#else
-        [Theory(Skip="Not supported on MONO on Travis, because of FileSystemWatcher not working")]
-#endif
         [MemberData(nameof(SimpleFileTest_TestParameters))]
         public void SimpleFileDeleteTest(bool concurrentWrites, bool keepFileOpen, bool networkWrites, bool forceManaged, bool forceMutexConcurrentWrites, bool optimizeBufferReuse)
         {
+            bool isSimpleKeepFileOpen = keepFileOpen && !networkWrites && !concurrentWrites && IsTravis();
+            if (IsTravis() && concurrentWrites && keepFileOpen && !networkWrites)
+            {
+                Console.WriteLine("[SKIP] Not supported on MONO on Travis, because of FileSystemWatcher not working");
+                return;
+            }
+
             var logFile = Path.GetTempFileName();
             var logFile2 = Path.Combine(Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString()), Path.GetFileName(logFile));
-
+           
             try
             {
                 var fileTarget = WrapFileTarget(new FileTarget
@@ -156,12 +159,12 @@ public void SimpleFileDeleteTest(bool concurrentWrites, bool keepFileOpen, bool
 
                 Directory.CreateDirectory(Path.GetDirectoryName(logFile2));
                 File.Move(logFile, logFile2);
-                if (keepFileOpen)
-#if MONO
-                    Thread.Sleep(500); // Allow AutoClose-Timer-Thread to react (FileWatcher depends on operating system, fallback to polling every 3 secs)
-#else
+
+                if (isSimpleKeepFileOpen)
+                    Thread.Sleep(1500); // Ensure EnableFileDeleteSimpleMonitor will trigger
+                else if (keepFileOpen && !networkWrites)
                     Thread.Sleep(150);  // Allow AutoClose-Timer-Thread to react (FileWatcher schedules timer after 50 msec)
-#endif
+
                 logger.Info("bbb");
 
                 LogManager.Configuration = null;
diff --git a/tests/NLog.UnitTests/Targets/TargetTests.cs b/tests/NLog.UnitTests/Targets/TargetTests.cs
index b9da4143ff..9f6e0f6b16 100644
--- a/tests/NLog.UnitTests/Targets/TargetTests.cs
+++ b/tests/NLog.UnitTests/Targets/TargetTests.cs
@@ -84,8 +84,6 @@ public void TargetContructorWithNameTest()
                       
                         var args = new List<object> { fileTarget };
 
-                
-
                         //default ctor
                         var defaultConstructedTarget = (WrapperTargetBase)Activator.CreateInstance(targetType);
                         defaultConstructedTarget.Name = name;
@@ -94,7 +92,7 @@ public void TargetContructorWithNameTest()
                         //specials cases
                         if (targetType == typeof(FilteringTargetWrapper))
                         {
-                            var cond = new ConditionLoggerNameExpression();
+                            ConditionLoggerNameExpression cond = null;
                             args.Add(cond);
                             var target = (FilteringTargetWrapper) defaultConstructedTarget;
                             target.Condition = cond;
diff --git a/tests/NLog.UnitTests/Targets/TargetWithContextTest.cs b/tests/NLog.UnitTests/Targets/TargetWithContextTest.cs
index 976fb61aa2..483e044381 100644
--- a/tests/NLog.UnitTests/Targets/TargetWithContextTest.cs
+++ b/tests/NLog.UnitTests/Targets/TargetWithContextTest.cs
@@ -46,13 +46,15 @@ public class TargetWithContextTest : NLogTestBase
     {
         public class CustomTargetWithContext : TargetWithContext
         {
+            public bool SkipAssert { get; set; }
+
             public class CustomTargetPropertyWithContext : TargetPropertyWithContext
             {
                 public string Hello { get; set; }
             }
 
             [NLog.Config.ArrayParameter(typeof(CustomTargetPropertyWithContext), "contextproperty")]
-            public override IList<TargetPropertyWithContext> ContextProperties { get;  }
+            public override IList<TargetPropertyWithContext> ContextProperties { get; }
 
             public CustomTargetWithContext()
             {
@@ -64,9 +66,13 @@ public CustomTargetWithContext()
 
             protected override void Write(LogEventInfo logEvent)
             {
-                var test = MappedDiagnosticsLogicalContext.GetNames();
-                Assert.Empty(test);
-                Assert.True(logEvent.HasStackTrace);
+                if (!SkipAssert)
+                {
+                    var test = MappedDiagnosticsLogicalContext.GetNames();
+                    Assert.Empty(test);
+                    Assert.True(logEvent.HasStackTrace);
+                }
+
                 LastCombinedProperties = base.GetAllProperties(logEvent);
                 LastMessage = base.RenderLogEvent(Layout, logEvent);
             }
@@ -102,14 +108,7 @@ public void TargetWithContextAsyncTest()
             MappedDiagnosticsLogicalContext.Set("TestKey", "Hello Async World");
             MappedDiagnosticsLogicalContext.Set("AsyncKey", "Hello Async World");
             logger.Debug("log message");
-            System.Threading.Thread.Sleep(1);
-            for (int i = 0; i < 1000; ++i)
-            {
-                if (target.LastMessage != null)
-                    break;
-
-                System.Threading.Thread.Sleep(1);
-            }
+            WaitForLastMessage(target);
 
             Assert.NotEqual(0, target.LastMessage.Length);
             Assert.NotNull(target.LastCombinedProperties);
@@ -124,6 +123,57 @@ public void TargetWithContextAsyncTest()
             Assert.Contains(new KeyValuePair<string, object>("threadid", System.Environment.CurrentManagedThreadId.ToString()), target.LastCombinedProperties);
         }
 
+        private static void WaitForLastMessage(CustomTargetWithContext target)
+        {
+            System.Threading.Thread.Sleep(1);
+            for (int i = 0; i < 1000; ++i)
+            {
+                if (target.LastMessage != null)
+                    break;
+
+                System.Threading.Thread.Sleep(1);
+            }
+        }
+
+        [Fact]
+        public void TargetWithContextMdcSerializeTest()
+        {
+            MappedDiagnosticsContext.Clear();
+            MappedDiagnosticsContext.Set("TestKey", new { a = "b" });
+
+            CustomTargetWithContext target = new CustomTargetWithContext() { IncludeMdc = true, SkipAssert = true };
+
+            WriteAndAssertSingleKey(target);
+        }
+
+        [Fact]
+        public void TargetWithContextMdlcSerializeTest()
+        {
+            MappedDiagnosticsLogicalContext.Clear();
+            MappedDiagnosticsLogicalContext.Set("TestKey", new { a = "b" });
+
+            CustomTargetWithContext target = new CustomTargetWithContext() { IncludeMdlc = true, SkipAssert = true };
+
+            WriteAndAssertSingleKey(target);
+        }
+
+        private static void WriteAndAssertSingleKey(CustomTargetWithContext target)
+        {
+            AsyncTargetWrapper wrapper = new AsyncTargetWrapper { WrappedTarget = target, TimeToSleepBetweenBatches = 0 };
+
+            NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(wrapper, LogLevel.Debug);
+
+            Logger logger = LogManager.GetLogger("Example");
+
+
+            logger.Debug("log message");
+
+            WaitForLastMessage(target);
+
+
+            Assert.Equal("{ a = b }", target.LastCombinedProperties["TestKey"]);
+        }
+
         [Fact]
         public void TargetWithContextConfigTest()
         {
diff --git a/tests/NLog.UnitTests/Targets/Wrappers/AsyncTargetWrapperTests.cs b/tests/NLog.UnitTests/Targets/Wrappers/AsyncTargetWrapperTests.cs
index 1b28d89132..88c91eb542 100644
--- a/tests/NLog.UnitTests/Targets/Wrappers/AsyncTargetWrapperTests.cs
+++ b/tests/NLog.UnitTests/Targets/Wrappers/AsyncTargetWrapperTests.cs
@@ -98,6 +98,7 @@ private void AsyncTargetWrapperSyncTest_WhenTimeToSleepBetweenBatchesIsEqualToZe
 #endif
                 BatchSize = 3,
                 QueueLimit = 5, // Will make it "sleep" between every second write
+                FullBatchSizeWriteLimit = 1,
                 OverflowAction = AsyncTargetWrapperOverflowAction.Block
             };
             targetWrapper.Initialize(null);
@@ -108,35 +109,69 @@ private void AsyncTargetWrapperSyncTest_WhenTimeToSleepBetweenBatchesIsEqualToZe
                 int flushCounter = 0;
                 AsyncContinuation flushHandler = (ex) => { ++flushCounter; };
 
-                List<KeyValuePair<LogEventInfo, AsyncContinuation>> itemPrepareList = new List<KeyValuePair<LogEventInfo, AsyncContinuation>>(500);
-                List<int> itemWrittenList = new List<int>(itemPrepareList.Capacity);
-                for (int i = 0; i< itemPrepareList.Capacity; ++i)
+                var itemPrepareList = new List<AsyncLogEventInfo>(500);
+                var itemWrittenList = new List<int>(itemPrepareList.Capacity);
+                for (int i = 0; i < itemPrepareList.Capacity; ++i)
                 {
                     var logEvent = new LogEventInfo();
                     int sequenceID = logEvent.SequenceID;
-                    itemPrepareList.Add(new KeyValuePair<LogEventInfo, AsyncContinuation>(logEvent, (ex) => itemWrittenList.Add(sequenceID)));
+                    bool blockConsumer = (itemPrepareList.Capacity / 2) == i;  // Force producers to get into blocking-mode
+                    itemPrepareList.Add(logEvent.WithContinuation((ex) => { if (blockConsumer) Thread.Sleep(125); itemWrittenList.Add(sequenceID); }));
                 }
 
-                long startTicks = Environment.TickCount;
-                for (int i = 0; i < itemPrepareList.Count; ++i)
+                var eventProducer0 = new ManualResetEvent(false);
+                var eventProducer1 = new ManualResetEvent(false);
+                ParameterizedThreadStart producerMethod = (s) =>
                 {
-                    var logEvent = itemPrepareList[i].Key;
-                    targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(itemPrepareList[i].Value));
-                }
+                    var eventProducer = (ManualResetEvent)s;
+                    if (eventProducer != null)
+                        eventProducer.Set();    // Signal we are ready
+
+                    int partitionNo = ReferenceEquals(eventProducer, eventProducer1) ? 1 : 0;
+                    for (int i = 0; i < itemPrepareList.Count; ++i)
+                    {
+                        if (i % 2 == partitionNo)
+                            targetWrapper.WriteAsyncLogEvent(itemPrepareList[i]);
+                    }
+                };
+
+                Thread producer0 = new Thread(producerMethod);
+                producer0.IsBackground = true;
+                Thread producer1 = new Thread(producerMethod);
+                producer1.IsBackground = true;
+                producer1.Start(eventProducer0);
+                producer0.Start(eventProducer1);
+                Assert.True(eventProducer0.WaitOne(5000), "Producer0 Start Timeout");
+                Assert.True(eventProducer1.WaitOne(5000), "Producer1 Start Timeout");
+
+                long startTicks = Environment.TickCount;
+
+                Assert.True(producer0.Join(5000), "Producer0 Complete Timeout");  // Wait for producer0 to complete
+                Assert.True(producer1.Join(5000), "Producer1 Complete Timeout");  // Wait for producer1 to complete
+
+                long elapsedMilliseconds = Environment.TickCount - startTicks;
 
                 targetWrapper.Flush(flushHandler);
 
                 for (int i = 0; i < itemPrepareList.Count * 2 && itemWrittenList.Count != itemPrepareList.Count; ++i)
                     Thread.Sleep(1);
 
-                long elapsedMilliseconds = Environment.TickCount - startTicks;
-
                 Assert.Equal(itemPrepareList.Count, itemWrittenList.Count);
-                int prevSequenceID = 0;
-                for (int i = 0; i < itemWrittenList.Count; ++i)
+
+                int producer0sequenceID = 0;
+                int producer1sequenceID = 0;
+                for (int i = 1; i < itemWrittenList.Count; ++i)
                 {
-                    Assert.True(prevSequenceID < itemWrittenList[i]);
-                    prevSequenceID = itemWrittenList[i];
+                    if (itemWrittenList[i] % 2 == 0)
+                    {
+                        Assert.True(producer0sequenceID < itemWrittenList[i], "Producer0 invalid sequence");
+                        producer0sequenceID = itemWrittenList[i];
+                    }
+                    else
+                    {
+                        Assert.True(producer1sequenceID < itemWrittenList[i], "Producer1 invalid sequence");
+                        producer1sequenceID = itemWrittenList[i];
+                    }
                 }
 
 #if NET4_5
@@ -475,7 +510,7 @@ public void LogEventDropped_OnRequestqueueOverflow()
             int eventsCounter = 0;
             var myTarget = new MyTarget();
 
-            var targetWrapper = new AsyncTargetWrapperForEventTests()
+            var targetWrapper = new AsyncTargetWrapper()
             {
                 WrappedTarget = myTarget,
                 QueueLimit = queueLimit,
@@ -514,7 +549,7 @@ public void LogEventNotDropped_IfOverflowActionBlock()
             int eventsCounter = 0;
             var myTarget = new MyTarget();
 
-            var targetWrapper = new AsyncTargetWrapperForEventTests()
+            var targetWrapper = new AsyncTargetWrapper()
             {
                 WrappedTarget = myTarget,
                 QueueLimit = queueLimit,
@@ -552,7 +587,7 @@ public void LogEventNotDropped_IfOverflowActionGrow()
             int eventsCounter = 0;
             var myTarget = new MyTarget();
 
-            var targetWrapper = new AsyncTargetWrapperForEventTests()
+            var targetWrapper = new AsyncTargetWrapper()
             {
                 WrappedTarget = myTarget,
                 QueueLimit = queueLimit,
@@ -588,18 +623,12 @@ public void EventQueueGrow_OnQueueGrow()
             int queueLimit = 2;
             int loggedEventCount = 10;
 
-            int expectedGrowingNumber = 0;
-
-        #if NETCOREAPP2_0
-            expectedGrowingNumber = loggedEventCount - queueLimit;
-        #else
-            expectedGrowingNumber = 3;
-        #endif
+            int expectedGrowingNumber = 3;
 
             int eventsCounter = 0;
             var myTarget = new MyTarget();
 
-            var targetWrapper = new AsyncTargetWrapperForEventTests()
+            var targetWrapper = new AsyncTargetWrapper()
             {
                 WrappedTarget = myTarget,
                 QueueLimit = queueLimit,
@@ -630,14 +659,6 @@ public void EventQueueGrow_OnQueueGrow()
             }
         }
 
-        private class AsyncTargetWrapperForEventTests : AsyncTargetWrapper
-        {
-            public void WriteEvent(AsyncLogEventInfo logEventInfo)
-            {
-                Write(logEventInfo);
-            }
-        }
-
         private class MyAsyncTarget : Target
         {
             private readonly NLog.Internal.AsyncOperationCounter pendingWriteCounter = new NLog.Internal.AsyncOperationCounter();
diff --git a/tests/NLog.UnitTests/Targets/Wrappers/ConcurrentRequestQueueTests.cs b/tests/NLog.UnitTests/Targets/Wrappers/ConcurrentRequestQueueTests.cs
index b6e8e5b49c..9922513181 100644
--- a/tests/NLog.UnitTests/Targets/Wrappers/ConcurrentRequestQueueTests.cs
+++ b/tests/NLog.UnitTests/Targets/Wrappers/ConcurrentRequestQueueTests.cs
@@ -45,7 +45,8 @@ public void RaiseEventLogEventQueueGrow_OnLogItems()
         {
             const int RequestsLimit = 2;
             const int EventsCount = 5;
-            const int ExpectedCountOfGrovingTimes = EventsCount - RequestsLimit;
+            const int ExpectedCountOfGrovingTimes = 2;
+            const int ExpectedFinalSize = 8;
             int grovingItemsCount = 0;
 
             ConcurrentRequestQueue requestQueue = new ConcurrentRequestQueue(RequestsLimit, AsyncTargetWrapperOverflowAction.Grow);
@@ -58,6 +59,7 @@ public void RaiseEventLogEventQueueGrow_OnLogItems()
             }
 
             Assert.Equal(ExpectedCountOfGrovingTimes, grovingItemsCount);
+            Assert.Equal(ExpectedFinalSize, requestQueue.RequestLimit);
         }
 
         [Fact]
diff --git a/tests/NLog.UnitTests/Targets/Wrappers/FilteringTargetWrapperTests.cs b/tests/NLog.UnitTests/Targets/Wrappers/FilteringTargetWrapperTests.cs
index b69ea31ea5..ec36acf28f 100644
--- a/tests/NLog.UnitTests/Targets/Wrappers/FilteringTargetWrapperTests.cs
+++ b/tests/NLog.UnitTests/Targets/Wrappers/FilteringTargetWrapperTests.cs
@@ -37,6 +37,7 @@ namespace NLog.UnitTests.Targets.Wrappers
     using System.Threading;
     using NLog.Common;
     using NLog.Conditions;
+    using NLog.Config;
     using NLog.Targets;
     using NLog.Targets.Wrappers;
     using Xunit;
@@ -267,6 +268,39 @@ public void FilteringTargetWrapperAsyncWithExceptionTest2()
             Assert.Equal(2, myMockCondition.CallCount);
         }
 
+        [Fact]
+        public void FilteringTargetWrapperWhenRepeatedFilter()
+        {
+            LogManager.Configuration = XmlLoggingConfiguration.CreateFromXmlString(@"
+            <nlog>
+                <targets>
+                  <target name='debug' type='BufferingWrapper'>
+                      <target name='filter' type='FilteringWrapper'>
+                        <filter type='whenRepeated' layout='${message}' timeoutSeconds='30' action='Ignore' />
+                        <target name='memory' type='Memory' />
+                      </target>
+                  </target>
+                </targets>
+                <rules>
+                    <logger name='*' minlevel='Debug' writeTo='debug'/>
+                </rules>
+            </nlog>");
+
+            var myTarget = LogManager.Configuration.FindTargetByName<MemoryTarget>("memory");
+            var logger = LogManager.GetLogger(nameof(FilteringTargetWrapperWhenRepeatedFilter));
+            logger.Info("Hello World");
+            logger.Info("Hello World");     // Will be ignored
+            logger.Info("Goodbye World");
+            logger.Warn("Goodbye World");
+            LogManager.Flush();
+            Assert.Equal(3, myTarget.Logs.Count);
+            logger.Info("Hello World");     // Will be ignored
+            logger.Error("Goodbye World");
+            logger.Fatal("Goodbye World");
+            LogManager.Flush();
+            Assert.Equal(5, myTarget.Logs.Count);
+        }
+
         class MyAsyncTarget : Target
         {
             public int WriteCount { get; private set; }
diff --git a/tests/NLog.UnitTests/Targets/Wrappers/PostFilteringTargetWrapperTests.cs b/tests/NLog.UnitTests/Targets/Wrappers/PostFilteringTargetWrapperTests.cs
index 922c0ed4d9..218988e8e6 100644
--- a/tests/NLog.UnitTests/Targets/Wrappers/PostFilteringTargetWrapperTests.cs
+++ b/tests/NLog.UnitTests/Targets/Wrappers/PostFilteringTargetWrapperTests.cs
@@ -203,6 +203,26 @@ public void PostFilteringTargetWrapperUsingDefaultNonFilterTest2()
             Assert.Equal(events.Length, exceptions.Count);
         }
 
+        [Fact]
+        public void PostFilteringTargetWrapperOnlyDefaultFilter()
+        {
+            var target = new MyTarget() { OptimizeBufferReuse = true };
+            var wrapper = new PostFilteringTargetWrapper()
+            {
+                WrappedTarget = target,
+                DefaultFilter = "level >= LogLevel.Info",   // by default log info and above
+            };
+
+            wrapper.Initialize(null);
+            target.Initialize(null);
+
+            var exceptions = new List<Exception>();
+            wrapper.WriteAsyncLogEvent(new LogEventInfo(LogLevel.Info, "Logger1", "Hello").WithContinuation(exceptions.Add));
+            Assert.Single(target.Events);
+            wrapper.WriteAsyncLogEvent(new LogEventInfo(LogLevel.Debug, "Logger1", "Hello").WithContinuation(exceptions.Add));
+            Assert.Single(target.Events);
+        }
+
         [Fact]
         public void PostFilteringTargetWrapperNoFiltersDefined()
         {
diff --git a/tools/MakeNLogXSD/TemplateXSD.xml b/tools/MakeNLogXSD/TemplateXSD.xml
index 07968c85d8..713dc6dfa0 100644
--- a/tools/MakeNLogXSD/TemplateXSD.xml
+++ b/tools/MakeNLogXSD/TemplateXSD.xml
@@ -43,12 +43,12 @@
     </xs:attribute>
     <xs:attribute name="globalThreshold" type="NLogLevel">
       <xs:annotation>
-        <xs:documentation>Global log level threshold for application log messages. Messages below this level won't be logged..</xs:documentation>
+        <xs:documentation>Global log level threshold for application log messages. Messages below this level won't be logged.</xs:documentation>
       </xs:annotation>
     </xs:attribute>
     <xs:attribute name="throwExceptions" type="xs:boolean">
       <xs:annotation>
-        <xs:documentation>Throw an exception when there is an internal error. Default value is: false.</xs:documentation>
+        <xs:documentation>Throw an exception when there is an internal error. Default value is: false. Not recommend to set to true in production!</xs:documentation>
       </xs:annotation>
     </xs:attribute>   
     <xs:attribute name="throwConfigExceptions" type="xs:boolean">
@@ -134,7 +134,7 @@
     </xs:choice>
     <xs:attribute name="name" use="optional">
       <xs:annotation>
-        <xs:documentation>Name of the logger. May include '*' character which acts like a wildcard. Allowed forms are: *, Name, *Name, Name* and *Name*</xs:documentation>
+        <xs:documentation>Name of the logger. May include  wildcard characters ('*' or '?').</xs:documentation>
       </xs:annotation>
     </xs:attribute>
 
@@ -174,9 +174,9 @@
       </xs:annotation>
     </xs:attribute>
 
-    <xs:attribute name="enabled" type="xs:boolean" default="true">
+    <xs:attribute name="ruleName" type="xs:string" use="optional">
       <xs:annotation>
-        <xs:documentation>Enable or disable logging rule. Disabled rules are ignored.</xs:documentation>
+        <xs:documentation>Rule identifier to allow rule lookup with Configuration.FindRuleByName and Configuration.RemoveRuleByName.</xs:documentation>
       </xs:annotation>
     </xs:attribute>
   </xs:complexType>
@@ -185,6 +185,11 @@
     <xs:choice minOccurs="0" maxOccurs="unbounded">
       <filters-go-here xmlns=""/>
     </xs:choice>
+     <xs:attribute name="defaultAction" type="FilterResult">
+      <xs:annotation>
+        <xs:documentation>Default action if none of the filters match.</xs:documentation>
+      </xs:annotation>
+    </xs:attribute>
   </xs:complexType>
 
   <xs:simpleType name="NLogLevel">
diff --git a/tools/MakeNLogXSD/XsdFileGenerator.cs b/tools/MakeNLogXSD/XsdFileGenerator.cs
index 26bc2d6460..f9069e47e5 100644
--- a/tools/MakeNLogXSD/XsdFileGenerator.cs
+++ b/tools/MakeNLogXSD/XsdFileGenerator.cs
@@ -312,6 +312,9 @@ private static string GetXsdType(string apiTypeName, bool attribute)
                 case "Layout":
                     return attribute ? "SimpleLayoutAttribute" : "Layout";
 
+                case "NLog.Filters.Filter":
+                    return "Filter";
+
                 case "Condition":
                     return "Condition";