ILoggingBuilder AddNLog extension method with correct dispose and no double logging

src/NLog.Extensions.Hosting/Extensions/ConfigureExtensions.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Reflection;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using NLog.Config;
@@ -41,7 +42,11 @@ public static IHostBuilder UseNLog(this IHostBuilder builder, NLogProviderOption
                 ConfigurationItemFactory.Default.RegisterItemsFromAssembly(typeof(ConfigureExtensions).GetTypeInfo()
                     .Assembly);
 
-                services.AddSingleton<ILoggerProvider>(serviceProvider =>
+                if (hostbuilder.Configuration != null)
+                    ConfigSettingLayoutRenderer.DefaultConfiguration = hostbuilder.Configuration;
+
+                // Try adding Singleton-implementation if not already exists
+                services.TryAddEnumerable(ServiceDescriptor.Singleton<ILoggerProvider, NLogLoggerProvider>(serviceProvider =>
                 {
                     var provider = new NLogLoggerProvider(options ?? new NLogProviderOptions());
                     if (hostbuilder.Configuration != null)
@@ -51,7 +56,7 @@ public static IHostBuilder UseNLog(this IHostBuilder builder, NLogProviderOption
                             provider.Configure(hostbuilder.Configuration.GetSection("Logging:NLog"));
                     }
                     return provider;
-                });
+                }));
             });
 
             return builder;

src/NLog.Extensions.Logging/Extensions/ConfigureExtensions.cs

@@ -2,6 +2,10 @@
 using System.Linq;
 using System.Reflection;
 using Microsoft.Extensions.Configuration;
+#if !NETCORE1_0
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+#endif
 using Microsoft.Extensions.Logging;
 using NLog.Common;
 using NLog.Config;
@@ -67,8 +71,8 @@ public static ILoggingBuilder AddNLog(this ILoggingBuilder factory)
         /// <returns>ILoggerFactory for chaining</returns>
         public static ILoggingBuilder AddNLog(this ILoggingBuilder factory, IConfiguration configuration)
         {
-            var provider = CreateNLogProvider(configuration);
-            factory.AddProvider(provider);
+            // Try adding Singleton-implementation if not already exists
+            factory.Services.TryAddEnumerable(ServiceDescriptor.Singleton<ILoggerProvider, NLogLoggerProvider>(s => CreateNLogProvider(configuration)));
             return factory;
         }
 
@@ -80,7 +84,8 @@ public static ILoggingBuilder AddNLog(this ILoggingBuilder factory, IConfigurati
         /// <returns>ILoggerFactory for chaining</returns>
         public static ILoggingBuilder AddNLog(this ILoggingBuilder factory, NLogProviderOptions options)
         {
-            factory.AddProvider(new NLogLoggerProvider(options));
+            // Try adding Singleton-implementation if not already exists
+            factory.Services.TryAddEnumerable(ServiceDescriptor.Singleton<ILoggerProvider, NLogLoggerProvider>(s => new NLogLoggerProvider(options)));
             return factory;
         }
 #endif

test/NLog.Extensions.Hosting.Tests/ExtensionMethodTests.cs

@@ -14,15 +14,15 @@ public class ExtensionMethodTests
         public void UseNLog_noParams_WorksWithNLog()
         {
             var actual = new HostBuilder().UseNLog().Build();
-            TestHostingResult(actual);
+            TestHostingResult(actual, true);
         }
 
         [Fact]
         public void UseNLog_withOptionsParam_WorksWithNLog()
         {
             var someParam = new NLogProviderOptions {CaptureMessageProperties = false, CaptureMessageTemplates = false};
             var actual = new HostBuilder().UseNLog(someParam).Build();
-            TestHostingResult(actual);
+            TestHostingResult(actual, true);
         }
 
         [Fact]
@@ -35,26 +35,51 @@ public void UseNLog_withConfiguration_WorksWithNLog()
 
             var someParam = new NLogProviderOptions { CaptureMessageProperties = false, CaptureMessageTemplates = false };
             var actual = new HostBuilder().ConfigureHostConfiguration(config => config.AddInMemoryCollection(memoryConfig)).UseNLog(someParam).Build();
-            TestHostingResult(actual);
+            TestHostingResult(actual, true);
         }
 
-        private static void TestHostingResult(IHost host)
+        [Fact]
+        public void AddNLog_withShutdownOnDispose_worksWithNLog()
+        {
+            var someParam = new NLogProviderOptions { ShutdownOnDispose = true };
+            var actual = new HostBuilder().ConfigureLogging(l => l.AddNLog(someParam)).Build();
+            try
+            {
+                TestHostingResult(actual, false);
+                Assert.NotNull(LogManager.Configuration);
+            }
+            finally
+            {
+                actual.Dispose();
+                Assert.Null(LogManager.Configuration);
+            }
+        }
+
+        [Fact]
+        public void UseNLog_withAddNLog_worksWithNLog()
+        {
+            var actual = new HostBuilder().UseNLog().ConfigureServices((h,s) => s.AddLogging(l => l.AddNLog())).Build();
+            TestHostingResult(actual, true);
+        }
+
+        private static void TestHostingResult(IHost host, bool resetConfiguration)
         {
             try
             {
                 var nlogTarget = new Targets.MemoryTarget() { Name = "Output" };
-                Config.SimpleConfigurator.ConfigureForTargetLogging(nlogTarget);
+                Config.SimpleConfigurator.ConfigureForTargetLogging(nlogTarget, LogLevel.Fatal);
 
                 var loggerFactory = host.Services.GetService<ILoggerFactory>();
                 Assert.NotNull(loggerFactory);
 
                 var logger = loggerFactory.CreateLogger("Hello");
-                logger.LogError("World");
-                Assert.NotEmpty(nlogTarget.Logs);
+                logger.LogCritical("World");
+                Assert.Single(nlogTarget.Logs);
             }
             finally
             {
-                LogManager.Configuration = null;
+                if (resetConfiguration)
+                    LogManager.Configuration = null;
             }
         }
     }