基於 .net 的 fluentvalidation 驗證教程

FluentValidation 是一个基于 .NET 开发的验证框架，开源免费，而且优雅，支持链式操作，易于理解，功能完善，还是可与 MVC5、WebApi2 和 ASP.NET CORE 深度集成，组件内提供十几种常用验证器，可扩展性好，支持自定义验证器，支持本地化媳妇言。

虽然 FluentValidation 是一个非常强大的验证框架，但针对该框架的中文资料并不完善，零度在学习的过程中，将官方文档进行了翻译，由此产生本文，可供参阅。

要使用验证框架, 需要在项目中添加对 FluentValidation.dll 的引用，支持 netstandard2.0 库和 .NET4.5 平台，支持.NET Core 平台，最简单的方法是使用 NuGet 包管理器引用组件。

Install-Package FluentValidation

若要在 ASP.NET Core 中使用 FluentValidation 扩展，可引用以下包：

Install-Package FluentValidation.AspNetCore

若要在 ASP.NET MVC 5 或 WebApi 2 项目集成, 可以使用分别使用 FluentValidation.Mvc5 和 FluentValidation.WebApi 程序包。

Install-Package FluentValidation.Mvc5
Install-Package FluentValidation.WebApi

创建第一个验证程序

若要为特定对象定义一组验证规则, 您需要创建一个从 AbstractValidator<T> 继承的类, 其中泛型 T 参数是要验证的类的类型。假设您有一个客户类别:

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; }
}

接下来自定义继承于 AbstractValidator 泛型类的验证器，然后在构造函数中使用 LINQ 表达式编写 RuleFor 验证规则。

using FluentValidation;

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

若要执行验证程序，我们通过定义好的 CustomerValidator 验证器传入实体类 Customer 即可。

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

ValidationResult result = validator.Validate(customer);

该验证方法返回一个 ValidationResult 对象，表示验证结果，ValidationResult 包含两个属性：IsValid 属性是布尔值, 它表示验证是否成功，Errors 属性包含验证失败的详细信息。

下面的代码演示向控制台输出验证失败的详细信息:

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 + " Error was: " + failure.ErrorMessage);
  }
}

链接规则写法

您可以将对象的同一属性用多个验证程序链在一起，以下代码将验证 Surname 属性不为 Null 的同时且不等于 foo 字符串。

using FluentValidation;

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

引发异常

如果验证失败, 不想返回 ValidationResult 对象，而是想直接抛出异常，可通过调用验证器的 ValidateAndThrow 进行验证。

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

validator.ValidateAndThrow(customer);

如果验证失败，将引发一个 ValidationException 类型的异常，这个异常可以被上层程序捕获，并从异常中找到详细错误信息。

集合

当针对一个集合进行验证时，只需要定义集合项类型的规则即可，以下规则将对集合中的每个元素运行 NotNull 检查。

public class Person {
  public List<string> AddressLines {get;set;} = new List<string>();
}
public class PersonValidator : AbstractValidator<Person> {
  public PersonValidator() {
    RuleForEach(x => x.AddressLines).NotNull();
  }
}

复杂属性

验证程序可以用于复杂属性，假设您有两个类：客户和地址。

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; }
}

然后定义一个基于地址的 AddressValidator 验证器件：

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

然后定义一个基于客户的 CustomerValidator 验证器件，对地址验证时使用地址验证器。

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

另外，还可以在集合属性上使用验证程序，假设客户对象包含订单集合属性：

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 }
};

定义了一个 OrderValidator 验证器件：

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

此验证程序可在 CustomerValidator 中通过 SetCollectionValidator 方法使用:

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

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

执行行验证程序时, 通过验证结果，可以输出订单每个属性验证错误的详细信息：

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.

在编写验证规则时，可以通过 Where 关键字排除或者筛选不需要验证的对象。

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

支持规则集

规则集允许您将验证规则组合在一起, 作为一个组一起执行, 同时忽略其他规则，假如：Person 类有 3 个属性分别是 Id、Surname 和 Forename，我们将 Id 单独验证， Surname 和 Forename 作为一组 Names 规则集进行验证。

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);
  }
}

然后，我们可以使用验证器提供的扩展方法，针对指定的规则集执行验证，以下代码将不验证 Id 属性。

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

