Structural Patterns

1. Decorator Pattern
2. Proxy Pattern
3. Bridge Pattern
4. Composite Pattern
5. Flyweight Pattern
6. Adapter Pattern
7. Façade Pattern

Creational Patterns

1. Prototype Pattern
2. Factory Method Pattern
3. Singleton Pattern
4. Abstract Factory Pattern
5. Builder Pattern

Behavioral Patterns

1. Strategy Pattern
2. State Pattern
3. Template Method Pattern
4. Chain of Responsibility Pattern
5. Command Pattern
6. Iterator Pattern
7. Mediator Pattern
8. Observer Pattern
9. Visitor Pattern
10. Interpreter Pattern
11. Memento Pattern

These writings doesn't dwell into the patterns deeply and are written just to give an idea of what they are ( for dummies remember ). The real challenge is identifying the problem rather than the pattern implementations. Although there are as many patterns as discussed, it is not necessary to implement all of them in any project. We’ll have to contemplate on the problem and see what fits in to our project.

Its was fun going through all off these patterns and hope you readers have enjoyed and learnt a few things from it.

P.S You can find the UML class diagrams to all of these patterns from dofactory site

1. Strategy Pattern
2. State Pattern
3. Template Method Pattern
4. Chain of Responsibility Pattern
5. Command Pattern
6. Iterator Pattern
7. Mediator Pattern
8. Observer Pattern
9. Visitor Pattern
10. Interpreter Pattern

You can read about the Structural patterns here.
You can read about the Creational patterns here.

The Memento

The memento pattern deals with capturing an object’s internal state and saving it externally so that the internal state of that object can be restored later. This pattern is usually used in computer games where the state of the game can be saved, and can be started from the same point. The following example illustrates the use of memento pattern.

The components that make up the memento pattern are the Originator, for which the state has to be saved, the Caretaker which is a class that holds the mementos and the Memento which holds the state of the originator.

namespace PatternsConsole
{
    class MementoPatter
    {
        // Originator
        [Serializable]
        class PersonInfo
        {
            public string Name { get; set; }
            public float Salary { get; set; }
 
            public Memento SetMemento()
            {
                var memento = new Memento();
                return memento.Save( this );
            }
 
            public void GetMemento( Memento memento )
            {
                var info = memento.Restore() as PersonInfo;
                if ( info != null )
                {
                    Name = info.Name;
                    Salary = info.Salary;
                }
            }
        }
 
        // Memento
        [Serializable]
        class Memento
        {
            readonly MemoryStream stream = new MemoryStream();
            readonly BinaryFormatter formatter = new BinaryFormatter();
 
            public Memento Save( object obj )
            {
                formatter.Serialize( stream, obj );
                return this;
            }
 
            public object Restore()
            {
                stream.Seek( 0, SeekOrigin.Begin );
                var obj = formatter.Deserialize( stream );
                stream.Close();
                return obj;
            }
        }
 
        // CareTaker
        class CareTaker
        {
            public Memento Memento { get; set; }
        }
 
        private static void Main()
        {
            var personInfo = new PersonInfo
                                 {
                                     Name = "Person1", Salary = 5000
                                 };
 
            // Store internal state
            var careTaker = new CareTaker
                        {
                            Memento = personInfo.SetMemento()
                        };
 
            Console.WriteLine( "Saved State : \nName = {0}, Salary = {1}",
                personInfo.Name, personInfo.Salary );
 
            // Change originator
            personInfo.Name = "Person2";
            personInfo.Salary = 10000;
 
            Console.WriteLine( "Changed Sate : \nName = {0}, Salary = {1}",
                personInfo.Name, personInfo.Salary );
 
            // Restore saved state
            personInfo.GetMemento( careTaker.Memento );
 
            Console.WriteLine( "Restored State : \nName = {0}, Salary = {1}",
                personInfo.Name, personInfo.Salary );
 
            // Output :
            // Saved State :
            // Name = Person1, Salary = 5000
            // Changed Sate :
            // Name = Person2, Salary = 10000
            // Restored State :
            // Name = Person1, Salary = 5000
 
            Console.ReadLine();
        }
    }
}

The memento pattern can be used when we need to save an object’s state and retrieve it later or when we don't want to expose an objects state directly.

1. Strategy Pattern
2. State Pattern
3. Template Method Pattern
4. Chain of Responsibility Pattern
5. Command Pattern
6. Iterator Pattern
7. Mediator Pattern
8. Observer Pattern
9. Visitor Pattern

You can read about the Structural patterns here.
You can read about the Creational patterns here.

The Interpreter

The interpreter pattern deals with interpretation of instructions defined for some specific purpose. The instructions are given as notations which are precise and can be defined in terms of grammar. For the sake of example, the notation in the following example is taken to be “PCCCCPC”. We will have to parse this expression and interpret it.

The components that make up an interpreter pattern are Context which contains information that is used by the interpreter and Element ( Term ) which provides an interface for the structure and the default operation for the interpreter.

Parsing

The interpreter pattern itself does not specify how the objects are to be built. For this purpose parsing is used, in which the the input is matched against a grammar to create the object structure. Once this is created the objects can passed to an interpreter to do its work.

namespace PatternsConsole
{
    class InterpreterPattern
    {
        //Context
        class Context
        {
            public string Input { get; set; }
 
            public Context( string input )
            {
                Input = input;
            }
        }
 
        // Term ( Includes a Parse method to parse the input )
        abstract class Element
        {
            public abstract char GetElement();
            public abstract void Interpret();
 
            public void Parse( Context context )
            {
                if ( context.Input.Length == 0 )
                {
                    return;
                }
 
                foreach (var character in context.Input)
                {
                    if ( character.CompareTo( GetElement() ) ==0 )
                    {
                        Interpret();
                    }
                }
            }
        }
 
        class Producer : Element
        {
            public override char GetElement()
            {
                return 'P';
            }
 
            public override void Interpret()
            {
                Console.WriteLine( "Interpreted Producer" );
            }
        }
 
        class Consumer : Element
        {
            public override char GetElement()
            {
                return 'C';
            }
 
            public override void Interpret()
            {
                Console.WriteLine( "Interpreted Consumer" );
            }
        }
 
        private static void Main()
        {
            var expression = "PCCCCPC";
            var context = new Context( expression );
 
            var tree = new List<Element>
                           {
                               new Producer(), new Consumer()
                           };
 
            Console.WriteLine( "Exression : {0}\n", expression );
 
            foreach ( var element in tree )
            {
                element.Parse( context );
            }
 
            // Output:
            // Exression : PCCCCPC
            //
            // Interpreted Producer
            // Interpreted Producer
            // Interpreted Consumer
            // Interpreted Consumer
            // Interpreted Consumer
            // Interpreted Consumer
            // Interpreted Consumer
 
            Console.Read();
        }
    }
}

This pattern has performance issues and is rarely used. We can use the Interpreter pattern when we have a grammar to be interpreted and the grammar is fairly small and efficiency is not critical.

1. Strategy Pattern
2. State Pattern
3. Template Method Pattern
4. Chain of Responsibility Pattern
5. Command Pattern
6. Iterator Pattern
7. Mediator Pattern
8. Observer Pattern

You can read about the Structural patterns here.
You can read about the Creational patterns here.

The Visitor

Suppose you need to add a new method to a structure of classes, you might end up damaging the design. This is where the visitor pattern comes into play. The visitor pattern deals with performing new operations on all elements of an existing hierarchy of classes without altering the the classes themselves. 

The visitor pattern is mainly made up of 2 components, the classes that make up the hierarchy and the methods that are applied to these classes. These methods are called as visitors. In the following example there is one visitor viz. SalaryVisitor which increments a persons salary.

The following example is based on the example shown in the Dofactory site

namespace PatternsConsole
{
    class VisitorPattern
    {
        // Visitor
        public abstract class Visitor
        {
            public void ReflectiveVisit( Element element )
            {
                var types = new[] { element.GetType() };
                var methodInfo = GetType().GetMethod( "Visit", types );
                if ( methodInfo != null )
                {
                    methodInfo.Invoke( this, new object[] { element } );
                }
            }
        }
 
