FluentValidation：更优雅的验证方法

发布时间：2023-05-22

在软件开发中，数据验证是很重要的一环。我们需要保证我们的应用程序接收的数据是有效、正确的，因此我们需要一套强大的验证库。在这篇文章中，我们将详细介绍 FluentValidation，这是一个非常流行的验证库。

一、简介

FluentValidation 是一个开源的 .NET 核心库，可以帮助我们运用一种更加优雅的方式来验证对象、模型、集合等。它提供了一种声明式的验证方法，使我们能够轻松地编写出易于维护的验证规则。 FluentValidation 的特点在于易于使用，同时非常灵活。它支持复杂的验证规则，并且可以轻松地定制错误信息。它还可以轻松地与 ASP.NET Core 集成，因此我们可以在验证期间对 HTTP 请求进行验证。

二、安装与使用

首先，我们需要安装 FluentValidation 及其相关扩展包：

Install-Package FluentValidation
Install-Package FluentValidation.AspNetCore

我们可以使用 NuGet 包管理器，或者使用 Package Manager Console 来进行安装。 在使用 FluentValidation 前，我们需要创建一个验证器类，如下所示：

public class PersonValidator : AbstractValidator<Person>
{
    public PersonValidator()
    {
        RuleFor(person => person.FirstName).NotEmpty();
        RuleFor(person => person.LastName).NotEmpty();
        RuleFor(person => person.Email).EmailAddress();
    }
}

在这个示例中，我们创建了一个名为 PersonValidator 的验证器类，它继承自 AbstractValidator 类。PersonValidator 类的泛型参数指定了要验证的类型，这里是 Person 类型。 在构造函数中，我们定义了三个验证规则。这些规则说明了一个人的名字和电子邮件地址不能为空，并且必须是有效的电子邮件地址。 一旦我们定义了验证器，我们就可以将其用于验证 Person 对象，如下所示：

var person = new Person();
var validator = new PersonValidator();
ValidationResult result = validator.Validate(person);
if(result.IsValid)
{
    // 对象验证成功
}
else
{
    // 对象验证失败
}

在这个例子中，我们首先创建了一个 Person 对象和一个 PersonValidator 实例。然后，我们将 Person 对象传递给验证器的 Validate 方法进行验证。如果验证通过，则 IsValid 属性将返回 true，否则返回 false。

三、验证规则

FluentValidation 提供了很多内置的验证规则，同时也支持自定义验证规则。

1. 内置验证规则

下表列出了 FluentValidation 内置的一些常见验证规则：

验证规则 说明
NotNull 验证对象不为空
NotEmpty 验证字符串不为空
EmailAddress 验证字符串是有效的电子邮件地址
Equal 验证对象是否相等
GreaterThan 验证对象是否大于指定的值
LessThan 验证对象是否小于指定的值
InclusiveBetween 验证对象是否在指定范围内
ExclusiveBetween 验证对象是否在指定范围外
Matches 验证字符串是否匹配指定的正则表达式
Length 验证字符串的长度是否在指定范围内
这些规则非常基础，它们可以满足我们的大部分需求。如果需要自定义验证规则，我们可以使用自定义验证器。

2. 自定义验证器

自定义验证器可以通过继承自 AbstractValidator 来创建。定义自定义验证器的方式与定义内置验证器的方式非常相似。例如，我们可以创建一个验证器来验证密码是强密码：

public class PasswordValidator : AbstractValidator<string>
{
    public PasswordValidator()
    {
        RuleFor(password => password).Must(password =>
        {
            var lower = false;
            var upper = false;
            var digit = false;
            var special = false;
            foreach (var character in password)
            {
                if (char.IsLower(character))
                {
                    lower = true;
                }
                else if (char.IsUpper(character))
                {
                    upper = true;
                }
                else if (char.IsDigit(character))
                {
                    digit = true;
                }
                else if (char.IsSymbol(character) || char.IsPunctuation(character))
                {
                    special = true;
                }
            }
            return lower && upper && digit && special;
        }).WithMessage("密码必须包含至少一个小写字母、一个大写字母、一个数字和一个特殊字符。");
    }
}

在这个示例中，我们创建了一个名为 PasswordValidator 的验证器类，它继承自 AbstractValidator<string>。在构造函数中，我们编写了一个验证规则。我们首先将密码字符串转换为 char 数组，并遍历整个数组。我们使用 char.IsLower、char.IsUpper、char.IsDigit 和 char.IsSymbol 方法来获取字符的类型，并将其保存在不同的布尔变量中。 然后，我们返回一个逻辑值，该值指示密码字符串是否包含小写字母、大写字母、数字和特殊字符。如果该方法返回 false，则验证失败，并显示指定的错误消息。

四、自定义错误消息

默认情况下，FluentValidation 会为每个验证规则生成一个默认的错误消息。如果我们需要自定义错误消息，可以使用 WithMessage 方法。这个方法需要一个字符串参数，这个参数就是我们要显示的错误消息。 例如，我们可以自定义 PersonValidator 验证器的错误消息：

public class PersonValidator : AbstractValidator<Person>
{
    public PersonValidator()
    {
        RuleFor(person => person.FirstName).NotEmpty().WithMessage("FirstName 不能为空");
        RuleFor(person => person.LastName).NotEmpty().WithMessage("LastName 不能为空");
        RuleFor(person => person.Email).EmailAddress().WithMessage("邮件地址不合法");
    }
}

在这个示例中，我们使用 WithMessage 方法来自定义每个验证规则的错误消息。这些错误消息将用于验证 Person 对象时出现错误时的提示。

五、复杂对象验证

在某些情况下，我们需要验证更复杂的对象，如嵌套对象、集合等。FluentValidation 提供了一种简单而灵活的方式来实现这一点。 考虑以下场景。我们需要验证一个订单对象，该对象包含多个产品。我们需要验证每个产品的名称和价格是否非空，并且订单总价是否正确。

public class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
}
public class Order
{
    public List<Product> Products { get; set; }
}
public class OrderValidator : AbstractValidator<Order>
{
    public OrderValidator()
    {
        RuleForEach(order => order.Products).SetValidator(new ProductValidator());
        RuleFor(order => order.Products.Sum(p => p.Price))
            .Equal(order => order.TotalPrice).WithMessage("订单总价错误");
    }
}
public class ProductValidator : AbstractValidator<Product>
{
    public ProductValidator()
    {
        RuleFor(product => product.Name).NotEmpty();
        RuleFor(product => product.Price).GreaterThan(0);
    }
}

在这个示例中，我们首先定义了一个 Product 类和一个 Order 类。Product 类表示一个产品，包含名称和价格属性。Order 类表示一个订单，包含一个产品列表。我们还定义了一个 OrderValidator 类，它继承自 AbstractValidator<Order>。在构造函数中，我们使用 RuleForEach 方法来验证订单中的每个产品。我们将 ProductValidator 的实例传递给 SetValidator 方法，这将验证 Order 对象中的每个产品。 在 ProductValidator 类中，我们定义了两个验证规则。一个是确认产品名称非空，另一个是确认价格大于零。 最后，我们在 OrderValidator 中定义了一个验证规则，该规则使用 Equals 方法验证订单总价是否正确。如果验证失败，则显示指定的错误消息。

总结

在本文中，我们详细介绍了 FluentValidation 库，一种更加优雅的验证方式。我们了解了如何创建验证器、编写验证规则、自定义错误消息和验证复杂的对象。通过这篇文章，希望能够帮助读者更好地理解 FluentValidation 的使用方法，以及它为我们带来的便利。

推荐文章