C# Iterator Design Pattern

C# Iterator Design Pattern tutorial

Advertisements

Link To source Code

This article will demonstrate the idea behind the Iteration pattern and simple implementation of it. The idea of the iterator pattern is to take the responsibility of accessing and passing trough the objects of the collection and put it in the iterator object. In C# Iterator pattern can be implemented simply using IEnumerable interface. Implementation of IEnumerable interface allows you to syntax sugar like foreach loop. This leads to the topic of collections.

In this post i’ll cover in more depth how Iterator is implemented by compiler. 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. The abstraction provided by the iterator pattern allows you to modify the collection implementation without making any changes outside of collection.

This time you will see generic example of implementation, this is because i want to focus on the pattern functionality instead of  using techniques you may not know.

UML diagram

l6

 

Let’s start by creating interface for IIterator. Iterator Interface defines an interface for accessing and traversing elements.

interface IIterator
{
  int FirstItem { get; }
  int NextItem { get; }
  int CurrentItem { get; }
  bool IsDone { get; }
}

This will simulate looping through the objects of collection.

Implementation of this interface will make the iteration process clearer.  Implementation of this patter can be more difficult to understand because each Class is referring to the next one. Iterator need to have a reference to the IAggregate to create instance of it in the constructor, and use it later for returning its values.

Return value is set to int in Aggregate for this example.

class Iterator : IIterator
{
  IAggregate aggregate = null;

  //We need an index to track the iteration process
  int currentIndex = 0;

  public Iterator(IAggregate newAggregate)
  {
    aggregate = newAggregate;
  }
  //Returns item with index 0
  public int FirstItem
  {
    get
    {
      currentIndex = 0;
      return aggregate[currentIndex];
    }
  }

  //Returns next item
  public int NextItem
  {
   get
   {
     currentIndex += 1;

     if (IsDone == false)
     {
       return aggregate[currentIndex];
     }
     else
     {
       return -1;
     }
    }
  }

  public int CurrentItem
  {
    get
    {
       return aggregate[currentIndex];
    }
  }
//This method will give us feedabck when iteration ended
  public bool IsDone
  {
     get
     {
       if (currentIndex < aggregate.Count)
       {
          return false;
       }
       return true;
     }
   }
 }

 

Next interface to create is IAggregate.  One of the methods will return IIterator interface object.

 interface IAggregate
 {
   IIterator GetIterator();
   //This will handle manipulation of objects in the array
   int this[int itemIndex] { set; get; }
   int Count { get; }
 }

Implementation of this interface in Aggregate Class will be used as a place to create a list of an object that we will iterate through.

class Aggregate : IAggregate
{
  //Here is why Iterator methods returns integers;
  List<int> values = null;

  public Aggregate()
  {
    values = new List<int>();
  }

  public IIterator GetIterator()
  {
    //Iterator constructor takes IAggregate as parameter
    return new Iterator(this);
  }

  public int this[int itemIndex]
  {
    get
    {
      if (itemIndex < values.Count)
       {
           return values[itemIndex];
       }
      else
      {
        return -1;
      }
    }
    set
    {
        values.Add(value);
    }
   }

   public int Count
   {
     get
     {
       return values.Count;
     }
   }
 }

 

Last step is to create a Client that will create instance of Aggregate Class and Use Iterator to loop throug collection items.

class Program
{
  static void Main(string[] args)
  {
    Aggregate aggr = new Aggregate();

    aggr[0] = 7;
    aggr[1] = 8;
    aggr[2] = 9;
    aggr[3] = 89;

  IIterator iter = aggr.GetIterator();
  //Loops until isDone==false
    for (int i = iter.FirstItem; iter.IsDone == false; i = iter.NextItem)
    {
       Console.WriteLine(i.ToString());
    }
  Console.ReadLine();
  }
}

To conclude, Iteration pattern provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation. In C# this can be handled just by implementing IEnumerable interface. I hope you learned something new today. In Next article I’ll cover one last design patterns. Stay Awesome!

PS: Thanks for all Up votes On Reddit.com! I can’t reply to  comments, because of shadow-ban 😀

C# Composite Pattern

C# Composite Pattern tutorial

Link to source code for this post