        // Element
        public abstract class Element
        {
            public abstract void Accept( Visitor visitor );
        }
 
        // ConcreteElement
        class Person : Element
        {
            public string Name { get; set; }
            public string Designation { get; set; }
            public double Salary { get; set; }
 
            public Person( string name, string designation, double salary )
            {
                Name = name;
                Designation = designation;
                Salary = salary;
            }
 
            public override void Accept( Visitor visitor )
            {
                visitor.ReflectiveVisit( this );
            }
        }
 
        // ElementType
        class Developer : Person
        {
            public Developer( string name, double salary ) :
                base( name, "Developer", salary )
            {
            }
        }
 
        // ElementType
        class Tester : Person
        {
            public Tester( string name, double salary ) :
                base( name, "Tester", salary )
            {
            }
        }
 
        // ConcreteVisitor
        class SalaryVisitor : Visitor
        {
            public void Visit( Developer developer )
            {
                VisitMethod( developer );
            }
 
            public void Visit( Tester tester )
            {
                VisitMethod( tester );
            }
 
            private static void VisitMethod( Element element )
            {
                var employee = element as Person;
 
                if ( employee != null )
                {
                    employee.Salary *= 1.50;
                    Console.WriteLine( "{0} {1}'s new income: {2:C}",
                                       employee.GetType().Name, employee.Name,
                                       employee.Salary );
                }
            }
 
 
        }
 
 
        private static void Main()
        {
            // ObjectStructure
            var people = new List<Person>();
 
            var developer = new Developer( "Foo", 1000 );
            var tester = new Tester( "Bar", 1500 );
 
            people.Add( developer );
            people.Add( tester );
 
            foreach ( var person in people )
            {
                person.Accept( new SalaryVisitor() );
            }
 
            //Output: Developer Foo's new income: $1,500.00
            //        Tester Bar's new income: $2,250.00
 
            Console.ReadLine();
        }
    }
}

The visitor pattern provides number of ways to modify the behavior of a hierarchy of classes without modifying the classes. We can use the visitor pattern when we have a hierarchy that is sealed or when there are many operations to perform on it or when we need the flexibility of defining new operations.

In my next post I will be writing about the Interpreter pattern.

1. Strategy Pattern
2. State Pattern
3. Template Method Pattern
4. Chain of Responsibility Pattern
5. Command Pattern
6. Iterator Pattern
7. Mediator Pattern

You can read about the Structural patterns from here.
You can read about the Creational patterns from here.

The Observer pattern deals with providing a relation between objects such that when one objects changes its state, then all the other objects that have a relation to it are notified of the change. This could be achieved by using a single publisher of the state of object and many subscribers who may want the notification for the changed state.

The Observer is usually composed of 2 class viz. a Subject whose state may change periodically and the Observer itself who maybe notified of the change, if they wish to receive the state change information.

