El enlace de Singleton Scope no funciona según lo previsto

Question

Estoy usando el complemento ninject mvc3 con mi aplicación web api. Me tendrá un borde que se parece a:

kernel.Bind<IFoo>().To<Foo>().InSingletonScope();

Es mi interpretación de que el meollo creará exactamente una instancia de Foo y volver a utilizarlo adecuadamente. Al poner un punto de interrupción en el constructor Foo, puedo ver claramente que se llama una vez por solicitud, y no puedo explicar por qué.

Mi única suposición es que de alguna manera se está creando un kernel nuevo por solicitud, pero ese no parece ser el caso, ya que el método CreateKernel que establece el resolvedor de dependencias global solo se ejecuta una vez en la vida de la aplicación.

estoy usando un código tomado de this post hacer ninject jugar bonito con MVC 4. Debido a los cambios estructurales, que tenía que hacer una envoltura adicional que le asigno a GlobalConfiguration.Configuration.DependencyResolver:

public class NinjectResolver : NinjectScope, IDependencyResolver 
{ 
    private readonly IKernel _kernel; 
    public NinjectResolver(IKernel kernel) 
     : base(kernel) 
    { 
     _kernel = kernel; 
    } 
    public IDependencyScope BeginScope() 
    { 
     return new NinjectScope(_kernel.BeginBlock()); 
    } 
} 

¿Qué estoy haciendo ¿incorrecto?

Answer 1

que nunca podría conseguir para que funcione correctamente, y no estoy seguro de por qué. Supongo que tiene algo que ver con la integración de MVC4 siendo un poco inmaduro en este momento.

Como alternativa estoy usando:

kernel.Bind<IFoo>().ToConstant(new Foo());

Esto parece funcionar, pero no estoy muy contento con él.

Answer 2

Nota: utilicé nuget para instalar ninject & ninject.web.mvc (que estoy seguro que hiciste también).

No puedo ver el resto de tu código, pero esto es lo que tenía en mi clase "NinjectDependencyScope". (Creo que la suya simplemente se llama NinjectScope, podría haber algunas otras inconsistencias de nombres con su código)

public class NinjectDependencyScope : IDependencyScope 
{ 
    private IResolutionRoot _resolver; 

    internal NinjectDependencyScope(IResolutionRoot resolver) 
    { 
     Contract.Assert(resolver != null); 

     _resolver = resolver; 
    } 

    #region IDependencyScope Members 

    public void Dispose() 
    { 
     var disposable = _resolver as IDisposable; 
     if (disposable != null) 
      disposable.Dispose(); 

     _resolver = null; 
    } 

    public object GetService(Type serviceType) 
    { 
     if (_resolver == null) 
      throw new ObjectDisposedException("this", "This scope has already been disposed"); 
     return _resolver.TryGet(serviceType); 
    } 

    public IEnumerable<object> GetServices(Type serviceType) 
    { 
     if (_resolver == null) 
      throw new ObjectDisposedException("this", "This scope has already been disposed"); 

     return _resolver.GetAll(serviceType); 
    } 

    #endregion 
} 

Y aquí está mi clase NinjectWebCommon (que se encuentra en la carpeta App_Start):

using System; 
using System.Web; 
using System.Web.Http; 
using Microsoft.Web.Infrastructure.DynamicModuleHelper; 
using Ninject; 
using Ninject.Modules; 
using Ninject.Web.Common; 

[assembly: WebActivator.PreApplicationStartMethod(typeof(ABCD.Project.Web.App_Start.NinjectWebCommon), "Start")] 
[assembly: WebActivator.ApplicationShutdownMethodAttribute(typeof(ABCD.Project.Web.App_Start.NinjectWebCommon), "Stop")] 

namespace ABCD.Project.Web.App_Start 
{ 
public static class NinjectWebCommon 
{ 
    private static readonly Bootstrapper Bootstrap = new Bootstrapper(); 

