思维 » 工厂 http://blog.acmind.com Acme of Mind Mon, 19 Apr 2010 02:23:51 +0000 http://wordpress.org/?v=2.9.2 en hourly 1 抽象工厂模式 http://blog.acmind.com/archives/129 http://blog.acmind.com/archives/129#comments Sat, 17 Jan 2009 02:10:26 +0000 笑谈 http://blog.acmind.com/?p=129 image

User.cs

class User
{
    private int _id;
    public int ID
    {
        get { return _id; }
        set { _id = value; }
    }

    private string _name;
    public string NAME
    {
        get { return _name; }
        set { _name = value; }
    }
}

IUser.cs

interface IUser
{
    void Insert(User user);

    User GetUser(int id);
}

SqlserverUser.cs

class SqlserverUser : IUser
{
    public void Insert(User user)
    {
        Console.WriteLine("在SQL Server中给User表增加一条记录。");
    }

    public User GetUser(int id)
    {
        Console.WriteLine("在SQL Server中根据ID得到User表一条记录。");
        return null;
    }
}

AccessUser.cs

class AccessUser : IUser
{
    public void Insert(User user)
    {
        Console.WriteLine("在Access中给User表增加一条记录。");
    }

    public User GetUser(int id)
    {
        Console.WriteLine("在Access中根据ID得到User表一条记录。");
        return null;
    }
}

Department.cs

class Department
{
    private int _id;
    public int ID
    {
        get { return _id; }
        set { _id = value; }
    }

    private string _deptName;
    public string DeptName
    {
        get { return _deptName; }
        set { _deptName = value; }
    }
}

IDepartment.cs

interface IDepartment
{
    void Insert(Department department);

    Department GetDepartment(int id);
}

SqlserverDepartment.cs

class SqlserverDepartment : IDepartment
{
    public void Insert(Department department)
    {
        Console.WriteLine("在SQL Server中给Department表增加一条记录。");
    }

    public Department GetDepartment(int id)
    {
        Console.WriteLine("在SQL Server中根据ID得到Department表一条记录。");
        return null;
    }
}

AccessDepartment.cs

class AccessDepartment : IDepartment
{
    public void Insert(Department department)
    {
        Console.WriteLine("在Access中给Department表增加一条记录。");
    }

    public Department GetDepartment(int id)
    {
        Console.WriteLine("在Access中根据ID得到Department表一条记录。");
        return null;
    }
}

IFactory.cs

interface IFactory
{
    IUser CreateUser();

    IDepartment CreateDepartment();
}

SqlserverFactory.cs

class SqlserverFactory : IFactory
{
    public IUser CreateUser()
    {
        return new SqlserverUser();
    }

    public IDepartment CreateDepartment()
    {
        return new SqlserverDepartment();
    }
}

AccessFactory.cs

class AccessFactory : IFactory
{
    public IUser CreateUser()
    {
        return new AccessUser();
    }

    public IDepartment CreateDepartment()
    {
        return new AccessDepartment();
    }
}

Client.cs

class Client
{
    static void Main(string[] args)
    {
        User user = new User();
        Department department = new Department();

        IFactory factory = new SqlserverFactory();
        //IFactory factory = new AccessFactory();

        IUser iu = factory.CreateUser();
        iu.Insert(user);
        iu.GetUser(1);

        IDepartment id = factory.CreateDepartment();
        id.Insert(department);
        id.GetDepartment(1);

        Console.Read();
    }
}

小结：

  • 本例分析：只有一个User类和User操作类时，是只需要工厂模式的，但现在加入新表，而且SQL Server与Access又是两大不同的分类，所以解决这种涉及多个产品系列的问题，用到了抽象工厂模式。
  • 优点：最大的好处是易于交换产品系列，由于具体工厂类，如IFactory factory=new AccessFactory()，在一个应用中只需要在初始化时出现一次，这就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即可使用不同的产品配置；第二大好处是，它让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户代码中。
  • 缺点：比如我们要增加项目表Project，至少要增加三个类，IProject、SqlserverProject、AccessProject，还需要更改IFactory、SqlserverFactory和AccessFactory才可以完全实现；另外，客户端程序类不只一个时，很多地方都在用IUser或IDepartment，每一个类在开始都会声明IFactory factory=new SqlserverFactory()，如果我有100个调用数据库的类，就要更改100次IFactory factory=new SqlserverFactory()。［此种情况时可以考虑用简单工厂模式＋抽象工厂模式进行，随后也可以再过渡到反射＋抽象工厂模式（反射＋配置文件）］。
]]> http://blog.acmind.com/archives/129/feed 0 简单工厂模式VS.工厂方法模式 http://blog.acmind.com/archives/126 http://blog.acmind.com/archives/126#comments Sat, 17 Jan 2009 01:58:09 +0000 笑谈 http://blog.acmind.com/?p=126 先将上面2个图拿出来做比较：

简单工厂：

clip_image001

工厂方法：

clip_image002

1、简单工厂模式下，工厂类与具体父类及具体子类都有关联；而工厂模式下，工厂类只与具体父类有关联，由工厂子类负责与具体子类进行关联。

