C# 4 and .NET 4

1334 ❘ ChaPTer 44 windOws wOrkflOw fOundAtiOn 4
}
public UIElement ProperttInspectorView
{
get { return _designer.PropertyInspectorView; }
}
private WorkflowDesigner _designer;
To begin, the ViewModel class derives from BaseViewModel — this base class is one that we use every time
we construct a view model, as it provides an implementation of INotifyPropertyChanged. It comes from
a set of snippets written by Josh Twist and available on www.thejoyofcode.com.
The constructor ensures that the metadata for all of the built-in activities is registered — without this call,
none of the type specific designers will show up on the user interface. Within the InitializeViewModel
method, we then construct an instance of the Workflow Designer and load an activity into it. The
WorkflowDesigner class is curious in that once you’ve loaded one workflow into it, you cannot load
another, so here we re-create this class whenever a new workflow is created.
The last thing that the InitializeViewModel method does is to call the property change notification
function to indicate to the user interface that both the DesignerView and PropertyInspectorView are
updated. As the UI is bound to these properties, they will be requeried and will load the new values from
the new Workflow Designer instance.
The next part of the user interface that needs to be created is the toolbox. In Workflow 3.x you had to construct
this control yourself; however, in Workflow 4 there is a ToolboxControl, which is trivially easy to use.
public UIElement Toolbox
{
get
{
if (null == _toolbox)
{
_toolbox = new ToolboxControl();
ToolboxCategory cat = new ToolboxCategory
("Standard Activities");
cat.Add(new ToolboxItemWrapper(typeof(Sequence),
"Sequence"));
cat.Add(new ToolboxItemWrapper(typeof(Assign), "Assign"));
_toolbox.Categories.Add(cat);
}
ToolboxCategory custom = new ToolboxCategory
("Custom Activities");
custom.Add(new ToolboxItemWrapper(typeof(Message),
"MessageBox"));
_toolbox.Categories.Add(custom);
}
}
return _toolbox;
Here, we construct the toolbox control, then add two toolbox items to the first category and one toolbox
item to a second category. The ToolboxItemWrapper class is used to simplify the code needed to add a
given activity to the toolbox.
With that code in place, we have a functioning application — well almost. All we need to do now is wire up
the ViewModel with the XAML. This is done in the constructor for the main window.
public MainWindow()
{
InitializeComponent();
ViewModel vm = new ViewModel();
www.it-ebooks.info