从零构建C#/.NET商用项目：跨平台开发与电商订单系统实战

在实际开发中，很多开发者对 C# 和 .NET 的印象还停留在“只能做 Windows 桌面应用”的阶段。事实上，经过多年的发展，.NET 已经成为一个跨平台、高性能、全栈的开源技术栈，从 Web API、微服务、桌面应用、移动应用到云原生和 AI 开发，都有成熟的应用。对于初学者或希望系统掌握 .NET 技术的开发者来说，最大的挑战往往不是语法本身，而是如何将零散的知识点串联成一个完整的知识体系，并最终能落地到真实的商业项目开发中。本文旨在提供一个从零开始的、可实践的 C#/.NET 学习路径，不仅涵盖核心语法和框架，更会通过一个模拟的商用项目案例，手把手带你完成从环境搭建、编码、调试到部署上线的全过程，让你真正具备独立开发的能力。

1. 理解 .NET 技术栈：从 .NET Framework 到 .NET 8

在开始编码之前，必须先理清 .NET 的“家族谱系”，否则很容易在版本、框架选择上陷入困惑，导致后续依赖冲突、项目无法运行等问题。

1.1 .NET 的演变与核心概念

最初的 .NET Framework 是微软推出的 Windows 平台专属开发框架。随着技术演进，出现了 .NET Core，这是一个跨平台、开源、模块化的新实现。如今，.NET 5/6/7/8 是 .NET Core 的延续，统一了 .NET Framework、.NET Core 和 Xamarin 等分支，成为官方推荐的、未来的唯一发展方向。我们所说的“现代 .NET 开发”通常指的就是基于 .NET 6/7/8 的开发。

几个关键术语需要区分：

• CLR (公共语言运行时)： 负责执行编译后的代码（中间语言 IL），提供内存管理（垃圾回收）、线程管理、异常处理等服务。可以理解为 .NET 程序的“操作系统”。
• BCL (基类库)： 一套庞大的、标准的类库集合，提供了文件 IO、网络通信、集合、字符串处理等基础功能。所有 .NET 应用都基于 BCL。
• SDK (软件开发工具包)： 包含了编译、运行、发布 .NET 应用所需的一切工具，如dotnet命令行工具。安装 SDK 是开发的第一步。
• 运行时 (Runtime)： 仅包含运行 .NET 应用所需的组件（如 CLR）。如果只想运行别人开发好的应用，安装运行时即可。

1.2 .NET SDK 与项目类型选择

对于初学者，建议直接从.NET 8 SDK (长期支持版本 LTS)开始。LTS 版本提供长期的技术支持，更适合学习和生产。

安装完成后，可以在命令行使用dotnet --info验证。接下来，你需要了解几种核心的项目模板，它们决定了应用的骨架：

# 查看所有可用的项目模板 dotnet new list # 创建不同类型的项目 dotnet new console -n MyFirstApp # 控制台应用，学习语法最佳起点 dotnet new webapi -n MyWebApi # Web API 项目，用于构建后端服务 dotnet new mvc -n MyWebApp # MVC Web 应用（包含前端页面） dotnet new classlib -n MyClassLibrary # 类库项目，用于封装可复用的代码 dotnet new xunit -n MyTests # 单元测试项目

对于商业项目，通常是多种项目类型的组合。例如，一个典型的微服务架构可能包含：多个webapi项目作为服务、若干个classlib项目作为共享的核心领域模型或工具库、以及对应的xunit测试项目。

2. 环境准备与第一个 C# 程序

工欲善其事，必先利其器。一个高效的开发环境能极大提升学习和开发体验。

2.1 开发环境搭建

1. 安装 .NET SDK： 访问 .NET 官方网站 下载并安装 .NET 8 SDK。安装后重启终端。
2. 选择 IDE：
   • Visual Studio 2022 (社区版免费)： Windows 平台首选，功能极其强大，尤其适合桌面、游戏开发。安装时务必勾选“.NET 桌面开发”和“ASP.NET 和 Web 开发”工作负载。
   • Visual Studio Code： 跨平台轻量级编辑器，配合 C# 扩展插件，是学习、Web 开发和跨平台开发的热门选择。它更灵活，但部分高级功能（如图形化的 WinForms/WPF 设计器）需要 VS。
   • Rider (JetBrains)： 一款强大的跨平台 .NET IDE，性能优异，功能全面，但需要付费。

