Refactor SurrogateConfigurationMethods

so that all methods in the class are dynamically discovered and exposed to Serilog settings as if they were regular extension methods

Author: tsimbalar

src/Serilog.Settings.Configuration/Settings/Configuration/SurrogateConfigurationMethods.cs

@@ -1,6 +1,6 @@
 using System;
 using System.Collections.Generic;
-using System.Linq.Expressions;
+using System.Linq;
 using System.Reflection;
 using Serilog.Configuration;
 using Serilog.Core;
@@ -10,62 +10,25 @@ namespace Serilog.Settings.Configuration
 {
     /// <summary>
     /// Contains "fake extension" methods for the Serilog configuration API.
-    /// By default the settings knows how to find extension methods, but some configuration
+    /// By default the settings know how to find extension methods, but some configuration
     /// are actually "regular" method calls and would not be found otherwise.
     ///
     /// This static class contains internal methods that can be used instead.
     ///
     /// </summary>
     static class SurrogateConfigurationMethods
     {
-        public static IEnumerable<MethodInfo> WriteTo
-        {
-            get
-            {
-                yield return GetSurrogateConfigurationMethod<LoggerSinkConfiguration, Action<LoggerConfiguration>, LoggingLevelSwitch>((c, a, s) => Logger(c, a, LevelAlias.Minimum, s));
-                yield return GetSurrogateConfigurationMethod<LoggerSinkConfiguration, ILogEventSink, LoggingLevelSwitch>((c, sink, s) => Sink(c, sink, LevelAlias.Minimum, s));
-            }
-        }
-
-        public static IEnumerable<MethodInfo> AuditTo
-        {
-            get
-            {
-                yield return GetSurrogateConfigurationMethod<LoggerAuditSinkConfiguration, ILogEventSink, LoggingLevelSwitch>((c, sink, s) => Sink(c, sink, LevelAlias.Minimum, s));
-            }
-        }
-
-        public static IEnumerable<MethodInfo> Filter
-        {
-            get
-            {
-                yield return GetSurrogateConfigurationMethod<LoggerFilterConfiguration, ILogEventFilter, object>((c, f, _) => With(c, f));
-            }
-        }
+        static readonly Dictionary<Type, MethodInfo[]> SurrogateMethodCandidates = typeof(SurrogateConfigurationMethods)
+            .GetTypeInfo().DeclaredMethods
+            .GroupBy(m => m.GetParameters().First().ParameterType)
+            .ToDictionary(g => g.Key, g => g.ToArray());
 
-        public static IEnumerable<MethodInfo> Destructure
-        {
-            get
-            {
-                yield return GetSurrogateConfigurationMethod<LoggerDestructuringConfiguration, IDestructuringPolicy, object>((c, d, _) => With(c, d));
-                yield return GetSurrogateConfigurationMethod<LoggerDestructuringConfiguration, int, object>((c, m, _) => ToMaximumDepth(c, m));
-                yield return GetSurrogateConfigurationMethod<LoggerDestructuringConfiguration, int, object>((c, m, _) => ToMaximumStringLength(c, m));
-                yield return GetSurrogateConfigurationMethod<LoggerDestructuringConfiguration, int, object>((c, m, _) => ToMaximumCollectionCount(c, m));
-                yield return GetSurrogateConfigurationMethod<LoggerDestructuringConfiguration, Type, object>((c, t, _) => AsScalar(c, t));
-            }
-        }
 
-        public static IEnumerable<MethodInfo> Enrich
-        {
-            get
-            {
-                yield return GetSurrogateConfigurationMethod<LoggerEnrichmentConfiguration, object, object>((c, _, __) => FromLogContext(c));
-                yield return GetSurrogateConfigurationMethod<LoggerEnrichmentConfiguration, ILogEventEnricher, object>((c, e, __) => With(c, e));
-            }
-        }
-
-        static MethodInfo GetSurrogateConfigurationMethod<TConfiguration, TArg1, TArg2>(Expression<Action<TConfiguration, TArg1, TArg2>> method)
-            => (method.Body as MethodCallExpression)?.Method;
+        internal static readonly MethodInfo[] WriteTo = SurrogateMethodCandidates[typeof(LoggerSinkConfiguration)];
+        internal static readonly MethodInfo[] AuditTo = SurrogateMethodCandidates[typeof(LoggerAuditSinkConfiguration)];
+        internal static readonly MethodInfo[] Enrich = SurrogateMethodCandidates[typeof(LoggerEnrichmentConfiguration)];
+        internal static readonly MethodInfo[] Destructure = SurrogateMethodCandidates[typeof(LoggerDestructuringConfiguration)];
+        internal static readonly MethodInfo[] Filter = SurrogateMethodCandidates[typeof(LoggerFilterConfiguration)];
 
         /*
         Pass-through calls to various Serilog config methods which are
@@ -75,6 +38,10 @@ invocation expressions as surrogates so that SelectConfigurationMethod
         has a way to match and invoke these instance methods.
         */
 
+        // ReSharper disable UnusedMember.Local
+        // those methods are discovered through reflection by `SurrogateMethodCandidates`
+        // ReSharper has no way to see that they are actually used ...
+
         // .WriteTo...
         // ========
         static LoggerConfiguration Sink(
@@ -138,5 +105,6 @@ static LoggerConfiguration With(LoggerEnrichmentConfiguration loggerEnrichmentCo
             return loggerEnrichmentConfiguration.With(enricher);
         }
 
+        // ReSharper restore UnusedMember.Local
     }
 }