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注入Factory。

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

这可以很容易地将工厂替换为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;
    }
}

使用Factory Pattern和DI改进代码

1 个答案: