C# 测试与工程化

1. 学习目标与 Bloom 分类法

本节遵循 Bloom 修订版认知能力分类体系，将学习目标按六个层级显式标注，便于学习者评估自身掌握程度。

1.1 学习目标矩阵

1.2 预期先修知识

• C# 高级特性（泛型、委托、异步、反射）
• .NET 平台基础（SDK、项目结构、NuGet）
• 面向对象设计原则（SOLID、DRY、KISS）
• 数据结构与算法基础
• 命令行操作与版本控制（Git）

1.3 学习评估方式

• L1-L2：通过简答题与概念对比题评估
• L3-L4：通过编程实践（重构既有代码并补充测试）评估
• L5-L6：通过课程项目（设计完整测试策略并实施 CI/CD）评估

2. 历史动机与演进脉络

2.1 软件测试的起源（1940s-1970s）

软件测试作为独立学科始于 1947 年 Grace Hopper 在 Mark II 计算机中发现的真实”虫子”（moth）。1958 年，NATO 软件工程会议正式将测试纳入软件开发生命周期。1970 年代，Goodhart 与 Myers 的”测试是为了发现错误”理论奠定了测试哲学基础。

这一时期测试以人工为主，缺乏工具支撑。FORTRAN 与 COBOL 时代没有自动化测试框架的概念，开发者依靠”调试即测试”的原始方式。

2.2 xUnit 家族的诞生（1990s-2000s）

1995 年 Kent Beck 发布 SUnit（Smalltalk），开创了 xUnit 家族。随后 JUnit（Java, 1997）、PHPUnit（PHP, 2001）、pytest（Python, 2002）相继问世。.NET 平台的 NUnit 由 Philip Craig 于 2002 年发布，是 .NET 生态最早的主流测试框架，深受 JUnit 影响。

NUnit 的命名承袭 JUnit，“N” 代表 .NET。其 [Test]、[SetUp]、[TearDown] 等特性（Attribute）语法成为 .NET 测试的标志性风格。

2.3 xUnit.net 的崛起（2007-至今）

2007 年，Brad Wilson 与 James Newkirk（NUnit 的贡献者）离开 NUnit 团队，发布了 xUnit.net。设计动机包括：

• 简化 API：移除 [SetUp]/[TearDown]，改用构造函数与 IDisposable
• 隔离性：每个测试方法运行在独立实例上，避免共享状态污染
• 可扩展性：基于 Xunit.Sdk 命名空间，便于自定义扩展
• 异步优先：原生支持 async Task 测试方法

xUnit.net 现已成为 .NET Core/5+ 时代的默认推荐框架，ASP.NET Core 与 .NET 运行时官方测试均采用 xUnit。

2.4 测试金字塔理论的成熟（2009-至今）

2009 年 Mike Cohn 在《Succeeding with Agile》中提出测试金字塔（Test Pyramid）模型：

       /\          E2E 测试（少）
      /  \         - 慢、脆弱、昂贵
     /----\
    /      \       集成测试（中）
   /        \      - 验证模块间协作
  /----------\
 /            \    单元测试（多）
/              \   - 快、稳定、廉价
------------------

Alister Scott 于 2011 年进一步提出”测试奖杯”（Testing Trophy）模型，强调集成测试的比重应高于单元测试。这一观点在微服务时代得到广泛认同。

2.5 .NET 测试生态的现代化（2015-至今）

2.6 Roslyn 与代码分析时代（2014-至今）

2014 年微软开源 Roslyn 编译器平台，引入 Analyzer（分析器）与 Source Generator（源生成器）两大扩展点：

• Analyzer：编译期静态分析，报告诊断信息（Diagnostic）
• Source Generator：编译期生成代码，替代运行时反射

这一变革使 .NET 的代码质量保障从”运行时检查”演进至”编译期保证”，显著提升了类型安全与性能。

3. 形式化定义

3.1 测试覆盖率的数学定义

定义 3.1（语句覆盖率）：设程序 $P$ 包含 $n$ 条可执行语句，测试套件 $T$ 执行了其中 $m$ 条，则语句覆盖率定义为：

$\text{Coverage}_{\text{stmt}}(T, P) = \frac{m}{n} \in [0, 1]$

定义 3.2（分支覆盖率）：设程序 $P$ 包含 $b$ 个分支决策点，每个决策点有 $k_i$ 个分支，测试套件 $T$ 覆盖了其中 $c$ 个分支，则分支覆盖率定义为：

$\text{Coverage}_{\text{branch}}(T, P) = \frac{c}{\sum_{i=1}^{b} k_i}$

定义 3.3（MC/DC 覆盖率）：Modified Condition/Decision Coverage 要求每个决策的每个条件都独立影响决策结果。形式化地，对于条件 $c_i$ 在决策 $D$ 中，存在测试用例对 $(t_1, t_2)$ 满足：

$\forall i, \exists (t_1, t_2): c_i(t_1) \neq c_i(t_2) \land D(t_1) \neq D(t_2) \land \forall j \neq i: c_j(t_1) = c_j(t_2)$

MC/DC 是航空软件 DO-178C 标准的强制要求。

3.2 测试用例的形式化模型

定义 3.4（测试用例）：测试用例是一个五元组 $\text{TC} = (I, E, O, S, \tau)$，其中：

• $I$：输入集合（Inputs）
• $E$：前置条件（Preconditions）
• $O$：期望输出（Expected outputs）
• $S$：系统初始状态（Initial state）
• $\tau$：超时阈值（Timeout）

定义 3.5（测试断言）：断言是一个谓词函数 $\text{Assert}: \text{Actual} \times \text{Expected} \to \{\text{Pass}, \text{Fail}\}$。xUnit 中的 Assert.Equal(expected, actual) 即是该函数的具体实现。

3.3 Mock 对象的代数定义

定义 3.6（Mock 对象）：给定接口 $I$ 与方法 $m \in I$，Mock 对象 $M$ 是一个二元组 $M = (S, B)$，其中：

• $S: I \times m \to V$ 是桩函数（Stub），返回预设值 $V$
• $B: I \times m \to \mathbb{N}$ 是行为验证器（Behavior verifier），记录调用次数

定义 3.7（Test Double 分类）：依据 Gerard Meszaros 的《xUnit Test Patterns》，Test Double 分为五类：

3.4 基准测试的统计模型

定义 3.8（基准测量）：基准测试对操作 $f$ 进行 $n$ 次测量，得到样本 $\{t_1, t_2, \ldots, t_n\}$。常用统计量：

• 均值：$\bar{t} = \frac{1}{n} \sum_{i=1}^{n} t_i$
• 标准差：$\sigma = \sqrt{\frac{1}{n-1} \sum_{i=1}^{n} (t_i - \bar{t})^2}$
• 中位数：$P_{50}$
• 百分位数：$P_{95}, P_{99}$

BenchmarkDotNet 默认报告均值、标准差、误差范围与中位数，避免离群点的影响。

3.5 持续集成的形式化定义

定义 3.9（CI 流水线）：CI 流水线是一个有向无环图 $G = (V, E)$，其中：

