这个权限是将容器/内核注入主应用程序主持人吗？ [英] Is this right to inject the container/kernel to the main application presenter?

问题描述

我正在使用Ninject来处理我的依赖关系。

我的 ApplicationPresenter 负责在整个应用程序中调度用户调用功能，因此需要注入多个工厂一次，因此容器本身。它处理MDI GUI。

1. 有更好的方法吗？


2. 可以做这样吗？

ApplicationPresenter

  public class ApplicationPresenter 
：Presenter< IApplicationView> 
，IApplicationPresenter {
 public ApplicationPresenter（IApplicationView view，IKernel dependencies）
：base（view）{
 Dependencies = dependencies; 
 View.Connect + = OnConnect; 
 View.ManageInquiries + = OnManageInquiries; 
} 
 
私有静态只读IKernel依赖关系; 
} 
  

ApplicationPresenter 负责在MDI窗口中编排系统的功能，例如：

1. 用户验证


2. 管理查询...

我有一个 AuthenticationPresenter 和一个 InquiryManagementPresenter ，它们都将从 ApplicationPresenter 中调用，如下所示：

用户点击...

  public class ApplicationPresenter：... {
 // See ctor for event subscription ... 
 
 private void OnConnect（）{
 AuthenticationPresenter authentication = 
 Dependencies.Get< IAuthenticationPresenter>（）; 
 authentication.ShowView（）; 
} 
 
 private void OnManageInquiries（）{
 InquiriesManagementPresenter inquiriesManagement = 
 Dependencies.Get< IInquiriesManagementPresenter>（）; 
 inquiriesManagement.ShowView（）; 
} 
} 
  

在 InquiriesManagementPresenter ，我对其他主持人的依赖关系如下：

• NewInquiryPresenter


• EditInquiryPresenter


• CancelInquiryPresenter


• ApproveInquiryPresenter ...

Ninject模块

  public class ApplicationModule：NinjectModule {
 public void Load（） b $ b绑定< IApplicationPresenter>（）。到< ApplicationPresenter>（）。InSingletonScope（）; 
绑定< IApplicationView>（）。到< ApplicationForm>（）; 
} 
} 
 
 public class AuthenticationModule：NinjectModule {
 public void Load（）{
绑定< IMembershipService>（）到< MembershipService> ）; 
绑定< IAuthenticationPresenter>（）。到< AuthenticationPresenter>（）。InSingletonScope（）; 
绑定< IAuthenticationView>（）。到< AuthenticationForm>（）; 
绑定< ICredentials>（）。到< Credentials>（）。InSingletonScope（）; 
绑定< IUser>（）。到< User>（）。InSingletonScope（）; 
绑定< IDatabaseInstance>（）。到< DatabaseInstance>（）。InSingletonScope（）; 
绑定< IDatabaseUser>（）。到< DatabaseUser>（）。InSingletonScope（）; 
} 
} 
 
 public class InquiryManagementModule：NinjectModule {
 public void Load（）{
绑定< INewInquiryPresenter>（）到< NewInquiryPresenter& ）.InSingletonScope（）; 
绑定< INewInquiryView>（）。到< NewInquiryForm>（）; 
绑定< IEditInquiryPresenter>（）。到< EditInquiryPresenter>（）。InSingletonScope（）; 
绑定< IEditInquiryView>（）。到< EditInquiryForm>（）; 
绑定< IInquiryRepository>（）。到< InquiryRepository>（）; 
 // ... 
} 
} 
  

所以，我发现将Ninject的 IKernel 从演示者传递给另一个需要多种功能的用户，比如$ code InquiryMinderPresenter 或者 ApplicationPresenter 。

那么还是这样还是还有更好的方法呢？

解决方案

你不应该传递DI容器，因为你使用它作为一个服务定位器，这是一种反模式。

如果您的 ApplicationPresenter 需要 AuthenticationPresenter 和查询管理提供者，然后注入这些依赖关系：

  public class ApplicationPresenter：Presenter< IApplicationView> IApplicationPresenter 
 {
 private readonly static AuthenticationPresenter authenticationPresenter; 
 private readonly static查询管理提供者查询管理提供者; 
 
 public ApplicationPresenter（
 IApplicationView视图，
 AuthenticationPresenter authenticationPresenter，
查询管理员查询管理员）
：基础（视图）
 {
 this.authenticationPresenter = authenticationPresenter; 
 this.inquiriesManagementPresenter = inquiriesManagementPresenter; 
 View.Connect + = OnConnect; 
 View.ManageInquiries + = OnManageInquiries; 
} 
} 
  

