C#高级编程实战：异步、内存管理、Web API与单元测试进阶指南

这次我们来看一个面向 C# 开发者的进阶学习路径。项目标题“Learn Complete C# – Beginner to Advanced part2”清晰地指向了 C# 语言从入门到精通的第二部分，这意味着它聚焦于更深入、更高级的主题。对于已经掌握基础语法、面向对象编程的开发者来说，如何跨越到企业级应用开发、性能优化和复杂问题解决，是成长的关键瓶颈。这个学习资源正是为了解决这个问题。

本文不会空谈概念，而是直接切入实战。我们将围绕 C# 高级编程的核心领域，如异步与并发、内存管理、反射与元数据、依赖注入、Web API 开发、单元测试以及性能调优等，构建一套可落地、可验证的学习与验证体系。无论你是想提升现有项目质量，还是为面试和开发更复杂的系统做准备，这里的内容都值得你花时间实践。

下面，我们将从核心能力速览开始，明确学习目标，然后逐步搭建环境，通过具体的代码示例来验证每个高级特性，最后提供常见问题的排查思路和最佳实践，确保你能将知识转化为实际编码能力。

1. 核心能力速览

2. 适用场景与使用边界

这套进阶学习内容主要适用于以下几类开发者：

1. 已有基础的 C# 程序员 ：熟悉语法和基本 OOP，希望深入理解框架底层机制和现代编程范式。
2. 准备技术面试者 ：面试中常涉及异步、内存、设计模式等高级话题，系统学习能建立知识体系。
3. 面临性能瓶颈的项目维护者 ：需要诊断和优化现有代码的内存使用、响应速度。
4. 计划开发新模块或系统者 ：在开始前，验证如依赖注入容器、Web API 架构等技术的可行性。

使用边界与注意事项：

• 并非零基础教程 ：需要具备 C# 基础语法、类与对象、集合等知识。
• 理论结合实践 ：概念需通过编码验证，不建议只阅读不动手。
• 环境一致性 ：示例代码基于较新的 .NET 版本（如 .NET 6/8），使用旧版本（如 .NET Framework 4.x）可能遇到 API 差异，需注意适配。
• 合法合规 ：所有代码示例用于学习目的。在实际项目中应用时，需遵守公司代码规范和开源协议，特别是涉及反射、动态代码生成等技术时，要评估安全风险。

3. 环境准备与前置条件

在开始动手之前，请确保你的开发环境满足以下要求。这是后续所有实验能够顺利进行的基础。

1. .NET SDK ：这是核心。建议安装最新的长期支持（LTS）版本，如 .NET 8.0。你可以从微软官网或使用命令行安装。

   • 验证安装 ：打开终端（CMD, PowerShell, Bash）并运行：

     dotnet --version
     

     应输出类似 8.0.100 的版本号。

2. 集成开发环境（IDE） ：

   • Visual Studio 2022 (社区版免费) ：功能全面，特别适合 Windows 平台的大型项目开发，内置强大的调试和性能分析工具。
   • Visual Studio Code ：轻量跨平台，需安装 C# 扩展包（ ms-dotnettools.csharp ）。适合喜欢轻量编辑器和命令行操作的开发者。

3. 操作系统 ：Windows 10/11， macOS 或 Linux 发行版（如 Ubuntu）均可。.NET 是跨平台的。

4. 可选工具 ：

   • Git ：用于版本管理和克隆示例仓库（如果有）。
   • Postman 或 curl ：用于测试 Web API 接口。
   • BenchmarkDotNet ：一个强大的 .NET 基准测试库，用于性能验证（可通过 NuGet 安装）。

4. 创建测试项目与解决方案结构

我们将创建一个解决方案，包含多个类库和可执行项目，以模块化方式组织不同主题的代码。

1. 创建解决方案目录和文件 ： 在合适的位置，打开终端，执行以下命令：

   mkdir CSharpAdvancedPart2
   cd CSharpAdvancedPart2
   dotnet new sln -n CSharpAdvancedPart2
   

