Nothing is as powerful as an idea whose time as come – Victor Hugo

Sequence Diagram Generation
I find this to be a life saver. I don’t know about you but as a developer I want to dive right into code after I finish designing. There are times I have to sequence diagrams and this usually comes before you start coding. Now, with the sequence diagram generator in Visual Studio 2010, I can write code then simply generate. This not only saves you time but also lets you better understand your branches in your code that can lead to code complexity or cyclomatic complexity.

Here is the Code that we will work with in this post.

class Animal {
       public virtual void Description() { Console.WriteLine("Lives on earth"); }
    }

    class Bird : Animal {
        public override void Description() { Console.WriteLine("have feathers and a beak"); }
    }

    class Lion : Animal {
        public override void Description()
        {
            Console.WriteLine("roars and have large teeth");
        }
    }

    class Park
    {
        static void Main(string[] args)
        {
            List animalsInPark = new List();
            ShowDescriptions(animalsInPark);
        }

        static void ShowDescriptions(List animals)
        {
            animals.ForEach(animal => animal.Description());
        }
    }

Now right click on ShowDescriptions() and click generate sequence diagram. You should see this dialog.

And wallah – your very own Visual Studio 2010 crafted sequence diagram. I have to admit, I am really starting to like these diagrams

.

Code Window Zoom
Visual Studio 2010 allows you to zoom in and out just as in Internet Explorer. All you have to do is press Ctrl and use your mouse wheel or your equivalent mouse pad scroll to zoom in and out. This may not be so exciting but when it comes to giving presentations, this will make all our lives easier when it comes to changing font size. The beauty about zooming is that the font is crisp and smooth due to the fact that Visual Studio 2010 is built with WPF. Below is an image of me zooming in on the Animal class.

Code Generation
Most of us who use Visual Studio 2008 love the generate method feature. If you don’t know what this is, here is your intro. If you  write a method name and it doesn’t exists, you can right click on the method and tell visual studio to generate the stub and it will do it. No questions ask.

Visual Studio 2010 has taken this further and now you can even do classes. See below for demonstration.



Highlighted Reference
If you select a reference or even click on it, Visual Studio 2010 highlights all of the places it is used in your code.

Navigate To
Pressing Ctrl comma (,) brings up a dialog window that allows you to look for Methods, properties, classes, etc within your solution. It is case insensitive and it searches via partial name.

Click on any of the items found will take you to the line within the file where it is located.

Box Selection
This is one feature that I still have not found a suitable use for. This feature allows you to hold Ctrl + Alt and use either your mouse or arrow keys to select a rectangular area. If you now start typing, you will simultaneously be typing on all lines that you selected. If you happen to find a useful case for it, please let me know.

One thing I forgot to mention is that adding references to a project also seems faster. These are only some of the new features in Visual Studio 2010. Hope you find them as exciting as I do. Now go code!
CodeProject

Overview
“This is a one-day, FREE event focused on core skills that modern developers need to have to be successful today.  This isn’t about learning the basics of Silverlight, WPF, or, rather, this conference will help you understand how to build software that is better designed, more maintainable, and more testable. “

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;

namespace OliverCode.CodeBytes
{
    class ParallelLinqCB
    {
        static void Main(string[] args)
        {
            Action action = (int itemFromList) => Console.Write(itemFromList + ",");
            var lst = Enumerable.Range(1, 10);

             //PLINQ will decide on the number of processors to use in this run up to 64 threads (if you have that much)
             lst.AsParallel().Select(i => i * i).ForAll(action);
            Console.WriteLine();
            //My machine has 4 cores but i only need it to use up to 2 cores so I use the WithDegreeOfParallelism to restrict it
            //Or I could have use all 4 with the statement WithDegreeOfParallelism(4) hereby not letting PLINQ choose for me
            lst.AsParallel().WithDegreeOfParallelism(2).ForAll(action);

            Console.Read();
        }
    }
}

Cropped diagram courtesy of MSDN PFX (Parallel Programming Framework)

CodeProject

Please share your thoughts and check back soon for the first in the series of CB (Code Bytes).

The Theory of Dynamic