执行多个规则集验证，可以使用逗号分隔的字符串列表。

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

通过*号匹配所有规则, 可以强制执行所有规则, 不管它们是否在规则集中:

validator.Validate(person, ruleSet: "*")

配置方法

通过在验证程序上调用 WithMessage 方法, 可以覆盖验证程序的默认验证错误消息：

RuleFor(customer => customer.Surname).NotNull().WithMessage("姓名不能为空");

错误提示中，可以通过 占位符替换属性名：

RuleFor(customer => customer.Surname).NotNull().WithMessage("{PropertyName}不能为空");

除了 占位符，框架还内置了：、、、和 占位符，关于更多内置占位符，可以参阅官方文档。

默认情况下，错误消息会输出属性名称，以下规则验证错误时，输出 Surname 不能为空。

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

验证程序支持通过 WithName 方法来指定属性别名，以下代码输出姓名不能为空。

RuleFor(customer => customer.Surname).NotNull().WithName("姓名");

FluentValidation 还支持通过 DisplayNameResolver 自定义别名获取逻辑：

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

也可以使用 DisplayName 特性指定属性别名。

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

某些条件下，可通过 When 方法按条件设置验证规则，如下代码：GreaterThan 规则仅在 IsPreferredCustomer 为 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();
});

默认情况，编写多个链式验证规则时，下无论前一个规则失败与否，后一个规则都将执行，以下代码检查 Surname 是否为空，然后检查 Surname 不等于零度，如多 NotNull 验证失败，则仍将调用 NotEqual 验证。

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

我们可以通过 StopOnFirstFailure 方法制定级联模式。

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

现在, 如果 NotNull 验证程序失败, NotEqual 验证程序将不会执行。

CascadeMode 是一个枚举，Continue 表示始终调用规则定义中的所有验证程序，StopOnFirstFailure 表示一旦验证程序失败, 就停止执行后边的规则。

若要全局设置级联模式, 可以在应用程序启动时修改 ValidatorOptions 类型的 CascadeMode 属性:

ValidatorOptions.CascadeMode = CascadeMode.StopOnFirstFailure;

若要为单个验证程序类设置级联模式，可以这样写：

public class PersonValidator : AbstractValidator<Person> {
  public PersonValidator() {

    // First set the cascade mode
    CascadeMode = CascadeMode.StopOnFirstFailure;

    // Rule definitions follow
    RuleFor(...)
    RuleFor(...)

   }
}

默认情况下, FluentValidation 中的所有规则都是独立运行的，无相互影响，有助于异步验证提高性能，但是, 有些情况下, 您希望某些规则仅在另一个规则验证完成后执行，通过 DependentRules 指定规则依赖，当依赖规则验证完成时，当前规则则会执行。

RuleFor(x => x.Surname).NotNull().DependentRules(() => {
  RuleFor(x => x.Forename).NotNull();
});

我们可以通过 ValidationContext 上下文的 RootContextData 字典向验证程序传递数据。

var instanceToValidate = new Person();
var context = new ValidationContext(person);
context.RootContextData["MyCustomData"] = "Test";
var validator = new PersonValidator();
validator.Validate(context);

然后，可以通过调用 Custom 方法在任何自定义属性验证程序内访问 RootContextData 字典。

RuleFor(x => x.Surname).Custom((x, context) => {
  if(context.ParentContext.RootContextData.ContainsKey("MyCustomData")) {
    context.AddFailure("My error message");
  }
});

如果每次调用验证程序前，都需要运行特定的代码, 可以通过重写 PreValidate 方法来拦截验证程序，该方法返回 true 验证程序将继续，返回 false 将终止继续验证。

public class MyValidator : AbstractValidator<Person> {
  public MyValidator() {
    RuleFor(x => x.Name).NotNull();
  }

  protected override bool PreValidate(ValidationContext<Person> context, ValidationResult result) {
    if (context.InstanceToValidate == null) {
      result.Errors.Add(new ValidationFailure("", "Please ensure a model was supplied."));
      return false;
    }
    return true;
  }
}

内置验证程序

FluentValidation 有几个内置的验证器，这些验证器的错误消息都可以使用特定占位符。

NotNull 验证程序

说明：确保指定的属性不是 null。

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

可用的格式参数占位符： = 正在验证的属性的名称 = 属性的当前值

