标签: factory-pattern

我正在编写一个用于查询Mediawiki API的框架.我有一个Page代表wiki上的文章的Category类,我也有一个类,它是一个 Page具有更多特定方法的类(比如能够计算该类别中成员的数量.我还有一个方法Page#category?,Page通过查询API以确定文章的名称空间来确定实例化对象是否实际代表Mediawiki类别页面.

class Page
  def initialize(title)
    # do initialization stuff
  end

  def category?
    # query the API to get the namespace of the page and then...
    namespace == CATEGORY_NAMESPACE
  end
end

class Category < Page
  # ...
end

我想要做的是能够检测我的框架的用户是否尝试使用Page对象(即Page.new("Category:My Category"))实例化Mediawiki类别,如果Category是Page,则直接从Page构造函数实例化对象而不是对象.

在我看来,这应该是可能的,因为它让人想起Rails中的单表继承,但我不知道如何让它工作.

我在我的项目中实现了一个工厂,最近建议我在我的类上使用属性,以便工厂可以确定要实例化和传回的类.我是开发世界的新手,并试图严格遵循松散耦合的规则,我想知道是否依赖"钩子"(作为属性)违背了这一点？

我从来没有真正看过工厂模式,今天决定花时间根据这篇文章(http://msdn.microsoft.com/en-us/library/ee817667.aspx)创建一个快速示例,最后让我的头围绕它.

源代码完美地安排在三个单独的程序集中,整齐地命名为Product,Factory和Client.

Factory模式的主要优点(据我所知)是从"Client"类抽象"product"类的实例化.因此,在提供的示例中,无论是否对产品类进行任何更改,Product实例化都不会更改,您仍然必须对客户端类进行更改以传递创建更新产品所需的新值.毕竟这个数据必须来自某个地方？

我读到的另一个例子表明,一旦实现了一个类并且其他类的负载直接使用它,在这里对"product"类所做的更改将需要对该类的每个实例化进行更改,例如,如果构造函数中需要新变量.

根据我的理解,Factory模式确保此类的实例化永远不会更改,如果要将新变量传递给product构造函数,您最终必须将这些新变量传递给更新的工厂.

因此,这显然不能解决问题,而只是移动它并且这样做会增加额外的复杂性.

鉴于这是一种既定的模式,我显然错过了一些东西.因此这篇文章:请向我解释我错过了什么.

谢谢

这是一个工厂方法，如果它返回一个类的一个实例，但它工厂方法如果它返回多个实例（数组）？

我有一个GUI应用程序.在其中,我允许用户从容器提供的算法列表中进行选择.每个算法将在另一个视图中作为后台任务启动.我需要支持此视图的多个实例,并支持同一算法的多个实例.该视图也将由容器提供.该算法也是有状态的.

所以我有一个案例,我需要创建我的视图和算法的实例,并在运行时将它们绑定在一起.我没有这些实例的静态绑定点,所以我不能使用正常的注入工具(构造函数或属性注入).我不想打电话new,我不想像服务定位器那样使用容器.

我在Castle.Windsor中使用Typed Factory Facility解决了这个问题,但我不得不在我的应用程序中处理工厂.工厂设计也有点奇怪,因为当我完成它们时,我不得不将我的实例返回工厂.

我现在正在研究使用NInject,因为到目前为止,学习曲线和介绍文档要好得多,我想为我的团队提出一个容器供我使用.但是对于这样的场景,我认为我必须编写自己的工厂并直接调用内核来解析新实例(嵌入在工厂中的Service Locator),以及在我的注册码中添加工厂方法.

是否有一种通用的方法来解决这个问题,或者这只是一个依赖注入本身不能解决的问题？

澄清:

我在评论中说我想要一个Ninject的具体答案,我已经得到了.非常感谢:)在现实生活中,我可能只是使用已经提出的实用解决方案.

但是我把我的基础作为一个具体的问题来解决我的问题.我希望在标题中对这个问题有一个更纯粹的基本答案.

是否有纯DI技术允许用户在运行时触发组件的新实例？或者所有这些实现都将容器用作服务定位器,或者需要对容器的特定"怪癖"(例如内置工厂支持,ala Castle.Windsor或即将发布的Ninject工厂特性),而不是而只利用"纯"DI的方方面面？

我只听说过Java世界中的这个词,我对它的含义并不太了解 - 请原谅我:)我正在寻找某种"注射"吗？

我有一些相关问题的工厂,仓库和服务在DDD.我有以下实体:文件夹,文件,FileData.

在我看来,"文件夹"是一个聚合根,应该负责创建File和FileData对象.

