Il relatore dovrebbe dipendere dalla vista o viceversa?

Finora, ho utilizzato il MVP modello di architettura un paio di volte. Ogni tanto mi chiedo se il mio Presenter debba dipendere dal mio View o viceversa, cioè View dipende dal mio Presenter .

Nota

Though the sample code provided is in C#, I don't mind about the language. My question targets more precisely the MVP pattern. Additionally, it was provided off the top of my head solely to help illustrate my concern. It may not compile.

Ecco un breve esempio di ciò che sono abituato a fare:

public interface IHasUiHandler<H> where H : IUiHandler {
    H Handler { set; }
}

public interface IView {
    void Close();
    void Hide();
    void Show();
}

public abstract class Presenter<V> where V : IView {
    protected Presenter(V view) { this.view = view; }

    public void CloseView() { view.Close(); }
    public void HideView() { view.Hide(); }
    public void ShowView() { view.Show(); }

    private readonly V view;
}

E diciamo che sto creando una funzione di gestione clienti.

public interface ICustomerManagementUiHandler : IUiHandler {
    Customer CreateNewCustomer();
    IList<Customer> ListCustomers();
    void RemoveCustomer(Customer customer);
    Customer UpdateCustomer(Customer customer);
}    

public class CustomerManagementPresenter : Presenter<ICustomerManagementView>
                                         , ICustomerManagementUiHandler {
    public CustomerManagementPresenter(ICustomerManagementView view
        , CustomerManagementService service) 
        : base(view) {
        view.Handler = this;
        customers = service;
    }

    public Customer ChangeExistingCustomer(Customer customer) { return customers.Update(customer); }
    public Customer CreateNewCustomer(Customer customer) { return customers.Add(customer); }
    public IList<Customer> ListCustomers() { return customers.List(); }
    public void RemoveCustomer(Customer customer) { customers.Remove(customer); }

    private readonly CustomerManagementService customers;
}

public interface ICustomerManagementView : IHasUiHandler<ICustomerManagementUiHandler> {        
}

public class CustomerManagementForm : Form, ICustomerManagementView {
    public CustomerManagementForm() { }

    public ICustomerManagementUiHandler Handler { 
        private get { return handler; } 
        set { if (handler == null) handler = value; } 
    }

    private void changeCustomerButton_Click(object sender, EventArgs e) {
        if (Handler == null) 
            throw new InvalidOperationException("Can't change customer. No handler specified.");
        Handler.ChangeExistingCustomer(current);
    }

    private void createCustomerButton_Click(object sender, EventArgs e) {                        
        if (Handler == null) 
            throw new InvalidOperationException("Can't add new customer. No handler specified.");
        Handler.CreateNewCustomer(); // No parameters for sample simplicity sake.
    }

    private void deleteCustomerButton_Click(object sender, EventArgs e) {
        if (Handler == null) 
            throw new InvalidOperationException("Can't add new customer. No handler specified.");
        Handler.RemoveCustomer(current); 
    }

    private readonly ICustomerManager manager;
    private ICustomerManagementUiHandler handler;
}

Mi sembra che il View dipenda dal presentatore, quindi non ci sarebbe bisogno di una proprietà Handler nella View stessa. Quindi Presenter potrebbe dipendere dal servizio di accesso ai dati o simili per gestire le entità aziendali e simili.

Questo sventerebbe il Method Injection , che è un vantaggio , A PARER MIO. Inoltre, sembra ridurre la complessità per sviare sia le interfacce IHasUiHandler che IUiHandler . Questo rende un codice facilmente verificabile perché Presenter è una classe facilmente testata.

Tuttavia, in questo modo temo che Presenter non abbia un vero controllo sulla vista che dovrebbe essere in grado di mostrare o nascondere. Quindi è qui che mi sto confondendo su quale debba dipendere da quale.