CODEWITHSUNDEEP
c#ninjectninject.web
Ehsan Akbar
Ehsan Akbar

Reputation: 7299

injection error in binding in c# cyclical dependency was detected between the constructors of two services

i have a class as you can see with its constructor :

public  class ReceptionService:IReceptionService
    {
        private readonly DataContext _ctx;
        private readonly IAutomotiveRepository _automotiveRepository;
        private readonly IReferredRepository _referredRepository;
        private readonly IReceptionRepository _receptionRepository;
        private readonly IReceptionService _receptionService;
        private readonly IAutomotiveService _automotiveService;
        private readonly IReferredService _referredService;

        public ReceptionService(DataContext ctx, IReferredRepository ReferredRepository, IAutomotiveRepository AutomotiveRepository,IReceptionRepository ReceptionRepository,IReceptionService ReceptionService,IReferredService ReferredService,IAutomotiveService AutomotiveService)
        {
            _ctx = ctx;
            _automotiveRepository = AutomotiveRepository;
            _referredRepository = ReferredRepository;
            _receptionRepository = ReceptionRepository;
            _referredService = ReferredService;
            _automotiveService = AutomotiveService;
            _receptionService = ReceptionService;
        }
}

And in global part i define this :

 public class Global : NinjectHttpApplication
    {
        protected override IKernel CreateKernel()
        {
            var kernel = new StandardKernel();
            kernel.Bind<Reception.Domain.Repository.IAutomotiveRepository>().To<Reception.Infrustructure.RepositoryImplement.AutomotiveRepository>().InRequestScope();
            kernel.Bind<Reception.Domain.Repository.IReceptionRepository>().To<Reception.Infrustructure.RepositoryImplement.ReceptionRepository>().InRequestScope();
            kernel.Bind<Reception.Domain.Repository.IReferredRepository>().To<Reception.Infrustructure.RepositoryImplement.ReferredRepository>().InRequestScope();
            kernel.Bind<Reception.Domain.Repository.ITestRepository>().To<Reception.Infrustructure.RepositoryImplement.TestRepository>().InRequestScope();
            kernel.Bind<Reception.Domain.Repository.IReceptionHistoryRepository>().To<Reception.Infrustructure.RepositoryImplement.ReceptionHistoryRepository>().InRequestScope();
            kernel.Bind<Reception.Domain.Repository.IGasReceptionHistoryRepository>().To<Reception.Infrustructure.RepositoryImplement.GasReceptionHistoryRepository>().InRequestScope();
            kernel.Bind<Reception.Domain.Repository.IGasReceptionRepository>().To<Reception.Infrustructure.RepositoryImplement.GasReceptionRepositoy>().InRequestScope();
            kernel.Bind<Reception.Domain.Repository.IGasTestRepository>().To<Reception.Infrustructure.RepositoryImplement.GasTestRepository>().InRequestScope();
            kernel.Bind<Reception.Domain.Repository.IHydrostaticReceptionHistoryRepository>().To<Reception.Infrustructure.RepositoryImplement.HydrostaticReceptionHistoryRepository>().InRequestScope();
            kernel.Bind<Reception.Domain.Repository.IHydrostaticReceptionRepository>().To<Reception.Infrustructure.RepositoryImplement.HydrostaticReceptionRepository>().InRequestScope();
            kernel.Bind<Reception.Domain.Repository.IHydrostaticTestRepository>().To<Reception.Infrustructure.RepositoryImplement.HydrostaticTestRepository>().InRequestScope();


            kernel.Bind<Reception.Domain.Service.IAutomotiveService>().To<Reception.Application.ServiceImplement.AutomotiveService>().InRequestScope();
            kernel.Bind<Reception.Domain.Service.IReceptionService>().To<Reception.Application.ServiceImplement.ReceptionService>().InRequestScope();
            kernel.Bind<Reception.Domain.Service.IReferredService>().To<Reception.Application.ServiceImplement.ReferredService>().InRequestScope();
            kernel.Bind<Reception.Domain.Service.ITestService>().To<Reception.Application.ServiceImplement.TestService>().InRequestScope();
            kernel.Bind<Reception.Domain.Service.IReceptionHistoryService>().To<Reception.Application.ServiceImplement.ReceptionHistoryService>().InRequestScope();
            kernel.Bind<Reception.Domain.Service.IGasReceptionHistoryService>().To<Reception.Application.ServiceImplement.GasReceptionHistoryService>().InRequestScope();
            kernel.Bind<Reception.Domain.Service.IGasReceptionService>().To<Reception.Application.ServiceImplement.GasReceptionService>().InRequestScope();
            kernel.Bind<Reception.Domain.Service.IGasTestService>().To<Reception.Application.ServiceImplement.GasTestService>().InRequestScope();
            kernel.Bind<Reception.Domain.Service.IHydrostaticReceptionHistoryService>().To<Reception.Application.ServiceImplement.HydrostaticReceptionHistoryService>().InRequestScope();
            kernel.Bind<Reception.Domain.Service.IHydrostaticReceptionService>().To<Reception.Application.ServiceImplement.HydrostaticReceptionService>().InRequestScope();
            kernel.Bind<Reception.Domain.Service.IHydrostaticTestService>().To<Reception.Application.ServiceImplement.HydrostaticTestService>().InRequestScope();


            kernel.Bind<DataContext>().To<DataContext>().InSingletonScope();
            return kernel;
        }
}

But when irun my page i get this errors:

Error activating IReceptionService using binding from IReceptionService to ReceptionService
A cyclical dependency was detected between the constructors of two services.

Activation path:
 4) Injection of dependency IReceptionService into parameter ReceptionService of constructor of type ReceptionService
 3) Injection of dependency IReceptionService into parameter ReceptionService of constructor of type ReceptionService
 2) Injection of dependency ReceptionService into parameter instance of constructor of type NinjectIISHostingServiceHost{ReceptionService}
 1) Request for NinjectIISHostingServiceHost{ReceptionService}

Suggestions:
 1) Ensure that you have not declared a dependency for IReceptionService on any implementations of the service.
 2) Consider combining the services into a single one to remove the cycle.
 3) Use property injection instead of constructor injection, and implement IInitializable
    if you need initialization logic to be run after property values have been injected.

Upvotes: 0

Views: 746

Answers (1)

David
David

Reputation: 219027

The ReceptionService constructor expects a ReceptionService instance:

public ReceptionService(/.../, IReceptionService ReceptionService, /.../)

So in order to build a reception service, you first need to build a reception service? I suspect that's the cyclical dependency that's confusing the framework. Unless there are other constructors available which you can somehow configure in the dependency injector, it's going to indefinitely try to build a ReceptionService by trying to build a ReceptionService.

I guess the first step would be to conceptually determine why that class would need an instance of itself. I suspect it probably doesn't, though I don't know what you're building.

Upvotes: 1

Related Questions