Шаблон проектирования Команда (Command) + Реализация на C#

Существуют ситуации, когда у нас есть просто данные, над которыми нужно провести одну лишь единственную операцию, например, у нас есть кино на DVD диске и нам нужно всего лишь либо, запустить фильм, либо остановить, либо нажать на паузу и так далее. Также нам может понадобится такое действие, которое может отменить предыдущее (например операция undo в блокноте). Я могу написать функции (или методы), которые будут исполнять нашу команду и обрабатывать ее, но у нас будет очень много похожего кода, так как у нас не будет базового класса, который будет иметь поля схожие для всех команд. К тому же код будет очень не гибким. Фактически это КЛАСС, который инкапсулирует один единственный метод execute(). Это позволяет нам хранить команды в каких то контейнерах, обрабатывать их с помощью наших обработчиков.
(Пример стыбзен с википедии). Мы проектируем калькулятор со стандартными операциями сложения, деления, умножения, вычитания
Все строится сначала на классе Command:

abstract class Command
  {
    public abstract void Execute(); //метод выполнения команды
    public abstract void UnExecute(); //метод отмены
  }

Теперь делаем производные классы от команды. Причем этот класс должен хранить получателя(Calculator), класс, который принимает команды и обрабатывает их.

class CalculatorCommand : Command
  {
 char @operator; //оператор
 int operand;
 Calculator calculator; //ОБЪЕКТ ПОЛУЧАЮЩИЙ КОМАНДЫ (Receiver)
 
    // Constructor
 public CalculatorCommand(Calculator calculator,
    char @operator, int operand)
    {
      this.calculator = calculator;
      this.@operator = @operator;
      this.operand = operand;
    }
 
    public char Operator
    {
      set{ @operator = value; }
    }
 
    public int Operand
    {
      set{ operand = value; }
    }
 //здесь мы просто вызываем метод нашего получателя, на вход которого мы отправляем оператор и операнд
    public override void Execute() 
    {
      calculator.Operation(@operator, operand);
    }
 
    public override void UnExecute()
    {
      calculator.Operation(Undo(@operator), operand);
    }
 
    // Private helper function : приватные вспомогательные функции
    private char Undo(char @operator)
    {
      char undo;
      switch(@operator)
      {
        case '+': undo = '-'; break;
        case '-': undo = '+'; break;
        case '*': undo = '/'; break;
        case '/': undo = '*'; break;
        default : undo = ' '; break;
      }
      return undo;
    }
  }

Теперь нужен класс который будет получать команды и их обрабатывать.

// "Receiver" : получатель
 
  class Calculator
  {
    private int curr = 0;
 
    public void Operation(char @operator, int operand)
    {
      switch(@operator)
      {
        case '+': curr += operand; break;
        case '-': curr -= operand; break;
        case '*': curr *= operand; break;
        case '/': curr /= operand; break;
      }
      Console.WriteLine(
        "Current value = {0,3} (following {1} {2})",
        curr, @operator, operand);
    }
  }

Теперь нужен класс, который будет отдавать команды на обработку калькулятору..

class User
  {
    // Initializers
    private Calculator _calculator = new Calculator();
    private List _commands = new List();
 
    private int _current = 0;
 
    public void Redo(int levels)
    {
      Console.WriteLine("\n---- Redo {0} levels ", levels);
 
      // Делаем возврат операций
      for (int i = 0; i < levels; i++)
        if (_current < _commands.Count - 1)
          _commands[_current++].Execute();
    }
 
    public void Undo(int levels)
    {
      Console.WriteLine("\n---- Undo {0} levels ", levels);
 
      // Делаем отмену операций
      for (int i = 0; i < levels; i++)
        if (_current > 0)
          _commands[--_current].UnExecute();
    }
 
    public void Compute(char @operator, int operand)
    {
 
      // Создаем команду операции и выполняем её
      Command command = new CalculatorCommand(
        _calculator, @operator, operand);
      command.Execute();
 
      // Добавляем операцию к списку отмены
      _commands.Add(command);
      _current++;
    }
  }

Ну и пример работы с нашим калькулятором

