Fix some warnings and suggestions proposed by ReSharper

0xced · 0xced · commit 2b33d112d8bf · 2022-05-12T08:09:38.000+02:00
diff --git a/sample/Sample/Program.cs b/sample/Sample/Program.cs
@@ -12,6 +12,8 @@
 using Serilog.Events;
 using Serilog.Debugging;
 
+// ReSharper disable UnusedType.Global
+
 namespace Sample
 {
     public class Program
@@ -31,7 +33,7 @@ public static void Main(string[] args)
                 .ReadFrom.Configuration(configuration)
                 .CreateLogger();
 
-            logger.Information("Args: {a}", args);
+            logger.Information("Args: {Args}", args);
 
             do
             {
@@ -79,6 +81,7 @@ public bool IsEnabled(LogEvent logEvent)
     public class LoginData
     {
         public string Username;
+        // ReSharper disable once NotAccessedField.Global
         public string Password;
     }
 
@@ -88,12 +91,12 @@ public bool TryDestructure(object value, ILogEventPropertyValueFactory propertyV
         {
             result = null;
 
-            if (value is LoginData)
+            if (value is LoginData loginData)
             {
                 result = new StructureValue(
                     new List<LogEventProperty>
                     {
-                        new LogEventProperty("Username", new ScalarValue(((LoginData)value).Username))
+                        new("Username", new ScalarValue(loginData.Username))
                     });
             }
 
diff --git a/serilog-settings-configuration.sln.DotSettings b/serilog-settings-configuration.sln.DotSettings
@@ -556,4 +556,6 @@ II.2.12 &lt;HandlesEvent /&gt;&#xD;
 	
 	
 	<s:String x:Key="/Default/FilterSettingsManager/AttributeFilterXml/@EntryValue">&lt;data /&gt;</s:String>
-	<s:String x:Key="/Default/FilterSettingsManager/CoverageFilterXml/@EntryValue">&lt;data&gt;&lt;IncludeFilters /&gt;&lt;ExcludeFilters /&gt;&lt;/data&gt;</s:String></wpf:ResourceDictionary>
+	<s:String x:Key="/Default/FilterSettingsManager/CoverageFilterXml/@EntryValue">&lt;data&gt;&lt;IncludeFilters /&gt;&lt;ExcludeFilters /&gt;&lt;/data&gt;</s:String>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Enricher/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=polyfilled/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
diff --git a/src/Serilog.Settings.Configuration/Settings/Configuration/ConfigurationReader.cs b/src/Serilog.Settings.Configuration/Settings/Configuration/ConfigurationReader.cs
@@ -146,7 +146,7 @@ void ApplyMinimumLevel(LoggerConfiguration loggerConfiguration)
             var defaultMinLevelDirective = minimumLevelDirective.Value != null ? minimumLevelDirective : minimumLevelDirective.GetSection("Default");
             if (defaultMinLevelDirective.Value != null)
             {
-                ApplyMinimumLevel(defaultMinLevelDirective, (configuration, levelSwitch) => configuration.ControlledBy(levelSwitch));
+                ApplyMinimumLevelConfiguration(defaultMinLevelDirective, (configuration, levelSwitch) => configuration.ControlledBy(levelSwitch));
             }
 
             var minLevelControlledByDirective = minimumLevelDirective.GetSection("ControlledBy");
@@ -163,7 +163,7 @@ void ApplyMinimumLevel(LoggerConfiguration loggerConfiguration)
                 var overridenLevelOrSwitch = overrideDirective.Value;
                 if (Enum.TryParse(overridenLevelOrSwitch, out LogEventLevel _))
                 {
-                    ApplyMinimumLevel(overrideDirective, (configuration, levelSwitch) => configuration.Override(overridePrefix, levelSwitch));
+                    ApplyMinimumLevelConfiguration(overrideDirective, (configuration, levelSwitch) => configuration.Override(overridePrefix, levelSwitch));
                 }
                 else
                 {
@@ -173,7 +173,7 @@ void ApplyMinimumLevel(LoggerConfiguration loggerConfiguration)
                 }
             }
 
-            void ApplyMinimumLevel(IConfigurationSection directive, Action<LoggerMinimumLevelConfiguration, LoggingLevelSwitch> applyConfigAction)
+            void ApplyMinimumLevelConfiguration(IConfigurationSection directive, Action<LoggerMinimumLevelConfiguration, LoggingLevelSwitch> applyConfigAction)
             {
                 var minimumLevel = ParseLogEventLevel(directive.Value);
 
@@ -261,9 +261,9 @@ void ApplyEnrichment(LoggerConfiguration loggerConfiguration)
             var propertiesDirective = _section.GetSection("Properties");
             if (propertiesDirective.GetChildren().Any())
             {
-                foreach (var enrichProperyDirective in propertiesDirective.GetChildren())
+                foreach (var enrichPropertyDirective in propertiesDirective.GetChildren())
                 {
-                    loggerConfiguration.Enrich.WithProperty(enrichProperyDirective.Key, enrichProperyDirective.Value);
+                    loggerConfiguration.Enrich.WithProperty(enrichPropertyDirective.Key, enrichPropertyDirective.Value);
                 }
             }
         }
@@ -356,11 +356,11 @@ static IReadOnlyCollection<Assembly> LoadConfigurationAssemblies(IConfigurationS
             return assemblies.Values.ToList().AsReadOnly();
         }
 
-        void CallConfigurationMethods(ILookup<string, Dictionary<string, IConfigurationArgumentValue>> methods, IList<MethodInfo> configurationMethods, object receiver)
+        void CallConfigurationMethods(ILookup<string, Dictionary<string, IConfigurationArgumentValue>> methods, IReadOnlyCollection<MethodInfo> configurationMethods, object receiver)
         {
             foreach (var method in methods.SelectMany(g => g.Select(x => new { g.Key, Value = x })))
             {
-                var methodInfo = SelectConfigurationMethod(configurationMethods, method.Key, method.Value.Keys);
+                var methodInfo = SelectConfigurationMethod(configurationMethods, method.Key, method.Value.Keys.ToList());
 
                 if (methodInfo != null)
                 {
@@ -409,7 +409,7 @@ object GetImplicitValueForNotSpecifiedKey(ParameterInfo parameter, MethodInfo me
             return parameter.DefaultValue;
         }
 
-        internal static MethodInfo SelectConfigurationMethod(IEnumerable<MethodInfo> candidateMethods, string name, IEnumerable<string> suppliedArgumentNames)
+        internal static MethodInfo SelectConfigurationMethod(IReadOnlyCollection<MethodInfo> candidateMethods, string name, IReadOnlyCollection<string> suppliedArgumentNames)
         {
             // Per issue #111, it is safe to use case-insensitive matching on argument names. The CLR doesn't permit this type
             // of overloading, and the Microsoft.Extensions.Configuration keys are case-insensitive (case is preserved with some
@@ -464,7 +464,7 @@ static bool ParameterNameMatches(string actualParameterName, IEnumerable<string>
             return suppliedNames.Any(s => ParameterNameMatches(actualParameterName, s));
         }
 
-        static IList<MethodInfo> FindSinkConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)
+        static IReadOnlyCollection<MethodInfo> FindSinkConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)
         {
             var found = FindConfigurationExtensionMethods(configurationAssemblies, typeof(LoggerSinkConfiguration));
             if (configurationAssemblies.Contains(typeof(LoggerSinkConfiguration).GetTypeInfo().Assembly))
@@ -473,15 +473,15 @@ static IList<MethodInfo> FindSinkConfigurationMethods(IReadOnlyCollection<Assemb
             return found;
         }
 
-        static IList<MethodInfo> FindAuditSinkConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)
+        static IReadOnlyCollection<MethodInfo> FindAuditSinkConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)
         {
             var found = FindConfigurationExtensionMethods(configurationAssemblies, typeof(LoggerAuditSinkConfiguration));
             if (configurationAssemblies.Contains(typeof(LoggerAuditSinkConfiguration).GetTypeInfo().Assembly))
                 found.AddRange(SurrogateConfigurationMethods.AuditTo);
             return found;
         }
 
-        static IList<MethodInfo> FindFilterConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)
+        static IReadOnlyCollection<MethodInfo> FindFilterConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)
         {
             var found = FindConfigurationExtensionMethods(configurationAssemblies, typeof(LoggerFilterConfiguration));
             if (configurationAssemblies.Contains(typeof(LoggerFilterConfiguration).GetTypeInfo().Assembly))
@@ -490,7 +490,7 @@ static IList<MethodInfo> FindFilterConfigurationMethods(IReadOnlyCollection<Asse
             return found;
         }
 
-        static IList<MethodInfo> FindDestructureConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)
+        static IReadOnlyCollection<MethodInfo> FindDestructureConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)
         {
             var found = FindConfigurationExtensionMethods(configurationAssemblies, typeof(LoggerDestructuringConfiguration));
             if (configurationAssemblies.Contains(typeof(LoggerDestructuringConfiguration).GetTypeInfo().Assembly))
@@ -499,7 +499,7 @@ static IList<MethodInfo> FindDestructureConfigurationMethods(IReadOnlyCollection
             return found;
         }
 
-        static IList<MethodInfo> FindEventEnricherConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)
+        static IReadOnlyCollection<MethodInfo> FindEventEnricherConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)
         {
             var found = FindConfigurationExtensionMethods(configurationAssemblies, typeof(LoggerEnrichmentConfiguration));
             if (configurationAssemblies.Contains(typeof(LoggerEnrichmentConfiguration).GetTypeInfo().Assembly))
diff --git a/src/Serilog.Settings.Configuration/Settings/Configuration/LoggingFilterSwitchProxy.cs b/src/Serilog.Settings.Configuration/Settings/Configuration/LoggingFilterSwitchProxy.cs
@@ -11,7 +11,8 @@ class LoggingFilterSwitchProxy
         {
             RealSwitch = realSwitch ?? throw new ArgumentNullException(nameof(realSwitch));
 
-            var expressionProperty = realSwitch.GetType().GetProperty("Expression");
+            var type = realSwitch.GetType();
+            var expressionProperty = type.GetProperty("Expression") ?? throw new MissingMemberException(type.FullName, "Expression");
 
             _setProxy = (Action<string>)Delegate.CreateDelegate(
                 typeof(Action<string>),
diff --git a/src/Serilog.Settings.Configuration/Settings/Configuration/ObjectArgumentValue.cs b/src/Serilog.Settings.Configuration/Settings/Configuration/ObjectArgumentValue.cs
@@ -48,8 +48,8 @@ public object ConvertTo(Type toType, ResolutionContext resolutionContext)
             if (toType.IsArray)
                 return CreateArray();
 
-            if (IsContainer(toType, out var elementType) && TryCreateContainer(out var result))
-                return result;
+            if (IsContainer(toType, out var elementType) && TryCreateContainer(out var container))
+                return container;
 
             if (TryBuildCtorExpression(_section, toType, resolutionContext, out var ctorExpression))
             {
@@ -61,17 +61,17 @@ public object ConvertTo(Type toType, ResolutionContext resolutionContext)
 
             object CreateArray()
             {
-                var elementType = toType.GetElementType();
+                var arrayElementType = toType.GetElementType()!;
                 var configurationElements = _section.GetChildren().ToArray();
-                var result = Array.CreateInstance(elementType, configurationElements.Length);
+                var array = Array.CreateInstance(arrayElementType, configurationElements.Length);
                 for (int i = 0; i < configurationElements.Length; ++i)
                 {
                     var argumentValue = ConfigurationReader.GetArgumentValue(configurationElements[i], _configurationAssemblies);
-                    var value = argumentValue.ConvertTo(elementType, resolutionContext);
-                    result.SetValue(value, i);
+                    var value = argumentValue.ConvertTo(arrayElementType, resolutionContext);
+                    array.SetValue(value, i);
                 }
 
-                return result;
+                return array;
             }
 
             bool TryCreateContainer(out object result)
@@ -82,7 +82,7 @@ bool TryCreateContainer(out object result)
                     return false;
 
                 // https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/object-and-collection-initializers#collection-initializers
-                var addMethod = toType.GetMethods().FirstOrDefault(m => !m.IsStatic && m.Name == "Add" && m.GetParameters()?.Length == 1 && m.GetParameters()[0].ParameterType == elementType);
+                var addMethod = toType.GetMethods().FirstOrDefault(m => !m.IsStatic && m.Name == "Add" && m.GetParameters().Length == 1 && m.GetParameters()[0].ParameterType == elementType);
                 if (addMethod == null)
                     return false;
 
diff --git a/test/Serilog.Settings.Configuration.Tests/ConfigurationSettingsTests.cs b/test/Serilog.Settings.Configuration.Tests/ConfigurationSettingsTests.cs
@@ -681,6 +681,7 @@ public void DestructureWithCollectionsOfTypeArgument()
 
             ConfigFromJson(json);
 
+            Assert.NotNull(DummyPolicy.Current);
             Assert.Equal(typeof(TimeSpan), DummyPolicy.Current.Type);
             Assert.Equal(new[] { typeof(int), typeof(string) }, DummyPolicy.Current.Array);
             Assert.Equal(new[] { typeof(byte), typeof(short) }, DummyPolicy.Current.List);
diff --git a/test/Serilog.Settings.Configuration.Tests/ObjectArgumentValueTests.cs b/test/Serilog.Settings.Configuration.Tests/ObjectArgumentValueTests.cs
@@ -4,6 +4,10 @@
 
 using Xunit;
 
+// ReSharper disable UnusedMember.Local
+// ReSharper disable UnusedParameter.Local
+// ReSharper disable UnusedType.Local
+
 namespace Serilog.Settings.Configuration.Tests
 {
     public class ObjectArgumentValueTests
diff --git a/test/TestDummies/Console/DummyConsoleSink.cs b/test/TestDummies/Console/DummyConsoleSink.cs
@@ -17,7 +17,7 @@ public DummyConsoleSink(ConsoleTheme theme = null)
         public static ConsoleTheme Theme;
 
         [ThreadStatic]
-        static List<LogEvent> EmittedList = new List<LogEvent>();
+        static List<LogEvent> EmittedList;
 
         public static List<LogEvent> Emitted => EmittedList ?? (EmittedList = new List<LogEvent>());
 

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,8 @@`
`12`	`12`	`using Serilog.Events;`
`13`	`13`	`using Serilog.Debugging;`
`14`	`14`
	`15`	`+// ReSharper disable UnusedType.Global`
	`16`	`+`
`15`	`17`	`namespace Sample`
`16`	`18`	`{`
`17`	`19`	`public class Program`
`@@ -31,7 +33,7 @@ public static void Main(string[] args)`
`31`	`33`	`.ReadFrom.Configuration(configuration)`
`32`	`34`	`.CreateLogger();`
`33`	`35`
`34`		`- logger.Information("Args: {a}", args);`
	`36`	`+ logger.Information("Args: {Args}", args);`
`35`	`37`
`36`	`38`	`do`
`37`	`39`	`{`
`@@ -79,6 +81,7 @@ public bool IsEnabled(LogEvent logEvent)`
`79`	`81`	`public class LoginData`
`80`	`82`	`{`
`81`	`83`	`public string Username;`
	`84`	`+ // ReSharper disable once NotAccessedField.Global`
`82`	`85`	`public string Password;`
`83`	`86`	`}`
`84`	`87`
`@@ -88,12 +91,12 @@ public bool TryDestructure(object value, ILogEventPropertyValueFactory propertyV`
`88`	`91`	`{`
`89`	`92`	`result = null;`
`90`	`93`
`91`		`- if (value is LoginData)`
	`94`	`+ if (value is LoginData loginData)`
`92`	`95`	`{`
`93`	`96`	`result = new StructureValue(`
`94`	`97`	`new List<LogEventProperty>`
`95`	`98`	`{`
`96`		`- new LogEventProperty("Username", new ScalarValue(((LoginData)value).Username))`
	`99`	`+ new("Username", new ScalarValue(loginData.Username))`
`97`	`100`	`});`
`98`	`101`	`}`
`99`	`102`
Original file line number	Diff line number	Diff line change
`@@ -146,7 +146,7 @@ void ApplyMinimumLevel(LoggerConfiguration loggerConfiguration)`
`146`	`146`	`var defaultMinLevelDirective = minimumLevelDirective.Value != null ? minimumLevelDirective : minimumLevelDirective.GetSection("Default");`
`147`	`147`	`if (defaultMinLevelDirective.Value != null)`
`148`	`148`	`{`
`149`		`- ApplyMinimumLevel(defaultMinLevelDirective, (configuration, levelSwitch) => configuration.ControlledBy(levelSwitch));`
	`149`	`+ ApplyMinimumLevelConfiguration(defaultMinLevelDirective, (configuration, levelSwitch) => configuration.ControlledBy(levelSwitch));`
`150`	`150`	`}`
`151`	`151`
`152`	`152`	`var minLevelControlledByDirective = minimumLevelDirective.GetSection("ControlledBy");`
`@@ -163,7 +163,7 @@ void ApplyMinimumLevel(LoggerConfiguration loggerConfiguration)`
`163`	`163`	`var overridenLevelOrSwitch = overrideDirective.Value;`
`164`	`164`	`if (Enum.TryParse(overridenLevelOrSwitch, out LogEventLevel _))`
`165`	`165`	`{`
`166`		`- ApplyMinimumLevel(overrideDirective, (configuration, levelSwitch) => configuration.Override(overridePrefix, levelSwitch));`
	`166`	`+ ApplyMinimumLevelConfiguration(overrideDirective, (configuration, levelSwitch) => configuration.Override(overridePrefix, levelSwitch));`
`167`	`167`	`}`
`168`	`168`	`else`
`169`	`169`	`{`
`@@ -173,7 +173,7 @@ void ApplyMinimumLevel(LoggerConfiguration loggerConfiguration)`
`173`	`173`	`}`
`174`	`174`	`}`
`175`	`175`
`176`		`- void ApplyMinimumLevel(IConfigurationSection directive, Action<LoggerMinimumLevelConfiguration, LoggingLevelSwitch> applyConfigAction)`
	`176`	`+ void ApplyMinimumLevelConfiguration(IConfigurationSection directive, Action<LoggerMinimumLevelConfiguration, LoggingLevelSwitch> applyConfigAction)`
`177`	`177`	`{`
`178`	`178`	`var minimumLevel = ParseLogEventLevel(directive.Value);`
`179`	`179`
`@@ -261,9 +261,9 @@ void ApplyEnrichment(LoggerConfiguration loggerConfiguration)`
`261`	`261`	`var propertiesDirective = _section.GetSection("Properties");`
`262`	`262`	`if (propertiesDirective.GetChildren().Any())`
`263`	`263`	`{`
`264`		`- foreach (var enrichProperyDirective in propertiesDirective.GetChildren())`
	`264`	`+ foreach (var enrichPropertyDirective in propertiesDirective.GetChildren())`
`265`	`265`	`{`
`266`		`- loggerConfiguration.Enrich.WithProperty(enrichProperyDirective.Key, enrichProperyDirective.Value);`
	`266`	`+ loggerConfiguration.Enrich.WithProperty(enrichPropertyDirective.Key, enrichPropertyDirective.Value);`
`267`	`267`	`}`
`268`	`268`	`}`
`269`	`269`	`}`
`@@ -356,11 +356,11 @@ static IReadOnlyCollection<Assembly> LoadConfigurationAssemblies(IConfigurationS`
`356`	`356`	`return assemblies.Values.ToList().AsReadOnly();`
`357`	`357`	`}`
`358`	`358`
`359`		`- void CallConfigurationMethods(ILookup<string, Dictionary<string, IConfigurationArgumentValue>> methods, IList<MethodInfo> configurationMethods, object receiver)`
	`359`	`+ void CallConfigurationMethods(ILookup<string, Dictionary<string, IConfigurationArgumentValue>> methods, IReadOnlyCollection<MethodInfo> configurationMethods, object receiver)`
`360`	`360`	`{`
`361`	`361`	`foreach (var method in methods.SelectMany(g => g.Select(x => new { g.Key, Value = x })))`
`362`	`362`	`{`
`363`		`- var methodInfo = SelectConfigurationMethod(configurationMethods, method.Key, method.Value.Keys);`
	`363`	`+ var methodInfo = SelectConfigurationMethod(configurationMethods, method.Key, method.Value.Keys.ToList());`
`364`	`364`
`365`	`365`	`if (methodInfo != null)`
`366`	`366`	`{`
`@@ -409,7 +409,7 @@ object GetImplicitValueForNotSpecifiedKey(ParameterInfo parameter, MethodInfo me`
`409`	`409`	`return parameter.DefaultValue;`
`410`	`410`	`}`
`411`	`411`
`412`		`- internal static MethodInfo SelectConfigurationMethod(IEnumerable<MethodInfo> candidateMethods, string name, IEnumerable<string> suppliedArgumentNames)`
	`412`	`+ internal static MethodInfo SelectConfigurationMethod(IReadOnlyCollection<MethodInfo> candidateMethods, string name, IReadOnlyCollection<string> suppliedArgumentNames)`
`413`	`413`	`{`
`414`	`414`	`// Per issue #111, it is safe to use case-insensitive matching on argument names. The CLR doesn't permit this type`
`415`	`415`	`// of overloading, and the Microsoft.Extensions.Configuration keys are case-insensitive (case is preserved with some`
`@@ -464,7 +464,7 @@ static bool ParameterNameMatches(string actualParameterName, IEnumerable<string>`
`464`	`464`	`return suppliedNames.Any(s => ParameterNameMatches(actualParameterName, s));`
`465`	`465`	`}`
`466`	`466`
`467`		`- static IList<MethodInfo> FindSinkConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)`
	`467`	`+ static IReadOnlyCollection<MethodInfo> FindSinkConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)`
`468`	`468`	`{`
`469`	`469`	`var found = FindConfigurationExtensionMethods(configurationAssemblies, typeof(LoggerSinkConfiguration));`
`470`	`470`	`if (configurationAssemblies.Contains(typeof(LoggerSinkConfiguration).GetTypeInfo().Assembly))`
`@@ -473,15 +473,15 @@ static IList<MethodInfo> FindSinkConfigurationMethods(IReadOnlyCollection<Assemb`
`473`	`473`	`return found;`
`474`	`474`	`}`
`475`	`475`
`476`		`- static IList<MethodInfo> FindAuditSinkConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)`
	`476`	`+ static IReadOnlyCollection<MethodInfo> FindAuditSinkConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)`
`477`	`477`	`{`
`478`	`478`	`var found = FindConfigurationExtensionMethods(configurationAssemblies, typeof(LoggerAuditSinkConfiguration));`
`479`	`479`	`if (configurationAssemblies.Contains(typeof(LoggerAuditSinkConfiguration).GetTypeInfo().Assembly))`
`480`	`480`	`found.AddRange(SurrogateConfigurationMethods.AuditTo);`
`481`	`481`	`return found;`
`482`	`482`	`}`
`483`	`483`
`484`		`- static IList<MethodInfo> FindFilterConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)`
	`484`	`+ static IReadOnlyCollection<MethodInfo> FindFilterConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)`
`485`	`485`	`{`
`486`	`486`	`var found = FindConfigurationExtensionMethods(configurationAssemblies, typeof(LoggerFilterConfiguration));`
`487`	`487`	`if (configurationAssemblies.Contains(typeof(LoggerFilterConfiguration).GetTypeInfo().Assembly))`
`@@ -490,7 +490,7 @@ static IList<MethodInfo> FindFilterConfigurationMethods(IReadOnlyCollection<Asse`
`490`	`490`	`return found;`
`491`	`491`	`}`
`492`	`492`
`493`		`- static IList<MethodInfo> FindDestructureConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)`
	`493`	`+ static IReadOnlyCollection<MethodInfo> FindDestructureConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)`
`494`	`494`	`{`
`495`	`495`	`var found = FindConfigurationExtensionMethods(configurationAssemblies, typeof(LoggerDestructuringConfiguration));`
`496`	`496`	`if (configurationAssemblies.Contains(typeof(LoggerDestructuringConfiguration).GetTypeInfo().Assembly))`
`@@ -499,7 +499,7 @@ static IList<MethodInfo> FindDestructureConfigurationMethods(IReadOnlyCollection`
`499`	`499`	`return found;`
`500`	`500`	`}`
`501`	`501`
`502`		`- static IList<MethodInfo> FindEventEnricherConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)`
	`502`	`+ static IReadOnlyCollection<MethodInfo> FindEventEnricherConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)`
`503`	`503`	`{`
`504`	`504`	`var found = FindConfigurationExtensionMethods(configurationAssemblies, typeof(LoggerEnrichmentConfiguration));`
`505`	`505`	`if (configurationAssemblies.Contains(typeof(LoggerEnrichmentConfiguration).GetTypeInfo().Assembly))`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,8 @@ class LoggingFilterSwitchProxy`
`11`	`11`	`{`
`12`	`12`	`RealSwitch = realSwitch ?? throw new ArgumentNullException(nameof(realSwitch));`
`13`	`13`
`14`		`- var expressionProperty = realSwitch.GetType().GetProperty("Expression");`
	`14`	`+ var type = realSwitch.GetType();`
	`15`	`+ var expressionProperty = type.GetProperty("Expression") ?? throw new MissingMemberException(type.FullName, "Expression");`
`15`	`16`
`16`	`17`	`_setProxy = (Action<string>)Delegate.CreateDelegate(`
`17`	`18`	`typeof(Action<string>),`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,10 @@`
`4`	`4`
`5`	`5`	`using Xunit;`
`6`	`6`
	`7`	`+// ReSharper disable UnusedMember.Local`
	`8`	`+// ReSharper disable UnusedParameter.Local`
	`9`	`+// ReSharper disable UnusedType.Local`
	`10`	`+`
`7`	`11`	`namespace Serilog.Settings.Configuration.Tests`
`8`	`12`	`{`
`9`	`13`	`public class ObjectArgumentValueTests`