• $V$ 是阶段集合（如 lint、build、test、deploy）
• $E \subseteq V \times V$ 是依赖关系，$(u, v) \in E$ 表示 $v$ 依赖 $u$ 的成功完成

定义 3.10（流水线执行时间）：若各阶段执行时间 $t_v$ 独立，串行流水线总时间为 $\sum_{v \in V} t_v$；若允许并行，总时间为关键路径长度 $\text{CP}(G) = \max_{p \in \text{Path}(G)} \sum_{v \in p} t_v$。

4. 理论推导与性能分析

4.1 测试覆盖率与缺陷检测概率

定理 4.1（缺陷检测上界）：设测试套件 $T$ 的语句覆盖率为 $c$，则未被覆盖的语句包含缺陷的概率 $p_{\text{undetected}}$ 满足：

$p_{\text{undetected}} \geq (1 - c) \cdot p_{\text{defect}}$

其中 $p_{\text{defect}}$ 是单条语句包含缺陷的先验概率。

证明：未被覆盖的语句集合大小为 $(1 - c) \cdot n$，假设缺陷均匀分布，则未被覆盖区域包含的缺陷期望为 $(1 - c) \cdot n \cdot p_{\text{defect}}$，对应概率为 $(1 - c) \cdot p_{\text{defect}}$。$\square$

推论 4.1：100% 覆盖率不等于零缺陷。覆盖率仅是必要条件，非充分条件。

4.2 Mock 与真实集成的权衡

定理 4.2（Mock 失真定理）：设被测系统 $S$ 依赖 $D$，真实 $D$ 的行为函数为 $f_D$，Mock 的行为函数为 $f_M$。若 $f_D \neq f_M$，则存在输入 $x$ 使得 $S(f_D, x) \neq S(f_M, x)$，即测试通过但生产失败。

工程含义：Mock 必须与真实依赖保持行为一致，否则会产生”绿色测试”假象。缓解措施包括：

• 契约测试（Contract Testing）：使用 Pact 等工具验证 Mock 与真实实现一致
• 集成测试兜底：在 Mock 测试之外补充真实依赖的集成测试

4.3 基准测量的统计可靠性

定理 4.3（样本量下界）：要在置信水平 $1 - \alpha$ 下，将均值估计误差控制在 $\epsilon$ 以内，所需样本量 $n$ 满足：

$n \geq \left( \frac{z_{\alpha/2} \cdot \sigma}{\epsilon} \right)^2$

其中 $z_{\alpha/2}$ 是标准正态分布的分位数，$\sigma$ 是总体标准差。

实证：若 $\sigma = 10$ ms，$\epsilon = 1$ ms，95% 置信水平（$z_{0.025} = 1.96$），则 $n \geq 384$。BenchmarkDotNet 默认样本量基于此原理自动调整。

4.4 测试金字塔的成本-收益分析

定理 4.4（最优测试分布）：设单元测试、集成测试、E2E 测试的成本分别为 $c_u, c_i, c_e$，缺陷捕获率分别为 $p_u, p_i, p_e$，则最优测试数量分布 $(n_u^*, n_i^*, n_e^*)$ 满足：

$\max \sum_{k \in \{u, i, e\}} n_k \cdot p_k \quad \text{s.t.} \quad \sum_{k} n_k \cdot c_k \leq B$

由拉格朗日乘数法，最优解满足 $\frac{p_k}{c_k}$ 相等。由于单元测试 $p_u/c_u$ 通常最大，金字塔形状得以证明。

经验数据：

5. 代码示例与实战演示

5.1 xUnit 单元测试基础

using Xunit;

// 被测类：简单计算器
public class Calculator
{
    public int Add(int a, int b) => a + b;

    public int Subtract(int a, int b) => a - b;

    public int Multiply(int a, int b) => a * b;

    public double Divide(int a, int b)
    {
        if (b == 0)
            throw new DivideByZeroException("除数不能为零");
        return (double)a / b;
    }
}

// 测试类：每个测试类对应一个被测类
public class CalculatorTests
{
    // Fact：无参数的单个测试
    [Fact]
    public void Add_TwoPositiveNumbers_ReturnsSum()
    {
        // Arrange：准备测试数据
        var calc = new Calculator();
        int a = 3, b = 5, expected = 8;

        // Act：执行被测方法
        int actual = calc.Add(a, b);

        // Assert：验证结果
        Assert.Equal(expected, actual);
    }

    [Fact]
    public void Add_NegativeNumbers_ReturnsCorrectSum()
    {
        var calc = new Calculator();
        Assert.Equal(-8, calc.Add(-3, -5));
    }

    [Fact]
    public void Divide_ByZero_ThrowsDivideByZeroException()
    {
        var calc = new Calculator();
        // 验证异常抛出
        Assert.Throws<DivideByZeroException>(() => calc.Divide(10, 0));
    }

    [Fact]
    public async Task AsyncTest_UsingTask()
    {
        await Task.Delay(10);
        Assert.True(true);
    }
}

5.2 参数化测试

public class CalculatorParameterizedTests
{
    private readonly Calculator _calc = new();

    // Theory：带参数的测试，通过 InlineData 提供数据
    [Theory]
    [InlineData(1, 2, 3)]
    [InlineData(-1, 1, 0)]
    [InlineData(0, 0, 0)]
    [InlineData(100, 200, 300)]
    [InlineData(int.MaxValue, 0, int.MaxValue)]
    public void Add_VariousInputs_ReturnsExpected(int a, int b, int expected)
    {
        Assert.Equal(expected, _calc.Add(a, b));
    }

    // MemberData：从属性或方法获取测试数据
    public static IEnumerable<object[]> MultiplyData => new[]
    {
        new object[] { 2, 3, 6 },
        new object[] { -2, 3, -6 },
        new object[] { 0, 100, 0 },
        new object[] { 1, 1, 1 }
    };

    [Theory]
    [MemberData(nameof(MultiplyData))]
    public void Multiply_VariousInputs_ReturnsExpected(int a, int b, int expected)
    {
        Assert.Equal(expected, _calc.Multiply(a, b));
    }

    // ClassData：从单独的类获取复杂数据
    [Theory]
    [ClassData(typeof(DivisionTestData))]
    public void Divide_ValidInputs_ReturnsExpected(int a, int b, double expected)
    {
        Assert.Equal(expected, _calc.Divide(a, b));
    }
}

// 数据类：实现 IEnumerable<object[]>
public class DivisionTestData : IEnumerable<object[]>
{
    public IEnumerator<object[]> GetEnumerator()
    {
        yield return new object[] { 10, 2, 5.0 };
        yield return new object[] { 9, 3, 3.0 };
        yield return new object[] { 7, 2, 3.5 };
        yield return new object[] { -10, 2, -5.0 };
    }

    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

5.3 Moq 模拟框架

using Moq;
using Xunit;

// 被测接口与依赖
public interface IUserRepository
{
    User? GetById(int id);
    Task<User?> GetByIdAsync(int id);
    Task<User> SaveAsync(User user);
    IEnumerable<User> GetAll();
    void Delete(int id);
}

public class User
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public string Email { get; set; } = string.Empty;
}

