C # WinForms Model-View-Presenter (Passive View)

voici un exemple simple qui démontre le concept de vues passives en utilisant le modèle de conception MVP. Parce que nous utilisons des vues passives la vue n'a aucune connaissance du présentateur. Le présentateur s'abonnera simplement aux événements publiés par The view et agira en conséquence.

pour commencer nous avons besoin de définir un contrat pour notre vue. Cela est généralement réalisé à l'aide d'une interface, essentiellement, nous voulons avoir un couplage très lâche à notre avis. Nous voulons la capacité de changer pour différentes vues ou événement créer des vues simulées pour le test de l'unité.

voici un contrat qui décrit une vue simple qui sera utilisée pour afficher des informations client

public interface ICustomerManagementView
{
    void InitializeCustomers(ICustomer[] customers);
    void DisplayCustomer(ICustomer customer);
    event EventHandler<EventArgs<ICustomer>> SelectedCustomerChanged;
}

Il expose une méthode unique InitializeCustomers qui sera utilisé pour initialiser notre vue avec des objets de notre modèle.

Nous avons aussi un événement SelectedCustomerChanged qui sera utilisé par notre présentateur pour recevoir notification qu'une action a eu lieu dans la vue.

une Fois que nous avons notre contrat, nous pouvons commencer à gérer ces interactions dans notre présentateur.

public class CustomerManagementPresenter
{
    private ICustomer _selectedCustomer;
    private readonly ICustomerManagementView _managementView;
    private readonly ICustomerRepository _customerRepository;

    public CustomerManagementPresenter(ICustomerManagementView managementView, ICustomerRepository customerRepository)
    {
        _managementView = managementView;
        _managementView.SelectedCustomerChanged += this.SelectedCustomerChanged;

        _customerRepository = customerRepository;

        _managementView.InitializeCustomers(_customerRepository.FetchCustomers());
    }

    private void SelectedCustomerChanged(object sender, EventArgs<ICustomer> args)
    {
        // Perform some logic here to update the view
        if(_selectedCustomer != args.Value)
        {
            _selectedCustomer = args.Value;
            _managementView.DisplayCustomer(_selectedCustomer);
        }
    }
}

Dans le présentateur nous pouvons utiliser un autre modèle appelé injection de dépendance pour fournir l'accès à notre vue et à toutes les classes de modèles dont nous avons besoin. Dans cet exemple, j'ai un CustomerRepository qui est responsable de récupérer les détails du client.

dans le constructeur nous avons deux lignes importantes de code, d'abord nous avons souscrit à L'événement SelectedCustomerChanged à notre avis, c'est ici que nous pouvons effectuer des actions associées. Deuxièmement, nous avons appelé InitilaizeCustomers avec les données du dépôt.

a ce point nous n'avons pas encore défini une implémentation concrète pour notre vue, tout ce que nous avons à faire est de créer un objet qui implémente ICustomerManagementView. Par exemple, dans une application Windows Forms, nous pouvons faire ce qui suit

public partial class CustomerManagementView : Form, ICustomerManagementView
{
    public CustomerManagementView()
    {
        this.InitializeComponents();
    }

    public void InitializeCustomers(ICustomer[] customers)
    {
        // Populate the tree view with customer details
    }

    public void DisplayCustomer(ICustomer customer)
    {
        // Display the customer...
    }

    // Event handler that responds to node selection
    private void CustomerTreeViewAfterSelect(object sender, TreeViewEventArgs e)
    {
        var customer = e.Node.Tag as ICustomer;
        if(customer != null)
        {
            this.OnSelectedCustomerChanged(new EventArgs<ICustomer>(customer));
        }
    }

    // Protected method so that we can raise our event
    protected virtual void OnSelectedCustomerChanged(EventArgs<ICustomer> args)
    {
        var eventHandler = this.SelectedCustomerChanged;
        if(eventHandler != null)
        {
            eventHandler.Invoke(this, args);
        }
    }

    // Our view will raise an event each time the selected customer changes
    public event EventHandler<EventArgs<ICustomer>> SelectedCustomerChanged;
}

Si nous voulions pour tester notre logique de présentation, nous pourrions nous moquer de notre point de vue et effectuer quelques assertions.

EDIT : Inclus événement personnalisé args

public class EventArgs<T> : EventArgs
{
    private readonly T _value;

    public EventArgs(T value)
    {
        _value = value;
    }

    public T Value
    {
        get { return _value; }
    }
}