对于纯新手，建议在 Windows 上用 Visual Studio，在 Mac/Linux 上用 VS Code，以降低初期环境配置的复杂度。

2.2 从“Hello World”到理解程序结构

让我们用命令行创建一个最简单的控制台应用，并理解其每一部分。

dotnet new console -n HelloWorld cd HelloWorld dotnet run

你会看到输出 “Hello, World!”。现在，用编辑器打开Program.cs文件：

// See https://aka.ms/new-console-template for more information Console.WriteLine("Hello, World!");

在 .NET 6 及以后的模板中，使用了“顶级语句”简化了代码。这对于小程序很方便，但为了理解传统结构，我们可以将其还原：

using System; // 引入命名空间 namespace HelloWorld // 定义命名空间，用于组织代码 { internal class Program // 定义类，C#程序的基本单元 { static void Main(string[] args) // 程序入口点 { Console.WriteLine("Hello, World!"); // 语句：调用系统类库输出 } } }

关键概念解释：

• using： 引入其他命名空间中的类，避免写冗长的完全限定名（如System.Console.WriteLine）。
• namespace： 逻辑上的代码容器，防止类名冲突。项目名通常作为默认命名空间。
• class： C# 是面向对象的语言，几乎所有代码都写在类内部。
• Main方法： 应用程序的入口。static表示它属于类而非实例，void表示无返回值，string[] args可以接收命令行参数。
• Console.WriteLine：Console是System命名空间下的一个静态类，WriteLine是其方法。

注意：现代模板使用顶级语句，实质是编译器帮我们生成了Main方法。在商业项目中，随着代码增多，我们通常会回归到显式的Program类和Main方法，或者使用更清晰的项目组织方式。

3. C# 核心语法精要与商用项目思维

学习语法不能停留在“知道”，而要联系“商用场景”。下面我们围绕几个核心语法点，探讨它们在真实项目中的应用。

3.1 类型系统、变量与商用数据建模

C# 是强类型语言，每个变量和表达式在编译时都有明确的类型。这虽然增加了初期的约束，但极大地增强了代码的健壮性和可维护性。

基础类型与变量声明：

// 值类型（存储在栈上，直接包含数据） int age = 30; // 整数，用于计数、ID等 decimal price = 99.99m; // 高精度小数，必须用于金融计算！float/double有精度损失风险。 bool isAvailable = true; // 布尔值，用于状态标志 DateTime orderDate = DateTime.Now; // 日期时间，记录业务发生时间 // 引用类型（存储在堆上，变量存储的是引用地址） string customerName = "张三"; // 字符串，最常用的类型之一 object obj = new object(); // 所有类型的基类，谨慎使用 // 商用场景思考：定义一个“订单项”模型 public class OrderItem { public int ProductId { get; set; } // 属性，推荐使用属性而非公共字段 public string ProductName { get; set; } public decimal UnitPrice { get; set; } // 单价用 decimal public int Quantity { get; set; } // 计算属性：订单项总价 public decimal TotalPrice => UnitPrice * Quantity; }

为什么用decimal而不是double表示金额？因为double和float是二进制浮点数，无法精确表示像 0.1 这样的十进制小数，在连续计算中会产生累积误差。decimal是十进制浮点数，专门为财务计算设计，精度有保障。

3.2 流程控制、集合与业务逻辑

程序的核心是逻辑。if/else,switch,for,foreach,while是构建逻辑的基石。而集合（List<T>,Dictionary<TKey, TValue>等）则是处理批量数据的利器。

// 模拟一个订单折扣计算逻辑 public decimal CalculateDiscount(Order order, Customer customer) { decimal discount = 0m; // 1. 条件判断：VIP客户有基础折扣 if (customer.Level == CustomerLevel.VIP) { discount = 0.05m; // 95折 } // 2. 循环与集合：订单总额超过1000，额外折扣 decimal orderTotal = 0; foreach (var item in order.Items) // 遍历订单项集合 { orderTotal += item.TotalPrice; } if (orderTotal > 1000) { discount += 0.02m; // 再减2% } // 3. Switch 表达式（C# 8.0+）：根据支付方式决定是否可叠加优惠 discount += customer.PreferredPaymentMethod switch { PaymentMethod.CreditCard => 0.01m, PaymentMethod.WeChatPay => 0.005m, _ => 0 // 默认情况，其他方式无叠加优惠 }; // 确保折扣不超过50% return discount > 0.5m ? 0.5m : discount; }

