MVP winforms中的数据绑定

Question

I have a WinForms application implemented in MVP. My form has a TextBox and I want to databind its Text property to a property in the Model. I don't want to refer to the Model in the View.

After searching in Google, I found that databinding by coupling Model and View is a bad idea. My sample initialization of Model , View and Presenter is as follows.

class View : Form, IView
{
    public View()
    {
        InitializeComponent();
        new Presenter(this);
    }
}

class Presenter
{
    public Presenter(IView) : this.Presenter(this, new Model())
    {
    }

    public Presenter(IView view)
    {
    }
}

class Model : IModel
{
    public Model()
    {
    }

}

At present I have 3 projects each for Model , View and Presenter . View has reference to Presenter and Presenter has reference to Model . Can anyone guide me how to form a databinding to a control in View to a property in Model ?

EDIT

I know to do the things in Grid. We can assign Datasource property of grid to a List (or something similar) in presenter like:

_view.DataSource = _model.ListOfEmployees;

This will reflect the value in UI when ListOfEmployees changes in the Model. But what about a TextBox which exposes a Text property? How can I bind that in MVP architecture?

Answer 1

My recommendation is to encapsulate the View and Model in the Presenter. This means a specialized Presenter (in most cases) for a given View. In my opinion, this works out well since most Models will be different anyway.

class Presenter {
    readonly IView view;
    readonly IModel model;

    public Presenter() {
        // if view needs ref. to presenter, pass into view ctor
        view = new View(this);
        model = new Model();
    }

    // alternatively - with the model injected - my preference
    public Presenter(IModel Model) {
        // if view needs ref. to presenter, pass into view ctor
        view = new View(this);
        model = Model;
    }
}

In your IView, expose a control or control's data source property:

interface IView {
    object GridDataSource { get; set; }
}

Add to your Presenter some method:

void SetGridDatasource() {
    view.GridDatasource = model.SomeBindableData;
}

View implementation:

public object GridDatasource {
    get { return myGridView.DataSource; }
    set { myGridView.DataSource = value; }
}

Note:
Code snippets are untested and recommended as a starting point.

Update to comments:
INotifyPropertyChanged is a very valuable mechanism for updating properties between IView and IModel .

Most controls do have some sort of binding capability. I would recommend using those DataBinding methods whenever possible. Simply expose those properties through IView and let the Presenter set those bindings to the IModel properties.

Answer 2

Explanation:

If you want to databind a textbox to and underlying property of the model:

First: Like many others have states, whatever contains your properties must implement the INotifyPropertyChanged interface so that when the object property is changed, the necessary event is fired to notify the view of the change. I would use a viewmodel as a property of your model in this regard to encapsulate the specific properties you would like to databind your view to.

Second: Your IView will include the viewmodel property which your View must implement.

Third: Your View will implement the IView property with only a set accessor on the viewmodel object to databind each textbox to the dto properties. Notice in the example below, how i never again manually set the textbox after view load. The textbox.text values will now be updated when the underlying model's viewmodel property changes. This works both ways (2 way databinding). Editing the textbox with user input will change the underlying model's dto property value.

Fourth: Your presenter will set the IView's property to the Model's property only once, on view load.

Example: keep in mind, this is a very very simplified rough example and does not have any Model abstraction like the OP is using, but should give a good starting point for textbox databinding in Winforms MVP. Another thing i would change in a production app, would be to make the Model stateless and move the viewmodel (person) into the presenter.

//VIEWMODEL
public class Person : INotifyPropertyChanged
{
    string _firstName;
    string _lastName;
    public string FirstName
    {
        get { return _firstName; }
        set
        {
            if(value != _firstName)
            {
                _firstName = value;
                NotifyPropertyChanged("FirstName");
            }
        }
    }
    public string LastName
    {
        get { return _lastName; }
        set
        {
            if (value != _lastName)
            {
                _lastName = value;
                NotifyPropertyChanged("LastName");
            }
        }
    }
    public event PropertyChangedEventHandler PropertyChanged;

    private void NotifyPropertyChanged(String info)
    {
        if (PropertyChanged != null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(info));
        }
    }

}

//MODEL
class Model
{
    Person _person;
    public Person Person { get { return _person; } }

    public Model()
    { 
        //Set default value
        _person = new Person(){ FirstName = "Test", LastName = "Subject" };
    }

    public void ChangePerson()
    {
        //When presenter calls this method, it will change the underlying source field and will reflect the changes in the View.
        _person.FirstName = "Homer";
        _person.LastName = "Simpson";
    }
}

//PRESENTER
class Presenter
{
    readonly View _view;
    readonly Model _model;
    public Presenter(View view)
    {
        _view = view;
        _model = new Model();

        _view.OnViewLoad += Load;
        _view.OnChangePerson += ChangePerson;
    }

    private void Load()
    {
        _view.Person = _model.Person;
    }

    private void ChangePerson()
    {
        _model.ChangePerson();
    }
}

//IVIEW
interface IView
{
   Person person { set; }

   event Action OnViewLoad;
   event Action OnChangePerson;
}

//VIEW
public partial class View : IView
{
     public View()
     {
         Presenter presenter = new Presenter(this); 
         this.Load += (s, e) => OnViewLoad(); //Shorthand event delegate
         this.btnChange.Click += (s, e) => OnChangePerson(); //Shorthand event delegate
     }

     public event Action OnViewLoad;
     public event Action OnChangePerson;

