FluentValidation Wiki & Documentation Rss Feed

Updated Wiki: Customising

JeremyS — Mon, 13 May 2013 16:02:37 GMT

Overriding the Default Error

You can override the default error message for a validator by calling the WithMessage method on a validator definition:

RuleFor(customer => customer.Surname).NotNull().WithMessage("Please ensure that you have entered your Surname");

Note that custom error messages can contain placeholders for special values such as the name of the property being validated. This means the above error message could be re-written as:

RuleFor(customer => customer.Surname).NotNull().WithMessage("Please ensure you have entered your {PropertyName}");

...and the value 'Surname' will be inserted. For a complete list of error message placeholders see the Validators page.

It is also possible to use your own custom arguments in the validation message. These can either be static values or references to other properties on the object being validated:

//Using static values in a custom message:
RuleFor(customer => x.Surname).NotNull().WithMessage("This message references some static values: {0} {1}", "hello", 5);
//Result would be "This message references some static values: hello 5"

//Referencing other property values:
RuleFor(customer => customer.Surname)
  .NotNull()
  .WithMesasge("This message references some other properties: Forename: {0} Discount: {1}", 
    customer => customer.Forename, 
    customer => customer.Discount
  );
//Result would be: "This message references some other properties: Forename: Jeremy Discount: 100"

If you want to override all of FluentValidation's default error messages, check out FluentValidation's support for Localization

Overriding the Default Property Name

The default validation error messages contain the property name being validated. For example, if you were to define a validator like this:

RuleFor(customer => customer.Surname).NotNull();

...then the default error message would be 'Surname' must not be empty. Although you can override the entire error message by calling WithMessage, you can also replace just the property name by calling WithName:

RuleFor(customer => customer.Surname).NotNull().WithName("Last name");

Now the error message would be 'Last name' must not be empty.

Note that this only replaces the name of the property in the error message. When you inspect the Errors collection on the ValidationResult, this error will still be associated with a property called "Surname". If you want to completely rename the property, you can use the WithPropertyName method instead.

Property name resolution is also pluggable. By default, the name of the property extracted from the MemberExpression passed to RuleFor. If you want change this logic, you can set the PropertyNameResolver property on the ValidatorOptions class:

ValidatorOptions.PropertyNameResolver = (type, member) => {
  if(member != null) {
     return member.Name + "Foo";
  }
  return null;
};

This is not a realistic example as it changes all properties to have the suffix "Foo", but hopefully illustrates the point.

Additionally, FluentValidation will respect the use of the DisplayName and Display attributes for generating the property's name within error messages:

public class Person {
  [Display(Name="Last name")]
  public string Surname { get; set; }
}

Specifying a condition with When/Unless

The When and Unless methods can be used to specify conditions that control when the rule should execute. For example, this rule on the CustomerDiscount property will only execute when IsPreferredCustomer is true:

RuleFor(customer => customer.CustomerDiscount).GreaterThan(0).When(customer => customer.IsPreferredCustomer);

The Unless method is simply the opposite of When.

If you need to specify the same condition for multiple rules then you can call the top-level When method instead of chaining the When call at the end of the rule:

When(customer => customer.IsPreferred, () => {
   RuleFor(customer => customer.CustomerDiscount).GreaterThan(0);
   RuleFor(customer => customer.CreditCardNumber).NotNull();
});

This time, the condition will be applied to both rules.

Setting the Cascade mode

You can set the cascade mode to customise how FluentValidation executes chained validators when a particular validator in the chain fails.

Imagine you have two validators defined as part of a single rule definition, a NotNull validator and a NotEqual validator:

RuleFor(x => x.Surname).NotNull().NotEqual("foo");

This will first check whether the Surname property is not null and then will check if it's not equal to the string "foo". If the first validator (NotNull) fails, then the call to NotEqual will still be invoked. This can be changed by specifying a cascade mode of StopOnFirstFailure:

RuleFor(x => x.Surname).Cascade(CascadeMode.StopOnFirstFailure).NotNull().NotEqual("foo");

Now, if the NotNull validator fails then the NotEqual validator will not be executed. This is particularly useful if you have a complex chain where each validator depends on the previous validator to succeed.

The two cascade modes are:

Continue (the default) - always invokes all validators in a rule definition
StopOnFirstFailure - stops executing a rule as soon as a validator fails

As well as being set at the rule level, the cascade mode can also be set globally for all validators, or for all the rules in a particular validator class.

To set the cascade mode globally, you can set the CascadeMode property on the static ValidatorOptions class during your application's startup routine:

ValidatorOptions.CascadeMode = CascadeMode.StopOnFirstFailure;

This can then be overriden by individual validator classes or by individual rules.

To set the cascade mode for all rules inside a single validator class, set the CascadeMode property on AbstractValidator:

public class PersonValidator : AbstractValidator<Person> {
  public PersonValidator() {
    
    // First set the cascade mode
    CascadeMode = CascadeMode.StopOnFirstFailure;
    
    // Rule definitions follow
    RuleFor(...) 
    RuleFor(...)

   }
}

Updated Wiki: Customising

JeremyS — Mon, 13 May 2013 16:02:24 GMT

Overriding the Default Error

You can override the default error message for a validator by calling the WithMessage method on a validator definition:

RuleFor(customer => customer.Surname).NotNull().WithMessage("Please ensure that you have entered your Surname");

Note that custom error messages can contain placeholders for special values such as the name of the property being validated. This means the above error message could be re-written as:

RuleFor(customer => customer.Surname).NotNull().WithMessage("Please ensure you have entered your {PropertyName}");

//Using static values in a custom message:
RuleFor(customer => x.Surname).NotNull().WithMessage("This message references some static values: {0} {1}", "hello", 5);
//Result would be "This message references some static values: hello 5"

//Referencing other property values:
RuleFor(customer => customer.Surname)
  .NotNull()
  .WithMesasge("This message references some other properties: Forename: {0} Discount: {1}", 
    customer => customer.Forename, 
    customer => customer.Discount
  );
//Result would be: "This message references some other properties: Forename: Jeremy Discount: 100"

If you want to override all of FluentValidation's default error messages, check out FluentValidation's support for Localization

Overriding the Default Property Name

The default validation error messages contain the property name being validated. For example, if you were to define a validator like this:

RuleFor(customer => customer.Surname).NotNull();

RuleFor(customer => customer.Surname).NotNull().WithName("Last name");

ValidatorOptions.PropertyNameResolver = (type, member) => {
  if(member != null) {
     return member.Name + "Foo";
  }
  return null;
};

Specifying a condition with When/Unless

The *When* and *Unless* methods can be used to specify conditions that control when the rule should execute. For example, this rule on the CustomerDiscount property will only execute when IsPreferredCustomer is true:

RuleFor(customer => customer.CustomerDiscount).GreaterThan(0).When(customer => customer.IsPreferredCustomer);

When(customer => customer.IsPreferred, () => {
   RuleFor(customer => customer.CustomerDiscount).GreaterThan(0);
   RuleFor(customer => customer.CreditCardNumber).NotNull();
});

