Extended the library to support ValidationRules in similar manner as the DataTemplateSelector extension.

And some corrections of the previous commit.

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

Author: Yeah69

Sources/LambdaConverters.Wpf/EventSource.cs

@@ -14,6 +14,7 @@ public static class Keywords
         {
             public const EventKeywords Converters = (EventKeywords)0x4;
             public const EventKeywords Selectors = (EventKeywords)0x8;
+            public const EventKeywords Rules = (EventKeywords)0x10;
         }
 
         [NotNull]
@@ -510,5 +511,63 @@ public void UnableToCastToItemType(
                     memberName,
                     sourceFilePath,
                     sourceLineNumber);
+
+        /// <summary>
+        /// The {0} is null, conversion result is a value according to the specified error strategy ({1}).
+        /// </summary>
+        [Conditional("TRACE")]
+        [Event(
+            24,
+            Version = 0,
+            Message = "The {0} is null, conversion result is a value according to the specified error strategy ({1}).",
+            Level = EventLevel.Warning,
+            Keywords = Keywords.Rules,
+            Opcode = EventOpcode.Info,
+            Channel = EventChannel.Operational
+        )]
+        public void MissingRuleFunction(
+            string callback,
+            string errorStrategy,
+            [CallerMemberName] string memberName = null,
+            [CallerFilePath] string sourceFilePath = null,
+            [CallerLineNumber] int sourceLineNumber = 0)
+            =>
+                WriteEvent(
+                    24,
+                    callback,
+                    errorStrategy,
+                    memberName,
+                    sourceFilePath,
+                    sourceLineNumber);
+
+        /// <summary>
+        /// The value ({0}) cannot be cast to the specified input type ({1}), conversion result is a value according to the specified error strategy ({2}).
+        /// </summary>
+        [Conditional("TRACE")]
+        [Event(
+            25,
+            Version = 0,
+            Message = "The value ({0}) cannot be cast to the specified input type ({1}), conversion result is a value according to the specified error strategy ({2}).",
+            Level = EventLevel.Warning,
+            Keywords = Keywords.Rules,
+            Opcode = EventOpcode.Info,
+            Channel = EventChannel.Operational
+        )]
+        public void UnableToCastToRuleInputType(
+            string itemType,
+            string inputType,
+            string errorStrategy,
+            [CallerMemberName] string memberName = null,
+            [CallerFilePath] string sourceFilePath = null,
+            [CallerLineNumber] int sourceLineNumber = 0)
+            =>
+                WriteEvent(
+                    25,
+                    itemType,
+                    inputType,
+                    errorStrategy,
+                    memberName,
+                    sourceFilePath,
+                    sourceLineNumber);
     }
 }

Sources/LambdaConverters.Wpf/LambdaConverters.Wpf.csproj

@@ -57,8 +57,10 @@
     <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" />
     <Compile Include="ConverterErrorStrategy.cs" />
     <Compile Include="EventSource.cs" />
@@ -68,17 +70,19 @@
     <Compile Include="MultiValueConverterArgs[T].cs" />
     <Compile Include="MultiValueConverterArgs[T].IEquatable[MultiValueConverterArgs[T]].cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Validator.cs" />
     <Compile Include="TemplateSelector.cs" />
     <Compile Include="ValueConverter.cs" />
+    <Compile Include="ValidationRuleArgs[T].cs" />
     <Compile Include="ValueConverterArgs[T,P].cs" />
     <Compile Include="ValueConverterArgs[T,P].IEquatable[ValueConverterArgs[T,P]].cs" />
     <Compile Include="TemplateSelectorArgs[T].cs" />
     <Compile Include="ValueConverterArgs[T].cs" />
-    <Compile Include="TemplateSelectorArgs[T].IEquatable[DataTemplateSelectorArgs[T]].cs" />
+    <Compile Include="TemplateSelectorArgs[T].IEquatable[TemplateSelectorArgs[T]].cs" />
+    <Compile Include="ValidationRuleArgs[T].IEquatable[ValidationRuleArgs[T]].cs" />
     <Compile Include="ValueConverterArgs[T].IEquatable[ValueConverterArgs[T]].cs" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="ClassDiagram1.cd" />
     <None Include="packages.config" />
     <None Include="Properties\LambdaConverters.public.snk" />
   </ItemGroup>

