如何使用工厂设计模式创建复杂对象

Question

你好，我必须创建一个复杂的对象，我想为 it.However 使用工厂模式，我不知道如何处理创建对象所需的附加依赖项。

依赖关系

public class SomeService
{
}
public class SomeOtherService
{
}

层次结构

public abstract class NeededObjectBase
{
  public readonly int Type {get;set;}  //id selected by the factory

  public abstract void DoSomething();
}
public class A:NeededObjectBase
{
   private SomeService service;
   A(SomeService service){ this.service=service;}
   public override void DoSomething(){}
}
public class B:NeededObjectBase
{
   public B(SomeService service,SomeOtherService otherService){
       this.service=service;
       this.otherService=otherService
   }
   public SomeOtherService service;
   public SomeOtherService otherService;
   public override void DoSomething(){}
}

工厂

public class Factory
{
   public static NeededObjectBase CreateInstance(int type)
   {
       switch(type)
       {
        case 0:return new A();  //this would need SomeService => new A(someService)
        case 1:return new B();   // this would need SomeService & SomeOtherService => new B(someService,someOtherService);
        default: return new A();
       }
   }
}

用法

public class Aggregate
{
   private SomeService s1;
   private SomeOtherService s2;
   public void UseNeededObject(int type)
   {
     NeededObjectBase neededObject=Factory.CreateInstance(type);
     neededObject.DoSomething();
   }
}

如果您查看代码，情况如下：
我有一个 Aggregate class 在那里我保留了我的 dependencies.
在它的方法里面我使用了 Factory 基于 type 参数以创建正确的对象。
但是我不知道如何处理 dependencies.Should 工厂获取所有必需的依赖项以创建对象？

所以基本上我不知道谁应该保留对象的依赖关系 creation.The 工厂进行选择但它如何提供正确的依赖关系以实例化选择？

P.S 我需要以某种方式首先根据参数进行选择并从工厂检索 something 然后得到它的东西依赖项以创建最终对象。

Answer 1

这样做的一个好方法是使用 DI 库，然后将它提供的任何容器注入工厂；然后工厂只根据传递的参数决定它应该 return 的类型，然后委托给容器为 return.

构造该对象

这有一些好处

它可以让您将这些依赖对象（实际上是构造对象）的生命周期与工厂分开
它使工厂不必知道如何构建它提供的所有可能的对象图，并让它专注于决定要构建什么什么，而不是如何构建它

例如

public class SimpleFoo: Foo
{
    public  SimpleFoo(IServiceA a){...}
}

public class ComplexFoo: Foo
{
    public  ComplexFoo(IServiceA a, IServiceB b){...}
}

public class DegenerateFoo: Foo
{
    public DegenerateFoo(){..does nothing...}
}

public class FooFactory
{    
    readonly IContainer _container;
    public void FooFactory(IContainer container){_container=container;}

    public Foo GetAFoo(int type)
    {
       switch (type)
       {
            case 0:
                return _container.Get<SimpleFoo>();
            case 1:
                return _container.Get<ComplexFoo>();
            default:
                //unknown case, return some kind of Foo that does nothing
                return _container.get<DegenerateFoo>();
       }
    }
}

同时，您的容器将在应用程序的其他地方单独配置 "Composition Root" 以了解如何解析对象图（以下仅为伪代码）

container.RegisterTransient<IServiceA, ServiceAImplementation>();
container.RegisterSingleton<IServiceB, ServiceBImplementation>();

在这种情况下，我们将任何 IServiceA 注入配置为每次请求时都是一个新的对象实例；而 IServiceB 注入将是一个单一的共享实例，容器负责创建一次并根据请求分发。当然，这只是您如何配置这些依赖项的示例，最终您最清楚需要如何配置这些依赖项的生命周期。

希望你明白了。

如何使用工厂设计模式创建复杂对象

How to create complex objects using factory design pattern

c#

dependencies

design-patterns

factory