2. 创建类库项目 ：我们将为每个核心主题创建独立的类库。

   # 异步与并发
   dotnet new classlib -n AsyncConcurrency
   # LINQ与集合
   dotnet new classlib -n LinqCollections
   # 反射与动态编程
   dotnet new classlib -n ReflectionDynamic
   # 内存与性能
   dotnet new classlib -n MemoryPerformance
   # 依赖注入与测试
   dotnet new classlib -n DependencyInjectionTests
   # Web API 项目
   dotnet new webapi -n AdvancedWebApi
   # 控制台主程序（用于运行示例）
   dotnet new console -n AdvancedConsoleRunner
   

3. 将项目添加到解决方案 ：

   dotnet sln add AsyncConcurrency/LinqCollections/ReflectionDynamic/MemoryPerformance/DependencyInjectionTests/AdvancedWebApi/AdvancedConsoleRunner
   

4. 添加项目引用 ：让控制台项目可以引用其他类库。

   cd AdvancedConsoleRunner
   dotnet add reference ../AsyncConcurrency
   dotnet add reference ../LinqCollections
   dotnet add reference ../ReflectionDynamic
   dotnet add reference ../MemoryPerformance
   dotnet add reference ../DependencyInjectionTests
   cd ..
   

   现在，你的解决方案结构已经搭建完成，可以开始在每个项目中编写和测试代码了。

5. 功能测试与效果验证：核心主题实战

我们将选取几个最具代表性的高级主题，编写代码进行验证。请在你的对应类库项目中创建类文件并实现以下示例。

5.1 异步编程深度实践 ( AsyncConcurrency 项目)

测试目的 ：理解 async / await 的非阻塞本质、 Task 的异常处理、取消机制以及并发集合的使用。

操作步骤与代码验证 ：

1. 基础异步与异常处理 ： 在 AsyncConcurrency 项目中创建 AsyncBasics.cs 。

   using System;
   using System.Threading.Tasks;
   
   namespace AsyncConcurrency
   {
       public class AsyncBasics
       {
           // 模拟一个可能失败或耗时的异步操作
           public static async Task<string> FetchDataAsync(int delayMs, bool shouldFail = false)
           {
               await Task.Delay(delayMs);
               if (shouldFail)
                   throw new InvalidOperationException("模拟异步操作失败");
               return $"数据已获取，延迟 {delayMs}ms";
           }
   
           public static async Task DemonstrateAsyncAwait()
           {
               Console.WriteLine("开始异步演示...");
               try
               {
                   // 并发启动多个任务，但不等待
                   Task<string> task1 = FetchDataAsync(1000);
                   Task<string> task2 = FetchDataAsync(2000);
                   Task<string> task3 = FetchDataAsync(1500, true); // 这个会失败
   
                   // 使用 Task.WhenAll 等待所有任务完成，并统一处理异常
                   Task allTasks = Task.WhenAll(task1, task2, task3);
                   try
                   {
                       await allTasks;
                       Console.WriteLine($"结果1: {task1.Result}");
                       Console.WriteLine($"结果2: {task2.Result}");
                   }
                   catch
                   {
                       // 检查每个任务的状态
                       if (task1.IsFaulted) Console.WriteLine($"任务1失败: {task1.Exception?.InnerException?.Message}");
                       if (task2.IsFaulted) Console.WriteLine($"任务2失败: {task2.Exception?.InnerException?.Message}");
                       if (task3.IsFaulted) Console.WriteLine($"任务3失败: {task3.Exception?.InnerException?.Message}");
                   }
               }
               catch (Exception ex)
               {
                   Console.WriteLine($"外层捕获异常: {ex.Message}");
               }
               Console.WriteLine("异步演示结束。");
           }
       }
   }
   

2. 使用 CancellationToken 取消任务 ： 创建 CancellationDemo.cs 。

   using System;
   using System.Threading;
   using System.Threading.Tasks;
   
   namespace AsyncConcurrency
   {
       public class CancellationDemo
       {
           public static async Task LongRunningOperationAsync(CancellationToken cancellationToken)
           {
               for (int i = 0; i < 10; i++)
               {
                   if (cancellationToken.IsCancellationRequested)
                   {
                       Console.WriteLine("操作被取消。");
                       cancellationToken.ThrowIfCancellationRequested(); // 抛出 OperationCanceledException
                   }
                   Console.WriteLine($"工作进度: {i + 1}/10");
                   await Task.Delay(500, cancellationToken); // Delay 也支持取消
               }
               Console.WriteLine("操作完成。");
           }
   
           public static async Task DemonstrateCancellation()
           {
               var cts = new CancellationTokenSource();
               // 设置3秒后自动取消
               cts.CancelAfter(3000);
   
               try
               {
                   await LongRunningOperationAsync(cts.Token);
               }
               catch (OperationCanceledException)
               {
                   Console.WriteLine("任务已被成功取消。");
               }
           }
       }
   }
   