如果这些演示者有自己的依赖，那就完全是罚款：您只需建立整个图表，但是 AplicationPresenter 不必看任何子图。

I'm using Ninject to handle my dependencies.

My ApplicationPresenter is responsible to dispatch the user calls to features throughout the application, hence the need to inject multiple factories at once, thus the container itself. It handles an MDI GUI.

1. Is there a better approach?
2. Is it okay to make it so?

ApplicationPresenter

public class ApplicationPresenter 
    : Presenter<IApplicationView>
    , IApplicationPresenter {
    public ApplicationPresenter(IApplicationView view, IKernel dependencies) 
        : base(view) {
        Dependencies = dependencies;
        View.Connect += OnConnect;
        View.ManageInquiries += OnManageInquiries;
    }

    private static readonly IKernel Dependencies;
}

The ApplicationPresenter is responsible for orchestrating the system's feature in the MDI window such as:

1. User authentication
2. Managing inquiries...

I have an AuthenticationPresenter and an InquiryManagementPresenter which shall both be called from the ApplicationPresenter like so:

User clicks on...

public class ApplicationPresenter : ... { 
    // See ctor for event subscription...

    private void OnConnect() {
        AuthenticationPresenter authentication = 
            Dependencies.Get<IAuthenticationPresenter>();
        authentication.ShowView();
    }

    private void OnManageInquiries() {
        InquiriesManagementPresenter inquiriesManagement = 
            Dependencies.Get<IInquiriesManagementPresenter>();
        inquiriesManagement.ShowView();
    }
}

And within the InquiriesManagementPresenter, I have dependencies on other presenters as:

• NewInquiryPresenter
• EditInquiryPresenter
• CancelInquiryPresenter
• ApproveInquiryPresenter...

Ninject modules

public class ApplicationModule : NinjectModule {
    public void Load() {
        Bind<IApplicationPresenter>().To<ApplicationPresenter>().InSingletonScope();
        Bind<IApplicationView>().To<ApplicationForm>();
    }
}

public class AuthenticationModule : NinjectModule {
    public void Load() {
        Bind<IMembershipService>().To<MembershipService>();
        Bind<IAuthenticationPresenter>().To<AuthenticationPresenter>().InSingletonScope();
        Bind<IAuthenticationView>().To<AuthenticationForm>();
        Bind<ICredentials>().To<Credentials>().InSingletonScope();
        Bind<IUser>().To<User>().InSingletonScope();
        Bind<IDatabaseInstance>().To<DatabaseInstance>().InSingletonScope();
        Bind<IDatabaseUser>().To<DatabaseUser>().InSingletonScope();
    }
}

public class InquiryManagementModule : NinjectModule {
    public void Load() {
        Bind<INewInquiryPresenter>().To<NewInquiryPresenter>().InSingletonScope();
        Bind<INewInquiryView>().To<NewInquiryForm>();
        Bind<IEditInquiryPresenter>().To<EditInquiryPresenter>().InSingletonScope();
        Bind<IEditInquiryView>().To<EditInquiryForm>();
        Bind<IInquiryRepository>().To<InquiryRepository>();
        // ...
    }
}

So, I find it simpler to pass the Ninject's IKernel from from a presenter to another for those that require multiple functionality like the InquiryManagementPresenter or the ApplicationPresenter.

So still, is it this okay or is there another much better way to achieve this?

解决方案

You should never pass the DI Container around, because then you're using it as a Service Locator, which is an anti-pattern.

If your ApplicationPresenter requires an AuthenticationPresenter and an InquiriesManagementPresenter, then inject those dependencies:

public class ApplicationPresenter : Presenter<IApplicationView>, IApplicationPresenter
{
    private readonly static AuthenticationPresenter authenticationPresenter;
    private readonly static InquiriesManagementPresenter inquiriesManagementPresenter;

    public ApplicationPresenter(
        IApplicationView view,
        AuthenticationPresenter authenticationPresenter,
        InquiriesManagementPresenter inquiriesManagementPresenter) 
        : base(view)
    {
        this.authenticationPresenter = authenticationPresenter;
        this.inquiriesManagementPresenter = inquiriesManagementPresenter;
        View.Connect += OnConnect;
        View.ManageInquiries += OnManageInquiries;
    }
}

If those presenters have dependencies of their own, it's totally fine: you just build up the entire graph up front, but the AplicationPresenter doesn't have to see any of the sub-graphs.

这篇关于这个权限是将容器/内核注入主应用程序主持人吗？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！