public interface IEmailService
{
    Task SendAsync(string to, string subject, string body);
}

// 被测服务
public class UserService
{
    private readonly IUserRepository _repo;
    private readonly IEmailService _email;

    public UserService(IUserRepository repo, IEmailService email)
    {
        _repo = repo;
        _email = email;
    }

    public async Task<User> CreateUserAsync(string name, string email)
    {
        if (string.IsNullOrEmpty(name))
            throw new ArgumentException("姓名不能为空", nameof(name));

        var user = new User { Name = name, Email = email };
        var saved = await _repo.SaveAsync(user);
        await _email.SendAsync(email, "欢迎", $"欢迎 {name}");
        return saved;
    }

    public async Task<bool> DeleteUserAsync(int id)
    {
        var user = await _repo.GetByIdAsync(id);
        if (user is null) return false;
        _repo.Delete(id);
        return true;
    }
}

// 测试类
public class UserServiceTests
{
    private readonly Mock<IUserRepository> _repoMock;
    private readonly Mock<IEmailService> _emailMock;
    private readonly UserService _service;

    public UserServiceTests()
    {
        // 创建 Mock 对象
        _repoMock = new Mock<IUserRepository>();
        _emailMock = new Mock<IEmailService>();
        _service = new UserService(_repoMock.Object, _emailMock.Object);
    }

    [Fact]
    public async Task CreateUserAsync_ValidInput_SavesAndSendsEmail()
    {
        // Arrange：配置 Mock 行为
        var savedUser = new User { Id = 1, Name = "测试", Email = "test@test.com" };
        _repoMock.Setup(r => r.SaveAsync(It.IsAny<User>()))
                 .ReturnsAsync(savedUser);

        // Act：调用被测方法
        var result = await _service.CreateUserAsync("测试", "test@test.com");

        // Assert：验证返回值
        Assert.Equal(1, result.Id);
        Assert.Equal("测试", result.Name);

        // Verify：验证 Mock 被正确调用
        _repoMock.Verify(r => r.SaveAsync(It.Is<User>(u =>
            u.Name == "测试" && u.Email == "test@test.com")), Times.Once);

        _emailMock.Verify(e => e.SendAsync(
            "test@test.com",
            "欢迎",
            It.Is<string>(s => s.Contains("测试"))), Times.Once);
    }

    [Fact]
    public async Task CreateUserAsync_EmptyName_ThrowsArgumentException()
    {
        await Assert.ThrowsAsync<ArgumentException>(() =>
            _service.CreateUserAsync("", "test@test.com"));

        // 验证失败时不发送邮件
        _emailMock.Verify(e => e.SendAsync(It.IsAny<string>(),
            It.IsAny<string>(), It.IsAny<string>()), Times.Never);
    }

    [Fact]
    public async Task DeleteUserAsync_UserExists_ReturnsTrue()
    {
        // Arrange
        var user = new User { Id = 1, Name = "测试" };
        _repoMock.Setup(r => r.GetByIdAsync(1)).ReturnsAsync(user);

        // Act
        var result = await _service.DeleteUserAsync(1);

        // Assert
        Assert.True(result);
        _repoMock.Verify(r => r.Delete(1), Times.Once);
    }

    [Fact]
    public async Task DeleteUserAsync_UserNotExists_ReturnsFalse()
    {
        // Arrange：默认 Mock 返回 null
        _repoMock.Setup(r => r.GetByIdAsync(999)).ReturnsAsync((User?)null);

        // Act
        var result = await _service.DeleteUserAsync(999);

        // Assert
        Assert.False(result);
        _repoMock.Verify(r => r.Delete(It.IsAny<int>()), Times.Never);
    }

    [Fact]
    public async Task CreateUserAsync_RepositoryThrows_PropagatesException()
    {
        // Arrange：配置 Mock 抛出异常
        _repoMock.Setup(r => r.SaveAsync(It.IsAny<User>()))
                 .ThrowsAsync(new InvalidOperationException("数据库连接失败"));

        // Act & Assert
        await Assert.ThrowsAsync<InvalidOperationException>(() =>
            _service.CreateUserAsync("测试", "test@test.com"));
    }

    // 回调验证：捕获传入参数
    [Fact]
    public async Task CreateUserAsync_CapturesUserViaCallback()
    {
        User? capturedUser = null;
        _repoMock.Setup(r => r.SaveAsync(It.IsAny<User>()))
                 .Callback<User>(u => capturedUser = u)
                 .ReturnsAsync((User u) => u);

        await _service.CreateUserAsync("测试", "test@test.com");

        Assert.NotNull(capturedUser);
        Assert.Equal("测试", capturedUser!.Name);
    }

    // 序列化调用验证
    [Fact]
    public async Task MultipleOperations_VerifyCallSequence()
    {
        var sequence = new MockSequence();
        _repoMock.InSequence(sequence)
                 .Setup(r => r.SaveAsync(It.IsAny<User>()))
                 .ReturnsAsync(new User { Id = 1 });
        _emailMock.InSequence(sequence)
                  .Setup(e => e.SendAsync(It.IsAny<string>(),
                      It.IsAny<string>(), It.IsAny<string>()));

        await _service.CreateUserAsync("测试", "test@test.com");

        _repoMock.Verify(r => r.SaveAsync(It.IsAny<User>()), Times.Once);
        _emailMock.Verify(e => e.SendAsync(It.IsAny<string>(),
            It.IsAny<string>(), It.IsAny<string>()), Times.Once);
    }
}

5.4 集成测试：WebApplicationFactory

using Microsoft.AspNetCore.Mvc.Testing;
using System.Net;
using System.Net.Http.Json;
using Xunit;

