改善与工厂模式和DI

Question

我期待就如何改善以下代码代码：

public interface IExample{ void Do(); } 

public interface IExampleA: IExample {} 

public class ExampleA: IExampleA { public void Do(); } 

public interface IExampleB: IExample {} 

public class ExampleB: IExampleB { public void Do(); } 

public interface IExampleFactory{ 
    IExample Make(TypesOfExamples thisIsAnEnum); 
} 

public class ExampleFactory: IExampleFactory { 
    IExampleA _exampleA; 
    IExampleB _exampleB; 

    public ExampleFactory(IExampleA exampleA, IExampleB exampleB) 
    { 
     _exampleA = exampleA; 
     _exampleB = exampleB; 
    } 

    public IExample Make(TypesOfExamples thisIsAnEnum) 
    { 
     switch(thisIsAnEnum) 
     { 
      case A: return _exampleA; 
      case B: return _exampleB; 
     } 
    }   
} 

基本上我不喜欢的是不必使用IExampleA和IExampleB，他们只在那里为是注：

container.Bind<IExampleA>().To.<ExampleA>(); 
container.Bind<IExampleB>().To.<ExampleB>(); 
container.Bind<IExampleFactory>().To.<ExampleFactory>(); 

而且它会像这样

public class ExampleUsage() 
{  
    ExampleFactory _exampleFactory; 

    public ExampleUsage(ExampleFactory exampleFactory) 
    { 
     _exampleFactory = exampleFactory; 
    } 

    public void useFactory(Test obj) 
    { 
     var implementation = _exampleFactory.Make(obj.ThisIsAnEnum); 
     implementation.Do(); 
    } 
} 

任何指针将不胜感激使用， 谢谢！

**编辑我忘了提，这两个例A和例B具有一定的依赖性需要由DI

public class ExampleA: IExampleA 
{ 
    IDependencyA _dependencyA; 
    IDependencyB _dependencyB; 

    public ExampleA(IDependencyA dependencyA, IDependencyB dependencyB) 
    { 
     _dependencyA = dependencyA; 
     _dependencyB = dependencyB; 
    } 

    public void Do(); 
} 

public class ExampleB: IExampleB 
{ 
    IDependencyA _dependencyA; 
    IDependencyB _dependencyB; 
    IDependencyC _dependencyC; 

    public ExampleA(IDependencyA dependencyA, IDependencyB dependencyB, IDependencyC dependencyC) 
    { 
     _dependencyA = dependencyA; 
     _dependencyB = dependencyB; 
     _dependencyC = dependencyC; 
    } 
    public void Do(); 
} 

container.Bind<IDependencyA>().To.<DependencyA>(); 
container.Bind<IDependencyB>().To.<DependencyB>(); 
container.Bind<IDependencyC>().To.<DependencyC>(); 

Answer 1

我认为你正在做错误的工厂被照顾。

将ExampleA和ExampleB注入工厂没有任何意义。

由于工厂模式负责创建，因此您可以从工厂类中进行实例化。

这可能很容易用IExampleFactory的其他实现替换工厂。

*编辑添加了更多详细信息。

事实上，DI容器可以被视为一个工厂（都负责对象创建）。

但是，如果你想要去工厂的方式，你可以实现你自己的实例化逻辑。

当然，您需要处理工厂的依赖关系。

工厂界面最好定义要单独创建的对象。

public interface IExampleFactory 
{ 
    IExampleA CreateExampleA(); 
    IExampleB CreateExampleB(); 
} 

然后具体工厂应该处理每个对象的实例化过程。

你可以做任何事情来获得所有的依赖来实例化对象（每个对象可以有不同的依赖关系）。

public class ExampleFactory: IExampleFactory 
{ 
    IExampleA CreateExampleA() 
    { 
     //instantiating concrete object A with its dependencies 

     return concreteA; 
    } 

    IExampleB CreateExampleB(); 
    { 
     //instantiating concrete object B with its dependencies 

     return concreteB; 
    } 
}