    /// <summary> 
    /// Starts the application 
    /// </summary> 
    public static void Start() 
    { 
     DynamicModuleUtility.RegisterModule(typeof(OnePerRequestHttpModule)); 
     DynamicModuleUtility.RegisterModule(typeof(NinjectHttpModule)); 
     Bootstrap.Initialize(CreateKernel); 
    } 

    /// <summary> 
    /// Stops the application. 
    /// </summary> 
    public static void Stop() 
    { 
     Bootstrap.ShutDown(); 
    } 

    /// <summary> 
    /// Creates the kernel that will manage your application. 
    /// </summary> 
    /// <returns>The created kernel.</returns> 
    private static IKernel CreateKernel() 
    { 
     var kernel = new StandardKernel(); 
     kernel.Bind<Func<IKernel>>().ToMethod(ctx =>() => new Bootstrapper().Kernel); 
     kernel.Bind<IHttpModule>().To<HttpApplicationInitializationHttpModule>(); 

     RegisterServices(kernel); 

     // Set Web API Resolver 
     GlobalConfiguration.Configuration.DependencyResolver = new NinjectDependencyResolver(kernel); 
     return kernel; 
    } 

    /// <summary> 
    /// Load your modules or register your services here! 
    /// </summary> 
    /// <param name="kernel">The kernel.</param> 
    private static void RegisterServices(IKernel kernel) 
    { 
     //var modules = new INinjectModule[] { new NinjectBindingModule(), }; 
     //kernel.Load(modules); 
     Here's where you would load your modules or define your bindings manually... 
    }   
} 
} 

Answer 3

Como se mencionó anteriormente, parece un error.
Una opción es simplemente poner en práctica un método de extensión Singleton mismo:

public static class NinjectSingletonExtension 
{ 
    public static CustomSingletonKernelModel<T> SingletonBind<T>(this IKernel i_KernelInstance) 
    { 
     return new CustomSingletonKernelModel<T>(i_KernelInstance); 
    } 
} 

public class CustomSingletonKernelModel<T> 
{ 
    private const string k_ConstantInjectionName = "Implementation"; 
    private readonly IKernel _kernel; 
private static object padlock = new Object(); 

    private T _concreteInstance; 


    public CustomSingletonKernelModel(IKernel i_KernelInstance) 
    { 
     this._kernel = i_KernelInstance; 
    } 

    public IBindingInNamedWithOrOnSyntax<T> To<TImplement>(TImplement i_Constant = null) where TImplement : class, T 
    { 
     _kernel.Bind<T>().To<TImplement>().Named(k_ConstantInjectionName); 
     var toReturn = 
      _kernel.Bind<T>().ToMethod(x => 
             { 
              if (i_Constant != null) 
              { 
               return i_Constant; 
              } 

              if (_concreteInstance == null) 
         { 
         lock (padlock) 
         { 
         if (_concreteInstance == null) 
         { 
          _concreteInstance = _kernel.Get<T>(k_ConstantInjectionName); 
         } 
          } 
         } 


              return _concreteInstance; 
             }).When(x => true); 

     return toReturn; 
    } 
} 

Y a continuación, sólo tiene que utilizar:

i_Kernel.SingletonBind<T>().To<TImplement>(); 

En lugar de

i_Kernel.Bind<T>().To<TImplement>().InSingletonScope(); 

Answer 4

llegar Ciertamente finales a este hilo pero sólo pasó a mí con un servicio de alojamiento Windows OWIN para los controladores de la API Web y resolver las dependencias con Ninject, InSingletonScope() no estaba funcionando hasta que hice lo siguiente:

var kernel = new StandardKernel(); 
... 
kernel.Bind<Foo>().ToSelf().InSingletonScope(); 
kernel.Bind<IFoo>().ToMethod(context => context.Kernel.Get<Foo>()); 
... 

// Controllers ask for the dependency as usual... 
public class SomeController : ApiController 
{ 
    readonly IFoo _foo; 

    public SomeController(IFoo foo) 
    { 
     _foo = foo; 
    } 
... 

Esperanza esto ayuda