So what is this here dynamic thingy? dynamic in C# 4.0 refers to dynamic binding and dynamic binding is what happens at runtime and not at compile time. This involves binding a method, property, operator, member etc of an object at runtime. Yes I know this sounds like polymorphism or like the var keyword or even like using the ultimate base class in C# – object. First and foremost you have to let go or what you know and remember this important fact.

dynamic != var && dynamic != object

The keyword dynamic, casually speaking, tells the compiler that “Even though it cannot resolve the member statically, it should trust the programmer and don’t worry because it will/may be resolved at runtime.”

Code

Here is a sample on how you use the dynamic keyword:

dynamic dyn = “My first time”;
Console.WriteLine(dyn);

Now let’s look at some similarities and differences of var, object, and dynamic for a sec.

var v = 1; // here the compiler will figure out (at compile time) the type for v which will be int.
Console.WriteLine(v.GetType().ToString());
//v.Compute(); // causes a compiler error
object o = 1; // this is boxed from value type to an object with type being int32
Console.WriteLine(o.GetType().ToString());
//o.Compute(); //also gives a compiler error
dynamic d = 1; //type here is int32
Console.WriteLine(d.GetType().ToString());
d.Compute(); // does not give compile time error but will throw a runtime RuntimeBinderException

So how is this binding done?

Look at the following code.

class Program
{

static void Main(string[] args)
{
dynamic dyn = "hello";
Function(dyn); //The first call is slow because here the call site must figure out the binding
Function(dyn); //The second call is faster because all the binding lookup was cached in the first call
Console.Read();
}

public static void Function(string s)
{
Console.WriteLine(s);
}

public static void Function(StringBuilder sb)
{
Console.WriteLine(sb.ToString());
}

}

Which version of Function is called? The one with the string argument.
The call to Function above on the dynamic type is resolved at runtime based on the runtime type information and not on the compile time’s type information. Also, the function with the most specific or closest matching parameter will be the one that is called. Pretty neat huh? By the way, the way in which we used the dynamic keyword above is referred to as language binding

A Bit More Advance Stuff

So let’s say you want to develop a class that has is able to calculate some basic statistics and one of your key requirements is to make it so that the calls to the methods are case insensitive. Also, you want to be able to add new functionality at will. How can you do that?
In the System.Dynamic namespace there is a class called DynamicObject that implements IDynamicMetaObjectProvider. If you want your classes to have the dynamic capability, then inheriting this class gives you those capabilities. By the way, inheriting DynamicObject or implementing IDynamicMetaObjectProvider is called custom binding.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Dynamic;

namespace OliverCode.DynamicProgramming
{
public class Statistics : DynamicObject
{
private readonly double[] _arrayOfValues;

public Statistics(double[] arrVals)
{
_arrayOfValues = arrVals;
}

public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
{
bool isSuccess = true;

switch (binder.Name.ToLower())
{
case "average":
result = _arrayOfValues.Average();
break;
case "max":
result = _arrayOfValues.Max();
break;
case "min":
result = _arrayOfValues.Min();
break;
default:
result = 0;
isSuccess = false;
break;
}

return isSuccess;
}
}

class Program
{

static void Main(string[] args)
{
dynamic stats = new Statistics(new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });

Console.WriteLine(stats.max()); //resolved at runtime time
Console.WriteLine(stats.Max());//resolved at runtime time
Console.WriteLine(stats.Mean());//resolved at runtime time

Console.Read();
}
}
}

Pay attention to the TryInvokeMember method which has been overridden. This means that my class can handle method calls. Actually there are a few methods that you can override:

IEnumerable GetDynamicMemberNames();
DynamicMetaObject GetMetaObject(Expression parameter);
bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object result);
bool TryConvert(ConvertBinder binder, out object result);
bool TryCreateInstance(CreateInstanceBinder binder, object[] args, out object result);
bool TryDeleteIndex(DeleteIndexBinder binder, object[] indexes);
bool TryDeleteMember(DeleteMemberBinder binder);
bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result);
bool TryGetMember(GetMemberBinder binder, out object result);
bool TryInvoke(InvokeBinder binder, object[] args, out object result);
bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result);
bool TrySetIndex(SetIndexBinder binder, object[] indexes, object value);
bool TrySetMember(SetMemberBinder binder, object value);
bool TryUnaryOperation(UnaryOperationBinder binder, out object result);

