Refactor: Introduce SettingValueResolver

tsimbalar · tsimbalar · commit b1e4661b58a4 · 2018-10-20T21:48:39.000+02:00
To pass around the `IConfiguration` object instead of a `static` member
diff --git a/src/Serilog.Settings.Configuration/Settings/Configuration/ConfigurationReader.cs b/src/Serilog.Settings.Configuration/Settings/Configuration/ConfigurationReader.cs
@@ -19,7 +19,7 @@ class ConfigurationReader : IConfigurationReader
     {
         const string LevelSwitchNameRegex = @"^\$[A-Za-z]+[A-Za-z0-9]*$";
 
-        static IConfiguration _configuration;
+        readonly IConfiguration _configuration;
 
         readonly IConfigurationSection _section;
         readonly DependencyContext _dependencyContext;
@@ -43,22 +43,25 @@ public ConfigurationReader(IConfigurationSection configSection, DependencyContex
         }
 
         // Used internally for processing nested configuration sections -- see GetMethodCalls below.
-        internal ConfigurationReader(IConfigurationSection configSection, IReadOnlyCollection<Assembly> configurationAssemblies, DependencyContext dependencyContext)
+        internal ConfigurationReader(IConfigurationSection configSection, IReadOnlyCollection<Assembly> configurationAssemblies, DependencyContext dependencyContext, SettingValueResolver valueResolver)
         {
             _section = configSection ?? throw new ArgumentNullException(nameof(configSection));
             _dependencyContext = dependencyContext;
             _configurationAssemblies = configurationAssemblies ?? throw new ArgumentNullException(nameof(configurationAssemblies));
+            _configuration = valueResolver.AppConfiguration;
         }
 
         public void Configure(LoggerConfiguration loggerConfiguration)
         {
             var declaredLevelSwitches = ProcessLevelSwitchDeclarations();
-            ApplyMinimumLevel(loggerConfiguration, declaredLevelSwitches);
-            ApplyEnrichment(loggerConfiguration, declaredLevelSwitches);
-            ApplyFilters(loggerConfiguration, declaredLevelSwitches);
-            ApplyDestructuring(loggerConfiguration, declaredLevelSwitches);
-            ApplySinks(loggerConfiguration, declaredLevelSwitches);
-            ApplyAuditSinks(loggerConfiguration, declaredLevelSwitches);
+            var settingsValueResolver = new SettingValueResolver(declaredLevelSwitches, _configuration);
+
+            ApplyMinimumLevel(loggerConfiguration, settingsValueResolver);
+            ApplyEnrichment(loggerConfiguration, settingsValueResolver);
+            ApplyFilters(loggerConfiguration, settingsValueResolver);
+            ApplyDestructuring(loggerConfiguration, settingsValueResolver);
+            ApplySinks(loggerConfiguration, settingsValueResolver);
+            ApplyAuditSinks(loggerConfiguration, settingsValueResolver);
         }
 
         IReadOnlyDictionary<string, LoggingLevelSwitch> ProcessLevelSwitchDeclarations()
@@ -89,7 +92,7 @@ IReadOnlyDictionary<string, LoggingLevelSwitch> ProcessLevelSwitchDeclarations()
             return namedSwitches;
         }
 
