Behavioral Patterns: Writing Command pattern with c#

• Download Command Pattern code - 64.3 KB

Introduction

This article shows how to implement the behavioral pattern Command 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 this 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 Receiver.

Client, creates a ConcreteCommand 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 of Command

1) Write the Command

This interface contains the method to call for executing Receiver code

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

2) Write the Concrete Command

This class defines a binding between a 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 controls that want to use Command

    public interface IFiller
    {
        void Fill();
    }

4) Write the "Invoker"

This class allow 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 of Client

1) Write the receiver(s)

The following Custom Controls (Label, ListBox, ListView) are controls that derive from Label, ListBox and ListView controls.

This controls implement the "Common Receiver" interface for implementing logic of binding

    // 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 call the Invoker that invoke the Command

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

    public partial class Form1 : Form
    {
        private List _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 any problems that anyone has found with it!

About Francesco Carata

.NET Software Developer for BeyondTrust Corporation.

I live in Turin, Italy.