I don’t have the details on all the methods but you get the gist.

So when does dynamic not work?

As far as I know there are 3 cases in which dynamic doesn’t work

1. On interface members that are explicitly implemented
2.  With Extension methods
3. Classes that subclass a base class but hide the bas classes members

So there is your introduction to dynamic programming. Now go code and don’t forget to live.
CodeProject

static void Main(string[] args)
{
TraditionalThreadCreation();
Console.Read();
}

static void TraditionalThreadCreation()
{
// Create threads
Thread thread1 = new Thread(Task);
Thread thread2 = new Thread(Task);

// this guy will do even numbers
thread1.Start(0);
// this guy will do odd numbers
thread2.Start(1);
//wait for first thread to finish
thread2.Join();
}

static void Task(object p)
{
for (int i = int.Parse(p.ToString()); i <=10; i += 2)
Console.WriteLine(i);
}

There is nothing wrong with creating threads like the code above. But there is one thing you have to keep in mind. Thread creation and startup has overhead. A typical thread can take up 1MB of your precious memory. Shocked?? Well you are not alone.

To mitigate this overhead, the .Net Framework has given you the thread pool (No this is not a swimming pool for threads). Basically, these are pre-created threads that are shared and recycled. They save you the trouble have creating threads but most importantly they alleviate the overhead in creating a thread.

Thread Pool -Things you should know.

• The run in the background.
• They are limited and when you’ve used them up; your tasks will begin to queue up.
• The Thread Pool only runs a certain amount of threads simultaneously. This is done to not choke your CPU.

How can you use the thread pool you ask?

Well that is done in a few ways. But for now I will list 2 that are pre .Net Framework 4.0

1. ThreadPool.QueueUserWorkItem
2. BackgroundWorker

Thread Pool

This is very easy to use. Here is how.

static void Main(string[] args)
{
ThreadPool.QueueUserWorkItem(Task, 1);
}

static void Task(object p)
{
for (int i = int.Parse(p.ToString()); i <=10; i += 2)
Console.WriteLine(i);
}

Now how much faster is the Thread Pool vs Traditional Thread execution? Well it depends. Remember that your task may become queued if the limit on Thread Pool has been reached or the total number of simultaneous threads have been met.

Just for kicks I tried just starting and executing s single thread traditionally and via the thread pool and on average the thread pool was 200% faster.

class Program
{
static void Main(string[] args)
{
TraditionalThreadCreation();
//Wait for the guy above to finish
Thread.Sleep(1000);
ThreadPoolThreadCreation();

Console.Read();
}

private static void ThreadPoolThreadCreation()
{
var start = DateTime.Now;
// this guy will do even numbers
ThreadPool.QueueUserWorkItem(Task, new object[] {start, "ThreadPoolThreadCreation() Finished: {0}" });
}

private static void TraditionalThreadCreation()
{
var start = DateTime.Now;
Thread thread = new Thread(Task);

thread.Start(new object[] {start,"TraditionalThreadCreation() Finished: {0}" });
}

private static void Task(object p)
{
var start = (DateTime)((object[])p)[0];
var end = DateTime.Now;
var message = ((object[])p)[1].ToString();

//I only care about starting up and running executing and not the time the task takes to execute
Console.WriteLine(message, end - start);

for (int i = 0; i <= 10; i += 2)
Console.Write(i);

Console.WriteLine();
}

}

Background Worker

This guy is in the System.ComponentModel name space. It is used primarily in GUI development where you execute a task on background thread and periodically update GUI elements on the foreground thread in the form of progress reporting. To use BackgroundWorker you have to do a few things.

1.  Instantiate

2.  Handle the DoWork Event

3.  Call RunWorkerAsync

class Program
{
private static BackgroundWorker _theBGW = new BackgroundWorker();

static void Main(string[] args)
{
   BackgroundWorkerRun();
   Console.Read();
}

static void BackgroundWorkerRun()
{
_theBGW.DoWork += new DoWorkEventHandler(bw_DoWork);
_theBGW.ProgressChanged += new ProgressChangedEventHandler(bw_ProgressChanged);
_theBGW.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerCompleted);
//This must be set to true in order to be able to cancel the worker
_theBGW.WorkerSupportsCancellation = true;
//This must be set to true in order to report progress
_theBGW.WorkerReportsProgress = true;
_theBGW.RunWorkerAsync();
Thread.Sleep(1000);
//uncomment this line to cancel before percentage reaches 100
//if (_theBGW.IsBusy)
// _theBGW.CancelAsync();
}

