MVVM Passing data to dialog View Model

I would perhaps do it in the following way:

1. The command attached to the edit button starts edit dialog, creating a custom ViewModel (VM) for it. The command itself should be perhaps either in the list's VM or in the Model (not quite sure).
2. Foobar edit dialog's VM gets a reference to the Foobar at its constructor.
3. The foobar is cloned and the clone is edited.
4. As soon as the user presses OK in the foobar edit dialog, the clone's values are written back to the original foobar in the VM (and the dialog is closed).

The need for a clone comes from the fact that the user doesn't want to see the changes in the foobar list until he accepts the changes in the edit dialog. If however online editing is okay, the clone is not needed.

The changes are propagated automatically.

PS: although I am MVVM's proponent, I am not sure that my solution is an orthodox one from pure MVVM point of view.

This article from codeproject shows a WPF Dialog control that does exactly what you need. The reason this implementation is necessary is that you can't put a Window inside the visual tree of any other control. Which means out of the box WPF doesn't let you create a dialog inside a window. So the above article creates a subclass ContentControl that creates a window.

Anyways, you put this in your FooBarList View

<dialog:Dialog Content="{Binding Path=DialogViewModel}" /> 

You make sure you have something like this in a resource dictionary somewhere:

<Style TargetType="{x:Type dialog:Dialog}"> <Style.Triggers>  <Trigger Property="HasContent" Value="True">   <Setter Property="Showing" Value="True" />  </Trigger> </Style.Triggers></Style>

and just write something like this(For WPF to work you need to implement INotifyPropertyChanged):

public Class FooBarListViewModel{  IList<FooBar> FooBarList {get;set;}  FooBar SelectedFooBar {get;set;}  ViewModelBase DialogViewModel {get;set;}  public EditFooBar(object param)  {    DialogViewModel = FooBar;  }}

To link the View to edit the FooBar to the FooBar ViewModel just do something like this(preferably in the Application.Resources so it's global)

<DataTemplate DataType={x:Type vm:FooBarViewModel}>  <vw:FooBarView/></DataTemplate>

(Or optionally: Use an IValueConverter to Convert get your View from a ViewModel like this post shows)

And then you're set. May sound like a lot, but it really frees you up a lot.

What’s missing is a Controller which is responsible for the workflow of the ViewModels. The Controller creates the ViewModels and it passes the necessary data between the ViewModels.

The WPF Application Framework (WAF) project contains sample applications that show how this might work.