This time, the condition will be applied to both rules.

Setting the Cascade mode

RuleFor(x => x.Surname).NotNull().NotEqual("foo");

RuleFor(x => x.Surname).Cascade(CascadeMode.StopOnFirstFailure).NotNull().NotEqual("foo");

Continue (the default) - always invokes all validators in a rule definition
StopOnFirstFailure - stops executing a rule as soon as a validator fails

ValidatorOptions.CascadeMode = CascadeMode.StopOnFirstFailure;

public class PersonValidator : AbstractValidator<Person> {
  public PersonValidator() {
    
    // First set the cascade mode
    CascadeMode = CascadeMode.StopOnFirstFailure;
    
    // Rule definitions follow
    RuleFor(...) 
    RuleFor(...)

   }
}

Updated Wiki: Customising

JeremyS — Mon, 13 May 2013 16:01:25 GMT

Overriding the Default Error

You can override the default error message for a validator by calling the WithMessage method on a validator definition:

RuleFor(customer => customer.Surname).NotNull().WithMessage("Please ensure that you have entered your Surname");

Note that custom error messages can contain placeholders for special values such as the name of the property being validated. This means the above error message could be re-written as:

RuleFor(customer => customer.Surname).NotNull().WithMessage("Please ensure you have entered your {PropertyName}");

//Using static values in a custom message:
RuleFor(customer => x.Surname).NotNull().WithMessage("This message references some static values: {0} {1}", "hello", 5);
//Result would be "This message references some static values: hello 5"

//Referencing other property values:
RuleFor(customer => customer.Surname)
  .NotNull()
  .WithMesasge("This message references some other properties: Forename: {0} Discount: {1}", 
    customer => customer.Forename, 
    customer => customer.Discount
  );
//Result would be: "This message references some other properties: Forename: Jeremy Discount: 100"

If you want to override all of FluentValidation's default error messages, check out FluentValidation's support for Localization

Overriding the Default Property Name

The default validation error messages contain the property name being validated. For example, if you were to define a validator like this:

RuleFor(customer => customer.Surname).NotNull();

RuleFor(customer => customer.Surname).NotNull().WithName("Last name");

ValidatorOptions.PropertyNameResolver = (type, member) => {
  if(member != null) {
     return member.Name + "Foo";
  }
  return null;
};

Specifying a condition with When/Unless

RuleFor(customer => customer.CustomerDiscount).GreaterThan(0).When(customer => customer.IsPreferredCustomer);

When(customer => customer.IsPreferred, () => {
   RuleFor(customer => customer.CustomerDiscount).GreaterThan(0);
   RuleFor(customer => customer.CreditCardNumber).NotNull();
});

This time, the condition will be applied to both rules.

Setting the Cascade mode

RuleFor(x => x.Surname).NotNull().NotEqual("foo");

RuleFor(x => x.Surname).Cascade(CascadeMode.StopOnFirstFailure).NotNull().NotEqual("foo");

Continue (the default) - always invokes all validators in a rule definition
StopOnFirstFailure - stops executing a rule as soon as a validator fails

ValidatorOptions.CascadeMode = CascadeMode.StopOnFirstFailure;

public class PersonValidator : AbstractValidator<Person> {
  public PersonValidator() {
    
    // First set the cascade mode
    CascadeMode = CascadeMode.StopOnFirstFailure;
    
    // Rule definitions follow
    RuleFor(...) 
    RuleFor(...)

   }
}

Updated Wiki: Customising

JeremyS — Mon, 13 May 2013 13:35:29 GMT

Overriding the Default Error

You can override the default error message for a validator by calling the WithMessage method on a validator definition:

RuleFor(customer => customer.Surname).NotNull().WithMessage("Please ensure that you have entered your Surname");

Note that custom error messages can contain placeholders for special values such as the name of the property being validated. This means the above error message could be re-written as:

RuleFor(customer => customer.Surname).NotNull().WithMessage("Please ensure you have entered your {PropertyName}");

//Using static values in a custom message:
RuleFor(customer => x.Surname).NotNull().WithMessage("This message references some static values: {0} {1}", "hello", 5);
//Result would be "This message references some static values: hello 5"

//Referencing other property values:
RuleFor(customer => customer.Surname)
  .NotNull()
  .WithMesasge("This message references some other properties: Forename: {0} Discount: {1}", 
    customer => customer.Forename, 
    customer => customer.Discount
  );
//Result would be: "This message references some other properties: Forename: Jeremy Discount: 100"

If you want to override all of FluentValidation's default error messages, check out FluentValidation's support for Localization

Overriding the Default Property Name

The default validation error messages contain the property name being validated. For example, if you were to define a validator like this:

RuleFor(customer => customer.Surname).NotNull();

RuleFor(customer => customer.Surname).NotNull().WithName("Last name");

ValidatorOptions.PropertyNameResolver = (type, member) => {
  if(member != null) {
     return member.Name + "Foo";
  }
  return null;
};

This is not a realistic example as it changes all properties to have the suffix "Foo", but hopefully illustrates the point.

Specifying a condition with When/Unless

RuleFor(customer => customer.CustomerDiscount).GreaterThan(0).When(customer => customer.IsPreferredCustomer);

When(customer => customer.IsPreferred, () => {
   RuleFor(customer => customer.CustomerDiscount).GreaterThan(0);
   RuleFor(customer => customer.CreditCardNumber).NotNull();
});

This time, the condition will be applied to both rules.

Setting the Cascade mode

RuleFor(x => x.Surname).NotNull().NotEqual("foo");

RuleFor(x => x.Surname).Cascade(CascadeMode.StopOnFirstFailure).NotNull().NotEqual("foo");

Continue (the default) - always invokes all validators in a rule definition
StopOnFirstFailure - stops executing a rule as soon as a validator fails

ValidatorOptions.CascadeMode = CascadeMode.StopOnFirstFailure;

public class PersonValidator : AbstractValidator<Person> {
  public PersonValidator() {
    
    // First set the cascade mode
    CascadeMode = CascadeMode.StopOnFirstFailure;
    
    // Rule definitions follow
    RuleFor(...) 
    RuleFor(...)

   }
}

Updated Wiki: Validators

JeremyS — Tue, 07 May 2013 10:29:27 GMT

Built in Validators

FluentValidation ships with several built-in validators. The error message for each validator can contain special placeholders that will be filled in when the error message is constructed.

NotNull Validator

Description: Ensures that the specified property is not null.

Example:

RuleFor(customer => customer.Surname).NotNull();

Example error: 'Surname' must not be empty.
String format args:

{PropertyName} = The name of the property being validated
{PropertyValue} = The current value of the property

NotEmpty Validator

Description: Ensures that the specified property is not null, an empty string or whitespace (or the default value for value types, eg 0 for int)

Example:

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

Example error: 'Surname' should not be empty.
String format args:

