设计模式 之 工厂方法

接上一节简单工厂。

正如前面一节所说，系统以后扩展增加数据专业，需要修改现有的简单工厂方法中的工厂类，这对于讲究关_闭原则的设计模式来说，这是不应该的。
因此，为了扩展以后的系统的不可知的业务的增加，需要一个方法能够来在不修改原由系统的基础上，方便的扩展新功能，因此，有了本方法。

首先，需要先设计一个接口或者抽象类，用来约束各个专业数据的处理方式。
using System;
using System.Collections.Generic;
using System.Text;
using System.Data;

namespace 工厂方法
{
    public interface ISpeciality<T> where T : IDomain
    {

        #region  新增一条数据
        /// <summary>
        /// 新增一条数据
        /// </summary>
        /// <param name="t">数据对象</param>
        /// <returns></returns>
        bool InserOneInfo(T t);
        #endregion

        #region 得到一条信息
        /// <summary>
        /// 得到一条信息
        /// </summary>
        /// <param name="strIntId"></param>
        /// <returns></returns>
        DataTable GetOneInfo(string strIntId);
        #endregion

        #region 得到所有信息
        /// <summary>
        /// 得到所有信息
        /// </summary>
        /// <returns></returns>
        DataTable GetAllInfo();
        #endregion

        #region 按条件查询信息
        /// <summary>
        /// 按条件查询信息
        /// </summary>
        /// <param name="strCtiyId">地市id</param>
        /// <param name="strBusiType">专业类型1为话务2 为传输3 为动环4为数据</param>
        /// <returns></returns>
        DataTable GetInfoByQuery(string strCtiyId, string strBusiType);
        #endregion

        #region 按条件查询信息，并用于导出
        /// <summary>
        /// 按条件查询信息，并用于导出
        /// </summary>
        /// <param name="strCtiyId">地市id</param>
        /// <param name="strBusiType">专业类型1为话务2 为传输3 为动环4为数据</param>
        /// <returns></returns>
        DataTable QueryInfoForDowland(string strCtiyId, string strBusiType);
        #endregion

        #region 删除一条信息
        /// <summary>
        /// 删除一条信息
        /// </summary>
        /// <param name="strIntId"></param>
        /// <returns></returns>
        bool DelOneInfo(string strIntId);
        #endregion

        #region 修改一条数据
        /// <summary>
        /// 修改一条数据
        /// </summary>
        /// <param name="t">数据对象</param>
        /// <returns></returns>
        bool UpDateOneInfo(T t);
        #endregion
    }

}

上面是一个接口类，下面是各个专业的信息的处理类。
using System;
using System.Collections.Generic;
using System.Text;
using System.Data;

namespace 工厂方法
{
    public class BtsSite<BtsSiteManagerDomain> : ISpeciality<BtsSiteManagerDomain>  where BtsSiteManagerDomain:IDomain
    {
        public BtsSite()
        {

        }
        #region  新增一条数据
        /// <summary>
        /// 新增一条数据
        /// </summary>
        /// <param name="t">数据对象</param>
        /// <returns></returns>
        public bool InserOneInfo(BtsSiteManagerDomain btsSiteManagerDomain)
        {
           
            btsSiteManagerDomain.Intid = "111";

            bool bRet = false;
            return bRet;
        }
        #endregion

        #region 得到一条信息
        /// <summary>
        /// 得到一条信息
        /// </summary>
        /// <param name="strIntId"></param>
        /// <returns></returns>
        public DataTable GetOneInfo(string strIntId)
        {
            DataTable tempTable = new DataTable();
            return tempTable;
        }
        #endregion

        #region 得到所有信息
        /// <summary>
        /// 得到所有信息
        /// </summary>
        /// <returns></returns>
        public DataTable GetAllInfo()
        {
            DataTable tempTable = new DataTable();
            return tempTable;
        }
        #endregion

        #region 按条件查询信息
        /// <summary>
        /// 按条件查询信息
        /// </summary>
        /// <param name="strCtiyId">地市id</param>
        /// <param name="strBusiType">专业类型1为话务2 为传输3 为动环4为数据</param>
        /// <returns></returns>
        public DataTable GetInfoByQuery(string strCtiyId, string strBusiType)
        {
            DataTable tempTable = new DataTable();
            return tempTable;
        }
        #endregion

        #region 按条件查询信息，并用于导出
        /// <summary>
        /// 按条件查询信息，并用于导出
        /// </summary>
        /// <param name="strCtiyId">地市id</param>
        /// <param name="strBusiType">专业类型1为话务2 为传输3 为动环4为数据</param>
        /// <returns></returns>
        public DataTable QueryInfoForDowland(string strCtiyId, string strBusiType)
        {
            DataTable tempTable = new DataTable();
            return tempTable;
        }
        #endregion

        #region 删除一条信息
        /// <summary>
        /// 删除一条信息
        /// </summary>
        /// <param name="strIntId"></param>
        /// <returns></returns>
        public bool DelOneInfo(string strIntId)
        {
            bool bRet = false;
            return bRet;
        }

        #endregion

        #region 修改一条数据
        /// <summary>
        /// 修改一条数据
        /// </summary>
        /// <param name="t">数据对象</param>
        /// <returns></returns>
        public bool UpDateOneInfo(BtsSiteManagerDomain btsSiteManagerDomain)
        {
            bool bRet = false;
            return bRet;
        }
        #endregion

    }
}

然后可以在定义其他专业的信息处理类。

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;

