Autofac官方文档(十六)【在启动时运行代码】

Autofac提供了在构建容器时通知组件或自动激活组件的功能。

有三种自动激活机制可用： - 可启动组件 - 自动激活组件 - 容器构建回调

在所有情况下，当容器建成时，组件将被激活。

可启动的组件

一个可启动的组件是容器在最初构建时被容器激活的组件，并且有一个特定的方法被调用来引导组件上的一个动作。

关键是要实现Autofac.IStartable接口。在构建容器时，组件将被激活，并调用IStartable.Start()方法。

这只会发生一次，对于每个组件的单个实例，首次构建容器。手动解析可启动组件不会导致调用Start()方法。不建议可启动组件实现其他服务，或者注册为SingleInstance()以外的任何其他服务。

每次被激活时需要像Start()方法那样的组件应该使用像OnActivated这样的生存事件。

要创建可启动组件，请实现Autofac.IStartable：

public class StartupMessageWriter : IStartable
{
   public void Start()
   {
      Console.WriteLine("App is starting up!");
   }
}

然后注册你的组件，并确保将其指定为IStartable，否则该操作将不会被调用：

var builder = new ContainerBuilder();
builder
   .RegisterType<StartupMessageWriter>()
   .As<IStartable>()
   .SingleInstance();

在构建容器时，类型将被激活，并调用IStartable.Start()方法。 在这个例子中，一条消息将被写入控制台。

已知问题：虽然IStartable组件将以依赖性顺序解析，但Start()方法实际上可能不会以依赖性顺序调用。 您可以使用与SingleInstance注册相结合的容器构建回调来解决此问题。 见下文。

自动激活的组件

一个自动激活的组件是一个组件，只需要在构建容器时激活一次。 这是一种“热启动”的行为方式，其中组件的任何方法都不被调用，也不需要实现接口 - 组件的单个实例将被解析，而不涉及它所持有的实例。

要注册自动激活的组件，请使用AutoActivate()注册扩展。

var builder = new ContainerBuilder();
builder
   .RegisterType<TypeRequiringWarmStart>()
   .AsSelf()
   .AutoActivate();

注意：如果您在注册AutoActivate()组件时忽略AsSelf()或As<T>()服务注册调用，则组件只会被注册为自动激活，容器构建后并不一定会在解析“自身” 。

容器构建回调

您可以通过注册构建回调来注册任何在容器构建时发生的任意动作。 构建回调是一个Action<IContainer>，并将从ContainerBuilder.Build返回该容器之前获取构建的容器。 构建回调按照它们注册的顺序执行：

var builder = new ContainerBuilder();
builder
   .RegisterBuildCallback(c => c.Resolve<DbContext>());

/回调将在容器生成之后但返回之前运行
var container = builder.Build();

您可以使用构建回调作为在容器构建中自动启动/预热对象的另一种方法。 通过将它们与生命周期事件OnActivated和SingleInstance注册结合使用来实现这一点。 这可以解决IStartable实现以依赖顺序解析的已知问题，但Start()方法不一定按依赖顺序调用。

单元测试形式中的一个冗长/人为的例子：

public class TestClass
{
  // 创建一个依赖链 像:
  //    ==> 2 ==+
  // 4 =+       ==> 1
  //    ==> 3 ==+
  // 4需要2和3
  // 2需要1
   // 3需要1
  // 依赖应该按顺序启动
  // 1, 2, 3, 4
  // 或者
  // 1, 3, 2, 4


  private class Dependency1
  {
    public Dependency1(ITestOutputHelper output)
    {
      output.WriteLine("Dependency1.ctor");
    }
  }

  private class Dependency2
  {
    private ITestOutputHelper output;

    public Dependency2(ITestOutputHelper output, Dependency1 dependency)
    {
      this.output = output;
      output.WriteLine("Dependency2.ctor");
    }

    public void Initialize()
    {
      this.output.WriteLine("Dependency2.Initialize");
    }
  }

  private class Dependency3
  {
    private ITestOutputHelper output;

    public Dependency3(ITestOutputHelper output, Dependency1 dependency)
    {
      this.output = output;
      output.WriteLine("Dependency3.ctor");
    }

    public void Initialize()
    {
      this.output.WriteLine("Dependency3.Initialize");
    }
  }

  private class Dependency4
  {
    private ITestOutputHelper output;

    public Dependency4(ITestOutputHelper output, Dependency2 dependency2, Dependency3 dependency3)
    {
      this.output = output;
      output.WriteLine("Dependency4.ctor");
    }

    public void Initialize()
    {
      this.output.WriteLine("Dependency4.Initialize");
    }
  }

  //Xunit把这个传递给测试类的ctor，所以我们可以捕获控制台输出。
  private ITestOutputHelper _output;

  public TestClass(ITestOutputHelper output)
  {
    this._output = output;
  }

  [Fact]
  public void OnActivatedDependencyChain()
  {
    var builder = new ContainerBuilder();
    builder.RegisterInstance(this._output).As<ITestOutputHelper>();
    builder.RegisterType<Dependency1>().SingleInstance();

    //OnActivated取代了IStartable的需要。 当一个实例被激活/创建时，它将按照指定的方式运行Initialize方法。 使用SingleInstance意味着只发生一次。
    builder.RegisterType<Dependency2>().SingleInstance().OnActivated(args => args.Instance.Initialize());
    builder.RegisterType<Dependency3>().SingleInstance().OnActivated(args => args.Instance.Initialize());
    builder.RegisterType<Dependency4>().SingleInstance().OnActivated(args => args.Instance.Initialize());

    //注意这些不是依赖性顺序
    builder.RegisterBuildCallback(c => c.Resolve<Dependency4>());
    builder.RegisterBuildCallback(c => c.Resolve<Dependency2>());
    builder.RegisterBuildCallback(c => c.Resolve<Dependency1>());
    builder.RegisterBuildCallback(c => c.Resolve<Dependency3>());

    // 这将运行构建回调。
    var container = builder.Build();

    //这些没有任何作用。 OnActivated不会再被调用，因为它们是SingleInstance。
    container.Resolve<Dependency1>();
    container.Resolve<Dependency2>();
    container.Resolve<Dependency3>();
    container.Resolve<Dependency4>();
  }
}

这个样本单元测试会产生这个输出：

Dependency1.ctor
Dependency2.ctor
Dependency3.ctor
Dependency4.ctor
Dependency2.Initialize
Dependency3.Initialize
Dependency4.Initialize

你会从输出中看到，以依赖顺序执行的回调函数和OnActivated方法。 如果你必须有激活和启动都发生在依赖顺序（而不仅仅是激活/决议），这是解决方法。

请注意，如果您不使用SingleInstance，则将为每个新的依赖项实例调用OnActivated。 由于“热启动”对象通常是单例，创建起来很昂贵，所以这通常是你想要的。