Click here to Skip to main content
Click here to Skip to main content

Behavioral Patterns: Implementing the Command Pattern in C#

, 23 Aug 2007 CPOL
Rate this:
Please Sign up or sign in to vote.
Writing the Command Pattern with C# (real example).

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.
  2. This interface contains the method to call for executing the Receiver code:

    // Command
    public interface ICommand    
    {
        void Execute();
    }
  3. Write the Concrete Command.
  4. 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();
        }
    }
  5. Write the "Common Receiver".
  6. 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();
    }
  7. Write the "Invoker".
  8. 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).
  2. 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()));
            }
        }
    }
  3. Write the Client.
  4. 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<ifiller />();
            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!

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Francesco Carata
Web Developer
Italy Italy
No Biography provided

Comments and Discussions

 
GeneralMy vote of 1 Pinmemberkirubaraja12-Sep-12 1:18 
GeneralMy vote of 3 PinmemberDimaPursanov18-Apr-11 22:15 
QuestionWhat problem do your code solve? PinmemberVerifier26-Aug-08 9:54 
GeneralInteresting Idea Pinmembermerlin98124-Aug-07 5:27 
QuestionInvoker? Pinmemberdejavudesi23-Aug-07 4:50 
AnswerRe: Invoker? PinmemberFrancesco Carata23-Aug-07 21:18 
QuestionSo what is Command Pattern? Pinmemberzhi-chen13-Jul-07 7:23 
AnswerRe: So what is Command Pattern? PinmemberFrancesco Carata14-Jul-07 7:26 
AnswerRe: So what is Command Pattern? Pinmembermike griggs1-Aug-07 23:51 
GeneralRe: So what is Command Pattern? PinmemberFrancesco Carata1-Aug-07 23:56 
Generalmultiple casts PinmemberMeile10-Jul-07 2:14 
GeneralRe: multiple casts PinmemberFrancesco Carata10-Jul-07 2:26 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web03 | 2.8.141223.1 | Last Updated 24 Aug 2007
Article Copyright 2007 by Francesco Carata
Everything else Copyright © CodeProject, 1999-2014
Layout: fixed | fluid