Najlepszym rozwiązaniem jest walidacja na poziomie klas modelu danych, a nie kontrolek. Dzięki temu raz utworzone reguły będą sprawdzane w każdym miejscu aplikacji, gdy tylko użytkownik będzie wprowadzał dane.

W tym celu możemy zaimplementować interfejs IDataErrorInfo o następującej strukturze:

    // Summary:
    //     Provides the functionality to offer custom error information that a user
    //     interface can bind to.
    public interface IDataErrorInfo
    {
        // Summary:
        //     Gets an error message indicating what is wrong with this object.
        //
        // Returns:
        //     An error message indicating what is wrong with this object. The default is
        //     an empty string ("").
        string Error { get; }

        // Summary:
        //     Gets the error message for the property with the given name.
        //
        // Parameters:
        //   columnName:
        //     The name of the property whose error message to get.
        //
        // Returns:
        //     The error message for the property. The default is an empty string ("").
        string this[string columnName] { get; }
    }

Przykład implementacji:

public class Customer : IDataErrorInfo
{
    public string Name{get;set;}
    public string Email { get; set; }
    public decimal Balance{get;set;

    string IDataErrorInfo.this[string propertyName]
    {
        get
        {
            if(propertyName=="Name")
            {
                if(String.IsNullOrEmpty(Name))
                {
                    return "Name is required.";
                }
            }
            return null;
        }
    }

    string IDataErrorInfo.Error
    {
        get
        {
            if(Balance < 100 || Balance > 300)
            {
                return "Balance must be beetween 100 and 300.";
            }
            return null;
        }
    }
}

Jednak ten sposób implementacji ma kilka wad:

• nazwy właściwości są wpisywane ręcznie, więc łatwo o pomyłkę, a w konsekwencji błąd w aplikacji
• wszystkie walidacje są w jednym miejscu, więc przy skomplikowanych regułach można się pogubić

Aby uniknąć tych problemów, proponuję zastosować świetną bibliotekę FluentValidation, dostępną w postaci paczki nuget.

Zanim jednak ruszymy do dzieła, przygotowałem implementację interfejsu IDataErrorInfo w klasie bazowej:

  public abstract class Base : IDataErrorInfo, INotifyPropertyChanged
    {
        protected IValidator validator = null;


        public string Error
        {
            get 
            {
             
                if (validator!=null)
                {
                    var results = validator.Validate(this);

                    return GetErrors(results);

                }

                return string.Empty;
                
            }
        }

        private static string GetErrors(FluentValidation.Results.ValidationResult results)
        {
            if (results != null && results.Errors.Any())
            {
                var errors = string.Join(Environment.NewLine, results.Errors.Select(x => x.ErrorMessage).ToArray());
                return errors;
            }
            else
                return string.Empty;

        
        }


        public string this[string columnName]
        {
            get { return InputValidation(columnName); }
        }


        private string InputValidation(string propertyName)
        {
            List<string> properties = new List<string>();
            properties.Add(propertyName);

            if (validator != null)
            {
                var results = validator.Validate
                    (new ValidationContext(this, new PropertyChain(), new MemberNameValidatorSelector(properties)));

                return GetErrors(results);
            }

            return string.Empty;

        }

     

        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void OnPropertyChanged(string propertyName)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
        }
    }

Następnie musimy utworzyć klasę walidacji:

 public class CustomerValidator : AbstractValidator<Customer>
    {
        public CustomerValidator()
        {
            RuleFor(customer => customer.Name)
                .NotEmpty();

            RuleFor(customer => customer.Email)
               .NotEmpty();

            RuleFor(customer => customer.Balance)
                .InclusiveBetween(100, 300);
        }
    }

I przekazać jej obiekt w konstruktorze klasy Customer:

public class Customer : Base
    {

        public Customer()
        {
            validator = new CustomerValidator();
        }

        private string _email;
        private string _name;
        private decimal _balance;

        public string Name
        {
            get { return _name; }
            set
            {
                _name = value;
                OnPropertyChanged("Name");
            }
        }

        public string Email
        {
            get { return _email; }
            set
            {
                _email = value;
                OnPropertyChanged("Email");
            }
        }

        public decimal Balance
        {
            get { return _balance; }
            set
            {
                _balance = value;
                OnPropertyChanged("Balance");
            }
        }
      
    }

Pozostało nam jeszcze podpięcie mechanizmu walidacji w WPF:

<Window x:Class="ValidationDemo.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:vm="clr-namespace:ValidationDemo.ViewModels"
        Title="MainWindow" Height="350" Width="700">

    <Window.DataContext>
        <vm:CustomerViewModel />
    </Window.DataContext>
    
    <Window.Resources>
        <ControlTemplate x:Key="ErrorTemplate">
            <StackPanel Orientation="Horizontal">
                <AdornedElementPlaceholder />
                <TextBlock Margin="0" Text="{Binding [0].ErrorContent}" Foreground="Red"/>
            </StackPanel>
        </ControlTemplate>

        <Style TargetType="TextBox">
            
            <Setter Property="Width" Value="200"/>

            <Setter Property="Margin" Value="20"/>

            <Setter Property="Validation.ErrorTemplate" Value="{StaticResource ErrorTemplate}" />
        </Style>
    </Window.Resources>
    <Grid>
        <StackPanel>

            <TextBox Text="{Binding Customer.Name, UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=True}" />

            <TextBox Text="{Binding Customer.Email, UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=True}"  />

            <TextBox Text="{Binding Customer.Balance, UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=True}"  />

            
        </StackPanel>
    </Grid>
</Window>