S7netplus 数据读取技巧：使用C#实现高效读取

## 简介

Hangfire是一个强大的开源库,用于在.NET应用程序中执行后台作业。它提供了一种简单而有效的方式来处理各种类型的后台任务,如定时作业、延迟作业和重复作业等。本文将深入探讨Hangfire的特性,并通过多个实例演示其在C#项目中的应用。

## Hangfire的主要特性

- 持久性和可靠性：作业存储在持久化存储中（如数据库）
- 分布式处理：支持多服务器环境
- 自动重试：失败作业会自动重试
- 实时监控：提供Web界面监控作业状态
- 多种存储选项：支持SQL Server, Redis等
- 易于集成：可以轻松集成到现有.NET项目中



## 安装和配置

### 安装Hangfire

使用NuGet包管理器安装Hangfire:

```C#
Install-Package Hangfire
```

对于SQL Server存储,还需要安装:

```PowerShell
Install-Package Hangfire.SqlServer
```

### 基本配置

在`Program.cs`文件中配置Hangfire:

```C#
// 添加Hangfire服务
builder.Services.AddHangfire(configuration => configuration
    .SetDataCompatibilityLevel(CompatibilityLevel.Version_170)
    .UseSimpleAssemblyNameTypeSerializer()
        .UseRecommendedSerializerSettings()
    .UseSqlServerStorage(_configuration.GetConnectionString("HangfireConnection"), new SqlServerStorageOptions
    {
        CommandBatchMaxTimeout = TimeSpan.FromMinutes(5),
        SlidingInvisibilityTimeout = TimeSpan.FromMinutes(5),
        QueuePollInterval = TimeSpan.Zero,
        UseRecommendedIsolationLevel = true,
        DisableGlobalLocks = true
    }));

// 添加Hangfire服务器
builder.Services.AddHangfireServer();

```

## 基本用法

### 创建和执行即发即弃作业

```C#
public class EmailService
{
    public void SendWelcomeEmail(string email)
    {
        // 发送欢迎邮件的逻辑
        Console.WriteLine($"Welcome email sent to {email}");
    }
}

```

```C#
[Route("api/[controller]")]
[ApiController]
public class UserController : ControllerBase
{
    [HttpPost]
    public IActionResult Register(string email)
    {
        // 用户注册逻辑...

        // 创建后台作业发送欢迎邮件
        BackgroundJob.Enqueue<EmailService>(x => x.SendWelcomeEmail(email));

        return Ok("User registered successfully");
    }
}

```

### 延迟作业

```C#
public class ReminderService
{
    public void SendReminder(int userId, string message)
    {
        // 发送提醒的逻辑
        Console.WriteLine($"Reminder sent to user {userId}: {message}");
    }
}

```

```C#
[Route("api/[controller]")]
[ApiController]
public class TaskController : ControllerBase
{
    [HttpPost]
    public IActionResult CreateTask(int userId, string taskDescription)
    {
        // 创建任务逻辑...

        // 创建延迟作业,24小时后发送提醒
        BackgroundJob.Schedule<ReminderService>(
            x => x.SendReminder(userId, $"Don't forget your task: {taskDescription}"),
            TimeSpan.FromHours(24));

        return Ok("Task created and reminder scheduled");
    }
}

```