     public Person person
     {   //This is how you set textbox two-way databinding
         set
         {
               //Databinding syntax: property of control, source, source property, enable formatting, when to update datasource, null value
               txtFirstName.DataBindings.Add(new Binding("Text", value, "FirstName", true, DataSourceUpdateMode.OnPropertyChanged, string.Empty));
               txtLastName.DataBindings.Add(new Binding("Text", value, "LastName", true, DataSourceUpdateMode.OnPropertyChanged, string.Empty)); 
         }
     }

}

Answer 3

I dabbled a bit with MVP in WinForms and there are many issues to address. Most of the problems come from the fact that you're in VS and it's nice to be able to design the forms easily using the form Designers.

I tried out a WinForms MVP API someone developed from a widely used WebForms MVP project, but because the code behind file for the form used Generics (eg. public class TheForm : UserControl) you lose the ability to design the form because the designer know how to handle Generics.

I ended up going with the core interfaces, IPresenter, IView, IViewModel. I ALWAYS created an intermediate interface for the specific implementation even if I don't add any extra properties, mainly because it's just easier to accomodate changes later when I do want to put extras in. IPresenter take a co-variant generice type of type IView so down the inheritance chain I can make presenters of a specific child view type. In the end creating a dialog is done by instantiating a Presenter and calling Show:

ISomePresenter<ISomeView> somePresenter = new SomeFactory.GetSomePresenter();
somePresenter.Show();

My view holds a copy of the IViewModel:

public void Show()
{
  ISomeView theView = new V();
  theView.ViewModel = new SomePresenterViewModel();
  .
  .
  .
}

No back to the original question... The SampleView can't know about the ISampleViewModel, therefore it's impossible to do the standard databinding to the ViewModel without putting a cast in somewhere. This got out of hand in the project I developed all this stuff in and people were casting all over the place in event handlers as well as the BindingSource wizards. The whole point of MVP was lost.

So now that I've been getting really strict on how to handle events and either setting the control as public in properties (and an accompanying ISampleView property) so the Presenter can see them or simply creating duplicate events to re-fire the event to be picked up by the Presenter I've been thinking about the whole Databinding conundrum. Really, the only way to do it is without designer support and do everything the designer does in code inside the Presenter. Perhaps use the Designer to get the auto generated code in the .designer.cs file, but cut all the code out into the Presenter. Maybe do it once to get the syntax etc right, then bash out some boiler plate code or create a snippet based on what's generated. You would still need access to the actual control on the view in order to specify the binding, so in conjunction also add a property to the ISampleView which returns the control instance. Also, I'd recommend putting the BindingSource instances in the Presenter as well or at least some other class which the Presenter holds an instance to.

I like to use the Designer as much as possible but sometimes you need to make the break. As I said the WinForms MVP project on CodePlex is great but all form design is done in code. In my scenario it's only the DataBinding which needs to be done in code, which isn't actually a visual thing anyway so it's easier to deal with.

Also, as a side note, user NotifyPropertyWeaver (IL Weaving) to support full databinding. It's brilliant in that you can create automatic properties in your view models which keeps your code succinct and more readable without having to put the calls to NotifyPropertyChanging, etc on each property. The IL Weaving with Fody does all that post compile before the final build output step. Extremely handy.

Anyway, I hope this brain dump of concepts around the issue are of value to someone. I spent a long time sorting it out but it works pretty well for me.

Steve

Edit 2014-04-23

You know what, .NET Databinding is a massive pain in the bum. Recently on a project we just ended up rolling our own databinding code for a specific control because it all just got to hard to work with.

Rethinking my initial reply further more recent experiences, the core model should be kept completely separate. I've tended to create what I've called a ViewModel which talks to the database and is DataBindable and seen by the View. Databinding has caused me SO much grief especially when handling control events, like DateTimePicker's ValueChanged. In one scenario I have a start and an end date picker as well as a checked box to set the end date to one day after the start date and other range rules I need to consider. With databinding configured to the VM when changing values based on some rule the events fire again and end up overriding choices I've made. I end up having to put bool values to aid in knowing if the event handler should continue or not, then there's potential race conditions or not knowing if an event handler (in another thread) should wait or not. Gets messy really quick.

So, my approach from now on is to create a big MODEL which touches the database and can do validation rule checking based on data captured, but I'll create a small, lighter version which just holds properties for databinding. Separation to the real model is still in place and any events the Presenter / Controller responds to can just copy from the VM to the main model at form data validation / data persistence time. If I'm responding to events, then setting vm values being bound to then which a much lighter weight VM I can create a whole new VM instance and re-assign the results of validation, then set this new VM instance as the .DataSource of the BindingSource on the View when I'm ready which avoids the event handler mess.

The main Model could respond to the NotifyPropertyChanged event to update itself on changes or even better just get the presenter to do that at the right time.

By the way, it seems that Visual Studio 2012 and 2013 now handle generic controls in the designer which is very cool.

As a side note I've been dabbling recently in iOS development. One thing I'm very impressed about is the way they have baked in MVC as part of the process, unlike .NET which allows us to come up with all manner of hack ways of doing it. I've taken some lessons from this and applied them to .NET and finding my brain isn't breaking so much. One thing in particular I love is the way the list controls work, which are much like Qt's (C++ framework) MVC controls. The ability to have monolithic backend lists of objects yet the view only holds what it needs in the visible area is so much nicer than the .NET controls default behaviour.

Anyway, good luck with .NET databinding. I'd personally recommend to any new comers...don't use it and just get the controller to assign all the values explicitly at appropriate times. But if you are comfortable and understand the annoying nuances I hope some of what I've said reaches someone.