首页
学习
活动
专区
圈层
工具
发布
社区首页 >问答首页 >使用通过DI容器注入的抽象工厂

问使用通过DI容器注入的抽象工厂
EN

Stack Overflow用户
提问于 2016-03-24 13:41:41
回答 1查看 3.6K关注 0票数 12

在一个具体的例子中,我对依赖注入实现感到困惑。

假设我们有一个SomeClass类,它有一个IClassX类型的依赖项。

代码语言:javascript
复制
public class SomeClass
{
     public SomeClass(IClassX dependency){...}
}

创建IClassX接口的具体实现取决于运行时参数N。

对于给定的构造函数,我无法配置DI容器(使用了统一),因为我不知道运行时将使用什么IClassX实现。Mark在他的“.Net中的依赖注入”一书中建议,我们应该使用抽象工厂作为注入参数。

现在我们有了SomeAbstractFactory,它基于运行时参数runTimeParam返回IClassX的实现。

代码语言:javascript
复制
public class SomeAbstractFactory
{
     public SomeAbstractFactory(){ }

     public IClassX GetStrategyFor(int runTimeParam)
     {
         switch(runTimeParam)
         {
             case 1: return new ClassX1();
             case 2: return new ClassX2();
               default : return new ClassDefault();
         }
     }
}

SomeClass现在接受ISomeAbstractFactory作为注入参数:

代码语言:javascript
复制
public class SomeClass
{
     public SomeClass(ISomeAbstractFactory someAbstractfactory){...}
}

这也没问题。在创建对象图时,我们只有一个组合根。我们将联合容器配置为将SomeAbstractFactory注入SomeClass。

但是,让我们假设类ClassX1和ClassX2有自己的依赖关系:

代码语言:javascript
复制
public class ClassX1 : IClassX
{
    public ClassX1(IClassA, IClassB) {...}
}

public class ClassX2 : IClassX
{
    public ClassX2(IClassA, IClassC, IClassD) {...}
}

如何解决IClassA、IClassB、IClassC和IClassD依赖关系?

1.通过SomeAbstractFactory构造函数注入

我们可以将IClassA、IClassB、IClassC和IClassD的具体实现注入SomeAbstractFactory,如下所示:

代码语言:javascript
复制
public class SomeAbstractFactory
{
     public SomeAbstractFactory(IClassA classA, IClassB classB, IClassC classC, IClassD classD)
     {...}
     ...
}

在初始组合根中使用统一容器,然后使用穷人的DI返回混凝土ClassX1或基于参数runTimeParam的ClassX2

代码语言:javascript
复制
public class SomeAbstractFactory
{
     public SomeAbstractFactory(IClassA classA, IClassB classB, IClassC classC, IClassD classD){...}

     public IClassX GetStrategyFor(int runTimeParam)
     {
         switch(runTimeParam)
         {
             case 1: return new ClassX1(classA, classB);
             case 2: return new ClassX2(classA, classC, classD);
               default : return new ClassDefault();
         }
     }
}