NotEmpty 验证程序

说明: 确保指定的属性不是 null、空字符串或空格 (或值类型的默认值, 例如 int 0)。

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

可用的格式参数占位符： = 正在验证的属性的名称 = 属性的当前值

NotEqual 验证程序

说明: 确保指定属性的值不等于特定值 (或不等于其他属性的值)

//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);

可用的格式参数占位符： = 正在验证的属性的名称 = 属性不应等于的值

Equal 相等验证程序

说明: 确保指定属性的值等于特定值 (或等于另一个属性的值)

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

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

可用的格式参数占位符： = 正在验证的属性的名称 = 属性应相等的值 = 属性的当前值

Length 尺子验证程序

确保特定字符串属性的尺子位于指定范围内。但是, 它不能确保字符串属性是否为 null。

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

可用的格式参数占位符：

= 正在验证的属性的名称 = 最小尺子 = 最大尺子 = 输入的字符数 = 属性的当前值

MaxLength 最大尺子验证程序

说明：确保特定字符串属性的尺子不超过指定的值。

RuleFor(customer => customer.Surname).MaximumLength(250); //must be 250 chars or fewer

可用的格式参数占位符： = 正在验证的属性的名称 = 最大尺子 = 输入的字符数 = 属性的当前值

MinLength 最小尺子验证程序

说明：确保特定字符串属性的尺子不能未来指定的值。

RuleFor(customer => customer.Surname).MinimumLength(10); //must be 10 chars or more

可用的格式参数占位符： = 正在验证的属性的名称 = 最小尺子 = 输入的字符数 = 属性的当前值

LessThan 未来验证程序

说明: 确保指定属性的值未来特定值 (或未来另一个属性的值)

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

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

可用的格式参数占位符： = 正在验证的属性的名称 -属性比较的值 = 属性的当前值

LessThanOrEqualTo 未来等于验证程序

说明: 确保指定属性的值未来等于特定值 (或未来等于另一个属性的值)

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

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

可用的格式参数占位符： = 正在验证的属性的名称 -属性比较的值 = 属性的当前值

GreaterThan 大于验证程序

说明: 确保指定属性的值大于特定值 (或大于另一个属性的值)

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

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

可用的格式参数占位符： = 正在验证的属性的名称 -属性比较的值 = 属性的当前值

GreaterThanOrEqualTo 大于等于验证程序

说明: 确保指定属性的值大于等于特定值 (或大于等于另一个属性的值)

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

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

可用的格式参数占位符： = 正在验证的属性的名称 -属性比较的值 = 属性的当前值

Must 验证程序

描述: 将指定属性的值传递到一个委托中, 可以对该值执行自定义验证逻辑

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

可用的格式参数占位符： = 正在验证的属性的名称 = 属性的当前值

请注意, 委托参数不仅传递参数，还支持直接传递验证对象参数:

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

正则表达式验证程序

说明: 确保指定属性的值与给定的正则表达式匹配，正则表达式可参阅正则表达式教程（站长注：链接已失效）这篇文章

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

可用的格式参数占位符： = 正在验证的属性的名称 = 属性的当前值

Email 电子邮件验证程序

说明: 确保指定属性的值是有效的电子邮件地址格式。

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

可用的格式参数占位符： = 正在验证的属性的名称 = 属性的当前值

自定义验证程序

Must 验证程序

实现自定义验证程序的最简单方法是使用方法 Must 方法，假设我们有以下类：

public class Person {
  public IList<Person> Pets {get;set;} = new List<Person>();
}

为了确保列表中至少包含 10 个元素, 我们可以这样做:

public class PersonValidator:AbstractValidator<Person> {
  public PersonValidator() {
   RuleFor(x => x.Pets).Must(list => list.Count <= 10).WithMessage("The list must contain fewer than 10 items");
  }
}

为了使这种逻辑可重用, 我们可以将其封装为扩展方法。

public static class MyCustomValidators {
  public static IRuleBuilderOptions<T, IList<TElement>> ListMustContainFewerThan<T, TElement>(this IRuleBuilder<T, IList<TElement>> ruleBuilder, int num) {
	return ruleBuilder.Must(list => list.Count < num).WithMessage("The list contains too many items");
  }
}