static void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
if(!e.Cancelled)
Console.WriteLine("Wordker Done!! - {0}", e.Result);
else
Console.WriteLine("The answer to the universe will remain unknown");
}

static void bw_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
Console.WriteLine("Completed {0}%", e.ProgressPercentage);
}

static void bw_DoWork(object sender, DoWorkEventArgs e)
{
for (int i = 10; i <= 100; i += 10)
{
if (!_theBGW.CancellationPending)
{
_theBGW.ReportProgress(i);
Thread.Sleep(1000);
}
else
{
e.Cancel = true;
return;
}
}
e.Result = "The secret to the universe is 42";
}
}

In my next post I will talk about the TPL (Task Parallel Library) in .Net Framework 4.0.
CodeProject

A few months ago I took the leap from WinForms programming to WPF and quite naturally, I took to it like a duck to water. Well, to be honest I had been developing Silverlight applications since its inception and being that Silverlight is a subset of WPF it required a low learning curve to catch on. However, the concept of Commanding was a bit different in WPF and I soon began to see how much more powerful Commanding in WPF was compared to Silverlight.

One of the areas in which Commanding is exemplary is in the way in which it complements MVVM.  But what is MVVM, and why is it useful? This is the toughest concept (In my opinion) to grasp when it comes to WPF (and Silverlight) programming. Why you ask? Because it is simple and as developers we often like code or concepts that warp our minds, so when we figure it out we can brag to our peers how it only took 2 hours to understand and implement the next BIG thing (No I am not projecting).  On a side not, I have found that everyone one who blogs about MVVM complicate it by adding too much code which just throws you for a loop. Simplicity is the key to all things complicated. So let’s delve into a little theory and we will finish up with some short-to-the-point code.

Purpose

The purpose of this post is to

a. Give a simple and clear definition of Model View View-Model

b. Provide a clear and simple sample that clearly illustrates MVVM usage

MVVM?

Figure 1.

MVVM - Model View ViewModel

Just in case you cannot read the text in the image here it is below:

1. The View holds a reference to the ViewModel. The View basically displays stuff by Binding to entities in the View Model.
2. The ViewModel exposes Commands, Notifiable Properties, and Observable Collections to the View. The View Binds to these ViewModel entities/members
3. The Model is your data and or application objects that move data while applying Application Logic. If you have a Business Layer then you might not need this.

Above is a simple figure that tells you exactly what MVVM is. In my own words, the ViewModel is the most significant in the entire pattern as it is the glue that sits between the View and the Model and binds both of them together. Now let’s explore some code.

Code

The application you are about to see is very intricate in design and implementation and as such must not be criticized by anyone. Here is an overview of what the application does. It takes your first name, last name and age and displays it to you in message box.  Below is the really complicated class diagram.

Figure 2.

MVVM - Class Diagram

Let’s take a look at the PersonModel class which is the only Model in the application:

namespace OliverCode.MVVM.Model
{
internal class PersonModel : System.ComponentModel.INotifyPropertyChanged
{
private string firstName;
public string FirstName
{
get { return firstName; }
set
{
if(firstname != value)
{
firstName = value;
OnPropertyChanged("FirstName");
}
}
}
private string lastName;
public string LastName
{
get { return lastName; }
set
{
//Check ensures you do not update unchanged values
if(lastname != value)
{
lastName = value;
OnPropertyChanged("LastName");
}
}
}
private int age;
public int Age
{
get { return age; }
set
{
if(age != value)
{
age = value;
OnPropertyChanged("Age");
}
}
}
#region INotifyPropertyChanged Members
public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
private void OnPropertyChanged(string propertyName)
{
if (PropertyChanged != null)
PropertyChanged(this, new System.ComponentModel.PropertyChangedEventArgs(propertyName));
}
#endregion
}
}

Person class implements the INotifyPropertyChanged interface which enables a WPF elements to be immediately notified if any of the properties changed on a Person object.