商用场景下的集合选择：

• List<T>： 最常用的动态数组。当你需要有序存储、频繁按索引访问或遍历时使用。例如，一个订单的商品列表。
• Dictionary<TKey, TValue>： 键值对集合，提供极快的按键查找速度（O(1)）。例如，用商品ID (int) 作为键，快速查找商品信息 (Product)。
• HashSet<T>： 不包含重复元素的集合，用于快速判断元素是否存在。例如，记录用户已领取的优惠券ID。

3.3 面向对象编程：类、接口与依赖注入

商用项目代码复杂度的管理，严重依赖于良好的面向对象设计。核心是：封装、继承、多态。

// 1. 抽象与接口：定义契约 public interface IEmailService { Task SendAsync(string to, string subject, string body); } // 实现1：模拟发送（用于测试） public class MockEmailService : IEmailService { /* ... */ } // 实现2：真正调用SMTP发送 public class SmtpEmailService : IEmailService { /* ... */ } // 2. 服务类，依赖接口而非具体实现 public class OrderService { private readonly IEmailService _emailService; // 通过构造函数注入 private readonly IOrderRepository _orderRepository; // 构造函数注入：这是依赖注入的核心模式 public OrderService(IEmailService emailService, IOrderRepository orderRepository) { _emailService = emailService; _orderRepository = orderRepository; } public async Task PlaceOrderAsync(Order order) { // 业务逻辑... await _orderRepository.SaveAsync(order); // 发送邮件通知，不关心具体是哪种实现 await _emailService.SendAsync(order.CustomerEmail, "订单创建成功", "..."); } }

为什么这样设计？

• 可测试性： 测试OrderService时，可以注入MockEmailService，避免真的发邮件。
• 可维护性： 如果想更换邮件提供商，只需新增一个IEmailService的实现，并在依赖注入容器中注册，无需修改OrderService的代码。
• 松耦合：OrderService不依赖于具体的邮件发送细节，只依赖于一个抽象的契约 (IEmailService)。

在现代 ASP.NET Core 项目中，依赖注入是内置且首选的模式。在Program.cs中，你会看到类似这样的注册代码：

builder.Services.AddScoped<IEmailService, SmtpEmailService>(); builder.Services.AddScoped<IOrderRepository, SqlOrderRepository>(); builder.Services.AddScoped<OrderService>();

4. 配套商用项目实操：简易电商订单系统

我们将构建一个极简的电商订单后端 API。这个项目将串联起 Web API、数据访问、依赖注入、配置管理等核心技能。

4.1 项目结构与初始化

1. 创建解决方案与项目：

   # 创建解决方案文件 dotnet new sln -n ECommerceDemo # 创建 Web API 主项目 dotnet new webapi -n ECommerceDemo.Api # 创建类库项目（领域模型和接口） dotnet new classlib -n ECommerceDemo.Core # 创建类库项目（数据访问实现） dotnet new classlib -n ECommerceDemo.Infrastructure # 将项目添加到解决方案 dotnet sln add ECommerceDemo.Api/ dotnet sln add ECommerceDemo.Core/ dotnet sln add ECommerceDemo.Infrastructure/ # 添加项目引用（Api 引用 Core 和 Infrastructure） cd ECommerceDemo.Api dotnet add reference ../ECommerceDemo.Core dotnet add reference ../ECommerceDemo.Infrastructure cd ../ECommerceDemo.Infrastructure dotnet add reference ../ECommerceDemo.Core

   最终结构如下：

   ECommerceDemo.sln ├── ECommerceDemo.Api/ # Web API 入口 │ ├── Controllers/ │ ├── Program.cs │ └── appsettings.json ├── ECommerceDemo.Core/ # 核心领域层 │ ├── Models/ # 实体类，如 Order, Product │ ├── Interfaces/ # 仓储、服务接口 │ └── Services/ # 领域服务接口 └── ECommerceDemo.Infrastructure/ # 基础设施层 ├── Data/ # DbContext, 仓储实现 ├── Services/ # 具体服务实现（如Email） └── ECommerceDemo.Infrastructure.csproj

