标签: abstract-factory

我有一个单独的"Base"类,以及从Base派生的几十个类.我想有一个方法,通过索引创建正确的类.像这样:

class Base
{
};

class A : public Base
{
}

class B : public Base
{
}

class C : public Base
{
}

Type array = { A, B, C };

然后我就能做到 new array[i];

如何用C++(0x)实现这一目标？通常我会使用抽象工厂模式.但是由于我有很多派生类,这确实会减慢程序的速度.

由于派生类只会使用一次我也教过使用它:

Base *array = { new A, new B, new C };

但是这会导致巨大的内存消耗,不计算并不是每个类都会被使用.

有什么建议吗？

很抱歉再次询问.我在网上搜索但是无法理解因此我必须放在这里.这就是我自己研究的内容.我从头部设计模式研究.

抽象工厂模式:

根据我研究的差异,建筑师有些人感觉它是一个工厂,但它只创造了一种类型,大部分时间.
所以我可以说上面的图像中的NYStore是构建器,因为它将比萨对象返回给客户端？我对么？请根据以上示例给出您的答案,这可能有助于我学习它.

我有以下类和接口结构,我很难尝试让代码完成我需要的工作.

public interface IUserManager
{
    int Add(User user);
}

public class UserManagerA : IUserManager{}
public class UserManagerB : IUserManager{}

在这个例子中,我使用Ninject作为IoC容器,但如果其他容器解决了这个问题,我可以更改它:

这是在我的内心NinjectWebCommon.cs:

void RegisterServices(IKernel kernel)
{
    string userRole = CurrentUser.Role;//this gets the user logged in
    //This is the part I do not how to do
    //I wish I could just type this in:
    kernel.Bind<IUserManager>().To<UserManagerA>()
        .When(userRole == "RoleA"); // this doesn't work obviously
    kernel.Bind<IUserManager>().To<UserManagerB>()
        .When(userRole == "RoleB"); // same doesn't work
}

所有这一切,以便在我的(MVC)控制器中我可以这样做:

public class UserController
{
    private readonly IUserManager …

CodeCampServer源代码包含一个通用的StaticFactory.

我猜想这是框架如何与依赖注入很好地结合的机制的关键部分.

其中的子类使用它的DefaultUnconfiguredState来提供对自己的默认未配置状态的静态访问,依赖解析机制可以用工作内容替换它们.

我找不到任何相关文件......

书中有一个很好的解释吗？(我正在等待从亚马逊送货......)

...或者其他任何人都能对这是什么提出一个很好的评论,以及我是否明智地采用这种模式(如果它是一个......)？

更新

由于Jeffrey Palermo回答了这个问题,我看到在MVC2 in Action的(正在进行中)手稿中,使用Factory来讨论和说明这种模式/样式,该工具用于定位存储库以保持域层无知持久性问题.(见第23章).

默认情况下,使用此工厂会引发异常:

"关于如何创建存储库的知识不在工厂中.这个工厂只代表返回存储库的能力"

该示例可能使用了几种机制之一来初始化存储库接口的具体实现.在本书的示例中,为了简单起见,他们选择不使用IOC容器,并在某些启动逻辑中明确提供它.

"重要的是,Core项目和UI项目都不应该引用基础设施项目或纯粹基础设施的库.我们已经将NHibernate完全放在一边,以便应用程序的其余部分不关心如何数据访问正在发生"

关于新章节中的示例代码的最后一点是工厂不再是静态的(至少不是涉及面向外部的接口).

更新2

Palermo先生在博客上发表了关于抽象工厂这种特殊风格的更多信息(参见OrderShipperFactory的实现).

我也可以考虑'手动依赖注入'(Uncle Bob).

更新3 - 2016年3月

这里有另一个例子,虽然Jeffrey明确表示这是演示代码,而评论表明这将配置在Mark Seeman所谓的组合根(即应用程序启动时)

我在杰弗里的文章发现了这个" 洋葱体系结构:第4部分-四年后的 "

我正在尝试学习创建型设计模式，我想我现在了解工厂方法模式。但是在转向抽象工厂模式时，我找不到它的用途。我知道我想念这个，但不知道在哪里。

在抽象工厂模式中，我们将有一个抽象工厂，具体工厂将返回实例。假设我们正在处理汽车的创建。我们将有一个抽象工厂，比如

public interface CarFactory{
    public Car getCar();
}

我们的具体工厂将类似于

public class AudiFactory{
    public Car getCar(){
        return new Audi();
    }
}

public class VolvoFactory{
    public Car getCar(){
        return new Volvo();
    }
}

在用户类中，我们将像这样使用它

CarFactory factory = new AudiFactory();
Car carAudi = factory.getCar();
factory = new VolvoFactory();
Car carVolvo = factory.getCar();

我认为我们也可以使用工厂模式构建相同的功能

public class CarFactory{

    public Car getCar(String make){
    if("Audi".equals(make))
        return new Audi();
    else if("Volvo".equals(make))
        return new Volvo();
    }
}

在用户类中我们可以

CarFactory factory = new CarFactory();
Car carAudi = factory.getCar("Audi");
Car …

我试图理解抽象工厂模式，这是我的第一个近似值：

#include <iostream>
using namespace std;

class Soldier
{
    public:
    virtual void shoot()=0;
};

class Archer: public Soldier
{
    public:
    void shoot(){
        cout<<"Archer shoot"<<endl;
    }
};

class Rider: public Soldier
{
    public:
    void shoot(){
        cout<<"Rider shoot"<<endl;
    }
};

class AbstractFactory
{
    public:
    virtual Soldier* createArcher()=0;
    virtual Soldier* createRider()=0;
};

class OrcFactory: public AbstractFactory
{
    Soldier* createArcher()
    {
        return new Archer();
    };
    Soldier* createRider()
    {
        return new Rider();
    };
};

class HumanFactory: public AbstractFactory
{
    Soldier* createArcher()
    {
        return new Archer(); …

我在阅读了许多关于 C# 中的抽象工厂设计模式的文章后写了这个问题。我真的无法从所有这些文章提供的示例中获得现实世界的用例意义。我所能看到的只是汽车/计算机/电话等的一些基本示例。我知道它们对于提供简单的解释很重要。但我真的无法将其映射到现实世界中的任何东西，因为如果我真的遵循这样的示例，当我想要引入新对象时，我的代码将每隔一周更改一次。

下面是它的示例代码

namespace ClassLibrary1
{

    public interface AbstractProductA { }
    public class ProductA1 : AbstractProductA { }
    public class ProductA2 : AbstractProductA { }


    public interface AbstractProductB { }
    public class ProductB1 : AbstractProductB { }
    public class ProductB2 : AbstractProductB { }


    public interface AbstractFactory
    {
        AbstractProductA CreateProductA();
        AbstractProductB CreateProductB();
    }


    public class ConcreteFactoryA : AbstractFactory
    {
        public AbstractProductA CreateProductA()
        {
            return new ProductA1();
        }

        public AbstractProductB CreateProductB()
        {
            return new ProductB1();
        }
    }

    public class ConcreteFactoryB …

我已经阅读了很多关于抽象工厂和工厂方法之间不同的帖子,但是有一个我无法理解的问题.

两者之间的一个区别是,使用抽象工厂模式,类通过组合将对象实例化的责任委托给另一个对象,而工厂方法模式使用继承并依赖子类来处理所需的对象实例化

也许我知道为什么抽象工厂模式使用组合和委托创建对象,但我无法理解为什么工厂方法模式使用继承来创建具体的类对象.