Now let’s rewrite our BindingModel class, we will inherit it from interface IDataErrorInfo and will implement it:

The main properties for our BindingModel will look like this:

Each call of VaidationRule checks some condition, and if it not true, then write info about this validation error in errors collection. After binding Silverlight infrastructure will call get method of indexing property this[string columnName] and it will return error information for this property (columnName). We should set property ValidatesOnDataErrors in our binding to true if we want to use this kind of validation. Property Error throw NotImplementedException because Silverlight doesn’t use it. Quotation from MSDN: “Note that the binding engine never uses the Error property, although you can use it in custom error reporting to display object-level errors.”

In end we should implement again methods for command:

We again should use CanChangePassword method, because we need to set button to disabled state when object is invalid. We can’t check valid state of whole object before binding happened. Another problem with this realization: we should write validation rules twice: in property set methods and at CanChangePassword method. But this is problem of this realization; you can solve it with another realization: you can write some class ValidationHandler, which will store not only validation errors, but validation rules, so you can raise validation check in CanChangePassword method. But we still have a problem, we can’t tell to ValidationSummary or some other control at our interface that some validation errors happened or disappeared without binging.

Also you can use DataAnnotation for this approach, but you should write some helper method for that, I will tell you how in next example.

Result of IDataErrorInfo realization (Silverlight sample):

I think that behavior of this sample the same like in previous part. I want to say that this sample has bug, if user will input Password Confirmation first and then New Password, he will see validation error about password confirmation not equal, because this check happened only on NewPasswordConfirmation binding. 

INotifyDataErrorInfo

The INotifyDataErrorInfointerface came with Silverlight 4 too. The main advantage of this interface you can do synchronous (like in previous samples) and asynchronous validation too. You can wait validation from server, and only after that tell to interface that all ok or some validation error occurred. I like this way of validation more than other. I will use some classes and realization from articles of Davy Brion about “MVP In Silverlight/WPF Series”.

First I got class PropertyValidation, with it we will store validation rule for properties and message which should be showed when validation error occurred.

