Mathias Brandewinder on .NET, F#, VSTO and Excel development, and quantitative analysis / machine learning.
by Mathias 22. February 2009 16:39

The M-V-VM seminar of last month inspired me to finally get serious about WPF. The best way to learn a technology is to write some code with it, so I have begun working on a project of my own, which I hope to complete by end-March (in spite of being working full bore on a project for a client).

So far, working with Model-View-ViewModel and WPF has proven easier than what I expected. Once you get the logic, things flow pretty naturally. One of my recent stumbling blocks was binding with a collection. Now that I got it to work, it seems trivial, but maybe this will help some other WPF beginner on the path to enlightenment!

Imagine that your model contains a list of persons, and that you want to display two things:

1) the list of persons,
2) detailed information about the selected person

First, let's create a WPF application project, and add a super-simple Person class:

public class Person
{
public string LastName
{
get;
set;
}
public string FirstName
{
get;
set;
}
}

For the sake of simplicity, in this example we will not separate the Model and ViewModel. Let's add a class ViewModel, with an ObservableCollection of Persons, which we pre-populate at construction time.

public class ViewModel
{
private ObservableCollection<Person> m_Persons;
public ObservableCollection<Person> Persons
{
get
{
return m_Persons;
}
}
public ViewModel()
{
var albert = new Person() { FirstName = "Albert", LastName = "Einstein" };
var bruno = new Person() { FirstName = "Bruno", LastName = "Latour" };
var charles = new Person() { FirstName = "Charles", LastName = "Darwin" };
m_Persons = new ObservableCollection<Person>() { albert, bruno, charles };
}
}

Our first task is to build a view to display the ModelView. We will use the main Window (which I renamed as "MainWindow") as the view, replace the Grid by a StackPanel, and add a ListView to it.

<Window x:Class="WpfCollectionSelectionTest.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="MainWindow" Height="300" Width="150">
<StackPanel>
<ListBox Height="150" 
Name="personsListBox" />
</StackPanel>
</Window>

Let's connect the View to the ViewModel. In the "startup" code of the application, we instantiate a ViewModel, and pass it as the DataContext to the View, in this case, the Window. This will allow the View to have access to data from the ViewModel. Note that the ViewModel knows nothing about the View.

public MainWindow()
{
InitializeComponent();
var viewModel = new ViewModel();
DataContext = viewModel;
}

We want the ListBox to fill from the collection in the ViewModel. To do this, add the following code to the ListBox:

<ListBox Height="150" 
Name="personsListBox" 
ItemsSource="{Binding Persons}" 
DisplayMemberPath="LastName"/>

The first part, ItemsSource, binds the contents of the ListBox to the ObservableCollection, by telling it to look for the Persons property in the DataContext (our ViewModel class). The second part declares that the data should be displayed calling the LastName property on the items in the list. If you don't do this, by default the display will call "ToString()", which is typically not all that great.

First part is done; if you run the app, you should see the ListBox display the names of some fine people.

Now let's add the following code to the ViewModel, to keep track of the selected Person:

private Person m_SelectedPerson;
public Person SelectedPerson
{
get
{
return m_SelectedPerson;
}
set
{
m_SelectedPerson = value;
}
}

we want the selected item in the ListBox to drive the SelectedPerson in the ViewModel. We could do this by setting the selection through code in the view, working with the DataContext, or firing events. Rather, we will use binding again, and bind the SelectedItem property on the ListBox to the SelectedPerson property in the ViewModel, by adding this code:

<ListBox Height="150" 
Name="personsListBox" 
ItemsSource="{Binding Persons}" 
DisplayMemberPath="LastName"
SelectedItem="{Binding SelectedPerson}" />

To prove that the binding work, let's add this code to the View, which will display the FirstName and LastName of the SelectedPerson:

<StackPanel>
<ListBox Height="150" 
Name="personsListBox" 
ItemsSource="{Binding Persons}" 
DisplayMemberPath="LastName"
SelectedItem="{Binding SelectedPerson}" />
<Label Content="Selected person"/>
<Label Content="{Binding SelectedPerson.FirstName}"/>
<Label Content="{Binding SelectedPerson.LastName}"/>
</StackPanel>

Et voila! If you run the application, the list should be populated, and whenever you select a person in that list, it will update the selected person in the View Model, and display the first and last name in the view.

Comments

7/28/2010 5:31:15 PM #

Jura Josef

This makes sense, but IMHO the Persons ObservableCollection should be of type PersonViewModel and that is complicating a lot of things. Have you ever tried to solve it this way ?

Jura Josef Czech Republic | Reply

8/3/2010 11:31:46 AM #

mathias

Hi Josef,
It's a good point, thank for the feedback! In general, I would use a ViewModel for the person as well, in spite of the overhead. In the example above, the Person is never updated, and to keep things simple I didn't introduce the extra ViewModel; maybe this wasn't such a great idea! Smile

mathias United States | Reply

7/6/2012 5:54:00 PM #

pingback

Pingback from starfootballlive.newpatriotmedia.com

Jobs data force delicate balancing act for Obama | Star Football Live

starfootballlive.newpatriotmedia.com | Reply

5/1/2013 11:43:55 PM #

MVVM_User

Thanks a ton for this fabulous article..

MVVM_User India | Reply

Add comment




  Country flag

biuquote
  • Comment
  • Preview
Loading



Comments

Comment RSS