Removed redundant intermediate classes in class hierarchies for ValidationRules and DataTemplateSelectors.

Signed-off-by: Dima Enns <[email protected]>

Author: Yeah69

Sources/LambdaConverters.Wpf/TemplateSelector.cs

@@ -11,35 +11,7 @@ namespace LambdaConverters
     /// </summary>
     public static class TemplateSelector
     {
-        abstract class Selector : LambdaConverters.Selector
-        {
-            protected Selector(
-                SelectorErrorStrategy errorStrategy,
-                object defaultInputTypeValue,
-                [NotNull] Type inputType,
-                bool isSelectorFunctionAvailable)
-                : base(
-                    errorStrategy,
-                    defaultInputTypeValue,
-                    inputType,
-                    isSelectorFunctionAvailable) { }
-
-            protected abstract DataTemplate SelectTemplateInternal(object item, DependencyObject container);
-
-            public override DataTemplate SelectTemplate(object item, DependencyObject container)
-            {
-                if (!IsSelectFunctionAvailable)
-                {
-                    EventSource.Log.MissingSelectTemplateFunction("selectFunction", ErrorStrategy.ToString());
-
-                    return GetErrorValue(default(DataTemplate));
-                }
-
-                return SelectTemplateInternal(item, container);
-            }
-        }
-
-        sealed class Selector<I> : Selector
+        sealed class Selector<I> : LambdaConverters.Selector
         {
             readonly Func<TemplateSelectorArgs<I>, DataTemplate> selectFunction;
 
@@ -51,7 +23,7 @@ internal Selector(
                 this.selectFunction = selectFunction;
             }
 
-            protected override DataTemplate SelectTemplateInternal(object item, DependencyObject container)
+            DataTemplate SelectTemplateInternal(object item, DependencyObject container)
             {
                 I inputValue;
                 try
@@ -69,6 +41,18 @@ protected override DataTemplate SelectTemplateInternal(object item, DependencyOb
 
                 return selectFunction(new TemplateSelectorArgs<I>(inputValue, container));
             }
+
+            public override DataTemplate SelectTemplate(object item, DependencyObject container)
+            {
+                if (!IsSelectFunctionAvailable)
+                {
+                    EventSource.Log.MissingSelectTemplateFunction("selectFunction", ErrorStrategy.ToString());
+
+                    return GetErrorValue(default(DataTemplate));
+                }
+
+                return SelectTemplateInternal(item, container);
+            }
         }
 
         /// <summary>

Sources/LambdaConverters.Wpf/Validator.cs

@@ -11,35 +11,7 @@ namespace LambdaConverters
     /// </summary>
     public static class Validator
     {
-        abstract class Rule : LambdaConverters.Rule
-        {
-            protected Rule(
-                RuleErrorStrategy errorStrategy,
-                object defaultInputTypeValue,
-                [NotNull] Type inputType,
-                bool isRuleFunctionAvailable)
-                : base(
-                    errorStrategy,
-                    defaultInputTypeValue,
-                    inputType,
-                    isRuleFunctionAvailable) { }
-
-            protected abstract ValidationResult ValidateInternal(object value, CultureInfo cultureInfo);
-
-            public override ValidationResult Validate(object value, CultureInfo cultureInfo)
-            {
-                if (!IsRuleFunctionAvailable)
-                {
-                    EventSource.Log.MissingRuleFunction("ruleFunction", ErrorStrategy.ToString());
-
-                    return GetErrorValue(default(ValidationResult));
-                }
-
-                return ValidateInternal(value, cultureInfo);
-            }
-        }
-
-        sealed class Rule<I> : Rule
+        sealed class Rule<I> : LambdaConverters.Rule
         {
             readonly Func<ValidationRuleArgs<I>, ValidationResult> ruleFunction;
 
@@ -51,7 +23,7 @@ internal Rule(
                 this.ruleFunction = ruleFunction;
             }
 
-            protected override ValidationResult ValidateInternal(object item, CultureInfo cultureInfo)
+            ValidationResult ValidateInternal(object item, CultureInfo cultureInfo)
             {
                 I inputValue;
                 try
@@ -69,13 +41,25 @@ protected override ValidationResult ValidateInternal(object item, CultureInfo cu
 
                 return ruleFunction(new ValidationRuleArgs<I>(inputValue, cultureInfo));
             }
+
+            public override ValidationResult Validate(object value, CultureInfo cultureInfo)
+            {
+                if (!IsRuleFunctionAvailable)
+                {
+                    EventSource.Log.MissingRuleFunction("ruleFunction", ErrorStrategy.ToString());
+
+                    return GetErrorValue(default(ValidationResult));
+                }
+
+                return ValidateInternal(value, cultureInfo);
+            }
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ValidationRule" /> class.
         /// </summary>
         /// <typeparam name="I">The value type.</typeparam>
-        /// <param name="ruleFunction">The <see cref="ValidationRule.Validate" /> method.</param>
+        /// <param name="ruleFunction">The Validate method.</param>
         /// <param name="errorStrategy">The error strategy.</param>
         /// <returns>An <see cref="ValidationRule" /> object.</returns>
         /// <exception cref="ArgumentOutOfRangeException">