4.2.1 定義

模板方法模式，定義一個操作中的演算法的骨架，將一些步驟延遲到子類中。模板方法使得子類可以不改變一個演算法的結構即可重定義該演算法的某些特定步驟

4.2.2 結構圖

4.2.3 通用程式碼

AbstractClass是抽象類，其實就是一抽象模板，定義並實現了一個模板方法，這個模板方法一般是一個具體方法，它給出了一個頂級邏輯的骨架，而邏輯的組成步驟在相應的抽象操作中，推遲到子類實現。頂級邏輯也有可能呼叫一些具體方法。

public abstract class AbstractClass
    {
        public abstract void PrimitiveOperation1();
        
 
public abstract void PrimitiveOperation2();

        public void TemplateMethod()
        {
            PrimitiveOperation1();
            PrimitiveOperation2();
            Console.WriteLine("");
        }
}

ConcreteClass,實現父類所定義的一個或多個抽象方法。每一個AbstractClass都可以有任意多個ConcreteClass與之對應，而每一個ConcretClass

 public class ConcreteClassA : AbstractClass
    {
        public override void PrimitiveOperation1()
        {
            Console.WriteLine("具體A方法1實現");
        }

        public override void PrimitiveOperation2()
        {
            Console.WriteLine("具體A方法2實現
 
");
        }
    }

    public class ConcreteClassB : AbstractClass
    {
        public override void PrimitiveOperation1()
        {
            Console.WriteLine("具體A方法1實現");
        }

        public override void PrimitiveOperation2()
        {
            Console.WriteLine("具體A方法2實現");
        }
    }

客戶端呼叫：

class Program
    {
        static void Main(string[] args)
        {
            AbstractClass c;

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

            c = new ConcreteClassB();
            c.TemplateMethod();
            Console.ReadLine();
        }
    }

4.2.4 模擬場景

以生活中炒蔬菜為例來實現下模板方法模式，在現實生活中，做蔬菜的步驟都大致相同，如果我們針對每種蔬菜類定義一個燒的方法，這樣在每個類中都有很多相同的程式碼，為了解決這個問題，我們一般的思路肯定是把相同的部分抽象出來到抽象類中去定義，具體子類來實現具體的不同部分。

4.2.5 場景程式碼實現

public abstract class Vegetable
    {
        // 模板方法，不要把模版方法定義為Virtual或abstract方法，避免被子類重寫，防止更改流程的執行順序
        public void CookVegetable()
        {
            Console.WriteLine("炒蔬菜的一般做法：");
            PourOil();
            HeatOil();
            PourVegetable();
            StirFry();
        }

        public void PourOil()
        {
            Console.WriteLine("倒油");
        }
        public void HeatOil()
        {
            Console.WriteLine("把油加熱");
        }

        //油熱了倒蔬菜下去，具體哪種蔬菜由子類決定
        public abstract void PourVegetable();
        public void StirFry()
        {
            Console.WriteLine("翻炒");
        }
    }
    public class Potato : Vegetable
    {
        public override void PourVegetable()
        {
            Console.WriteLine("倒土豆進鍋中");
        }
    }

    public class ChinestCabbage : Vegetable
    {
        public override void PourVegetable()
        {
            Console.WriteLine("倒大白菜進鍋中");
        }
}
 class Program
    {
        /// <summary>
        /// 客戶端呼叫
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            Potato potato = new Potato();
            potato.CookVegetable();
            Console.ReadLine();
        }
    }

4.2.6 使用場景

當不變和可變的行為在方法的子類實現中混在一起的時候，不變的行為就會在子類中重複出現，我們通過模板方法模式把這些行為搬移到單一的地方，這樣就幫助子類拜託重複的不變行為的糾纏。

參考連結：https://www.cnblogs.com/zhaoshujie/p/9746958.html