Behavioral Design Pattern for .NET: Part 1

namespace Interpreter
{
class Example
{
static void Main()
{
string roman = "MCMXXVIII";
Context context = new Context(roman);

// Build the 'parse tree'
List<Expression> tree = new List<Expression>();
tree.Add(new ThousandExpression());
tree.Add(new HundredExpression());
tree.Add(new TenExpression());
tree.Add(new OneExpression());

foreach (Expression exp in tree)
{
exp.Interpret(context);
}
Console.WriteLine("{0} = {1}",
roman, context.Output);
Console.ReadKey();
}
}

class Context
{
private string _input;
private int _output;
public Context(string input)
{
this._input = input;
}
public string Input
{
get { return _input; }
set { _input = value; }
}
public int Output
{
get { return _output; }
set { _output = value; }
}
}

//'AbstractExpression' class
abstract class Expression
{
public void Interpret(Context context)
{
if (context.Input.Length == 0)
return;
if (context.Input.StartsWith(Nine()))
{
context.Output += (9 * Multiplier());
context.Input = context.Input.Substring(2);
}
else if (context.Input.StartsWith(Four()))
{
context.Output += (4 * Multiplier());
context.Input = context.Input.Substring(2);
}
else if (context.Input.StartsWith(Five()))
{
context.Output += (5 * Multiplier());
context.Input = context.Input.Substring(1);
}
while (context.Input.StartsWith(One()))
{
context.Output += (1 * Multiplier());
context.Input = context.Input.Substring(1);
}
}

public abstract string One();
public abstract string Four();
public abstract string Five();
public abstract string Nine();
public abstract int Multiplier();
}
class ThousandExpression : Expression
{
public override string One() { return "M"; }
public override string Four() { return " "; }
public override string Five() { return " "; }
public override string Nine() { return " "; }
public override int Multiplier() { return 1000; }
}
class HundredExpression : Expression
{
public override string One() { return "C"; }
public override string Four() { return "CD"; }
public override string Five() { return "D"; }
public override string Nine() { return "CM"; }
public override int Multiplier() { return 100; }
}
class TenExpression : Expression
{
public override string One() { return "X"; }
public override string Four() { return "XL"; }
public override string Five() { return "L"; }
public override string Nine() { return "XC"; }
public override int Multiplier() { return 10; }
}
class OneExpression : Expression
{
public override string One() { return "I"; }
public override string Four() { return "IV"; }
public override string Five() { return "V"; }
public override string Nine() { return "IX"; }
public override int Multiplier() { return 1; }
}
}

4. Iterator:

This pattern is used to provide the way to access the aggregate object without any knowledge of Aggregate structure. The iterator object will maintain the state of the iteration, keeping track of the current item and having a way of identifying what elements are next to be iterated. This allows traversing of lists, trees and other structures in a standard manner.

Model:



UML Diagram:



Example:

using System;
using System.Collections;

namespace Iterator
{
class Example
{
static void Main()
{
// Build a collection
Collection collection = new Collection();
collection[0] = new Item("Item A");
collection[1] = new Item("Item B");
collection[2] = new Item("Item C");
collection[3] = new Item("Item D");
collection[4] = new Item("Item E");
collection[5] = new Item("Item F");
collection[6] = new Item("Item G");
collection[7] = new Item("Item H");
collection[8] = new Item("Item I");

Iterator iterator = new Iterator(collection);
iterator.Step = 2;
Console.WriteLine("Iterating over collection:");
for (Item item = iterator.First();
!iterator.IsDone; item = iterator.Next())
{
Console.WriteLine(item.Name);
}
Console.ReadKey();
}
}

class Item
{
private string _name;
public Item(string name)
{
this._name = name;
}
public string Name
{
get { return _name; }
}
}

//The 'Aggregate' interface
interface IAbstractCollection
{
Iterator CreateIterator();
}

class Collection : IAbstractCollection
{
private ArrayList _items = new ArrayList();
public Iterator CreateIterator()
{
return new Iterator(this);
}
public int Count
{
get { return _items.Count; }
}
public object this[int index]
{
get { return _items[index]; }
set { _items.Add(value); }
}
}

//The 'Iterator' interface
interface IAbstractIterator
{
Item First();
Item Next();
bool IsDone { get; }
Item CurrentItem { get; }
}

class Iterator : IAbstractIterator
{
private Collection _collection;
private int _current = 0;
private int _step = 1;
public Iterator(Collection collection)
{
this._collection = collection;
}
public Item First()
{
_current = 0;
return _collection[_current] as Item;
}
public Item Next()
{
_current += _step;
if (!IsDone)
return _collection[_current] as Item;
else
return null;
}
public int Step
{
get { return _step; }
set { _step = value; }
}
public Item CurrentItem
{
get { return _collection[_current] as Item; }
}
public bool IsDone // Gets whether iteration is complete
{
get { return _current >= _collection.Count; }
}
}
}

