NamedScopes Associazioni Ninject e asincrona (threading)

Question

Il mio progetto è strutturato da servizi e repository (tutti i repository condividono il contesto db). In uno dei miei livelli di servizio, ho un metodo asincrono che scrive nel database usando un repository. La richiesta web terminerà e eliminerà il contesto prima che questo metodo possa essere utilizzato. Ho provato a capire NamedScopes come indicato in questo answer. Non riesco ancora a capire come implementarlo. Mostrerò come è strutturato il mio progetto e spero che qualcuno possa aiutarmi a livello di codice.

Binding

private static void RegisterServices(IKernel kernel) 
    { 
     //dbcontext 
     kernel.Bind<EntityDatabaseContext>().ToMethod(context => new EntityDatabaseContext()).InRequestScope(); 

     //unit of work 
     kernel.Bind<IUnitOfWork>().To<UnitOfWork>().InRequestScope(); 

     //repositories 
     kernel.Bind<IRepository<Account>>().To<Repository<Account>>().InRequestScope(); 

     //services 
     kernel.Bind<IAuthenticationService>().To<AuthenticationService>().InRequestScope(); 
    } 

AuthenticationService utilizza iniezione costruttore

public AuthenticationService(UnitOfWork unitOfWork, IRepository<Account> accountRepository){} 

Procedimento dentro il mio AuthenticationService

//this is a background process 
    public Task SomeMethodAsync(string text) 
    { 
     //spin it off into a new task 
     return Task.Factory.StartNew(() => SomeMethod(text)); 
    } 

SomeMethod fa uso di accountRepository. Per favore dimmi se sono necessarie ulteriori informazioni. Per favore aiutatemi con il problema del threading, se NamedScopes è la soluzione, come posso implementarla nel mio caso?

Fondamentalmente, un processo in background è in esecuzione e sta utilizzando un contesto che viene eliminato da ninject a causa dell'ambito della richiesta.

Answer 1

È necessario tenere presente che l'esecuzione di thread in background può causare molti problemi. IIS può decidere di riciclare il pool di applicazioni in qualsiasi momento che interrompe immediatamente il thread (o che in alcuni casi non viene eseguito) lasciando l'applicazione in uno stato incoerente.

http://haacked.com/archive/2011/10/16/the-dangers-of-implementing-recurring-background-tasks-in-asp-net.aspx

Il più semplice e meno errori wayto incline eseguire operazioni asincroni è quello di implementare un servizio di Windows e delegare quelle operazioni asincrone al servizio delle finestre per esempio usando MSMQ.

Se si desidera continuare a leggere, leggere HostingEnvironment.RegisterObject e IRegisteredObject per evitare queste situazioni incoerenti.

La parte di Ninject è abbastanza semplice. Crea semplicemente una classe di processore di lavoro, ad es. MyJobProcessor prendendo tutte le dipendenze richieste per eseguire l'attività. Dovrebbe implementare INotifyWhenDisposed. Il modo più semplice per farlo è derivare da DisposeNotifyingObject.

Iniettare questo processore sul controller e lasciare che l'attività avviarlo e disporlo quando ha finito il suo lavoro.

Task.Factory.StartNew(() => 
    { 
     try 
     { 
      processor.Execute(); 
     } 
     finally 
     { 
      processor.Dispose); 
     } 
    }); 

Specificare che è lo scopo delle sue dipendenze.

Bind<MyJobProcessor>().ToSelf().Named("MyJobProcessor").DefinesNamedScope("MyJobProcessorScope"); 
Bind<IUnitOfWork>().To<UnitOfWork>().WhenAnyAnchestorNamed("MyJobProcessor").InNamedScope("MyJobProcessorScope");