The following example is based on the example from Dofactory website

    1 namespace PatternsConsole
    2 {
    3     class ObserverPattern
    4     {
    5         public delegate void ChangeEventHandler<TArg1, TArg2>( TArg1 sender, TArg2 eventArgs );
    6 
    7         public class ChangeEventArgs : EventArgs
    8         {
    9             public string Title { get; set; }
   10             public string Name { get; set; }
   11 
   12             public ChangeEventArgs( string name, string title )
   13             {
   14                 Name = name;
   15                 Title = title;
   16             }
   17 
   18         }
   19 
   20         // Subject
   21         class Blog
   22         {
   23             public string Name { get; private set; }
   24             protected string title;
   25 
   26             // Constructor
   27             public Blog( string name, string title )
   28             {
   29                 Name = name;
   30                 this.title = title;
   31             }
   32 
   33             public event ChangeEventHandler<Blog, ChangeEventArgs> Change;
   34 
   35             public virtual void OnChange( ChangeEventArgs e )
   36             {
   37                 if ( Change != null )
   38                 {
   39                     Change( this, e );
   40                 }
   41             }
   42 
   43             public void Attach( IObserver observer )
   44             {
   45                 Change += observer.Update;
   46             }
   47 
   48             public string Title
   49             {
   50                 set
   51                 {
   52                     title = value;
   53                     OnChange( new ChangeEventArgs( Name, title ) );
   54                     Console.WriteLine( "" );
   55                 }
   56             }
   57         }
   58 
   59         // Observer
   60         interface IObserver
   61         {
   62             void Update( Blog sender, ChangeEventArgs e );
   63         }
   64 
   65         // ConcreteObserver
   66         class Observer : IObserver
   67         {
   68             public string Name { get; private set; }
   69 
   70             public Observer( string name )
   71             {
   72                 Name = name;
   73             }
   74 
   75             public void Update( Blog sender, ChangeEventArgs e )
   76             {
   77                 Console.WriteLine( "Notified {0} of {1}'s " + "post : {2}", Name, e.Name, e.Title );
   78             }
   79         }
   80 
   81         static void Main()
   82         {
   83             var rob = new Blog( "Rob Conery", "Weke Road" );
   84             rob.Attach( new Observer( "Vinay" ) );
   85 
   86             rob.Title = "Subsonic 3";
   87             rob.Title = "Storefront Finis";
   88             rob.Title = "Oxite Refactor";
   89 
   90             //Output : 
   91             // Notified Vinay of Rob Conery's post : Subsonic 3
   92             //
   93             // Notified Vinay of Rob Conery's post : Storefront Finis
   94             //
   95             // Notified Vinay of Rob Conery's post : Oxite Refactor
   96 
   97             Console.ReadLine();
   98         }
   99     }
  100 }

We can use the observer pattern when changes in one object needs to be propagated to other objects or when the object sending the changes does not need to know about the receivers.

In my next post I will be writing about the Visitor Pattern

1. Strategy Pattern
2. State Pattern
3. Template Method Pattern
4. Chain of Responsibility Pattern
5. Command Pattern
6. Iterator Pattern

You can read about the Structural patterns from here.
You can read about the Creational patterns from here.

The Mediator patterns deals with providing a way for objects to communicate with each other without knowing each others identity. The participants involved in this pattern are a Mediator and Colleague. A concrete colleague is used to communicate with other colleagues through its mediator.

    1 namespace PatternsConsole
    2 {
    3     class MediatorPattern
    4     {
    5         public delegate void Callback( string message, string from );
    6 
    7         class Mediator
    8         {
    9             Callback respond;
   10 
   11             public void Register( Callback method )
   12             {
   13                 respond += method;
   14             }
   15 
   16             // Send is implemented as a broadcast
   17             public void Send( string message, string from )
   18             {
   19                 respond( message, from );
   20                 Console.WriteLine();
   21             }
   22         }
   23 
   24         class FooColleague
   25         {
   26             Mediator mediator;
   27             protected string name;
   28 
   29             public FooColleague( Mediator mediator, string name )
   30             {
   31                 this.mediator = mediator;
   32                 this.name = name;
   33                 mediator.Register( Receive );
   34             }
   35 
   36             public virtual void Receive( string message, string from )
   37             {
   38                 if ( !string.Equals( from, name ) )
   39                     Console.WriteLine( name + " received from " + from + ": " + message );
   40             }
   41 
   42             public void Send( string message )
   43             {
   44                 Console.WriteLine( "Send (From " + name + "): ");
   45                 mediator.Send( message, name );
   46             }
   47 
   48         }
   49 
   50         class BarColleague : FooColleague
   51         {
   52             public BarColleague( Mediator mediator, string name )
   53                 : base( mediator, name ) { }
   54 
   55             public override void Receive( string message, string from )
   56             {
   57                 if ( !string.Equals( from, name ) )
   58                     Console.WriteLine( name + " received from " + from + ": " + message );
   59             }
   60         }
   61 
   62         static void Main()
   63         {
   64             var mediator = new Mediator();
   65 
   66             var foo = new FooColleague( mediator, "Foo" );
   67             var bar = new BarColleague( mediator, "Bar" );
   68 
   69             foo.Send( "Hi Bar! This is a greeting through the mediator" );
   70             bar.Send( "Hi Foo! Really!!" );
   71 
   72             // Output :
   73             // Send (From Foo):
   74             // Bar received from Foo: Hi Bar! This is a greeting through the mediator
   75 
   76             // Send (From Bar):
   77             // Foo received from Bar: Hi Foo! Really!!
   78 
   79             Console.ReadLine();
   80         }
   81     }
   82 }