{PropertyName} = The name of the property being validated
{PropertyValue} = The current value of the property

NotEqual Validator

Description: Ensures that the value of the specified property is not equal to a particular value (or not equal to the value of another property)

Example:

//Not equal to a particular value
RuleFor(customer => customer.Surname).NotEqual("Foo");

//Not equal to another property
RuleFor(customer => customer.Surname).NotEqual(customer => customer.Forename);

Example error: 'Surname' should not be equal to 'Foo'
String format args:

{PropertyName} = The name of the property being validated
{ComparisonValue} = Value that the property should not equal

Equal Validator

Description: Ensures that the value of the specified property is equal to a particular value (or equal to the value of another property)

Example:

//Equal to a particular value
RuleFor(customer => customer.Surname).Equal("Foo");

//Equal to another property
RuleFor(customer => customer.Password).Equal(customer => customer.PasswordConfirmation);

Example error: 'Surname' should be equal to 'Foo'
String format args:

{PropertyName} = The name of the property being validated
{ComparisonValue} = Value that the property should equal
{PropertyValue} = The current value of the property

Length Validator

Description: Ensures that the length of a particular string property is within the specified range.

Example:

RuleFor(customer => customer.Surname).Length(1, 250); //must be between 1 and 250 chars (inclusive)

Example error: 'Surname' must be between 1 and 250 characters. You entered 251 characters.
Note: Only valid on string properties.
String format args:

{PropertyName} = The name of the property being validated
{MinLength} = Minimum length
{MaxLength} = Maximum length
{TotalLength} = Number of characters entered
{PropertyValue} = The current value of the property

Less Than Validator

Description: Ensures that the value of the specified property is less than a particular value (or less than the value of another property)
Example:

//Less than a particular value
RuleFor(customer => customer.CreditLimit).LessThan(100);

//Less than another property
RuleFor(customer => customer.CreditLimit).LessThan(customer => customer.MaxCreditLimit);

Example error: 'Credit Limit' must be less than 100.
Notes: Only valid on types that implement IComparable<T>
String format args:

{PropertyName} = The name of the property being validated
{ComparisonValue} - The value to which the property was compared
{PropertyValue} = The current value of the property

Less Than Or Equal Validator

Description: Ensures that the value of the specified property is less than or equal to a particular value (or less than or equal to the value of another property)
Example:

//Less than a particular value
RuleFor(customer => customer.CreditLimit).LessThanOrEqual(100);

//Less than another property
RuleFor(customer => customer.CreditLimit).LessThanOrEqual(customer => customer.MaxCreditLimit);

Example error: 'Credit Limit' must be less than or equal to 100.
Notes: Only valid on types that implement IComparable<T>

{PropertyName} = The name of the property being validated
{ComparisonValue} - The value to which the property was compared
{PropertyValue} = The current value of the property

Greater Than Validator

Description: Ensures that the value of the specified property is greater than a particular value (or greater than the value of another property)
Example:

//Greater than a particular value
RuleFor(customer => customer.CreditLimit).GreaterThan(0);

//Greater than another property
RuleFor(customer => customer.CreditLimit).GreaterThan(customer => customer.MinimumCreditLimit);

Example error: 'Credit Limit' must be greater than 0.
Notes: Only valid on types that implement IComparable<T>

{PropertyName} = The name of the property being validated
{ComparisonValue} - The value to which the property was compared
{PropertyValue} = The current value of the property

Greater Than Or Equal Validator

Description: Ensures that the value of the specified property is greater than or equal to a particular value (or greater than or equal to the value of another property)
Example:

//Greater than a particular value
RuleFor(customer => customer.CreditLimit).GreaterThanOrEqual(1);

//Greater than another property
RuleFor(customer => customer.CreditLimit).GreaterThanOrEqual(customer => customer.MinimumCreditLimit);

Example error: 'Credit Limit' must be greater than or equal to 1.
Notes: Only valid on types that implement IComparable<T>

{PropertyName} = The name of the property being validated
{ComparisonValue} - The value to which the property was compared
{PropertyValue} = The current value of the property

Predicate Validator (aka Must)

Description: Passes the value of the specified property into a custom delegate that can perform custom validation logic on the value

Example:

RuleFor(customer => customer.Surname).Must(surname => "Foo".Equals(surname));

Example error: The specified condition was not met for 'Surname'
String format args:

{PropertyName} = The name of the property being validated
{PropertyValue} = The current value of the property

Note that there is an additional overload for Must that also accepts an instance of the parent object being validated. This can be useful if you want to compare the current property with another property from inside the predicate:

RuleFor(customer => customer.Surname).Must((customer, surname) => surname != customer.Forename)

(Note that in this particular example, it would be better to use the cross-property version of NotEqual)

Regular Expression Validator

Description: Ensures that the value of the specified property matches the given regular expression.
Example:

RuleFor(customer => customer.Surname).Matches("some regex here");

Example error: 'Surname' is not in the correct format.
String format args:

{PropertyName} = The name of the property being validated
{PropertyValue} = The current value of the property

Email Validator

Description: Ensures that the value of the specified property is a valid email address format.
Example:

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

Example error: 'Email' is not a valid email address.
String format args:

{PropertyName} = The name of the property being validated
{PropertyValue} = The current value of the property

The regular expression used by the email validator can be found at http://regexlib.com/REDetails.aspx?regexp_id=1448

Updated Wiki: Validators

JeremyS — Tue, 07 May 2013 10:28:47 GMT

Built in Validators

FluentValidation ships with several built-in validators. The error message for each validator can contain special placeholders that will be filled in when the error message is constructed.

NotNull Validator

Description: Ensures that the specified property is not null.

Example:

RuleFor(customer => customer.Surname).NotNull();

Example error: 'Surname' must not be empty.
String format args:

{PropertyName} = The name of the property being validated
{PropertyValue} = The current value of the property

NotEmpty Validator

Description: Ensures that the specified property is not null, an empty string or whitespace (or the default value for value types, eg 0 for int)

Example:

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

Example error: 'Surname' should not be empty.
String format args:

{PropertyName} = The name of the property being validated
{PropertyValue} = The current value of the property

NotEqual Validator

Description: Ensures that the value of the specified property is not equal to a particular value (or not equal to the value of another property)

Example:

//Not equal to a particular value
RuleFor(customer => customer.Surname).NotEqual("Foo");

//Not equal to another property
RuleFor(customer => customer.Surname).NotEqual(customer => customer.Forename);

Example error: 'Surname' should not be equal to 'Foo'
String format args:

{PropertyName} = The name of the property being validated
{ComparisonValue} = Value that the property should not equal

Equal Validator

Description: Ensures that the value of the specified property is equal to a particular value (or equal to the value of another property)

Example:

//Equal to a particular value
RuleFor(customer => customer.Surname).Equal("Foo");

//Equal to another property
RuleFor(customer => customer.Password).Equal(customer => customer.PasswordConfirmation);

Example error: 'Surname' should be equal to 'Foo'
String format args:

