我读设计模式之模板方法模式（TemplateMethod Pattern）

     这个模式还是经常用到的：把一些子类共有的操作从子类中抽象出来，实现代码复用；利用函数多态，实现对不同实现的子类的访问。

     代码原型：

Code
using System;
using System.Collections.Generic;
using System.Text;

namespace Demo1
{
    class Program
    {
        static void Main(string[] args)
        {
            TemplateMethodCls cls1 = new ConcreteCls1();
            cls1.CallMethod();

            TemplateMethodCls cls2 = new ConcreteCls2();
            cls2.CallMethod();

            Console.Read();
        }
    }

    public abstract class TemplateMethodCls
    {
        public abstract void Method1();
        public abstract void Method2();
        public abstract void Method3();

        public void CallMethod() //Template method
        {
            Method1();
            Method2();
            Method3();

            Console.WriteLine("-----------------");
        }
    }

    public class ConcreteCls1 : TemplateMethodCls
    {
        public override void Method1()
        {
            Console.WriteLine("method 1 in concrete class 1");
        }
        public override void Method2()
        {
            Console.WriteLine("method 2 in concrete class 1");
        }
        public override void Method3()
        {
            Console.WriteLine("method 3 in concrete class 1");
        }
    }

    public class ConcreteCls2 : TemplateMethodCls
    {
        public override void Method1()
        {
            Console.WriteLine("method 1 in concrete class 2");
        }

        public override void Method2()
        {
            Console.WriteLine("method 2 in concrete class 2");
        }
        public override void Method3()
        {
            Console.WriteLine("method 3 in concrete class 2");
        }
    }
}

     
     其实，对于模板方法的使用，使得抽象出来的方法具有一定的并发性。比如说，访问一个数据库，总要有建立连接，数据访问，返回数据，关闭连接几个动作。但是可能对于查询，更新作业可能有不同的实现。这个时候，如果利用模板方法模式，就可以把这几个方法从类中抽象，而查询，和更新类对其进行不同的实现。

     

Code
using System;
using System.Collections.Generic;
using System.Text;

namespace Demo2
{
    class Program
    {
        static void Main(string[] args)
        {
            DataAccessTemp dal = new DAL();
            dal.TempMethod();

            Console.Read();
        }
    }
    public abstract class DataAccessTemp
    {
        public abstract void Connect();

        public abstract void Select();

        public abstract void Show();

        public abstract void Disconncet();

        public void TempMethod()
        {
            Connect();
            Select();
            Show();
            Disconncet();
        }
    }
    public class DALSelect : DataAccessTemp
    {
        public override void Connect()
        {
            Console.WriteLine("Create connection ");

        }
        public override void Select()
        {
            Console.WriteLine("select Data from database");
        }
        public override void Show()
        {
            Console.WriteLine("Show Data from select ");
        }
        public override void Disconncet()
        {
            Console.WriteLine("Disconn form database");
        }
    }
    public class DALUpdate : DataAccessTemp
    {
        public override void Connect()
        {
            Console.WriteLine("Create distinct  connection ");

        }
        public override void Select()
        {
            Console.WriteLine("update Data from database");
        }
        public override void Show()
        {
            Console.WriteLine("Show Data from select ");
        }
        public override void Disconncet()
        {
            Console.WriteLine("Disconn from distinct database");
        }
    }

}

     模板方法模式是很简单的一种实现代码复用的设计模式，在开发过程中，可能会经常用到~
      
      【实践】
      WMS系统入库作业中，半成品和成品的作业方式不太一样，但是他们的入库却具有相同的作业流程：入库抛转，料号移转，记录log. 此时可以利用模板方法对此一联动的动作进行抽象和封装，使得client端在执行入库时，只需执行模板方法，而不是连续实行多个方法。
      示例code:

 

Code
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TemplateMethodPattern
{
    class WMS
    {
        static void Main()
        {
            GoodsReceive cellRec = new CellGoodsReceive();
            cellRec.ExecuteGoodRec();

            GoodsReceive modRec = new ModGoodsReceive();
            modRec.ExecuteGoodRec();
        }
    }

   public abstract class GoodsReceive
    {
        public abstract void RecOperation();
        public abstract void TransOperation();

        public abstract void LogOperation();

        /// <summary>
        /// 执行入库作业
        /// </summary>
        public void ExecuteGoodRec()
        {
            //入库抛转
            RecOperation();

            //料号移转
            TransOperation();

            //记录log信息
            LogOperation();
        }
    }

   public class CellGoodsReceive:GoodsReceive
   {
       public override void RecOperation()
       {
           //在这里执行半成品cell入库抛转
           Console.WriteLine("Cell 131 Operation Done");
       }
       public override void TransOperation()
       {
           //在这里执行半成品cell 料号移转
           Console.WriteLine("Cell 131 material transfer Operation Done");
       }

       public override void LogOperation()
       {
           //在这里执行半成品cell 抛转 log 记录
           Console.WriteLine("Cell 131 log Operation Done");
       }
   }

   public class ModGoodsReceive : GoodsReceive
   {
       public override void RecOperation()
       {
           //在这里执行成品Mod入库抛转
           Console.WriteLine("Module 101 Operation Done");
       }
       public override void TransOperation()
       {
           //在这里执行成品Mod 料号移转
           Console.WriteLine("Module 101 material transfer Operation Done");
       }

       public override void LogOperation()
       {
           //在这里执行成品Mod 抛转 log 记录
           Console.WriteLine("Module 101 log Operation Done");
       }
   }
}

 

 

     参考学习：
      http://www.cnblogs.com/Terrylee/archive/2006/07/04/442660.html