标签: factory

我有一些Python代码,它基于来自iCalendar文件的解析的VEvent对象创建一个Calendar对象.

日历对象只有一个方法,可以在解析时添加事件.

现在我想创建一个工厂函数,用于从文件对象,路径或URL创建日历.

我一直在使用iCalendar python模块,它直接在Class上实现工厂函数作为类方法,它返回一个实例:

cal = icalendar.Calendar.from_string(data)

从我对Java的了解很少,这是Java代码中的一种常见模式,尽管我似乎发现对工厂方法的更多引用与实际想要实例化实例的类不同.

问题是,这也被认为是Pythonic吗？或者只是创建一个模块级方法作为工厂函数,它被认为更pythonic？

使用接口是一种非常简单的方法来删除依赖项,但是当您的某个类需要一个未由接口定义的方法时会发生什么？如果您正在使用构造函数注入或工厂,那么如何在不进行转换的情况下访问该额外方法？这可能吗？

这是一个有这个问题的工厂的例子.我想做一些不可能的事吗？谢谢你的帮助.

interface IFoo {
    int X { get; set; }
    int Y { get; set; }
}

public class A : IFoo {
    int X { get; set; }
    int Y { get; set; }
}

public class B : IFoo {
    int X { get; set; }
    int Y { get; set; }
    int Z { get; set; }
}