2. 定义核心领域模型(ECommerceDemo.Core/Models/Order.cs)：

   namespace ECommerceDemo.Core.Models; public class Order { public int Id { get; set; } public string OrderNumber { get; set; } = Guid.NewGuid().ToString("N").Substring(0, 8).ToUpper(); public int CustomerId { get; set; } public string CustomerName { get; set; } public decimal TotalAmount { get; set; } public DateTime CreatedAt { get; set; } = DateTime.UtcNow; // 使用UTC时间 public OrderStatus Status { get; set; } = OrderStatus.Pending; public List<OrderItem> Items { get; set; } = new(); // C# 9.0 简化初始化 } public enum OrderStatus { Pending, Paid, Shipped, Completed, Cancelled }

4.2 实现数据访问与仓储模式

我们不直接使用数据库，而是用内存集合模拟，重点在于模式。

1. 定义仓储接口(ECommerceDemo.Core/Interfaces/IOrderRepository.cs)：

   using ECommerceDemo.Core.Models; namespace ECommerceDemo.Core.Interfaces; public interface IOrderRepository { Task<Order?> GetByIdAsync(int id); Task<IEnumerable<Order>> GetAllAsync(); Task<Order> AddAsync(Order order); Task<bool> UpdateAsync(Order order); Task<bool> DeleteAsync(int id); }

2. 实现内存仓储(ECommerceDemo.Infrastructure/Data/InMemoryOrderRepository.cs)：

   using ECommerceDemo.Core.Interfaces; using ECommerceDemo.Core.Models; namespace ECommerceDemo.Infrastructure.Data; public class InMemoryOrderRepository : IOrderRepository { private static readonly List<Order> _orders = new(); private static int _nextId = 1; public Task<Order?> GetByIdAsync(int id) { var order = _orders.FirstOrDefault(o => o.Id == id); return Task.FromResult(order); } public Task<IEnumerable<Order>> GetAllAsync() => Task.FromResult(_orders.AsEnumerable()); public Task<Order> AddAsync(Order order) { order.Id = _nextId++; _orders.Add(order); return Task.FromResult(order); } // ... 省略 Update 和 Delete 实现 }

4.3 编写 Web API 控制器

在ECommerceDemo.Api项目中，修改或创建Controllers/OrdersController.cs：

using ECommerceDemo.Core.Interfaces; using ECommerceDemo.Core.Models; using Microsoft.AspNetCore.Mvc; namespace ECommerceDemo.Api.Controllers; [ApiController] [Route("api/[controller]")] // 路由模板： /api/orders public class OrdersController : ControllerBase { private readonly IOrderRepository _orderRepository; // 依赖注入：框架会自动提供 IOrderRepository 的实现 public OrdersController(IOrderRepository orderRepository) { _orderRepository = orderRepository; } [HttpGet] public async Task<ActionResult<IEnumerable<Order>>> GetOrders() { var orders = await _orderRepository.GetAllAsync(); return Ok(orders); } [HttpGet("{id}")] public async Task<ActionResult<Order>> GetOrder(int id) { var order = await _orderRepository.GetByIdAsync(id); if (order == null) return NotFound(); return Ok(order); } [HttpPost] public async Task<ActionResult<Order>> CreateOrder([FromBody] Order order) { // 简单的模型验证 if (order == null || !order.Items.Any()) return BadRequest("订单无效或没有商品。"); var createdOrder = await _orderRepository.AddAsync(order); // 返回 201 Created 状态码，并在 Location 头中提供新资源的URI return CreatedAtAction(nameof(GetOrder), new { id = createdOrder.Id }, createdOrder); } }

4.4 配置依赖注入与运行

在ECommerceDemo.Api/Program.cs中，注册我们的服务：

using ECommerceDemo.Core.Interfaces; using ECommerceDemo.Infrastructure.Data; var builder = WebApplication.CreateBuilder(args); // 添加服务到容器 builder.Services.AddControllers(); builder.Services.AddEndpointsApiExplorer(); builder.Services.AddSwaggerGen(); // 添加Swagger用于API测试 // 注册我们自己的服务 builder.Services.AddSingleton<IOrderRepository, InMemoryOrderRepository>(); // 单例，因为内存数据需要共享 var app = builder.Build(); // 配置HTTP请求管道 if (app.Environment.IsDevelopment()) { app.UseSwagger(); app.UseSwaggerUI(); // 开发环境启用Swagger UI } app.UseHttpsRedirection(); app.UseAuthorization(); app.MapControllers(); app.Run();

现在，在ECommerceDemo.Api目录下运行：

dotnet run

访问https://localhost:5001/swagger(或http://localhost:5000/swagger)，你将看到自动生成的 API 文档。可以在这里直接测试GET /api/orders和POST /api/orders。

5. 进阶：连接真实数据库与异常处理

内存存储无法持久化。接下来，我们引入 Entity Framework Core (EF Core) 连接 SQLite 数据库。

5.1 添加 EF Core 包与配置

1. 安装 NuGet 包：

   cd ECommerceDemo.Infrastructure dotnet add package Microsoft.EntityFrameworkCore.Sqlite dotnet add package Microsoft.EntityFrameworkCore.Design cd ../ECommerceDemo.Api dotnet add package Microsoft.EntityFrameworkCore.Sqlite

2. 创建 DbContext(ECommerceDemo.Infrastructure/Data/AppDbContext.cs)：

   using ECommerceDemo.Core.Models; using Microsoft.EntityFrameworkCore; namespace ECommerceDemo.Infrastructure.Data; public class AppDbContext : DbContext { public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { } public DbSet<Order> Orders => Set<Order>(); public DbSet<OrderItem> OrderItems => Set<OrderItem>(); protected override void OnModelCreating(ModelBuilder modelBuilder) { // 配置模型关系（可选） modelBuilder.Entity<Order>() .HasMany(o => o.Items) .WithOne() .HasForeignKey(oi => oi.OrderId) .OnDelete(DeleteBehavior.Cascade); // 级联删除 } }

3. 实现基于 EF Core 的仓储(ECommerceDemo.Infrastructure/Data/EfOrderRepository.cs)：

   using ECommerceDemo.Core.Interfaces; using ECommerceDemo.Core.Models; using Microsoft.EntityFrameworkCore; namespace ECommerceDemo.Infrastructure.Data; public class EfOrderRepository : IOrderRepository { private readonly AppDbContext _context; public EfOrderRepository(AppDbContext context) => _context = context; public async Task<Order?> GetByIdAsync(int id) { // 使用 Include 加载关联的 Items return await _context.Orders.Include(o => o.Items).FirstOrDefaultAsync(o => o.Id == id); } public async Task<Order> AddAsync(Order order) { _context.Orders.Add(order); await _context.SaveChangesAsync(); return order; } // ... 其他方法实现 }

4. 在 API 项目中注册 DbContext(ECommerceDemo.Api/Program.cs)：

   // 添加 using using ECommerceDemo.Infrastructure.Data; using Microsoft.EntityFrameworkCore; // 在 builder.Services.AddControllers() 之后添加 builder.Services.AddDbContext<AppDbContext>(options => options.UseSqlite(builder.Configuration.GetConnectionString("DefaultConnection"))); // 修改仓储注册为 Scoped（与DbContext生命周期一致） builder.Services.AddScoped<IOrderRepository, EfOrderRepository>();

5. 配置连接字符串(ECommerceDemo.Api/appsettings.json)：

   { "ConnectionStrings": { "DefaultConnection": "Data Source=ecommerce.db" }, // ... 其他配置 }

6. 创建并应用数据库迁移：

   cd ECommerceDemo.Api # 安装 dotnet-ef 工具（如果未安装） dotnet tool install --global dotnet-ef # 创建迁移 dotnet ef migrations add InitialCreate # 更新数据库 dotnet ef database update

   这将在项目根目录下创建一个ecommerce.db文件。

5.2 全局异常处理与日志

商用 API 必须优雅地处理异常，并记录日志。

1. 创建自定义异常类型(ECommerceDemo.Core/Exceptions/OrderNotFoundException.cs)：

   namespace ECommerceDemo.Core.Exceptions; public class OrderNotFoundException : Exception { public OrderNotFoundException(int orderId) : base($"Order with ID {orderId} was not found.") { } }

2. 在仓储中抛出异常：

   public async Task<Order> GetByIdAsync(int id) { var order = await _context.Orders.Include(o => o.Items).FirstOrDefaultAsync(o => o.Id == id); if (order == null) throw new OrderNotFoundException(id); return order; }

3. 创建全局异常处理中间件(ECommerceDemo.Api/Middleware/ExceptionHandlingMiddleware.cs)：

   using System.Net; using System.Text.Json; using ECommerceDemo.Core.Exceptions; namespace ECommerceDemo.Api.Middleware; public class ExceptionHandlingMiddleware { private readonly RequestDelegate _next; private readonly ILogger<ExceptionHandlingMiddleware> _logger; public ExceptionHandlingMiddleware(RequestDelegate next, ILogger<ExceptionHandlingMiddleware> logger) { _next = next; _logger = logger; } public async Task InvokeAsync(HttpContext context) { try { await _next(context); } catch (Exception ex) { _logger.LogError(ex, "An unhandled exception occurred."); await HandleExceptionAsync(context, ex); } } private static Task HandleExceptionAsync(HttpContext context, Exception exception) { context.Response.ContentType = "application/json"; var (statusCode, message) = exception switch { OrderNotFoundException => (HttpStatusCode.NotFound, exception.Message), // 可以添加更多自定义异常类型 _ => (HttpStatusCode.InternalServerError, "An internal server error occurred.") }; context.Response.StatusCode = (int)statusCode; var response = new { error = message }; var json = JsonSerializer.Serialize(response); return context.Response.WriteAsync(json); } }

4. 在Program.cs中注册中间件：

   // 在 app.UseHttpsRedirection(); 之前添加 app.UseMiddleware<ExceptionHandlingMiddleware>();

   现在，当访问不存在的订单时，API 将返回结构化的 404 错误{"error": "Order with ID 999 was not found."}，而不是崩溃或返回难懂的堆栈信息。

6. 常见问题排查与最佳实践

6.1 开发与部署常见问题

6.2 商用项目最佳实践清单

1. 分层架构： 坚持清晰的职责分离（如展示层、应用层、领域层、基础设施层）。这能极大提升代码的可测试性和可维护性。
2. 依赖注入： 始终通过构造函数注入依赖。避免使用静态类或new关键字在类内部直接创建依赖，这会让单元测试变得极其困难。
3. 异步编程： 对于 I/O 密集型操作（数据库访问、网络请求、文件读写），务必使用async/await模式，避免阻塞线程，提升应用吞吐量。
4. 配置管理： 不要将数据库连接字符串、API密钥等硬编码在代码中。使用appsettings.json、环境变量或专业的配置中心（如 Azure Key Vault, Consul）。
5. 日志记录： 使用ILogger<T>接口记录日志，而不是Console.WriteLine。合理设置日志级别（Information, Warning, Error），并配置日志输出到文件或日志系统（如 Serilog + Elasticsearch）。
6. 输入验证： 在 API 入口处验证用户输入。除了使用[Required],[MaxLength]等数据注解，对于复杂逻辑，应实现自定义验证或使用 FluentValidation 库。
7. 使用decimal处理金额： 再次强调，金融计算必须使用decimal类型。
8. 异常处理策略： 区分业务异常（如“订单不存在”）和系统异常（如“数据库连接失败”）。业务异常应返回明确的 HTTP 状态码（如 404, 400），系统异常应被捕获、记录并返回通用的 500 错误，避免泄露系统细节。
9. API 版本管理： 从项目初期就考虑 API 版本化（如/api/v1/orders），为后续不兼容的变更留有余地。
10. 编写单元测试： 为核心业务逻辑和公共服务编写单元测试（使用 xUnit, NUnit）。这是保证代码质量、支持重构的最有效手段。

6.3 下一步学习路径

完成这个简易项目后，你可以沿着以下路径继续深入：

• 前端集成： 学习使用 Vue.js/React 或 Blazor 创建一个管理后台，调用你写的 Web API。
• 认证与授权： 集成 ASP.NET Core Identity 或 JWT Bearer Token，为 API 添加用户登录和权限控制。
• 使用真正的数据库： 将 SQLite 替换为 PostgreSQL 或 SQL Server，学习更复杂的查询优化和索引。
• 容器化与部署： 为项目编写 Dockerfile，使用 Docker 构建镜像，并部署到 Kubernetes 或云平台（如 Azure App Service）。
• 微服务与领域驱动设计： 将单体应用拆分为更细粒度的服务，深入学习 DDD 概念，如聚合根、值对象、领域事件等。
• 性能与监控： 学习使用缓存（Redis）、消息队列（RabbitMQ, Azure Service Bus），并集成 Application Insights 进行应用性能监控。

学习 .NET 生态是一个持续的过程，关键在于动手实践，并在实践中不断思考和重构。从这个简单的订单系统开始，逐步为其添加更多真实的业务功能和架构考量，是掌握全套 .NET 开发技术最有效的方法。