Asp.Net MVC UNitOfWork e MySQL e collegamenti a pelo

Question

Ho una web app MVC che si basa sulla seguente architettura

Asp.Net MVC2, Ninject, Ottima NHibernate, MySQL che utilizza un'unità di modello di lavoro.

Ogni connessione a MySQL genera una connessione di sonno che può essere visto come una voce nei risultati della query SHOW PROCESSLIST.

Alla fine questo si riproducono abbastanza connessioni al exeed limite stagno di app e crash l'applicazione web.

Ho il sospetto che le connessioni non vengono smaltiti correttamente.

Se questo è il caso dove e come dovrebbe succedere?

Ecco un'istantanea del codice che sto usando:

public class UnitOfWork : IUnitOfWork
{
    private readonly ISessionFactory _sessionFactory;
    private readonly ITransaction _transaction;
    public ISession Session { get; private set; }

    public UnitOfWork(ISessionFactory sessionFactory)
    {
        _sessionFactory = sessionFactory;
        Session = _sessionFactory.OpenSession();
        Session.FlushMode = FlushMode.Auto;
        _transaction = Session.BeginTransaction(IsolationLevel.ReadCommitted);
    }

    public void Dispose()
    {
        if (Session != null)
        {
            if (Session.IsOpen)
            {
                Session.Close();
                Session = null;
            }
        }
    }

    public void Commit()
    {
        if (!_transaction.IsActive)
        {
            throw new InvalidOperationException("No active transation");
        }
        _transaction.Commit();
        Dispose();
    }

    public void Rollback()
    {
        if (_transaction.IsActive)
        {
            _transaction.Rollback();
        }
    }
}




public interface IUnitOfWork : IDisposable
{
    void Commit();
    void Rollback();
}




public class DataService
{
    int WebsiteId = Convert.ToInt32(ConfigurationManager.AppSettings["Id"]);

    private readonly IKeyedRepository<int, Page> pageRepository;
    private readonly IUnitOfWork unitOfWork;

    public PageService Pages { get; private set; }


    public DataService(IKeyedRepository<int, Page> pageRepository,
        IUnitOfWork unitOfWork)
    {
        this.pageRepository = pageRepository;
        this.unitOfWork = unitOfWork;

        Pages = new PageService(pageRepository);

    }

    public void Commit()
    {
        unitOfWork.Commit();
    }

}


public class PageService
{
    private readonly IKeyedRepository<int, Page> _pageRepository;
    private readonly PageValidator _pageValidation;

    public PageService(IKeyedRepository<int, Page> pageRepository)
    {
        _pageRepository = pageRepository;
        _pageValidation = new PageValidator(pageRepository);
    }

    public IList<Page> All()
    {
        return _pageRepository.All().ToList();
    }

    public Page FindBy(int id)
    {
        return _pageRepository.FindBy(id);
    }
}

Answer 1

Il tuo post non dà alcuna informazione in cui vengono creati di portata UOW.

Se è transitoria. Non sarà disposto a tutto e questo dipende da voi.

In caso di InRequestScope sarà disposta dopo il CG ha raccolto HttpContext. Ma, come ho detto a Bob di recente nel Ninject Mailing List è possibile rilasciare tutti gli oggetti nel gestore di eventi richiesta fine del HttpApplication. Io aggiungo il supporto per questo nella prossima release di Ninject.

Answer 2

Ho fatto qualche indagine sulla causa principale di questo problema. Qui è un po 'più di informazioni e le possibili soluzioni:

http://blog.bobcravens.com / 2010/11 / usando-Ninject da gestire-critiche-resources /

Enjoy.

Answer 3

Ninject non fornisce alcuna garanzia circa quando e dove saranno IDisposabled tuoi Disposes.

posta dalla originale l'uomo Ninject

Vorrei anche suggerire di dare un'occhiata qui intorno, questo ha messo a punto per i vari meccanismi di persistenza e contenitori vari - la cosa fondamentale è che devi prendere il controllo e sapere quando sei aggancio negli anni UOW commit / rollback / dispose semantica e non lasciare al caso o cooincidence (anche se Convenzione è grande).