class MainApp
  {
    static void Main()
    {
      // Создаем пользователя.
      User user = new User();
 
      // Пусть он что-нибудь сделает.
      user.Compute('+', 100);
      user.Compute('-', 50);
      user.Compute('*', 10);
      user.Compute('/', 2);
 
      // Отменяем 4 команды
      user.Undo(4);
 
      // Вернём 3 отменённые команды.
      user.Redo(3);
 
      // Ждем ввода пользователя и завершаемся.
      Console.Read();
    }
  }

Итак, теперь обобщим все, что мы здесь написали, вот схемка шаблона:

Ну, кто не силен в английском, могу объяснить, сначала наш вызывающий (по английски Invoker) (в нашем случае User), вызывает команду (причем команда передается в виде объекта) и посылает ее получателю (Calculator), где команда успешно обрабатывается калькулятором.
Благодаря такому шаблону, мы можем без труда можем добавить свои команды, которые с помощью метода execute() будут также выполнятся. Всего лишь надо унаследовать все от Command.

Read More

Шаблон проектирования Абстрактная фабрика (Abstract factory) Реализация C#

Абстрактная фабрика - порождающий шаблон проектирования, используемый для создания ГРУППЫ объектов, реализующих одно поведение, то есть объекты одного типа, причем не специфируя их конкретные классы.

Абстрактная фабрика используется, когда:

1. Система должна работать с группами объектов и объекты в этом семействе должны использоваться совместно.
2. Система не должна зависеть от того, как создаются компоненты и взаимодействуют.
3. Когда надо, чтобы при изменении класса конкретного продукта, не приходилось изменять класс клиента (класс, взаимодействующий  с созданными продуктами)

Действующие лица:

• AbstractProduct — абстрактный продукт
  • определяет интерфейс для создания объектов, создаваемых методом CreateProduct, то есть он содержит виртуальные функции CreateProduct, где уже в ConcreteFactory переопределяются (override).
• ConcreteProduct — конкретный продукт
  • реализует интерфейс Product (то есть у нас есть класс AbstractProduct, от которого у нас несколько производных классов, типа ConcreteProductA, либо ConcreteProductB и так далее)
• AbstractProduct — абстрактный создатель
  • предназначен, для реализации интерфейса от производных классов типа ConcreteProduct
• ConcreteFactory — конкретная фабрика
• переопределяет фабричный метод таким образом, чтобы он создавал и возвращал объект класса ConcreteProduct.
• Client - клиент
• дает команды на получение продукта определенного семейства, к тому же в параметры передается фабрика, к-ая создает все объекты, фактически это наш интерфейс взаимодействия, с помощью которого, мы решаем какие объекты создать.

Диаграмма:

Шаблон:

//сам интерфейс абстрактной фабрики
//два абстрактных методов, к-ые переопределяются в наследниках
    abstract class AbstractFactory
    {
        public abstract AbstractProductA CreateProductA();
        public abstract AbstractProductB CreateProductB();
    }

    // "ConcreteFactory1" 
    class ConcreteFactory1 : AbstractFactory
    {
//переопредление методов интерфейсных для 1ой фабрики
        public override AbstractProductA CreateProductA()
        {
            return new ProductA1();
        }
        public override AbstractProductB CreateProductB()
        {
            return new ProductB1();
        }
    }

    // "ConcreteFactory2" 
    class ConcreteFactory2 : AbstractFactory
    {
//переопредление методов интерфейсных для 2ой фабрики
        public override AbstractProductA CreateProductA()
        {
            return new ProductA2();
        }
        public override AbstractProductB CreateProductB()
        {
            return new ProductB2();
        }
    }
//пошли уже наши интерфейсы продуктов
    // "AbstractProductA" 
    abstract class AbstractProductA
    {
    }

    // "AbstractProductB" 
    abstract class AbstractProductB
    {
//метод, который показывает, как продукт B взаимодействует с объектом А
        public abstract void Interact(AbstractProductA a);
    }
//реализация продуктов
    // "ProductA1" 
    class ProductA1 : AbstractProductA
    {
    }

    // "ProductB1" 
    class ProductB1 : AbstractProductB
    {
//определение
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name + " interacts with " + a.GetType().Name);
        }
    }

    // "ProductA2" 
    class ProductA2 : AbstractProductA
    {
    }

    // "ProductB2" 
    class ProductB2 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name + " interacts with " + a.GetType().Name);
        }
    }