Moving on… Let’s look at the View which is cleverly named, PersonView (Quite creative if I might add).

<UserControl x:Class="OliverCode.MVVM.View.PersonView"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    Height="Auto" Width="Auto"

    xmlns:local="clr-namespace:OliverCode.MVVM.ViewModel">

    <StackPanel Orientation="Vertical" Margin="4">

        <!--Here is where we the view gets a reference to the ViewModel Declaratively-->

        <StackPanel.DataContext>

            <local:PersonViewModel />

        </StackPanel.DataContext>

        <StackPanel Orientation="Vertical" DataContext="{Binding Path=Person, Mode=TwoWay}" Margin="4">

            <StackPanel Orientation="Horizontal">

                <Label Content="First Name:" Margin="0,0,4,0"/>

                <TextBox Width="250" Text="{Binding Path=FirstName}"/>

            </StackPanel>

            <StackPanel Orientation="Horizontal" Margin="0,5,0,0">

                <Label Content="Last Name:" Margin="0,0,4,0"/>

                <TextBox Width="250" Text="{Binding Path=LastName}"/>

            </StackPanel>

            <StackPanel Orientation="Horizontal" Margin="0,5,0,0">

                <Label Content="Age:" Margin="35,0,4,0"/>

                <TextBox Width="50" MaxLength="3" Text="{Binding Path=Age}"/>

            </StackPanel>

        </StackPanel>

        <StackPanel>

        <!—The Command is bound to the Property in the PersonViewModel call SavePersonCommand-->

            <Button Content="Save" HorizontalAlignment="Right" Width="80" Command="{Binding Path=SavePersonCommand}"/>

        </StackPanel>

    </StackPanel>

</UserControl>

The key take away from the XAML above is the way the PersonViewModel is attached to the PersonView’s DataContext (This is the typical means by which the View gets a reference to the ViewModel).  Also pay attention to the Button element who’s Command is using the Binding Class to Attach the SavepersonCommand, which is a property on the ViewModel. Typically, binding to a command is more complicated than this, but because of the WPF Mvvm Toolkit 1.0 which is located here http://wpf.codeplex.com/Wiki/View.aspx?title=WPF%20Model-View-ViewModel%20Toolkit from the Microsoft Team, developers can now easily Bind to commands. I have included the DelegateCommand class in the project so you don’t need to download it directly. There is also a CommandReference class whose purpose is to resolve limitations in WPF when binding data binding from XMAL (This is not used in the program).

WPF Mvvm Toolkit 1.0 Tidbits

There are several classes in the toolkit but the one you should pay attention to is the DelegateCommand. This class makes it easy to write a function to handle a gesture or command. Gestures can be thought of as any interaction that can initiate a command. I use the DelegateCommand directly in my PersonViewModel like so.

private DelegateCommand savePersonCommand;

public ICommand SavePersonCommand
{
get
{
if(savePersonCommand == null)
savePersonCommand = new DelegateCommand(new Action(SaveExecuted), new Func<bool>(SaveCanExecute));
return savePersonCommand;
}
}
public bool SaveCanExecute()
{
return Person.Age > 0 && !string.IsNullOrEmpty(Person.FirstName) && !string.IsNullOrEmpty(Person.LastName);
}
public void SaveExecuted()
{
System.Windows.MessageBox.Show(string.Format("Saved: {0} {1} - ({2})", Person.FirstName, Person.LastName, Person.Age));
}

namespace OliverCode.MVVM.ViewModel
{
internal class PersonViewModel
{
public PersonModel Person { get; set; }
private DelegateCommand savePersonCommand;
public ICommand SavePersonCommand
{
get
{
if(savePersonCommand == null)
savePersonCommand = new DelegateCommand(new Action(SaveExecuted), new Func<bool>(SaveCanExecute));
return savePersonCommand;
}
}
public PersonViewModel()
{
//This data will load as the default person from the model attached to the view
Person = new PersonModel { FirstName = "John", LastName = "Doe", Age = 999 };
}
public bool SaveCanExecute()
{
return Person.Age > 0 && !string.IsNullOrEmpty(Person.FirstName) && !string.IsNullOrEmpty(Person.LastName);
}
public void SaveExecuted()
{
System.Windows.MessageBox.Show(string.Format("Saved: {0} {1} - ({2})", Person.FirstName, Person.LastName, Person.Age));
}
}
}