// 集成测试：测试整个 ASP.NET Core 应用
public class ApiIntegrationTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly WebApplicationFactory<Program> _factory;
    private readonly HttpClient _client;

    public ApiIntegrationTests(WebApplicationFactory<Program> factory)
    {
        // 自定义测试环境：替换真实数据库为内存数据库
        _factory = factory.WithWebHostBuilder(builder =>
        {
            builder.ConfigureServices(services =>
            {
                // 移除真实数据库上下文注册
                var dbContextDescriptor = services.SingleOrDefault(
                    d => d.ServiceType == typeof(DbContextOptions<AppDbContext>));
                if (dbContextDescriptor is not null)
                    services.Remove(dbContextDescriptor);

                // 添加内存数据库
                services.AddDbContext<AppDbContext>(options =>
                    options.UseInMemoryDatabase("TestDb"));

                // 替换其他外部依赖
                services.AddScoped<IEmailService, FakeEmailService>();
            });
        });

        _client = _factory.CreateClient();
    }

    [Fact]
    public async Task GetUsers_ReturnsSuccessAndValidContentType()
    {
        // Act
        var response = await _client.GetAsync("/api/users");

        // Assert
        response.EnsureSuccessStatusCode();
        Assert.Equal("application/json",
            response.Content.Headers.ContentType?.MediaType);
    }

    [Fact]
    public async Task GetUser_ExistingId_ReturnsUser()
    {
        // Arrange：在测试数据库中播种数据
        using var scope = _factory.Services.CreateScope();
        var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
        db.Users.Add(new User { Id = 1, Name = "测试用户", Email = "test@test.com" });
        await db.SaveChangesAsync();

        // Act
        var response = await _client.GetAsync("/api/users/1");

        // Assert
        response.EnsureSuccessStatusCode();
        var user = await response.Content.ReadFromJsonAsync<User>();
        Assert.NotNull(user);
        Assert.Equal("测试用户", user!.Name);
    }

    [Fact]
    public async Task CreateUser_ValidPayload_ReturnsCreated()
    {
        // Arrange
        var payload = new { Name = "新用户", Email = "new@test.com" };

        // Act
        var response = await _client.PostAsJsonAsync("/api/users", payload);

        // Assert
        Assert.Equal(HttpStatusCode.Created, response.StatusCode);
        var created = await response.Content.ReadFromJsonAsync<User>();
        Assert.NotNull(created);
        Assert.Equal("新用户", created!.Name);
    }

    [Fact]
    public async Task DeleteUser_ExistingId_ReturnsNoContent()
    {
        // Arrange
        using var scope = _factory.Services.CreateScope();
        var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
        await db.Users.AddAsync(new User { Id = 1, Name = "待删除" });
        await db.SaveChangesAsync();

        // Act
        var response = await _client.DeleteAsync("/api/users/1");

        // Assert
        Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
    }
}

// Fake 实现：用于集成测试
public class FakeEmailService : IEmailService
{
    public List<(string To, string Subject, string Body)> SentEmails { get; } = new();

    public Task SendAsync(string to, string subject, string body)
    {
        SentEmails.Add((to, subject, body));
        return Task.CompletedTask;
    }
}

5.5 Testcontainers：真实依赖集成测试

using Testcontainers.MsSql;
using Testcontainers.Redis;
using Xunit;

// 真实数据库集成测试：使用 Docker 容器
public class DatabaseIntegrationTests : IAsyncLifetime
{
    private readonly MsSqlContainer _sqlContainer = new MsSqlBuilder()
        .WithImage("mcr.microsoft.com/mssql/server:2022-latest")
        .WithPassword("YourStrong!Passw0rd")
        .Build();

    private readonly RedisContainer _redisContainer = new RedisBuilder()
        .WithImage("redis:7-alpine")
        .Build();

    private AppDbContext _dbContext = null!;
    private IConnectionMultiplexer _redis = null!;

    public async Task InitializeAsync()
    {
        // 启动容器
        await Task.WhenAll(_sqlContainer.StartAsync(), _redisContainer.StartAsync());

        // 配置数据库上下文
        var options = new DbContextOptionsBuilder<AppDbContext>()
            .UseSqlServer(_sqlContainer.GetConnectionString())
            .Options;
        _dbContext = new AppDbContext(options);
        await _dbContext.Database.EnsureCreatedAsync();

        // 配置 Redis
        _redis = await ConnectionMultiplexer.ConnectAsync(_redisContainer.GetConnectionString());
    }

    public async Task DisposeAsync()
    {
        await _dbContext.DisposeAsync();
        await _sqlContainer.DisposeAsync();
        await _redisContainer.DisposeAsync();
    }

    [Fact]
    public async Task SaveAndRetrieve_WorksCorrectly()
    {
        // Arrange
        var user = new User { Name = "测试", Email = "test@test.com" };

        // Act
        _dbContext.Users.Add(user);
        await _dbContext.SaveChangesAsync();

        // Assert：重新查询验证持久化
        var retrieved = await _dbContext.Users.FindAsync(user.Id);
        Assert.NotNull(retrieved);
        Assert.Equal("测试", retrieved!.Name);
    }

    [Fact]
    public async Task Transaction_RollsBackOnError()
    {
        // Arrange
        using var transaction = await _dbContext.Database.BeginTransactionAsync();

        try
        {
            _dbContext.Users.Add(new User { Name = "测试1" });
            await _dbContext.SaveChangesAsync();

            // 模拟错误
            throw new InvalidOperationException("模拟错误");

            await transaction.CommitAsync();
        }
        catch
        {
            await transaction.RollbackAsync();
        }

        // Assert：事务回滚后无数据
        Assert.Empty(_dbContext.Users);
    }
}

5.6 BenchmarkDotNet 性能基准测试

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using BenchmarkDotNet.Configs;
using BenchmarkDotNet.Diagnosers;

// 基准测试：字符串拼接性能对比
[MemoryDiagnoser]    // 启用内存诊断
[RankColumn]          // 显示排名
[SimpleJob(launchCount: 3, warmupCount: 5, iterationCount: 10)]
public class StringConcatBenchmarks
{
    private const int Iterations = 1000;
    private readonly string[] _parts = Enumerable.Range(0, Iterations)
        .Select(i => $"part{i}").ToArray();

    [Benchmark(Baseline = true)]
    public string StringConcatenation()
    {
        var result = "";
        foreach (var part in _parts)
            result += part;
        return result;
    }

    [Benchmark]
    public string StringBuilder()
    {
        var sb = new StringBuilder();
        foreach (var part in _parts)
            sb.Append(part);
        return sb.ToString();
    }

    [Benchmark]
    public string StringJoin() => string.Join("", _parts);

    [Benchmark]
    public string StringConcat() => string.Concat(_parts);

    [Benchmark]
    public string LinqAggregate() => _parts.Aggregate((a, b) => a + b);
}

// 基准测试：集合遍历性能对比
[MemoryDiagnoser]
public class CollectionIterationBenchmarks
{
    private readonly List<int> _list = Enumerable.Range(0, 10000).ToList();
    private readonly int[] _array = Enumerable.Range(0, 10000).ToArray();
    private readonly HashSet<int> _set = Enumerable.Range(0, 10000).ToHashSet();
    private readonly Dictionary<int, int> _dict = Enumerable.Range(0, 10000)
        .ToDictionary(i => i, i => i);

    [Benchmark]
    public int ListIteration()
    {
        int sum = 0;
        foreach (var x in _list) sum += x;
        return sum;
    }

    [Benchmark]
    public int ArrayIteration()
    {
        int sum = 0;
        foreach (var x in _array) sum += x;
        return sum;
    }

    [Benchmark]
    public int HashSetIteration()
    {
        int sum = 0;
        foreach (var x in _set) sum += x;
        return sum;
    }

    [Benchmark]
    public int DictionaryIteration()
    {
        int sum = 0;
        foreach (var kv in _dict) sum += kv.Value;
        return sum;
    }
}

// 运行基准测试
public class Program
{
    public static void Main(string[] args)
    {
        // 运行所有基准测试
        BenchmarkRunner.Run<StringConcatBenchmarks>();

        // 或运行指定基准
        // BenchmarkRunner.Run<CollectionIterationBenchmarks>(
        //     ManualConfig.Create(DefaultConfig.Instance)
        //         .AddDiagnoser(MemoryDiagnoser.Default));
    }
}