预期结果与判断 ：

• 运行 AsyncBasics.DemonstrateAsyncAwait() 应看到任务1和任务2成功输出，任务3失败信息被捕获，程序不会崩溃。
• 运行 CancellationDemo.DemonstrateCancellation() 应看到任务在约3秒后被中断，并输出取消信息。
• 成功标准 ：程序能正确处理异步并发、异常聚合和用户取消，UI或主线程保持响应。

5.2 LINQ 高级查询与性能 ( LinqCollections 项目)

测试目的 ：掌握 LINQ 的延迟执行与立即执行区别、复杂查询编写、以及如何通过 AsParallel() 进行并行查询（PLINQ）。

操作步骤与代码验证 ：

1. 延迟执行 vs 立即执行 ： 在 LinqCollections 项目中创建 LinqExecution.cs 。

   using System;
   using System.Linq;
   using System.Collections.Generic;
   
   namespace LinqCollections
   {
       public class LinqExecution
       {
           public static void DemonstrateDeferredExecution()
           {
               var numbers = new List<int> { 1, 2, 3, 4, 5 };
               // 延迟执行：查询被定义，但未执行
               var query = numbers.Where(n => {
                   Console.WriteLine($"过滤数字: {n}");
                   return n % 2 == 0;
               }).Select(n => {
                   Console.WriteLine($"映射数字: {n}");
                   return n * n;
               });
   
               Console.WriteLine("查询已定义，开始迭代：");
               // 此时才真正执行过滤和映射操作
               foreach (var item in query)
               {
                   Console.WriteLine($"结果: {item}");
               }
   
               Console.WriteLine("\n--- 立即执行示例 ---");
               // 立即执行：使用 ToList(), ToArray(), Count() 等
               var evenSquaresList = numbers.Where(n => n % 2 == 0)
                                            .Select(n => n * n)
                                            .ToList(); // 立即执行并物化为列表
               Console.WriteLine($"列表元素: {string.Join(", ", evenSquaresList)}");
           }
       }
   }
   

2. 并行 LINQ (PLINQ) 性能对比 ： 创建 PlinqPerformance.cs 。需要生成大量数据来观察效果。

   using System;
   using System.Diagnostics;
   using System.Linq;
   
   namespace LinqCollections
   {
       public class PlinqPerformance
       {
           public static void DemonstratePlinq()
           {
               var random = new Random();
               var largeData = Enumerable.Range(1, 10_000_000)
                                         .Select(_ => random.Next(1, 1000))
                                         .ToArray();
   
               Console.WriteLine($"数据量: {largeData.Length:N0}");
   
               // 顺序 LINQ
               var sw = Stopwatch.StartNew();
               var sequentialSum = largeData.Where(x => x > 500).Sum();
               sw.Stop();
               Console.WriteLine($"顺序 LINQ - 总和: {sequentialSum:N0}, 耗时: {sw.ElapsedMilliseconds}ms");
   
               // 并行 LINQ (PLINQ)
               sw.Restart();
               var parallelSum = largeData.AsParallel().Where(x => x > 500).Sum();
               sw.Stop();
               Console.WriteLine($"并行 LINQ - 总和: {parallelSum:N0}, 耗时: {sw.ElapsedMilliseconds}ms");
   
               // 注意：对于CPU密集型且无依赖的操作，PLINQ通常更快，但会有开销。
           }
       }
   }
   

预期结果与判断 ：