所以我的第一个问题是我应该使用工厂来创建这个聚合还是由存储库来决定？这时我有2个存储库,一个用于Folder,另一个用于File,但在我看来,我应该将它们合并在一起.以下代码段显示了我的文件夹存储库,它位于我的基础架构层中:

public class FolderRepository : IFolderRepository
{
    #region Fields

    private readonly IFolderContext _context;
    private readonly IUnitOfWork _unitOfWork;

    #endregion

    #region Constructor

    public FolderRepository(IUnitOfWork unitOfWork)
    {
        _unitOfWork = unitOfWork;
        _context = _unitOfWork.Context as IFolderContext;
    }

    #endregion

    public IUnitOfWork UnitOfWork
    {
        get { return _unitOfWork; }
    }

    public IQueryable<Folder> All
    {
        get { return _context.Folders; }
    }

    public Folder Find(Guid id)
    {
        return _context.Folders.Find(id);
    } …

在大多数情况下,当我们编写工厂方法时,它是一堆if可以继续增长的条件.编写这种方法的最有效方法是什么(if条件最少)？

public A createA(final String id) {
    if (id.equals("A1")) {
      return new A1();
    }
    else if (id.equals("A2")) {
      return new A2();
    }
    return null;
  }

我们有一个我们多次使用的模式,我们在不同的Dll中实现处理程序和工厂.我们在运行时配置exe,说明加载了哪些dll,以及应用程序可以使用哪些处理程序.

我们这样做是因为我们为一些客户提供了自定义处理,同时它还具有很大的灵活性,因为我们可以快速开发新的处理程序,并且可以放心地测试和部署它们,我们甚至没有触及正在运行的应用程序的任何其他部分.我们还可以通过简单地放入一个替换dll来修补处理程序,我们让客户拥有严格的变更管理程序并且他们喜欢这个.

要做到这一点,模式依赖于两个级别的工厂,实现特定处理程序的特定工厂,以及一个总体工厂(我们称之为提供者).Provider选择使用哪个处理程序工厂来创建处理程序.

问题:Windsor是否包含可以简化此过程的内容？
具体来说,我正在寻找可以省略Handler工厂对象的东西,它感觉就像它应该能做的事情.
我已经阅读了Typed Factory Facility和UsingFactory&UsingFactoryMethodmethods,但我看不出他们在这里有什么帮助.
也就是说我经常发现Castle Windsor的文档是钝的,所以我可能会遗漏一些明显的东西 或者是否有更好的方法来获得我没有考虑过的相同的最终目标.

这里有一些代码来说明,第一个消息,处理程序和工厂接口

public interface IMessage
{
    string MessageType { get; }
}
public interface IMessageHandler
{
    void Process(IMessage message);
}
public interface IMessageHandlerFactory
{
    bool CanProcessType(string type);
    IMessageHandler Create();
}

在第二个DLL中,我们为Type1实现了一个处理程序和工厂

public class Type1MessageHandler
    : IMessageHandler
{
    public void Process(IMessage message) { }
}
public class Type1MessageHandlerFactory
    : IMessageHandlerFactory
{
    public bool CanProcessType(string type)
    {
        return type == "Type1"; …

我有一个简单的抽象工厂实现:

  public abstract class ICarFactory{
    public abstract ISportsCar CreateSportCar();
    public abstract IFamilyCar CreateFamilyCar();
}

public abstract class ISportsCar {        
    public abstract void Accelerate();
}

public abstract class IFamilyCar  {
    public abstract void Accelarete();
}

public class BMWFactory : ICarFactory {
    public override ISportsCar CreateSportCar() {
        return new BMWi7();
    }

    public override IFamilyCar CreateFamilyCar() {
        return new BMWM5();
    }
}

public class WolksvagenFactory : ICarFactory {

    public override ISportsCar CreateSportCar() {
        return new WVGolfR();
    }

    public override IFamilyCar CreateFamilyCar() {
        return …

我有一个Factory设计模式的小例子,我对这部分感兴趣:

std::make_unique< A >(*this)

......尤其如此*this.

这是否意味着该clone()方法返回一个std::unique_ptr指向工厂类成员的？并且createInstance()总是返回同一个Factory类的成员？

我只是混淆std::make_unique< A >(*this)应该做什么,因为A在构造函数中std::string,而不是指向自身的指针.

class Base {
    public:
        virtual ~Base() {}
        virtual std::unique_ptr<Base> clone() = 0;
        virtual void print() = 0;
};

class A: public Base {
        std::string name_;
    public:
        A(std::string name ){name_ = name;};
        std::unique_ptr<Base> clone() override{
            return std::make_unique<A>(*this);
        };
        void print( ) override{
            std::cout << "Class A: " << name_;    
        };
        virtual ~A(){};
};

class …