DataAnnotations and INotifyDataErrorInfo provides an easy and cleaner way to implement validations in WPF ViewModels. Unlike IDataErrorInfo, INotifyDataErrorInfo allows you to raise multiple errors (there are many more features which makes it more interesting than IDataErrorInfo including making it possible to use asynchronous validations).
This being a hands-on demonstration, we will keep the theoritical part to the minimum and hit the code at the earliest. We will begin by writing our little Model class, which would be used for demonstration.
public class Model
{
[Required(ErrorMessage = "Name cannot be empty")]
[StringLength(9, MinimumLength = 3, ErrorMessage = "Name should have min 3 characters and max 9")]
public string Name { get; set; }
[Required]
[Range(0,100,ErrorMessage = "Age should be between 1 and 100")]
public int Age { get; set; }
}
Not too much to explain there. We have used the DataAnnotationAttribute to specify requirements of each property. We will now define a View to display this model. We will get to the ViewModel last, because thats where the trick lies.
<Grid>
<StackPanel>
<Grid Margin="10">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="3*"/>
<ColumnDefinition Width="7*"/>
</Grid.ColumnDefinitions>
<Label Content="Name"/>
<TextBox Grid.Column="1" Text="{Binding Name, UpdateSourceTrigger=PropertyChanged, ValidatesOnNotifyDataErrors=True}" >
<Validation.ErrorTemplate>
<ControlTemplate>
<StackPanel>
<AdornedElementPlaceholder x:Name="textBox"/>
<TextBlock Text="{Binding [0].ErrorContent}" Foreground="Red"/>
</StackPanel>
</ControlTemplate>
</Validation.ErrorTemplate>
</TextBox>
</Grid>
<Grid Margin="10">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="3*"/>
<ColumnDefinition Width="7*"/>
</Grid.ColumnDefinitions>
The most significant part here is of course the property ValidatesOnNotifyDataErrors being set to true. Additionally I have also used ErrorTemplate to display the error but that is more of an implementation detail for this particular demo, you could opt for the default template or choose another that suits your needs.
The next task obiovusly would be to implement the INotifyDataErrorInfo property in your ViewModel. The INotifyDataErrorInfo is defined as following.
public interface INotifyDataErrorInfo
{
bool HasErrors { get; }
event EventHandler<DataErrorsChangedEventArgs>? ErrorsChanged;
IEnumerable GetErrors(string? propertyName);
}
As noticed, the interface comprises mainly of a property,method and event.
HasErrors: Indicates a value whether the current entity has Validation errors. This is a read-only property.GetErrors: A Method which retrieves all the validation errors for the given Property. The property name is passed via parameter.ErrorsChanged: This event would be raised each time the Validation errors has changed for a particular property or for the Entity as a whole.
Let us go ahead and implement our view model. We will use a dictionary to store the errors.
private IDictionary<string, List<string>> _errors = new Dictionary<string, List<string>>();
The next step is to create our Properties.
private Model _model = new ();
public string Title => "Data Annotation and INotifyDataErrorInfo";
public string Name
{
get => _model.Name;
set
{
if (Equals(_model.Name, value)) return;
_model.Name = value;
NotifyOfPropertyChange();
Validate(value);
}
}
public int Age
{
get => _model.Age;
set
{
if (_model.Age == value) return;
_model.Age = value;
NotifyOfPropertyChange();
Validate(value);
}
}
Notice a method Validate is being invoked each time a property changes. This method is responsible for validating the property and maintaining the dictionary of errors.
The implementation of Validate looks like following.
private void Validate(object val, [CallerMemberName] string propertyName = null)
{
if (_errors.ContainsKey(propertyName)) _errors.Remove(propertyName);
ValidationContext context = new ValidationContext(_model) { MemberName = propertyName };
List<ValidationResult> results = new();
if (!Validator.TryValidateProperty(val, context, results))
{
_errors[propertyName] = results.Select(x => x.ErrorMessage).ToList();
}
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
}
What remains now is to impement our interface, which is pretty straightforward.
public bool HasErrors => _errors.Any();
public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;
public IEnumerable GetErrors(string propertyName)
{
return _errors.ContainsKey(propertyName) ? _errors[propertyName] : null;
}
The complete ViewModel looks like following.
public class DataAnnotionViewModel : ViewModelBase, INotifyDataErrorInfo
{
private IDictionary<string, List<string>> _errors = new Dictionary<string, List<string>>();
private Model _model = new ();
public string Title => "Data Annotation and INotifyDataErrorInfo";
public string Name
{
get => _model.Name;
set
{
if (Equals(_model.Name, value)) return;
_model.Name = value;
NotifyOfPropertyChange();
Validate(value);
}
}
public int Age
{
get => _model.Age;
set
{
if (_model.Age == value) return;
_model.Age = value;
NotifyOfPropertyChange();
Validate(value);
}
}
private void Validate(object val, [CallerMemberName] string propertyName = null)
{
if (_errors.ContainsKey(propertyName)) _errors.Remove(propertyName);
ValidationContext context = new ValidationContext(_model) { MemberName = propertyName };
List<ValidationResult> results = new();
if (!Validator.TryValidateProperty(val, context, results))
{
_errors[propertyName] = results.Select(x => x.ErrorMessage).ToList();
}
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
}
public bool HasErrors => _errors.Any();
public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;
public IEnumerable GetErrors(string propertyName)
{
return _errors.ContainsKey(propertyName) ? _errors[propertyName] : null;
}
}
That’s all you need for Validating your ViewModels using DataAnnotationAttribute and INotifyDataErrorInfo. The complete code sample is available in my Github here.