where TBindingModel : BindingModelBase { private Func _validationCriteria; private string _errorMessage; private readonly string _propertyName; public PropertyValidation(string propertyName) { _propertyName = propertyName; } public PropertyValidation When(Func validationCriteria) { if (_validationCriteria != null) throw new InvalidOperationException("You can only set the validation criteria once."); _validationCriteria = validationCriteria; return this; } public PropertyValidation Show(string errorMessage) { if (_errorMessage != null) throw new InvalidOperationException("You can only set the message once."); _errorMessage = errorMessage; return this; } public bool IsInvalid(TBindingModel presentationModel) { if (_validationCriteria == null) throw new InvalidOperationException( "No criteria have been provided for this validation. (Use the 'When(..)' method.)"); return _validationCriteria(presentationModel); } public string GetErrorMessage() { if (_errorMessage == null) throw new InvalidOperationException( "No error message has been set for this validation. (Use the 'Show(..)' method.)"); return _errorMessage; } public string PropertyName { get { return _propertyName; } } } ```

You will understand how it works when we will start implement validation rules in our example. This class has generic parameter with base class BindingModelBase<T>, from which we will inherit our main BindingModel class.

Let’s implement BindingModelBase class, we will inherit it from INotifyPropertyChanged and INotifyDataErrorInfo interfaces, and will add two fields, one for store validation rules and one for store validation errors:

```csharp public abstract class BindingModelBase : INotifyPropertyChanged, INotifyDataErrorInfo where TBindingModel : BindingModelBase { private readonly List> _validations = new List>(); private Dictionary> _errorMessages = new Dictionary>(); #region INotifyDataErrorInfo public IEnumerable GetErrors(string propertyName) { if (_errorMessages.ContainsKey(propertyName)) return _errorMessages[propertyName]; return new string[0]; } public bool HasErrors { get { return _errorMessages.Count > 0; } } public event EventHandler ErrorsChanged = delegate { }; private void OnErrorsChanged(string propertyName) { ErrorsChanged(this, new DataErrorsChangedEventArgs(propertyName)); } #endregion #region INotifyPropertyChanged public event PropertyChangedEventHandler PropertyChanged = delegate { }; protected void OnPropertyChanged(string propertyName) { PropertyChanged(this, new PropertyChangedEventArgs(propertyName)); } #endregion } ```

Also I want to add one helper method additional to OnPropertyChanged, it will be method which has Expression in parameters and will let us to use it like this:

```csharp public string NewPassword { get { return _newPassword; } set { _newPassword = value; OnCurrentPropertyChanged(); } } ```

This method is very useful. Implementation of this method:

```csharp public string NewPassword { get { return _newPassword; } set { _newPassword = value; OnPropertyChanged(() => NewPassword); } } ```

Implementation:

```csharp protected void OnPropertyChanged(Expression> expression) { OnPropertyChanged(GetPropertyName(expression)); } private static string GetPropertyName(Expression> expression) { if (expression == null) throw new ArgumentNullException("expression"); MemberExpression memberExpression; if (expression.Body is UnaryExpression) memberExpression = ((UnaryExpression)expression.Body).Operand as MemberExpression; else memberExpression = expression.Body as MemberExpression; if (memberExpression == null) throw new ArgumentException("The expression is not a member access expression", "expression"); var property = memberExpression.Member as PropertyInfo; if (property == null) throw new ArgumentException("The member access expression does not access a property", "expression"); var getMethod = property.GetGetMethod(true); if (getMethod.IsStatic) throw new ArgumentException("The referenced property is a static property", "expression"); return memberExpression.Member.Name; } ```

Method get property name from expression. Next, let’s add some methods which will perform validation:

```csharp public void ValidateProperty(Expression> expression) { ValidateProperty(GetPropertyName(expression)); } private void ValidateProperty(string propertyName) { _errorMessages.Remove(propertyName); _validations.Where(v => v.PropertyName == propertyName).ToList().ForEach(PerformValidation); OnErrorsChanged(propertyName); OnPropertyChanged(() => HasErrors); } private void PerformValidation(PropertyValidation validation) { if (validation.IsInvalid((TBindingModel) this)) { AddErrorMessageForProperty(validation.PropertyName, validation.GetErrorMessage()); } } private void AddErrorMessageForProperty(string propertyName, string errorMessage) { if (_errorMessages.ContainsKey(propertyName)) { _errorMessages[propertyName].Add(errorMessage); } else { _errorMessages.Add(propertyName, new List {errorMessage}); } } ```

Method ValidateProperty delete information about all validation errors which was happened with current property, then check each rule for current property, and if some rule is false it will add error to errors collection. Also we can raise validation check for each property auto with PropertyChanged event:

```csharp protected BindingModelBase() { PropertyChanged += (s, e) => { if (e.PropertyName != "HasErrors") ValidateProperty(e.PropertyName); }; } ```

For easy add validation rules to our collection we will add next method:

```csharp protected PropertyValidation AddValidationFor(Expression> expression) { var validation = new PropertyValidation(GetPropertyName(expression)); _validations.Add(validation); return validation; } ```

Now we can implement BindingModel class, which we will use in our last example. If we want to implement validation with INotifyDataErrorInfo interface we should set to true property ValidatesOnNotifyDataErrorsin bindings.

BindingModel implementation:

```csharp public class BindingModel : BindingModelBase { private string _newPassword; private string _newPasswordConfirmation; public DelegateCommand ChangePasswordCommand { get; private set; } public BindingModel() { ChangePasswordCommand = new DelegateCommand(ChangePassword); AddValidationFor(() => NewPassword) .When(x => string.IsNullOrEmpty(x._newPassword)) .Show("New password required field."); AddValidationFor(() => NewPassword) .When(x => !string.IsNullOrEmpty(x._newPassword) && x._newPassword.Length > 80) .Show("New password must be a string with maximum length of 80."); AddValidationFor(() => NewPasswordConfirmation) .When(x => !string.IsNullOrEmpty(x._newPassword) && string.CompareOrdinal(x._newPassword, x._newPasswordConfirmation) != 0) .Show("Password confirmation not equal to password."); } [Display(Name = "New password")] public string NewPassword { get { return _newPassword; } set { _newPassword = value; OnPropertyChanged(() => NewPassword); } } [Display(Name = "New password confirmation")] public string NewPasswordConfirmation { get { return _newPasswordConfirmation; } set { _newPasswordConfirmation = value; OnPropertyChanged(() => NewPasswordConfirmation); } } private void ChangePassword(object obj) { throw new NotImplementedException(); } } ```

In ctor we describe all three validation rules for properties. Look’s very good (Thanks Davy Brion!). I told you that I don’t like to set disabled button, so from now it will be always enabled. For realization command’s method ChangePassword I need some method which will check all validation rules of current object, it will be ValidateAll method, which I will implement in BindingModelBase class:

```csharp public void ValidateAll() { var propertyNamesWithValidationErrors = _errorMessages.Keys; _errorMessages = new Dictionary>(); _validations.ForEach(PerformValidation); var propertyNamesThatMightHaveChangedValidation = _errorMessages.Keys.Union(propertyNamesWithValidationErrors).ToList(); propertyNamesThatMightHaveChangedValidation.ForEach(OnErrorsChanged); OnPropertyChanged(() => HasErrors); } ```

This method deletes all validation errors in collection. Then check validation rules, write errors if rule is false, and then raise OnErrorsChanged event for each property which has changed validation state.

Implementation of method ChangePassword:

```csharp private void ChangePassword(object obj) { ValidateAll(); if (!HasErrors) { MessageBox.Show("Bingo!"); } } ```

Result (Silverlight application):

I like this realization. It much more flexible and it can use all advantages of previous variants. What about DataAnnotation? If you like to describe validation rules with data annotation attributes I can give you one more help method for that. This method will get all rules from attributes and convert them to PropertyValidation:

```csharp protected PropertyValidation AddValidationFor(Expression> expression) { return AddValidationFor(GetPropertyName(expression)); } protected PropertyValidation AddValidationFor(string propertyName) { var validation = new PropertyValidation(propertyName); _validations.Add(validation); return validation; } protected void AddAllAttributeValidators() { PropertyInfo[] propertyInfos = GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance); foreach (PropertyInfo propertyInfo in propertyInfos) { Attribute[] custom = Attribute.GetCustomAttributes(propertyInfo, typeof(ValidationAttribute), true); foreach (var attribute in custom) { var property = propertyInfo; var validationAttribute = attribute as ValidationAttribute; if (validationAttribute == null) throw new NotSupportedException("validationAttribute variable should be inherited from ValidationAttribute type"); string name = property.Name; var displayAttribute = Attribute.GetCustomAttributes(propertyInfo, typeof(DisplayAttribute)).FirstOrDefault() as DisplayAttribute; if (displayAttribute != null) { name = displayAttribute.GetName(); } var message = validationAttribute.FormatErrorMessage(name); AddValidationFor(propertyInfo.Name) .When(x => { var value = property.GetGetMethod().Invoke(this, new object[] { }); var result = validationAttribute.GetValidationResult(value, new ValidationContext(this, null, null) { MemberName = property.Name }); return result != ValidationResult.Success; }) .Show(message); } } } ```

And the last BindingModel variant:

```csharp public class BindingModel : BindingModelBase { private string _newPassword; private string _newPasswordConfirmation; public DelegateCommand ChangePasswordCommand { get; private set; } public BindingModel() { ChangePasswordCommand = new DelegateCommand(ChangePassword); AddAllAttributeValidators(); AddValidationFor(() => NewPasswordConfirmation) .When(x => !string.IsNullOrEmpty(x._newPassword) && string.CompareOrdinal(x._newPassword, x._newPasswordConfirmation) != 0) .Show("Password confirmation not equal to password."); } [Display(Name = "New password")] [Required] [StringLength(80, ErrorMessage = "New password must be a string with maximum length of 80.")] public string NewPassword { get { return _newPassword; } set { _newPassword = value; OnPropertyChanged(() => NewPassword); } } [Display(Name = "New password confirmation")] public string NewPasswordConfirmation { get { return _newPasswordConfirmation; } set { _newPasswordConfirmation = value; OnPropertyChanged(() => NewPasswordConfirmation); } } private void ChangePassword(object obj) { ValidateAll(); if (!HasErrors) { MessageBox.Show("Bingo!"); } } } ```

Source code of these samples you can download from my assembla.com repository.

See Also

• Silverlight basics. Validation. Part 1. DataAnnotations & ValidatesOnExceptions
• Silverlight. Основы. Валидация. Часть 2. IDataErrorInfo & INotifyDataErrorInfo
• Silverlight. Основы. Валидация. Часть 1. DataAnnotations & ValidatesOnExceptions
• Как часто вы думаете о том, что пользователь может нажать Double-Click, где это не предусмотрено?
• Никогда не делайте классы и пространства имен с одним и тем же именем