.net 使用DbContext的接口多态性，正确的方法是什么？

与DbContext的接口多态性，正确的方法是什么？

有没有更优雅的方法来实现它？

有没有办法直接在存储库中获取dbcontext的实例

而不是在控制器和

将其一直传递到存储库中的方法

这就是我现在正在做的

第1步-控制器

    [Route("api/[controller]")]
    public class ModulesApiController : Controller
    {
        private readonly ApplicationDbContext _dbContext;

        private readonly ILogger _logger;


        public ModulesApiController(ILoggerFactory loggerFactory, **ApplicationDbContext dbContext**)
        {
            _logger = loggerFactory.CreateLogger<ModulesApiController>();
            _dbContext = dbContext;
        }


        [HttpGet]
        [Route("GetModule/{module}")]
        public async Task<JsonResult> GetModule(string module)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    var ListModules = new List<ImoduleBL>();
                    ImoduleBL obj = new HomeModuleBL();
                    if (module == "home-index")
                    {
                        //obj = new HomeModuleBL();
                        //ListModules.Add(obj as ImoduleBL);
                        //List<Layout> ListObj = await GetModuleService.GetModule(ListModules);
                        //return Json(ListObj);
                    }
                    else if (module == "shop-index")
                    {
                        obj = new ShopModuleBL();
                        ImoduleBL Iobj = obj as ImoduleBL;
                        return  await GetModuleService.GetCateroy(Iobj, _dbContext);

                    }
                    else if (module == "top-bunner")
                    {

                    }
                }
                catch (Exception ex)
                {
                    _logger.LogError("Failed of : GetLayOutFor - Index Module", ex);
                    return null;
                }
            }
            return null;
        }
}

[路由（“api/[控制器]”）]
公共类模块微处理器：控制器
{
私有只读应用程序dbContext_dbContext；
专用只读ILogger\u记录器；
公共模块安全控制器（ILoggerFactory loggerFactory，**ApplicationDbContext dbContext**）
{
_logger=loggerFactory.CreateLogger（）；
_dbContext=dbContext；
}
[HttpGet]
[路由（“GetModule/{module}”）]
公共异步任务GetModule（字符串模块）
{
if（ModelState.IsValid）
{
尝试
{
var ListModules=new List（）；
ImoduleBL obj=新的HomeModuleBL（）；
if（模块==“主索引”）
{
//obj=新的HomeModuleBL（）；
//ListModules.Add（对象为ImoduleBL）；
//List ListObj=等待GetModuleService.GetModule（ListModules）；
//返回Json（ListObj）；
}
else if（模块==“店铺索引”）
{
obj=新的ShopModuleBL（）；
ImoduleBL Iobj=作为ImoduleBL的obj；
return wait wait GetModuleService.GetCateroy（Iobj，_dbContext）；
}
否则，如果（模块==“顶部邦纳”）
{
}
}
捕获（例外情况除外）
{
_logger.LogError（“GetLayOutFor-索引模块失败”，ex）；
返回null；
}
}
返回null；
}
}

步骤2-获取模块服务-服务

公共类GetModuleService { //_dbContext-将其一直传递到存储库中的方法

public static async Task<JsonResult> GetCateroy(ImoduleBL ListModules, ApplicationDbContext _dbContext)
{
        return await ListModules.GetCateroy(_dbContext);
}

公共静态异步任务GetCateroy（ImoduleBL ListModules，ApplicationDbContext\u dbContext）
{
返回wait-ListModules.GetCateroy（_-dbContext）；
}

}

步骤3-购物模块BL-BL

    public class ShopModuleBL : ImoduleBL
    {

        public async Task<JsonResult> GetCateroy(ApplicationDbContext _dbContext)
        {
            ImoduleBL ListModules;
            ShopModuleRepo obj = new ShopModuleRepo();
            ListModules = obj as ImoduleBL;
            return await GetModuleService.GetCateroy(ListModules, _dbContext);
        }

}

公共类ShopModuleBL:ImoduleBL
{
公共异步任务GetCateroy（ApplicationDbContext\u dbContext）
{
ImoduleBL列表模块；
ShopModuleRepo obj=新ShopModuleRepo（）；
ListModules=obj作为ImoduleBL；
返回wait-wait-GetModuleService.GetCateroy（ListModules，_-dbContext）；
}
}

**步骤4-ShopModuleRepo-存储库**

public class ShopModuleRepo : ImoduleBL
{

    public async Task<JsonResult> GetCateroy(ApplicationDbContext _dbContext)
    {
        return new JsonResult(await _dbContext.Category1s.ToListAsync());
    }

public类ShopModuleRepo:ImoduleBL
{
公共异步任务GetCateroy（ApplicationDbContext\u dbContext）
{
返回新的JsonResult（wait _dbContext.Category1s.toListSync（））；
}

}

**步骤5-客户端-cs** 结果传递到angular应用程序

---

谢谢

您应该使用构造函数注入，而不是方法注入。正如您所看到的，您正在通过每个方法传递db上下文实例，一直传递到存储库。如果使用构造函数注入，则不必这样做

不幸的是，你正在到处更新实例。如果您想使用构造函数注入，那么将设计更改为使用控制反转可能是有益的。很多关于这方面的文章，看看吧

您的存储库将如下所示

public class ShopModuleRepo : ImoduleBL
{
    public ShopModuleRepo(ApplicationDbContext dbContext) {
         if (dbContext == null)
             throw new ArgumentNullException(nameof(dbContext));

        _dbContext = dbContext;
    }

    private readonly ApplicationDbContext _dbContext;

    public async Task<JsonResult> GetCateroy()
    {
        return new JsonResult(await _dbContext.Category1s.ToListAsync());
    }
}

public类ShopModuleRepo:ImoduleBL
{
public ShopModuleRepo（应用程序上下文dbContext）{
if（dbContext==null）
抛出新ArgumentNullException（nameof（dbContext））；
_dbContext=dbContext；
}
私有只读应用程序dbContext_dbContext；
公共异步任务GetCateroy（）
{
返回新的JsonResult（wait _dbContext.Category1s.toListSync（））；
}
}

注意方法

GetCateroy

中没有参数

---

现在，您可以从控制器中删除db context字段，并删除所有其他类中的所有db context参数。

感谢IoC的意图当然非常有效，但根据建议的解决方案，我将继续处理相同的问题。我打电话给ShopModuleRepo-frome ShopModuleBL如下：ShopModuleRepo obj=new ShopModuleRepo（），请注意，constractor中没有参数，这就是为什么我仍然使用相同的问题