1

我对DbContext在我的 WinForms 应用程序中使用依赖注入来管理我的生命周期的正确方法感到困惑。现在，我的代码如下所示

static class Program
{
   // This is the main window's controller, which stores all the
   // dependencies that are resolved in the composition root and handles 
   // passing those dependencies to other objects
   private static IMainController mainController;

   private static void ComposeDependencies
   {
      UnityContainer container = new UnityContainer();
      container.RegisterType<IMyContext, MyContext>();
      container.RegisterType<IOrderRepository, OrderRepository>();
      container.RegisterType<IOrderService, OrderService>();

      mainController = new MainController(
         container.Resolve<IOrderService>());
   }
}

public class OrderRepository : IOrderRepository
{
   private readonly IMyContext context;

   public OrderRepository(IMyContext context)
   {
      this.context = context;
   }
}

public class OrderService : IOrderService
{
   private readonly IOrderRepository repository;

   public OrderService(IOrderRepository repository)
   { 
      this.repository = repository;
   }
}

public class MainController
{
   private readonly IOrderService orderService;   

   public MainController(IOrderService orderService)
   {
      this.orderService = orderService;
   }

   public void DoSomethingWithAnOrder()
   {
      FirstTypeOfController controller = new FirstTypeOfController(this.orderService);

      // Show window, assign controller, etc.
   }

   public void DoSomethingElseWithAnOrder()
   {
      SecondTypeOfController controller = new SecondTypeOfController(this.orderService);

      // Show window, assign controller, etc.
   }
}

我遇到的问题是，这种模式导致我的所有存储库在我的程序启动时都被创建，因此MyContext实例在整个程序中都存在。因此，当数据库在我的程序之外更新时，我的程序看不到新数据，因为MyContext它正在使用对它已经加载的数据的引用。

如果这是一个 Web 应用程序，那么我会为每个请求创建新的依赖项，但由于这是 WinForms，我不明白如何解决这个问题，同时保持一个单一的组合根并且不传递我的 Unity 容器我的程序（或对其有静态引用），以便每个控制器都可以解决自己的每个实例依赖项。

这个问题的标准解决方案是什么，我在如何/在哪里编写我的依赖项或使用我的DbContext?

我知道 MVC 更适用于 Web 应用程序，而 MVVM 或 MVP 之类的东西可能更适合非 Web 应用程序，但是它们都存在相同的问题，即单个组合根只被调用一次。

4

2 回答 2

0

这取决于您如何配置依赖注入，如果它是单例，还是每个范围一个实例。我知道在 Ninject 的 DI 框架上，您可以使用以下命令指定：

//Thread Scope (New instance on each injection)
kernel.Bind<IInterface>.To<ConcreteClass>().InThreadScope();


//Singleton Scope (One instance per application)
kernel.Bind<IInterface>.To<ConcreteClass>().InSingletonScope()
于 2016-08-03T14:27:08.513 回答
0

我看不出你的实现有什么问题，它看起来是正确的。没错，当程序启动时，您正在初始化存储库，这很好，并且您在整个应用程序生命周期内都保留了上下文。使用存储库，您调用一个对数据库执行某些操作的方法；在获取数据的情况下，无论如何，如果正确实施，您总是会获得最新的数据，除非您在应用程序加载时检索它并将其存储在某个地方以供将来访问（例如全局变量，例如设置）。

于 2016-08-03T14:32:11.670 回答