Composite pattern is used to create a tree structure, where every item of the structure implements the same interface. Therefore methods declared in interface can performed on every item in the structure. This pattern classifies each element in the tree as a composite or a leaf. A composite means that there can be other elements below it, whereas a leaf cannot have any elements below it.

To demonstrate the implementation of this pattern I’ll use an example of inventory where player can have Items( leafs ) and Backpack ( composite ). Player will be able to loop through all items in inventory and return the name of the items.

 

UML diagram

l5

 

First thing to create is the Component interface that will be inherited by all items in the structure.

public interface IInventory
{
  string Name { get; set; }
  void PrintName();
}

It acts as the base class for all the objects within the hierarchy. I’m creating name property for all items. you can find more about properties on my recent post about it.

Next thing is the implementation of the interface in Backpack Class that will be used to store Items or other Backpacks. To do this You need method for adding and removing items. Objects will be stored in generic List.


public class Backpack : IInventory, IEnumerable<IInventory>
{
  private List<IInventory> _subordinates = new List<IInventory>();

  public string Name { get; set; }

  public void AddSubordinate(IInventory subordinate)
  {
    _subordinates.Add(subordinate);
  }

  public void RemoveSubordinate(IInventory subordinate)
  {
    _subordinates.Remove(subordinate);
  }

  public IInventory GetSubordinate(int index)
  {
    return _subordinates[index];
  }

  public void PrintName()
  {
    Console.WriteLine(Name);
  }
  public IEnumerator<IInventory> GetEnumerator()
  {
    foreach (IInventory subordinate in _subordinates)
    {
      yield return subordinate;
    }
  }

  IEnumerator IEnumerable.GetEnumerator()
  {
    return GetEnumerator();
  }
}

Next thing is  to create an object Class, this class will be used to represent single item in inventory.

 public class Item : IInventory
{
  public string Name { get; set; }

  public void PrintName()
  {
    Console.WriteLine(Name);
  }
}

Last thing to do is the Client site that will create the structure based on the created Interface and Classes.

 class Program
{
  static void Main(string[] args)
  {
    Backpack inventory = new Backpack { Name = "Inventory" };
    Backpack backpack = new Backpack { Name = "Backpack" };

    inventory.AddSubordinate(backpack);
    inventory.AddSubordinate(new Item { Name = "Sword"});
    inventory.AddSubordinate(new Item { Name = "Armor" });

    backpack.AddSubordinate(new Item { Name = "Shield" });

    Console.WriteLine("List of items in inventory");

      foreach (IInventory element in inventory)
      {
         element.PrintName();
      }
    Console.ReadKey();
   }
 }

In this example Backpack class is used to create rot object for the tree. Where new backpack and few new items are added. Thanks to implementation of IEnumerable interface we can loop through items in the backpack class.

To conclude, Composite pattern compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly. I hope you find this tutorial useful. If you have any questions feel free to ask in comments. In next part I’ll cover yet another design pattern. Stay Awesome!

C# Proxy Design Pattern

C# Proxy Design Pattern

Link To source Code for this article

This pattern is used to restrict access to Real Subject Class by creating Proxy gate, that implements the same interface as Real Subject and extends the interface methods to perform additional operations before executing method in Real Subject. Proxy Design Pattern acts as main point of contact for the resources that should not be available directly to the client code.

To demonstrate the implementation of this pattern I’ll use an example of in game equipment where access to the items is restricted by Proxy.

 

UML diagram:

l4

 

 

 

 

 

 

 

 

 

 

Let’s begin by creating Interface that will be implemented by both Classes.

public interface IEquipment
{
  string GetData();
}

Nothing fancy, just to demonstrate the idea behind the pattern. Subject Interface provides and interface that both actual class and proxy class will implement. this way the proxy can easily be used as substitute for the real subject.

Next step is to create Equipment Class that is our Real Subject

 public class Equipment : IEquipment
{
  string itemName;
  public int intemId;
  //Constructor
  public Equipment()
  {
    itemName = "Iron Sword";
    intemId = 4;
  }

  public string GetData()
  {
    return (itemName + " ID: "+ intemId.ToString());
  }
}

This class also contains one item with name and ID, which is represented just by fields, in more real example it would be list of Items. We assign new values when instance of this class is created.

Now we need to create Proxy that will have a reference to the Real Subject  and will modify the GetData() method to restrict the access.

