使用Factory Pattern和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();
    }
}

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

**编辑我忘了提到ExampleA和ExampleB都具有一些依赖项，这些依赖项需要由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;
    }
}