Behavioral Patterns: Implementing the Command Pattern in C#

• Download source code - 30.6 KB

Introduction

This article shows how to implement the behavioral Command Pattern with C# 2.0 and .NET in a real case.

What's a Design Pattern?

A Design Pattern is a general repeatable solution to a commonly occurring problem in software design. A Design Pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations.

What's a Behavioral Design Pattern

Behavioral Design Patterns are Design Patterns that identify common communication patterns between objects and realize these patterns. By doing so, these patterns increase flexibility in carrying out the communication.

Purpose

The Command Pattern is a Design Pattern in which objects are used to represent actions. A command object encapsulates an action and its parameters.

Structure

• Command, declares an interface for executing an operation.
• Concrete Command, defines a binding between a Receiver object and an action. Implements Execute by invoking the corresponding operation(s) on the Receiver.
• Client, creates a Concrete Command object and sets its receiver.
• Invoker, asks the Command to carry out the request.
• Receiver, knows how to perform the operations associated with carrying out the request.

Real case

This example shows how to fill different controls with the Command Pattern. The source for each control is the file of Custom Resources.

Note: each control implements a different binding logic, but across the Command Pattern, this is hidden to client.

Let's write the code for the Command

1. Write the Command.

This interface contains the method to call for executing the Receiver code:

// Command
public interface ICommand    
{
    void Execute();
}

2. Write the Concrete Command.

This class defines a binding between the Receiver and the Execute Command action:

// Concrete Command
public class ConcreteCommand: ICommand
{
    private IFiller _filler;

    public ConcreteCommand(IFiller filler)
    {
        _filler = filler;
    }

    public void Execute()
    {
        _filler.Fill();
    }
}

3. Write the "Common Receiver".

This interface contains the common method for all controls to bind. This interface provides a common aspect for all the controls that want to use the Command.

public interface IFiller
{
    void Fill();
}

4. Write the "Invoker".

This class allows to call the Execute method for each item that implements IFiller.

// Invoker
public class Invoker
{
    private IFiller[] _filler;

    public Invoker(IFiller[] filler)
    {
        _filler = filler;
    }

    public void Execute()
    {
        ICommand command;
        foreach (IFiller item in _filler)
        {
            command = new ConcreteCommand(item);
            command.Execute();
        }

    }
}

Let's write the code for the Client

1. Write the Receiver(s).

The following custom controls (CustomLabel, CustomListBox, CustomListView) are controls that derive from the Label, ListBox, and ListView controls.

Thes controls implement the "Common Receiver" interface for implementing the binding logic:

// Receiver
public class CustomLabel: Label, IFiller
{
    public void Fill()
    {
        this.Text = Resources.ResourceManager.GetString(this.Name);
    }
}

// Receiver
public class CustomListBox: ListBox, IFiller
{
    public void Fill()
    {
        this.Items.Clear();
        int index=1;
        string item = Resources.ResourceManager.GetString(
            string.Format("{0}{1}{2}", 
            this.Name, 
            "_", 
            index.ToString()));
        while (item != null)
        {
            this.Items.Add(item);
            index++;
            item = Resources.ResourceManager.GetString(
            string.Format("{0}{1}{2}",
            this.Name,
            "_",
            index.ToString()));
        }
    }
}

// Receiver
public class CustomListView: ListView, IFiller
{
    public void Fill()
    {
        this.Columns.Clear();
        int index = 1;
        string item = Resources.ResourceManager.GetString(
             string.Format("{0}{1}{2}",
             this.Name,
             "_",
             index.ToString()));
        while (item != null)
        {
            this.Columns.Add(item);
            index++;
            item = Resources.ResourceManager.GetString(
            string.Format("{0}{1}{2}",
            this.Name,
            "_",
            index.ToString()));
        }
    }
}

2. Write the Client.

The Client calls the Invoker that invokes the Command.

After inserting the custom controls in a form, I wrote recursive functions to find controls that implement IFiller, and then I call the Invoker on the List of IFiller controls.

public partial class Form1 : Form
{
    private List<ifiller> _filler;

    public Form1()
    {
        InitializeComponent();
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        _filler = new List();
        searchControl(this.Controls);
        
        // Client
        Invoker invoker = new Invoker(_filler.ToArray());
        invoker.Execute();
    }

    private void searchControl(Control.ControlCollection ctrCollection)
    {
        foreach (Control ctr in ctrCollection)
        {
            IFiller fctr = ctr as IFiller;
            if (fctr != null)
                _filler.Add(fctr);
            if (ctr.Controls.Count > 0)
                searchControl(ctr.Controls);
        }
    }
}

History

This is the first iteration of this code. Please provide any feedback as to whether you have used this or not, or on any problems that anyone has found with it!