How to get the result of a ValidationResult method, inside ViewModel? (True / False)

Question

I have an (part of) XAML file like this

                                <TextBox.Text>
                                    <Binding Path="MyProperty"
                                             UpdateSourceTrigger="PropertyChanged"
                                             TargetNullValue="">
                                        <Binding.ValidationRules>
                                            <validation:IntRangeRule Min="-999"
                                                                     Max="999" />
                                        </Binding.ValidationRules>
                                    </Binding>
                                </TextBox.Text>

with IntRangeRule class like this

    public override ValidationResult Validate(object value, CultureInfo cultureInfo)
    {
        if (value != null)
        {
            var stringToConvert = value as string;

            if (!string.IsNullOrEmpty(stringToConvert))
            {
                Int32 number;

                bool result = Int32.TryParse(stringToConvert, NumberStyles.Integer, cultureInfo, out number);
                if (!result)
                {
                    var localizer = ServiceLocator.Current.GetInstance<IResourceLocalizer>();
                    return new ValidationResult(false, string.Format(localizer["IntValidationError"], stringToConvert, Min, Max));
                }

                if ((number < Min) || (number > Max))
                {
                    var localizer = ServiceLocator.Current.GetInstance<IResourceLocalizer>();
                    return new ValidationResult(false, string.Format(localizer["IntRangeValidationError"], Min, Max));
                }
            }
        }

        return new ValidationResult(true, 0);
    }

Since I realized that when ValidationResult has first parameter false it does not changes the MyProperty property.

So, my goal is to somehow acknowledge, inside the ViewModel, is the ValidationResult true or false, so I can use that information inside my if statement. I could not find how to do this so far.

Answer 1

Validators like that raise a routed event when there is a validation.error and another when it is fixed. As you noticed there is no transfer of data from view to viewmodel.

There is is a routed event raised which you can handle in a parent. Say in a grid or at usercontrol level.

You obviously need a way to tell the viewmodel there's an error or not.

In your parent where you handle the event you can set a dependency property which is bound to a property from your viewmodel.

This is some old code intended to give you the idea. It might not cut and paste because it's old.

In the parent grid or usercontrol, or you can make it more re-usable by putting this sort of thing in the template for a contentcontrol. Then put your ui in that control.

The following uses a command.

<Grid>
    <i:Interaction.Triggers>
        <UIlib:RoutedEventTrigger RoutedEvent="{x:Static Validation.ErrorEvent}">
            <e2c:EventToCommand
                 Command="{Binding ConversionErrorCommand, Mode=OneWay}"
                 EventArgsConverter="{StaticResource BindingErrorEventArgsConverter}"
                 PassEventArgsToCommand="True" />

Event to command is from mvvm light. I mentioned not being a cut and paste solution.

Converter

public class BindingErrorEventArgsConverter : IEventArgsConverter
{
    public object Convert(object value, object parameter)
    {
        ValidationErrorEventArgs e = (ValidationErrorEventArgs)value;
        PropertyError err = new PropertyError();
        err.PropertyName = ((System.Windows.Data.BindingExpression)(e.Error.BindingInError)).ResolvedSourcePropertyName;
        err.Error = e.Error.ErrorContent.ToString();
        // Validation.ErrorEvent fires both when an error is added AND removed
        if (e.Action == ValidationErrorEventAction.Added)
        {
            err.Added = true;
        }
        else
        {
            err.Added = false;
        }
        return err;
    }
}

Note how it's hit when adding an error and when removing an error.

Routed event trigger.

// This is necessary in order to grab the bubbling routed source changed and conversion errors
public class RoutedEventTrigger : EventTriggerBase<DependencyObject>
{
    RoutedEvent routedEvent;
    public RoutedEvent RoutedEvent
    {
        get
        {
            return routedEvent;
        }
        set
        {
            routedEvent = value;
        }
    }

    public RoutedEventTrigger()
    {
    }
    protected override void OnAttached()
    {
        Behavior behavior = base.AssociatedObject as Behavior;
        FrameworkElement associatedElement = base.AssociatedObject as FrameworkElement;
        if (behavior != null)
        {
            associatedElement = ((IAttachedObject)behavior).AssociatedObject as FrameworkElement;
        }
        if (associatedElement == null)
        {
            throw new ArgumentException("This only works with framework elements");
        }
        if (RoutedEvent != null)
        {
            associatedElement.AddHandler(RoutedEvent, new RoutedEventHandler(this.OnRoutedEvent));
        }
    }
    void OnRoutedEvent(object sender, RoutedEventArgs args)
    {
        base.OnEvent(args);
        args.Handled = true;
    }
    protected override string GetEventName()
    {
        return RoutedEvent.Name;
    }
}

Answer 2

Here is a Behavior implementation to bind any property (including read-only).

using Microsoft.Xaml.Behaviors;
using System;
using System.ComponentModel;
using System.Windows;
using System.Windows.Data;
 
namespace CustomBehaviors
{
    /// <summary>To create a binding from any <see cref="DependencyProperty"/>,
    /// including "read-only".</summary>
    public class ReadOnlyBinding : Behavior<DependencyObject>
    {
 
        private bool isSeal;
        private DependencyProperty? _property;
        private BindingBase? _sourceBinding;
        public BindingBase? SourceBinding
        {
            get => _sourceBinding;
            set
            {
                if (isSeal)
                    throw new InvalidOperationException("Sealed!");
                _sourceBinding = value;
                if (value is null)
                {
                    BindingOperations.ClearBinding(this, SourceProperty);
                }
                else
                {
                    BindingOperations.SetBinding(this, SourceProperty, value);
                }
            }
        }
 
 
        public DependencyProperty? Property
        {
            get => _property;
            set
            {
                if (isSeal)
                    throw new InvalidOperationException("Sealed!");
                _property = value;
            }
        }
 
        /// <summary>Hidden Dependency Property.</summary>
        private static readonly DependencyProperty SourceProperty =
            DependencyProperty.Register("Source", typeof(object), typeof(ReadOnlyBinding), new PropertyMetadata(null));
 
 
        protected override void OnAttached()
        {
            isSeal = true;
            if (Property is null)
                throw new NullReferenceException(nameof(Property));
 
            base.OnAttached();
 
            DependencyPropertyDescriptor
                .FromProperty(Property, AssociatedObject.GetType())
                .AddValueChanged(AssociatedObject, OnPropertyValueChanged);
            OnPropertyValueChanged(AssociatedObject, EventArgs.Empty);
        }
 
        private void OnPropertyValueChanged(object? sender, EventArgs e)
        {
            SetValue(SourceProperty, AssociatedObject.GetValue(Property));
        }
 
        protected override void OnDetaching()
        {
            base.OnDetaching();
            DependencyPropertyDescriptor
                .FromProperty(Property, AssociatedObject.GetType())
                .RemoveValueChanged(AssociatedObject, OnPropertyValueChanged);
        }
 
    }
}

Its use for your example:

        <TextBox ....>
            <i:Interaction.Behaviors>
                <cbs:ReadOnlyBinding  SourceBinding="{Binding SomePropertyOfViewModel, Mode=TwoWay}"
                                      Property="Validation.HasError"/>
            </i:Interaction.Behaviors>
            <TextBox.Text>
                <Binding Path="MyProperty"
                         UpdateSourceTrigger="PropertyChanged"
                         TargetNullValue="">