模板模式 策略模式 命令模式 比说明与比较

模板模式

在模板模式中,一个抽象类公开定义了执行它的方法/模板.它的子类可以按需要重写方法实现,但调用将以抽象类中定义的方式进行.这种类型模式属于行为模式.

定义一个操作算法的骨架,而将这一些步骤延迟到子类中,模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤.

优点:

1. 封装不变部分,扩展可变部分.
2. 提取公共代码,便于维护.
3. 行为由父类控制,子类实现.

缺点:

每个不同的事项都需要一个子类来实现,导致类的个数增加,使得系统更加庞大.

生活中的例子:

实现代码:

//写一个父类
abstract class AbstractClass
    {
        public abstract void PrimitiveOperation1();
        public abstract void PrimitiveOperation2();

        public void TemplateMethod()
        {
            PrimitiveOperation1();
            PrimitiveOperation2();
            Console.WriteLine("");
        }
}
//两个子类继承父类
class ConcreteClassA : AbstractClass
    {
        public override void PrimitiveOperation1()
        {
            Console.WriteLine("具体类A方法1实现");
        }
        public override void PrimitiveOperation2()
        {
            Console.WriteLine("具体类A方法2实现");
        }
    }

    class ConcreteClassB : AbstractClass
    {
        public override void PrimitiveOperation1()
        {
            Console.WriteLine("具体类B方法1实现");
        }
        public override void PrimitiveOperation2()
        {
            Console.WriteLine("具体类B方法2实现");
        }
    }

 

客户端代码:

AbstractClass c;

            c = new ConcreteClassA();
            c.TemplateMethod();

            c = new ConcreteClassB();
            c.TemplateMethod();

            Console.Read();

 

策略模式

在策略模式中,一个类的行为或其算法可以在运行是更改.这种类型的设计模式属于行为模式.

在策略模式中,我们创建表示各种策略的对象和一个行为随着策略对象改变的context对象.策略对象改变context对象的执行算法.

定义一系列的算法,把他们一个个给封装起来,并且使他们可以互相替换.

 

优点:

1. 算法可以自由切换.
2. 避免使用多重条件判断.
3. 扩展性良好,

缺点:

1. 策略类会增多.
2. 所有策略类都需要对外暴露.

生活中的例子:

代码实现:

//抽象算法类
    abstract class Strategy
    {
        //算法方法
        public abstract void AlgorithmInterface();
    }
    //具体算法A
    class ConcreteStrategyA : Strategy
    {
        //算法A实现方法
        public override void AlgorithmInterface()
        {
            Console.WriteLine("算法A实现");
        }
    }
    //具体算法B
    class ConcreteStrategyB : Strategy
    {
        //算法B实现方法
        public override void AlgorithmInterface()
        {
            Console.WriteLine("算法B实现");
        }
    }
    //具体算法C
    class ConcreteStrategyC : Strategy
    {
        //算法C实现方法
        public override void AlgorithmInterface()
        {
            Console.WriteLine("算法C实现");
        }
    }
    //上下文
    class Context
    {
        Strategy strategy;

        public Context(Strategy strategy)
        {
            this.strategy = strategy;
        }
        //上下文接口
        public void ContextInterface()
        {
            strategy.AlgorithmInterface();
        }
}

 

客户端代码

Context context;

            context = new Context(new ConcreteStrategyA());
            context.ContextInterface();

            context = new Context(new ConcreteStrategyB());
            context.ContextInterface();

            context = new Context(new ConcreteStrategyC());
            context.ContextInterface();

            Console.Read();

 

命令模式

命令模式是一种数据驱动的设计模式,它属于行为型模式.请求以命令的形式包裹在对象中,并传给调用对象.调用对象寻找可以处理该命令的合适的对象,并把该命令传给相对应的对象,该对象执行命令.

将一个请求封装成一个对象,从而让使用者可以用不同的请求对客户进行参数化.

优点:

1. 降低了系统耦合度.
2. 新的命令可以很容易添加到系统中去.

缺点:

使用明亮模式可能会导致某些系统由过多的具体命令类.

 

 

代码实现:

abstract class Command
    {
        protected Receiver receiver;

        public Command(Receiver receiver)
        {
            this.receiver = receiver;
        }

        abstract public void Execute();
    }

    class ConcreteCommand : Command
    {
        public ConcreteCommand(Receiver receiver)
            :
          base(receiver) { }

        public override void Execute()
        {
            receiver.Action();
        }
    }

    class Receiver
    {
        public void Action()
        {
            Console.WriteLine("执行请求！");
        }
    }

    class Invoker
    {
        private Command command;

        public void SetCommand(Command command)
        {
            this.command = command;
        }

        public void ExecuteCommand()
        {
            command.Execute();
        }
}

客户端代码:

Receiver r = new Receiver();
            Command c = new ConcreteCommand(r);
            Invoker i = new Invoker();

            // Set and execute command 
            i.SetCommand(c);
            i.ExecuteCommand();

            Console.Read();