Sources/LambdaConverters.Wpf/Rule.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Windows.Controls;
+using JetBrains.Annotations;
+
+namespace LambdaConverters
+{
+    internal abstract class Rule : System.Windows.Controls.ValidationRule
+    {
+        internal Rule(
+            RuleErrorStrategy errorStrategy,
+            object defaultInputTypeValue,
+            [NotNull] Type inputType,
+            bool isRuleFunctionAvailable)
+        {
+            ErrorStrategy = errorStrategy;
+            DefaultInputTypeValue = defaultInputTypeValue;
+            InputType = inputType;
+            IsRuleFunctionAvailable = isRuleFunctionAvailable;
+        }
+
+        internal RuleErrorStrategy ErrorStrategy { get; }
+
+        internal object DefaultInputTypeValue { get; }
+
+        [NotNull]
+        internal Type InputType { get; }
+
+        internal bool IsRuleFunctionAvailable { get; }
+
+        [Pure]
+        internal 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();
+            }
+        }
+    }
+}

Sources/LambdaConverters.Wpf/RuleErrorStrategy.cs

@@ -0,0 +1,25 @@
+using System.Windows.Controls;
+
+namespace LambdaConverters
+{
+    /// <summary>
+    /// Defines the validation rule error strategy.
+    /// </summary>
+    public enum RuleErrorStrategy
+    {
+        /// <summary>
+        /// The default of <see cref="ValidationRule" /> is returned.
+        /// </summary>
+        ReturnDefaultValue,
+
+        /// <summary>
+        /// An invalid validation result is returned.
+        /// </summary>
+        ReturnInvalid,
+
+        /// <summary>
+        /// A valid validation result is returned.
+        /// </summary>
+        ReturnValid
+    }
+}

Sources/LambdaConverters.Wpf/Selector.cs

@@ -10,12 +10,12 @@ internal Selector(
             SelectorErrorStrategy errorStrategy,
             object defaultInputTypeValue,
             [NotNull] Type inputType,
-            bool isConvertFunctionAvailable)
+            bool isSelectFunctionAvailable)
         {
             ErrorStrategy = errorStrategy;
             DefaultInputTypeValue = defaultInputTypeValue;
             InputType = inputType;
-            IsSelectFunctionAvailable = isConvertFunctionAvailable;
+            IsSelectFunctionAvailable = isSelectFunctionAvailable;
         }
 
         internal SelectorErrorStrategy ErrorStrategy { get; }

Sources/LambdaConverters.Wpf/TemplateSelector.cs

@@ -72,7 +72,7 @@ protected override DataTemplate SelectTemplateInternal(object item, DependencyOb
         }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="DataTemplateSelector" /> interface.
+        /// Initializes a new instance of the <see cref="DataTemplateSelector" /> class.
         /// </summary>
         /// <typeparam name="I">The item type.</typeparam>
         /// <param name="selectFunction">The <see cref="DataTemplateSelector.SelectTemplate" /> method.</param>

Sources/LambdaConverters.Wpf/TemplateSelectorArgs[T].IEquatable[DataTemplateSelectorArgs[T]].cs renamed to Sources/LambdaConverters.Wpf/TemplateSelectorArgs[T].IEquatable[TemplateSelectorArgs[T]].cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+
+namespace LambdaConverters
+{
+    partial struct ValidationRuleArgs<T> : IEquatable<ValidationRuleArgs<T>>
+    {
+        /// <summary>
+        /// Implements the operator <c>==</c>.
+        /// </summary>
+        /// <param name="x">The left operand.</param>
+        /// <param name="y">The right operand.</param>
+        /// <returns>The result of the operator.</returns>
+        public static bool operator ==(ValidationRuleArgs<T> x, ValidationRuleArgs<T> y) => Equals(x.Value, y.Value) && Equals(x.Culture, y.Culture);
+
+        /// <summary>
+        /// Implements the operator <c>!=</c>.
+        /// </summary>
+        /// <param name="x">The left operand.</param>
+        /// <param name="y">The right operand.</param>
+        /// <returns>The result of the operator.</returns>
+        public static bool operator !=(ValidationRuleArgs<T> x, ValidationRuleArgs<T> y) => !Equals(x.Value, y.Value) || !Equals(x.Culture, y.Culture);
+
+        /// <inheritdoc />
+        public override int GetHashCode() => EqualityComparer<T>.Default.GetHashCode(Value) ^ (Culture?.GetHashCode() ?? 0);
+
+        /// <inheritdoc />
+        public override bool Equals(object obj) => obj is ValidationRuleArgs<T> && Equals((ValidationRuleArgs<T>)obj);
+
+        /// <inheritdoc />
+        public bool Equals(ValidationRuleArgs<T> other) => this == other;
+    }
+}