public static class FooFactory {
    public static IFoo GetFoo(string AorB) {
        IFoo result = null;
        switch (AorB) { …

autofac是否可以创建只能解析特定基类类型的通用工厂？

我现在看到改造一个'brownfield'c#项目使用autofac是多么可行.该项目需要创建一个不同类型但具有相同基类的组件树.这些组件需要身份验证和数据库服务(以及其他内容),因此很难只拥有空构造函数.

因此,工厂可以创建导出基类的对象,使用autofac扫描这些类,并为它们提供工厂.我认为如果你不必为每个类提供工厂,它可能会更容易构建组件对象树.

除此之外,还是这是一个糟糕设计的标志？组件和树应该尽可能少地执行,我们将此树传递给其他服务以提供处理和呈现吗？

像(哪里？是神秘工厂)的东西

public MyBase { 
    public Add(MyBase x) {..}
}

public DerivedA: MyBase {}

public DerivedB : MyBase {}

public DerivedC : DerivedA {}

public SomethingElse
{
     private ? _myBaseFact;

     public SomethingElse(? myBaseFact) { 
            _myBaseFact = myBaseFact;
     }

     public BuildComponentTree() {
        DerivedA a = _myBaseFact<DerivedA>();
        DerivedB b = _myBaseFact<DerivedB>();
        DerivedC c = _myBaseFact<DerivedC>();
        a.Add(b);
        b.Add(c);
     }
}

编辑:我被要求一个更具体的例子,这是公平的:)有框架组件,我想允许开发人员创建自己的组件,而无需注册autofac.拥有工厂类意味着开发人员必须将自定义组件添加到此工厂吗？请原谅这个例子,这与我遇到它时框架的工作原理类似.

FwComponent {
    public FwComponent (DataProvider, AuthManager, OtherModule)
    public Add(FwComponent x);
    public Setup();
    public Process();
    public Render();
}

Page : …

我在理解为什么这段代码不起作用时遇到了一些麻烦.我从二叉树中的99个Scala问题中得到了它(http://aperiodic.net/phil/scala/s-99/).它看起来对我有用:Node对象是Node类的伴随对象,它在树上添加叶子的构造函数.但是当我尝试编译它时,我会得到以下结果:

<console>:10: error: too many arguments for method apply: (value: T)Node[T] in object Node

    def apply[T](value: T): Node[T] = Node(value, End, End)

如果我删除两个Ends,我没有得到任何编译错误,但如果我创建一个具有单个值的Node,我会陷入无限循环.所以看起来应用就是构造更多的Node对象,而不是将自己与Node类相关联.

任何帮助表示赞赏.

sealed abstract class Tree[+T]
case class Node[+T](value: T, left: Tree[T], right: Tree[T]) extends Tree[T] {
    override def toString = "T(" + value.toString + " " + left.toString + " " + right.toString + ")"
}
case object End extends Tree[Nothing] {
    override def toString = "."
}
object Node {
    def apply[T](value: T): Node[T] = Node(value, …

在我的程序中,一些对象需要其他对象(依赖),而我正在使用Factory作为我的创建模式.

现在,我该如何解决一个简单的依赖问题？

这是我正在做的解决问题的一个例子.我想知道将所需对象发送到Create方法是不是非常错误.

//AbstractBackground
// - SpecialBackground
// - ImageBackground
// - NormalBackground
class Screen{
    List<AbstractBackground> list;
    Cursor cursor;
    ContentManager content;

    public void load(string[] backgroundTypes){
        //is this okay? --------------->
        AbstractBackground background = BackgroundFactory.Create(backgroundTypes[0], cursor, content);
        list.add(background);
    }
}

class BackgroundFactory{
    static public AbstractBackground Create(string type, Cursor cursor, ContentManager content){

        if( type.Equals("special") ){
            return new SpecialBackground(cursor, content);
        }

        if( type.Equals("image") ){
            return new ImageBackground(content);
        }

        if( type.Equals("normal") ){
            return new NormalBackground();
        }
    }
}

我正在尝试创建这个bean:

<bean id="myBean" class="java.lang.String" factory-method="valueOf">
    <constructor-arg name="obj" value="a string" type="java.lang.Object"/>
</bean>

我希望Spring java.lang.String#valueOf(Object obj)在创建bean时使用此方法.

我明白了:

Caused by: org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'myBean' defined in class path resource [META-INF/test-contexts/testManualDependencyBundleResolverContext.xml]: Unsatisfied dependency expressed through constructor argument with index 0 of type [char[]]: Ambiguous factory method argument types - did you specify the correct bean references as factory method arguments?
Related cause: org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'myBean' defined in class path resource [META-INF/test-contexts/testManualDependencyBundleResolverContext.xml]: Unsatisfied dependency expressed through constructor …

我在使用Castle.Windsor的TypedFactoryFacility概念时遇到了问题,并且不确定如何解决它(或者如果我可以).

我有一个像这样定义的ViewModel;

public class MyViewModel : IMyViewModel
{
    // constructor which I aim to access through the factory
    public MyViewModel(
        ISomeContainerResolvableDependency a,
        ISomePassedInDependency b)
    { ... }
}

并且定义了相应的工厂接口;

public interface IMyViewModelFactory 
{
    IMyViewModel Create(ISomePassedInDependency a);

    void Release(IMyViewModel vm);
}

但是,当我尝试使用类似的有效非null实例调用工厂时ISomePassedInDependency;

ISomePassedInDependency o = new SomePassedInDependency();
IMyViewModelFactory factory = IoC.Get<IMyViewModelFactory>();
IMyViewModel viewModel = factory.Create(o);

我得到一个异常,指出温莎城堡无法从解决的依赖IMyViewModel上ISomePassedInDependency.在这种情况下,我正在提供ISomePassedInDependency实例,只希望设施ISomeContainerResolvableDependency为我解决.

如果我将构造函数定义更改为接受我传入的值类型(int例如)而不是ISomePassedInDependency实例,则工厂调用将起作用.因此,似乎Castle Windsor内部假设所有引用类型都将被容器解析而其他任何东西都不会被解析？

有没有办法使这项工作？

我们有一个我们多次使用的模式,我们在不同的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"; …

这与Joshua Bloch撰写的"Effective Java"一书中创建和销毁对象有关

第1项:考虑静态工厂方法而不是构造函数

此方法将布尔基元值转换为布尔对象引用:

public static Boolean valueOf(boolean b) {
    return b ? Boolean.TRUE : Boolean.FALSE;
}

请注意,静态工厂方法与"设计模式"中的"工厂方法"模式不同[Gamma95,p.107].此项中描述的静态工厂方法在设计模式中没有直接等效项.

作者似乎在谈论静态工厂方法和工厂方法模式之间的区别.这有什么区别？

另外一点,BalusC 在这个帖子中提到了 Factory Method下的一个链接,java.util.Calendar#getInstance()这是一个静态工厂方法,因此建议静态工厂方法是Factory Method Pattern的子集.

我正在配置Quartz库以使用Simple Injector,我有正确注册它的问题.问题是,GetScheduler()是异步这个代码注册Task<IScheduler>不IScheduler

 container.Register(async () =>
 {
      return await container.GetInstance<ISchedulerFactory>().GetScheduler();
 });

如何在Simple Injector中注册异步的工厂方法？当然,我可以等使用效果Result的Task,但也许还有其他办法吗？