The abstract base classes Rule and Selector can be removed as well.

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

Author: Yeah69

Sources/LambdaConverters.Wpf/LambdaConverters.Wpf.csproj

@@ -57,8 +57,6 @@
     <Reference Include="WindowsBase" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Rule.cs" />
-    <Compile Include="Selector.cs" />
     <Compile Include="Converter.cs" />
     <Compile Include="RuleErrorStrategy.cs" />
     <Compile Include="SelectorErrorStrategy.cs" />

Sources/LambdaConverters.Wpf/Rule.cs

@@ -11,15 +11,37 @@ namespace LambdaConverters
     /// </summary>
     public static class TemplateSelector
     {
-        sealed class Selector<I> : LambdaConverters.Selector
+        sealed class Selector<I> : System.Windows.Controls.DataTemplateSelector
         {
             readonly Func<TemplateSelectorArgs<I>, DataTemplate> selectFunction;
 
+            SelectorErrorStrategy ErrorStrategy { get; }
+
+            bool IsSelectFunctionAvailable { get; }
+
+            [Pure]
+            DataTemplate GetErrorValue(DataTemplate defaultValue)
+            {
+                switch (ErrorStrategy)
+                {
+                    case SelectorErrorStrategy.ReturnDefaultValue:
+                        return defaultValue;
+
+                    case SelectorErrorStrategy.ReturnNewEmptyDataTemplate:
+                        return new DataTemplate();
+
+                    default:
+                        throw new NotSupportedException();
+                }
+            }
+
             internal Selector(
                 Func<TemplateSelectorArgs<I>, DataTemplate> selectFunction,
                 SelectorErrorStrategy errorStrategy)
-                : base(errorStrategy, default(I), typeof(I), selectFunction != null)
             {
+                ErrorStrategy = errorStrategy;
+                IsSelectFunctionAvailable = selectFunction != null;
+
                 this.selectFunction = selectFunction;
             }
 

Sources/LambdaConverters.Wpf/Selector.cs

@@ -11,18 +11,42 @@ namespace LambdaConverters
     /// </summary>
     public static class Validator
     {
-        sealed class Rule<I> : LambdaConverters.Rule
+        sealed class Rule<I> : System.Windows.Controls.ValidationRule
         {
             readonly Func<ValidationRuleArgs<I>, ValidationResult> ruleFunction;
 
             internal Rule(
                 Func<ValidationRuleArgs<I>, ValidationResult> ruleFunction,
                 RuleErrorStrategy errorStrategy)
-                : base(errorStrategy, default(I), typeof(I), ruleFunction != null)
             {
+                ErrorStrategy = errorStrategy;
+                IsRuleFunctionAvailable = ruleFunction != null;
                 this.ruleFunction = ruleFunction;
             }
 
+            RuleErrorStrategy ErrorStrategy { get; }
+
+            bool IsRuleFunctionAvailable { get; }
+
+            [Pure]
+            ValidationResult GetErrorValue(ValidationResult defaultValue)
+            {
+                switch (ErrorStrategy)
+                {
+                    case RuleErrorStrategy.ReturnDefaultValue:
+                        return defaultValue;
+
+                    case RuleErrorStrategy.ReturnInvalid:
+                        return new ValidationResult(false, null);
+
+                    case RuleErrorStrategy.ReturnValid:
+                        return new ValidationResult(true, null);
+
+                    default:
+                        throw new NotSupportedException();
+                }
+            }
+
             ValidationResult ValidateInternal(object item, CultureInfo cultureInfo)
             {
                 I inputValue;
@@ -59,7 +83,7 @@ public override ValidationResult Validate(object value, CultureInfo cultureInfo)
         /// Initializes a new instance of the <see cref="ValidationRule" /> class.
         /// </summary>
         /// <typeparam name="I">The value type.</typeparam>
-        /// <param name="ruleFunction">The Validate method.</param>
+        /// <param name="ruleFunction">The <see cref="ValidationRule.Validate(object, CultureInfo)"/> method.</param>
         /// <param name="errorStrategy">The error strategy.</param>
         /// <returns>An <see cref="ValidationRule" /> object.</returns>
         /// <exception cref="ArgumentOutOfRangeException">