ASP.NET Core 6 Web API中EF Core服务层的依赖注入优化方案

核心问题总结 #

1. 业务服务类继承DbContext，职责混淆，db = this;的写法不符合设计规范；
2. 手动实例化其他服务（new anotherService()），违背依赖注入的核心原则；
3. 大量同类服务存在重复设计，需要统一优化减少冗余。

一、重构DbContext与业务服务的职责分离 #

1. 修正Program.cs的服务注册逻辑 #

不要将业务服务注册为DbContext，应该分别注册DbContext和业务服务，明确职责边界：

var builder = WebApplication.CreateBuilder(args);

// 注册DbContext（负责数据库连接与实体映射）
builder.Services.AddDbContext<myContext>(options => options.UseSqlServer(ConnStr));
builder.Services.AddDbContext<anotherContext>(options => options.UseSqlServer(anotherConnStr));

// 注册业务服务（默认Scoped生命周期，与DbContext保持一致）
builder.Services.AddScoped<myService>();
builder.Services.AddScoped<anotherService>();

// ...其他配置代码

2. 重构myService：移除DbContext继承，改用构造函数注入 #

业务服务只负责封装业务逻辑，通过构造函数注入所需的DbContext和其他服务，不再继承DbContext：

public class myService
{
    private readonly myContext _dbContext;
    private readonly anotherService _anotherService;

    // 通过构造函数注入所有依赖，由DI容器管理实例
    public myService(myContext dbContext, anotherService anotherService)
    {
        _dbContext = dbContext;
        _anotherService = anotherService;
    }

    public IQueryable<mytable> Getdata()
    {
        return _dbContext.mytable.AsQueryable();
    }

    // 示例：使用注入的anotherService实现跨服务业务逻辑
    public async Task<CombinedResult> GetCombinedData()
    {
        var myTableData = await _dbContext.mytable.ToListAsync();
        var anotherTableData = await _anotherService.GetAnotherTableData();
        
        return new CombinedResult
        {
            MyTableData = myTableData,
            AnotherTableData = anotherTableData
        };
    }
}

3. 保持控制器的简洁性 #

控制器仅依赖业务服务，无需直接操作DbContext，聚焦接口请求处理：

public class myController : ControllerBase
{
    private readonly myService _myService;

    public myController(myService myService)
    {
        _myService = myService;
    }

    [HttpGet]
    public IActionResult GetData()
    {
        var data = _myService.Getdata();
        return Ok(data);
    }

    [HttpGet("combined")]
    public async Task<IActionResult> GetCombinedData()
    {
        var result = await _myService.GetCombinedData();
        return Ok(result);
    }
}

二、批量同类服务的优化建议 #

如果存在大量结构相似的业务服务，可以通过泛型基类封装通用CRUD逻辑，减少重复代码：

// 泛型基类：封装通用数据库操作逻辑
public class BaseService<TContext, TEntity> 
    where TContext : DbContext
    where TEntity : class
{
    protected readonly TContext _dbContext;

    public BaseService(TContext dbContext)
    {
        _dbContext = dbContext;
    }

    public virtual IQueryable<TEntity> GetAll()
    {
        return _dbContext.Set<TEntity>().AsQueryable();
    }

    public virtual async Task<TEntity?> GetById(int id)
    {
        return await _dbContext.Set<TEntity>().FindAsync(id);
    }

    public virtual async Task Add(TEntity entity)
    {
        await _dbContext.Set<TEntity>().AddAsync(entity);
        await _dbContext.SaveChangesAsync();
    }
}

// 自定义业务服务：继承泛型基类，添加专属业务逻辑
public class myService : BaseService<myContext, mytable>
{
    private readonly anotherService _anotherService;

    public myService(myContext dbContext, anotherService anotherService) 
        : base(dbContext)
    {
        _anotherService = anotherService;
    }

    // 自定义业务方法
    public async Task<CustomResult> ProcessSpecialData()
    {
        var baseData = await GetAll().ToListAsync();
        var externalData = await _anotherService.GetExternalData();
        // 专属业务逻辑处理
        return new CustomResult();
    }
}

三、关键注意事项 #

• 单一职责原则：DbContext仅负责数据库连接和实体映射，业务服务专注于业务逻辑，职责清晰；
• 生命周期一致性：DbContext默认是Scoped生命周期，业务服务也使用Scoped，避免因生命周期不匹配导致的资源问题；
• 依赖注入规范：所有依赖均通过构造函数注入，禁止手动实例化，便于单元测试和后续维护。

内容的提问来源于stack exchange，提问作者user13058080