在这里，我们通过为 IRuleBuilder 创建扩展方法实现可重用逻辑，使用方法很简单。

RuleFor(x => x.Pets).ListMustContainFewerThan(10);

编写自定义验证程序

如果您想灵活控制可重用的验证器, 则可以使用 Must 方法编写自定义规则，此方法允许您手动创建与验证错误关联的实例。

public class PersonValidator:AbstractValidator<Person> {
  public PersonValidator() {
   RuleFor(x => x.Pets).Custom((list, context) => {
     if(list.Count > 10) {
       context.AddFailure("The list must contain 10 items or fewer");
     }
   });
  }
}

此方法的优点是它允许您为同一规则返回多个错误。

context.AddFailure("SomeOtherProperty", "The list must contain 10 items or fewer");
// Or you can instantiate the ValidationFailure directly:
context.AddFailure(new ValidationFailure("SomeOtherProperty", "The list must contain 10 items or fewer");

自定义属性验证程序

在某些情况下, 针对某些属性的验证逻辑非常复杂, 我们希望将基于属性的自定义逻辑移动到单独的类中，可通过重写 PropertyValidator 类来完成。

using System.Collections.Generic;
using FluentValidation.Validators;
public class ListCountValidator<T> : PropertyValidator {
        private int _max;

	public ListCountValidator(int max)
		: base("{PropertyName} must contain fewer than {MaxElements} items.") {
		_max = max;
	}

	protected override bool IsValid(PropertyValidatorContext context) {
		var list = context.PropertyValue as IList<T>;

		if(list != null && list.Count >= _max) {
			context.MessageFormatter.AppendArgument("MaxElements", _max);
			return false;
		}

		return true;
	}
}

继承 PropertyValidator 时, 必须重写 IsValid 方法，此方法接受一个对象, 并返回一个布尔值, 指示验证是否成功，可通过 PropertyValidatorContext 属性访问： Instance-正在验证的对象 PropertyDescription-属性的名称 (或者是由调用 WithName 的自定义的别名) PropertyValue-正在验证的属性值 Member-描述正在验证的属性的 MemberInfo 信息

若要使用自定义的属性验证程序, 可以在定义验证规则时调用：

public class PersonValidator : AbstractValidator<Person> {
    public PersonValidator() {
       RuleFor(person => person.Pets).SetValidator(new ListCountValidator<Pet>(10));
    }
}

本地化与媳妇言

FluentValidation 为默认验证消息提供几种语言的翻译，默认情况下, 会根据当前线程的 CurrentUICulture 语言文化来选择语言，你也可以使用 WithMessage 和 WithLocalizedMessage 来指定错误提示。

WithMessage

如果使用 Visual Studio 的内置的 resx 格式资源文件， 则可以通过调用 WithMessage 本地化错误消息。

RuleFor(x => x.Surname).NotNull().WithMessage(x => MyLocalizedMessages.SurnameRequired);

当然，您可以将多种语言存储在数据库中，通过 lambda 表达式来读取媳妇言消息。

WithLocalizedMessage

您可以通过调用 WithLocalizedMessage 方法，传递资源类型和资源名称，使错误消息支持本地媳妇言。

RuleFor(x => x.Surname).NotNull().WithLocalizedMessage(typeof(MyLocalizedMessages), "SurnameRequired");

默认错误消息

如果您要替换 FluentValidation 的默认错误提示，可以实现 ILanguageManager 接口，该接口支持本地化媳妇言。

public class CustomLanguageManager : FluentValidation.Resources.LanguageManager {
  public CustomLanguageManager() {
    AddTranslation("en", "NotNullValidator", "'{PropertyName}' is required.");
  }
}

以上代码为 NotNullValidator 验证器自定义英文错误提示消息，当然也可以实现更多的语言，定义好 LanguageManager 后，需要在启动时进行配置。

ValidatorOptions.LanguageManager = new CustomLanguageManager();

禁用本地化媳妇言

您可以完全禁用 FluentValidation 对本地化的支持, 这将强制使用默认的英文语言, 而不考虑线程的 CurrentUICulture。这可以通过静态类 ValidatorOptions 在应用程序的启动例程中完成。

ValidatorOptions.LanguageManager.Enabled = false;

还可以强制指定默认语言，始终以特定语言显示:

ValidatorOptions.LanguageManager.Culture = new CultureInfo("fr");

ASP.NET Core 集成

FluentValidation 可以与 ASP.NET Core 集成, 要启用 MVC 集成, 您需要通过 NuGet 包来添加对程序集 FluentValidation.AspNetCore 的引用:

Install-Package FluentValidation.AspNetCore

安裝後, 您需要引用命名空間 using fluentvalidation.aspnetcore，然後，在應用程式的啟動類 startup 中通過調用 services 的擴展方法 addfluentvalidation 進行配置。

public void ConfigureServices(IServiceCollection services) {
    services.AddMvc(setup => {
      //...mvc setup...
    }).AddFluentValidation();
}

為了讓 asp.net core 發現您的驗證程式, 必須在服務集容器中註冊它們。

public void ConfigureServices(IServiceCollection services) {
    services.AddMvc(setup => {
      //...mvc setup...
    }).AddFluentValidation();

    services.AddTransient<IValidator<Person>, PersonValidator>();
    //etc
}

或使用 addfromassemblycontaining 方法自動註冊特定程式集中的所有驗證器。

services.AddMvc()
  .AddFluentValidation(fv => fv.RegisterValidatorsFromAssemblyContaining<PersonValidator>());

本示例定義 personvalidator 驗證器，用於驗證 person 類型。

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);
	}
}