5. Mediator:

Mediator design pattern also deals with communication and defines an object to encapsulate that how the set of an object should interact. It promotes many–to–many relationships between interacting peers and thus defines simplifies communication between classes. Here is an example of text box with buttons.

Model:



UML Diagram:



Example:

using System;
using System.Collections.Generic;

namespace Mediator
{
class Example
{
static void Main()
{
Chatroom chatroom = new Chatroom(); // Create chatroom

// Create participants and register them
Participant AlkaYagnik = new Singer("AlkaYagnik");
Participant Abhijeet = new Singer("Abhijeet");
Participant Sunidhi = new Singer("Sunidhi");
Participant Shaan = new Singer("Shaan");
Participant Abhishek = new NonSinger("Abhishek");
chatroom.Register(AlkaYagnik);
chatroom.Register(Abhijeet);
chatroom.Register(Sunidhi);
chatroom.Register(Shaan);
chatroom.Register(Abhishek);

Abhishek.Send("Shaan", "Hi Shaan!");
Abhijeet.Send("Sunidhi", "Can you sing a new Song");
Sunidhi.Send("AlkaYagnik", "My Pleasure");
Abhijeet.Send("Shaan", "Sorry Can't Sing");
Shaan.Send("Abhishek", "Oh! What a Joke");
Console.ReadKey();
}
}

abstract class AbstractChatroom
{
public abstract void Register(Participant participant);
public abstract void Send(
string from, string to, string message);
}

//The 'ConcreteMediator' class
class Chatroom : AbstractChatroom
{
private Dictionary<string, Participant> _participants =
new Dictionary<string, Participant>();
public override void Register(Participant participant)
{
if (!_participants.ContainsValue(participant))
{
_participants[participant.Name] = participant;
}
participant.Chatroom = this;
}
public override void Send(
string from, string to, string message)
{
Participant participant = _participants[to];
if (participant != null)
{
participant.Receive(from, message);
}
}
}

class Participant
{
private Chatroom _chatroom;
private string _name;
public Participant(string name)
{
this._name = name;
}
public string Name
{
get { return _name; }
}
public Chatroom Chatroom
{
set { _chatroom = value; }
get { return _chatroom; }
}
public void Send(string to, string message)
{
_chatroom.Send(_name, to, message);
}

// Receives message from given participant
public virtual void Receive(
string from, string message)
{
Console.WriteLine("{0} to {1}: '{2}'",
from, Name, message);
}
}

class Singer : Participant
{
public Singer(string name)
: base(name)
{ }
public override void Receive(string from, string message)
{
Console.Write("To a Singer: ");
base.Receive(from, message);
}
}

//A 'ConcreteColleague' class
class NonSinger : Participant
{
public NonSinger(string name)
: base(name)
{ }
public override void Receive(string from, string message)
{
Console.Write("To a non-Singer: ");
base.Receive(from, message);
}
}
}

Continue...