// 必须使用 Release 模式运行：dotnet run -c Release

5.7 源生成器（Source Generators）

// 项目文件 (.csproj) 配置
// <Project Sdk="Microsoft.NET.Sdk">
//   <PropertyGroup>
//     <TargetFramework>netstandard2.0</TargetFramework>
//     <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
//     <LangVersion>latest</LangVersion>
//   </PropertyGroup>
//   <ItemGroup>
//     <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.11.0" />
//     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.11.0" />
//   </ItemGroup>
// </Project>

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using System.Text;

// 增量源生成器：编译期生成 INotifyPropertyChanged 实现
[Generator]
public class AutoNotifyGenerator : IIncrementalGenerator
{
    public void Initialize(IncrementalGeneratorInitializationContext context)
    {
        // 第一步：筛选带 [AutoNotify] 特性的字段
        var provider = context.SyntaxProvider
            .ForAttributeWithMetadataName(
                "AutoNotify.AutoNotifyAttribute",
                predicate: (node, _) => node is FieldDeclarationSyntax,
                transform: (ctx, _) => GetFieldInfo(ctx))
            .Where(f => f is not null);

        // 第二步：注册源输出
        context.RegisterSourceOutput(provider, (spc, field) =>
        {
            if (field is null) return;
            var source = GeneratePropertyClass(field.Value);
            spc.AddSource($"{field.Value.ClassName}_AutoNotify.g.cs", source);
        });
    }

    private record FieldInfo(string ClassName, string FieldType, string FieldName, string PropertyName);

    private static FieldInfo? GetFieldInfo(GeneratorAttributeSyntaxContext context)
    {
        var fieldSyntax = (FieldDeclarationSyntax)context.TargetNode;
        var variable = fieldSyntax.Declaration.Variables.First();
        var fieldName = variable.Identifier.Text;
        var fieldType = fieldSyntax.Declaration.Type.ToString();

        // 字段名转属性名：_name → Name
        var propertyName = fieldName.TrimStart('_');
        if (propertyName.Length > 0)
            propertyName = char.ToUpper(propertyName[0]) + propertyName[1..];

        var classSymbol = context.TargetSymbol.ContainingType;
        return new FieldInfo(classSymbol.Name, fieldType, fieldName, propertyName);
    }

    private static string GeneratePropertyClass(FieldInfo field)
    {
        var sb = new StringBuilder();
        sb.AppendLine("// <auto-generated/>");
        sb.AppendLine("using System.ComponentModel;");
        sb.AppendLine();
        sb.AppendLine($"namespace {field.ClassName}_Generated");
        sb.AppendLine("{");
        sb.AppendLine($"    public partial class {field.ClassName} : INotifyPropertyChanged");
        sb.AppendLine("    {");
        sb.AppendLine("        public event PropertyChangedEventHandler? PropertyChanged;");
        sb.AppendLine();
        sb.AppendLine($"        public {field.FieldType} {field.PropertyName}");
        sb.AppendLine("        {");
        sb.AppendLine($"            get => {field.FieldName};");
        sb.AppendLine("            set");
        sb.AppendLine("            {");
        sb.AppendLine($"                if ({field.FieldName} != value)");
        sb.AppendLine("                {{");
        sb.AppendLine($"                    {field.FieldName} = value;");
        sb.AppendLine("                    OnPropertyChanged(nameof(value));");
        sb.AppendLine("                }");
        sb.AppendLine("            }");
        sb.AppendLine("        }");
        sb.AppendLine();
        sb.AppendLine("        protected virtual void OnPropertyChanged(string propertyName)");
        sb.AppendLine("        {");
        sb.AppendLine("            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));");
        sb.AppendLine("        }");
        sb.AppendLine("    }");
        sb.AppendLine("}");
        return sb.ToString();
    }
}

// 特性定义（在使用方项目中）
// [AttributeUsage(AttributeTargets.Field)]
// public class AutoNotifyAttribute : Attribute { }

// 使用示例：
// public partial class MyViewModel
// {
//     [AutoNotify] private string _name = "";
//     [AutoNotify] private int _age = 0;
// }
// 编译后自动生成 Name 与 Age 属性，并实现 INotifyPropertyChanged

5.8 Roslyn 分析器

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;
using System.Collections.Immutable;

// 自定义分析器：检测 async void 方法
[DiagnosticAnalyzer(LanguageNames.CSharp)]
public class AsyncVoidMethodAnalyzer : DiagnosticAnalyzer
{
    // 诊断规则定义
    public static readonly DiagnosticDescriptor AsyncVoidRule = new(
        id: "FANDEX001",
        title: "避免使用 async void 方法",
        messageFormat: "方法 '{0}' 使用了 async void，建议返回 Task 或 ValueTask",
        category: "Design",
        defaultSeverity: DiagnosticSeverity.Warning,
        isEnabledByDefault: true,
        description: "async void 方法异常无法被调用方捕获，可能导致应用崩溃。",
        helpLinkUri: "https://learn.microsoft.com/dotnet/csharp/async");

    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics =>
        ImmutableArray.Create(AsyncVoidRule);

    public override void Initialize(AnalysisContext context)
    {
        // 配置分析器行为
        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
        context.EnableConcurrentExecution();

        // 注册语法节点分析
        context.RegisterSyntaxNodeAction(AnalyzeMethod, SyntaxKind.MethodDeclaration);
    }

    private static void AnalyzeMethod(SyntaxNodeAnalysisContext context)
    {
        var method = (MethodDeclarationSyntax)context.Node;

        // 检查是否为 async void（非事件处理器）
        var isAsync = method.Modifiers.Any(SyntaxKind.AsyncKeyword);
        var isVoid = method.ReturnType is PredefinedTypeSyntax pts
                     && pts.Keyword.IsKind(SyntaxKind.VoidKeyword);

        if (!isAsync || !isVoid) return;

        // 排除事件处理器（async void 事件处理器是允许的）
        if (IsEventHandlerSignature(method, context.SemanticModel)) return;

        // 报告诊断
        var diagnostic = Diagnostic.Create(
            AsyncVoidRule,
            method.GetLocation(),
            method.Identifier.Text);

        context.ReportDiagnostic(diagnostic);
    }

    private static bool IsEventHandlerSignature(
        MethodDeclarationSyntax method, SemanticModel semanticModel)
    {
        var parameters = method.ParameterList.Parameters;
        if (parameters.Count != 2) return false;

        // 第一个参数应为 object sender
        var firstType = semanticModel.GetTypeInfo(parameters[0].Type).Type;
        if (firstType?.SpecialType != SpecialType.System_Object) return false;

        // 第二个参数应为 EventArgs 派生类
        var secondType = semanticModel.GetTypeInfo(parameters[1].Type).Type;
        var eventArgsType = semanticModel.Compilation.GetTypeByMetadataName("System.EventArgs");
        return secondType is not null
            && eventArgsType is not null
            && secondType.Equals(eventArgsType, SymbolEqualityComparer.Default);
    }
}

