add Behavioral Patterns exmaples part 1

Author: QianMo

Assets/Behavioral Patterns/Chain of Responsibility Pattern/Example1.meta

@@ -0,0 +1,147 @@
+//-------------------------------------------------------------------------------------
+//	ChainOfResponsibilityExample1.cs
+//-------------------------------------------------------------------------------------
+
+//This real-world code demonstrates the Chain of Responsibility pattern in which several linked 
+//managers and executives can respond to a purchase request or hand it off to a superior. 
+//Each position has can have its own set of rules which orders they can approve.
+
+
+using UnityEngine;
+using System.Collections;
+
+namespace ChainOfResponsibilityExample1
+{ 
+ public class ChainOfResponsibilityExample1 : MonoBehaviour
+ {
+ void Start ( )
+ {
+ // Setup Chain of Responsibility
+ Approver larry = new Director();
+ Approver sam = new VicePresident();
+ Approver tammy = new President();
+
+ larry.SetSuccessor(sam);
+ sam.SetSuccessor(tammy);
+
+ // Generate and process purchase requests
+ Purchase p = new Purchase(2034, 350.00, "Assets");
+ larry.ProcessRequest(p);
+
+ p = new Purchase(2035, 32590.10, "Project X");
+ larry.ProcessRequest(p);
+
+ p = new Purchase(2036, 122100.00, "Project Y");
+ larry.ProcessRequest(p);
+
+ }
+ }
+
+ /// <summary>
+ /// The 'Handler' abstract class
+ /// </summary>
+ abstract class Approver
+ {
+ protected Approver successor;
+
+ public void SetSuccessor(Approver successor)
+ {
+ this.successor = successor;
+ }
+
+ public abstract void ProcessRequest(Purchase purchase);
+ }
+
+ /// <summary>
+ /// The 'ConcreteHandler' class
+ /// </summary>
+ class Director : Approver
+ {
+ public override void ProcessRequest(Purchase purchase)
+ {
+ if (purchase.Amount < 10000.0)
+ {
+ Debug.Log(this.GetType().Name+" approved request# "+purchase.Number);
+ }
+ else if (successor != null)
+ {
+ successor.ProcessRequest(purchase);
+ }
+ }
+ }
+
+ /// <summary>
+ /// The 'ConcreteHandler' class
+ /// </summary>
+ class VicePresident : Approver
+ {
+ public override void ProcessRequest(Purchase purchase)
+ {
+ if (purchase.Amount < 25000.0)
+ {
+ Debug.Log(this.GetType().Name + " approved request# " + purchase.Number);
+ }
+ else if (successor != null)
+ {
+ successor.ProcessRequest(purchase);
+ }
+ }
+ }
+
+ /// <summary>
+ /// The 'ConcreteHandler' class
+ /// </summary>
+ class President : Approver
+ {
+ public override void ProcessRequest(Purchase purchase)
+ {
+ if (purchase.Amount < 100000.0)
+ {
+ Debug.Log(this.GetType().Name + " approved request# " + purchase.Number);
+ }
+ else
+ {
+ Debug.Log("Request# "+purchase.Number+ "requires an executive meeting!");
+ }
+ }
+ }
+
+ /// <summary>
+ /// Class holding request details
+ /// </summary>
+ class Purchase
+ {
+ private int _number;
+ private double _amount;
+ private string _purpose;
+
+ // Constructor
+ public Purchase(int number, double amount, string purpose)
+ {
+ this._number = number;
+ this._amount = amount;
+ this._purpose = purpose;
+ }
+
+ // Gets or sets purchase number
+ public int Number
+ {
+ get { return _number; }
+ set { _number = value; }
+ }
+
+ // Gets or sets purchase amount
+ public double Amount
+ {
+ get { return _amount; }
+ set { _amount = value; }
+ }
+
+ // Gets or sets purchase purpose
+ public string Purpose
+ {
+ get { return _purpose; }
+ set { _purpose = value; }
+ }
+ }
+}

Assets/Behavioral Patterns/Chain of Responsibility Pattern/Example1/ChainOfResponsibilityExample1.cs

@@ -0,0 +1,171 @@
+//-------------------------------------------------------------------------------------
+//	CommandExample1.cs
+//-------------------------------------------------------------------------------------
+
+//This real-world code demonstrates the Command pattern used in a simple calculator with unlimited number of undo's and redo's.
+//Note that in C# the word 'operator' is a keyword. Prefixing it with '@' allows using it as an identifier.
+
+using System;
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace CommandExample1
+{
+ public class CommandExample1 : MonoBehaviour
+ {
+ void Start ( )
+ {
+ // Create user and let her compute
+ User user = new User();
+
+ // User presses calculator buttons
+ user.Compute('+', 100);
+ user.Compute('-', 50);
+ user.Compute('*', 10);
+ user.Compute('/', 2);
+
+ // Undo 4 commands
+ user.Undo(4);
+
+ // Redo 3 commands
+ user.Redo(3);
+ }
+ }
+
+ /// <summary>
+ /// The 'Command' abstract class
+ /// </summary>
+ abstract class Command
+ {
+ public abstract void Execute();
+ public abstract void UnExecute();
+ }
+
+ /// <summary>
+ /// The 'ConcreteCommand' class
+ /// </summary>
+ class CalculatorCommand : Command
+ {
+ private char _operator;
+ private int _operand;
+ private Calculator _calculator;
+
+ // Constructor
+ public CalculatorCommand(Calculator calculator,
+ char @operator, int operand)
+ {
+ this._calculator = calculator;
+ this._operator = @operator;
+ this._operand = operand;
+ }
+
+ // Gets operator
+ public char Operator
+ {
+ set { _operator = value; }
+ }
+
+ // Get operand
+ public int Operand
+ {
+ set { _operand = value; }
+ }
+
+ // Execute new command
+ public override void Execute()
+ {
+ _calculator.Operation(_operator, _operand);
+ }
+
+ // Unexecute last command
+ public override void UnExecute()
+ {
+ _calculator.Operation(Undo(_operator), _operand);
+ }
+
+ // Returns opposite operator for given operator
+ private char Undo(char @operator)
+ {
+ switch (@operator)
+ {
+ case '+': return '-';
+ case '-': return '+';
+ case '*': return '/';
+ case '/': return '*';
+ default:
+ throw new
+ ArgumentException("@operator");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The 'Receiver' class
+ /// </summary>
+ 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;
+ }
+ Debug.Log("Current value = " + _curr+ " ( following "+ @operator+operand+" )");
+ }
+ }
+
+ /// <summary>
+ /// The 'Invoker' class
+ /// </summary>
+ class User
+ {
+ // Initializers
+ private Calculator _calculator = new Calculator();
+ private List<Command> _commands = new List<Command>();
+ private int _current = 0;
+
+ public void Redo(int levels)
+ {
+ for (int i = 0; i < levels; i++)
+ {
+ if (_current < _commands.Count - 1)
+ {
+ Command command = _commands[_current++];
+ command.Execute();
+ }
+ }
+ }
+
+ public void Undo(int levels)
+ {
+ Debug.Log("\n---- Undo "+ levels + " levels");
+ // Perform undo operations
+ for (int i = 0; i < levels; i++)
+ {
+ if (_current > 0)
+ {
+ Command command = _commands[--_current] as Command;
+ command.UnExecute();
+ }
+ }
+ }
+
+ public void Compute(char @operator, int operand)
+ {
+ // Create command operation and execute it
+ Command command = new CalculatorCommand(
+ _calculator, @operator, operand);
+ command.Execute();
+
+ // Add command to undo list
+ _commands.Add(command);
+ _current++;
+ }
+ }
+}