{PropertyName} = The name of the property being validated
{ComparisonValue} = Value that the property should equal
{PropertyValue} = The current value of the property

Length Validator

Description: Ensures that the length of a particular string property is within the specified range.

Example:

RuleFor(customer => customer.Surname).Length(1, 250); //must be between 1 and 250 chars (inclusive)

Example error: 'Surname' must be between 1 and 250 characters. You entered 251 characters.
Note: Only valid on string properties.
String format args:

{PropertyName} = The name of the property being validated
{MinLength} = Minimum length
{MaxLength} = Maximum length
{TotalLength} = Number of characters entered
{PropertyValue} = The current value of the property

Less Than Validator

Description: Ensures that the value of the specified property is less than a particular value (or less than the value of another property)
Example:

//Less than a particular value
RuleFor(customer => customer.CreditLimit).LessThan(100);

//Less than another property
RuleFor(customer => customer.CreditLimit).LessThan(customer => customer.MaxCreditLimit);

Example error: 'Credit Limit' must be less than 100.
Notes: Only valid on types that implement IComparable<T>
String format args:

{PropertyName} = The name of the property being validated
{ComparisonValue} - The value to which the property was compared
{PropertyValue} = The current value of the property

Less Than Or Equal Validator

Description: Ensures that the value of the specified property is less than or equal to a particular value (or less than or equal to the value of another property)
Example:

//Less than a particular value
RuleFor(customer => customer.CreditLimit).LessThanOrEqual(100);

//Less than another property
RuleFor(customer => customer.CreditLimit).LessThanOrEqual(customer => customer.MaxCreditLimit);

Example error: 'Credit Limit' must be less than or equal to 100.
Notes: Only valid on types that implement IComparable<T>

{PropertyName} = The name of the property being validated
{ComparisonValue} - The value to which the property was compared
{PropertyValue} = The current value of the property

Greater Than Validator

Description: Ensures that the value of the specified property is greater than a particular value (or greater than the value of another property)
Example:

//Less than a particular value
RuleFor(customer => customer.CreditLimit).GreaterThan(0);

//Less than another property
RuleFor(customer => customer.CreditLimit).GreaterThan(customer => customer.MinimumCreditLimit);

Example error: 'Credit Limit' must be greater than 0.
Notes: Only valid on types that implement IComparable<T>

{PropertyName} = The name of the property being validated
{ComparisonValue} - The value to which the property was compared
{PropertyValue} = The current value of the property

Greater Than Or Equal Validator

Description: Ensures that the value of the specified property is greater than or equal to a particular value (or greater than or equal to the value of another property)
Example:

//Less than a particular value
RuleFor(customer => customer.CreditLimit).GreaterThanOrEqual(1);

//Less than another property
RuleFor(customer => customer.CreditLimit).GreaterThanOrEqual(customer => customer.MinimumCreditLimit);

Example error: 'Credit Limit' must be greater than or equal to 1.
Notes: Only valid on types that implement IComparable<T>

{PropertyName} = The name of the property being validated
{ComparisonValue} - The value to which the property was compared
{PropertyValue} = The current value of the property

Predicate Validator (aka Must)

Description: Passes the value of the specified property into a custom delegate that can perform custom validation logic on the value

Example:

RuleFor(customer => customer.Surname).Must(surname => "Foo".Equals(surname));

Example error: The specified condition was not met for 'Surname'
String format args:

{PropertyName} = The name of the property being validated
{PropertyValue} = The current value of the property

RuleFor(customer => customer.Surname).Must((customer, surname) => surname != customer.Forename)

(Note that in this particular example, it would be better to use the cross-property version of NotEqual)

Regular Expression Validator

Description: Ensures that the value of the specified property matches the given regular expression.
Example:

RuleFor(customer => customer.Surname).Matches("some regex here");

Example error: 'Surname' is not in the correct format.
String format args:

{PropertyName} = The name of the property being validated
{PropertyValue} = The current value of the property

Email Validator

Description: Ensures that the value of the specified property is a valid email address format.
Example:

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

Example error: 'Email' is not a valid email address.
String format args:

{PropertyName} = The name of the property being validated
{PropertyValue} = The current value of the property

The regular expression used by the email validator can be found at http://regexlib.com/REDetails.aspx?regexp_id=1448

Updated Wiki: Documentation

JeremyS — Tue, 07 May 2013 10:16:04 GMT

This documentation is for the 4.0 release of FluentValidation.

Updated Wiki: mvc

JeremyS — Thu, 02 May 2013 11:27:33 GMT

Integration with ASP.NET MVC

FluentValidation can be integrated with ASP.NET MVC 3 and ASP.NET MVC 4. Once enabled, MVC will use FluentValidation to validate objects that are passed in to controller actions by the model binding infrastructure.

Note There is no built-in integration for ASP.NET Web API.

To enable MVC integration, you'll need to add a reference to the FluentValidation.Mvc3 or FluentValidation.Mvc4 assemblies (either available through the download package on this site, or by installing the FluentValidation.Mvc3 / FluentValidation.Mvc4 NuGet packages).

Once installed, you'll need to configure the FluentValidationModelValidatorProvider (which lives in the FluentValidation.Mvc namespace) during the Application_Start event of your MVC application.

protected void Application_Start() {
    AreaRegistration.RegisterAllAreas();

    RegisterGlobalFilters(GlobalFilters.Filters);
    RegisterRoutes(RouteTable.Routes);

    FluentValidationModelValidatorProvider.Configure();
}

Internally, FluentValidation's MVC integration makes use of a validator factory to know how to work out which validator should be used to validate a particular type. By default, FluentValidation ships with an AttributedValidatorFactory that allows you to link a validator to the type that it validates by decorating the class to validate with an attribute that identifies its corresponding validator:

[Validator(typeof(PersonValidator))]
public class Person {
	public int Id { get; set; }
	public string Name { get; set; }
	public string Email { get; set; }
	public int Age { get; set; }
}
 
public class PersonValidator : AbstractValidator<Person> {
	public PersonValidator() {
		RuleFor(x => x.Id).NotNull();
		RuleFor(x => x.Name).Length(0, 10);
		RuleFor(x => x.Email).EmailAddress();
		RuleFor(x => x.Age).InclusiveBetween(18, 60);
	}
}

Instead of using an attribute, you can also use a custom validator factory with an IoC container. You can tell the FluentValidationModelValidatorProvider to use a different validator factory by passing a nested closure into the Configure method which allows the provider to be customized:

FluentValidationModelValidatorProvider.Configure(provider => {
  provider.ValidatorFactory = new MyCustomValidatorFactory();
});

Finally, we can create the controller and associated view:

public class PeopleController : Controller {
	public ActionResult Create() {
		return View();
	}
 
	[HttpPost]
	public ActionResult Create(Person person) {
 
		if(! ModelState.IsValid) { // re-render the view when validation failed.
			return View("Create", person);
		}
 
		TempData["notice"] = "Person successfully created";
		return RedirectToAction("Index");
 
	}
}

