基于条件的WPF Binding.ValidationRules

Question

I currently have TextBox with a Binding.ValidationRules that work like;

<TextBox>
    <Binding Path="MyID" NotifyOnValidationError="True" ValidatesOnDataErrors="True" 
             Mode="TwoWay" UpdateSourceTrigger="PropertyChanged" NotifyOnSourceUpdated="True" 
             NotifyOnTargetUpdated="True" Delay="100">
        <Binding.ValidationRules>
            <local:IDValidator ValidatesOnTargetUpdated="True" table="Items"  />
        </Binding.ValidationRules>
    </Binding>
</TextBox>

And the custom ValidationRule :

public class IDValidator : ValidationRule
{
    public string table { get; set; }

    public override ValidationResult Validate(object value, System.Globalization.CultureInfo cultureInfo)
    {
        //Logic
    }
}

Problem is under certain conditions I would want IDValidator to be the ValidationRule . Other times I may want say IDValidator2 to be the ValidationRule .

Now I couldn't find a way to accomplish this. So I figured hey why not send another value down to IDValidator and then handle it in the logic of Validate like this:

XMAL update:

<local:IDValidator ValidatesOnTargetUpdated="True" table="Items" testing="{Binding Path=test}"  />

IDValidator update:

public string testing { get; set; }

Problem is that doesn't seem to like sending a bind value down. How can I accomplish this?

Answer 1

This is doable, but it is not very simple and has some gotchas that you may not expect. The underlying issue is that dynamic bindings can only be applied on objects that derive from DependencyObject . ValidationRule is not such an object. However, we can add a property to a custom ValidationRule that exposes a class that does derive from DependencyObject . An example will help explain:

public class IDValidator : ValidationRule
{
    private IDValidatorRange _range;

    public int MinLength { get; set; }

    public int MaxLength { get; set; }

    public IDValidatorRange Range
    {
        get { return _range; }
        set
        {
            _range = value;
            value?.SetValidator(this);
        }
    }

    public override ValidationResult Validate(object value, CultureInfo cultureInfo)
    {
        // Logic
    }
}

Note the IDValidatorRange object returned from the Range property. You will need to create this class using DependencyProperties with a mechanism for updating the IDValidator rule properties. Here is an example of such a class:

public class IDValidatorRange : Freezable
{
    public static readonly DependencyProperty MinLengthProperty = DependencyProperty.Register(
        "MinLength", typeof (int), typeof (IDValidatorRange), new FrameworkPropertyMetadata(5, OnMinLengthChanged));

    public static readonly DependencyProperty MaxLengthProperty = DependencyProperty.Register(
        "MaxLength", typeof (int), typeof (IDValidatorRange), new FrameworkPropertyMetadata(10, OnMaxLengthChanged));

    public void SetValidator(IDValidator validator)
    {
        Validator = validator;
        if (validator != null)
        {
            validator.MinLength = MinLength;
            validator.MaxLength = MaxLength;
        }
    }

    public int MaxLength
    {
        get { return (int) GetValue(MaxLengthProperty); }
        set { SetValue(MaxLengthProperty, value); }
    }

    public int MinLength
    {
        get { return (int) GetValue(MinLengthProperty); }
        set { SetValue(MinLengthProperty, value); }
    }

    private IDValidator Validator { get; set; }

    private static void OnMaxLengthChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var range = (IDValidatorRange) d;
        if (range.Validator != null)
        {
            range.Validator.MaxLength = (int) e.NewValue;
        }
    }

    private static void OnMinLengthChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var range = (IDValidatorRange) d;
        if (range.Validator != null)
        {
            range.Validator.MinLength = (int) e.NewValue;
        }
    }

    protected override Freezable CreateInstanceCore()
    {
        return new IDValidatorRange();
    }
}

You can see that I derived from Freezable instead of its ancestor DependencyObject because we will want to inherit a DataContext for our bindings. DependencyObject does not provide this but Freezable does.

Finally, we can put this all together in XAML like such:

    <TextBox>
        <TextBox.Resources>
            <local:IDValidatorRange x:Key="ValidatorRange"
                                    MaxLength="{Binding MaxLength}"
                                    MinLength="{Binding MinLength}" />
        </TextBox.Resources>
        <TextBox.Text>
            <Binding Delay="100"
                     Mode="TwoWay"
                     NotifyOnSourceUpdated="True"
                     NotifyOnTargetUpdated="True"
                     NotifyOnValidationError="True"
                     Path="ID"
                     UpdateSourceTrigger="PropertyChanged"
                     ValidatesOnDataErrors="True">
                <Binding.ValidationRules>
                    <local:IDValidator Range="{StaticResource ValidatorRange}" />
                </Binding.ValidationRules>
            </Binding>
        </TextBox.Text>
    </TextBox>

One last gotcha here, because validation rules do not hold or inherit a DataContext this will prevent binding from working as expected if you try to declare everything inline with your rule. Instead, declare your bindable rule options as a resource and set the property on your custom rule using a StaticBinding .

This approach is a lot of work and a bit confusing. If your hands are not tied with the data context, I would recommend exploring other options. Using the INotifyDataErrorInfo interface on a view-model may be a more elegant approach to this problem.