Autofac (+MVC + EF + SignalR + Hangfire) 生命周期范围

Question

我有一个 ASP.NET MVC 项目，它使用 Entity Framwork、SignalR 和 Hangfire 作业。

我的主（根）容器是这样定义的：

builder.RegisterType<DbContext>().InstancePerLifetimeScope(); // EF Db Context
builder.RegisterType<ChatService>().As<IChatService>().SingleInstance(); // classic "service", has dependency on DbContext
builder.RegisterType<ChatHub>().ExternallyOwned(); // SignalR hub
builder.RegisterType<UpdateStatusesJob>().InstancePerDependency(); // Hangfire job
builder.RegisterType<HomeController>().InstancePerRequest(); // ASP.NET MVC controller
IContainer container = builder.Build();

对于 MVC，我使用的是 Autofac.MVC5 nuget 包。依赖解析器：

DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

对于 SignalR，我使用 Autofac.SignalR nuget 包。依赖解析器：

GlobalHost.DependencyResolver = new Autofac.Integration.SignalR.AutofacDependencyResolver(container);

我的 signalR 集线器是这样实例化的 (http://autofac.readthedocs.org/en/latest/integration/signalr.html#managing-dependency-lifetimes):

private ILifetimeScope _hubScope;
protected IChatService ChatService;
public ChatHub(ILifetimeScope scope) {
  _hubScope = scope.BeginLifetimeScope(); // scope 
  ChatService = _hubScope.Resolve<IChatService>(); // this service is used in hub methods
}
protected override void Dispose(bool disposing)
{
  // Dipose the hub lifetime scope when the hub is disposed.
  if (disposing && _hubScope != null)
  {
    _hubScope.Dispose();
  }
  base.Dispose(disposing);
}

对于 Hangfire，我使用的是 Hangfire.Autofac 包：

config.UseActivator(new AutofacJobActivator(container));

作业是这样实例化的：

private readonly ILifetimeScope _jobScope;
protected IChatService ChatService;
protected BaseJob(ILifetimeScope scope)
{
    _jobScope = scope.BeginLifetimeScope();
    ChatService = _jobScope.Resolve<IChatService>();
}
public void Dispose()
{
    _jobScope.Dispose();
}

Question/problem: 我总是在集线器和作业中获得相同的 DbContext 实例。我希望所有集线器实例都将获得相同的 ChatService，但 DbContext（它是 ChatService 的依赖项）将始终是一个新实例。 Hangfire 工作也应该采取相同的行动。

这可以完成吗，还是我遗漏了什么？

更新 1：

经过思考（和睡过头）后，我认为我有两个选择。我还是想保留 "session per request" ("session per hub", "session per job").

选项 1：

更改为所有服务都将具有 InstancePerLifetimeScope。服务的实例化并不昂贵。对于维护某种状态的服务，我将创建另一个 "storage" (class)，它将是 SingleInstance，并且不会依赖于会话 (DbContext)。我认为这也适用于中心和工作。

选项 2：

创建@Ric .Net 建议的某种工厂。像这样：

public class DbFactory: IDbFactory
{
    public MyDbContext GetDb()
    {
        if (HttpContext.Current != null)
        {
            var db = HttpContext.Current.Items["db"] as MyDbContext;
            if (db == null)
            {
                db = new MyDbContext();
                HttpContext.Current.Items["db"] = db;
            }
            return db;
        }

        // What to do for jobs and hubs?
        return new MyDbContext();
    }
}

    protected void Application_EndRequest(object sender, EventArgs e)
    {
        var db = HttpContext.Current.Items["db"] as MyDbContext;
        if (db != null)
        {
            db.Dispose();
        }
    }

我认为这适用于 MVC，但我不知道让它适用于集线器（每个集线器调用都是集线器的新实例）和作业（每个运行作业是作业的新实例 class).

我倾向于方案一，你怎么看？

非常感谢！

Answer 1

我对 AutoFac 完全没有经验。但引起我注意的是：

I want that all hub instances will get the same ChatService, but the DbContext (which is dependency of ChatService) will always be a new instance.

你在这里基本上说的是：

"My car is in maintenance by the same the car company which have a dependency on their garage, but everytime I bring my car I want the garage to be a new one".

当您在其他组件中注入（完整构建实例，包括依赖项）ChatService 时，当然也会构建它具有的其他依赖项，无论它们是否具有其他类型的生活方式。当一个对象的生命周期比它被注入的对象短时，你创建了一个所谓的'captive dependency'

在 ChatService 中获得 DbContext 的新 'instance' 的唯一方法不是注入 DbContext 本身，而是注入 DbContextFactory 它会在您使用它时为您创建 DbContext。

一个实现看起来像：

public class DbContextFactory
{
    public DbContext Create()
    {
         return new DbContext();
    }
}

//usage:
public class ChatService
{
     private readonly DbContextFactory dbContextFactory;

     public ChatService(DbContextFactory dbContextFactory)
     {
         this.dbContextFactory = dbContextFactory;
     }

    public void SomeMethodInChatService()
    {
         using (var db = this.dbContextFactory.Create())
         {
             //do something with DbContext    
         }
     }
}

DbContextFactory 可以使用 Singleton Lifestyle 在 AutoFac 中注册。

但这可能不是您的目标。因为在这种情况下每次你使用 DbContext 你都会得到一个新的。另一方面，新的 DbContext 可能是解决这个问题的最安全方法，您可以阅读 here.

这个很棒的答案值得一读的原因不止一个，因为它对如何使用 command / handler pattern 进行了解释，这应该非常适合您的情况。

这将使您的聊天服务完全不知道 DbContext，它改进了应用程序的“SOLID”设计，并创造了测试 ChatService 的可能性直接注入 DbContext 或 DbContextFactory 时几乎不可撤销。

Answer 2

你需要解析一个工厂。 Autofac 内置了对 Func<T> 的支持，例如参见 [=19=]。

如果您的依赖项具有 disposable 依赖项，您将必须管理处置模式以避免内存泄漏。使用 Autofac 解决此问题的常见模式是使用 Func<Owned<T>>

public class ChatService
{
    public ChatService(Func<Owned<DbContext>> dbContextFactory)
    {
        this._dbContextFactory = dbContextFactory;
    }

    private readonly Func<Owned<DbContext>> _dbContextFactory;

    private void DoSomething()
    {
        using (Owned<DbContext> ownedDbContext = this._dbContextFactory())
        {
            DbContext context = ownedDbContext.Value;
        }
    }
}

Func<T> 是工厂。每次调用 factory 时，autofac 都会 return 一个新实例（取决于注册生命周期的配置方式）。 Owned<T> 是一盏灯 ILifetimescope，这个 class 的主要目的是管理已解决组件的处置。

您可以在此处找到有关 Func<Owned<T>> 的更多信息：Combining Owned<T> with Func<T>

Autofac (+MVC + EF + SignalR + Hangfire) 生命周期范围

Autofac (+MVC + EF + SignalR + Hangfire) lifetime scopes

asp.net-mvc

entity-framework

autofac

signalr

hangfire