...and here's the corresponding view (using Razor):

@Html.ValidationSummary()
 
@using (Html.BeginForm()) {
	Id: @Html.TextBoxFor(x => x.Id) @Html.ValidationMessageFor(x => x.Id)
	<br />
	Name: @Html.TextBoxFor(x => x.Name) @Html.ValidationMessageFor(x => x.Name) 		
	<br />
	Email: @Html.TextBoxFor(x => x.Email) @Html.ValidationMessageFor(x => x.Email)
	<br />
	Age: @Html.TextBoxFor(x => x.Age) @Html.ValidationMessageFor(x => x.Age)
 
	<br /><br />
 
	<input type="submit" value="submit" />
}

Now when you post the form MVC’s DefaultModelBinder will validate the Person object using the FluentValidationModelValidatorProvider.

Note that FluentValidation will also work with ASP.NET MVC's client-side validation, but not all rules are supported. For example, any rules defined using a condition (with When/Unless), custom validators, or calls to Must will not run on the client side. The following validators are supported on the client:

*NotNull/NotEmpty
*Matches (regex)
*InclusiveBetween (range)
*CreditCard
*Email
*EqualTo (cross-property equality comparison)
*Length

Validator customization

The downside of using this automatic integration is that you don’t have access to the validator directly which means that you don’t have as much control over the validation processes compared to running the validator manually.

With FluentValidation v3 you can use the CustomizeValidatorAttribute to configure how the validator will be run. For example, if you want the validator to only run for a particular ruleset then you can specify that ruleset name by attributing the parameter that is going to be validated:

public ActionResult Save([CustomizeValidator(RuleSet="MyRuleset")] Customer cust) {
  // ...
}

This is the equivalent of specifying the ruleset if you were to pass a ruleset name to a validator:

var validator = new CustomerValidator();
var customer = new Customer();
var result = validator.Validate(customer, ruleSet: "MyRuleset");

The attribute can also be used to invoke validation for individual properties:

public ActionResult Save([CustomizeValidator(Properties="Surname,Forename")] Customer cust) {
  // ...
}

…which would be the equivalent of specifying properties in the call to validator.Validate:

var validator = new CustomerValidator();
var customer = new Customer();
var result = validator.Validate(customer, properties: new[] { "Surname", "Forename" });

Validator Interceptors

You can further customize this process by using an interceptor. An interceptor has to implement the IValidatorInterceptor interface from the FluentValidation.Mvc namespace:

public interface IValidatorInterceptor {
    ValidationContext BeforeMvcValidation(ControllerContext controllerContext, ValidationContext validationContext);
 
    ValidationResult AfterMvcValidation(ControllerContext controllerContext, ValidationContext validationContext, ValidationResult result);
}

This interface has two methods – BeforeMvcValidation and AfterMvcValidation. If you implement this interface in your validator classes then these methods will be called as appropriate during the MVC validation pipeline.

BeforeMvcValidation is invoked after the appropriate validator has been selected but before it is invoked. One of the arguments passed to this method is a ValidationContext that will eventually be passed to the validator. The context has several properties including a reference to the object being validated. If we want to change which rules are going to be invoked (for example, by using a custom ValidatorSelector) then we can create a new ValidationContext, set its Selector property, and return that from the BeforeMvcValidation method.

Likewise, AfterMvcValidation occurs after validation has occurs. This time, we also have a reference to the result of the validation. Here we can do some additional processing on the error messages before they’re added to modelstate.

As well as implementing this interface directly in a validator class, we can also implement it externally, and specify the interceptor by using a CustomizeValidatorAttribute on an action method parameter:

public ActionResult Save([CustomizeValidator(Interceptor=typeof(MyCustomerInterceptor))] Customer cust) {
 //...
}

In this case, the interceptor has to be a class that implements IValidatorInterceptor and has a public, parameterless constructor. The advantage of this approach is that your validators don’t have to be in an assembly that directly references System.Web.Mvc.

Note that this is considered to be an advanced scenario. Most of the time you probably won’t need to use an interceptor, but the option is there if you want it.

Updated Wiki: mvc

JeremyS — Thu, 02 May 2013 08:37:29 GMT

Integration with ASP.NET MVC

FluentValidation can be integrated with ASP.NET MVC 3 and ASP.NET MVC 4. Once enabled, MVC will use FluentValidation to validate objects that are passed in to controller actions by the model binding infrastructure.

To enable MVC integration, you'll need to add a reference to the FluentValidation.Mvc3 or FluentValidation.Mvc4 assemblies (either available through the download package on this site, or by installing the FluentValidation.Mvc3 / FluentValidation.Mvc4 NuGet packages).

Once installed, you'll need to configure the FluentValidationModelValidatorProvider (which lives in the FluentValidation.Mvc namespace) during the Application_Start event of your MVC application.

protected void Application_Start() {
    AreaRegistration.RegisterAllAreas();

    RegisterGlobalFilters(GlobalFilters.Filters);
    RegisterRoutes(RouteTable.Routes);

    FluentValidationModelValidatorProvider.Configure();
}

[Validator(typeof(PersonValidator))]
public class Person {
	public int Id { get; set; }
	public string Name { get; set; }
	public string Email { get; set; }
	public int Age { get; set; }
}
 
public class PersonValidator : AbstractValidator<Person> {
	public PersonValidator() {
		RuleFor(x => x.Id).NotNull();
		RuleFor(x => x.Name).Length(0, 10);
		RuleFor(x => x.Email).EmailAddress();
		RuleFor(x => x.Age).InclusiveBetween(18, 60);
	}
}

FluentValidationModelValidatorProvider.Configure(provider => {
  provider.ValidatorFactory = new MyCustomValidatorFactory();
});

Finally, we can create the controller and associated view:

public class PeopleController : Controller {
	public ActionResult Create() {
		return View();
	}
 
	[HttpPost]
	public ActionResult Create(Person person) {
 
		if(! ModelState.IsValid) { // re-render the view when validation failed.
			return View("Create", person);
		}
 
		TempData["notice"] = "Person successfully created";
		return RedirectToAction("Index");
 
	}
}

...and here's the corresponding view (using Razor):

@Html.ValidationSummary()
 
@using (Html.BeginForm()) {
	Id: @Html.TextBoxFor(x => x.Id) @Html.ValidationMessageFor(x => x.Id)
	<br />
	Name: @Html.TextBoxFor(x => x.Name) @Html.ValidationMessageFor(x => x.Name) 		
	<br />
	Email: @Html.TextBoxFor(x => x.Email) @Html.ValidationMessageFor(x => x.Email)
	<br />
	Age: @Html.TextBoxFor(x => x.Age) @Html.ValidationMessageFor(x => x.Age)
 
	<br /><br />
 
	<input type="submit" value="submit" />
}

Validator customization

public ActionResult Save([CustomizeValidator(RuleSet="MyRuleset")] Customer cust) {
  // ...
}