Sources/LambdaConverters.Wpf/ValidationRuleArgs[T].IEquatable[ValidationRuleArgs[T]].cs

@@ -0,0 +1,27 @@
+using System.Globalization;
+
+namespace LambdaConverters
+{
+    /// <summary>
+    /// Provides data for parameterized validation rule functions.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    public partial struct ValidationRuleArgs<T>
+    {
+        internal ValidationRuleArgs(T value, CultureInfo culture)
+        {
+            Value = value;
+            Culture = culture;
+        }
+
+        /// <summary>
+        /// Gets the value.
+        /// </summary>
+        public T Value { get; }
+
+        /// <summary>
+        /// Gets the culture.
+        /// </summary>
+        public CultureInfo Culture { get; }
+    }
+}

Sources/LambdaConverters.Wpf/ValidationRuleArgs[T].cs

@@ -0,0 +1,104 @@
+using System;
+using System.Diagnostics;
+using System.Globalization;
+using System.Windows.Controls;
+using JetBrains.Annotations;
+
+namespace LambdaConverters
+{
+    /// <summary>
+    /// A factory class used to create lambda-based instances of the <see cref="ValidationRule"/> class.
+    /// </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
+        {
+            readonly Func<ValidationRuleArgs<I>, ValidationResult> ruleFunction;
+
+            internal Rule(
+                Func<ValidationRuleArgs<I>, ValidationResult> ruleFunction,
+                RuleErrorStrategy errorStrategy)
+                : base(errorStrategy, default(I), typeof(I), ruleFunction != null)
+            {
+                this.ruleFunction = ruleFunction;
+            }
+
+            protected override ValidationResult ValidateInternal(object item, CultureInfo cultureInfo)
+            {
+                I inputValue;
+                try
+                {
+                    inputValue = (I)item;
+                }
+                catch (SystemException e) when (e is InvalidCastException || e is NullReferenceException)
+                {
+                    EventSource.Log.UnableToCastToRuleInputType(item?.GetType().Name ?? "null", typeof(I).Name, ErrorStrategy.ToString());
+
+                    return GetErrorValue(default(ValidationResult));
+                }
+
+                Debug.Assert(ruleFunction != null);
+
+                return ruleFunction(new ValidationRuleArgs<I>(inputValue, 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="errorStrategy">The error strategy.</param>
+        /// <returns>An <see cref="ValidationRule" /> object.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">
+        ///     <paramref name="errorStrategy"/> is not a valid <see cref="RuleErrorStrategy"/> value.
+        /// </exception>
+        [Pure]
+        [NotNull]
+        public static ValidationRule Create<I>(
+            Func<ValidationRuleArgs<I>, ValidationResult> ruleFunction = null,
+            RuleErrorStrategy errorStrategy = RuleErrorStrategy.ReturnDefaultValue)
+        {
+            switch (errorStrategy)
+            {
+                case RuleErrorStrategy.ReturnDefaultValue:
+                case RuleErrorStrategy.ReturnInvalid:
+                case RuleErrorStrategy.ReturnValid:
+                    break;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(errorStrategy));
+            }
+
+            return new Rule<I>(ruleFunction, errorStrategy);
+        }
+    }
+}