// .editorconfig 配置示例
// [*.cs]
// dotnet_diagnostic.FANDEX001.severity = error
// dotnet_diagnostic.CA2007.severity = warning
// dotnet_diagnostic.CA1062.severity = suggestion

5.9 xUnit 高级特性

using Xunit;
using Xunit.Abstractions;

// 自定义 Trait：分类标记
[TraitDiscoverer("TestCategoryDiscoverer", "TestAssembly")]
[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
public class TestCategoryAttribute : Attribute, ITraitAttribute
{
    public string Category { get; }
    public TestCategoryAttribute(string category) => Category = category;
}

// 测试输出辅助：ITestOutputHelper
public class LoggingTests : IDisposable
{
    private readonly ITestOutputHelper _output;
    private readonly StringWriter _logCapture;

    public LoggingTests(ITestOutputHelper output)
    {
        _output = output;
        _logCapture = new StringWriter();
        Console.SetOut(_logCapture);
    }

    [Fact]
    public void TestWithLogging()
    {
        _output.WriteLine("测试开始");
        // 业务逻辑
        _output.WriteLine($"当前时间: {DateTime.Now}");
        Assert.True(true);
    }

    public void Dispose()
    {
        var logs = _logCapture.ToString();
        _output.WriteLine($"捕获的日志:\n{logs}");
        _logCapture.Dispose();
    }
}

// 测试集合：共享上下文
[CollectionDefinition("Database collection")]
public class DatabaseCollection : ICollectionFixture<DatabaseFixture> { }

[Collection("Database collection")]
public class UserRepoTests : IClassFixture<DatabaseFixture>
{
    private readonly DatabaseFixture _fixture;

    public UserRepoTests(DatabaseFixture fixture)
    {
        _fixture = fixture;
    }

    [Fact]
    public void Test1() { }

    [Fact]
    public void Test2() { }
}

public class DatabaseFixture : IDisposable
{
    public DatabaseFixture()
    {
        // 初始化共享资源
    }

    public void Dispose()
    {
        // 清理资源
    }
}

// 自定义断言
public static class CustomAssertions
{
    public static void ShouldBeEquivalentTo<T>(T actual, T expected)
    {
        Assert.Equal(expected, actual);
    }

    public static async Task ShouldCompleteWithinAsync(
        Func<Task> action, TimeSpan timeout)
    {
        var task = action();
        var completed = await Task.WhenAny(task, Task.Delay(timeout));
        Assert.Same(task, completed);
    }
}

5.10 完整 CI/CD 流水线

# .github/workflows/dotnet-ci.yml
name: .NET CI/CD

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]
  release:
    types: [published]

env:
  DOTNET_VERSION: '8.0.x'
  CONFIGURATION: 'Release'

jobs:
  # 阶段 1：代码质量检查
  quality:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }}

      - name: Restore tools
        run: dotnet tool restore

      - name: Format check
        run: dotnet format --verify-no-changes --severity warn

      - name: Lint
        run: dotnet build --no-restore -p:EnforceCodeStyleInBuild=true

  # 阶段 2：单元测试
  unit-test:
    needs: quality
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }}

      - name: Restore
        run: dotnet restore

      - name: Build
        run: dotnet build --no-restore -c ${{ env.CONFIGURATION }}

      - name: Test
        run: |
          dotnet test --no-build -c ${{ env.CONFIGURATION }} \
            --logger "trx;LogFileName=unit-tests.trx" \
            --logger "html;LogFileName=unit-tests.html" \
            --collect:"XPlat Code Coverage" \
            --results-directory ./TestResults

      - name: Upload test results
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: unit-test-results
          path: ./TestResults

      - name: Upload coverage
        uses: codecov/codecov-action@v4
        with:
          files: ./TestResults/**/coverage.cobertura.xml
          flags: unittests

  # 阶段 3：集成测试
  integration-test:
    needs: unit-test
    runs-on: ubuntu-latest
    services:
      sqlserver:
        image: mcr.microsoft.com/mssql/server:2022-latest
        env:
          ACCEPT_EULA: Y
          SA_PASSWORD: YourStrong!Passw0rd
        ports:
          - 1433:1433
        options: >-
          --health-cmd "sqlcmd -S localhost -U sa -P 'YourStrong!Passw0rd' -Q 'SELECT 1'"
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    steps:
      - uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }}

      - name: Restore & Build
        run: |
          dotnet restore
          dotnet build --no-restore -c ${{ env.CONFIGURATION }}

      - name: Integration tests
        env:
          ConnectionStrings__Default: "Server=localhost,1433;Database=TestDb;User Id=sa;Password=YourStrong!Passw0rd;TrustServerCertificate=true"
        run: |
          dotnet test --no-build -c ${{ env.CONFIGURATION }} \
            --filter "Category=Integration" \
            --logger "trx;LogFileName=integration-tests.trx"

  # 阶段 4：安全扫描
  security:
    needs: unit-test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Run CodeQL
        uses: github/codeql-action/init@v3
        with:
          languages: csharp

      - name: Build
        run: |
          dotnet restore
          dotnet build --no-restore

      - name: CodeQL analysis
        uses: github/codeql-action/analyze@v3

      - name: Dependency scan
        run: dotnet list package --vulnerable --include-transitive

  # 阶段 5：发布
  publish:
    needs: [integration-test, security]
    runs-on: ubuntu-latest
    if: github.event_name == 'release'
    steps:
      - uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }}

      - name: Publish
        run: |
          dotnet publish -c ${{ env.CONFIGURATION }} \
            -r linux-x64 \
            --self-contained \
            -p:PublishSingleFile=true \
            -p:PublishTrimmed=true \
            -o ./publish

      - name: Build Docker image
        run: |
          docker build -t myapp:${{ github.event.release.tag_name }} .

      - name: Push to registry
        run: |
          echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USER }} --password-stdin
          docker push myapp:${{ github.event.release.tag_name }}

  # 阶段 6：部署
  deploy:
    needs: publish
    runs-on: ubuntu-latest
    environment: production
    steps:
      - name: Deploy to production
        run: |
          echo "部署到生产环境"
          # kubectl apply -f k8s/

5.11 Docker 化部署

# Dockerfile - 多阶段构建
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src

# 复制项目文件并还原依赖（利用缓存层）
COPY *.csproj ./
RUN dotnet restore

# 复制源代码并构建
COPY . .
RUN dotnet publish -c Release -o /app/publish \
    -p:UseAppHost=false

# 运行时镜像
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS runtime
WORKDIR /app

# 安装 ICU 全球化支持
RUN apt-get update && apt-get install -y libicu-dev

COPY --from=build /app/publish ./

# 配置健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD curl -f http://localhost:8080/health || exit 1

# 配置非 root 用户
RUN useradd -m appuser
USER appuser

EXPOSE 8080
ENV ASPNETCORE_URLS=http://+:8080

ENTRYPOINT ["dotnet", "MyApp.dll"]

# docker-compose.yml - 本地开发环境
version: '3.8'

