C# 4 and .NET 4

Commanding ❘ 1061
Instead of using the Binding markup extension, now the binding is done as a child of the TextBox.Text
element. The bound object now defines an Email property that is implemented with the simple property
syntax. The UpdateSourceTrigger property defines when the source should be updated. Possible options
for updating the source are:
➤
➤
➤
When the property value changes — which is every character typed by the user
When the focus is lost
Explicitly
ValidationRules is a property of the Binding class that contains ValidationRule elements. Here
the validation rule used is the custom class RegularExpressionValidationRule, where the Expression
property is set to a regular expression that verifies if the input is a valid e-mail, and the
ErrorMessage property that gives the error message in case the data entered to the TextBox is not valid:
Email:
Commanding
Commanding is a concept of WPF that creates a loose coupling between the source of an action (for
example, a button) and the target that does the work (for example, a handler method). Events are strongly
coupled (at least with XAML 2006). Compiling the XAML code that includes references to events requires
that the code-behind have a handler implemented and available at compile time. With commands, the
coupling is loose.
The action that is executed is defined by a command object. Commands implement the interface ICommand.
Command classes that are used by WPF are RoutedCommand and a class that derives from it, RoutedUICommand.
RoutedUICommand defines an additional text for the user interface that is not defined by ICommand. ICommand
defines the methods Execute() and CanExecute(), which are executed on a target object.
The command source is an object that invokes the command. Command sources implement the interface
ICommandSource. Examples of such command sources are button classes that derive from ButtonBase,
Hyperlink, and InputBinding. KeyBinding and MouseBinding are examples of InputBinding derived
classes. Command sources have a Command property where a command object implementing ICommand
can be assigned. This fires the command when the control is used, such as with the click of a button.
The command target is an object that implements a handler to perform the action. With command binding,
a mapping is defined to map the handler to a command. Command bindings define what handler is invoked
on a command. Command bindings are defined by the CommandBinding property that is implemented in
the UIElement class. Thus every class that derives from UIElement has the CommandBinding property.
This makes the finding of the mapped handler a hierarchical process. For example, a button that is defined
within a StackPanel that is inside a ListBox — which itself is inside a Grid — can fire a command. The
handler is specified with command bindings somewhere up the tree — such as with command bindings of a
Window.
Let’s change the implementation of the BooksDemo project to use commands instead of the event model.
www.it-ebooks.info