![image.png](https://blog.idiosoft.com/static/img/f181ce26cf1e42b7edbcfd2aae44c579.image.webp)

### 重复作业

```C#
public class DatabaseCleanupService
{
    public void PerformCleanup()
    {
        // 数据库清理逻辑
        Console.WriteLine("Database cleanup performed at: " + DateTime.Now);
    }
}

```

`Program.cs`

```C#
// 在这里设置重复作业  
using (var scope = app.Services.CreateScope())
{
    var recurringJobManager = scope.ServiceProvider.GetRequiredService<IRecurringJobManager>();
    recurringJobManager.AddOrUpdate<DatabaseCleanupService>(
        "database-cleanup",
        x => x.PerformCleanup(),
        Cron.Daily);
}
```

## 批量处理与进度报告

这个例子展示了如何使用Hangfire处理大量数据,并报告进度。

```C#
public class BatchProcessingService
{
    private readonly ILogger<BatchProcessingService> _logger;

    public BatchProcessingService(ILogger<BatchProcessingService> logger)
    {
        _logger = logger;
    }

    public void ProcessLargeDataSet(int batchSize, int totalItems)
    {
        var batchCount = (int)Math.Ceiling((double)totalItems / batchSize);

        for (int i = 0; i < batchCount; i++)
        {
            var batchNumber = i;
            BackgroundJob.Enqueue(() => ProcessBatch(batchNumber, batchSize, totalItems));
        }
    }

    public void ProcessBatch(int batchNumber, int batchSize, int totalItems)
    {
        var startIndex = batchNumber * batchSize;
        var endIndex = Math.Min(startIndex + batchSize, totalItems);

        for (int i = startIndex; i < endIndex; i++)
        {
            // 处理单个项目的逻辑
            _logger.LogInformation($"Processing item {i}");
        }

        var progress = (int)((endIndex / (double)totalItems) * 100);
        _logger.LogInformation($"Batch {batchNumber} completed. Overall progress: {progress}%");
    }
}

```

```C#
[Route("api/[controller]")]
[ApiController]
public class DataProcessingController : ControllerBase
{
    private readonly BatchProcessingService _batchProcessingService;

    public DataProcessingController(BatchProcessingService batchProcessingService)
    {
        _batchProcessingService = batchProcessingService;
    }

    [HttpPost]
    public IActionResult StartBatchProcessing()
    {
        BackgroundJob.Enqueue(() => _batchProcessingService.ProcessLargeDataSet(100, 10000));
        return Ok("Batch processing started");
    }
}

```


![image.png](https://blog.idiosoft.com/static/img/efb9a82a3406d193337b82f850067235.image.webp)

## 定时报告生成与邮件发送

这个例子展示了如何使用Hangfire定期生成报告并通过邮件发送。

```C#
public interface IEmailService
{
    void SendEmail(string recipient, string subject, string body);
}

public class EmailService : IEmailService
{
    public void SendEmail(string recipient, string subject, string body)
    {
        // send an email
        Console.WriteLine($"Email sent to {recipient} with subject: {subject}");
    }
}

// Define the IReportGenerator interface
public interface IReportGenerator
{
    string GenerateMonthlyReport();
}

// Implement the IReportGenerator interface
public class ReportGenerator : IReportGenerator
{
    public string GenerateMonthlyReport()
    {
        return "This is the monthly report content.";
    }
}

// The ReportingService class as defined
public class ReportingService
{
    private readonly IEmailService _emailService;
    private readonly IReportGenerator _reportGenerator;
    private readonly IBackgroundJobClient _backgroundJobClient;

    public ReportingService(IEmailService emailService, IReportGenerator reportGenerator, IBackgroundJobClient backgroundJobClient)
    {
        _emailService = emailService;
        _reportGenerator = reportGenerator;
        _backgroundJobClient = backgroundJobClient;
    }

    public void GenerateAndSendMonthlyReport()
    {
        var report = _reportGenerator.GenerateMonthlyReport();
        var recipients = new[] { "manager@example.com", "director@example.com" };

        foreach (var recipient in recipients)
        {
            _backgroundJobClient.Enqueue(() => _emailService.SendEmail(recipient, "Monthly Report", report));
        }
    }
}

```

```C#
// 在这里设置重复作业  
using (var scope = app.Services.CreateScope())
{
    var recurringJobManager = scope.ServiceProvider.GetRequiredService<IRecurringJobManager>();
    recurringJobManager.AddOrUpdate<ReportingService>(
        "monthly-report",
        x => x.GenerateAndSendMonthlyReport(),
        Cron.Monthly(1, 2)); //每月第一天凌晨2点

}

```

## 使用Hangfire进行缓存预热

这个例子展示了如何使用Hangfire定期预热应用程序缓存。

```C#
public class CacheWarmupService
{
    private readonly IMemoryCache _cache;
    private readonly IProductRepository _productRepository;

    public CacheWarmupService(IMemoryCache cache, IProductRepository productRepository)
    {
        _cache = cache;
        _productRepository = productRepository;
    }

    public void WarmupProductCache()
    {
        var products = _productRepository.GetAllProducts();
        foreach (var product in products)
        {
            _cache.Set($"product_{product.Id}", product, TimeSpan.FromHours(1));
        }
        Console.WriteLine($"Cache warmed up at {DateTime.Now}");
    }
}

// 注册定时作业
using (var scope = app.Services.CreateScope())
{
    var recurringJobManager = scope.ServiceProvider.GetRequiredService<IRecurringJobManager>();
    recurringJobManager.AddOrUpdate<CacheWarmupService>(
        "monthly-report",
        x => x.WarmupProductCache(),
        Cron.Hourly);

}

```

## 最佳实践

1. **使用依赖注入**: Hangfire支持依赖注入,利用这一特性来管理服务的生命周期。
2. **适当的异常处理**: 在后台作业中实现适当的异常处理,以确保作业失败时能够正确重试或记录。
3. **监控和日志**: 利用Hangfire的仪表板和日志功能来监控作业执行情况。
4. **作业幂等性**: 设计作业使其具有幂等性,这样即使重复执行也不会产生副作用。
5. **合理使用重试**: 配置合适的重试策略,避免无限重试导致资源浪费。

## 结论

Hangfire为.NET开发者提供了一个强大而灵活的后台作业处理解决方案。通过本文的示例和最佳实践,你应该能够在自己的C#项目中有效地使用Hangfire来管理各种类型的后台任务。无论是简单的延迟作业还是复杂的重复任务,Hangfire都能满足你的需求,同时保证可靠性和可扩展性。

Hangfire：.NET开发者的后台任务神器

本示例展示了如何在WinForms应用程序中使用ScottPlot 5.0创建一个带有十字光标的交互式图表。我们将绘制一个正弦波，并添加一个跟随鼠标移动的十字光标。

## 准备工作

首先，确保你已经安装了必要的NuGet包：

- ScottPlot (5.0.x)
- ScottPlot.WinForms (5.0.x)



## 完整代码

以下是完整的C#代码，包含详细注释：

```C#
public partial class Form1 : Form
{
    private FormsPlot formsPlot1;
    private Crosshair crosshair;
    private ScottPlot.Plottables.Text text;

    public Form1()
    {
        InitializeComponent();
        SetupPlot();
    }

    private void SetupPlot()
    {
        // 创建 FormsPlot 控件  
        formsPlot1 = new FormsPlot();

        formsPlot1.Plot.Font.Set("SimSun");

        formsPlot1.Dock = DockStyle.Fill;
        this.Controls.Add(formsPlot1);

        // 生成示例数据（正弦波）  
        int pointCount = 1000;
        double[] dataX = new double[pointCount];
        double[] dataY = new double[pointCount];
        for (int i = 0; i < pointCount; i++)
        {
            dataX[i] = i;
            dataY[i] = Math.Sin(i * 0.05);
        }

        // 添加散点图  
        var scatter = formsPlot1.Plot.Add.Scatter(dataX, dataY);
        scatter.Color = Colors.Blue;
        scatter.MarkerSize = 0; // 不显示点标记，只显示线  

        // 设置轴标签  
        formsPlot1.Plot.XLabel("X轴");
        formsPlot1.Plot.YLabel("Y轴");
        formsPlot1.Plot.Title("带十字光标的正弦波图");

        // 创建十字光标  
        crosshair = formsPlot1.Plot.Add.Crosshair(0, 0);
        crosshair.MarkerColor = Colors.Red;
        crosshair.LineWidth = 1;
        crosshair.LinePattern = LinePattern.Dashed;

        // 创建一个文本注释来显示光标位置  
        text = formsPlot1.Plot.Add.Text("", 10, 10);
        text.Alignment = Alignment.UpperLeft;
        text.FontSize = 14;

        // 添加鼠标移动事件处理器  
        formsPlot1.MouseMove += FormsPlot1_MouseMove;
    }

    private void FormsPlot1_MouseMove(object sender, MouseEventArgs e)
    {
        // 获取鼠标在图表坐标系中的位置  
        var d = formsPlot1.Plot.GetCoordinates(e.X, e.Y);

        // 更新十字光标位置  
        crosshair.X = d.X;
        crosshair.Y = d.Y;

        // 更新文本注释  
        text.LabelText = $"X: {d.X:F2}, Y: {d.Y:F2}";

        // 请求重绘  
        formsPlot1.Refresh();
    }

}


```


![image.png](https://blog.idiosoft.com/static/img/66b5cfc2ec8d87649ad95227aff7a54d.image.webp)

## 代码解释

### 十字光标和文本注释

- **`crosshair = formsPlot1.Plot.Add.Crosshair(0, 0);`**：创建一个十字光标，初始位置在 (0, 0)。
    - **`crosshair.MarkerColor = Colors.Red;`**：设置十字光标的颜色为红色。
    - **`crosshair.LineWidth = 1;`**：设置线宽。
    - **`crosshair.LinePattern = LinePattern.Dashed;`**：设置线型为虚线。
- **`text = formsPlot1.Plot.Add.Text("", 10, 10);`**：创建一个文本注释，用于显示十字光标的位置。
    - **`text.Alignment = Alignment.UpperLeft;`**：设置文本对齐方式为左上。
    - **`text.FontSize = 14;`**：设置文本字体大小。

## 注意事项

- 这个示例使用了ScottPlot 5.0的新API，与早期版本可能有所不同。
- 确保使用最新版本的ScottPlot和ScottPlot.WinForms包。

这个示例展示了如何创建一个基本的交互式图表，包括十字光标和坐标显示。你可以根据需要进一步自定义和扩展这个示例。

ScottPlot 5.0 WinForms 十字光标示例

Titanium Web Proxy是一个强大的开源.NET库,用于截获、查看和修改HTTP/HTTPS流量。本文将详细介绍如何使用Titanium Web Proxy来截获系统中的所有HTTP通信,并提供多个实用示例。

## 目录

1. [安装Titanium Web Proxy](#安装titanium-web-proxy)
2. [基本用法](#基本用法)
3. [高级功能](#高级功能)
    - [修改请求和响应](#修改请求和响应)
    - [处理HTTPS流量](#处理https流量)
    - [自定义证书验证](#自定义证书验证)
    - [处理WebSocket连接](#处理websocket连接)
4. [性能优化](#性能优化)
5. [最佳实践和注意事项](#最佳实践和注意事项)



## 安装Titanium Web Proxy

首先,通过NuGet包管理器安装Titanium Web Proxy:

```C#
Install-Package Titanium.Web.Proxy
```


![image.png](https://blog.idiosoft.com/static/img/bcef444a81f3d03f926cf6cee06fba86.image.webp)

或者在你的项目文件中添加以下引用:

```XML
<PackageReference Include="Titanium.Web.Proxy" Version="3.1.1397" />
```

## 基本用法

以下是一个基本的示例,展示如何设置Titanium Web Proxy并开始截获HTTP流量:

```C#
using System;
using System.Threading.Tasks;
using Titanium.Web.Proxy;
using Titanium.Web.Proxy.EventArguments;
using Titanium.Web.Proxy.Models;

class Program
{
    static async Task Main(string[] args)
    {
        var proxyServer = new ProxyServer();

        // 创建一个显式端点
        var explicitEndPoint = new ExplicitProxyEndPoint(System.Net.IPAddress.Any, 8000, true);

        // 添加端点
        proxyServer.AddEndPoint(explicitEndPoint);

        // 注册事件处理程序
        proxyServer.BeforeRequest += OnRequest;
        proxyServer.BeforeResponse += OnResponse;

        // 启动代理服务器
        proxyServer.Start();

        // 将代理设置为系统代理
        proxyServer.SetAsSystemHttpProxy(explicitEndPoint);
        proxyServer.SetAsSystemHttpsProxy(explicitEndPoint);

        Console.WriteLine("代理服务器已启动在端口 8000。按任意键退出...");
        Console.ReadKey();

        // 停止代理服务器
        proxyServer.Stop();
    }

    private static Task OnRequest(object sender, SessionEventArgs e)
    {
        Console.WriteLine($"请求: {e.HttpClient.Request.Url}");
        return Task.CompletedTask;
    }

    private static Task OnResponse(object sender, SessionEventArgs e)
    {
        Console.WriteLine($"响应: {e.HttpClient.Request.Url}, 状态码: {e.HttpClient.Response.StatusCode}");
        return Task.CompletedTask;
    }
}
```


![image.png](https://blog.idiosoft.com/static/img/7f693f142da5e31751fb671eb7b90b64.image.webp)

这个基本示例设置了一个代理服务器,监听所有接口的8000端口,并将其设置为系统代理。它会打印出所有请求和响应的基本信息。

## 高级功能

### 修改请求和响应

Titanium Web Proxy允许你修改请求和响应。以下是一个更复杂的示例:

```C#
private static async Task OnRequest(object sender, SessionEventArgs e)
{
    Console.WriteLine($"请求: {e.HttpClient.Request.Method} {e.HttpClient.Request.Url}");

    // 修改请求头
    e.HttpClient.Request.Headers.AddHeader("X-Intercepted-By", "Titanium");

    // 修改请求体 (如果是POST请求)
    if (e.HttpClient.Request.Method == "POST")
    {
        string body = await e.GetRequestBodyAsString();
        body = body.Replace("oldValue", "newValue");
        e.SetRequestBodyString(body);
    }

    // 重定向请求
    if (e.HttpClient.Request.RequestUri.Host.Contains("example.com"))
    {
        e.Redirect("https://google.com");
    }
}

private static async Task OnResponse(object sender, SessionEventArgs e)
{
    Console.WriteLine($"响应: {e.HttpClient.Request.Url}, 状态码: {e.HttpClient.Response.StatusCode}");

    // 修改响应头
    e.HttpClient.Response.Headers.AddHeader("X-Proxy-Modified", "True");

    // 修改响应体
    if (e.HttpClient.Response.ContentType != null && e.HttpClient.Response.ContentType.Trim().ToLower().Contains("text/html"))
    {
        string body = await e.GetResponseBodyAsString();
        body = body.Replace("</body>", "<script>alert('Intercepted by Titanium!');</script></body>");
        e.SetResponseBodyString(body);
    }
}
```


![image.png](https://blog.idiosoft.com/static/img/a6b94b9bc96e6e3795035e8e14adcc43.image.webp)

### 处理HTTPS流量

Titanium Web Proxy可以解密HTTPS流量。默认情况下,它会为每个域生成一个自签名证书。你可以自定义这个行为:

```TypeScript
// 在Main方法中
proxyServer.CertificateManager.CreateRootCertificate(false);
proxyServer.CertificateManager.TrustRootCertificate(true);

// 可选：使用自定义证书
// var certificate = new X509Certificate2("path_to_pfx_file", "password");
// proxyServer.CertificateManager.RootCertificate = certificate;

// 设置服务器证书验证回调
proxyServer.ServerCertificateValidationCallback += OnCertificateValidation;

// ...

private static Task OnCertificateValidation(object sender, CertificateValidationEventArgs e)
{
    // 总是信任远程证书
    e.IsValid = true;
    return Task.CompletedTask;
}
```

### 自定义证书验证

你可以实现自定义的证书验证逻辑:

```C#
private static Task OnCertificateValidation(object sender, CertificateValidationEventArgs e)
{
    if (e.SslPolicyErrors == System.Net.Security.SslPolicyErrors.None)
    {
        e.IsValid = true;
    }
    else
    {
        // 自定义验证逻辑
        if (e.ServerCertificate.Subject.Contains("trusted-domain.com"))
        {
            e.IsValid = true;
        }
        else
        {
            e.IsValid = false;
        }
    }
    return Task.CompletedTask;
}
```

### 处理WebSocket连接

Titanium Web Proxy也支持拦截WebSocket连接:

```C#
private static async Task OnRequest(object sender, SessionEventArgs e)
{
    if (e.HttpClient.Request.Method == "CONNECT" && e.HttpClient.ConnectRequest.TunnelType == TunnelType.Websocket)
    {
        Console.WriteLine($"WebSocket连接: {e.HttpClient.Request.Url}");

        // 你可以在这里修改WebSocket握手请求  
        e.HttpClient.Request.Headers.AddHeader("X-WebSocket-Intercepted", "True");

        // 如果你想拦截WebSocket消息，可以这样做：  
        e.DataReceived += OnWebSocketDataReceived;
        e.DataSent += OnWebSocketDataSent;
    }
}

private static void OnWebSocketDataReceived(object sender, DataEventArgs e)
{
    Console.WriteLine($"接收到WebSocket数据: {e.Buffer.Length} 字节");
    // 在这里处理接收到的WebSocket数据  
}

private static void OnWebSocketDataSent(object sender, DataEventArgs e)
{
    Console.WriteLine($"发送WebSocket数据: {e.Buffer.Length} 字节");
    // 在这里处理发送的WebSocket数据  
}

```

## 性能优化

对于高流量场景,可以考虑以下优化:

异步处理:

```C#
private static async Task OnRequest(object sender, SessionEventArgs e)
{
    // 对于耗时操作，使用Task.Run来避免阻塞
    await Task.Run(async () =>
    {
        // 执行耗时操作
        await SomeTimeConsumingOperation();
    });
}
```

选择性拦截:

```C#
private static Task OnRequest(object sender, SessionEventArgs e)
{
    // 只拦截特定域名的请求
    if (e.HttpClient.Request.RequestUri.Host.Contains("example.com"))
    {
        // 执行拦截逻辑
    }
    else
    {
        // 对于其他请求，直接放行
    }
    return Task.CompletedTask;
}
```

## 最佳实践和注意事项

1. **证书管理**: 在生产环境中,确保使用受信任的根证书,并妥善管理。
2. **错误处理**: 实现全面的错误处理,以防止单个请求的失败影响整个代理服务器。

```C#
private static async Task OnRequest(object sender, SessionEventArgs e)
{
    try
    {
        // 处理请求
    }
    catch (Exception ex)
    {
        Console.WriteLine($"处理请求时发生错误: {ex.Message}");
        // 可以选择让请求继续,或者返回一个错误响应
        e.Ok();
    }
}
```
3. **资源管理**: 正确释放资源,特别是在处理大文件时。
4. **隐私和合规性**: 确保你有合法权利拦截流量,并遵守相关的数据保护法规。
5. **性能监控**: 实现性能监控,以便及时发现和解决瓶颈。

```C#
proxyServer.OnServerConnectionCreate+= OnServerConnectionCreate;

private static void OnServerConnectionCreate(object sender, Socket e)
{
    Console.WriteLine($"创建新连接,当前连接数: {proxyServer.ClientConnectionCount}");
}
```

通过遵循这些最佳实践和注意事项,你可以构建一个强大、高效且可靠的HTTP拦截系统。记住,拦截HTTP流量是一个强大的功能,应该谨慎使用,并始终考虑到安全性和隐私问题。

网络安全新武器：C# Titanium Web Proxy助你监控全系统HTTP流量

## 简介

FluentValidation是一个流行的.NET验证库,它提供了一种优雅的方式来定义强类型的验证规则。它的流畅接口使得创建复杂的验证逻辑变得简单直观。本文将深入探讨FluentValidation的各种特性和用法,并提供丰富的示例来说明如何在实际项目中应用这些概念。



## 安装和基本设置

首先,让我们通过NuGet包管理器安装FluentValidation:

```Markdown
dotnet add package FluentValidation
```


![image.png](https://blog.idiosoft.com/static/img/13ca631b52bd64bce9e9b0acca219dc0.image.webp)

[对于ASP.NET](http://xn--ASP-xi9dk72d.NET) Core项目,你可能还想安装集成包:

```Markdown
dotnet add package FluentValidation.AspNetCore
```

## 创建验证器

让我们从一个简单的例子开始,创建一个用户模型和相应的验证器:

```C#
public class User
{
    public int Id { get; set; }
    public string Username { get; set; }
    public string Email { get; set; }
    public DateTime DateOfBirth { get; set; }
}

public class UserValidator : AbstractValidator<User>
{
    public UserValidator()
    {
        RuleFor(user => user.Username).NotEmpty().Length(3, 20);
        RuleFor(user => user.Email).NotEmpty().EmailAddress();
        RuleFor(user => user.DateOfBirth).NotEmpty().LessThan(DateTime.Today);
    }
}
```

这个验证器可以确保：

1. 用户名不为空，且长度适当
2. 提供了有效的电子邮件地址
3. 提供了有效的出生日期

```C#
static void Main(string[] args)
{
    var user = new User
    {
        Username = "john",
        Email = "john@example.com",
        DateOfBirth = new DateTime(1990, 1, 1)
    };

    var validator = new UserValidator();
    var result = validator.Validate(user);

    if (result.IsValid)
    {
        Console.WriteLine("User is valid");
    }
    else
    {
        foreach (var error in result.Errors)
        {
            Console.WriteLine(error.ErrorMessage);
        }
    }
}

```

在这个例子中,我们为`User`类创建了一个验证器,定义了用户名、邮箱和出生日期的基本验证规则。

## 常用验证规则

FluentValidation提供了许多内置的验证规则。以下是一些常用的规则:

```C#
public enum ProductCategory
{
    Electronics,
    Clothing,
    Food,
    Books,
    Toys
}

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int StockQuantity { get; set; }
    public string Description { get; set; }
    public ProductCategory Category { get; set; }
    public List<string> Tags { get; set; }
}

public class ProductValidator : AbstractValidator<Product>
{
    public ProductValidator()
    {
        RuleFor(p => p.Name)
            .NotEmpty().WithMessage("产品名称不能为空")
            .MaximumLength(50).WithMessage("产品名称不能超过50个字符");

        RuleFor(p => p.Price)
            .GreaterThan(0).WithMessage("价格必须大于0")
            .LessThanOrEqualTo(1000000).WithMessage("价格不能超过1,000,000");

        RuleFor(p => p.StockQuantity)
            .InclusiveBetween(0, 10000).WithMessage("库存数量必须在0到10,000之间");

        RuleFor(p => p.Description)
            .Length(10, 500).WithMessage("描述必须在10到500个字符之间");

        RuleFor(p => p.Category)
            .IsInEnum().WithMessage("无效的产品类别");

        RuleFor(p => p.Tags)
            .Must(tags => tags != null && tags.All(tag => tag.Length <= 20))
            .WithMessage("每个标签不能超过20个字符");
    }
}

```

- 产品名称不能为空且不超过50个字符
- 价格必须大于0且不超过1,000,000
- 库存数量必须在0到10,000之间
- 描述长度必须在10到500个字符之间
- 类别必须是有效的枚举值
- 每个标签不能超过20个字符

```C#
static void Main(string[] args)
{
    var product = new Product
    {
        Name = "Super Gadget",
        Price = 199.99m,
        StockQuantity = 99999,
        Description = "This is a fantastic gadget that does amazing things.",
        Category = ProductCategory.Electronics,
        Tags = new List<string> { "gadget", "electronic", "cool" }
    };

    var validator = new ProductValidator();
    var result = validator.Validate(product);

    if (result.IsValid)
    {
        Console.WriteLine("Product is valid");
    }
    else
    {
        foreach (var error in result.Errors)
        {
            Console.WriteLine(error.ErrorMessage);
        }
    }
}

```


![image.png](https://blog.idiosoft.com/static/img/e700a5e47cfcb9c208f3d70eadeae22f.image.webp)

这个例子展示了多种常用的验证规则,包括非空检查、长度限制、数值范围检查、枚举验证等。

## 自定义验证规则

有时,内置的验证规则可能无法满足特定需求。在这种情况下,我们可以创建自定义验证规则:

```C#
public class Order  
{  
    public int Id { get; set; }  
    public DateTime DeliveryDate { get; set; }  
    public string CustomerCode { get; set; }  
    // 可以根据需要添加更多属性  
}  

public class OrderValidator : AbstractValidator<Order>  
{  
    public OrderValidator()  
    {  
        RuleFor(order => order.DeliveryDate)  
            .Must(BeAWorkingDay)  
            .WithMessage("送货日期必须是工作日");  

        RuleFor(order => order.CustomerCode)  
            .Must(BeAValidCustomerCode)  
            .WithMessage("无效的客户代码");  
    }  

    private bool BeAWorkingDay(DateTime date)  
    {  
        return date.DayOfWeek != DayOfWeek.Saturday && date.DayOfWeek != DayOfWeek.Sunday;  
    }  

    private bool BeAValidCustomerCode(string code)  
    {  
        // 假设有效的客户代码是以"CUST-"开头,后跟5个数字  
        return Regex.IsMatch(code, @"^CUST-\d{5}$");  
    }  
}  
```

- 送货日期必须是工作日（非周六或周日）
- 客户代码必须符合特定格式（"CUST-" 后跟5个数字）

```C#
static void Main(string[] args)
{
    var order = new Order
    {
        Id = 1,
        DeliveryDate = DateTime.Now.AddDays(1), // 假设明天是工作日  
        CustomerCode = "CUST-12345"
    };

    var validator = new OrderValidator();
    var result = validator.Validate(order);

    if (result.IsValid)
    {
        Console.WriteLine("Order is valid");
    }
    else
    {
        foreach (var error in result.Errors)
        {
            Console.WriteLine(error.ErrorMessage);
        }
    }

    // 测试无效的订单  
    var invalidOrder = new Order
    {
        Id = 2,
        DeliveryDate = new DateTime(2023, 7, 1), // 假设这是一个周六  
        CustomerCode = "INVALID-CODE"
    };

    var invalidResult = validator.Validate(invalidOrder);

    if (!invalidResult.IsValid)
    {
        Console.WriteLine("\nInvalid order errors:");
        foreach (var error in invalidResult.Errors)
        {
            Console.WriteLine(error.ErrorMessage);
        }
    }
}

```


![image.png](https://blog.idiosoft.com/static/img/e4f17e13809bcc4823c045347494b4be.image.webp)

在这个例子中,我们创建了两个自定义验证规则:一个检查日期是否为工作日,另一个验证客户代码的格式。

## 条件验证

FluentValidation允许我们基于某些条件应用验证规则:

```C#
public class RegistrationValidator : AbstractValidator<Registration>
{
    public RegistrationValidator()
    {
        RuleFor(r => r.Email).NotEmpty().EmailAddress();

        RuleFor(r => r.Age).NotEmpty();

        When(r => r.Age < 18, () => {
            RuleFor(r => r.ParentConsent)
                .NotEmpty()
                .Equal(true).WithMessage("未成年人需要父母同意才能注册");
        });

        RuleFor(r => r.Password).NotEmpty().Length(8, 20);

        RuleFor(r => r.ConfirmPassword)
            .Equal(r => r.Password).WithMessage("确认密码必须与密码相同")
            .When(r => !string.IsNullOrWhiteSpace(r.Password));
    }
}
```

这个例子展示了如何使用`When`方法来应用条件验证,例如只有当年龄小于18岁时才要求父母同意,以及只有在密码不为空时才验证确认密码。

## 集合验证

FluentValidation可以验证集合中的每个元素:

```C#
public class Order
{
    public int Id { get; set; }
    public List<OrderItem> Items { get; set; }
}

public class OrderItem
{
    public int ProductId { get; set; }
    public int Quantity { get; set; }
}

public class OrderValidator : AbstractValidator<Order>
{
    public OrderValidator()
    {
        RuleFor(o => o.Items).NotEmpty().WithMessage("订单必须包含至少一个商品");
        RuleForEach(o => o.Items).SetValidator(new OrderItemValidator());
    }
}

public class OrderItemValidator : AbstractValidator<OrderItem>
{
    public OrderItemValidator()
    {
        RuleFor(item => item.ProductId).GreaterThan(0).WithMessage("产品ID必须大于0");
        RuleFor(item => item.Quantity).InclusiveBetween(1, 100).WithMessage("数量必须在1到100之间");
    }
}

```

- 订单包含至少一个商品。
- 每个商品都有有效的产品 ID（大于 0）。
- 每个商品的数量都在合理范围内（1 到 100）。

```C#
static void Main(string[] args)
{
    // 创建一个有效的订单  
    var validOrder = new Order
    {
        Id = 1,
        Items = new List<OrderItem>
    {
        new OrderItem { ProductId = 1, Quantity = 5 },
        new OrderItem { ProductId = 2, Quantity = 3 }
    }
    };

    // 创建一个无效的订单  
    var invalidOrder = new Order
    {
        Id = 2,
        Items = new List<OrderItem>
    {
        new OrderItem { ProductId = 0, Quantity = 0 },
        new OrderItem { ProductId = 3, Quantity = 101 }
    }
    };

    var validator = new OrderValidator();

    // 验证有效订单  
    var validResult = validator.Validate(validOrder);
    Console.WriteLine("Valid Order Validation Result:");
    PrintValidationResult(validResult);

    // 验证无效订单  
    var invalidResult = validator.Validate(invalidOrder);
    Console.WriteLine("\nInvalid Order Validation Result:");
    PrintValidationResult(invalidResult);
}

static void PrintValidationResult(FluentValidation.Results.ValidationResult result)
{
    if (result.IsValid)
    {
        Console.WriteLine("Order is valid");
    }
    else
    {
        foreach (var error in result.Errors)
        {
            Console.WriteLine($"- {error.ErrorMessage}");
        }
    }
}
```

这个例子展示了如何验证订单中的每个订单项。

## 级联验证

FluentValidation支持级联验证,允许我们验证复杂对象的属性:

```C#
public class Customer
{
    public string Name { get; set; }
    public Address BillingAddress { get; set; }
    public Address ShippingAddress { get; set; }
}

public class Address
{
    public string Street { get; set; }
    public string City { get; set; }
    public string ZipCode { get; set; }
}

public class CustomerValidator : AbstractValidator<Customer>
{
    public CustomerValidator()
    {
        RuleFor(c => c.Name).NotEmpty().WithMessage("客户名称不能为空");
        RuleFor(c => c.BillingAddress).SetValidator(new AddressValidator()).WithMessage("账单地址无效");
        RuleFor(c => c.ShippingAddress).SetValidator(new AddressValidator()).WithMessage("送货地址无效");
    }
}

public class AddressValidator : AbstractValidator<Address>
{
    public AddressValidator()
    {
        RuleFor(a => a.Street).NotEmpty().WithMessage("街道不能为空");
        RuleFor(a => a.City).NotEmpty().WithMessage("城市不能为空");
        RuleFor(a => a.ZipCode).NotEmpty().Matches(@"^\d{5}(-\d{4})?$").WithMessage("邮政编码格式无效");
    }
}

```

```C#
static void Main(string[] args)
{
    // 创建一个有效的客户  
    var validCustomer = new Customer
    {
        Name = "John Doe",
        BillingAddress = new Address
        {
            Street = "123 Billing St",
            City = "Billing City",
            ZipCode = "12345"
        },
        ShippingAddress = new Address
        {
            Street = "456 Shipping St",
            City = "Shipping City",
            ZipCode = "67890-1234"
        }
    };

    // 创建一个无效的客户  
    var invalidCustomer = new Customer
    {
        Name = "",
        BillingAddress = new Address
        {
            Street = "",
            City = "Billing City",
            ZipCode = "INVALID"
        },
        ShippingAddress = new Address
        {
            Street = "789 Shipping St",
            City = "",
            ZipCode = "54321"
        }
    };

    var validator = new CustomerValidator();

    // 验证有效客户  
    var validResult = validator.Validate(validCustomer);
    Console.WriteLine("Valid Customer Validation Result:");
    PrintValidationResult(validResult);

    // 验证无效客户  
    var invalidResult = validator.Validate(invalidCustomer);
    Console.WriteLine("\nInvalid Customer Validation Result:");
    PrintValidationResult(invalidResult);
}

static void PrintValidationResult(FluentValidation.Results.ValidationResult result)
{
    if (result.IsValid)
    {
        Console.WriteLine("Customer is valid");
    }
    else
    {
        foreach (var error in result.Errors)
        {
            Console.WriteLine($"- {error.PropertyName}: {error.ErrorMessage}");
        }
    }
}

```

![image.png](https://blog.idiosoft.com/static/img/958b8b498e60f2076862390942d5b8b9.image.webp)

这个例子展示了如何验证客户对象,包括其嵌套的地址对象。

## [与ASP.NET](http://xn--ASP-b38d.NET) Core集成


![image.png](https://blog.idiosoft.com/static/img/f6c4570f35e11681773e74470b7b2af2.image.webp)

[FluentValidation可以很容易地集成到ASP.NET](http://xn--FluentValidationASP-qx14a267b66ipptdvzoyvp7ohrzwv52a.NET) Core应用中:

```C#
 builder.Services.AddFluentValidationAutoValidation();
 builder.Services.AddValidatorsFromAssemblyContaining<Program>();

```

```C#
public class UserRegistrationRequest
{
    public string Username { get; set; }
    public string Email { get; set; }
    public string Password { get; set; }
    public DateTime DateOfBirth { get; set; }
}

```

```C#
public class UserRegistrationValidator : AbstractValidator<UserRegistrationRequest>
{
    public UserRegistrationValidator()
    {
        RuleFor(x => x.Username)
            .NotEmpty().WithMessage("用户名是必填的。")
            .Length(3, 20).WithMessage("用户名必须在3到20个字符之间。");

        RuleFor(x => x.Email)
            .NotEmpty().WithMessage("邮箱是必填的。")
            .EmailAddress().WithMessage("请输入有效的邮箱地址。");

        RuleFor(x => x.Password)
            .NotEmpty().WithMessage("密码是必填的。")
            .MinimumLength(6).WithMessage("密码至少需要6个字符。")
            .Matches(@"[A-Z]+").WithMessage("密码必须包含至少一个大写字母。")
            .Matches(@"[a-z]+").WithMessage("密码必须包含至少一个小写字母。")
            .Matches(@"[0-9]+").WithMessage("密码必须包含至少一个数字。");

        RuleFor(x => x.DateOfBirth)
            .NotEmpty().WithMessage("出生日期是必填的。")
            .LessThan(DateTime.Now.AddYears(-18)).WithMessage("您必须年满18岁才能注册。");
    }
}

```

```C#
[Route("api/[controller]")]
[ApiController]
public class UserController : ControllerBase
{
    [HttpPost("register")]
    public IActionResult Register(UserRegistrationRequest request)
    {
        // 如果验证失败，ASP.NET Core 会自动返回 400 Bad Request  
        // 带有验证错误详情  
        // 在这里处理有效的注册请求  
        return Ok(new { Message = "用户注册成功" });
    }
}

```

有效请求：

```JSON
{  
    "username": "johndoe",  
    "email": "john@example.com",  
    "password": "Password123",  
    "dateOfBirth": "1990-01-01"  
}  
```

无效请求：

```JSON
{  
    "username": "j",  
    "email": "not-an-email",  
    "password": "weak",  
    "dateOfBirth": "2010-01-01"  
}  
```


![image.png](https://blog.idiosoft.com/static/img/e92560ad88dd7f69e60fbb432a20d69f.image.webp)

对于有效请求，您应该收到一个成功的响应。对于无效请求，您应该收到一个 400 Bad Request 响应，其中包含详细的验证错误信息。

## 最佳实践

1. **保持验证器的单一职责**: 每个验证器应该只负责一个模型的验证。
2. **重用验证逻辑**: 使用自定义方法或扩展方法来重用常见的验证逻辑。
3. **适当使用条件验证**: 不要过度使用条件验证,这可能会使规则变得难以理解和维护。
4. **提供有意义的错误消息**: 错误消息应该清晰地指出问题所在,并可能提供如何修正的建议。
5. **考虑性能**: 对于大型集合或复杂对象,考虑使用异步验证或优化验证逻辑。
6. **定期审查和更新验证规则**: 随着业务规则的变化,确保验证规则保持最新。

## 结论

FluentValidation是一个强大而灵活的验证库,能够极大地简化.NET应用程序中的数据验证过程。通过本文介绍的各种技术,你应该能够处理大多数验证场景。记住,好的验证不仅能确保数据的完整性和正确性,还能提供良好的用户体验。持续练习和应用这些概念,将帮助你构建更健壮、更可靠的应用程序。

FluentValidation: C#开发者的数据验证利器

link

script

这个博客将是我技术思考、创业经验和个人成长的记录本。无论是技术解决方案、创业感悟，还是职场心得，我都将坦诚相见，希望能为正在成长的技术人和创业者提供一些真实而有价值的洞察。"

主要特点

简介

Hangfire的主要特性

准备工作

目录

简介