services:
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      - ConnectionStrings__Default=Server=db;Database=MyApp;User Id=sa;Password=YourStrong!Passw0rd
    depends_on:
      - db
      - redis

  db:
    image: mcr.microsoft.com/mssql/server:2022-latest
    environment:
      - ACCEPT_EULA=Y
      - SA_PASSWORD=YourStrong!Passw0rd
    ports:
      - "1433:1433"
    volumes:
      - dbdata:/var/opt/mssql

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  dbdata:

6. 对比分析

6.1 测试框架对比

6.2 Mock 框架对比

6.3 性能测试工具对比

7. 常见陷阱与误区

7.1 单元测试陷阱

陷阱 7.1：测试实现细节而非行为

// 错误：测试私有方法或实现细节
[Fact]
public void Test_PrivateMethod()
{
    var calc = new Calculator();
    var method = typeof(Calculator).GetMethod("ValidateInput",
        BindingFlags.NonPublic | BindingFlags.Instance);
    var result = method!.Invoke(calc, new object[] { 5 });
    Assert.True((bool)result!);
}

// 正确：通过公共 API 测试行为
[Fact]
public void Add_NegativeInput_Throws()
{
    var calc = new Calculator();
    Assert.Throws<ArgumentException>(() => calc.Add(-1, 0));
}

陷阱 7.2：过度 Mock 导致测试脆弱

// 错误：Mock 每一个细节，重构即失败
[Fact]
public void Test_OverMocked()
{
    _mock.Setup(x => x.Method1()).Returns(1);
    _mock.Setup(x => x.Method2(It.IsAny<int>())).Returns(2);
    _mock.Setup(x => x.Method3(It.Is<string>(s => s.Length > 5))).Returns(3);
    // ... 大量 Mock 配置
}

// 正确：使用 Fake 对象或真实实现
public class FakeRepository : IRepository
{
    private readonly List<User> _users = new();

    public Task<User> SaveAsync(User user)
    {
        user.Id = _users.Count + 1;
        _users.Add(user);
        return Task.FromResult(user);
    }
}

陷阱 7.3：测试间共享状态

// 错误：静态字段共享状态
public class BadTests
{
    private static int _counter = 0;  // 测试间会污染

    [Fact]
    public void Test1() => _counter++;

    [Fact]
    public void Test2() => Assert.Equal(1, _counter);  // 顺序依赖！
}

// 正确：使用实例字段（xUnit 每测试新实例）
public class GoodTests
{
    private int _counter = 0;

    [Fact]
    public void Test1() => _counter++;

    [Fact]
    public void Test2() => Assert.Equal(0, _counter);  // 独立
}

7.2 异步测试陷阱

陷阱 7.4：async void 测试方法

// 错误：async void 无法被测试框架正确捕获异常
[Fact]
public async void BadAsyncTest()
{
    await Task.Delay(100);
    Assert.True(false);  // 异常被吞掉！
}

// 正确：返回 Task
[Fact]
public async Task GoodAsyncTest()
{
    await Task.Delay(100);
    Assert.True(false);
}

陷阱 7.5：未 await 异步操作

[Fact]
public async Task Test_NotAwaited()
{
    var task = _service.DoSomethingAsync();
    // 忘记 await，断言在操作完成前执行
    Assert.NotNull(_service.Result);
}

// 正确
[Fact]
public async Task Test_Awaited()
{
    await _service.DoSomethingAsync();
    Assert.NotNull(_service.Result);
}

7.3 基准测试陷阱

陷阱 7.6：在 Debug 模式下运行基准

// 错误：Debug 模式下结果不准确
// dotnet run  // 默认 Debug

// 正确：必须使用 Release 模式
// dotnet run -c Release

陷阱 7.7：未预热导致冷启动偏差

// BenchmarkDotNet 自动处理预热，无需手动预热
[Benchmark]
public void ColdStart()
{
    // 错误：假设自动预热
    var dict = new Dictionary<int, string>();
    // ...
}

// 如需手动控制，使用 [GlobalSetup]
[GlobalSetup]
public void Setup()
{
    // 初始化共享资源
}

7.4 源生成器陷阱

陷阱 7.8：生成代码不可调试

// 错误：直接生成代码字符串，难以调试
var code = "public class X { ... }";
context.AddSource("X.g.cs", code);

// 正确：启用源生成器调试
// <PropertyGroup>
//   <IsRoslynComponent>true</IsRoslynComponent>
//   <DebuggerFlavor>SingleFile</DebuggerFlavor>
// </PropertyGroup>
// 在 Debugger.Launch() 中附加调试器

陷阱 7.9：增量生成器缓存失效

// 错误：使用不可哈希的类型作为输入
public record Input(List<string> Items);  // List 不可哈希

// 正确：使用 EquatableArray<T>
public record Input(EquatableArray<string> Items);

8. 工程实践与最佳实践

8.1 测试命名约定

// 命名规范：MethodName_StateUnderTest_ExpectedBehavior
public class UserServiceTests
{
    [Fact]
    public void CreateUser_ValidInput_ReturnsCreatedUser() { }

    [Fact]
    public void CreateUser_EmptyName_ThrowsArgumentException() { }

    [Fact]
    public async Task DeleteUser_NonExistingId_ReturnsFalse() { }
}

8.2 测试组织结构

tests/
├── MyApp.UnitTests/
│   ├── Services/
│   │   ├── UserServiceTests.cs
│   │   └── OrderServiceTests.cs
│   ├── Controllers/
│   │   └── UserControllerTests.cs
│   └── Models/
│       └── UserTests.cs
├── MyApp.IntegrationTests/
│   ├── Api/
│   │   ├── UserApiTests.cs
│   │   └── OrderApiTests.cs
│   └── Database/
│       └── RepositoryTests.cs
└── MyApp.E2ETests/
    ├── UserJourneyTests.cs
    └── CheckoutTests.cs

8.3 测试覆盖目标

8.4 代码规范配置

# .editorconfig
root = true

[*.cs]
# 命名规范
dotnet_naming_rule.private_fields_underscore.symbols = private_fields
dotnet_naming_rule.private_fields_underscore.style = underscore_style
dotnet_naming_rule.private_fields_underscore.severity = error

dotnet_naming_style.underscore_style.required_prefix = _
dotnet_naming_style.underscore_style.capitalization = camel_case

dotnet_naming_symbols.private_fields.applicable_kinds = field
dotnet_naming_symbols.private_fields.applicable_accessibilities = private

# 严重级别配置
dotnet_diagnostic.CA1062.severity = warning    # 参数验证
dotnet_diagnostic.CA2007.severity = suggestion # ConfigureAwait
dotnet_diagnostic.CA2016.severity = warning    # CancellationToken
dotnet_diagnostic.IDE0001.severity = suggestion # 简化名称
dotnet_diagnostic.IDE0009.severity = none      # this 限定符

# 代码风格
csharp_style_var_for_built_in_types = true:suggestion
csharp_style_var_when_type_is_apparent = true:suggestion
csharp_style_expression_bodied_methods = when_on_single_line:suggestion
csharp_new_line_before_open_brace = all

8.5 Git Hooks 自动化

