Structuremap 是否支持开箱即用的 Lazy？

Question

structuremap 是否允许您以惰性方式进行构造函数注入？ 意思是在使用之前不创建注入的对象？

Answer 1

更新： StructureMap v3 开箱即用地实现了这一点，因此不再需要这个技巧。

---

StructureMap 版本 2 没有，但是通过一些技巧，您可以让它完成我相信您正在寻找的事情。首先，您已经可以像这样手动连接Lazy<T> 实例：

container = new Container(x =>
{
    x.Scan(y =>
    {
        y.TheCallingAssembly();
        y.WithDefaultConventions();
    });

    x.For<Lazy<IFoo>>().Use(y => new Lazy<IFoo>(y.GetInstance<Foo>));
    x.For<Lazy<IBar>>().Use(y => new Lazy<IBar>(y.GetInstance<Bar>));
    x.For<Lazy<IBaz>>().Use(y => new Lazy<IBaz>(y.GetInstance<Baz>));
});

这很好用，但是您必须单独注册每种类型。如果您可以利用更基于约定的方法，那就更好了。理想情况下，以下语法会很好。

x.For(typeof(Lazy<>)).Use(typeof(Lazy<>));

这种语法确实有效……有点。不幸的是，在运行时，StructureMap 将尝试为Lazy<T> 找到“最贪婪”的构造函数并选择public Lazy(Func<T> valueFactory, bool isThreadSafe)。由于我们没有告诉它如何处理布尔 isThreadSafe 参数，所以当它尝试解析 `Lazy' 时会抛出异常。

Lazy 的文档指出，默认 Lazy(Func<T> valueFactory) 构造函数的“线程安全模式”是 LazyThreadSafetyMode.ExecutionAndPublication，这恰好是您通过将 true 传递给上述构造函数的 isThreadSafe 参数所得到的。因此，如果我们可以告诉 StructureMap 将true 传递给isThreadSafe，我们将获得与调用我们实际上想要首先使用的构造函数相同的行为（例如Lazy(Func<T> valueFactory)）。

简单地注册x.For(typeof(bool)).Use(y => true) 将是非常鲁莽和危险的，因为我们会告诉StructureMap 继续使用值true 作为任何 布尔值。相反，我们需要告诉 StructureMap 对于这个 one 布尔参数使用什么值，我们可以这样做。

x.For(typeof(Lazy<>)).Use(typeof(Lazy<>))
 .CtorDependency<bool>("isThreadSafe").Is(true);

StructureMap 现在知道在解析 Lazy<T> 时使用 isThreadSafe 参数的“true”值。我们现在可以在构造函数参数中使用Lazy<T>，并获得我认为您正在寻找的行为。

您可以阅读有关 Lazy 课程的更多详细信息here。

Answer 2

是的，确实如此。最新版本的 StructureMap (2.6.x) 是针对 .NET Framework 3.5 编译的，因此无法访问 .NET 4 中引入的 Lazy<T> 类型。但是，它确实支持相同的功能 - “不创建对象在使用之前一直注入”。您不依赖于Lazy<T>，而是依赖于Func<T>。不需要特殊的容器注册。

我已经包含了一个创建以下输出的示例程序：

Created Consumer
Consuming
Created Helper
Helping

示例.cs：

class Program
{
    static void Main(string[] args)
    {
        var container = new Container(x =>
        {
            x.For<IConsumer>().Use<Consumer>();
            x.For<IHelper>().Use<Helper>();
        });

        var consumer = container.GetInstance<IConsumer>();
        consumer.Consume();
    }
}

public class Consumer : IConsumer
{
    private readonly Func<IHelper> _helper;

    public Consumer(Func<IHelper> helper)
    {
        _helper = helper;
        Console.WriteLine("Created Consumer");
    }

    public void Consume()
    {
        Console.WriteLine("Consuming");
        _helper().Help();
    }
}

public interface IConsumer
{
    void Consume();
}

public interface IHelper
{
    void Help();
}

public class Helper : IHelper
{
    public Helper()
    {
        Console.WriteLine("Created Helper");
    }

    public void Help()
    {
        Console.WriteLine("Helping");
    }
}