Gemischter lifestyle für Pro Thread und Pro Web-Anfrage mit Einfach Injektor

Scheint es, wenn ich ausführen einer Aufgabe in einem separaten thread in ASP.NET MVC,
SimpleInjector erstellt eine neue Instanz von DbContext für jeden Anruf.

Das Verhalten der RegisterPerWebRequest lebensstil der Einfachen Injector v1.5 und unten ist um wieder eine transiente Instanz, wenn Instanzen werden gebeten, außerhalb des Kontextes eines web-Anfrage (wo HttpContext.Current null ist). Rückkehr eine transiente Instanz wurde ein design-Fehler in Einfache Injektor, da dies macht es leicht zu verstecken unsachgemäße Nutzung. Die Version 1.6 von der Einfachen Injektor wird eine exception werfen, statt falsch Rückkehr eine transiente Instanz, klar zu kommunizieren, dass Sie falsch konfiguriert ist der container.

Während einige IoC-Bibliotheken (zum Beispiel StructureMap) haben eine gemischte
lifestyle für die pro-thread-pro-webrequest, es scheint Einfach, Injektor
hat nicht einer

Ist es richtig, dass Einfache Injektor hat keine integrierte Unterstützung für gemischte Lebensstile, wegen ein paar Gründen. Zunächst einmal ist es durchaus ein exotisches feature, das nicht viele Menschen brauchen. Zweitens, können Sie mischen zwei oder drei Lebensstile zusammen, das wäre also fast eine endlose Kombination von Hybriden. Und zuletzt, es ist (ziemlich) einfach anmelden, selbst.

Obwohl Sie können mischen Pro Web-Anfrage mit Pro Thread Lebensstile, wäre es wahrscheinlich besser, wenn Sie sich mischen, die Pro Web-Anfrage mit Pro Lebensdauer Rahmen, da mit der Lebensdauer Bereich, den Sie explizit starten und beenden Sie den Umfang (und können über die DbContext wenn der scope endet).

Vom Einfache Injektor 2 und auf, Sie können leicht mischen Sie eine beliebige Anzahl von Lebensstilen zusammen mit der Lifestyle.CreateHybrid Methode. Hier ist ein Beispiel:

var hybridLifestyle = Lifestyle.CreateHybrid(
    () => HttpContext.Current != null,
    new WebRequestLifestyle(),
    new LifetimeScopeLifestyle());

//Register as hybrid PerWebRequest /PerLifetimeScope.
container.Register<DbContext, MyDbContext>(hybridLifestyle);

Es ist ein weiterer Stackoverflow-Frage, die in diesem Thema ein bisschen tiefer, möchten Sie vielleicht einen Blick: Einfache Injektor: multi-threading in MVC3 ASP.NET

UPDATE

Über Ihr update. Sie sind fast da. Die Befehle, die auf einem hintergrund-thread ausgeführt werden müssen, innerhalb einer Lebensdauer Anwendungsbereich, so müssen Sie explizit starten. Der trick ist hier zu nennen BeginLifetimeScope neuen thread auf, aber vor der eigentlichen Befehls-handler (und Ihre Abhängigkeiten) erstellt. In anderen Worten, der beste Weg, dies zu tun, ist in einen decorator.

Die einfachste Lösung ist ein update Ihrer AsyncCommandHandlerDecorator zum hinzufügen von Rahmen:

public class AsyncCommandHandlerDecorator<TCommand> 
    : ICommandHandler<TCommand> where TCommand : ICommand 
{
    private readonly Container _container;
    private readonly Func<ICommandHandler<TCommand>> _factory;

    public AsyncCommandHandlerDecorator(Container container,
        Func<ICommandHandler<TCommand>> factory) 
    {
        _container = container;
        _factory = factory;
    }

    public void Handle(TCommand command) 
    {
        ThreadPool.QueueUserWorkItem(_ => 
        {
            using (_container.BeginLifetimeScope())
            {
                //Create new handler in this thread
                //and inside the lifetime scope.
                var handler = _factory();
                handler.Handle(command);
            }
        });
    }
}

Puristen, für die SOLID Prinzipien zu Schreien, dass diese Klasse gegen die Prinzip Der Einzigen Verantwortung, da dieser Dekorator beide Befehle ausgeführt werden, in einem neuen thread und beginnt ein neues Leben Umfang. Ich würde nicht zu viel sorgen, da ich denke, dass es eine enge Beziehung zwischen dem starten einer hintergrund-thread starten und Lebensdauer Umfang (verwenden Sie nicht das eine ohne das andere sowieso). Aber immer noch, Sie könnte leicht lassen Sie die AsyncCommandHandlerDecorator unberührt und erzeugen eine neue LifetimeScopedCommandHandlerDecorator wie folgt:

public class LifetimeScopedCommandHandlerDecorator<TCommand> 
    : ICommandHandler<TCommand> where TCommand : ICommand 
{
    private readonly Container _container;
    private readonly Func<ICommandHandler<TCommand>> _factory;

    public LifetimeScopedCommandHandlerDecorator(Container container,
        Func<ICommandHandler<TCommand>> factory)
    {
        _container = container;
        _factory = factory;
    }

    public void Handle(TCommand command)
    {
        using (_container.BeginLifetimeScope())
        {
            //The handler must be created inside the lifetime scope.
            var handler = _factory();
            handler.Handle(command);
        }
    }
}

Die Reihenfolge in der die Dekoratoren registriert werden, von natürlich essentiell, da die AsyncCommandHandlerDecorator muss wickeln Sie die LifetimeScopedCommandHandlerDecorator. Dies bedeutet, dass die LifetimeScopedCommandHandlerDecorator Registrierung muss zuerst kommen:

container.RegisterDecorator(typeof(ICommandHandler<>),
    typeof(LifetimeScopedCommandHandlerDecorator<>),
    backgroundCommandCondition);

container.RegisterDecorator(typeof(ICommandHandler<>),
    typeof(AsyncCommandHandlerDecorator<>),
    backgroundCommandCondition);

Diese alte Stackoverflow-Frage spricht über diese im detail. Sie sollten definitiv einen Blick.