namespace 工厂方法
{
    class Asite<AsiteDomain>:ISpeciality<AsiteDomain> where AsiteDomain:IDomain
    {
        public Asite()
        {

        }
        #region  新增一条数据
        /// <summary>
        /// 新增一条数据
        /// </summary>
        /// <param name="t">数据对象</param>
        /// <returns></returns>
        public bool InserOneInfo(AsiteDomain asiteDomain)
        {

            asiteDomain.Intid = "111";

            bool bRet = false;
            return bRet;
        }
        #endregion

        #region 得到一条信息
        /// <summary>
        /// 得到一条信息
        /// </summary>
        /// <param name="strIntId"></param>
        /// <returns></returns>
        public DataTable GetOneInfo(string strIntId)
        {
            DataTable tempTable = new DataTable();
            return tempTable;
        }
        #endregion

        #region 得到所有信息
        /// <summary>
        /// 得到所有信息
        /// </summary>
        /// <returns></returns>
        public DataTable GetAllInfo()
        {
            DataTable tempTable = new DataTable();
            return tempTable;
        }
        #endregion

        #region 按条件查询信息
        /// <summary>
        /// 按条件查询信息
        /// </summary>
        /// <param name="strCtiyId">地市id</param>
        /// <param name="strBusiType">专业类型1为话务2 为传输3 为动环4为数据</param>
        /// <returns></returns>
        public DataTable GetInfoByQuery(string strCtiyId, string strBusiType)
        {
            DataTable tempTable = new DataTable();
            return tempTable;
        }
        #endregion

        #region 按条件查询信息，并用于导出
        /// <summary>
        /// 按条件查询信息，并用于导出
        /// </summary>
        /// <param name="strCtiyId">地市id</param>
        /// <param name="strBusiType">专业类型1为话务2 为传输3 为动环4为数据</param>
        /// <returns></returns>
        public DataTable QueryInfoForDowland(string strCtiyId, string strBusiType)
        {
            DataTable tempTable = new DataTable();
            return tempTable;
        }
        #endregion

        #region 删除一条信息
        /// <summary>
        /// 删除一条信息
        /// </summary>
        /// <param name="strIntId"></param>
        /// <returns></returns>
        public bool DelOneInfo(string strIntId)
        {
            bool bRet = false;
            return bRet;
        }

        #endregion

        #region 修改一条数据
        /// <summary>
        /// 修改一条数据
        /// </summary>
        /// <param name="t">数据对象</param>
        /// <returns></returns>
        public bool UpDateOneInfo(AsiteDomain asiteDomain)
        {
            bool bRet = false;
            return bRet;
        }
        #endregion
    }
}

简单工厂中，类实例的创建，是根据传入参数的不同创建不同的类实例，在工厂方法中，类实例的创建，都是由各自的创建类来创建。

首先，定义一个创建各实例类的接口：

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

namespace 工厂方法
{
    public interface ICreator<T> where T : IDomain
    {
        ISpeciality<T> CreaterSpeciality( );
    }
}

然后是各个专业的创建类：
话务专业：
using System;
using System.Collections.Generic;
using System.Text;

namespace 工厂方法
{
   public class AsiteCreator<AsiteDomain> :ICreator<AsiteDomain> where AsiteDomain:IDomain
    {
       public ISpeciality<AsiteDomain> CreaterSpeciality()
       {
           return new Asite<AsiteDomain>();
       }
    }
}
using System;
using System.Collections.Generic;
using System.Text;

namespace 工厂方法
{
    public class BtsSiteCreator<BtsSiteManagerDomain> : ICreator<BtsSiteManagerDomain>  where BtsSiteManagerDomain:IDomain
    {
        public ISpeciality<BtsSiteManagerDomain> CreaterSpeciality()
        {
            return new BtsSite<BtsSiteManagerDomain>();
        }
    }
}

最后，实例的时候：
  IDomain asiteDomain= new AsiteDomain();
            ICreator<IDomain> asiteCreator = new AsiteCreator<IDomain>();
            ISpeciality<IDomain> asite = asiteCreator.CreaterSpeciality();
            asite.InserOneInfo(asiteDomain);
对于以后的新的专业类型的增加，只需要分别继承这两个接口就可以，不会存在对原由系统修改的事情了。

最后，付上完全代码；
using System;
using System.Collections.Generic;
using System.Text;

namespace 工厂方法
{
    public interface IDomain
    {
        string Intid
        {
            get;
            set;
        }
    }
}
using System;
using System.Collections.Generic;
using System.Text;

namespace 工厂方法
{
    public class AsiteDomain : IDomain
    {
        private string mIntId;
        public string Intid
        {
            get
            {
                return mIntId;
            }

            set
            {
                mIntId = value;
            }
        }

    }
}
using System;
using System.Collections.Generic;
using System.Text;

namespace 工厂方法
{
    public class BtsSiteManagerDomain : IDomain
    {
        private string mIntId;
        public string Intid
        {
            get
            {
                return mIntId;
            }

            set
            {
                mIntId = value;
            }
        }

    }
}

该模式，能够解决现有的类的创建工作，并且能够满足后面的新的需求的增加，似乎是很好的了。
但是，咱们那么多的设计模式，各有各的优点，每个模式总有不满足和满足的地方，前面讲了一篇坡的好处，难道该模式就没有缺点么？
缺点在于哪？在于该模式，现阶段 的 每个 ICreator，只是创建单一的实例，那对于一次要创建n多不同的类实例的情况呢？
及，如果我们要实现这样的方法呢？：
using System;
using System.Collections.Generic;
using System.Text;

namespace 工厂方法
{
    public interface ICreator<T> where T : IDomain
    {
        ISpeciality<T> CreaterSpeciality( );
        //这里带上其他的类的创建方法
    }
}
我们又该用什么方法呢？
请看后一节：抽象工厂。