Asp.net mvc Autofac（+；MVC+；EF+；信号机+；Hangfire）寿命范围

我有一个ASP.NETMVC项目，它使用实体框架、信号器和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();

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

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

DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

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

我的信号集线器是这样实例化的（）：

作业的实例化方式如下：

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();

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

我认为这对MVC是可行的，但我不知道如何让它对集线器（每个集线器调用都是集线器的新实例）和作业（每个作业的运行都是作业类的新实例）起作用

我倾向于选择1。你觉得怎么样

---

非常感谢

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

我希望所有hub实例都将获得相同的ChatService，但是DbContext（ChatService的依赖项）将始终是一个新实例

你在这里的基本意思是：

“我的车由同一家汽车公司维修，这家公司依赖于他们的车库，但每次我把车带来时，我都希望车库是新的。”

当您将（完全构建实例，包括的依赖项）

ChatService

注入到其他组件中时，当然也将构建它所具有的其他依赖项，无论它们是否具有其他类型的生活方式。当创建的对象的生存期短于所注入的对象时，即创建了一个所谓的“”

在

ChatService

中获取

DbContext

的新“实例”的唯一方法不是注入

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

可以使用单例生活方式在AutoFac中注册

然而，这可能不是你的目标。因为在这种情况下，每次使用

DbContext

都会得到一个新的。另一方面，正如您所看到的，新的DbContext可能是实现这一点的最安全的方法

这个伟大的答案值得一读，原因不止一个，因为它解释了如何使用应该非常适合您的情况

---

这将使您的聊天服务完全不知道

DbContext

，它改进了应用程序的“”设计，并创建了测试

chatservice

的可能性，这在直接注入

DbContext

或

DbContextFactory

时几乎是不可撤销的。

您需要解决一个工厂的问题。Autofac内置了对

Func

的支持，请参见示例

如果依赖项具有一次性依赖项，则必须管理dispose模式以避免内存泄漏。使用Autofac解决此问题的常见模式是使用

Func

公共类聊天室服务
{
公共聊天室服务（Func dbContextFactory）
{
这是._dbContextFactory=dbContextFactory；
}
私有只读Func_dbContextFactory；
私人无效剂量（）
{
使用（Owned ownedBContext=this.\u dbContextFactory（））
{
DbContext context=ownedBContext.Value；
}
}
}

Func

是一个工厂。每次调用工厂时，autofac将返回一个新实例（取决于注册的生存期配置方式）。

Owned

是一种轻型

ILifetimescope

，此类的主要目的是管理已解析组件的处置

---

您可以在这里找到有关

Func

的更多信息：

拥有的

接口的缺点是，您的应用程序代码依赖于DI库，这是您通常想要阻止IMO的事情。@Steven我同意您的看法。可以解析
Func
，但不能保证在处置
DbContext
时处置
DbContext
的直接或间接可处置依赖项。据我所知，没有任何本机.net等同于拥有的
。我编辑这篇文章是为了更好地解释
Owned
也许我误解了Autofac的工作原理，但是使用
Owned
似乎是多余的。如果
DbContext
注册为
InstancePerLifetimeScope
，则Autofac应在其周围生存期范围结束时自动处置该
DbContext
实例。换句话说，注入一个
Func
就足够了。然而，Autofac的问题是，如果没有活动的生存期范围，
DbContext
将作为单例（设计缺陷）解决。这就有点棘手了。
Owned
是多余的，如果这些对象的生存期相同。但是，如果工厂的所有者是单例，则工厂创建的对象图将不会被处理（GC可能会处理它们）。在这种情况下，
ChatService
似乎是一个单身汉。对不起。我的假设是这样的，因为
Func
是一个单例，就像
ChatService
一样。我的假设是
Func
会根据生活方式产生一个新实例，但经过一些实验后，我不得不得出结论，
Func
在注入单例时表现不同。Autofac中的
Func
在注入到单例时会产生单例，即使在生存期范围的上下文中调用
DoSomething
。这确实让IMO感到困惑。但这解释了为什么在Autofac的案例中，您必须依赖于
拥有的
。您不应该在范围上乱搞。事实上，您根本不需要将其传递给构造函数。您的服务应该通过DI容器传递，并让autofac处理您的范围。您还应该仔细检查文档。具有每个生存期作用域的组件将具有
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    
         }
     }
}

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;
        }
    }
}