-        void ApplyMinimumLevel(LoggerConfiguration loggerConfiguration, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
+        void ApplyMinimumLevel(LoggerConfiguration loggerConfiguration, SettingValueResolver valueResolver)
         {
             var minimumLevelDirective = _section.GetSection("MinimumLevel");
 
@@ -102,7 +105,7 @@ void ApplyMinimumLevel(LoggerConfiguration loggerConfiguration, IReadOnlyDiction
             var minLevelControlledByDirective = minimumLevelDirective.GetSection("ControlledBy");
             if (minLevelControlledByDirective.Value != null)
             {
-                var globalMinimumLevelSwitch = declaredLevelSwitches.LookUpSwitchByName(minLevelControlledByDirective.Value);
+                var globalMinimumLevelSwitch = valueResolver.LookUpSwitchByName(minLevelControlledByDirective.Value);
                 // not calling ApplyMinimumLevel local function because here we have a reference to a LogLevelSwitch already
                 loggerConfiguration.MinimumLevel.ControlledBy(globalMinimumLevelSwitch);
             }
@@ -117,7 +120,7 @@ void ApplyMinimumLevel(LoggerConfiguration loggerConfiguration, IReadOnlyDiction
                 }
                 else
                 {
-                    var overrideSwitch = declaredLevelSwitches.LookUpSwitchByName(overridenLevelOrSwitch);
+                    var overrideSwitch = valueResolver.LookUpSwitchByName(overridenLevelOrSwitch);
                     // not calling ApplyMinimumLevel local function because here we have a reference to a LogLevelSwitch already
                     loggerConfiguration.MinimumLevel.Override(overridePrefix, overrideSwitch);
                 }
@@ -142,59 +145,59 @@ void ApplyMinimumLevel(IConfigurationSection directive, Action<LoggerMinimumLeve
             }
         }
 
-        void ApplyFilters(LoggerConfiguration loggerConfiguration, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
+        void ApplyFilters(LoggerConfiguration loggerConfiguration, SettingValueResolver valueResolver)
         {
             var filterDirective = _section.GetSection("Filter");
             if (filterDirective.GetChildren().Any())
             {
                 var methodCalls = GetMethodCalls(filterDirective);
-                CallConfigurationMethods(methodCalls, FindFilterConfigurationMethods(_configurationAssemblies), loggerConfiguration.Filter, declaredLevelSwitches);
+                CallConfigurationMethods(methodCalls, FindFilterConfigurationMethods(_configurationAssemblies), loggerConfiguration.Filter, valueResolver);
             }
         }
 
-        void ApplyDestructuring(LoggerConfiguration loggerConfiguration, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
+        void ApplyDestructuring(LoggerConfiguration loggerConfiguration, SettingValueResolver valueResolver)
         {
             var destructureDirective = _section.GetSection("Destructure");
             if (destructureDirective.GetChildren().Any())
             {
                 var methodCalls = GetMethodCalls(destructureDirective);
-                CallConfigurationMethods(methodCalls, FindDestructureConfigurationMethods(_configurationAssemblies), loggerConfiguration.Destructure, declaredLevelSwitches);
+                CallConfigurationMethods(methodCalls, FindDestructureConfigurationMethods(_configurationAssemblies), loggerConfiguration.Destructure, valueResolver);
             }
         }
 
-        void ApplySinks(LoggerConfiguration loggerConfiguration, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
+        void ApplySinks(LoggerConfiguration loggerConfiguration, SettingValueResolver valueResolver)
         {
             var writeToDirective = _section.GetSection("WriteTo");
             if (writeToDirective.GetChildren().Any())
             {
                 var methodCalls = GetMethodCalls(writeToDirective);
-                CallConfigurationMethods(methodCalls, FindSinkConfigurationMethods(_configurationAssemblies), loggerConfiguration.WriteTo, declaredLevelSwitches);
+                CallConfigurationMethods(methodCalls, FindSinkConfigurationMethods(_configurationAssemblies), loggerConfiguration.WriteTo, valueResolver);
             }
         }
 
-        void ApplyAuditSinks(LoggerConfiguration loggerConfiguration, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
+        void ApplyAuditSinks(LoggerConfiguration loggerConfiguration, SettingValueResolver valueResolver)
         {
             var auditToDirective = _section.GetSection("AuditTo");
             if (auditToDirective.GetChildren().Any())
             {
                 var methodCalls = GetMethodCalls(auditToDirective);
-                CallConfigurationMethods(methodCalls, FindAuditSinkConfigurationMethods(_configurationAssemblies), loggerConfiguration.AuditTo, declaredLevelSwitches);
+                CallConfigurationMethods(methodCalls, FindAuditSinkConfigurationMethods(_configurationAssemblies), loggerConfiguration.AuditTo, valueResolver);
             }
         }
 
-        void IConfigurationReader.ApplySinks(LoggerSinkConfiguration loggerSinkConfiguration, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
+        void IConfigurationReader.ApplySinks(LoggerSinkConfiguration loggerSinkConfiguration, SettingValueResolver valueResolver)
         {
             var methodCalls = GetMethodCalls(_section);
-            CallConfigurationMethods(methodCalls, FindSinkConfigurationMethods(_configurationAssemblies), loggerSinkConfiguration, declaredLevelSwitches);
+            CallConfigurationMethods(methodCalls, FindSinkConfigurationMethods(_configurationAssemblies), loggerSinkConfiguration, valueResolver);
         }
 
-        void ApplyEnrichment(LoggerConfiguration loggerConfiguration, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
+        void ApplyEnrichment(LoggerConfiguration loggerConfiguration, SettingValueResolver valueResolver)
         {
             var enrichDirective = _section.GetSection("Enrich");
             if (enrichDirective.GetChildren().Any())
             {
                 var methodCalls = GetMethodCalls(enrichDirective);
-                CallConfigurationMethods(methodCalls, FindEventEnricherConfigurationMethods(_configurationAssemblies), loggerConfiguration.Enrich, declaredLevelSwitches);
+                CallConfigurationMethods(methodCalls, FindEventEnricherConfigurationMethods(_configurationAssemblies), loggerConfiguration.Enrich, valueResolver);
             }
 
             var propertiesDirective = _section.GetSection("Properties");
@@ -318,7 +321,7 @@ where filter(assemblyFileName)
             return query.ToArray();
         }
 
-        static void CallConfigurationMethods(ILookup<string, Dictionary<string, IConfigurationArgumentValue>> methods, IList<MethodInfo> configurationMethods, object receiver, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
+        static void CallConfigurationMethods(ILookup<string, Dictionary<string, IConfigurationArgumentValue>> methods, IList<MethodInfo> configurationMethods, object receiver, SettingValueResolver valueResolver)
         {
             foreach (var method in methods.SelectMany(g => g.Select(x => new { g.Key, Value = x })))
             {
@@ -328,17 +331,19 @@ static void CallConfigurationMethods(ILookup<string, Dictionary<string, IConfigu
                 {
                     var call = (from p in methodInfo.GetParameters().Skip(1)
                                 let directive = method.Value.FirstOrDefault(s => s.Key.Equals(p.Name, StringComparison.OrdinalIgnoreCase))
-                                select directive.Key == null ? p.DefaultValue : directive.Value.ConvertTo(p.ParameterType, declaredLevelSwitches)).ToList();
+                                select directive.Key == null
+                                    ? p.DefaultValue
+                                    : directive.Value.ConvertTo(p.ParameterType, valueResolver)).ToList();
 
                     var parm = methodInfo.GetParameters().FirstOrDefault(i => i.ParameterType == typeof(IConfiguration));
                     if (parm != null && !parm.HasDefaultValue)
                     {
-                        if (_configuration is null)
+                        if (valueResolver.AppConfiguration is null)
                         {
                             throw new InvalidOperationException("Trying to invoke a configuration method accepting a `IConfiguration` argument. " +
                                                                 $"This is not supported when only a `IConfigSection` has been provided. (method '{methodInfo}')");
                         }
-                        call[parm.Position - 1] = _configuration;
+                        call[parm.Position - 1] = valueResolver.AppConfiguration;
                     }
 
                     call.Insert(0, receiver);
diff --git a/src/Serilog.Settings.Configuration/Settings/Configuration/IConfigurationArgumentValue.cs b/src/Serilog.Settings.Configuration/Settings/Configuration/IConfigurationArgumentValue.cs
@@ -1,11 +1,9 @@
 ﻿using System;
-using System.Collections.Generic;
-using Serilog.Core;
 
 namespace Serilog.Settings.Configuration
 {
     interface IConfigurationArgumentValue
     {
-        object ConvertTo(Type toType, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches);
+        object ConvertTo(Type toType, SettingValueResolver valueResolver);
     }
 }
diff --git a/src/Serilog.Settings.Configuration/Settings/Configuration/IConfigurationReader.cs b/src/Serilog.Settings.Configuration/Settings/Configuration/IConfigurationReader.cs
@@ -1,11 +1,9 @@
-﻿using System.Collections.Generic;
-using Serilog.Configuration;
-using Serilog.Core;
+﻿using Serilog.Configuration;
 
 namespace Serilog.Settings.Configuration
 {
     interface IConfigurationReader : ILoggerSettings
     {
-        void ApplySinks(LoggerSinkConfiguration loggerSinkConfiguration, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches);
+        void ApplySinks(LoggerSinkConfiguration loggerSinkConfiguration, SettingValueResolver valueResolver);
     }
 }
diff --git a/src/Serilog.Settings.Configuration/Settings/Configuration/LevelSwitchDictionaryExtensions.cs b/src/Serilog.Settings.Configuration/Settings/Configuration/LevelSwitchDictionaryExtensions.cs
diff --git a/src/Serilog.Settings.Configuration/Settings/Configuration/ObjectArgumentValue.cs b/src/Serilog.Settings.Configuration/Settings/Configuration/ObjectArgumentValue.cs
@@ -1,7 +1,6 @@
 ﻿using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyModel;
 using Serilog.Configuration;
-using Serilog.Core;
 using System;
 using System.Collections.Generic;
 using System.Reflection;
@@ -23,30 +22,30 @@ public ObjectArgumentValue(IConfigurationSection section, IReadOnlyCollection<As
             this.dependencyContext = dependencyContext;
         }
 
-        public object ConvertTo(Type toType, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
+        public object ConvertTo(Type toType, SettingValueResolver valueResolver)
         {
             // return the entire section for internal processing
-            if(toType == typeof(IConfigurationSection)) return section;
+            if (toType == typeof(IConfigurationSection)) return section;
 
             // process a nested configuration to populate an Action<> logger/sink config parameter?
             var typeInfo = toType.GetTypeInfo();
-            if(typeInfo.IsGenericType &&
+            if (typeInfo.IsGenericType &&
                 typeInfo.GetGenericTypeDefinition() is Type genericType && genericType == typeof(Action<>))
             {
                 var configType = typeInfo.GenericTypeArguments[0];
-                if(configType != typeof(LoggerConfiguration) && configType != typeof(LoggerSinkConfiguration))
+                if (configType != typeof(LoggerConfiguration) && configType != typeof(LoggerSinkConfiguration))
                     throw new ArgumentException($"Configuration for Action<{configType}> is not implemented.");
 
-                IConfigurationReader configReader = new ConfigurationReader(section, configurationAssemblies, dependencyContext);
+                IConfigurationReader configReader = new ConfigurationReader(section, configurationAssemblies, dependencyContext, valueResolver);
 
-                if(configType == typeof(LoggerConfiguration))
+                if (configType == typeof(LoggerConfiguration))
                 {
                     return new Action<LoggerConfiguration>(configReader.Configure);
                 }
 
-                if(configType == typeof(LoggerSinkConfiguration))
+                if (configType == typeof(LoggerSinkConfiguration))
                 {
-                    return new Action<LoggerSinkConfiguration>(loggerSinkConfig => configReader.ApplySinks(loggerSinkConfig, declaredLevelSwitches));
+                    return new Action<LoggerSinkConfiguration>(loggerSinkConfig => configReader.ApplySinks(loggerSinkConfig, valueResolver));
                 }
             }
 
diff --git a/src/Serilog.Settings.Configuration/Settings/Configuration/SettingValueResolver.cs b/src/Serilog.Settings.Configuration/Settings/Configuration/SettingValueResolver.cs
@@ -0,0 +1,43 @@
+﻿
+
+using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.Configuration;
+using Serilog.Core;
+
+namespace Serilog.Settings.Configuration
+{
+    internal sealed class SettingValueResolver
+    {
+        readonly IReadOnlyDictionary<string, LoggingLevelSwitch> _declaredLevelSwitches;
+
+        public SettingValueResolver(IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches, IConfiguration appConfiguration)
+        {
+            _declaredLevelSwitches = declaredLevelSwitches ?? throw new ArgumentNullException(nameof(declaredLevelSwitches));
+            AppConfiguration = appConfiguration;
+        }
+
+        public IConfiguration AppConfiguration { get; }
+
+        /// <summary>
+        /// Looks up a switch in the declared LoggingLevelSwitches
+        /// </summary>
+        /// <param name="switchName">the name of a switch to look up</param>
+        /// <returns>the LoggingLevelSwitch registered with the name</returns>
+        /// <exception cref="InvalidOperationException">if no switch has been registered with <paramref name="switchName"/></exception>
+        public LoggingLevelSwitch LookUpSwitchByName(string switchName)
+        {
+            if (_declaredLevelSwitches.TryGetValue(switchName, out var levelSwitch))
+            {
+                return levelSwitch;
+            }
+
+            throw new InvalidOperationException($"No LoggingLevelSwitch has been declared with name \"{switchName}\". You might be missing a section \"LevelSwitches\":{{\"{switchName}\":\"InitialLevel\"}}");
+        }
+
+        public static SettingValueResolver Default()
+        {
+            return new SettingValueResolver(new Dictionary<string, LoggingLevelSwitch>(), null);
+        }
+    }
+}
diff --git a/src/Serilog.Settings.Configuration/Settings/Configuration/StringArgumentValue.cs b/src/Serilog.Settings.Configuration/Settings/Configuration/StringArgumentValue.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Text.RegularExpressions;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Primitives;
 
 using Serilog.Core;
@@ -31,13 +32,13 @@ public StringArgumentValue(Func<string> valueProducer, Func<IChangeToken> change
                 { typeof(Type), s => Type.GetType(s, throwOnError:true) },
             };
 
-        public object ConvertTo(Type toType, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
+        public object ConvertTo(Type toType, SettingValueResolver valueResolver)
         {
             var argumentValue = Environment.ExpandEnvironmentVariables(_valueProducer());
 
             if (toType == typeof(LoggingLevelSwitch))
             {
-                return declaredLevelSwitches.LookUpSwitchByName(argumentValue);
+                return valueResolver.LookUpSwitchByName(argumentValue);
             }
 
             var toTypeInfo = toType.GetTypeInfo();
diff --git a/test/Serilog.Settings.Configuration.Tests/ConfigurationReaderTests.cs b/test/Serilog.Settings.Configuration.Tests/ConfigurationReaderTests.cs
@@ -3,7 +3,6 @@
 using Xunit;
 using System.Reflection;
 using System.Linq;
-using Serilog.Core;
 using Serilog.Settings.Configuration.Tests.Support;
 
 namespace Serilog.Settings.Configuration.Tests
@@ -75,7 +74,7 @@ public void WriteToSupportExpandedSyntaxWithArgs()
 
             Assert.Equal(1, args.Length);
             Assert.Equal("outputTemplate", args[0].Key);
-            Assert.Equal("{Message}", args[0].Value.ConvertTo(typeof(string), new Dictionary<string, LoggingLevelSwitch>()));
+            Assert.Equal("{Message}", args[0].Value.ConvertTo(typeof(string), SettingValueResolver.Default()));
         }
 
         [Fact]
diff --git a/test/Serilog.Settings.Configuration.Tests/LoggerConfigurationExtensionsTests.cs b/test/Serilog.Settings.Configuration.Tests/LoggerConfigurationExtensionsTests.cs
diff --git a/test/Serilog.Settings.Configuration.Tests/StringArgumentValueTests.cs b/test/Serilog.Settings.Configuration.Tests/StringArgumentValueTests.cs

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ class ConfigurationReader : IConfigurationReader`
`19`	`19`	`{`
`20`	`20`	`const string LevelSwitchNameRegex = @"^\$[A-Za-z]+[A-Za-z0-9]*$";`
`21`	`21`
`22`		`- static IConfiguration _configuration;`
	`22`	`+ readonly IConfiguration _configuration;`
`23`	`23`
`24`	`24`	`readonly IConfigurationSection _section;`
`25`	`25`	`readonly DependencyContext _dependencyContext;`
`@@ -43,22 +43,25 @@ public ConfigurationReader(IConfigurationSection configSection, DependencyContex`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`// Used internally for processing nested configuration sections -- see GetMethodCalls below.`
`46`		`- internal ConfigurationReader(IConfigurationSection configSection, IReadOnlyCollection<Assembly> configurationAssemblies, DependencyContext dependencyContext)`
	`46`	`+ internal ConfigurationReader(IConfigurationSection configSection, IReadOnlyCollection<Assembly> configurationAssemblies, DependencyContext dependencyContext, SettingValueResolver valueResolver)`
`47`	`47`	`{`
`48`	`48`	`_section = configSection ?? throw new ArgumentNullException(nameof(configSection));`
`49`	`49`	`_dependencyContext = dependencyContext;`
`50`	`50`	`_configurationAssemblies = configurationAssemblies ?? throw new ArgumentNullException(nameof(configurationAssemblies));`
	`51`	`+ _configuration = valueResolver.AppConfiguration;`
`51`	`52`	`}`
`52`	`53`
`53`	`54`	`public void Configure(LoggerConfiguration loggerConfiguration)`
`54`	`55`	`{`
`55`	`56`	`var declaredLevelSwitches = ProcessLevelSwitchDeclarations();`
`56`		`- ApplyMinimumLevel(loggerConfiguration, declaredLevelSwitches);`
`57`		`- ApplyEnrichment(loggerConfiguration, declaredLevelSwitches);`
`58`		`- ApplyFilters(loggerConfiguration, declaredLevelSwitches);`
`59`		`- ApplyDestructuring(loggerConfiguration, declaredLevelSwitches);`
`60`		`- ApplySinks(loggerConfiguration, declaredLevelSwitches);`
`61`		`- ApplyAuditSinks(loggerConfiguration, declaredLevelSwitches);`
	`57`	`+ var settingsValueResolver = new SettingValueResolver(declaredLevelSwitches, _configuration);`
	`58`	`+`
	`59`	`+ ApplyMinimumLevel(loggerConfiguration, settingsValueResolver);`
	`60`	`+ ApplyEnrichment(loggerConfiguration, settingsValueResolver);`
	`61`	`+ ApplyFilters(loggerConfiguration, settingsValueResolver);`
	`62`	`+ ApplyDestructuring(loggerConfiguration, settingsValueResolver);`
	`63`	`+ ApplySinks(loggerConfiguration, settingsValueResolver);`
	`64`	`+ ApplyAuditSinks(loggerConfiguration, settingsValueResolver);`
`62`	`65`	`}`
`63`	`66`
`64`	`67`	`IReadOnlyDictionary<string, LoggingLevelSwitch> ProcessLevelSwitchDeclarations()`
`@@ -89,7 +92,7 @@ IReadOnlyDictionary<string, LoggingLevelSwitch> ProcessLevelSwitchDeclarations()`
`89`	`92`	`return namedSwitches;`
`90`	`93`	`}`
`91`	`94`
`92`		`- void ApplyMinimumLevel(LoggerConfiguration loggerConfiguration, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)`
	`95`	`+ void ApplyMinimumLevel(LoggerConfiguration loggerConfiguration, SettingValueResolver valueResolver)`
`93`	`96`	`{`
`94`	`97`	`var minimumLevelDirective = _section.GetSection("MinimumLevel");`
`95`	`98`
`@@ -102,7 +105,7 @@ void ApplyMinimumLevel(LoggerConfiguration loggerConfiguration, IReadOnlyDiction`
`102`	`105`	`var minLevelControlledByDirective = minimumLevelDirective.GetSection("ControlledBy");`
`103`	`106`	`if (minLevelControlledByDirective.Value != null)`
`104`	`107`	`{`
`105`		`- var globalMinimumLevelSwitch = declaredLevelSwitches.LookUpSwitchByName(minLevelControlledByDirective.Value);`
	`108`	`+ var globalMinimumLevelSwitch = valueResolver.LookUpSwitchByName(minLevelControlledByDirective.Value);`
`106`	`109`	`// not calling ApplyMinimumLevel local function because here we have a reference to a LogLevelSwitch already`
`107`	`110`	`loggerConfiguration.MinimumLevel.ControlledBy(globalMinimumLevelSwitch);`
`108`	`111`	`}`
`@@ -117,7 +120,7 @@ void ApplyMinimumLevel(LoggerConfiguration loggerConfiguration, IReadOnlyDiction`
`117`	`120`	`}`
`118`	`121`	`else`
`119`	`122`	`{`
`120`		`- var overrideSwitch = declaredLevelSwitches.LookUpSwitchByName(overridenLevelOrSwitch);`
	`123`	`+ var overrideSwitch = valueResolver.LookUpSwitchByName(overridenLevelOrSwitch);`
`121`	`124`	`// not calling ApplyMinimumLevel local function because here we have a reference to a LogLevelSwitch already`
`122`	`125`	`loggerConfiguration.MinimumLevel.Override(overridePrefix, overrideSwitch);`
`123`	`126`	`}`
`@@ -142,59 +145,59 @@ void ApplyMinimumLevel(IConfigurationSection directive, Action<LoggerMinimumLeve`
`142`	`145`	`}`
`143`	`146`	`}`
`144`	`147`
`145`		`- void ApplyFilters(LoggerConfiguration loggerConfiguration, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)`
	`148`	`+ void ApplyFilters(LoggerConfiguration loggerConfiguration, SettingValueResolver valueResolver)`
`146`	`149`	`{`
`147`	`150`	`var filterDirective = _section.GetSection("Filter");`
`148`	`151`	`if (filterDirective.GetChildren().Any())`
`149`	`152`	`{`
`150`	`153`	`var methodCalls = GetMethodCalls(filterDirective);`
`151`		`- CallConfigurationMethods(methodCalls, FindFilterConfigurationMethods(_configurationAssemblies), loggerConfiguration.Filter, declaredLevelSwitches);`
	`154`	`+ CallConfigurationMethods(methodCalls, FindFilterConfigurationMethods(_configurationAssemblies), loggerConfiguration.Filter, valueResolver);`
`152`	`155`	`}`
`153`	`156`	`}`
`154`	`157`
`155`		`- void ApplyDestructuring(LoggerConfiguration loggerConfiguration, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)`
	`158`	`+ void ApplyDestructuring(LoggerConfiguration loggerConfiguration, SettingValueResolver valueResolver)`
`156`	`159`	`{`
`157`	`160`	`var destructureDirective = _section.GetSection("Destructure");`
`158`	`161`	`if (destructureDirective.GetChildren().Any())`
`159`	`162`	`{`
`160`	`163`	`var methodCalls = GetMethodCalls(destructureDirective);`
`161`		`- CallConfigurationMethods(methodCalls, FindDestructureConfigurationMethods(_configurationAssemblies), loggerConfiguration.Destructure, declaredLevelSwitches);`
	`164`	`+ CallConfigurationMethods(methodCalls, FindDestructureConfigurationMethods(_configurationAssemblies), loggerConfiguration.Destructure, valueResolver);`
`162`	`165`	`}`
`163`	`166`	`}`
`164`	`167`
`165`		`- void ApplySinks(LoggerConfiguration loggerConfiguration, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)`
	`168`	`+ void ApplySinks(LoggerConfiguration loggerConfiguration, SettingValueResolver valueResolver)`
`166`	`169`	`{`
`167`	`170`	`var writeToDirective = _section.GetSection("WriteTo");`
`168`	`171`	`if (writeToDirective.GetChildren().Any())`
`169`	`172`	`{`
`170`	`173`	`var methodCalls = GetMethodCalls(writeToDirective);`
`171`		`- CallConfigurationMethods(methodCalls, FindSinkConfigurationMethods(_configurationAssemblies), loggerConfiguration.WriteTo, declaredLevelSwitches);`
	`174`	`+ CallConfigurationMethods(methodCalls, FindSinkConfigurationMethods(_configurationAssemblies), loggerConfiguration.WriteTo, valueResolver);`
`172`	`175`	`}`
`173`	`176`	`}`
`174`	`177`
`175`		`- void ApplyAuditSinks(LoggerConfiguration loggerConfiguration, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)`
	`178`	`+ void ApplyAuditSinks(LoggerConfiguration loggerConfiguration, SettingValueResolver valueResolver)`
`176`	`179`	`{`
`177`	`180`	`var auditToDirective = _section.GetSection("AuditTo");`
`178`	`181`	`if (auditToDirective.GetChildren().Any())`
`179`	`182`	`{`
`180`	`183`	`var methodCalls = GetMethodCalls(auditToDirective);`
`181`		`- CallConfigurationMethods(methodCalls, FindAuditSinkConfigurationMethods(_configurationAssemblies), loggerConfiguration.AuditTo, declaredLevelSwitches);`
	`184`	`+ CallConfigurationMethods(methodCalls, FindAuditSinkConfigurationMethods(_configurationAssemblies), loggerConfiguration.AuditTo, valueResolver);`
`182`	`185`	`}`
`183`	`186`	`}`
`184`	`187`
`185`		`- void IConfigurationReader.ApplySinks(LoggerSinkConfiguration loggerSinkConfiguration, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)`
	`188`	`+ void IConfigurationReader.ApplySinks(LoggerSinkConfiguration loggerSinkConfiguration, SettingValueResolver valueResolver)`
`186`	`189`	`{`
`187`	`190`	`var methodCalls = GetMethodCalls(_section);`
`188`		`- CallConfigurationMethods(methodCalls, FindSinkConfigurationMethods(_configurationAssemblies), loggerSinkConfiguration, declaredLevelSwitches);`
	`191`	`+ CallConfigurationMethods(methodCalls, FindSinkConfigurationMethods(_configurationAssemblies), loggerSinkConfiguration, valueResolver);`
`189`	`192`	`}`
`190`	`193`
`191`		`- void ApplyEnrichment(LoggerConfiguration loggerConfiguration, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)`
	`194`	`+ void ApplyEnrichment(LoggerConfiguration loggerConfiguration, SettingValueResolver valueResolver)`
`192`	`195`	`{`
`193`	`196`	`var enrichDirective = _section.GetSection("Enrich");`
`194`	`197`	`if (enrichDirective.GetChildren().Any())`
`195`	`198`	`{`
`196`	`199`	`var methodCalls = GetMethodCalls(enrichDirective);`
`197`		`- CallConfigurationMethods(methodCalls, FindEventEnricherConfigurationMethods(_configurationAssemblies), loggerConfiguration.Enrich, declaredLevelSwitches);`
	`200`	`+ CallConfigurationMethods(methodCalls, FindEventEnricherConfigurationMethods(_configurationAssemblies), loggerConfiguration.Enrich, valueResolver);`
`198`	`201`	`}`
`199`	`202`
`200`	`203`	`var propertiesDirective = _section.GetSection("Properties");`
`@@ -318,7 +321,7 @@ where filter(assemblyFileName)`
`318`	`321`	`return query.ToArray();`
`319`	`322`	`}`
`320`	`323`
`321`		`- static void CallConfigurationMethods(ILookup<string, Dictionary<string, IConfigurationArgumentValue>> methods, IList<MethodInfo> configurationMethods, object receiver, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)`
	`324`	`+ static void CallConfigurationMethods(ILookup<string, Dictionary<string, IConfigurationArgumentValue>> methods, IList<MethodInfo> configurationMethods, object receiver, SettingValueResolver valueResolver)`
`322`	`325`	`{`
`323`	`326`	`foreach (var method in methods.SelectMany(g => g.Select(x => new { g.Key, Value = x })))`
`324`	`327`	`{`
`@@ -328,17 +331,19 @@ static void CallConfigurationMethods(ILookup<string, Dictionary<string, IConfigu`
`328`	`331`	`{`
`329`	`332`	`var call = (from p in methodInfo.GetParameters().Skip(1)`
`330`	`333`	`let directive = method.Value.FirstOrDefault(s => s.Key.Equals(p.Name, StringComparison.OrdinalIgnoreCase))`
`331`		`- select directive.Key == null ? p.DefaultValue : directive.Value.ConvertTo(p.ParameterType, declaredLevelSwitches)).ToList();`
	`334`	`+ select directive.Key == null`
	`335`	`+ ? p.DefaultValue`
	`336`	`+ : directive.Value.ConvertTo(p.ParameterType, valueResolver)).ToList();`
`332`	`337`
`333`	`338`	`var parm = methodInfo.GetParameters().FirstOrDefault(i => i.ParameterType == typeof(IConfiguration));`
`334`	`339`	`if (parm != null && !parm.HasDefaultValue)`
`335`	`340`	`{`
`336`		`- if (_configuration is null)`
	`341`	`+ if (valueResolver.AppConfiguration is null)`
`337`	`342`	`{`
`338`	`343`	throw new InvalidOperationException("Trying to invoke a configuration method accepting a `IConfiguration` argument. " +
`339`	`344`	$"This is not supported when only a `IConfigSection` has been provided. (method '{methodInfo}')");
`340`	`345`	`}`
`341`		`- call[parm.Position - 1] = _configuration;`
	`346`	`+ call[parm.Position - 1] = valueResolver.AppConfiguration;`
`342`	`347`	`}`
`343`	`348`
`344`	`349`	`call.Insert(0, receiver);`
Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,9 @@`
`1`	`1`	`using System;`
`2`		`-using System.Collections.Generic;`
`3`		`-using Serilog.Core;`
`4`	`2`
`5`	`3`	`namespace Serilog.Settings.Configuration`
`6`	`4`	`{`
`7`	`5`	`interface IConfigurationArgumentValue`
`8`	`6`	`{`
`9`		`- object ConvertTo(Type toType, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches);`
	`7`	`+ object ConvertTo(Type toType, SettingValueResolver valueResolver);`
`10`	`8`	`}`
`11`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,9 @@`
`1`		`-using System.Collections.Generic;`
`2`		`-using Serilog.Configuration;`
`3`		`-using Serilog.Core;`
	`1`	`+using Serilog.Configuration;`
`4`	`2`
`5`	`3`	`namespace Serilog.Settings.Configuration`
`6`	`4`	`{`
`7`	`5`	`interface IConfigurationReader : ILoggerSettings`
`8`	`6`	`{`
`9`		`- void ApplySinks(LoggerSinkConfiguration loggerSinkConfiguration, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches);`
	`7`	`+ void ApplySinks(LoggerSinkConfiguration loggerSinkConfiguration, SettingValueResolver valueResolver);`
`10`	`8`	`}`
`11`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,6 @@`
`1`	`1`	`using Microsoft.Extensions.Configuration;`
`2`	`2`	`using Microsoft.Extensions.DependencyModel;`
`3`	`3`	`using Serilog.Configuration;`
`4`		`-using Serilog.Core;`
`5`	`4`	`using System;`
`6`	`5`	`using System.Collections.Generic;`
`7`	`6`	`using System.Reflection;`
`@@ -23,30 +22,30 @@ public ObjectArgumentValue(IConfigurationSection section, IReadOnlyCollection<As`
`23`	`22`	`this.dependencyContext = dependencyContext;`
`24`	`23`	`}`
`25`	`24`
`26`		`- public object ConvertTo(Type toType, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)`
	`25`	`+ public object ConvertTo(Type toType, SettingValueResolver valueResolver)`
`27`	`26`	`{`
`28`	`27`	`// return the entire section for internal processing`
`29`		`- if(toType == typeof(IConfigurationSection)) return section;`
	`28`	`+ if (toType == typeof(IConfigurationSection)) return section;`
`30`	`29`
`31`	`30`	`// process a nested configuration to populate an Action<> logger/sink config parameter?`
`32`	`31`	`var typeInfo = toType.GetTypeInfo();`
`33`		`- if(typeInfo.IsGenericType &&`
	`32`	`+ if (typeInfo.IsGenericType &&`
`34`	`33`	`typeInfo.GetGenericTypeDefinition() is Type genericType && genericType == typeof(Action<>))`
`35`	`34`	`{`
`36`	`35`	`var configType = typeInfo.GenericTypeArguments[0];`
`37`		`- if(configType != typeof(LoggerConfiguration) && configType != typeof(LoggerSinkConfiguration))`
	`36`	`+ if (configType != typeof(LoggerConfiguration) && configType != typeof(LoggerSinkConfiguration))`
`38`	`37`	`throw new ArgumentException($"Configuration for Action<{configType}> is not implemented.");`
`39`	`38`
`40`		`- IConfigurationReader configReader = new ConfigurationReader(section, configurationAssemblies, dependencyContext);`
	`39`	`+ IConfigurationReader configReader = new ConfigurationReader(section, configurationAssemblies, dependencyContext, valueResolver);`
`41`	`40`
`42`		`- if(configType == typeof(LoggerConfiguration))`
	`41`	`+ if (configType == typeof(LoggerConfiguration))`
`43`	`42`	`{`
`44`	`43`	`return new Action<LoggerConfiguration>(configReader.Configure);`
`45`	`44`	`}`
`46`	`45`
`47`		`- if(configType == typeof(LoggerSinkConfiguration))`
	`46`	`+ if (configType == typeof(LoggerSinkConfiguration))`
`48`	`47`	`{`
`49`		`- return new Action<LoggerSinkConfiguration>(loggerSinkConfig => configReader.ApplySinks(loggerSinkConfig, declaredLevelSwitches));`
	`48`	`+ return new Action<LoggerSinkConfiguration>(loggerSinkConfig => configReader.ApplySinks(loggerSinkConfig, valueResolver));`
`50`	`49`	`}`
`51`	`50`	`}`
`52`	`51`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`using System.Linq;`
`4`	`4`	`using System.Reflection;`
`5`	`5`	`using System.Text.RegularExpressions;`
	`6`	`+using Microsoft.Extensions.Configuration;`
`6`	`7`	`using Microsoft.Extensions.Primitives;`
`7`	`8`
`8`	`9`	`using Serilog.Core;`
`@@ -31,13 +32,13 @@ public StringArgumentValue(Func<string> valueProducer, Func<IChangeToken> change`
`31`	`32`	`{ typeof(Type), s => Type.GetType(s, throwOnError:true) },`
`32`	`33`	`};`
`33`	`34`
`34`		`- public object ConvertTo(Type toType, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)`
	`35`	`+ public object ConvertTo(Type toType, SettingValueResolver valueResolver)`
`35`	`36`	`{`
`36`	`37`	`var argumentValue = Environment.ExpandEnvironmentVariables(_valueProducer());`
`37`	`38`
`38`	`39`	`if (toType == typeof(LoggingLevelSwitch))`
`39`	`40`	`{`
`40`		`- return declaredLevelSwitches.LookUpSwitchByName(argumentValue);`
	`41`	`+ return valueResolver.LookUpSwitchByName(argumentValue);`
`41`	`42`	`}`
`42`	`43`
`43`	`44`	`var toTypeInfo = toType.GetTypeInfo();`