Need help with MvvmValidation?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

146 Stars 22 Forks MIT License 230 Commits 7 Opened issues


Lightweight library that helps reduce boilerplate when implementing validation in XAML MVVM applications

Services available


Need anything else?

Contributors list

# 265,417
164 commits
# 628,788
4 commits

Build status

MVVM Validation Helpers

MVVM Validation Helpers is a lightweight library that makes it easier for developers to implement validation in MVVM applications.

It allows you to: * Define and keep all your validation rules conveniently in one place. * Reduce boilerplate of maintaining error list for each of the validation targets (properties). * Validate a target and get the validation result back without worrying what rules need to be checked. * Easily implement

interface in your view models to integrate with XAML binding engine for displaying validation errors in your views (see

Getting Started

Install the NuGet package.


Download the binaries from Releases.


Creating an instance of the helper

In order to use the library you need to create an instance of the

helper class and store it in an instance field of the class where you want to implement validation. If you do a lot of validation, it is probably the best to do it in your
class. ```cs public class ViewModelBase { public ViewModelBase() { Validator = new ValidationHelper(); }
protected ValidationHelper Validator { get; private set; }


**Adding a simple validation rule**
cs Validator.AddRule(nameof(FirstName), () => RuleResult.Assert(!string.IsNullOrEmpty(FirstName), "First Name is required"));
cs Validator.AddRequiredRule(() => FirstName, "First Name is required"); ``` Adding a rule that depends on two different properties

Such a rule will be executed whenever you validate either of those properties.

                  () => RuleResult.Assert(RangeEnd > RangeStart, 
                                          "RangeEnd must be grater than RangeStart");
Adding an asynchronous rule

Such rule can perform more complex validation that may take long time or cannot be executed synchronously, for example, a call to a web service. ```cs Validator.AddAsyncRule(nameof(UserName), async () => { var isAvailable = await UserRegistrationService.IsUserNameAvailable(UserName).ToTask();

    return RuleResult.Assert(isAvailable, 
        string.Format("User Name {0} is taken. Please choose a different one.", UserName));
**Executing validation**
// Validate all (execute all validation rules)
ValidationResult validationResult = Validator.ValidateAll();

// Validate a specific target ValidationResult validationResult = Validator.Validate(nameof(FirstName));

Executing validation asynchronously ```cs // Validate all (execute all validation rules) ValidationResult validationResult = await Validator.ValidateAllAsync();

// Validate a specific target ValidationResult validationResult = await Validator.ValidateAsync(nameof(FirstName)); ``` Getting current validation state at any point of time

Any time you can request current validation state for the entire object or for specific validation targets. ```cs // Get validation result for the entire object var validationResult = Validator.GetResult();

// Get validation result for a target var firstNameValidationResult = Validator.GetResult(nameof(FirstName));

**Receive notifications when validation result changes**
cs Validator.ResultChanged += OnValidationResultChanged;

private void OnValidationResultChanged(object sender, ValidationResultChangedEventArgs e) { // Get current state of the validation ValidationResult validationResult = Validator.GetResult();


} ``

INotifyDataErrorInfo` interface**

The library includes

class that makes the implementation of
interface in your view models trivial.
public class ValidatableViewModelBase : INotifyDataErrorInfo
    protected ValidationHelper Validator { get; private set; }
    private NotifyDataErrorInfoAdapter NotifyDataErrorInfoAdapter { get; set; }

public ValidatableViewModelBase()
    Validator = new ValidationHelper();

    NotifyDataErrorInfoAdapter = new NotifyDataErrorInfoAdapter(Validator);

public IEnumerable GetErrors(string propertyName)
    return NotifyDataErrorInfoAdapter.GetErrors(propertyName);

public bool HasErrors
    get { return NotifyDataErrorInfoAdapter.HasErrors; }

public event EventHandler<dataerrorschangedeventargs> ErrorsChanged
    add { NotifyDataErrorInfoAdapter.ErrorsChanged += value; }
    remove { NotifyDataErrorInfoAdapter.ErrorsChanged -= value; }


For more examples download the source code and check out the example project.

Sample UI Screenshot

Advanced Use Cases

Execute rules even if the target is already invalid

By default, if the first rule for the target failed, the remaining rules for that target are skipped. For example, if the "Email" field is required it doesn't make sense to check that the email address is in valid format until user has entered something, so first we execute the "required" rule and only if it succeds we execute the next rule to verify the format of the email.

This default behavior can be overriden either globally or per rule:


Validator = new ValidationHelper(new ValidationSettings
    DefaultRuleSettings = new ValidationRuleSettings
        ExecuteOnAlreadyInvalidTarget = true

Per Rule:

Validator.AddAsyncRule(/* Rule */)
         .WithSettings(s => s.ExecuteOnAlreadyInvalidTarget = false);

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.