What is Design Pattern?

 What is Design Pattern?

 What is not Design Pattern?

 When to use a Desing Pattern?

 Drawbacks

Creational Design Patterns

 What?

Singleton

Singleton

Ensures single instance of an object for the project

 What is Singleton Design Pattern?

 When to use Singleton?

• Different parts of a system need to access a single object
   

• System requires global access to the object instance
   

• Expensive instantiation -> lazy loading

 How to implement Singleton?

public Logger
{
    private static Logger instance;
    // private constructor ensures that
    // Logger cannot be instantiated from outside
    private Logger()
    { }
    // provide access to the single instance
    public static Logger Instance
    {
        get
        {
            // instantiate on the first access
            if(instance == null)
                instance = new Logger();

            return instance;
        }
    }
    public void Log(string log)
    {
        Console.WriteLine(log);
    }
}

 Problems

Abstract Factory

Abstract Factory

Defines abstract interface for creating a family of related types of objects

 What is Abstract Factory?

 When to use Abstract Factory?

 How to implement Abstract Factory?

interface IContinentFactory { // AbstractFactory
   Herbivore CreateHerbivore();
   Carnivore CreateCarnivore();
}
class AfricaFactory : IContinentFactory {
   public Herbivore CreateHerbivore() {
      return new Wildbeаst();
   }
   public Carnivore CreateCarnivore() {
      return new Lion(); // Constructor can be internal
   }
}
class AmericaFactory : IContinentFactory {
    public Herbivore CreateHerbivore() {
        return new Bison();
    }
    public Carnivore CreateCarnivore() {
        return new Wolf();
    }
}

 Problems

 Quizlet

1. The console is/ is not an example of Singleton?
2. Must Singleton objects be initialized with the start of the programme?
3. Does Singleton facilitate testing?
4. Abstract factory facilitates controlling the behavior of the objects?
5. Must the client specify the way each object from the factory is created?
6. Nice implementation of Abstract factory?

Structural Design Patterns

 What is Structural Design Pattern?

Composite

 Composite

Treat in the same way individual objects or groups of objects

 When to use Composite?

 How to implement Component?

abstract class MailReceiver 
{
    public abstract void SendMail();
}
class EmailAddress : MailReceiver 
{
    public override void SendMail() { /*...*/ }
}
class GroupOfEmailAddresses : MailReceiver 
{
    private List<MailReceiver> participants;
    public override void SendMail() 
    {
        foreach(var p in participants) 
        {
            p.SendMail();
        }
    }
}
static void Main()
{
    var rootGroup = new GroupOfEmailAddresses();
    rootGroup.SendMail();
}

Decorator

Decorator

Add functionality to existing objects at run-time

 What is Decorator Design Pattern?

 When to use Decorator?

 When to use Decorator?

 How to implement Decorator?

abstract class Decorator : LibraryItem {
    protected LibraryItem libraryItem;
    public Decorator(LibraryItem libraryItem) {
        this.libraryItem = libraryItem;
    }
    public override void Display() {
        libraryItem.Display();
    }
}
class Borrowable : Decorator {
    protected List<string> borrowers = new List<string>();
    public Borrowable(LibraryItem libraryItem) : base(libraryItem) {}
    public void BorrowItem(string name) {
      borrowers.Add(name);
      libraryItem.NumCopies--;
    }
    public override void Display() {
      base.Display();
      foreach (string borrower in borrowers) {
        Console.WriteLine(" borrower: " + borrower);
      }
    }
  }

​Decorator vs Inheritance

1. Decorating can provide new behavior at runtime for individual objects, and the change affects all instances of the original class; Subclassing adds behavior at compile time
    
2. Example: TextView class.
   1. You want a scrolled text view - ScrolledTextView class.
   2. You want a border around text view - BorderedTextView.
   3. You want both border and scroll - ScrolledBorderedTextView
      
      ​Result - duplication of the effort + class explosion
       
3. Decorator pattern is used to decorate the existing classes without changing the old behavior.
    
4. You can test your decorator in isolation of the decorated object (not possible with inheritance to mock the parent class)

Adapter

Adapter

Converts the given class'es interface into another class requested by the client

 What is Adapter Design Pattern?

 When to use Adapter?

 How to implement Adapter?

interface ITarget {
  List<string> GetProducts();
}
public class VendorAdaptee
{
   public List<string> GetListOfProducts() {
      List<string> products = new List<string>();
      products.Add("Gaming Consoles");
      products.Add("Television");
      products.Add("Books");
      products.Add("Musical Instruments");
      return products;
   }
}
class VendorAdapter:ITarget {
   public List<string> GetProducts() {
      VendorAdaptee adaptee = new VendorAdaptee();
      return adaptee.GetListOfProducts();
   }
}
class ShoppingPortalClient {
   static void Main(string[] args) {
      ITarget adapter = new  VendorAdapter();
      foreach (string product in adapter.GetProducts()) {
        Console.WriteLine(product);
      }
      Console.ReadLine();
   }
}

 Quizlet

1. Composite pattern handles a single object and group of objects differently?

2. Decorator pattern works in favour of keeping the Open-Closed principle?

3. If you have an old class with API that does not work anymore which pattern are you going to use?

4. Differences between Decorator pattern and inheritance?

5. Adapter pattern creates new implementations of the objects of old system?

6. The 'Adaptee' class is the one which interface is not compatible or the class that takes care of the implementing the new interface?

7. The 'Target' class is?

8. Which design pattern is illustrated with:

Behavioral Design Patterns

 What is Behavioral Design Pattern?

Template Method

Template Method

The program skeleton of an algorithm in an operation, deferring some steps to subclasses

 What is Template method Design Pattern?

 When to use Template Method?

 How to implement Template Method?

public abstract class HotDrink {
    public void PrepareRecipe()
    {
        BoilWater(); Brew(); PourInCup(); AddSpices();
    }
    protected abstract void Brew();
    protected abstract void AddSpices();
    private void BoilWater() { ... }
    private void PourInCup() { ... }
}
public class Coffee : HotDrink {
    protected override void Brew() { ... }
    protected override void AddSpices() { ... }
}
public class Tea : HotDrink {
    protected override void Brew() { ... }
    protected override void AddSpices() { ... }
}