//интерфейс взаимодействия, с помощью которого мы решаем какого типа создать объекты
    // "Client" - the interaction environment of the products 
    class Client
    {
        private AbstractProductA abstractProductA;
        private AbstractProductB abstractProductB;

        // Constructor, создается группа объектов, причем все в зависимости от типа фабрики
        public Client(AbstractFactory factory)
        {
            abstractProductB = factory.CreateProductB();
            abstractProductA = factory.CreateProductA();
        }
//запуск клиента
        public void Run()
        {
            abstractProductB.Interact(abstractProductA);
        }
    }

Main():

        static void Main(string[] args)
        {
            // Abstract factory #1 
            AbstractFactory factory1 = new ConcreteFactory1();
            Client c1 = new Client(factory1);
            c1.Run();

            // Abstract factory #2 
            AbstractFactory factory2 = new ConcreteFactory2();
            Client c2 = new Client(factory2);
            c2.Run();

            // Wait for user input 
            Console.Read();

        }

Вывод: Итак, все как в фабричном методе, только мы создаем ГРУППЫ объектов, и также у нас клиент занимается созданием объектов и анализ взаимодействия созданных объектов.

Read More

Шаблон проектирования Фабричный метод (Factory Method) Реализация C#

Фабричный метод используется для создания одного! объекта с определенным интерфейсом (типом).

Фабричный метод относится к порождающим шаблонам проектирования. Порождающие шаблоны проектирования используются для создания объектов, причем они позволяют быть независимыми от типа создаваемого объекта и от процесса создания.

Фабричный метод используется, когда:

1. Заранее известно, когда создавать объект, но не известен его тип.
2. Созданные фабричным методом объекты должны определятся уже в подклассе.
3. Класс делегирует свои методы производному классу, после чего происходит определение, какой класс принимает какие методы.

Диаграмма:

Действующие лица:

• Product — продукт
  • определяет интерфейс объектов, создаваемых абстрактным методом;
• ConcreteProduct — конкретный продукт
  • реализует интерфейс Product (то есть у нас есть интерфейс IProduct, от которого у нас несколько производных классов, типа ConcreteProductA, либо ConcreteProductB и так далее)
• Creator — создатель
  • предназначен, для реализации интерфейса от производных классов типа ConcreteCreator
  • содержит фабричный метод для создания объекта типа Product, который переопределяется в классах ConcreteCreatorA, ConcreteCreatorB;
• ConcreteCreator — конкретный создатель
• переопределяет фабричный метод таким образом, чтобы он создавал и возвращал объект класса ConcreteProduct.

На основе класса Factory создается один или несколько классов фабрик (причем эти фабрики имеют тип), и эти фабрики создают конкретные модели.

Шаблон:

//абстрактный класс создателя, который имеет абстрактный метод FactoryMethod, принимающий тип продукта
public abstract class Creator
{
    public abstract Product FactoryMethod(int type);
}
 
 
public class ConcreteCreator : Creator
{
    public override Product FactoryMethod(int type)
    {
        switch (type)
        {
            //возвращает объект A, если type==1
            case 1: return new ConcreteProductA();
            //возвращает объект B, если type==2 
            case 2: return new ConcreteProductB(); 
            default: throw new ArgumentException("Invalid type.", "type");
        }
    }
}

public abstract class Product { } //абстрактный класс продукт
 //конкретные продукты с разной реализацией
public class ConcreteProductA : Product { } 
 
public class ConcreteProductB : Product { }
 //

Потом в Main()

static void Main()
{       //создаем создателя
        Creator creator = new ConcreteCreator();
 for (int i = 1; i <= 2; i++)
 {
            //создаем сначала продукт с типом 1, потом с типом 2
     var product = creator.FactoryMethod(i);
     Console.WriteLine("Where id = {0}, Created {1} ", i, product.GetType());
 }
}

Здесь сначала создается сам конкретный создатель, который потом будет использоваться в создании продуктов, сначала ConcreteProductA, вывод на экран типа, потом ConcreteProductB, и также вывод его типа.

Итак, подводим итоги:
Самый главный недостаток, это необходимость создания объекта Creator для того, чтобы создать любой продукт с помощью метода FactoryMethod().

Read More