Zenject框架（十三）

使用LazyInject <>进行即时解析（Just-In-Time Resolving Using LazyInject<>）

在某些情况下需要在启动后延迟创建某些依赖项，您可以使用LazyInject <>构造来实现。

比如，假设有这样一个脚本：

public class Foo
{
    public void Run()
    {
        ...
    }
}

public class Bar
{
    Foo _foo;

    public Bar(Foo foo)
    {
        _foo = foo;
    }

    public void Run()
    {
        _foo.Run();
    }
}

public class TestInstaller : MonoInstaller<TestInstaller>
{
    public override void InstallBindings()
    {
        Container.Bind<Foo>().AsSingle();
        Container.Bind<Bar>().AsSingle();
    }
}

假设我们只想在真正使用时才创建一个Foo的实例（也就是调用Bar.Run方法时）。 如上所述，即使从未调用过Bar.Run，每次创建Bar``时都会创建Foo。 我们可以通过将Bar```更改为以下内容来解决此问题：

public class Bar
{
    LazyInject<Foo> _foo;

    public Bar(LazyInject<Foo> foo)
    {
        _foo = foo;
    }

    public void Run()
    {
        _foo.Value.Run();
    }
}

现在，通过使用LazyInject <>，直到第一次调用Bar.Run时才会创建Foo类的实例，之后，将会使用同个实例

请注意，这两种情况下安装器保持不变。任何注入依赖项都可以通过使用LazyInject <>变为延迟。

非泛型绑定（Non Generic bindings）

在某些情况下，您可能不知道要在编译时绑定的确切类型。 在这些情况下，您可以使用Bind方法的重载，该方法采用System.Type值而不是泛型参数。

\\这两行结果形同
Container.Bind(typeof(Foo));
Container.Bind<Foo>();

注意，使用非泛型绑定时，可以传递多个参数：

Container.Bind(typeof(Foo), typeof(Bar), typeof(Qux)).AsSingle();

// 上面的一行等同于下面的三行:
Container.Bind<Foo>().AsSingle();
Container.Bind<Bar>().AsSingle();
Container.Bind<Qux>().AsSingle();

对于To方法同样适用：

Container.Bind<IFoo>().To(typeof(Foo), typeof(Bar)).AsSingle();

// 上面的一行等同于下面的两行:
Container.Bind<IFoo>().To<Foo>().AsSingle();
Container.Bind<IFoo>().To<Bar>().AsSingle();

或者，两者混合：

Container.Bind(typeof(IFoo), typeof(IBar)).To(typeof(Foo1), typeof(Foo2)).AsSingle();

// 上面一行等同于下面几行:
Container.Bind<IFoo>().To<Foo>().AsSingle();
Container.Bind<IFoo>().To<Bar>().AsSingle();
Container.Bind<IBar>().To<Foo>().AsSingle();
Container.Bind<IBar>().To<Bar>().AsSingle();

当您有一个类实现多个接口时，这可能特别有用：

Container.Bind(typeof(ITickable), typeof(IInitializable), typeof(IDisposable)).To<Foo>().AsSingle();

虽然在这个特定的例子中已经存在了内置的快捷方法：

Container.BindInterfacesTo<Foo>().AsSingle();

基于约定的绑定（Convention Based Binding）

基于约定的绑定可以在以下任何一种情况下派上用场：

• 您想定义一个命名约定，该约定确定类如何绑定到容器（例如，使用前缀，后缀或正则表达式）
• 您希望使用自定义属性来确定类与容器的绑定方式
• 您希望自动绑定在给定命名空间或程序集中实现给定接口的所有类

使用“convention over configuration”可以允许您定义一个框架，其他程序员可以使用该框架快速轻松地完成任务，而不必在安装器中明确添加每个绑定。 这是Ruby on Rails，ASP.NET MVC等框架所遵循的理念。当然，这种方法既有优点也有缺点。

除了不用向Bind()和To()方法提供类型列表外，它们以与非泛型绑定类似的方式指定，您可以使用Fluent API描述约定。 例如，要将IFoo绑定到在整个代码库中实现它的每个类：

Container.Bind<IFoo>().To(x => x.AllTypes().DerivingFrom<IFoo>());

注意，您也可以在Bind()方法中使用相同的Fluent API，您也可以在Bind()和To()中同时使用它。

有关更多示例，请参阅下面的示例部分。 完整格式如下：

x.InitialList().Conditional().AssemblySources()

这里：

• InitialList = 用于绑定的初始类型列表。 此列表将由给定的条件进行过滤。 它可以是以下（相当自我解释）方法之一：
  i.AllTypes
  ii.AllNonAbstractClasses
  iii.AllAbstractClasses
  iv.AllInterfaces
  v.AllClasses
• Conditional = 要应用于InitialList给出的类型列表的过滤器。 请注意，您可以根据需要将所有这些链接在一起，并且它们将按顺序应用于初始列表。 它可以是以下之一：
  i.DerivingFrom - 只匹配派生自T的类型
  ii.DerivingFromOrEqual - 只匹配派生自T类型或T类型
  iii.WithPrefix(value) - 只匹配名字以value开始的类型
  iv.WithSuffix(value) - 只匹配名字以value结尾的类型
  v.WithAttribute - 只匹配类以[T]特性修饰的类型
  vi.WithoutAttribute - 只匹配类没有以[T]特性修饰的类型
  vii.WithAttributeWhere(predicate) - 仅匹配在类声明之上具有属性[T]的类型，并且在传递属性时给定谓词返回true。 这很有用，因此您可以使用赋予该属性的数据来创建绑定
  viii.InNamespace(value)-只匹配在给定命名空间中的类型
  ix.InNamespaces(value1,value2,等)-只匹配在给定命名空间中的类型
  x.MatchingRegex(pattern) - 只匹配符合给定正则表达式的类型
  xi.Where(predicate) - 最后，您还可以通过传入带有Type参数的谓词来添加任何类型的条件逻辑
• AssemblySources = 填充InitialList时要搜索类型的程序集列表。 它可以是以下之一：
  i.FromAllAssemblies - 在所有加载的程序集中查找类型，未指定时默认该值
  ii.FromAssemblyContaining - 在包含[T]的程序集中查找类型
  iii.FromAssembliesContaining(type1, type2, ..) - 在包含[T]的程序集中查找类型
  iv.FromThisAssembly- 仅在要调用此方法的程序集中查找类型
  v.FromAssembly(assembly) - 仅在给定的程序集中查找类型
  vi.FromAssemblies(assembly1, assembly2, ...) - 仅在给定的程序集中查找类型
  vii.FromAssembliesWhere(predicate) - 在与给定谓词匹配的所有程序集中查找类型

例子：

请注意，您可以将以下项任意组合在同一个绑定中。 另请注意，由于我们未在此处指定程序集，因此Zenject将在所有已加载的程序集中进行搜索。
1.将IFoo绑定到整个代码库中实现它的每个类：

Container.Bind<IFoo>().To(x => x.AllTypes().DerivingFrom<IFoo>());

注意，以下结果相同：

Container.Bind<IFoo>().To(x => x.AllNonAbstractTypes());

这是因为Zenject将跳过具体类型不是从基类型派生的任何绑定。 另请注意，在这种情况下，我们必须确保使用AllNonAbstractTypes而不仅仅是AllTypes，以确保我们不将IFoo绑定到自身

2.将接口绑定到在给定命名空间内实现它的所有类

Container.Bind<IFoo>().To(x => x.AllTypes().DerivingFrom<IFoo>().InNamespace("MyGame.Foos"));

3.自动绑定IController每个具有后缀“Controller”的类（如ASP.NET MVC中所做的那样）：

Container.Bind<IController>().To(x => x.AllNonAbstractTypes().WithSuffix("Controller"));

你也可以使用MatchingRegex:

Container.Bind<IController>().To(x => x.AllNonAbstractTypes().MatchingRegex("Controller$"));

4.使用前缀“Widget”绑定所有类型并注入Foo

Container.Bind<object>().To(x => x.AllNonAbstractTypes().WithPrefix("Widget")).WhenInjectedInto<Foo>();

5.自动绑定给定命名空间中每种类型使用的接口

Container.Bind(x => x.AllInterfaces())
    .To(x => x.AllNonAbstractClasses().InNamespace("MyGame.Things"));

这相当于为名称空间“MyGame.Things”中的每个类型调用Container.BindInterfacesTo <T>()。 这是有效的，因为如上所述，Zenject将跳过任何绑定，其中具体类型实际上不是从基类型派生的。 因此，即使我们使用AllInterfaces匹配每个加载的程序集中的每个单独的接口，这也没关系，因为它不会尝试将接口绑定到不实现此接口的类型。

装饰器绑定（Decorator Bindings）

见后续章节