This is the equivalent of specifying the ruleset if you were to pass a ruleset name to a validator:

var validator = new CustomerValidator();
var customer = new Customer();
var result = validator.Validate(customer, ruleSet: "MyRuleset");

The attribute can also be used to invoke validation for individual properties:

public ActionResult Save([CustomizeValidator(Properties="Surname,Forename")] Customer cust) {
  // ...
}

…which would be the equivalent of specifying properties in the call to validator.Validate:

var validator = new CustomerValidator();
var customer = new Customer();
var result = validator.Validate(customer, properties: new[] { "Surname", "Forename" });

Validator Interceptors

You can further customize this process by using an interceptor. An interceptor has to implement the IValidatorInterceptor interface from the FluentValidation.Mvc namespace:

public interface IValidatorInterceptor {
    ValidationContext BeforeMvcValidation(ControllerContext controllerContext, ValidationContext validationContext);
 
    ValidationResult AfterMvcValidation(ControllerContext controllerContext, ValidationContext validationContext, ValidationResult result);
}

public ActionResult Save([CustomizeValidator(Interceptor=typeof(MyCustomerInterceptor))] Customer cust) {
 //...
}

Updated Wiki: mvc

JeremyS — Thu, 02 May 2013 08:36:58 GMT

Integration with ASP.NET MVC

FluentValidation can be integrated with ASP.NET MVC 3 and ASP.NET MVC 4. Once enabled, MVC will use FluentValidation to validate objects that are passed in to controller actions by the model binding infrastructure.

To enable MVC integration, you'll need to add a reference to the FluentValidation.Mvc3 assembly (either available through the download package on this site, or by installing the FluentValidation.Mvc3 NuGet package).

Once installed, you'll need to configure the FluentValidationModelValidatorProvider (which lives in the FluentValidation.Mvc namespace) during the Application_Start event of your MVC application.

protected void Application_Start() {
    AreaRegistration.RegisterAllAreas();

    RegisterGlobalFilters(GlobalFilters.Filters);
    RegisterRoutes(RouteTable.Routes);

    FluentValidationModelValidatorProvider.Configure();
}

[Validator(typeof(PersonValidator))]
public class Person {
	public int Id { get; set; }
	public string Name { get; set; }
	public string Email { get; set; }
	public int Age { get; set; }
}
 
public class PersonValidator : AbstractValidator<Person> {
	public PersonValidator() {
		RuleFor(x => x.Id).NotNull();
		RuleFor(x => x.Name).Length(0, 10);
		RuleFor(x => x.Email).EmailAddress();
		RuleFor(x => x.Age).InclusiveBetween(18, 60);
	}
}

FluentValidationModelValidatorProvider.Configure(provider => {
  provider.ValidatorFactory = new MyCustomValidatorFactory();
});

Finally, we can create the controller and associated view:

public class PeopleController : Controller {
	public ActionResult Create() {
		return View();
	}
 
	[HttpPost]
	public ActionResult Create(Person person) {
 
		if(! ModelState.IsValid) { // re-render the view when validation failed.
			return View("Create", person);
		}
 
		TempData["notice"] = "Person successfully created";
		return RedirectToAction("Index");
 
	}
}

...and here's the corresponding view (using Razor):

@Html.ValidationSummary()
 
@using (Html.BeginForm()) {
	Id: @Html.TextBoxFor(x => x.Id) @Html.ValidationMessageFor(x => x.Id)
	<br />
	Name: @Html.TextBoxFor(x => x.Name) @Html.ValidationMessageFor(x => x.Name) 		
	<br />
	Email: @Html.TextBoxFor(x => x.Email) @Html.ValidationMessageFor(x => x.Email)
	<br />
	Age: @Html.TextBoxFor(x => x.Age) @Html.ValidationMessageFor(x => x.Age)
 
	<br /><br />
 
	<input type="submit" value="submit" />
}

Validator customization

public ActionResult Save([CustomizeValidator(RuleSet="MyRuleset")] Customer cust) {
  // ...
}

This is the equivalent of specifying the ruleset if you were to pass a ruleset name to a validator:

var validator = new CustomerValidator();
var customer = new Customer();
var result = validator.Validate(customer, ruleSet: "MyRuleset");

The attribute can also be used to invoke validation for individual properties:

public ActionResult Save([CustomizeValidator(Properties="Surname,Forename")] Customer cust) {
  // ...
}

…which would be the equivalent of specifying properties in the call to validator.Validate:

var validator = new CustomerValidator();
var customer = new Customer();
var result = validator.Validate(customer, properties: new[] { "Surname", "Forename" });

Validator Interceptors

You can further customize this process by using an interceptor. An interceptor has to implement the IValidatorInterceptor interface from the FluentValidation.Mvc namespace:

public interface IValidatorInterceptor {
    ValidationContext BeforeMvcValidation(ControllerContext controllerContext, ValidationContext validationContext);
 
    ValidationResult AfterMvcValidation(ControllerContext controllerContext, ValidationContext validationContext, ValidationResult result);
}

public ActionResult Save([CustomizeValidator(Interceptor=typeof(MyCustomerInterceptor))] Customer cust) {
 //...
}

Updated Wiki: Home

JeremyS — Mon, 29 Apr 2013 16:29:36 GMT

Project Description
A small validation library for .NET that uses a fluent interface and lambda expressions for building validation rules for your business objects.

If you find FluentValidation useful, please consider making a donation.

NuGet packages are available - the package IDs are FluentValidation, FluentValidation.MVC3 and FluentValidation.MVC4.

If you need signed binaries then use the NuGet packages FluentValidaiton-signed, FluentValidation.MVC3-signed and FluentValidation.MVC4-signed.

The main source code repository for this project is on GitHub although it is also mirrored to CodePlex.

Example

using FluentValidation;

public class CustomerValidator: AbstractValidator<Customer> {
  public CustomerValidator() {
    RuleFor(customer => customer.Surname).NotEmpty();
    RuleFor(customer => customer.Forename).NotEmpty().WithMessage("Please specify a first name");
    RuleFor(customer => customer.Company).NotNull();
    RuleFor(customer => customer.Discount).NotEqual(0).When(customer => customer.HasDiscount);
    RuleFor(customer => customer.Address).Length(20, 250);
    RuleFor(customer => customer.Postcode).Must(BeAValidPostcode).WithMessage("Please specify a valid postcode");
  }

  private bool BeAValidPostcode(string postcode) {
    // custom postcode validating logic goes here
  }
}

Customer customer = new Customer();
CustomerValidator validator = new CustomerValidator();
ValidationResult results = validator.Validate(customer);

bool validationSucceeded = results.IsValid;
IList<ValidationFailure> failures = results.Errors;

Supported By

Updated Wiki: Home

JeremyS — Mon, 29 Apr 2013 16:29:20 GMT

using FluentValidation;

