模板模式

1. 概述

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

2. 模式中的角色

　　2.1 抽象类（AbstractClass）：实现了模板方法，定义了算法的骨架。

　　2.2 具体类（ConcreteClass)：实现抽象类中的抽象方法，已完成完整的算法。

3. 模式解读

　　3.1 模板方法类图

　　

　　3.2 模板方法模式代码实现

    /// <summary>
    /// 抽象类
    /// </summary>
    public abstract class AbstractClass
    {
        // 一些抽象行为，放到子类去实现
        public abstract void PrimitiveOperation1();
        public abstract void PrimitiveOperation2();

        /// <summary>
        /// 模板方法，给出了逻辑的骨架，而逻辑的组成是一些相应的抽象操作，它们推迟到子类去实现。
        /// </summary>
        public void TemplateMethod()
        {
            PrimitiveOperation1();
            PrimitiveOperation2();
            Console.WriteLine("Done the method.");
        }
    }

    /// <summary>
    /// 具体类，实现了抽象类中的特定步骤
    /// </summary>
    public class ConcreteClassA : AbstractClass
    {
        /// <summary>
        /// 与ConcreteClassB中的实现逻辑不同
        /// </summary>
        public override void PrimitiveOperation1()
        {
            Console.WriteLine("Implement operation 1 in Concreate class A.");
        }

        /// <summary>
        /// 与ConcreteClassB中的实现逻辑不同
        /// </summary>
        public override void PrimitiveOperation2()
        {
            Console.WriteLine("Implement operation 2 in Concreate class A.");
        }
    }

    /// <summary>
    /// 具体类，实现了抽象类中的特定步骤
    /// </summary>
    public class ConcreteClassB : AbstractClass
    {
        /// <summary>
        /// 与ConcreteClassA中的实现逻辑不同
        /// </summary>
        public override void PrimitiveOperation1()
        {
            Console.WriteLine("Implement operation 1 in Concreate class B.");
        }

        /// <summary>
        /// 与ConcreteClassA中的实现逻辑不同
        /// </summary>
        public override void PrimitiveOperation2()
        {
            Console.WriteLine("Implement operation 2 in Concreate class B.");
        }
    }

　　3.3 客户端代码

    class Program
    {
        static void Main(string[] args)
        {
            // 声明抽象类
            AbstractClass c;

            // 用ConcreteClassA实例化c
            c = new ConcreteClassA();
            c.TemplateMethod();

            // 用ConcreteClassB实例化c
            c = new ConcreteClassB();
            c.TemplateMethod();

            Console.Read();
        }
    }

　　运行结果

　　

5. 模式总结

　　5.1 优点

　　　　5.1.1 模板方法模式通过把不变的行为搬移到超类，去除了子类中的重复代码。

　　　　5.1.2 子类实现算法的某些细节，有助于算法的扩展。

　　　　5.1.3 通过一个父类调用子类实现的操作，通过子类扩展增加新的行为，符合“开放-封闭原则”。

　　5.2 缺点

　　　　5.2.1 每个不同的实现都需要定义一个子类，这会导致类的个数的增加，设计更加抽象。

　　5.3 适用场景

　　　　5.1 在某些类的算法中，用了相同的方法，造成代码的重复。

　　　　5.2 控制子类扩展，子类必须遵守算法规则。