定義控制器 peoplecontroller 用於創建並保存 person 實例，使用 modelstate.isvalid 判斷用戶的輸入是否驗證通過。

public class PeopleController : Controller {
	public ActionResult Create() {
		return View();
	}

	[HttpPost]
	public IActionResult Create(Person person) {

		if(! ModelState.IsValid) { // re-render the view when validation failed.
			return View("Create", person);
		}

		Save(person); //Save the person to the database, or some other logic

		TempData["notice"] = "Person successfully created";
		return RedirectToAction("Index");

	}
}

這是我們創建 person 的視圖代碼：

@model Person

<div asp-validation-summary="ModelOnly"></div>

<form asp-action="Create">
  Id: <input asp-for="Id" /> <span asp-validation-for="Id"></span>
  <br />
  Name: <input asp-for="Name" /> <span asp-validation-for="Name"></span>
  <br />
  Email: <input asp-for="Email" /> <span asp-validation-for="Email"></span>
  <br />
  Age: <input asp-for="Age" /> <span asp-validation-for="Age"></span>

  <br /><br />
  <input type="submit" value="submtit" />
</form>

現在, 當您提交表單時, mvc 的模型綁定系統將使用 personpersonvalidator 驗證輸入，並將驗證結果保存至 modelstate 用於判斷。

與 asp.net core 內置驗證的兼容性

默認情況下, 在執行 fluentvalidation 驗證之後, mvc 原生內置的 dataannotations 驗證方式也可能執行，這意味著您可以將 fluentvalidation 與 dataannotations 驗證混合在一起使用。如果要禁用此行為, 將 fluentvalidation 設為唯一的驗證庫, 可以將 rundefaultmvcvalidationafterfluentvalidationexecutes 屬性設為 false 值：

services.AddMvc().AddFluentValidation(fv => {
 fv.RunDefaultMvcValidationAfterFluentValidationExecutes = false;
});

隱式與顯式子屬性驗證

在驗證複雜對象時, 默認情況下, 您必須手動通過 setvalidator 方法指定複雜屬性的子驗證器。運行 asp.net mvc 應用程式時, 還可以選擇為子屬性啟用隱式驗證，啟用此功能時, mvc 的驗證基礎結構將會自動查找每個屬性的驗證程式, 而不必指定的子驗證程式，這可以通過將 setvalidatorimplicitlyvalidatechildproperties 設置為 true 來完成:

services.AddMvc().AddFluentValidation(fv => {
 fv.ImplicitlyValidateChildProperties = true;
});

請注意, 如果啟用此行為, 則不應手動通過 setvalidator 指定子屬性驗證程式, 否則，驗證程式將執行兩次。

客戶端驗證

fluentvalidation 是服務端驗證框架, 不直接提供任何客戶端驗證。但是, 它可以生成 jquery 驗證框架支持的 html 元素元數據，用於支持 jquery.validate 框架的自動驗證。

手動驗證