public class CustomerValidator: AbstractValidator<Customer> {
  public CustomerValidator() {
    RuleFor(customer => customer.Surname).NotEmpty();
    RuleFor(customer => customer.Forename).NotEmpty().WithMessage("Please specify a first name");
    RuleFor(customer => customer.Company).NotNull();
    RuleFor(customer => customer.Discount).NotEqual(0).When(customer => customer.HasDiscount);
    RuleFor(customer => customer.Address).Length(20, 250);
    RuleFor(customer => customer.Postcode).Must(BeAValidPostcode).WithMessage("Please specify a valid postcode");
  }

  private bool BeAValidPostcode(string postcode) {
    // custom postcode validating logic goes here
  }
}

Customer customer = new Customer();
CustomerValidator validator = new CustomerValidator();
ValidationResult results = validator.Validate(customer);

bool validationSucceeded = results.IsValid;
IList<ValidationFailure> failures = results.Errors;

Documentation

Supported By

Updated Wiki: CreatingAValidator

JeremyS — Tue, 23 Apr 2013 13:02:05 GMT

Creating a Validator class

Before creating any validators, you will need to add a reference to FluentValidation.dll

To define a set of validation rules for a particular object, you will need to create a class that inherits from AbstractValidator<T>, where T is the type of class that you wish to validate.

For example, imagine that you have a Customer class:

public class Customer {
  public int Id { get; set; }
  public string Surname { get; set; }
  public string Forename { get; set; }
  public decimal Discount { get; set; }
  public string Address { get; set; }
}

You would define a set of validation rules for this class by inheriting from AbstractValidator<Customer>:

using FluentValidation; 

public class CustomerValidator : AbstractValidator<Customer> {
}

The validation rules themselves should be defined in the validator class's constructor. To specify a validation rule for a particular property, call the RuleFor method, passing a lambda expression for the property that you wish to validate. For example, to ensure that the Surname property is not null, the validator class would look like this:

using FluentValidation;

public class CustomerValidator : AbstractValidator<Customer> {
  public CustomerValidator {
    RuleFor(customer => customer.Surname).NotNull();
  }
}

Chaining Validators for the Same Property

You can chain multiple validators together for the same property:

using FluentValidation;

public class CustomerValidator : AbstractValidator<Customer> {
  public CustomerValidator {
    RuleFor(customer => customer.Surname).NotNull().NotEqual("foo");
  }
}

This would ensure that the surname is not null and is not equal to the string 'foo'.

To execute the validator, create an instance of the validator class and pass the object that you wish to validate to the Validate method.

Customer customer = new Customer();
CustomerValidator validator = new CustomerValidator();

ValidationResult results = validator.Validate(customer);

ValidationResult

The Validate method returns a ValidationResult object. This contains two properties:

IsValid - a boolean that says whether the validation suceeded.
Errors - a collection of ValidationFailure objects containing details about any validation failures.

The following code would write any validation failures to the console:

Customer customer = new Customer();
CustomerValidator validator = new CustomerValidator();

ValidationResult results = validator.Validate(customer);

if(! results.IsValid) {
  foreach(var failure in results.Errors) {
    Console.WriteLine("Property " + failure.PropertyName + " failed validation. Error was: " + failure.ErrorMessage);
  }
}

Throwing Exceptions

Instead of returning a ValidationResult, you can alternatively tell FluentValidation to throw an exception if validation fails by using the ValidateAndthrow method:

Customer customer = new Customer();
CustomerValidator validator = new CustomerValidator();

validator.ValidateAndThrow(customer);

This throws a ValidationException which contains the error messages in the Errors property.

Note ValidateAndThrow is an extension method, so you must have the FluentValidation namespace imported for this method to be available.

Re-using Validators for Complex Properties

Validators can be re-used for complex properties. For example, imagine you have two classes, Customer and Address:

public class Customer {
  public string Name { get; set; }
  public Address Address { get; set; }
}

public class Address {
  public string Line1 { get; set; }
  public string Line2 { get; set; }
  public string Town { get; set; }
  public string County { get; set; }
  public string Postcode { get; set; }
}

... and you define an AddressValidator:

public class AddressValidator : AbstractValidator<Address> {
  public AddressValidator() {
    RuleFor(address => address.Postcode).NotNull();
    //etc
  }
}

... you can then re-use the AddressValidator in the CustomerValidator definition:

public class CustomerValidator : AbstractValidator<Customer> {
  public CustomerValidator() {
    RuleFor(customer => customer.Name).NotNull();
    RuleFor(customer => customer.Address).SetValidator(new AddressValidator())
  }
}

... so when you call Validate on the CustomerValidator it will run through the validators defined in both the CustomerValidator and the AddressValidator and combine the results into a single ValidationResult.

Re-using Validators for Collections

Validators can also be re-used on properties that contain collections of other objects. For example, imagine a Customer object that has a collection of Orders:

public class Customer {
   public IList<Order> Orders { get; set; }
}

public class Order {
  public string ProductName { get; set; }
  public decimal? Cost { get; set; }
}

var customer = new Customer();
customer.Orders = new List<Order> {
  new Order { ProductName = "Foo" },
  new Order { Cost = 5 } 
};

... and you've already defined an OrderValidator:

public class OrderValidator : AbstractValidator<Order> {
    public OrderValidator() {
        RuleFor(x => x.ProductName).NotNull();
        RuleFor(x => x.Cost).GreaterThan(0);
    }
}

....this validator can be used within the CustomerValidator definition:

public class CustomerValidator : AbstractValidator<Customer> {
    public CustomerValidator() {
        RuleFor(x => x.Orders).SetCollectionValidator(new OrderValidator());
    }
}

var validator = new CustomerValidator();
var results = validator.Validate(customer);

When the validator is executed, the error messages will reflect the placement of the order object within the collection:

foreach(var result in results.Errors) {
   Console.WriteLine("Property name: " + result.PropertyName);
   Console.WriteLine("Error: " + result.ErrorMessage);
   Console.WriteLine("");
}

Property name: Orders[0].Cost
Error: 'Cost' must be greater than '0'.

Property name: Orders[1].ProductName
Error: 'Product Name' must not be empty.

You can optionally include or exclude certain items in the collection from being validated by using the Where method:

 RuleFor(x => x.Orders).SetCollectionValidator(new OrderValidator())
        .Where(x => x.Cost != null);

Rule Sets

RuleSets allow you to group validation rules together which can be executed together as a group whilst ignoring other rules:

For example, let’s imagine we have 3 properties on a Person object (Id, Surname and Forename) and have a validation rule for each. We could group the Surname and Forename rules together in a “Names” RuleSet:

 public class PersonValidator : AbstractValidator<Person> {
  public PersonValidator() {
     RuleSet("Names", () => {
        RuleFor(x => x.Surname).NotNull();
        RuleFor(x => x.Forename).NotNull();
     });
 
     RuleFor(x => x.Id).NotEqual(0);
  }
}

Here the two rules on Surname and Forename are grouped together in a “Names” RuleSet. We can invoke only these rules by passing a ruleSet parameter to the Validate extension method (note that this must be a named parameter as this overload has several options available).

 var validator = new PersonValidator();
