configSetting - Stripped down dependencies to only Microsoft.Extensions.Configuration.Abstractions

Author: snakefoot

examples/NetCore2/ConsoleExample/ConsoleExample.csproj

@@ -9,15 +9,18 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="2.0.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="2.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Logging" Version="2.0.1" />
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\..\..\src\NLog.Extensions.Logging\NLog.Extensions.Logging.csproj" />
+    <ProjectReference Include="..\..\..\src\NLog.Extensions.Configuration\NLog.Extensions.Configuration.csproj" />
   </ItemGroup>
 
   <ItemGroup>
+    <None Update="appsettings.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Update="nlog.config">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>

examples/NetCore2/ConsoleExample/Program.cs

@@ -1,9 +1,9 @@
-using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using NLog;
 using NLog.Extensions.Logging;
 using System;
-using LogLevel = Microsoft.Extensions.Logging.LogLevel;
 
 namespace ConsoleExample
 {
@@ -46,19 +46,21 @@ private static IServiceProvider BuildDi()
 
             services.AddSingleton<ILoggerFactory, LoggerFactory>();
             services.AddSingleton(typeof(ILogger<>), typeof(Logger<>));
-            services.AddLogging(builder => builder.SetMinimumLevel(LogLevel.Trace));
 
-            var serviceProvider = services.BuildServiceProvider();
-
-            var loggerFactory = serviceProvider.GetRequiredService<ILoggerFactory>();
+            var config = new ConfigurationBuilder()
+                .SetBasePath(System.IO.Directory.GetCurrentDirectory())
+                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                .Build();
 
             // configure NLog
-            loggerFactory.AddNLog(new NLogProviderOptions
+            services.AddLogging(loggingBuilder =>
             {
-                CaptureMessageTemplates = true,
-                CaptureMessageProperties = true
+                loggingBuilder.ClearProviders();
+                loggingBuilder.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Trace);
+                loggingBuilder.AddNLog(config);
             });
 
+            var serviceProvider = services.BuildServiceProvider();
             return serviceProvider;
         }
     }

examples/NetCore2/ConsoleExample/appsettings.json

@@ -0,0 +1,9 @@
+{
+    "Logging": {
+        "NLog": {
+            "IncludeScopes": false,
+            "ParseMessageTemplates": false,
+            "CaptureMessageProperties": true
+        }
+    }
+}

src/NLog.Extensions.Configuration/ConfigSettingLayoutRenderer.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Configuration;
+using NLog.Common;
+using NLog.Config;
+
+namespace NLog.Extensions.Logging
+{
+    /// <summary>
+    /// Helpers for .NET Core
+    /// </summary>
+    public static class ConfigureExtensions
+    {
+        /// <summary>
+        /// Enable NLog as logging provider in .NET Core.
+        /// </summary>
+        /// <param name="factory"></param>
+        /// <param name="configuration"></param>
+        /// <returns>ILoggerFactory for chaining</returns>
+        public static ILoggerFactory AddNLog(this ILoggerFactory factory, IConfiguration configuration)
+        {
+            return AddNLog(factory, configuration, null);
+        }
+
+        /// <summary>
+        /// Enable NLog as logging provider in .NET Core.
+        /// </summary>
+        /// <param name="factory"></param>
+        /// <param name="configuration">Configuration</param>
+        /// <param name="options">NLog options</param>
+        /// <returns>ILoggerFactory for chaining</returns>
+        public static ILoggerFactory AddNLog(this ILoggerFactory factory, IConfiguration configuration, NLogProviderOptions options)
+        {
+            ConfigurationItemFactory.Default.RegisterItemsFromAssembly(typeof(Configuration.ConfigSettingLayoutRenderer).GetTypeInfo().Assembly);
+            var provider = new NLogLoggerProvider(options);
+            if (configuration != null)
+            {
+                ConfigureLoggerPovider(configuration, provider);
+            }
+            factory.AddProvider(provider);
+            return factory;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="configuration"></param>
+        /// <param name="provider"></param>
+        public static void ConfigureLoggerPovider(IConfiguration configuration, NLogLoggerProvider provider)
+        {
+            Configuration.ConfigSettingLayoutRenderer.DefaultConfiguration = configuration;
+            var configValues = configuration?.GetSection("Logging:NLog")?.GetChildren()?.ToList();
+            if (configValues == null || configValues.Count == 0)
+                configValues = configuration?.GetSection("NLog")?.GetChildren()?.ToList();
+
+            if (configValues?.Count > 0)
+            {
+                var options = provider.Options;
+                System.Collections.Generic.Dictionary<string, PropertyInfo> configProps = null;
+                foreach (var configValue in configValues)
+                {
+                    configProps = configProps ?? options.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public).Where(p => p.SetMethod?.IsPublic == true).ToDictionary(p => p.Name, StringComparer.OrdinalIgnoreCase);
+
+                    if (configProps.TryGetValue(configValue.Key, out var propertyInfo))
+                    {
+                        try
+                        {
+                            var result = Convert.ChangeType(configValue.Value, propertyInfo.PropertyType);
+                            propertyInfo.SetMethod.Invoke(options, new[] { result });
+                        }
+                        catch (Exception ex)
+                        {
+                            InternalLogger.Warn(ex, "NLogProviderOptions: Property {0} could not be assigned value: {1}", configValue.Key, configValue.Value);
+                        }
+                    }
+                }
+            }
+        }
+
+#if !NETCORE1_0
+        /// <summary>
+        /// Enable NLog as logging provider in .NET Core.
+        /// </summary>
+        /// <param name="factory"></param>
+        /// <param name="configuration">Configuration</param>
+        /// <returns>ILoggerFactory for chaining</returns>
+        public static ILoggingBuilder AddNLog(this ILoggingBuilder factory, IConfiguration configuration)
+        {
+            return AddNLog(factory, configuration, null);
+        }
+
+        /// <summary>
+        /// Enable NLog as logging provider in .NET Core.
+        /// </summary>
+        /// <param name="factory"></param>
+        /// <param name="configuration">Configuration</param>
+        /// <param name="options">NLog options</param>
+        /// <returns>ILoggerFactory for chaining</returns>
+        public static ILoggingBuilder AddNLog(this ILoggingBuilder factory, IConfiguration configuration, NLogProviderOptions options)
+        {
+            ConfigurationItemFactory.Default.RegisterItemsFromAssembly(typeof(Configuration.ConfigSettingLayoutRenderer).GetTypeInfo().Assembly);
+            var loggerProvider = new NLogLoggerProvider(options);
+            if (configuration != null)
+            {
+                ConfigureLoggerPovider(configuration, loggerProvider);
+            }
+            factory.AddProvider(loggerProvider);
+            return factory;
+        }
+#endif
+    }
+}