Question

I’m trying to implement elegant form validation in a C# / WPF / Entity Framework 4.0 application. I have a classic form (some textboxes and checkboxes) and a save button.
I only want to update the source (and database) when the user presses save, and I also only want to run the form validation when the user presses save.

I set all my bindings with the parameter UpdateSourceTrigger=Explicit. I also placed all the bindings within a BindingGroup.

When the user presses save I trigger the UpdateSources method of the binding group – this triggers UpdateSource on each binding. At this point (before the source update completes) I want the form validation to take place and errors to be highlighted in the GUI. If there are no input errors then the update should be free to go through.

I thought I could achieve this by implementing IDataErrorInfo on the EntityObject the fields are bound to, and setting the parameter ValidatesOnDataErrors=True on all my bindings.

Unfortunately this does not work because as explained here:
MSDN Databinding Overview – Data Validation
under the heading “Validation Process”

5) The binding engine sets the source property.

6) …… This is the point when bindings that have the ValidatesOnDataErrors set to true are checked.

This seems really stupid to me – why would you want to validate the data after it has already been “committed” to the object? I’ve been searching for hours for a way to get the behavior I want… Has someone done something like this before?

So the main question is:
How can I validate the input BEFORE the source is updated and cancel the update if the validation fails?

Answer 1

Value has to be commited to the object because IDataErrorInfo uses only propertyName to retrieve error for a specific property. There is no way to pass proposed value (that should be validated) to it, so only commited property value can be used.

I consider this to be a good approach because view model and view are always synchronized, even if properties have invalid values and invalid value state is preserved in view model so additional logic, based on that information, can be contained in view model and not view.

If you want to propagate proposed value validation to view model you are going to have to do it with your own custom interface and validation rule.

Here is how I accomplished it:

IProposedValueErrorInfo.cs

using System.Globalization;

namespace WpfApplication
{
    public interface IProposedValueErrorInfo
    {
        object GetError(string propertyName, object value, CultureInfo cultureInfo);
    }
}

ProposedValueErrorValidationRule.cs

using System;
using System.Globalization;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;

namespace WpfApplication
{
    internal sealed class ProposedValueErrorValidationRule : ValidationRule
    {
        private readonly DependencyObject targetObject;
        private readonly DependencyProperty targetProperty;

        public ProposedValueErrorValidationRule(DependencyObject targetObject, DependencyProperty targetProperty)
            : base(ValidationStep.RawProposedValue, true)
        {
            if (targetObject == null)
                throw new ArgumentNullException("targetObject");
            if (targetProperty == null)
                throw new ArgumentNullException("targetProperty");

            this.targetObject = targetObject;
            this.targetProperty = targetProperty;
        }

        public override ValidationResult Validate(object value, CultureInfo cultureInfo)
        {
            var expression = BindingOperations.GetBindingExpression(this.targetObject, this.targetProperty);
            if (expression != null)
            {
                var sourceItem = expression.DataItem as IProposedValueErrorInfo;
                if (sourceItem != null)
                {
                    var propertyName = expression.ParentBinding.Path != null ? expression.ParentBinding.Path.Path : null;
                    if (propertyName != null)
                    {
                        var error = sourceItem.GetError(propertyName, value, cultureInfo);
                        if (error != null)
                            return new ValidationResult(false, error);
                    }
                }
            }
            return ValidationResult.ValidResult;
        }
    }
}

ProposedValueValidationBindingExtension.cs

using System;
using System.Windows;
using System.Windows.Data;
using System.Windows.Markup;

namespace WpfApplication
{
    public sealed class ProposedValueValidationBindingExtension : MarkupExtension
    {
        private readonly Binding binding;

        public ProposedValueValidationBindingExtension(Binding binding)
        {
            if (binding == null)
                throw new ArgumentNullException("binding");

            this.binding = binding;
        }

        public override object ProvideValue(IServiceProvider serviceProvider)
        {
            var provideValueTarget = serviceProvider != null ? serviceProvider.GetService(typeof(IProvideValueTarget)) as IProvideValueTarget : null;
            if (provideValueTarget != null)
                this.binding.ValidationRules.Add(new ProposedValueErrorValidationRule(provideValueTarget.TargetObject as DependencyObject, provideValueTarget.TargetProperty as DependencyProperty));

            return this.binding.ProvideValue(serviceProvider);
        }
    }
}

Person.cs

using System.Globalization;

namespace WpfApplication
{
    public class Person : IProposedValueErrorInfo
    {
        public int Age { get; set; }
        public string Surname { get; set; }

        #region IProposedValueErrorInfo Members

        object IProposedValueErrorInfo.GetError(string propertyName, object value, CultureInfo cultureInfo)
        {
            switch (propertyName)
            {
                case "Age":
                    int dummy;
                    return value is int || int.TryParse(value as string, NumberStyles.Integer, cultureInfo, out dummy) ? null : "Age must be a number.";
            }

            return null;
        }

        #endregion
    }
}

MainWindow.xaml

<Window x:Class="WpfApplication.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:WpfApplication"
        Title="MainWindow" Height="350" Width="525">
    <Window.DataContext>
        <local:Person Age="16"/>
    </Window.DataContext>
    <StackPanel>
        <TextBox Text="{local:ProposedValueValidationBinding {Binding Age}}" ToolTip="{Binding Path='(Validation.Errors)/ErrorContent', RelativeSource={RelativeSource Self}}"/>
        <TextBox Text="{local:ProposedValueValidationBinding {Binding Age}}" ToolTip="{Binding Path='(Validation.Errors)/ErrorContent', RelativeSource={RelativeSource Self}}"/>
    </StackPanel>
</Window>