Obtenir ninject pour disposer des ressources InRequestScope

Question

J'ai un projet avec lequel je travaille et j'essaie d'intégrer ninject dans. La façon dont je l'ai mis en place est que j'ai plusieurs classes de service qui héritent de deux classes de base similaires AbstractService & AbstractReadableService, à partir de laquelle ils ont accès à la couche de données à travers mon unité de travail. La dépendance principale que je veux être disposé est le DataContext qui est tenu par le UnitOfWork qui est à son tour injecté par ninject.

La façon dont j'ai tous ces composants mis en place est, j'ai le ServiceFactory mis dans le contrôleur, qui obtient les dépendances nécessaires de ninject. Ensuite, chaque fois que j'ai besoin d'un service, j'utilise la méthode GetService qui définit les dépendances nécessaires pour ce service tiré de la copie de ServiceFactory et renvoie une copie de ce service prêt à l'emploi. Cependant, lorsque je navigue vers une nouvelle page ou que j'effectue une autre action, la méthode Dispose sur UnitOfWork n'est jamais appelée.

Je pensais que ServiceFactory et ses dépendances seraient créés à chaque requête et que chaque fois que je définirais une nouvelle requête, UnitOfWork disposerait du contexte de base de données. Cependant, je ne suis pas en train d'utiliser la méthode d'élimination et j'espérais que quelqu'un pourrait me diriger dans la bonne direction.

AbstractService:

AbstractReadableService tient l'unité de travail.

public abstract class AbstractService : AbstractReadableService 
{ 
    /// <summary> 
    /// Gets the current user id all lowercase at run time 
    /// </summary> 
    protected string UserId; //TODO: Change, to a more complete object, ex: We can resolve the employee number at startup time and get all that from an object returned by ICustomPrincipalService 

    public AbstractService() { } 

    /// <summary> 
    /// Constructor for abstract service that we can use to create a new service inside of other services 
    /// </summary> 
    /// <param name="user"></param> 
    /// <param name="unitOfWork"></param> 
    public AbstractService(ICustomPrincipalService user, IUnitOfWork unitOfWork) 
    { 
     if (base._unitOfWork == null || this.UserId == null) 
     { 
      this.UserId = user.GetUser(); 
      base._unitOfWork = unitOfWork; 
     } 
    } 

    public void SetDependencies(ICustomPrincipalService user, IUnitOfWork unitOfWork) 
    { 
     if (base._unitOfWork == null || this.UserId == null) 
     { 
      this.UserId = user.GetUser(); 
      base._unitOfWork = unitOfWork; 
     } 
     else 
     { 
      // Throw some really nasty error 
     } 
    } 
} 

Unité de classe de travail

public class UnitOfWork : IUnitOfWork 
{ 
    private DataContext _dataContext; 


    public UnitOfWork(DataContext dataContext) 
    { 
     //Misc 
     _dataContext = dataContext; 
     ISomeRepo SomeRepo { get; private set; } 

     //Repositories 
     SomeRepo = new SomeRepo(dataContext); 

    } 

    public void SaveChanges(string userId) 
    { 
     RecordAuditProperties(userId); 
     _epmsContext.SaveChanges(); 
    } 

    private bool disposed = false; 
    protected virtual void Dispose(bool disposing) 
    { 
     if (!disposed) 
     { 
      if (disposing) 
      { 
       _dataContext.Dispose(); 
      } 
     } 
     disposed = true; 
    } 

    public void Dispose() 
    { 
     Dispose(true); 
     GC.SuppressFinalize(this); 
    } 
} 

usine de service

public class ServiceFactory : IServiceFactory 
{ 
    private IUnitOfWork _unitOfWork; 
    private ICustomPrincipalService _userInfo; 
    private IEmployeeCredentialService employeeCredentials; 

    public ServiceFactory(IUnitOfWork unitOfWork, ICustomPrincipalService userInfo, IEmployeeCredentialService employeeCredentials) 
    { 
     _unitOfWork = unitOfWork; 
     _userInfo = userInfo; 
    } 

    public T GetService<T>() where T : AbstractService, new() 
    { 
     T svc = new T(); 

     svc.SetDependencies(_userInfo, _unitOfWork); 

     return svc; 
    } 

    public T GetReadOnlyService<T>() where T : AbstractReadableService, new() 
    { 
     T svc = new T(); 

     svc.SetDependencies(_unitOfWork); 

     return svc; 
    } 
} 

bindings ninject:

private void AddBindings() 
    { 
     // Binding context to ensure only one context is used in the lifetime of the request 
     kernel.Bind<DataContext>().ToSelf().InRequestScope(); 
     kernel.Bind<IUnitOfWork>().To<UnitOfWork>().InRequestScope(); 

     //Deals with pulling the current HTTP context user id into the services 
     kernel.Bind<ICustomPrincipalService>().To<CustomPrincipalService>().InRequestScope(); 
     kernel.Bind<IHttpContextFactory>().To<HttpContextFactory>().InRequestScope(); 
     kernel.Bind<IEmployeeCredentialService>().To<EmployeeCredentialService>().InRequestScope(); 

     //Disposible dependencies are passed here 
     kernel.Bind<IServiceFactory>().To<ServiceFactory>().InRequestScope(); 
    } 

Answer 1

Tout était correct, j'ai pu le faire fonctionner après que je installé la solution Ninject MVC4 from nuget