这种方法的问题:

  • SomeAbstractFactory知道不属于它的依赖关系。
  • 更深层次的对象图需要同时更改SomeAbstractFactory构造函数和类实现。
  • 不能使用DI容器来解决依赖关系,必须使用可怜的man`s的DI

2.显式调用DI容器

我们将使用DI容器来解析它们,而不是“newing up”ClassX1或ClassX2。

代码语言:javascript
复制
public class SomeAbstractFactory
{
     public SomeAbstractFactory(IUnityContainer container){...}

     public IClassX GetStrategyFor(int runTimeParam)
     {
         switch(runTimeParam)
         {
             case 1: return container.Resolve<IClassX>("x1");
             case 2: return container.Resolve<IClassX>("x2");
               default : return container.Resolve<IClassX>("xdefault");
         }
     }
}

这种方法的问题:

  • DI容器被传递到SomeAbstractFactory
  • DI解析方法不只是在组合根上使用(ServiceLocator反模式)。

还有其他更合适的方法吗?

EN

回答 1

Stack Overflow用户

回答已采纳

发布于 2016-03-25 03:24:00

下面的示例展示了如何使用Unity来完成这一任务。这篇博客文章用温莎更好地解释了这一点。每个基本概念完全相同,只是实现略有不同。

我宁愿让我的抽象工厂访问容器。我认为抽象工厂是一种防止对容器的依赖的方法--我的类只依赖于IFactory,所以只有工厂的实现才使用容器。Castle更进一步--您定义了工厂的接口,但是温莎提供了实际的实现。但是,这是一个很好的迹象,在这两种情况下,相同的方法都是有效的,并且您不必更改工厂接口。

在下面的方法中,需要的是依赖于工厂的类传递一些参数,允许工厂决定要创建哪个实例。工厂将将其转换为字符串,容器将将其与命名的实例匹配。这种方法适用于团结和温莎。

这样做,依赖于IFactory的类不知道工厂正在使用字符串值来找到正确的类型。在温莎示例中,一个类将一个Address对象传递给工厂,而工厂使用该对象来根据地址的国家确定要使用的地址验证器。没有其他类,只有工厂“知道”如何选择正确的类型。这意味着,如果切换到不同的容器,唯一需要更改的是IFactory的实现。任何依赖于IFactory的东西都不需要改变。

下面是使用Unity的示例代码:

代码语言:javascript
复制
public interface IThingINeed
{}

public class ThingA : IThingINeed { }
public class ThingB : IThingINeed { }
public class ThingC : IThingINeed { }

public interface IThingINeedFactory
{
    IThingINeed Create(ThingTypes thingType);
    void Release(IThingINeed created);
}

public class ThingINeedFactory : IThingINeedFactory
{
    private readonly IUnityContainer _container;

    public ThingINeedFactory(IUnityContainer container)
    {
        _container = container;
    }

    public IThingINeed Create(ThingTypes thingType)
    {
        string dependencyName = "Thing" + thingType;
        if(_container.IsRegistered<IThingINeed>(dependencyName))
        {
            return _container.Resolve<IThingINeed>(dependencyName);
        }
        return _container.Resolve<IThingINeed>();
    }

    public void Release(IThingINeed created)
    {
        _container.Teardown(created);
    }
}

public class NeedsThing
{
    private readonly IThingINeedFactory _factory;

    public NeedsThing(IThingINeedFactory factory)
    {
        _factory = factory;
    }

    public string PerformSomeFunction(ThingTypes valueThatDeterminesTypeOfThing)
    {
        var thingINeed = _factory.Create(valueThatDeterminesTypeOfThing);
        try
        {
            //This is just for demonstration purposes. The method
            //returns the name of the type created by the factory
            //so you can tell that the factory worked.                
            return thingINeed.GetType().Name;
        }
        finally
        {
            _factory.Release(thingINeed);
        }
    }
}

public enum ThingTypes
{
    A, B, C, D
}

public class ContainerConfiguration
{
    public void Configure(IUnityContainer container)
    {
        container.RegisterType<IThingINeedFactory,ThingINeedFactory>(new InjectionConstructor(container));
        container.RegisterType<IThingINeed, ThingA>("ThingA");
        container.RegisterType<IThingINeed, ThingB>("ThingB");
        container.RegisterType<IThingINeed, ThingC>("ThingC");
        container.RegisterType<IThingINeed, ThingC>();
    }
}

这是一些单元测试。它们显示,工厂在检查传递给其IThingINeed函数的内容后返回正确类型的Create()。

在这种情况下(可能适用也可能不适用),我还指定了一种类型为默认类型。如果没有向与需求完全匹配的容器注册任何内容,那么它可以返回该缺省值。该默认值也可以是没有行为的空实例。但所有这些选择都在工厂和容器配置中。

代码语言:javascript
复制
[TestClass]
public class UnitTest1
{
    private IUnityContainer _container;

    [TestInitialize]
    public void InitializeTest()
    {
       _container = new UnityContainer();
       var configurer = new ContainerConfiguration();
       configurer.Configure(_container);
    }

    [TestCleanup]
    public void CleanupTest()
    {
        _container.Dispose();
    }

    [TestMethod]
    public void ThingINeedFactory_CreatesExpectedType()
    {
        var factory = _container.Resolve<IThingINeedFactory>();
        var needsThing = new NeedsThing(factory);
        var output = needsThing.PerformSomeFunction(ThingTypes.B);
        Assert.AreEqual(output, typeof(ThingB).Name);
    }

    [TestMethod]
    public void ThingINeedFactory_CreatesDefaultyTpe()
    {
        var factory = _container.Resolve<IThingINeedFactory>();
        var needsThing = new NeedsThing(factory);
        var output = needsThing.PerformSomeFunction(ThingTypes.D);
        Assert.AreEqual(output, typeof(ThingC).Name);
    }
}

这个工厂可以使用Windsor来实现,而Windsor示例中的工厂可以在Unity中完成。

票数 3
EN
页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接:

https://stackoverflow.com/questions/36201621

复制
相关文章

相似问题

领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档