Simple, isn’t it? I hope I have helped someone by saving them hours trying to find a simple demonstration of MVVM in WPF. Thank you now go code.

Commanding in WPF is unlike your traditional events in Winforms. Commands were primarily designed to be used at the application level, but they have become one of the most popular features among developers when it comes to UI programming (we tend to use them more than they should be). Commands enable the developer to define a task once and “attach” it multiple times without having to go through the traditional means which would require duplicating the code or even calling it in more than one place (This is the magic). WPF intrinsically provides 5 commands that you can use out of the box.

1. ApplicationCommands
2. ComponentCommands
3. EditingCommands
4. MediaCommands
5. NavigationCommands

I have explored them and have taken a liking to ApplicationCommands (In fact this is the one that most developers will use).

To use command do the following:

1. Link  your custom/predefined  command to a control that you want to respond to the command and add a input gesture to the command
2. Create a handler for the command and use the CommandBindings class to bind the handler to the control
3. Add the binding to the control’s Commands collection

So let’s delve into some code to demonstrate WPF commanding.

Lets first look at the XAML:

<Window x:Class="Commanding.Window1"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    Title="Window1" Height="340" Width="509"

    xmlns:MyCommands="clr-namespace:Commanding">

    <Grid>

        <Border Padding="5" BorderBrush="Black" BorderThickness="2" CornerRadius="5" Margin="10">

            <StackPanel Orientation="Vertical" HorizontalAlignment="Center" VerticalAlignment="Top" Height="64">

                <StackPanel Orientation="Horizontal" HorizontalAlignment="Center" VerticalAlignment="Center">

                    <Label>Type Your Name :</Label>

                    <TextBox Name="txtName" Width="200"></TextBox>

                    <Button Command="MyCommands:Commands.HelloCommand" Content="Say Hello" Padding="3"></Button>

                </StackPanel>

                <CheckBox Name="chkCanExecute" Content="Uncheck to suppress command execution" IsChecked="True"/>

            </StackPanel>

        </Border>

    </Grid>

</Window>

xmlns:MyCommands=”clr-namespace:Commanding

 references the namespace in which the custom command is defined.

The Button Element’s Command property is associated with the custom command:

<Button Command=”MyCommands: CustomCommand.HelloCommand” Content=”Say Hello” Padding=”3″></Button>

Below you will see the HellowCommand Property from the CustomCommand class.

namespace Commanding
{

    public class CustomCommand

    {

        private static System.Windows.Input.RoutedUICommand helloCommand;

        static CustomCommand ()

        {

            // First: I created a gesture collections

            System.Windows.Input.InputGestureCollection gestureCollection

                = new System.Windows.Input.InputGestureCollection();

            //Second: I add the input (Key gesture) that I want to trigger this command)

            gestureCollection.Add(new System.Windows.Input.KeyGesture(System.Windows.Input.Key.H, System.Windows.Input.ModifierKeys.Control));

            //Third: Initialize my command

            helloCommand = new System.Windows.Input.RoutedUICommand("HelloCommand", "HelloCommand", typeof(Commands), gestureCollection);

        }

        public static System.Windows.Input.RoutedUICommand HelloCommand

        {

            get { return helloCommand; }

        }

    }

}

namespace Commanding

{

    /// <summary>

    /// Interaction logic for Window1.xaml

    /// </summary>

    public partial class Window1 : Window

    {

        public Window1()

        {

            InitializeComponent();

            CommandBinding binding = new CommandBinding();

            binding.Command = Commanding.Commands.HelloCommand;

            binding.Executed += new ExecutedRoutedEventHandler(binding_Executed);

            binding.CanExecute += new CanExecuteRoutedEventHandler(binding_CanExecute);

            this.CommandBindings.Add(binding);//Commenting out this line disables the button

        }

        void binding_CanExecute(object sender, CanExecuteRoutedEventArgs e)

        {

            e.CanExecute = (bool)chkCanExecute.IsChecked;

        }

        void binding_Executed(object sender, ExecutedRoutedEventArgs e)

        {

            MessageBox.Show(string.Format("Hello {0}, you have mastered commanding", txtName.Text));

        }

    }

}