有時您可能需要手動驗證 mvc 項目中的對象，在這種情況下， 我們可以將驗證結果複製到 mvc 的 modelstate 字典中，便可用於前端錯誤提示。

public ActionResult DoSomething() {
  var customer = new Customer();
  var validator = new CustomerValidator();
  var results = validator.Validate(customer);

  results.AddToModelState(ModelState, null);
  return View();
}

addtomodelstate 方法是作為擴展方法實現的, 需要引用 fluentvalidation 命名空間，請注意, 第二個參數是可選的模型名稱前綴, 該參數可設置對象屬性在 modelstate 字典中的前綴。

驗證程式自定義

您可以使用 customizevalidatorattribute 為模型指定驗證程式，也支持為驗證器指定規則集。

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

這相當於為驗證指定規則集，等同於將規則集傳遞給驗證程式：

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

該屬性還可用於調用單個屬性的驗證:

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

這相當於對驗證程式指定特定屬性，其他屬性將不被驗證：

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

也可以使用 customizevalidatorattribute 特性跳過某些類型的驗證。

public ActionResult Save([CustomizeValidator(Skip=true)] Customer cust) {
  // ...
}

驗證器攔截器

您可以使用攔截器進一步自定義驗證過程，攔截器必須實現 fluentvalidation.mvc 命名空間中的 ivalidatorinterceptor 接口：

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

此接口有兩個方法：beforemvcvalidation 和 aftermvcvalidation，分別可攔截驗證前和驗證後的過程。除了在驗證程式類中直接實現此接口外, 我們還可以在外部實現該接口, 通過 customizevalidatorattribute 特性指定攔截器:

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

在這種情況下, 攔截器必須是一個實現 ivalidatorinterceptor 接口，並具有公共無參數構造函數的類。請注意, 攔截器是高級方案，大多數情況下, 您可能不需要使用攔截器, 但如果需要, 可以選擇它。

為客戶端指定規則集

默認情況下 fluentvalidation 不會為客戶端生成基於規則集的驗證代碼, 但您可以通過 rulesetforclientsidemessagesattribute 為客戶端指定規則集。

[RuleSetForClientSideMessages("MyRuleset")]
public ActionResult Index() {
   return View(new PersonViewModel());
}

也可以在控制器中使用 setrulesetforclientsidemessages 擴展方法 (需要引用 fluentvalidation 命名空間)為客戶端指定規則集。

public ActionResult Index() {
   ControllerContext.SetRulesetForClientsideMessages("MyRuleset");
   return View(new PersonViewModel());
}

asp.net mvc 5 集成

fluentvalidation 還可以與舊的 asp.net mvc 5 項目集成，需要通過 nuget 添加對程式集 fluentvalidation.mvc5 的引用，然後引用 fluentvalidation.mvc 命名空間：

Install-Package FluentValidation.Mvc5

安裝後, 需要在應用程式全局文件 (global.asax) 中配置 application_start 事件，以便於 fluentvalidation 執行初始化。

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

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

    FluentValidationModelValidatorProvider.Configure();
}

在 mvc 內部, fluentvalidation 利用驗證器工廠為特定類型創建驗證程式，默認情況下使用 attributedvalidatorfactory 工廠，通過特性的方式，允許您為指定的模型設置驗證程式：

[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);
	}
}

您還可以使用 mvc 自帶的 ioc 依賴注入容器實現自定義的驗證器工廠, 而不是使用上述特性標記的方法。

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

最後, 我們可以創建控制器和與之關聯的視圖:

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");

	}
}

這是相應的視圖代碼：

@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" />
}

現在, 當您提交表單時， mvc 的將使用 fluentvalidation 框架驗證模型。

特別說明

在 asp.net mvc 5 中使用 fluentvalidation 框架，和 asp.net core 基本相同，所以，客戶端驗證、手動驗證、驗證程式自定義、驗證器攔截器和客戶端規則集都類似於上文，由於文章篇幅，這裡將不再贅述。

asp.net webapi 2 集成

fluentvalidation 的 webapi 的集成 與 mvc 5 集成 (上面) 相同, 但您需要通過 nuget 引用 fluentvalidation.webapi 程式包。

出處：https://www.xcode.me/post/5849（站長註：該連結已失敗，可在博客園瀏覽轉載文章：https://www.cnblogs.com/mq0036/p/14548370.html）