2、如果在简单工厂模式下加入新功能扩展，就要对工厂类做修改，加入新功能；而在工厂模式下，只是单纯地加入工厂子类和具体子类，而不需要对工厂类做修改，做到了“开放扩展，封闭修改”。

3、其实尽管对工厂类不需要做修改了，但是也要对客户端做修改，因为添加了对新功能的调用。也就是说工厂模式做到了对工厂类的开闭原则，却解决不了对客户端的修改。

4、一些情况下，可以考虑用工厂模式＋反射来解决客户端修改问题。

]]> http://blog.acmind.com/archives/126/feed 0 工厂方法模式 http://blog.acmind.com/archives/121 http://blog.acmind.com/archives/121#comments Sat, 17 Jan 2009 01:54:43 +0000 笑谈 http://blog.acmind.com/?p=121 image

Operation.cs

public class Operation
{
    private double _numberA = 0;
    private double _numberB = 0;

    public double NumberA
    {
        get { return _numberA; }
        set { _numberA = value; }
    }

    public double NumberB
    {
        get { return _numberB; }
        set { _numberB = value; }
    }

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

OperationAdd.cs

class OperationAdd : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA + NumberB;
        return result;
    }

}

OperationSub.cs

class OperationSub : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA - NumberB;
        return result;
    }
}

OperationMul.cs

class OperationMul : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA * NumberB;
        return result;
    }
}

OperationDiv.cs

class OperationDiv : Operation
{
    public override double GetResult()
    {
        double result = 0;
        if (NumberB == 0)
            throw new Exception("除数不能为0。");
        result = NumberA / NumberB;
        return result;
    }
}

IFactory.cs

interface IFactory
{
    Operation CreateOperation();
}

AddFactory.cs

class AddFactory : IFactory
{
    public Operation CreateOperation()
    {
        return new OperationAdd();
    }
}

SubFactory.cs

class SubFactory : IFactory
{
    public Operation CreateOperation()
    {
        return new OperationSub();
    }
}

MulFactory.cs

class MulFactory : IFactory
{
    public Operation CreateOperation()
    {
        return new OperationMul();
    }
}

DivFactory.cs

class DivFactory : IFactory
{
    public Operation CreateOperation()
    {
        return new OperationDiv();
    }
}

Client.cs

class Client
{
    static void Main(string[] args)
    {
        IFactory operFactory = new AddFactory();
        Operation oper = operFactory.CreateOperation();
        oper.NumberA = 1;
        oper.NumberB = 2;
        double result = oper.GetResult();
        Console.WriteLine(result);
    }
}

小结：

  • 模式分析：工厂方法模式是类的创建模式，主要实现的是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。工厂方法模式有一个别名叫多态性工厂模式，因为具体工厂类都有共同的接口或共同的抽象父类。
  • 优点：核心的工厂类不再负责所有产品的创建，仅仅负责给出具体工厂必须实现的接口，而不接触哪一个产品类被实例化这种细节，使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。当系统扩展需要添加新的产品对象时，仅仅需要有添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，符合“开放－封闭”原则。
]]> http://blog.acmind.com/archives/121/feed 0 简单工厂模式 http://blog.acmind.com/archives/94 http://blog.acmind.com/archives/94#comments Fri, 16 Jan 2009 18:06:39 +0000 笑谈 http://blog.acmind.com/?p=94  

Operation.cs

public class Operation
{
    private double _numberA = 0;
    private double _numberB = 0;

    public double NumberA
    {
        get { return _numberA; }
        set { _numberA = value; }
    }

    public double NumberB
    {
        get { return _numberB; }
        set { _numberB = value; }
    }

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

OperationAdd.cs

class OperationAdd : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA + NumberB;
        return result;
    }
}

OperationSub.cs

class OperationSub : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA - NumberB;
        return result;
    }
}

OperationMul.cs

class OperationMul : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA * NumberB;
        return result;
    }
}

OperationDiv.cs

class OperationDiv : Operation
{
    public override double GetResult()
    {
        double result = 0;
        if (NumberB == 0)
            throw new Exception("除数不能为0。");
        result = NumberA / NumberB;
        return result;
    }
}

OperationFactory.cs

public class OperationFactory
{
    public static Operation CreateOperate(string operate)
    {
        Operation oper = null;
        switch (operate)
        {
            case "+":
                oper = new OperationAdd();
                break;
            case "-":
                oper = new OperationSub();
                break;
            case "*":
                oper = new OperationMul();
                break;
            case "/":
                oper = new OperationDiv();
                break;
        }
        return oper;
    }
}

Client.cs

class Client
{
    static void Main(string[] args)
    {
        Operation oper;
        oper = OperationFactory.CreateOperate("+");
        oper.NumberA = 1;
        oper.NumberB = 2;
        double result = oper.GetResult();
        Console.WriteLine(result);
    }
}

小结：

  • 模式分析：简单工厂模式根据提供给它的数据，返回几个类中的一个类的实例。通常返回的类都有一个公共父类和公共方法。
  • 优点：工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，通过这种方法实现了对责任的分割。
  • 缺点：工厂类集中了所有产品创建逻辑，一旦不能工作，整个系统都要受到影响。同时，系统扩展困难，一旦添加新产品就不得不修改工厂逻辑。
]]> http://blog.acmind.com/archives/94/feed 0