public class EquipmentProxy : IEquipment
{
  Equipment client = new Equipment();

  public string GetData()
  {
     if (client.intemId == 4)
         return client.GetData();

     else
         return "Item is not in inventory";
   }
 }

Id is hard typed and set to 4 just for the example. The application will use this class and this class will internally take care of talking to the RealSubject and get the data to the local application.

Last part of the application is Client site, where Instance of the proxy is created and GetData() method is called.

class Program
{
  static void Main(string[] args)
  {
     EquipmentProxy proxy = new EquipmentProxy();
     Console.WriteLine("Data from Proxy: "+ proxy.GetData());

     Console.ReadKey();
  }
}

 

To conclude, The proxy design pattern is used to provide a surrogate object, which references to other object. Proxy pattern involves a class, called proxy class, which represents functionality of another class. I hope you learned something new, in next article I’ll cover another design pattern. Stay Awesome!

 

 

 

C# Factory Pattern

C# Factory Pattern tutorial

This is one of the creational patterns. Factory is used to create an object from instance of another class.  In Factory pattern, we create object without exposing the creation logic. This helps to deal with large and more complex programs. In this pattern, an interface is used for creating an object, but let subclass decide which class to instantiate. Creation process is done in run time.

1245px-factory_1b-svg

I’ll use example from typical video game where Enemy object is created, and its type is based on random number. Object is created in run time.

 

 

 

 

UML diagram:

l3

 

First let’s create Interface that will be shared between all enemies that can be crated with Factory. This will be used by client.

public interface IFactory
{
  void Demage(int dmg);
}

 

Now we need to create Classes that will inherit this interface. In my example this will be enemyType1 and 2.

public class EnemyType1 : IFactory
{
  int _health=100;
  public void Demage(int dmg)
  {
     _health -= dmg;
     Console.WriteLine("EnemyType1 health:" + _health.ToString());
  }
}

public class EnemyType2 : IFactory
{
  int _health = 200;
  public void Demage(int dmg)
  {
     _health -= dmg;
     Console.WriteLine("EnemyType2 health:" + _health.ToString());
  }
}

Both classes also contains health count, just to make it more interesting.

Next we need to create the Interface for factory itself.

public abstract class EnemyFactory
{
  public abstract IFactory InstantiateEnemy(int type);
}

As a return type we use interface IFactory, this way we can return any object that inherits from it.

In The factory Class we override the method with switch statement that will return the objects based on the input number.

public class InstantiateEnemyFactory : EnemyFactory
{
  public override IFactory InstantiateEnemy(int type)
  {
     switch (type)
     {
        case 1:
            return new EnemyType1();
        case 2:
           return new EnemyType2();
         default:
           throw new ApplicationException(string.Format("Wrong number"));
     }
  }
}

 

Last step is to create client that will use the factory class.

class Program
{
  static void Main(string[] args)
  {
  //random number
  int type = new Random().Next(1, 1000)% 2 + 1;
  //Instance of the class
  EnemyFactory factory = new InstantiateEnemyFactory();

  IFactory newEnemy= factory.InstantiateEnemy(type);
  newEnemy.Demage(20);

  type = new Random().Next(1, 2000)%2 + 1;

  IFactory newEnemy2 = factory.InstantiateEnemy(type);
  newEnemy2.Demage(20);

  Console.ReadKey();

  }
}

Numbers don’t have to be random. I’m using random numbers to demonstrate the example. I real world we would rather create a list of enemies rather than choosing name for each of them.

This patters is very simple and effective. This makes it commonly used across all languages. To conclude, Factory defines an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses. I hope you found it useful and you will implement this pattern to your next project. Stay Awesome!

Link to full source code

 

 

 

 

 

C# Observer Design Pattern

C# Observer Design Pattern

This is very popular behavioural pattern. As the name suggests, the Observer Pattern is a pattern where the important objects are “observed” or watched for changes. This pattern is useful when we want to pass message from one object(subject) to multiple objects(observers).  Observers are not related with each other, but every one of them needs to inherit from IObserver interface.

To demonstrate the implementation of the pattern I’ll use an example with Enemy Class sending message to Subscriber when health is changed. Message will be sent to UserInterface and DifferentUnit Classes.

UML diagram:

l2

 

 

First we need to create IObserver Interface that will be used as a base for Concrete Classes.

public interface IObserver
{
  void Update();
}

Simple as that. Next we need to write implementation of this Interface in  Concrete Classes.

public class UserInteface : IObserver
{
  public void Update()
  {
     Console.WriteLine("Interface Updated");
  }
}
public class DifferentUnit : IObserver
{
  public void Update()
  {
     Console.WriteLine("Relation Updated");
  }
}

In this example we don’t need any extra parameters, just implementation of an Update() method.

Now lets move our attention to Subject site.  Subject interface need methods for subscribing and unsubsribing Observers. And method for Notifing the Listeners about the cahnge.

interface IEnemy
{
  void Subscribe(IObserver observer);
  void Unsubscribe(IObserver observer);
  void Notify();
}

 

In Enemy class I’m using may techniques like Properties, Generic List, Lambda Expressin, click on links if you want to learn more about them.

Enemy class inherits from IEnemy interface. It contains generic list of Observers, using interface as an object allows you to store objects of any class that inherits form IObserver interface. Notify() is called whenever health value is changing. Subscribe and Unsubscribe methods are using methods from List library

public class Enemy : IEnemy
{
  private List<IObserver> observers = new List<IObserver>();
  private int _health=10;
  public int Health
  {
    get { return _health; }
    set
    {
      _health = value;
      Notify();
    }
  }

  public void Notify()
  {
     observers.ForEach(x => x.Update());
  }

  public void Subscribe(IObserver observer)
  {
     observers.Add(observer);
  }

  public void Unsubscribe(IObserver observer)
  {
     observers.Remove(observer);
  }
}

Last part of implementation contains Client Class that will be used to create instances of Enemy Class and to display the final output.

class Program
{
  static void Main(string[] args)
  {
  Enemy subject = new Enemy();

  IObserver observer1 = new UserInteface();
  subject.Subscribe(observer1);

  subject.Subscribe(new DifferentUnit());
  subject.Health++;
  Console.WriteLine("--------------------");
  subject.Unsubscribe(observer1);
  subject.Health--;
  Console.ReadLine();
  }
}

Here you can see that two Concrete Classes are added to the Observer List by calling subscription method. Changing health value causes Notify() method that prints the values to the console. Later I unsubscribe one item from Observer and I’m changing the value once again, this time by decrementing the health value.

To conclude, Observer pattern defines a one-to-many dependency between objects so that when one object changes state, all its dependants are notified and updated automatically.

Link to source code for this pattern.

In Unity Engine this massaging system can be created with List of Events. You can find how to build messaging system in Unity in my article here. In my next article You will learn how to implement another exciting design patter. Stay Awesome!

 

 

 

 

C# Builder Design Pattern

C# Builder Design Pattern

In this article you will learn how to implement builder design pattern. This is one of structural patterns. You can use it when you need to have control over how complex objects would be created at runtime. This pattern gives you step by step approach on the object creation process. This is useful if you want to reuse the same creation process to build different representations. I’ll demonstrate the implementation of the pattern on simplified  real word example. And I’ll explain it step by step.

To show you the pattern I created the system of creating two types of enemies, each process of creation takes multiple steps, that’s good opportunity for using builder.

UML diagram:

l1

 

  1. IEnemy – Builder interface
  2. EnemyTypeA and EnemyTypeB– Concrete Builder
  3. Enemy– Product
  4. EnemyCreator – Director

 

So first let’s create an enemy Class, we will instantiate objects of this class in Concrete Builders.

class Enemy
{
  public string model;
  public string behaviour;
  public string components;
}

Here we have three public variables just to  demonstrate the example.

Next we need Builder interface that will contains all the method that will be implemented by Enemies Classes. And we have Get Enemy method that will return the Enemy Class instance after competing the construction process.

interface IEnemy
{
  void SelectModel();
  void SelectBehaviour();
  void AddComponents();

  Enemy GetEnemy();
}

 

Next step is to create Classes based on the interface. Each class will have unique implementation of the interface methods.  In order to get access to Enemy Class properties we need to create instance of this Class.

class EnemyTypeA : IEnemy
{
  Enemy enemy = new Enemy();
  public void AddComponents()
  {
    enemy.components="Components Added";
  }

