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

Question

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

Answer 1

更新： StructureMap v3 开箱即用地实现了此功能，因此不再需要此技巧。

---

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

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 找到“最贪婪”的构造函数，并选择 public Lazy(FuncvalueFactory, bool isThreadSafe)。由于我们没有告诉它如何处理布尔 isThreadSafe 参数，因此当它尝试解析“Lazy”时会抛出异常。

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

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

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

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

您可以在此处详细了解 Lazy 类。

Answer 2

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

我提供了一个示例程序，该程序创建以下输出：

Created Consumer
Consuming
Created Helper
Helping

Sample.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");
    }
}