commandrealworld.cs

使用C#程序将23个常用设计模式进行列表显示

using System;
using System.Windows.Forms;
using System.Collections;

//命令模式(Command pattern)
//意图
//    将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作。
//适用性
//    1.使用命令模式作为"CallBack"在面向对象系统中的替代。"CallBack"讲的便是先将一个函数登记上，然后在以后调用此函数。
//    2.需要在不同的时间指定请求、将请求排队。一个命令对象和原先的请求发出者可以有不同的生命期。
//      换言之，原先的请求发出者可能已经不在了，而命令对象本身仍然是活动的。这时命令的接收者可以是在本地，也可以在网络的另外一个地址。
//      命令对象可以在串形化之后传送到另外一台机器上去。
//    3.系统需要支持命令的撤消(undo)。命令对象可以把状态存储起来，等到客户端需要撤销命令所产生的效果时，可以调用undo()方法，把命令所产生的效果撤销掉。
//      命令对象还可以提供redo()方法，以供客户端在需要时，再重新实施命令效果。
//    4.如果一个系统要将系统中所有的数据更新到日志里，以便在系统崩溃时，可以根据日志里读回所有的数据更新命令，
//      重新调用Execute()方法一条一条执行这些命令，从而恢复系统在崩溃前所做的数据更新。
//    5.一个系统需要支持交易(Transaction)。一个交易结构封装了一组数据更新命令。使用命令模式来实现交易结构可以使系统增加新的交易类型。

namespace DesignPattern.CommandRealWorld
{
    class CommandRealWorld : AbstractPattern
    {
        public static void Run(TextBox tbInfo)
        {
            s_tbInfo = tbInfo;
            s_tbInfo.Text = "";

            // Create user and let her compute 
            User user = new User(); 
            user.Compute('+', 100); 
            user.Compute('-', 50); 
            user.Compute('*', 10); 
            user.Compute('/', 2); 
            
            // Undo 4 commands 
            user.Undo(4); 
            
            // Redo 3 commands 
            user.Redo(3); 
            
            // Wait for user 
            //Console.Read();
        }
    }

    // "Command" 
    abstract class Command 
    {
        public abstract void Execute(); 
        public abstract void UnExecute(); 
    }
    
    // "ConcreteCommand" 
    class CalculatorCommand : Command 
    {
        char @operator; 
        int operand; 
        Calculator calculator; 
        
        // 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; 
            }
            DesignPattern.FormMain.OutputInfo( "Current value = {0,3} (following {1} {2})", curr, @operator, operand); 
        }
    }
    
    // "Invoker" 
    class User
    {
        // Initializers 
        private Calculator calculator = new Calculator();
        private ArrayList commands = new ArrayList();
        private int current = 0;
        public void Redo(int levels)
        {
            DesignPattern.FormMain.OutputInfo("\n---- Redo {0} levels ", levels);

            // Perform redo operations 
            for (int i = 0; i < levels; i++)
            {
                if (current < commands.Count - 1)
                {
                    Command command = commands[current++] as Command;
                    command.Execute();
                }
            }
        }

        public void Undo(int levels)
        {
            DesignPattern.FormMain.OutputInfo("\n---- Undo {0} 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++;
        }
    }
}