Château Windsor, injections de dépendance retour null

Question

Probablement mon idée est erronée depuis le début.

J'ai un projet MVC5, et j'essaie d'implémenter une couche de référentiel entre mon site et EF (pour la semplicité, c'est un projet d'apprentissage).

j'ai un code EF premier contexte, et une classe Repository:

public interface IRepository<TDbContext> : IDisposable where TDbContext : class, new() 

public class Repository<TContext> : IRepository<TContext>, IDisposable where TContext : DbContext, new() 

J'ai une deuxième couche où je mets en œuvre des fonctions supplémentaires:

public interface ILog<TLogContext> : IRepository<TLogContext> where TLogContext : class, new() 

public class Logger<TContext> : Repository<TContext>, ILog<TContext> where TContext : LogContext, new() 

Le porpouse est d'utiliser le générique référentiel pour tous mes contextes, et de créer des contextes séparés et séparer les «secondes couches» pour différentes zones/portées dans mon site Web (journalisation, gestion de compte, etc), de sorte que je peux utiliser, si je veux, différentes implémentations DB.

Et c'est la mise en œuvre Windsor:

Installer.cs:

public class Installer : IWindsorInstaller 
{ 
    public void Install(IWindsorContainer container, IConfigurationStore store) 
    { 
     // Controller 
     container.Register(
      Classes.FromThisAssembly().BasedOn<IController>().LifestyleTransient()); 

     // EF, Business 
     container.Register(
      Component.For<IRepository<LogContext>>() 
        .ImplementedBy<Repository<LogContext>>() 
        .LifestylePerWebRequest() 
     ); 

     container.Register(
      Component.For<ILog<LogContext>>() 
        .ImplementedBy<Logger<LogContext>>() 
        .LifestylePerWebRequest() 
     ); 
    } 
} 

ControllerFactory.cs:

public class ControllerFactory : DefaultControllerFactory 
{ 
    private readonly IKernel kernel; 

    public ControllerFactory(IKernel kernel) 
    { 
     this.kernel = kernel; 
    } 

    public override void ReleaseController(IController controller) 
    { 
     kernel.ReleaseComponent(controller); 
    } 

    protected override IController GetControllerInstance(RequestContext requestContext, Type controllerType) 
    { 
     if (controllerType == null) 
     { 
      throw new HttpException(404, string.Format("The controller for path '{0}' could not be found.", requestContext.HttpContext.Request.Path)); 
     } 

     return (IController)kernel.Resolve(controllerType); 
    } 
} 

Et Global.asax:

protected void Application_Start() 
    { 
     AreaRegistration.RegisterAllAreas(); 
     FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); 
     RouteConfig.RegisterRoutes(RouteTable.Routes); 

     // Windsor 
     container = new WindsorContainer().Install(FromAssembly.This()); 

     // ContainerFactory loading 
     ControllerBuilder.Current.SetControllerFactory(new ControllerFactory(container.Kernel)); 
    } 

BaseController.cs:

public class BaseController : Controller 
{ 
    // Services 
    internal ILog<LogContext> Logger { get; set; } 

    public void Test() 
    { 
     var allEvents = Logger.All<Event>(); 
    } 
} 

Et ... Logger est nulle. Pourquoi?

Answer 1

La propriété Logger doit être public.

Documentation complète here, les détails pertinents est:

injection Propriété de dépendances est conçu pour être fait lors de l'activation d'un composant lorsqu'un composant est créé. La responsabilité de déterminer les propriétés sont utilisées pour l'injection est remplie par défaut par PropertiesDependenciesModelInspector - une implémentation IContributeComponentModelConstruction qui utilise tous les critères suivants pour déterminer si une propriété représente une dépendance:

• a-t-setter accessible « public »
• est une propriété d'instance
• Si ComponentModel.InspectionBehavior est réglé sur PropertiesInspectionBehavior.DeclaredOnly, n'est pas hérité
• N'a pas paramètres
• Is not annotés avec l'attribut Castle.Core.DoNotWireAttribute

Si une propriété répond à tous ces critères, un modèle de dépendance est créé pour elle et il est ensuite résolu lorsque les dépendances de composant sont résolues lors de l'activation.