Iniezione di dipendenza più istanze o solo una InrequestScope

Sto cercando di capire cosa succede con le dipendenze (Ninject) quando una stessa interfaccia viene iniettata in più classi. Sto specificando InRequestScope per i miei binding, così come capisco che dovrebbe esserci sempre una singola istanza di diciamo il mio IUnitOfWork in una singola HttpRequest.

C'è un modo per verificare quante istanze di IUnitOfWork sono attualmente aperte all'interno di una HttpRequest - il che confermerebbe o smentirebbe la mia domanda qui.

Ho fatto un semplice esempio di come lo sto usando e quale sia la mia domanda.

La domanda è - in un singolo HttpRequest ci saranno due istanze di IUnitOfWork o solo una?

Ho una unità di lavoro che implementa un'interfaccia e alcuni metodi.

public interface IUnitOfWork : IDisposable
{
    string GetItem(string what);
    string GetAllItems();
}

public class UnitOfWork : IUnitOfWork
{
    public string GetAllItems()
    {
        return "This is something different...";
    }

    public string GetItem(string what)
    {
        return "Actual item for " + what + " is Beer";
    }

    public void Dispose()
    {
        // Dispose any contexts etc.
    }
}

Ho anche una classe di servizio che implementa un'interfaccia e viene utilizzata da un controller. Questo servizio richiede un IUnitOfWork tramite un costruttore.

public interface IService
{
    string ServeMe(string what);
}
public class Service : IService
{
    private readonly IUnitOfWork _unitOfWork;
    public Service(IUnitOfWork unitOfWork)
    {
        this._unitOfWork = unitOfWork;
    }

    public string ServeMe(string what)
    {
        return "Served you some: " + _unitOfWork.GetItem(what);
    }
}

Il mio controller prende due parametri attraverso il suo costruttore - IUnitOfWork e IService.

Per favore non importa la decisione architettonica, so che dovrei iniettare IService nel mio controller, ma questo è il modo più semplice per mostrare quale sia la mia domanda.

public class HomeController : Controller
{
    private readonly IUnitOfWork _unitOfWork;
    private readonly IService _service;
    public HomeController(IUnitOfWork unitOfWork,
                            IService service)
    {
        this._unitOfWork = unitOfWork;
        this._service = service;
    }

    public ActionResult Index()
    {
        ViewBag.Item = _unitOfWork.GetAllItems();
        return View();
    }

    public ActionResult Serve()
    {
        ViewBag.Served = _service.ServeMe("a drink");
        return View();
    }
}

E finalmente sto usando Ninject per le mie esigenze di DI. Ecco come leghiamo sia IUnitOfWork che IService.

kernel.Bind<IUnitOfWork>().To<UnitOfWork>().InRequestScope();
kernel.Bind<IService>().To<Service>().InRequestScope();