Daily Archives: 2009 Jul 27 [Mon]

by dkt

A Hello World Order Entry app in WPF

So you’ve decided that Windows Forms is more trouble than its worth. You’re all set to start writing a WPF app. You fire up Visual Studio 2008, create a new solution, and see absolutely nothing about this fancy MVVM that seems to have taken the world by storm. No standard template—just a “WPF Application” that, when you start it, gives you the same blank Window that you used to get when you were creating Windows Forms apps. Really?

To be fair, I don’t think even the gang in Redmond realized just how far the community would run with MVVM and a lot of what we think of as staples of MVVM design now simply weren’t even thought of when Microsoft was trying to rush VS 2008 out the door. Visual Studio 2010 will provide better out-of-the-box guidance in creating a well-factored WPF app, but that’s not here quite yet.

Until then, give Order Entry a whirl. It’s a simple app with a simple purpose—provide a simple order entry ticket (buy/sell, symbol, price, and quantity). It sets up the basics of defining a view and a viewmodel that exposes the properties of a model in a way more conducive to consumption by the view.

It illustrates:

  1. Binding a view to a viewmodel
  2. Separation of the view (visual elements) from the viewmodel (data, non-visual resources)
  3. A simple ICommand implementation that disables/enables the Submit button

It’s not perfect because it lacks two things that every real GUI has (which we’ll fix in later posts):

  1. Threading. When you press Submit, all the “work” happens on the GUI thread.
  2. Validation. When you type something in the view that is not physically storable in the viewmodel (like entering in “Abracadabra” as a quantity), the screen changes to indicate an error on the field, but it doesn’t stop the user from submitting (viewmodel and its ICommand don’t know that the view is in an error state—only the view knows).

Validation and WPF data binding are tricky to get right. We’ll talk about that in later posts too. But for now, here’s version 1 of the Order Entry app to chew on. —DKT

by dkt

Windows Forms is a Maintenance Risk

People say that WPF is a pretty big change from the Windows Forms technology of yesteryear, but there are also people who have invested considerable time and money into Windows Forms solutions that aren’t eager to rewrite their apps yet again. I can understand that—it takes time to develop things, and rewriting things for the sake of using the latest and greatest is not usually something that keeps projects on time and on budget.

But any new development should definitely be written in WPF.

Here’s a snippet of Windows Forms code that keeps a TextBox on the screen synchronized with a Quantity field on an Order object:

MyEditor.cs 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

public class MyEditor : UserControl
{
    private System.Windows.Forms.TextBox quantityTextBox;
 
    public MyEditor()
    {
        InitializeComponent();
    }
 
    private void InitializeComponent()
    {
        quantityTextBox = new System.Windows.Forms.TextBox();
        quantityTextBox.TextChanged += new System.EventHandler(quantityTextBox_TextChanged);
        // ...more auto-generated noise
    }
 
    public void SetOrder(Order order)
    {
        _order = order;
        _order.PropertyChanged += order_PropertyChanged;
        quantityTextBox.Text = _order.Quantity.ToString();
    }
 
    private void quantityTextBox_TextChanged(object sender, EventArgs e)
    {
        long qty;
        if (long.TryParse(quantityTextBox.Text, out qty))
        {
            _order.Quantity = qty;
            quantityTextBox.BackColor = Color.White;
        }
        else
        {
            quantityTextBox.BackColor = Color.Pink;
        }
    }
 
    private void order_PropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        if (e.PropertyName == "Quantity")
        {
            quantityTextBox.Text = _order.Quantity.ToString();
        }
    }
}

And in WPF:

MyEditor.xaml 
1
2
3
4
5

<UserControl x:Class="MyEditor"
                         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <TextBox Text="{Binding Path=Quantity}"/>
</UserControl>
MyEditor.xaml.cs 
1
2
3
4
5
6
7
8
9
10
11
12

public partial class MyEditor
{
    public MyEditor()
    {
        InitializeComponent();
    }
 
    public void SetOrder(Order order)
    {
        this.DataContext = order;
    }
}

Which one would you rather maintain? —DKT