// package.json 或 .husky/hooks.json
{
  "hooks": {
    "pre-commit": "dotnet format --verify-no-changes && dotnet build",
    "pre-push": "dotnet test --filter \"Category!=Integration\""
  }
}

# .husky/pre-commit
#!/bin/sh
echo "运行代码格式化检查..."
dotnet format --verify-no-changes || exit 1

echo "构建检查..."
dotnet build --no-restore || exit 1

8.6 测试报告与可视化

<!-- 测试结果生成 HTML 报告 -->
<!-- dotnet test --logger "html;LogFileName=report.html" -->

<!-- 使用 ReportGenerator 合并覆盖率 -->
<!-- dotnet tool install -g dotnet-reportgenerator-globaltool -->
<!-- reportgenerator -reports:**/coverage.cobertura.xml -targetdir:coverage-report -reporttypes:Html -->

9. 案例研究

9.1 案例一：电商系统测试策略

场景：中型电商系统，包含用户、商品、订单、支付四个核心模块。

测试金字塔实施：

单元测试（70%）：
- 业务规则验证（价格计算、库存检查）
- 数据模型验证
- 工具类测试

集成测试（20%）：
- API 端到端测试
- 数据库持久化测试
- 第三方支付接口测试（使用 WireMock）

E2E 测试（10%）：
- 关键用户流程（注册→下单→支付→收货）
- 多角色权限测试

核心代码示例：

// 单元测试：价格计算逻辑
public class PricingServiceTests
{
    private readonly PricingService _service = new();

    [Theory]
    [InlineData(100, 0.1, 90)]      // 10% 折扣
    [InlineData(100, 0.5, 50)]      // 50% 折扣
    [InlineData(100, 0, 100)]       // 无折扣
    [InlineData(0, 0.5, 0)]         // 零价格
    public void CalculateDiscount_ValidInputs_ReturnsCorrectPrice(
        decimal original, decimal discount, decimal expected)
    {
        var result = _service.CalculateDiscount(original, discount);
        Assert.Equal(expected, result);
    }

    [Fact]
    public void CalculateDiscount_NegativePrice_Throws()
    {
        Assert.Throws<ArgumentException>(
            () => _service.CalculateDiscount(-100, 0.1m));
    }
}

// 集成测试：订单流程
public class OrderFlowIntegrationTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly HttpClient _client;

    public OrderFlowIntegrationTests(WebApplicationFactory<Program> factory)
    {
        _client = factory.CreateClient();
    }

    [Fact]
    public async Task CompleteOrder_Flow_WorksEndToEnd()
    {
        // 1. 用户注册
        var registerResponse = await _client.PostAsJsonAsync("/api/auth/register",
            new { Username = "testuser", Password = "Password123!" });

        // 2. 添加商品到购物车
        var cartResponse = await _client.PostAsJsonAsync("/api/cart/add",
            new { ProductId = 1, Quantity = 2 });

        // 3. 创建订单
        var orderResponse = await _client.PostAsJsonAsync("/api/orders",
            new { ShippingAddress = "测试地址" });

        // 4. 验证订单
        var order = await orderResponse.Content.ReadFromJsonAsync<Order>();
        Assert.NotNull(order);
        Assert.Equal(OrderStatus.Pending, order!.Status);
    }
}

9.2 案例二：性能优化案例

场景：API 响应时间从 500ms 优化至 50ms。

// 优化前：同步阻塞
public class UserService
{
    public List<UserDto> GetAllUsers()
    {
        var users = _dbContext.Users.ToList();  // 同步查询
        var dtos = new List<UserDto>();
        foreach (var user in users)
        {
            var orders = _dbContext.Orders.Where(o => o.UserId == user.Id).ToList();
            dtos.Add(MapToDto(user, orders));
        }
        return dtos;  // N+1 查询问题
    }
}

// 优化后：异步 + 批量查询
public class UserService
{
    public async Task<List<UserDto>> GetAllUsersAsync()
    {
        var users = await _dbContext.Users
            .AsNoTracking()
            .ToListAsync();

        var userIds = users.Select(u => u.Id).ToList();
        var orders = await _dbContext.Orders
            .Where(o => userIds.Contains(o.UserId))
            .ToListAsync();

        var ordersByUser = orders.ToLookup(o => o.UserId);
        return users.Select(u => MapToDto(u, ordersByUser[u.Id].ToList())).ToList();
    }
}

基准测试验证：

[MemoryDiagnoser]
public class UserServiceBenchmarks
{
    private UserService _syncService = null!;
    private UserService _asyncService = null!;
    private AppDbContext _dbContext = null!;

    [GlobalSetup]
    public void Setup()
    {
        // 初始化测试数据
    }

    [Benchmark(Baseline = true)]
    public List<UserDto> Sync_GetAllUsers() => _syncService.GetAllUsers();

    [Benchmark]
    public async Task<List<UserDto>> Async_GetAllUsers() =>
        await _asyncService.GetAllUsersAsync();
}

10. 习题与参考答案

10.1 基础题（L1-L2）

习题 10.1.1：简述 xUnit 与 NUnit 在测试隔离性上的区别。

参考答案：

• xUnit：每个测试方法运行在独立的测试类实例上，构造函数等价于 [SetUp]，IDisposable.Dispose() 等价于 [TearDown]
• NUnit：默认每个测试类共享一个实例，需通过 [FixtureLifeCycle] 配置隔离策略

习题 10.1.2：解释 Mock、Stub、Fake、Spy 的区别。

参考答案：

• Stub（桩）：返回预设值，不验证调用
• Mock（模拟）：验证调用行为，可返回预设值
• Fake（假对象）：提供简化的可工作实现（如内存数据库）
• Spy（间谍）：记录调用供事后验证，可选择性返回预设值
• Dummy（哑对象）：仅用于填充参数列表，从不被调用

10.2 应用题（L3）

习题 10.2.1：为以下方法编写完整的单元测试。

public class StringAnalyzer
{
    public bool IsPalindrome(string input)
    {
        if (string.IsNullOrEmpty(input)) return true;
        var normalized = input.ToLowerInvariant().Replace(" ", "");
        return normalized.SequenceEqual(normalized.Reverse());
    }
}

参考答案：

public class StringAnalyzerTests
{
    private readonly StringAnalyzer _analyzer = new();

    [Theory]
    [InlineData("", true)]                    // 空字符串
    [InlineData("a", true)]                   // 单字符
    [InlineData("aa", true)]                  // 重复字符
    [InlineData("aba", true)]                 // 奇数长度回文
    [InlineData("abba", true)]                // 偶数长度回文
    [InlineData("A man a plan a canal Panama", true)] // 含空格与大小写
    [InlineData("hello", false)]              // 非回文
    [InlineData("Hello", false)]              // 大小写测试
    public void IsPalindrome_VariousInputs_ReturnsExpected(string input, bool expected)
    {
        Assert.Equal(expected, _analyzer.IsPalindrome(input));
    }

    [Fact]
    public void IsPalindrome_NullInput_ReturnsTrue()
    {
        Assert.True(_analyzer.IsPalindrome(null!));
    }
}