var person = new Person();
var result = validator.Validate(person, ruleSet: "Names");

This allows you to break down a complex validator definition into smaller segments that can be executed in isolation.

Additionally, you can execute multiple rulesets by using a comma-separated list of strings:

validator.Validate(person, ruleSet: "Names,MyRuleSet,SomeOtherRuleSet")

...and you can also include rules not in any ruleset by specifying a ruleset of "default":

validator.Validate(person, ruleSet: "default,MyRuleSet")

This would execute rules in the MyRuleSet set, and those rules not in any ruleset.

Updated Wiki: CreatingAValidator

JeremyS — Mon, 11 Mar 2013 16:33:41 GMT

Creating a Validator class

public class Customer {
  public int Id { get; set; }
  public string Surname { get; set; }
  public string Forename { get; set; }
  public decimal Discount { get; set; }
  public string Address { get; set; }
}

You would define a set of validation rules for this class by inheriting from AbstractValidator<Customer>:

using FluentValidation; 

public class CustomerValidator : AbstractValidator<Customer> {
}

using FluentValidation;

public class CustomerValidator : AbstractValidator<Customer> {
  public CustomerValidator {
    RuleFor(customer => customer.Surname).NotNull();
  }
}

Chaining Validators for the Same Property

You can chain multiple validators together for the same property:

using FluentValidation;

public class CustomerValidator : AbstractValidator<Customer> {
  public CustomerValidator {
    RuleFor(customer => customer.Surname).NotNull().NotEqual("foo");
  }
}

Customer customer = new Customer();
CustomerValidator validator = new CustomerValidator();

ValidationResult results = validator.Validate(customer);

ValidationResult

The Validate method returns a ValidationResult object. This contains two properties:

IsValid - a boolean that says whether the validation suceeded.
Errors - a collection of ValidationFailure objects containing details about any validation failures.

The following code would write any validation failures to the console:

Customer customer = new Customer();
CustomerValidator validator = new CustomerValidator();

ValidationResult results = validator.Validate(customer);

if(! results.IsValid) {
  foreach(var failure in results.Errors) {
    Console.WriteLine("Property " + failure.PropertyName + " failed validation. Error was: " + failure.ErrorMessage);
  }
}

Throwing Exceptions

Instead of returning a ValidationResult, you can alternatively tell FluentValidation to throw an exception if validation fails by using the ValidateAndthrow method:

Customer customer = new Customer();
CustomerValidator validator = new CustomerValidator();

validator.ValidateAndThrow(customer);

Re-using Validators for Complex Properties

Validators can be re-used for complex properties. For example, imagine you have two classes, Customer and Address:

public class Customer {
  public string Name { get; set; }
  public Address Address { get; set; }
}

public class Address {
  public string Line1 { get; set; }
  public string Line2 { get; set; }
  public string Town { get; set; }
  public string County { get; set; }
  public string Postcode { get; set; }
}

... and you define an AddressValidator:

public class AddressValidator : AbstractValidator<Address> {
  public AddressValidator() {
    RuleFor(address => address.Postcode).NotNull();
    //etc
  }
}

... you can then re-use the AddressValidator in the CustomerValidator definition:

public class CustomerValidator : AbstractValidator<Customer> {
  public CustomerValidator() {
    RuleFor(customer => customer.Name).NotNull();
    RuleFor(customer => customer.Address).SetValidator(new AddressValidator())
  }
}

Re-using Validators for Collections

Validators can also be re-used on properties that contain collections of other objects. For example, imagine a Customer object that has a collection of Orders:

public class Customer {
   public IList<Order> Orders { get; set; }
}

public class Order {
  public string ProductName { get; set; }
  public decimal? Cost { get; set; }
}

var customer = new Customer();
customer.Orders = new List<Order> {
  new Order { ProductName = "Foo" },
  new Order { Cost = 5 } 
};

... and you've already defined an OrderValidator:

public class OrderValidator : AbstractValidator<Order> {
    public OrderValidator() {
        RuleFor(x => x.ProductName).NotNull();
        RuleFor(x => x.Cost).GreaterThan(0);
    }
}

....this validator can be used within the CustomerValidator definition:

public class CustomerValidator : AbstractValidator<Customer> {
    public CustomerValidator() {
        RuleFor(x => x.Orders).SetCollectionValidator(new OrderValidator());
    }
}

var validator = new CustomerValidator();
var results = validator.Validate(customer);

When the validator is executed, the error messages will reflect the placement of the order object within the collection:

foreach(var result in results.Errors) {
   Console.WriteLine("Property name: " + result.PropertyName);
   Console.WriteLine("Error: " + result.ErrorMessage);
   Console.WriteLine("");
}

Property name: Orders[0].Cost
Error: 'Cost' must be greater than '0'.

Property name: Orders[1].ProductName
Error: 'Product Name' must not be empty.

You can optionally include or exclude certain items in the collection from being validated by using the Where method:

 RuleFor(x => x.Orders).SetCollectionValidator(new OrderValidator())
        .Where(x => x.Cost != null);

Rule Sets

 public class PersonValidator : AbstractValidator<Person> {
  public PersonValidator() {
     RuleSet("Names", () => {
        RuleFor(x => x.Surname).NotNull();
        RuleFor(x => x.Forename).NotNull();
     });
 
     RuleFor(x => x.Id).NotEqual(0);
  }
}

 var validator = new PersonValidator();
var person = new Person();
var result = validator.Validate(person, ruleSet: "Names");

This allows you to break down a complex validator definition into smaller segments that can be executed in isolation.

New Comment on "CreatingAValidator"

JeremyS — Fri, 08 Mar 2013 09:31:27 GMT

Please do not post comments on these wiki pages - they are not monitored. If you have a question, please open a discussion on the Discussions page.

New Comment on "CreatingAValidator"

saranroyal — Thu, 07 Mar 2013 05:04:14 GMT

I don't see the .ValidateAndThrow() method, I'm using FluentValidation.dll version 3.4.6.0. Could you fix it?

New Comment on "CreatingAValidator"

lurongkai — Wed, 26 Dec 2012 08:43:33 GMT

RuleFor(x => x.Orders).SetCollectionValidator(new OrderValidator()) .Where(x => x.Cost != null); Is that means only set validator for orders which cost is not null? if so, move 'Where' statement in front may be a better choice?

New Comment on "mvc"

grandadmiralmcb — Thu, 04 Oct 2012 17:44:07 GMT

How do you enable client-side validation? I have integrated FluentValidation with MVC, but it would be great to see how to enforce certain rules on the client without having to post to the server.

New Comment on "CreatingAValidator"

stefh — Wed, 29 Aug 2012 12:06:21 GMT

Add information to this documentation page that you have to include the "DefaultValidatorExtensions" for some methods like ValidateAndThrow().

New Comment on "CreatingAValidator"

Flyear — Sun, 26 Aug 2012 02:54:26 GMT

Very good post for beginner, Thank you.