How to (correctly) update the M in MVVM of WPF application?

Having passed a series of Edward Tanguay's questions refractoring the usage of MVVM for WPF app which can be found in Linked sidebar of his Fat Models, skinny ViewModels and dumb Views, the best MVVM approach?, I am a little confused by his final WPF application in Big smart ViewModels, dumb Views, and any model, the best MVVM approach?

Its M (Model) is Customer class:

//model
public class Customer
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime TimeOfMostRecentActivity { get; set; }

    public static Customer GetCurrentCustomer()
    {
        return new Customer 
                   { FirstName = "Jim"
                     , LastName = "Smith"
                     , TimeOfMostRecentActivity = DateTime.Now 
                   };
    }

}

which returns current user. Kind of, beause it returns duplicates of newly created "current" user...

But where is the M's data stored and updated in case of need?

Suppose, I want to change the model's current user's FirstName to "Gennady"?

I added a button for updating the model with this button click event handler:

private void button1_Click(object sender, RoutedEventArgs e)
{


}

aiming to change the model's data from it which will be reflected in GUI.

How can I do this, by clicking this button... sorry, by placing the code into this button1_Click()?

Or it is something wrong with my wish to do it?
Then. how to correctly update/change M in MVVM ?

Update:
All answers seem refer that I should not make changes in M but on VM.
Though I've specifically asked about referenced M-V-VM implementation with:

public CustomerViewModel()
{
    _timer = new Timer(CheckForChangesInModel, null, 0, 1000);
} 
private void CheckForChangesInModel(object state)
{
    Customer currentCustomer = CustomerViewModel.GetCurrentCustomer();
    MapFieldsFromModeltoViewModel(currentCustomer, this);
} 
public static void MapFieldsFromModeltoViewModel
     (Customer model, CustomerViewModel viewModel) 
{
    viewModel.FirstName = model.FirstName;
    viewModel.LastName = model.LastName;
    viewModel.TimeOfMostRecentActivity = model.TimeOfMostRecentActivity;
}

So, for example, upon implementing the code from Adolfo Perez's answer changes, the TextBox's content is changed from "Jim" to "Gennady" only for a period of interval set in _timer = new Timer(CheckForChangesInModel, null, 0, 1000);.

All logic of referenced by me M-V-VM in WPF approach is such that it is "M" should be updated, in order VM has caught up those changes, but not the "VM".

Even more, I cannot understand, if to make changes in VM how can they be reflected in M if the VM knows about M but - not vice versa - Model does not know about ViewModel).

Adolfo Perez

In MVVM you should avoid code-behind. The reason is that you want to end up with testable classes, in this case your VM's that are completely independent from your V. You could run a set of unit tests on your VM without involving the V. You could also hook different types of Views without affecting your business logic.

Your button will bind its Command property to an ICommand property exposed in your VM. This Command in your VM will handle your click event in the method you specify.

In your View:

<Button Content="Change FirstName" 
        Command="{Binding Path=ChangeFirstNameCommand"}/>

In your ViewModel:

//Define your command
public ICommand ChangeFirstNameCommand {get;set;}

//Initialize your command in Constructor perhaps
ChangeFirstNameCommand = new RelayCommand(OnChangeFirstName,CanChangeFirstName);

private void OnChangeFirstName()
{ 
    //Your FirstName TextBox in your V will be updated after you click the Button
    this.FirstName = "Gennady";
}

private bool CanChangeFirstName()
{
  //Add any validation to set whether your button is enabled or not. 
  // WPF internals take care of this.
  return true;
}

It is very important to keep in mind that in this pattern your V knows about your VM and your VM knows about your M but not the other way around.

In your example if you want to change your Model FirstName property you woud have to do the following:

Create a VM which implements INotifyPropertyChanged
Expose your M FirstName property in your VM notifying changes
Create a TextBox in your XAML View and bind its Text property to your VM.FirstName setting Binding Mode=TwoWay.
```
<TextBox Text=
     "{Binding Path=FirstName,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}"/>
```

As you type in the TextBox your FirstName will be directly populated in the VM-M. Also, thanks to the Two way binding, if you modify your FirstName property in your VM, that change will be reflected automatically in your V

Set your View.DataContext to your VM. This is what sets the Context for all your data bindings, unless you specify a different binding source.
If you want to persist changes in a DB then inject a service class in your VM which will take care of CRUD operations

Take a look at this simple example:

http://www.codeproject.com/Articles/126249/MVVM-Pattern-in-WPF-A-Simple-Tutorial-for-Absolute

Your model is your domain (business) objects. There are number of ways you can get them. For example you may have a repository class that gives you your data when you request it and handles the persistance when you wish to store it.

Your view-model is a class that handles UI logic, like updating fields, reacting on user actions, etc. In your case, you may pass an instance of CustomerRepository class to your view model. Then in view-model code you get the instance of Customer from the repository and fill your view-model properties on wich your UI elements are bound.

Your view is just a set of rules of how you wish to show the information to a user. It must be as declarative and logic free as possible.

Having a code like this:

private void button1_Click(object sender, RoutedEventArgs e)
{


}

in your view (or even worse - in your view-model) is a huge mistake wich breaks the pattern and may (and surely will) lead to troubles. You should bind ICommand fields of ViewModel to the buttons. You should not try to write a WPF application in a WinForm event-driven style.

That's how mvvm works in general and it's main purpose is to support multi-tier architecture in your application.

First off, you need to work on your V and VM.

If you are using a Click event for a button, you definatly aren't following this architecture.

You need to use WPF and XAML in your view to bind to your ViewModel, your ViewModel should be a subset of a particular or potentially many models and present the properties to the View which allows for binding.

I would also consider researching:

RelayCommand and ICommand for binding your buttons.
Repository pattern for interchanging your models and creating a way of CRUD

The tutorial which you have followed doesn't seem to be very good in that the concepts haven't really been put across properly or you haven't understood them.

If you have a pure WPF application it could be interesting to investigate the MVVM 'reverse' pattern, ViewModel-First.

For webdevelopment it is common to use MVVM because webpages get loaded through a browser and the View is constructed wich creates the ViewModel.

WPF users do not browse to pages (unless you use Page navigation) so it gets more interesting to follow VM-V-VM-M :

interface IMyView
  Show();

//view implementations in different assemblies:

//silverlight
class SilverlightMyView:IMyView
  Show();

//wpf
class WpfMyView:IMyView
  Show();

class MyViewModel

   IMyView _view;
   MyModel _model;

  //ex. view resolved by DI (Unity, ..)
  MyViewModel(IMyView view)
   _view = view

  Show(model as MyModel)
      _model = model;
      _view.DataContext = this;
      _view.Show();

来源：https://stackoverflow.com/questions/16101309/how-to-correctly-update-the-m-in-mvvm-of-wpf-application

标签

wpf

mvvm

conceptual