.NET 4.8 Web API依赖注入实现DbContext动态切换数据库连接

针对你的.NET 4.8 ASP.NET Web API项目，以下是在不大量修改数据访问层逻辑的前提下，通过依赖注入实现数据库连接切换的具体步骤：

1. 重构依赖注入容器的全局配置 #

首先取消控制器内部手动创建ServiceCollection的逻辑，改为在应用启动时统一配置依赖注入容器：

在Global.asax.cs中添加初始化代码：

using System.Web.Http;
using Microsoft.Extensions.DependencyInjection;

namespace myApp
{
    public class WebApiApplication : System.Web.HttpApplication
    {
        protected void Application_Start()
        {
            // 创建服务集合
            var services = new ServiceCollection();
            
            // 注册所有依赖项
            ConfigureServices(services);
            
            // 构建服务提供者并替换Web API默认依赖解析器
            var serviceProvider = services.BuildServiceProvider();
            GlobalConfiguration.Configuration.DependencyResolver = new DefaultDependencyResolver(serviceProvider);
            
            // 原有Web API配置逻辑
            GlobalConfiguration.Configure(WebApiConfig.Register);
        }
        
        private void ConfigureServices(IServiceCollection services)
        {
            // 注册业务层与数据访问层，使用Scoped生命周期（每个请求一个实例）
            services.AddScoped<IDept_BLL, Dept_BLL>();
            services.AddScoped<EMP_DAL>();
            
            // 注册DbContext工厂（核心：用于动态生成指定连接的DbContext）
            services.AddScoped<IBmaDbContextFactory, BmaDbContextFactory>();
        }
    }
}

注：如果没有现成的依赖解析器，可自行实现简单版本：

public class DefaultDependencyResolver : IDependencyResolver
{
    private readonly IServiceProvider _serviceProvider;

    public DefaultDependencyResolver(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public object GetService(Type serviceType)
    {
        return _serviceProvider.GetService(serviceType);
    }

    public IEnumerable<object> GetServices(Type serviceType)
    {
        return _serviceProvider.GetServices(serviceType);
    }

    public IDependencyScope BeginScope()
    {
        return this;
    }

    public void Dispose()
    {
        // 无需额外处理，ServiceProvider会管理资源生命周期
    }
}

2. 定义DbContext工厂接口与实现 #

创建工厂类用于根据条件动态生成带指定连接字符串的BMAModel实例：

namespace myApp.Models
{
    public interface IBmaDbContextFactory
    {
        // 方式1：外部传入连接字符串
        BMAModel Create(string connectionString);
        
        // 方式2：自动从请求上下文获取切换条件（如Header、用户信息）
        // BMAModel Create();
    }

    public class BmaDbContextFactory : IBmaDbContextFactory
    {
        public BMAModel Create(string connectionString)
        {
            return new BMAModel(connectionString);
        }
        
        // 若使用自动获取条件的方式，可注入HttpContextAccessor：
        // private readonly IHttpContextAccessor _httpContextAccessor;
        // public BmaDbContextFactory(IHttpContextAccessor httpContextAccessor)
        // {
        //     _httpContextAccessor = httpContextAccessor;
        // }
        // public BMAModel Create()
        // {
        //     var switchFlag = _httpContextAccessor.HttpContext.Request.Headers["DbSwitch"].FirstOrDefault();
        //     string connStr = switchFlag == "Db2" 
        //         ? ConfigurationManager.ConnectionStrings["BMAModel_Db2"].ConnectionString 
        //         : ConfigurationManager.ConnectionStrings["BMAModel"].ConnectionString;
        //     return new BMAModel(connStr);
        // }
    }
}

3. 修改数据访问层(DAL)，注入工厂而非手动实例化DbContext #

仅修改DAL的依赖注入逻辑，保留原有查询代码：

public class EMP_DAL
{
    private readonly IBmaDbContextFactory _dbContextFactory;

    // 构造函数注入工厂
    public EMP_DAL(IBmaDbContextFactory dbContextFactory)
    {
        _dbContextFactory = dbContextFactory;
    }

    // 若使用外部传入连接字符串的方式：
    public async Task<string> GetDepartmentById(int Id, string connectionString)
    {
        using(var model = _dbContextFactory.Create(connectionString))
        {
            return await model.Departments
                              .Where(d => d.Dept_Id == Id)
                              .Select(d => d.dept_name.Trim())
                              .FirstOrDefaultAsync();
        }
    }
    
    // 若使用自动获取条件的方式，方法无需修改参数：
    // public async Task<string> GetDepartmentById(int Id)
    // {
    //     using(var model = _dbContextFactory.Create())
    //     {
    //         return await model.Departments
    //                           .Where(d => d.Dept_Id == Id)
    //                           .Select(d => d.dept_name.Trim())
    //                           .FirstOrDefaultAsync();
    //     }
    // }
}

注：使用using包裹DbContext，确保请求结束后自动释放资源，避免内存泄漏。

4. 调整业务逻辑层(BLL)，传递切换条件（按需） #

修改BLL的构造函数注入逻辑，并根据业务条件获取对应连接字符串：

public class Dept_BLL : IDept_BLL
{
    private readonly EMP_DAL _dal;

    // 构造函数注入DAL，不再手动实例化
    public Dept_BLL(EMP_DAL dal)
    {
        _dal = dal;
    }

    public async Task<ResponseDTO<string>> SomeMethod(ModelDTO modelDto)
    {
        // 根据业务条件获取对应连接字符串
        string connectionString = modelDto.UseSecondaryDb 
            ? ConfigurationManager.ConnectionStrings["BMAModel_Db2"].ConnectionString 
            : ConfigurationManager.ConnectionStrings["BMAModel"].ConnectionString;
        
        var result = await _dal.GetDepartmentById(modelDto.DeptId, connectionString);
        return new ResponseDTO<string> { Data = result, Success = true };
    }
}

5. 修改控制器，通过构造函数注入业务层接口 #

删除控制器内部手动创建ServiceProvider的代码，改为构造函数注入：

public class MyController : ApiController
{
    private readonly IDept_BLL _iDept_BLL;

    // 构造函数注入业务层接口
    public MyController(IDept_BLL deptBll)
    {
        _iDept_BLL = deptBll;
    }

    [Route("api/CreateEmployee")]
    [HttpPost]
    public async Task<IHttpActionResult> CreateEmployee([FromBody] Employee_DTO empDto)
    {
        // 移除不必要的Task.Run，直接调用异步方法
        var response = await _iDept_BLL.SomeMethod(empDto);
        return Ok(response);
    }
}

核心优势 #

• 最小侵入性：仅修改依赖注入相关代码，原有业务查询逻辑完全保留。
• 灵活切换：支持两种切换模式：根据请求参数主动传递、从请求上下文自动识别。
• 生命周期安全：使用Scoped生命周期，确保每个请求对应独立的DbContext实例，避免线程安全问题。

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