Design Patterns

كل سنة وأنتم طيبين :)

Agenda

Behavioral Pattern

Command

Review

Factory

Singleton

Adapter

Composite

Observer

State

Strategy

MVC

GraFCIS Design Discussion

Command Pattern

Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.

Command Pattern Example

UML Diagram

let's Implement it

 // Command pattern -- Structural example

using System;
 
namespace DoFactory.GangOfFour.Command.Structural
{
  /// <summary>
  /// MainApp startup class for Structural
  /// Command Design Pattern.
  /// </summary>
  class MainApp
  {
    /// <summary>
    /// Entry point into console application.
    /// </summary>
    static void Main()
    {
      // Create receiver, command, and invoker
      Receiver receiver = new Receiver();
      Command command = new ConcreteCommand(receiver);
      Invoker invoker = new Invoker();
 
      // Set and execute command
      invoker.SetCommand(command);
      invoker.ExecuteCommand();
 
      // Wait for user
      Console.ReadKey();
    }
  }
 
  /// <summary>
  /// The 'Command' abstract class
  /// </summary>
  abstract class Command
  {
    protected Receiver receiver;
 
    // Constructor
    public Command(Receiver receiver)
    {
      this.receiver = receiver;
    }
 
    public abstract void Execute();
  }
 
  /// <summary>
  /// The 'ConcreteCommand' class
  /// </summary>
  class ConcreteCommand : Command
  {
    // Constructor
    public ConcreteCommand(Receiver receiver) :
      base(receiver)
    {
    }
 
    public override void Execute()
    {
      receiver.Action();
    }
  }
 
  /// <summary>
  /// The 'Receiver' class
  /// </summary>
  class Receiver
  {
    public void Action()
    {
      Console.WriteLine("Called Receiver.Action()");
    }
  }
 
  /// <summary>
  /// The 'Invoker' class
  /// </summary>
  class Invoker
  {
    private Command _command;
 
    public void SetCommand(Command command)
    {
      this._command = command;
    }
 
    public void ExecuteCommand()
    {
      _command.Execute();
    }
  }
}

When to Use

Specify, queue, and execute requests at different times.
Support Undoable operations.
Load and Store.

Review

Factory:

Define an interface for creating an object, but let subclasses decide which class to instantiate.

When To Use:

A class can't anticipate the class of object must create.
A class wants its subclasses to specify the objects it creates.

Review

Singleton:

Ensure a class has only one instance and provide a global point of access to it.

When To Use:

There must be exactly one instance of a class, and it must be accessible to the clients from a well-known access point.

Review

Composite:

Compose objects into tree structures to represent part-whole hierarchies.

When To Use:

You want to represent part-whole hierarchies of objects.
you want clients to be able to ignore the difference between compositions of objects and individual objects.

Review

State:

Allow an object to alter its behavior when its internal state changes. The object will appear to change its class

When To Use:

An object's behavior depends on its state, and it must change its behavior at run-time depending on the state.
Operations have large, multipart conditional statements that depend on the object's state.

REVIEW

Strategy:

Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it.

When To Use:

Many related classes differ only in their behavior.

GraFCIS

Demo.

Any Questions ?!

Thank You :)

The End

presented by Anas A. Ismail / _aaismail