.Net Web Api常用目录结构

一、基础项目结构（适合中小型项目）

MyWebApi/
├── Controllers/           # API控制器（处理HTTP请求）
│   └── WeatherController.cs
├── Models/                # 数据模型（DTOs/Entities）
│   ├── DTOs/             # 数据传输对象
│   └── Entities/         # 数据库实体
├── Services/              # 业务逻辑层
│   └── WeatherService.cs
├── Data/                  # 数据访问层（DbContext和仓储）
│   ├── AppDbContext.cs
│   └── Migrations/       # EF Core数据库迁移
├── Helpers/               # 工具类（如自定义中间件、扩展方法）
├── Properties/            # 项目属性（如launchSettings.json）
├── appsettings.json       # 配置文件
└── Program.cs             # 入口和配置

二、分层项目架构（推荐中大型项目）

示例一

MyWebApi/
├── MyWebApi.Core/        # 核心领域模型
│   ├── Entities/         # 领域实体
│   ├── Interfaces/       # 仓储和服务接口
│   └── Enums/           # 枚举类型
│
├── MyWebApi.Infrastructure/ # 基础设施（数据库、外部服务）
│   ├── Data/             # EF Core配置
│   ├── Repositories/     # 仓储实现
│   └── Services/         # 第三方服务集成
│
├── MyWebApi.Application/   # 应用层（业务逻辑）
│   ├── Services/         # 应用服务
│   └── DTOs/            # 输入/输出模型
│
├── MyWebApi.Web/          # Web层（API端点）
│   ├── Controllers/
│   ├── Middleware/       # 自定义中间件
│   └── Program.cs        # 入口和依赖注入配置
│
├── Tests/                # 单元/集成测试
│   ├── MyWebApi.Core.Tests/
│   └── MyWebApi.Web.Tests/
└── MyWebApi.sln          # 解决方案文件

核心模块说明

1. Program.cs
   配置服务（依赖注入）和中间件（如Swagger、身份验证）。

   var builder = WebApplication.CreateBuilder(args);
   builder.Services.AddControllers();
   builder.Services.AddSwaggerGen();
   var app = builder.Build();
   app.UseHttpsRedirection();
   app.MapControllers();
   app.Run();
   

2. Controllers
   轻量级类，仅处理HTTP请求/响应。

   [ApiController]
   [Route("api/[controller]")]
   public class WeatherController : ControllerBase
   {
       private readonly IWeatherService _service;
       public WeatherController(IWeatherService service) => _service = service;
   
       [HttpGet]
       public ActionResult<IEnumerable<Weather>> Get() => Ok(_service.GetAll());
   }
   

3. Services
   实现业务逻辑，通过依赖注入解耦。

   public interface IWeatherService
   {
       IEnumerable<Weather> GetAll();
   }
   
   public class WeatherService : IWeatherService
   {
       // 业务逻辑实现
   }
   

4. Data访问层
   使用Entity Framework Core或Dapper操作数据库。

   public class AppDbContext : DbContext
   {
       public DbSet<Weather> Weathers { get; set; }
   }
   

5. DTOs（数据传输对象）
   隔离内部实体与外部API接口，避免直接暴露数据库模型。

   public class WeatherDto
   {
       public DateTime Date { get; set; }
       public int TemperatureC { get; set; }
   }
   

示例二

MyProject/
├── MyProject.WebApi/          # 表现层（HTTP接口暴露）
│   ├── Controllers/           # API控制器（处理HTTP请求/响应）‌
│   ├── DTOs/                  # 数据传输对象（输入/输出模型）‌
│   │   ├── Request/           # 请求DTO（如UserCreateRequest）‌
│   │   └── Response/          # 响应DTO（如UserResponse）‌
│   ├── Middlewares/            # 自定义中间件（异常处理、日志等）‌
│   └── Extensions/            # 扩展方法（Swagger配置、服务注册）‌
│
├── MyProject.Application/     # 应用服务层（业务逻辑核心）
│   ├── Services/              # 服务接口及实现（如IUserService）‌
│   ├── Interfaces/            # 服务契约（抽象接口定义）‌
│   └── Mappings/              # AutoMapper配置（Model↔DTO转换）‌
│
├── MyProject.Domain/          # 领域模型层（数据库实体）
│   ├── Entities/              # 数据库实体类（如User、Product）‌
│   └── Enums/                 # 枚举类型（如UserRole）‌
│
├── MyProject.Infrastructure/  # 基础设施层（数据访问）
│   ├── Repositories/          # 仓储接口及实现（如IUserRepository）‌
│   ├── Data/                  # DbContext及迁移配置‌
│   └── Seeders/               # 数据库初始化数据‌
│
└── MyProject.Tests/           # 单元测试项目‌

核心模块说明

1. WebApi层
   接收HTTP请求、路由分发、响应格式化‌

   // Program.cs中注册服务及中间件
   builder.Services.AddControllers();
   builder.Services.AddSwaggerGen();  // API文档生成‌:ml-citation{ref="4,5" data="citationList"}
   app.UseMiddleware<ExceptionMiddleware>();  // 全局异常处理‌
   

2. Application层
   实现业务逻辑、协调领域模型与基础设施层‌

   // IUserService.cs
   public interface IUserService {
       UserResponse GetUserById(int id);
   }
   // UserService.cs（依赖注入仓储）
   public class UserService : IUserService {
       private readonly IUserRepository _repo;
       public UserService(IUserRepository repo) => _repo = repo;
   }
   

3. Domain层
   实体定义

   public class User {
       public int Id { get; set; }
       public string Name { get; set; }
       public UserRole Role { get; set; }
   }
   
   

4. Infrastructure层
   仓储模式实现

   // IUserRepository.cs
   public interface IUserRepository {
       User GetById(int id);
   }
   
   // UserRepository.cs
   public class UserRepository : IUserRepository {
       private readonly AppDbContext _context;
       public UserRepository(AppDbContext context) => _context = context;
   }
   

跨层依赖关系

1. WebApi → Application‌：调用服务接口获取业务结果‌
2. Application → Domain‌：操作领域模型实体‌
3. ‌Application → Infrastructure‌：通过仓储访问数据库‌
4. ‌Infrastructure → Domain‌：实体映射到数据库表‌

三、实践开发策略

3.1 DTO与实体分离

1. 请求/响应使用DTO，避免直接暴露数据库结构‌
2. 通过AutoMapper实现User→UserResponse自动映射‌

3.2 依赖注入配置

// Program.cs中注册
builder.Services.AddScoped<IUserService, UserService>();
builder.Services.AddScoped<IUserRepository, UserRepository>();

3.3 统一响应格式

// WebApi层定义标准响应体
public class ApiResponse<T> {
    public int Code { get; set; }
    public T Data { get; set; }
    public string Message { get; set; }
}

3.4 工具推荐

1. Swagger/OpenAPI：自动生成API文档。
2. AutoMapper：简化DTO与实体映射。
3. FluentValidation：请求模型验证。
4. Serilog：结构化日志记录。

‌