winforms - instalar google tag manager

¿Es correcto inyectar el contenedor/kernel al presentador principal de la aplicación?

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Es mejor crear un singleton para acceder al contenedor de la unidad o pasarlo a través de la aplicación? 4 respuestas

Estoy usando Ninject para manejar mis dependencias.

Mi ApplicationPresenter es responsable de enviar las llamadas de los usuarios a las funciones en toda la aplicación, por lo tanto, la necesidad de inyectar varias fábricas a la vez, por lo tanto, el contenedor en sí. Maneja una GUI de MDI.

1. ¿Hay un mejor enfoque?
2. ¿Está bien hacerlo así?

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;
}

El ApplicationPresenter es responsable de orquestar la función del sistema en la ventana de MDI, como por ejemplo:

1. Autenticacion de usuario
2. Gestión de consultas ...

Tengo un AuthenticationPresenter y un InquiryManagementPresenter que serán llamados desde ApplicationPresenter manera:

El usuario hace clic en ...

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();
    }
}

Y dentro de InquiriesManagementPresenter , tengo dependencias con otros presentadores como:

• NewInquiryPresenter
• EditInquiryPresenter
• CancelarInquiryPresenter
• ApproveInquiryPresenter ...

Módulos Ninject

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>();
        // ...
    }
}

Por lo tanto, me resulta más sencillo pasar el IKernel de IKernel de un presentador a otro para aquellos que requieren funcionalidad múltiple como InquiryManagementPresenter o ApplicationPresenter .

Entonces, ¿está bien o hay otra forma mucho mejor de lograr esto?

Answer 1

Nunca debe pasar el Contenedor DI alrededor, porque entonces lo está usando como un Localizador de Servicio, que es un antipatrón .

Si su ApplicationPresenter requiere un AuthenticationPresenter y un InquiriesManagementPresenter , entonces inyecte esas dependencias:

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;
    }
}

Si esos presentadores tienen sus propias dependencias, está totalmente bien: simplemente compila todo el gráfico por adelantado , pero el AplicationPresenter no tiene que ver ninguno de los subgráficos.