We can use the mediator pattern when we have objects are communicating in a complex way or when we have to protect the identities of objects who are communicating.

In my next post I will be writing about the Observer Pattern.

1. Strategy Pattern
2. State Pattern
3. Template Method Pattern
4. Chain of Responsibility Pattern
5. Command Pattern

You can read about the Structural patterns from here.
You can read about the Creational patterns from here.

The Iterator patterns deals with providing an easy way to access elements of a collection sequentially. To implement an iterator in C#, we can implement either IEnumerator or the IEnumerable interfaces.  IEnumerator interface has 2 methods GetEnumerator and Reset which we would have to implement and an Current object which is used to maintain the position. The easier way of doing it is to implement the IEnumerable interface and implement the GetEnumerator method for it. In the following example I am using the yield return statement in the GetEnumerator method which saves us from maintaining the state.

    1 namespace PatternsConsole
    2 {
    3     class IteratorPattern
    4     {
    5         class Collection<T> : IEnumerable<T>
    6         {
    7             private readonly List<T> items = new List<T>();
    8 
    9             public void Add( T t )
   10             {
   11                 items.Add( t );
   12             }
   13 
   14             public IEnumerator<T> GetEnumerator()
   15             {
   16                 for ( int i = 0; i < Count; i++ )
   17                 {
   18                     yield return items[i];
   19                 }
   20             }
   21 
   22             public int Count
   23             {
   24                 get { return items.Count; }
   25             }
   26 
   27             IEnumerator IEnumerable.GetEnumerator()
   28             {
   29                 return GetEnumerator();
   30             }
   31         }
   32 
   33         class Person
   34         {
   35             public string Name { get; private set; }
   36 
   37             public Person( string name )
   38             {
   39                 Name = name;
   40             }
   41         }
   42 
   43         private static void Main()
   44         {
   45             var people = new Collection<Person>
   46                              {
   47                                  new Person("Person 1"),
   48                                  new Person("Person 2"),
   49                                  new Person("Person 3"),
   50                                  new Person("Person 4"),
   51                                  new Person("Person 5")
   52                              };
   53 
   54             foreach ( var person in people )
   55             {
   56                 Console.WriteLine( person.Name );
   57             }
   58 
   59             // Output :
   60             // Person 1
   61             // Person 2
   62             // Person 3
   63             // Person 4
   64             // Person 5
   65 
   66             Console.ReadLine();
   67         } 
   68     }
   69 }

We can implement our iterator when we want iterations over a collection or we have many ways of traversing it or when there are many collections for traversing.

In my next post I will be writing about the Mediator Pattern.

1. Strategy Pattern
2. State Pattern
3. Template Method Pattern
4. Chain of Responsibility Pattern

You can read about the Structural patterns from here.
You can read about the Creational patterns from here.