  public void SelectBehaviour()
  {
    enemy.behaviour= "Behaviour Type A Selected";
  }

  public void SelectModel()
  {
     enemy.model = "Body Type A Selected";
  }
  public Enemy GetEnemy()
  {
     return enemy;
  }
}
//EnemyTypeB
class EnemyTypeB : IEnemy
{
  Enemy enemy = new Enemy();
  public void AddComponents()
  {
     enemy.components = "Components Added";
  }

  public void SelectBehaviour()
  {
     enemy.behaviour = "Behaviour Type B Selected";
  }

  public void SelectModel()
  {
     enemy.model = "Body Type B Selected";
  }
  public Enemy GetEnemy()
  {
     return enemy;
  }
}

 

Now it’s time for creating Director that will contain the logic behind creating new enemy. In Class constructor we pass IEnemy interface, this way we can pass any Class that inhirates form this interface.

class EnemyCreator
{
  private readonly IEnemy enemyBuilder;

  public EnemyCreator( IEnemy enemyType)
  {
     enemyBuilder = enemyType;
  }
  public Enemy ConstructEnemy()
  {
    enemyBuilder.SelectBehaviour();
    enemyBuilder.SelectModel();
    enemyBuilder.AddComponents();

    return enemyBuilder.GetEnemy();
  }
}

Construct Enemy method return instance of Enemy Class with new properties.

Last thing to complete the implementation is to create Client Class that will  create instances of each enemy type.

class Program
{
  static void Main(string[] args)
  {
  var enemyCreator = new EnemyCreator(new EnemyTypeA());
  var enemy = enemyCreator.ConstructEnemy();
  enemy.ShowInfo();
  Console.WriteLine("_______________________");
  enemyCreator = new EnemyCreator(new EnemyTypeB());
  enemy = enemyCreator.ConstructEnemy();
  enemy.ShowInfo();
  Console.ReadLine();
  }
}

 

To conclude, Builder pattern Separates the construction of a complex object from its representation so that the same construction process can create different representations. I hope you found it useful and you will implement this pattern to you programs. I next article I’ll cover another exciting design patter. Stay Awesome!

Link To Full Source Code 

 

 

 

 

 

 

C# Adapter Design Pattern

C# Adapter Design Pattern

Next pattern on my list is called adapter. This is another type of structural pattern. Adapter is the object which lets two mutually incompatible interfaces communicate with each other. Adapter pattern acts as a bridge between two incompatible interfaces. This pattern involves a single class called adapter which is responsible for communication between two independent or incompatible interfaces.

 

248-goravel-uk-swiss-switzerland-adapter-plugMost popular example that illustrate this problem is electrical socket adapter plug that changes. For example UK is using different sockets than rest of EU. That’s forcing people to use adapters.

 

 

To demonstrate this pattern I’ll use simplified example of game mechanics that have Interface of enemies, but one of the enemies is different than others and don’t have implementation of Attack method.  Instead this specific enemy is casting spells.

UML diagram

l

 

Lest begin by crating SpecialEnemy class that’s using CastSpell method. That is called Adaptee and will be used later in Adapter Class.

class SpecialEnemy
{
  public string CastSpell()
  {
     return "using spell";
  }
}

I will use return string to simplify the process.

Next lest create Interface IEnemy for managing the enemies behaviour, in this case it’s only one method for Attack.

interface IEnemy
{
  string Attack();
}

Now we need to inherit this interface by EnemyAdapter Class that will connect both pieces together.

class EnemyAdapter: IEnemy
{
  SpecialEnemy e = new SpecialEnemy();
  public string Attack()
  {
     return e.CastSpell();
  }
}

We need to add reference to the Adaptee in order to have access to CastSpell method. This way we can use the Attack Method without implementation it SpecialEnemy Adaptee.

Last step is to call the Enemy Attack method in client Class.

class Program
{
  static void Main(string[] args)
  {
    IEnemy enemy = new EnemyAdapter();
    Console.WriteLine(enemy.Attack());
    Console.ReadLine();
  }
}

As an output we get “using spell” string displayed.

This example was oversimplified, but it demonstrates the idea behind this simple pattern. I hope you will find it useful. In next article I’ll demonstrate another exciting creational Pattern called Builder. Stay Awesome!