• 运行 LinqExecution.DemonstrateDeferredExecution() 应清晰看到控制台输出分为“定义查询”和“迭代执行”两个阶段。
• 运行 PlinqPerformance.DemonstratePlinq() 应看到并行查询的耗时显著低于顺序查询（在多核CPU上）。这是验证 PLINQ 有效的直接证据。
• 成功标准 ：理解查询何时执行，并能根据数据量和操作复杂度合理选择是否使用并行。

5.3 反射、动态编程与源生成器 ( ReflectionDynamic 项目)

测试目的 ：了解如何在运行时检查和使用类型信息，以及更高效的编译时代码生成技术。

操作步骤与代码验证 ：

1. 反射基础：动态调用方法 ： 在 ReflectionDynamic 项目中创建 ReflectionDemo.cs 。

   using System;
   using System.Reflection;
   
   namespace ReflectionDynamic
   {
       public class Calculator
       {
           public int Add(int a, int b) => a + b;
           private int Multiply(int a, int b) => a * b;
       }
   
       public class ReflectionDemo
       {
           public static void DemonstrateReflection()
           {
               var calc = new Calculator();
               Type type = calc.GetType();
   
               // 获取并调用公共方法
               MethodInfo addMethod = type.GetMethod("Add");
               object result = addMethod.Invoke(calc, new object[] { 5, 3 });
               Console.WriteLine($"反射调用 Add(5,3) 结果: {result}");
   
               // 获取并调用私有方法 (需要 BindingFlags)
               MethodInfo multiplyMethod = type.GetMethod("Multiply", BindingFlags.NonPublic | BindingFlags.Instance);
               object privateResult = multiplyMethod.Invoke(calc, new object[] { 5, 3 });
               Console.WriteLine($"反射调用私有 Multiply(5,3) 结果: {privateResult}");
   
               // 获取所有属性、方法等信息
               Console.WriteLine("\nCalculator 类型成员：");
               foreach (var member in type.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
               {
                   Console.WriteLine($"  {member.MemberType}: {member.Name}");
               }
           }
       }
   }
   

2. 使用 dynamic 关键字 ： 创建 DynamicDemo.cs 。反射性能开销大， dynamic 提供了另一种晚期绑定的方式。

   using System;
   
   namespace ReflectionDynamic
   {
       public class DynamicDemo
       {
           public static void DemonstrateDynamic()
           {
               // 使用 ExpandoObject 创建动态对象
               dynamic person = new System.Dynamic.ExpandoObject();
               person.Name = "Alice";
               person.Age = 30;
               person.SayHello = (Action)(() => Console.WriteLine($"Hello, I'm {person.Name}"));
   
               Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
               person.SayHello();
   
               // 注意：dynamic 绕过了编译时类型检查，错误会在运行时抛出
               try
               {
                   Console.WriteLine(person.NonExistentProperty);
               }
               catch (Microsoft.CSharp.RuntimeBinder.RuntimeBinderException ex)
               {
                   Console.WriteLine($"动态访问错误: {ex.Message}");
               }
           }
       }
   }
   

预期结果与判断 ：

• 运行 ReflectionDemo.DemonstrateReflection() 应成功调用公共和私有方法，并列出类型的所有成员。
• 运行 DynamicDemo.DemonstrateDynamic() 应能动态添加属性和方法并调用，同时能捕获到访问不存在的属性时的运行时异常。
• 成功标准 ：掌握在必要时通过反射或动态类型操作对象的能力，同时理解其性能代价和适用场景。

5.4 内存管理与性能分析 ( MemoryPerformance 项目)

测试目的 ：理解值类型与引用类型的内存差异、 IDisposable 模式、避免内存泄漏，并使用 BenchmarkDotNet 进行量化性能测试。

操作步骤与代码验证 ：

1. 实现 IDisposable 模式 ： 在 MemoryPerformance 项目中创建 DisposablePattern.cs 。

   using System;
   using System.Runtime.InteropServices;
   
   namespace MemoryPerformance
   {
       // 模拟一个包装了非托管资源的类
       public class UnmanagedResourceWrapper : IDisposable
       {
           private IntPtr _unmanagedHandle; // 模拟非托管句柄
           private bool _disposed = false;
   
           public UnmanagedResourceWrapper()
           {
               // 模拟分配非托管资源
               _unmanagedHandle = Marshal.AllocHGlobal(1024);
               Console.WriteLine("非托管资源已分配。");
           }
   
           public void DoWork()
           {
               if (_disposed) throw new ObjectDisposedException(nameof(UnmanagedResourceWrapper));
               Console.WriteLine("正在使用资源工作...");
           }
   
           // 实现 IDisposable 模式
           protected virtual void Dispose(bool disposing)
           {
               if (!_disposed)
               {
                   if (disposing)
                   {
                       // 释放托管资源 (本例中没有)
                   }
                   // 释放非托管资源
                   if (_unmanagedHandle != IntPtr.Zero)
                   {
                       Marshal.FreeHGlobal(_unmanagedHandle);
                       _unmanagedHandle = IntPtr.Zero;
                       Console.WriteLine("非托管资源已释放。");
                   }
                   _disposed = true;
               }
           }
   
           ~UnmanagedResourceWrapper() // 析构函数 (终结器)
           {
               Dispose(false);
           }
   
           public void Dispose()
           {
               Dispose(true);
               GC.SuppressFinalize(this); // 告知GC不需要再调用终结器
           }
       }
   
       public class DisposableDemo
       {
           public static void DemonstrateDispose()
           {
               // 使用 using 语句确保资源被释放
               using (var resource = new UnmanagedResourceWrapper())
               {
                   resource.DoWork();
               } // 此处自动调用 Dispose()
               Console.WriteLine("using 块结束，资源应已释放。");
   
               // 不好的例子：忘记释放
               var leakedResource = new UnmanagedResourceWrapper();
               leakedResource.DoWork();
               // 没有调用 Dispose()，依赖GC和终结器，释放时机不确定。
           }
       }
   }
   

2. 使用 BenchmarkDotNet 进行性能基准测试 ： 首先，在 MemoryPerformance 项目中安装 NuGet 包：

   dotnet add package BenchmarkDotNet
   

   然后创建 StringBenchmarks.cs 。

   using BenchmarkDotNet.Attributes;
   using BenchmarkDotNet.Running;
   
   namespace MemoryPerformance
   {
       [MemoryDiagnoser] // 启用内存诊断
       public class StringBenchmarks
       {
           private readonly string[] _words = { "Hello", "World", "Benchmark", "DotNet", "Test" };
   
           [Benchmark(Baseline = true)]
           public string StringConcatenation()
           {
               string result = "";
               foreach (var word in _words)
               {
                   result += word + " "; // 产生多个中间字符串
               }
               return result.Trim();
           }
   
           [Benchmark]
           public string StringBuilderConcatenation()
           {
               var sb = new System.Text.StringBuilder();
               foreach (var word in _words)
               {
                   sb.Append(word).Append(' ');
               }
               return sb.ToString().Trim();
           }
   
           [Benchmark]
           public string StringJoin()
           {
               return string.Join(" ", _words); // 最推荐的方式
           }
       }
   
       public class BenchmarkRunnerDemo
       {
           public static void RunBenchmarks()
           {
               var summary = BenchmarkRunner.Run<StringBenchmarks>();
               // 运行后，BenchmarkDotNet 会在输出目录生成详细的报告
           }
       }
   }
   

预期结果与判断 ：

• 运行 DisposableDemo.DemonstrateDispose() 应看到资源分配和释放的日志。理解 using 语句和手动管理资源的必要性。
• 运行 BenchmarkRunnerDemo.RunBenchmarks() 会启动一个基准测试过程（可能需要以 Release 模式运行以获得准确结果）。最终报告会清晰显示 StringJoin 和 StringBuilder 在性能和内存分配上远优于简单的 + 拼接。
• 成功标准 ：建立资源管理意识，并能使用科学工具量化代码性能差异，为优化提供依据。

6. Web API 开发与依赖注入 ( AdvancedWebApi 项目)

测试目的 ：创建 RESTful API，集成依赖注入，实现仓储模式，并进行集成测试。

操作步骤与代码验证 ：

1. 定义模型、接口和仓储 ： 在 AdvancedWebApi 项目中，创建以下文件。 Models/Product.cs :

   namespace AdvancedWebApi.Models
   {
       public class Product
       {
           public int Id { get; set; }
           public string Name { get; set; } = string.Empty;
           public decimal Price { get; set; }
       }
   }
   

   Interfaces/IProductRepository.cs :

   using AdvancedWebApi.Models;
   
   namespace AdvancedWebApi.Interfaces
   {
       public interface IProductRepository
       {
           IEnumerable<Product> GetAll();
           Product? GetById(int id);
           void Add(Product product);
       }
   }
   

   Repositories/InMemoryProductRepository.cs :

   using AdvancedWebApi.Interfaces;
   using AdvancedWebApi.Models;
   
   namespace AdvancedWebApi.Repositories
   {
       public class InMemoryProductRepository : IProductRepository
       {
           private readonly List<Product> _products = new();
           private int _nextId = 1;
   
           public IEnumerable<Product> GetAll() => _products;
   
           public Product? GetById(int id) => _products.FirstOrDefault(p => p.Id == id);
   
           public void Add(Product product)
           {
               product.Id = _nextId++;
               _products.Add(product);
           }
       }
   }
   

2. 创建控制器并注入服务 ： Controllers/ProductsController.cs :

   using Microsoft.AspNetCore.Mvc;
   using AdvancedWebApi.Interfaces;
   using AdvancedWebApi.Models;
   
   namespace AdvancedWebApi.Controllers
   {
       [ApiController]
       [Route("api/[controller]")]
       public class ProductsController : ControllerBase
       {
           private readonly IProductRepository _repository;
   
           // 依赖注入：构造函数注入
           public ProductsController(IProductRepository repository)
           {
               _repository = repository;
           }
   
           [HttpGet]
           public ActionResult<IEnumerable<Product>> Get()
           {
               return Ok(_repository.GetAll());
           }
   
           [HttpGet("{id}")]
           public ActionResult<Product> Get(int id)
           {
               var product = _repository.GetById(id);
               if (product == null) return NotFound();
               return Ok(product);
           }
   
           [HttpPost]
           public ActionResult<Product> Post([FromBody] Product product)
           {
               if (product == null) return BadRequest();
               _repository.Add(product);
               // 返回创建成功的资源及位置
               return CreatedAtAction(nameof(Get), new { id = product.Id }, product);
           }
       }
   }
   

3. 在 Program.cs 中注册服务 ： 确保 Program.cs 中注册了仓储和控制器的依赖。

   using AdvancedWebApi.Interfaces;
   using AdvancedWebApi.Repositories;
   
   var builder = WebApplication.CreateBuilder(args);
   
   // 添加服务到容器
   builder.Services.AddControllers();
   builder.Services.AddSingleton<IProductRepository, InMemoryProductRepository>(); // 注册仓储
   // 学习 Swagger/OpenAPI
   builder.Services.AddEndpointsApiExplorer();
   builder.Services.AddSwaggerGen();
   
   var app = builder.Build();
   
   // 配置 HTTP 请求管道
   if (app.Environment.IsDevelopment())
   {
       app.UseSwagger();
       app.UseSwaggerUI();
   }
   
   app.UseHttpsRedirection();
   app.UseAuthorization();
   app.MapControllers();
   
   app.Run();
   

4. 运行并测试 API ： 在终端中，进入 AdvancedWebApi 目录并运行：

   dotnet run
   

   应用启动后，通常会在 https://localhost:5001 或 http://localhost:5000 监听。

   • 使用浏览器或 Postman 测试 ：
     • GET https://localhost:5001/api/products ：获取所有产品（初始为空数组）。
     • POST https://localhost:5001/api/products ：Body 选择 raw JSON，输入 {"name": "Laptop", "price": 999.99} ，应返回创建的产品和 201 Created 状态码。
     • GET https://localhost:5001/api/products/1 ：获取刚创建的产品。

预期结果与判断 ：

• API 成功启动，Swagger 页面可访问（如果启用）。
• 能通过 HTTP 客户端成功进行 CRUD 操作。
• 成功标准 ：理解控制器、依赖注入、仓储模式在 Web API 中的协作方式，并能独立搭建一个具备基本功能的后端服务。

7. 单元测试与 Mock ( DependencyInjectionTests 项目)

测试目的 ：为上述 ProductRepository 和 ProductsController 编写单元测试，使用 Mock 框架隔离依赖。

操作步骤与代码验证 ：

1. 添加测试项目引用和 NuGet 包 ： 在 DependencyInjectionTests 项目目录下，运行：

   dotnet add package Microsoft.NET.Test.Sdk
   dotnet add package xunit
   dotnet add package xunit.runner.visualstudio
   dotnet add package Moq # 流行的 Mock 框架
   dotnet add package Microsoft.AspNetCore.Mvc.Testing # 用于集成测试 (如果需要测试Web API)
   dotnet add reference ../AdvancedWebApi # 引用被测试项目
   

2. 编写仓储层的单元测试 ： 创建 RepositoriesTests/ProductRepositoryTests.cs 。

   using Xunit;
   using AdvancedWebApi.Repositories;
   using AdvancedWebApi.Models;
   
   namespace DependencyInjectionTests.RepositoriesTests
   {
       public class ProductRepositoryTests
       {
           [Fact]
           public void GetAll_Initially_ReturnsEmptyList()
           {
               // Arrange
               var repo = new InMemoryProductRepository();
   
               // Act
               var products = repo.GetAll();
   
               // Assert
               Assert.Empty(products);
           }
   
           [Fact]
           public void Add_Product_ShouldAssignIdAndBeRetrievable()
           {
               // Arrange
               var repo = new InMemoryProductRepository();
               var newProduct = new Product { Name = "Test", Price = 10.0m };
   
               // Act
               repo.Add(newProduct);
               var retrieved = repo.GetById(1);
   
               // Assert
               Assert.NotNull(retrieved);
               Assert.Equal(1, retrieved.Id);
               Assert.Equal("Test", retrieved.Name);
           }
       }
   }
   

3. 使用 Moq 测试控制器（隔离仓储） ： 创建 ControllersTests/ProductsControllerTests.cs 。

   using Xunit;
   using Moq;
   using Microsoft.AspNetCore.Mvc;
   using AdvancedWebApi.Controllers;
   using AdvancedWebApi.Interfaces;
   using AdvancedWebApi.Models;
   
   namespace DependencyInjectionTests.ControllersTests
   {
       public class ProductsControllerTests
       {
           [Fact]
           public void Get_ReturnsAllProducts_FromRepository()
           {
               // Arrange
               var mockRepo = new Mock<IProductRepository>();
               var expectedProducts = new List<Product>
               {
                   new Product { Id = 1, Name = "Mock1", Price = 100 },
                   new Product { Id = 2, Name = "Mock2", Price = 200 }
               };
               mockRepo.Setup(repo => repo.GetAll()).Returns(expectedProducts);
               var controller = new ProductsController(mockRepo.Object);
   
               // Act
               var result = controller.Get();
   
               // Assert
               var actionResult = Assert.IsType<ActionResult<IEnumerable<Product>>>(result);
               var okResult = Assert.IsType<OkObjectResult>(actionResult.Result);
               var returnedProducts = Assert.IsAssignableFrom<IEnumerable<Product>>(okResult.Value);
               Assert.Equal(2, returnedProducts.Count());
               mockRepo.Verify(repo => repo.GetAll(), Times.Once); // 验证方法被调用了一次
           }
   
           [Fact]
           public void Get_WithInvalidId_ReturnsNotFound()
           {
               // Arrange
               var mockRepo = new Mock<IProductRepository>();
               mockRepo.Setup(repo => repo.GetById(It.IsAny<int>())).Returns((Product)null);
               var controller = new ProductsController(mockRepo.Object);
   
               // Act
               var result = controller.Get(999);
   
               // Assert
               Assert.IsType<NotFoundResult>(result.Result);
           }
       }
   }
   

4. 运行测试 ： 在 DependencyInjectionTests 项目目录下运行：

   dotnet test
   

   所有测试应该通过（绿色对勾）。

预期结果与判断 ：

• 单元测试全部通过，控制台输出测试结果摘要。
• 成功标准 ：掌握为业务逻辑和控制器编写独立单元测试的能力，理解如何使用 Mock 框架模拟外部依赖，确保测试的纯粹性和可重复性。

8. 资源占用与性能观察

对于 C# 高级编程学习，资源占用主要体现在开发时的 CPU、内存以及运行时应用程序的性能上。

1. 开发环境资源 ：

   • Visual Studio ：大型解决方案加载和智能感知可能占用较多内存（1-2GB+），建议确保机器有足够 RAM（16GB+ 为佳）。
   • .NET SDK 构建 ：增量构建很快，但清理后全新构建可能耗时，尤其是项目多、引用复杂时。观察任务管理器中的 MSBuild 进程。

2. 运行时性能观察 ：

   • 诊断工具 ：Visual Studio 和 VS Code 都有内置的性能探查器（Profiler），可以分析 CPU 使用率、内存分配、垃圾回收（GC）情况。
   • 日志与监控 ：在 Web API 或长时间运行的服务中，使用如 Serilog 等日志库记录关键操作的耗时，并使用 System.Diagnostics.Activity 进行分布式追踪。
   • BenchmarkDotNet ：如前所述，这是进行微观性能基准测试的金标准，能提供精确的纳秒级耗时和内存分配字节数。

3. 内存泄漏排查 ：

   • 工具 ：使用 .NET 对象分配跟踪 或 dotnet-dump / dotnet-gcdump 命令行工具分析内存快照。
   • 常见陷阱 ：事件注册未取消、静态集合无限增长、缓存无过期策略、非托管资源未释放（ IDisposable ）。
   • 验证方法 ：对怀疑有泄漏的组件进行压力测试（如循环调用），同时使用性能探查器观察托管堆大小是否持续增长且不被 GC 回收。

9. 常见问题与排查方法

10. 最佳实践与使用建议

1. 异步编程 ：

   • 准则 ： async 后缀、 Task 返回、避免 async void （除了事件处理器）。
   • 配置上下文 ：在库代码中使用 ConfigureAwait(false) 以避免不必要的上下文封送，提高性能。
   • 错误处理 ：在 Task.WhenAll 中处理多个任务的异常。

2. API 设计 ：

   • RESTful 原则 ：使用合适的 HTTP 动词和状态码。
   • 版本控制 ：从项目开始就考虑 API 版本（如通过 URL 路径 /api/v1/products ）。
   • 输入验证 ：使用模型验证特性（ [Required] , [Range] ）或 FluentValidation 。
   • 日志与监控 ：集成结构化日志（如 Serilog）和应用性能管理（APM）工具。

3. 测试策略 ：

   • 金字塔模型 ：多写单元测试（底层），适量集成测试（中层），少写端到端测试（顶层）。
   • 测试命名 ：使用 MethodName_StateUnderTest_ExpectedBehavior 模式。
   • Mock 过度 ：只 Mock 外部依赖（数据库、HTTP 客户端），不要 Mock 系统内部简单的数据对象。

4. 性能与内存 ：

   • 测量优先 ：优化前先用 BenchmarkDotNet 测量，找到真正的瓶颈。
   • 字符串操作 ：优先使用 StringBuilder 或 string.Join 。
   • 集合选择 ：根据访问模式（频繁插入、查找、迭代）选择合适的集合（ List , Dictionary , HashSet ）。
   • 对象池 ：对于创建成本高、生命周期短的对象（如 HttpClient 虽不应池化，但应复用），考虑使用对象池（ Microsoft.Extensions.ObjectPool ）。

5. 代码质量与维护 ：

   • 依赖注入 ：促使代码松耦合、易测试。
   • 单一职责 ：类和方法应只做一件事。
   • 异常处理 ：只捕获你能处理的异常，避免空的 catch 块。使用自定义异常类型传递业务错误。
   • 代码分析器 ：启用 .editorconfig 和 Roslyn 分析器（如 StyleCop.Analyzers ）来强制执行代码风格和质量规则。

这套从环境搭建、核心主题实践到 Web API 和单元测试的完整路径，覆盖了 C# 进阶开发中的关键技能点。真正的掌握来自于将每个示例代码运行起来，观察结果，并尝试修改和扩展它们。建议你按照文章顺序逐个实践，遇到问题时回头查阅“常见问题”部分。当你能够独立完成一个包含数据访问、业务逻辑、Web API 接口和配套单元测试的小型模块时，就标志着你的 C# 水平已经迈上了一个新的台阶。