设计模式之工厂模式(Factory pattern)

工厂模式有三种:简单工厂模式,工厂方法(Factory Method) 工厂模式,抽象工厂(Abstract Factory)工厂模式

1 简单工厂模式:这种模式用过给工厂传递不同的参数来产生不同类的对象.

先建立抽象基类和需要实际操作的类

namespace FactoryPattern
{
    public abstract class AbstractBaseClass
    {
        //定义virtual方法 在子类中可以被重写
        public virtual void SaySomeThing()
        {
            Console.WriteLine("这是{0}中的{1}方法", "AbstractBaseClass", "SaySomeThing()");
        }
    }
}

//

namespace FactoryPattern
{
    public class MySqlHepler : AbstractBaseClass
    {
        //重写基类方法
        public override void SaySomeThing()
        {
            base.SaySomeThing();//先执行基类中的方法
            Console.WriteLine("这是{0}中的{1}方法", "MySqlHepler", "SaySomeThing()");
        }
    }
}

//

namespace FactoryPattern
{
    public class MsSqlHelper : AbstractBaseClass
    {
        //重写基类方法
        public override void SaySomeThing()
        {
            base.SaySomeThing();//先执行基类中的方法
            Console.WriteLine("这是{0}中的{1}方法", "MsSqlHelper", "SaySomeThing()");
        }
    }
}

再建立简单工厂类

namespace FactoryPattern
{
    public class SimpleFactory
    {
        public static AbstractBaseClass CreateInstance(string arg0)
        {
            switch (arg0)
            {
                case "mysql":
                    return new MySqlHepler();
                case "mssql":
                    return new MsSqlHelper();
                default: //参数错误时 默认创建MySqlHepler对象
                    return new MySqlHepler();
            }
        }
    }
}

调用代码

namespace DesignPatternDemo
{
    class Program
    {
        static void Main(string[] args)
        { 

            var MySql = SimpleFactory.CreateInstance("mysql");
            var MsSql = SimpleFactory.CreateInstance("mssql");
            var Oracle = SimpleFactory.CreateInstance("oracle"); //本意是想创建Oracle的实例

            MySql.SaySomeThing();
            MsSql.SaySomeThing();
            Oracle.SaySomeThing(); 
        }
    }
}

 

运行结果

 

传递不同参数 获得不同的实例 并且通过重写,实现多态

缺点:每新增一个操作类 都要修改工厂类,耦合性比较高

2 工厂方法工厂模式 

创建实现类基类

namespace FactoryPattern
{
    public abstract class AbstractBaseClass
    {
        //定义virtual方法 在子类中可以被重写
        public virtual void SaySomeThing()
        {
            Console.WriteLine("这是{0}中的{1}方法", "AbstractBaseClass", "SaySomeThing()");
        }
    }
}

创建具体实现类 继承上面的基类

namespace FactoryPattern
{

    public class MsSqlHelper : AbstractBaseClass
    {
        //重写基类方法
        public override void SaySomeThing()
        {
            Console.WriteLine("这是{0}中的{1}方法", "MsSqlHelper", "SaySomeThing()");
        }
    }



public class MySqlHelper : AbstractBaseClass
    {
        //重写基类方法
        public override void SaySomeThing()
        {
            Console.WriteLine("这是{0}中的{1}方法", "MySqlHelper", "SaySomeThing()");
        }
    }
}

创建工厂基类

namespace FactoryPattern
{
    public abstract class FactoryMethod
    {
        public abstract AbstractBaseClass CreateInstance();
    }
}

创建具体实现类的工厂类

namespace FactoryPattern
{
    public class MsSqlFactory : FactoryMethod
    {
        public override AbstractBaseClass CreateInstance()
        {
            return new MsSqlHelper();
        }
    }
}

namespace FactoryPattern
{
    public class MysqlFactory : FactoryMethod
    {
        public override AbstractBaseClass CreateInstance()
        {
            return new MySqlHelper();
        } 
    }
}

调用

namespace DesignPatternDemo
{
    class Program
    {
        static void Main(string[] args)
        { 
            var mysqlfac = new MysqlFactory();
            var mssqlfac = new MsSqlFactory();
            var mysql = mysqlfac.CreateInstance();
            var mssql = mssqlfac.CreateInstance();
            mysql.SaySomeThing();
            mssql.SaySomeThing();
        }
    }
}

运行结果

通过不同的工厂产生不用的类,每个类的初始化可以有不同的实现方式,并且不需要通过修改参数创建不同对象 降低了耦合性

缺点:每一类产品都需要一个工厂类,增加工作量