设计模式学习笔记三：简单工厂（Simple Factory）

    开始学习创建型模式，这些模式的使用是面向接口编程的必然结果，面向接口编程要求针对接口，而不是具体的实现，这样程序可以不用关心具体使用实现也能做到实现的互换。尽管编程是面向接口，但执行是操作需要实例化后的对象，而实例化必须要针对具体的类。如果直接实例化，则破坏了面向接口编程的原则。解决的方法就是通过一个专门实例化的类来获得具体的对象，通常我们将这个类成为“工厂”，将与实例化相关的模式成为“创建型模式”。
    1.概述
     简单工厂（Simple Factory）的作用是实例化对象，而不需要客户了解这个对象属于那个具体的子类。在GOF的设计模式中并没有简单工厂，而是将其作为工厂方法的一个特例加以解释，简单工厂就是参数化的工厂方法。该模式是通过switch分支(也有用if判断的)，来决定最终生成哪一个对象的，而这个switch分支语句，嵌在一个静态方法中，这个改装就是简单工厂。
    2.实例    
    1）.大话设计模式中的计算器用简单工厂实现。
    结构图:

    代码：
    Operation基类：

Code
 public class Operation
    {
        private double _numbleA=0;
        private double _numbleB=0;

        public double NumbleA
        {
            get { return _numbleA; }
            set { _numbleA = value; }
        }

        public double NumbleB
        {
            get { return _numbleB; }
            set { _numbleB = value; }
        }

        public virtual double GetResult()
        {
            double Result = 0;
            return Result;
        }
    }

加法类：

Code
    public class OperationAdd:Operation 
    {
        public override double GetResult()
        {
            double Result = 0;
            Result = NumbleA + NumbleB;
            return Result;
        }
    }

减法类：  

Code
    public class OprationSub:Operation
    {
        public override double GetResult()
        {
            double Result = 0;
            Result = NumbleA + NumbleB;
            return Result;
        }
    }

乘法类：

Code
    public class OperationMul:Operation 
    {
        public override double GetResult()
        {
            double Result = 0;
            Result = NumbleA + NumbleB;
            return Result;
        }
    }

运算工厂类：

Code
    public class OperationFactory
    {
        public static Operation CreateOperate(string Operate)
        {
            Operation oper = null;
            switch (Operate)
            {
                case "+":
                    oper=new OperationAdd();
                    break;
                case "-":
                    oper = new OprationSub();
                    break;
                case "*":
                    oper = new OperationMul();
                    break;
            }
            return oper;
        }
    }

    2）.典型应用——获取数据连接对象
    结构图：
    
    具体代码实现：
    数据库操作基类：

Code
    public abstract class AbstractDB
    {
        protected string connString;
        public string ConnString
        {
            get { return connString; }
            set { connString = value; }
        }

        public void New(string cs)
        {
            connString = cs;
        }

        public  abstract void Open();
        public abstract void Close();
        public abstract DataTable ExecSql(string strSql);
        public abstract void ExecSqlNoquery(string strSql);
        public abstract string TrateDateFiled(string strDateValue);
    }

    Sql2005实现类：
    其他实现类相同，不再重复。哈哈，比较偷懒。

Code
public class Sql2005DB : AbstractDB
    {
        private SqlConnection Mconn;

        public  Sql2005DB(string cs)
        {
            base.New(cs);
            Mconn = new SqlConnection();
        }

        public override void Open()
        {
            if (Mconn == null)
            {
                Mconn=new SqlConnection();
            }
        }

        public override void Close()
        {
            if (Mconn != null && Mconn.State != ConnectionState.Closed)
            {
                Mconn.Close();
            }
        }

        public override DataTable ExecSql(string strSql)
        {
            DataTable dt=new DataTable();
            SqlCommand sqlCom = new SqlCommand(strSql);
            SqlDataAdapter da = new SqlDataAdapter(sqlCom);
            sqlCom.Connection = Mconn;
            da.Fill(dt);
            return dt;
        }

        public override void ExecSqlNoquery(string strSql)
        {
            SqlCommand sqlCom = new SqlCommand(strSql);
            sqlCom.Connection = Mconn;
            sqlCom.ExecuteNonQuery();
        }

        public override string TrateDateFiled(string strDateValue)
        {
            return "_ToDate(" + strDateValue + ")";
        }
    }

    数据库工厂：

Code
public class DBFactory
    {
        public static AbstractDB CreateDB(string strType,string strConnString)
        {
            AbstractDB mysql=null;
            switch (strType)
            {
                case "OleDB":
                     mysql = new OleDB(strConnString);
                     break;
                case "Sql@005":
                     mysql = new Sql2005DB(strConnString);
                     break;
                case "":
                     mysql = new OracleDB(strConnString);
                     break;
            }
            return mysql;
        }
    }

    3.总结
    简单工厂的使用场合：简单工厂实例化的类具有相同的接口，种类有限并且基本不需要扩展时，可以使用简单工厂，例如，我们实现不同数据库连接时，常用数据库类可以预知，则可以使用简单工厂。
    简单工厂的优点是可以使用户根据参数获得对应的类实例，避免了直接实例化类，降低了耦合性；缺点是所实例化的类在编译期间已经被确定，如果增加新类型，则需要修改工厂。一旦增加新产品类，同时要实现抽象类中的所有方法；还有，一旦要修改抽象类中的方法，所有子类都要变动——扩展性差，不符合开闭原则。另外，简单工厂模式通常使用静态工厂方法，这使得无法由子类继承，造成工厂角色无法形成基于继承的等级结构。
    简单工厂要知道所有要生成的类型，当子类过多或者子类层次过多时就不适合使用简单工厂。