11

我有一个工厂类，它创建了几种不同类型的类。工厂在容器中注册。考虑到它们也有依赖关系，在工厂内创建类的推荐方法是什么。我显然想避免对容器的依赖，但如果我新建这些类，那么它们将不会使用容器。例如

public class MyFactory
{
    public IMyWorker CreateInstance(WorkerType workerType)
    {
        if (workerType == WorkerType.A)
              return new WorkerA(dependency1, dependency2);
        
        return new WorkerB(dependency1);    
    }
}

所以问题是我从哪里获得这些依赖项。

一种选择是使它们成为工厂的依赖项。例如

public class MyFactory
{
    private Dependency1 dependency1;
    private Dependency2 dependency2;

    public MyFactory(Dependency1 dependency1, Dependency2, dependency2)
    {
        this.dependency1 = dependency1; this.dependency2 = dependency2;
    }

    public IMyWorker CreateInstance(WorkerType workerType)
    {
        if (workerType == WorkerType.A)
              return new WorkerA(dependency1, dependency2);
        
        return new WorkerB(dependency1);

    }
}

另一个可能是注册工人类型并建立工厂的依赖关系，例如

public class MyFactory
{
    private IWorkerA workerA;
    private IWorkerB workerB;

    public MyFactory(IWorkerA workerA, IWorkerB, workerB)
    {
        this.workerA = workerA; this.workerB = workerB;
    }

    public IMyWorker CreateInstance(WorkerType workerType)
    {
        if (workerType == WorkerType.A)
              return workerA;
        
        return workerB;  
    }
}

对于第一个选项，我觉得我正在将工人的依赖关系吸进工厂。使用第二个选项，工人是在创建工厂时创建的。

4

4 回答 4

18

我同意@Phil 的观点，让工厂依赖容器是可以的，但他的回答中缺少一种信息的平静。

您可能正试图阻止对容器的依赖，因为您试图远离Service Locator 反模式。我同意服务定位器是一种反模式，应该被阻止。

对容器的依赖是否是 Service Locator 反模式的实现取决于此使用者的定义位置。Mark Seemann在这里解释了这一点：

封装在组合根中的 DI 容器不是服务定位器——它是一个基础设施组件。

因此，只要您在组合根中定义此实现，就可以让您的工厂依赖于MyFactory容器。

当你这样做时，你很快就会遇到麻烦，因为在组合根中定义的类不能被应用程序的其余部分引用。但是通过在应用程序中定义一个接口并让您的工厂实现实现该接口很容易解决这个问题IMyFactory（无论如何您都应该这样做以遵守Dependency Inversion Principle）。

所以你的注册会变成这样：

container.RegisterSingleton<IMyFactory, MyFactory>();

和这样的实现：

private sealed class MyFactory : IMyFactory
{
    private readonly Container container;

    public MyFactory(Container container)
    {
        this.container = container;
    }

    public IMyWorker CreateInstance(WorkerType workerType)
    {
        if (workerType == WorkerType.A)
              return this.container.GetInstance<IWorkerA>();

        return this.container.GetInstance<IWorkerB>();
    }
}
于 2013-11-13T19:16:47.603 回答
5

这是一个经典的问题。

如果不同实现的数量增加，您的两种解决方案都可能会出现问题，特别是如果每​​个实现的依赖关系有很多差异。您最终可能会得到一个带有 20 个参数的构造函数。

我首选的实现是让工厂类引用容器，并以这种方式解析所需的实例。

有些人可能会争辩说，这并不比服务定位器反模式更好，但我觉得这个问题没有完美的解决方案，这样做对我来说似乎是最自然的。

于 2013-11-13T18:56:35.570 回答
3

在我看来，解决方案很大程度上取决于两个依赖项的生命周期。这些依赖关系是否可以跨对象共享，那么你可以在容器中注册它们，并将它们传递给工厂并重用它们。如果工厂的每个“产品”都应该有自己的实例，那么也许您可以考虑为这些依赖项构建一个单独的工厂（当然，如果它们属于同一个对象“家族”）并将其传递给您的工厂，然后询问每当您创建 IMyWorker 的实例时。或者，您可以考虑在创建最终产品之前使用 Builder 而不是 Factory 来创建每个依赖项——在您的情况下为 IMyWorker。

传递容器被认为是代码异味，除非您正在实现组合根，例如在 WCF 中。

如果你最终得到一个工厂，在构造函数中包含许多依赖项，那么你应该将其视为一个提示，表明有问题 - 很可能是某些事情违反了单一责任原则 - 它知道的太多了；）

一本非常好的谈论依赖注入的书是我推荐的 Mark Seemann 的书“.NET 中的依赖注入”：）

于 2013-11-13T19:55:59.360 回答
1

虽然这个问题是主观的（答案也是如此），但我会说你的第一种方法是合适的。

当您使用时，Dependency Injection您必须了解什么是实际依赖项。在这种情况下，WorkerA和WorkerB不是真正的依赖关系，但显然Dependency1和Dependency2是依赖关系。在实际场景中，我在我的 Micrsoft Prism 应用程序中使用了这种模式。

希望我的应用程序示例能让您更好地理解要使用的模式。我利用了ILoggerFacade依赖。我有一些视图模型位于单独的程序集中（工厂也位于该程序集中）。我的个人IPlayerViewModels不是依赖项（这就是我没有走第二条路线的原因）。

ShellViewModel.cs：

[Export]
public sealed class ShellViewModel : NotificationObject
{
    public ShellViewModel()
    {
         Players = new ObservableCollection<IPlayerViewModel>();

         // Get the list of player models
         // from the database (ICollection<IPlayer>)
         var players = GetCollectionOfPlayerModels();

         foreach (var player in players)
         {
             var vm = PlayerViewModelFactory.Create(player);

             Players.Add(vm);
         }
    }

    [Import]
    private IPlayerViewModelFactory PlayerViewModelFactory { get; set; }

    public ObservableCollection<IPlayerViewModel> Players { get; private set; }
}

IPlayerViewModelFactory.cs

public interface IPlayerViewModelFactory
{
    IPlayerViewModel Create(IPlayer player);
}

IPlayer.cs

public interface IPlayer
{
    // Sport Enum
    Sport Sport { get; set; }
}

单独组装/PlayerViewModelFactory.cs

[Export]
public sealed class PlayerViewModelFactory : IPlayerViewModelFactory
{
    [Import]
    private ILoggerFacade Logger { get; set; }

    public IPlayerViewModel Create(IPlayer player)
    {
        switch (player.Sport)
        {
            case Sport.Basketball:
                return new BasketballViewModel(Logger, player);

            case Sport.Football:
                return new FootballViewModel(Logger, player);

            // etc...

            default:
                throw new ArgumentOutOfRangeException("player");
        }
    }
}
于 2013-11-13T19:25:31.373 回答