The Command pattern deals with segregation of the client that requested an operation and the object that can perform that operation. The command pattern can support sending requests to different receivers, queuing of requests, redo and undo functionality.

    1 namespace PatternsConsole
    2 {
    3     public class CommandPattern
    4     {
    5         // Command
    6         interface ICommand
    7         {
    8             void Execute();
    9         }
   10 
   11         // ConcreteCommand
   12         class AddCommand : ICommand
   13         {
   14             public Item Itm { get; set; }
   15             public Category Cat { get; set; }
   16 
   17             public void Execute()
   18             {
   19                 Itm.Add( Cat );
   20                 Cat.Add( Itm );
   21             }
   22         }
   23 
   24         // ConcreteCommand
   25         class DeleteCommand : ICommand
   26         {
   27             public Item Itm { get; set; }
   28             public Category Cat { get; set; }
   29 
   30             public void Execute()
   31             {
   32                 Itm.Delete( Cat );
   33                 Cat.Delete( Itm );
   34             }
   35         }
   36 
   37         // Invoker
   38         class ItemManager
   39         {
   40             public ICommand Command { set; get; }
   41 
   42             public void Process()
   43             {
   44                 Command.Execute();
   45             }
   46         }
   47 
   48         // Receiver
   49         class Item
   50         {
   51 
   52             private IDictionary<string, Category> categories;
   53 
   54             public string Desc { get; set; }
   55 
   56             public Item( string itemName )
   57             {
   58                 Desc = itemName;
   59                 categories = new Dictionary<string, Category>();
   60             }
   61 
   62             public void Add( Category cat )
   63             {
   64                 categories.Add( cat.Desc, cat );
   65             }
   66 
   67             public void Delete( Category cat )
   68             {
   69                 categories.Remove( cat.Desc );
   70             }
   71 
   72         }
   73 
   74         // Receiver
   75         class Category
   76         {
   77 
   78             private IDictionary<string, Item> items;
   79 
   80             public string Desc { get; set; }
   81 
   82             public Category( string catName )
   83             {
   84                 Desc = catName;
   85                 items = new Dictionary<string, Item>();
   86             }
   87 
   88             public void Add( Item item )
   89             {
   90                 items.Add( item.Desc, item );
   91                 Console.WriteLine( "Item '" + item.Desc + "' has been added to the '"
   92                     + Desc + "' Category " );
   93             }
   94 
   95             public void Delete( Item item )
   96             {
   97                 items.Remove( item.Desc );
   98                 Console.WriteLine( "Item '" + item.Desc
   99                     + "' has been deleted from the '" + Desc + "' Category " );
  100             }
  101         }
  102 
  103         public static void Main()
  104         {
  105             // Create Receiver objects
  106             Item DVD = new Item( "The Fountain" );
  107             Category catDVD = new Category( "DVD" );
  108 
  109             // create the command object
  110             ICommand command = new AddCommand { Itm = DVD, Cat = catDVD };
  111 
  112             // create the invoker
  113             ItemManager manager = new ItemManager { Command = command };
  114             manager.Process();
  115 
  116             // Add an item to the CD category
  117             DVD = new Item( "The Wrestler" );
  118             catDVD = new Category( "DVD" );
  119             command = new AddCommand { Itm = DVD, Cat = catDVD };
  120             manager.Command = command;
  121             manager.Process();
  122 
  123             // Add an item to the Old Releases category
  124             DVD = new Item( "Pi" );
  125             catDVD = new Category( "Old Releases" );
  126             command = new AddCommand { Itm = DVD, Cat = catDVD };
  127             manager.Command = command;
  128             manager.Process();
  129 
  130             // Delete an item from the Old Releases category
  131             command = new DeleteCommand { Itm = DVD, Cat = catDVD };
  132             manager.Command = command;
  133             manager.Process();
  134 
  135             // Output:
  136             // Item 'The Fountain' has been added to the 'DVD' Category
  137             // Item 'The Wrestler' has been added to the 'DVD' Category
  138             // Item 'Pi' has been added to the 'Old Releases' Category
  139             // Item 'Pi' has been deleted from the 'Old Releases' Category
  140 
  141             Console.ReadLine();
  142         }
  143     }
  144 }

We can use the command pattern when we have different receivers and handle each in a different way or we want to specify and execute commands at different times or when we want to support undo functionality.

In my next post I will be writing about the Iterator pattern.

1. Strategy Pattern
2. State Pattern
3. Template Method Pattern

You can read about the Structural patterns from here.
You can read about the Creational patterns from here.

The Chain of Responsibility pattern deals with a list of Handler objects that limits based on the requests that they can deal with. If one object can not handle a request, then the request is passed to the next object in the chain which means by the end of the chain there can be an expected behavior or an exception. 

The following example is based on the example provided in the DoFactory website

    1 namespace PatternsConsole
    2 {
    3     class ChainOfResponsibilityPattern
    4     {
    5         // Delegate for withdrawal requests
    6         public delegate void WithdrawHandler<T, E>( T sender, E eventArgs );
    7 
    8         public class WithdrawArgs : EventArgs
    9         {
   10             public double Amount { get; set; }
   11             public int AccountNumber { get; set; }
   12         }
   13 
   14         // "Handler"
   15         abstract class Approver
   16         {
   17             public event WithdrawHandler<Approver, WithdrawArgs> Withdraw;
   18             public Approver Successor { protected get; set; }
   19 
   20             // Invoing the event
   21             public virtual void OnWithdraw( WithdrawArgs e )
   22             {
   23                 if ( Withdraw != null )
   24                 {
   25                     Withdraw( this, e );
   26                 }
   27             }
   28 
   29             public void ProcessRequest( WithDrawal withDrawal )
   30             {
   31                 OnWithdraw( new WithdrawArgs
   32                                 {
   33                                     AccountNumber = withDrawal.AccountNumber,
   34                                     Amount = withDrawal.Amount
   35                                 } );
   36             }
   37         }
   38 
   39         // "ConcreteHandler"
   40         class Clerk : Approver
   41         {
   42             public Clerk()
   43             {
   44                 // Hook up delegate to event
   45                 Withdraw += ProcessByClerk;
   46             }
   47 
   48             public void ProcessByClerk( Approver approver, WithdrawArgs e )
   49             {
   50                 if ( e.Amount < 10000 )
   51                 {
   52                     Console.WriteLine( "{0} approved withdrawal for account : {1}",
   53                         GetType().Name, e.AccountNumber );
   54                 }
   55                 else if ( Successor != null )
   56                 {
   57                     Successor.OnWithdraw( e );
   58                 }
   59             }
   60         }
   61 
   62         // "ConcreteHandler"
   63         class Officer : Approver
   64         {
   65             public Officer()
   66             {
   67                 // Hook up delegate to event
   68                 Withdraw += ProcessByOfficer;
   69             }
   70 
   71             public void ProcessByOfficer( Approver approver,
   72                 WithdrawArgs e )
   73             {
   74                 if ( e.Amount < 100000 )
   75                 {
   76                     Console.WriteLine( "{0} approved withdrawal for account : {1}",
   77                         GetType().Name, e.AccountNumber );
   78                 }
   79                 else if ( Successor != null )
   80                 {
   81                     Successor.OnWithdraw( e );
   82                 }
   83             }
   84         }
   85 
   86         // "ConcreteHandler"
   87         class Manager : Approver
   88         {
   89             public Manager()
   90             {
   91                 // Hook up delegate to event
   92                 Withdraw += ProcessByManager;
   93             }
   94 
   95             public void ProcessByManager( Approver approver, WithdrawArgs e )
   96             {
   97                 if ( e.Amount < 1000000 )
   98                 {
   99                     Console.WriteLine( "{0} approved withdrawal for account : {1}",
  100                         GetType().Name, e.AccountNumber );
  101                 }
  102                 else
  103                 {
  104                     Console.WriteLine( "Cannot be approved" );
  105                 }
  106             }
  107         }
  108 
  109         class WithDrawal
  110         {
  111             public double Amount { get; set; }
  112             public int AccountNumber { get; set; }
  113         }
  114 
  115         static void Main()
  116         {
  117             // Setup Chain of Responsibility
  118             var clerkAprover = new Clerk();
  119             var officerApprover = new Officer();
  120             var managerApprover = new Manager();
  121 
  122             clerkAprover.Successor = officerApprover;
  123             officerApprover.Successor = managerApprover;
  124 
  125             var withDrawal = new WithDrawal { AccountNumber = 1234, Amount = 1001 };
  126             clerkAprover.ProcessRequest( withDrawal );
  127 
  128             withDrawal = new WithDrawal { AccountNumber = 2345, Amount = 10000 };
  129             clerkAprover.ProcessRequest( withDrawal );
  130 
  131             withDrawal = new WithDrawal { AccountNumber = 3456, Amount = 100000 };
  132             clerkAprover.ProcessRequest( withDrawal );
  133 
  134             //Output : Clerk approved withdrawal for account : 1234
  135             //         Officer approved withdrawal for account : 2345
  136             //         Manager approved withdrawal for account : 3456
  137 
  138             Console.Read();
  139         }
  140     }
  141 }

As seen in the example there are 3 approvers for withdrawal as  a chain. The request is passed to the clerk and based on the amount the responsibility is transferred to the successive approver in the chain. We can use the chain of responsibility patter when we have more than one handler for a single request or we have a set of handler that vary dynamically.

In my next post I will be writing about the Command pattern.

1. Strategy Pattern
2. State Pattern

You can read about the Structural patterns from here.
You can read about the Creational patterns from here.

The template method pattern deals with enabling algorithms to defer certain steps. It doesn't change the structure of the algorithm but a few of their operations are handled elsewhere.

    1 namespace PatternsConsole
    2 {
    3     class TemplatePattern
    4     {
    5         //Interface for operations
    6         interface ISortStrategy
    7         {
    8             void Sort();
    9         }
   10 
   11         //Algorithm with template method
   12         class Algorithm
   13         {
   14             public void TemplateMethod(ISortStrategy sortStrategy)
   15             {
   16                 sortStrategy.Sort();
   17             }
   18         }
   19 
   20         //Concrete Class
   21         class SortByAge : ISortStrategy
   22         {
   23             public void Sort()
   24             {
   25                 PersonList.Sort( ( p1, p2 ) => p1.Age.CompareTo( p2.Age ) );
   26                 Console.WriteLine("Sort By Age");
   27                 foreach ( var person in PersonList )
   28                 {
   29                     Console.WriteLine( "Name : " + person.Name + " Age :" + person.Age);
   30                 }
   31             }
   32         }
   33 
   34         //Concrete Class
   35         class SortByName : ISortStrategy
   36         {
   37             public void Sort()
   38             {
   39                 PersonList.Sort( ( p1, p2 ) => p1.Name.CompareTo( p2.Name ) );
   40                 Console.WriteLine( "\nSort By Name" );
   41                 foreach ( var person in PersonList )
   42                 {
   43                     Console.WriteLine( "Name : " + person.Name + " Age :" + person.Age );
   44                 }
   45             }
   46         }
   47 
   48         class Person
   49         {
   50             public string Name { get; set; }
   51             public int Age { get; set; }
   52         }
   53 
   54         private static List<Person> PersonList;
   55 
   56         private static void Main()
   57         {
   58             PersonList = new List<Person>
   59                               {
   60                                   new Person {Name = "Person1", Age = 25},
   61                                   new Person {Name = "Person3", Age = 26},
   62                                   new Person {Name = "Person4", Age = 20},
   63                                   new Person {Name = "Person2", Age = 28}
   64                               };
   65 
   66             var sortAlgo = new Algorithm();
   67 
   68             sortAlgo.TemplateMethod( new SortByAge() );
   69             //Output :  Sort By Age
   70             //          Name : Person4 Age :20
   71             //          Name : Person1 Age :25
   72             //          Name : Person3 Age :26
   73             //          Name : Person2 Age :28
   74 
   75             sortAlgo.TemplateMethod( new SortByName() );
   76             //Output :  Sort By Name 
   77             //          Name : Person1 Age :25
   78             //          Name : Person2 Age :28
   79             //          Name : Person3 Age :26
   80             //          Name : Person4 Age :20
   81 
   82             Console.Read();
   83         }
   84     }
   85 }

We can use the template method pattern when common behavior can be outside the algorithm and the the behavior itself varies based on the type of the subclass.

In my next post I will be writing about the Chain of Responsibility pattern.