E 'possibile che Castle Windsor risolva le dipendenze dalla proprietà quando non si ha un riferimento al container?

Question

Abbiamo una soluzione con più progetti che rappresentano gli strati della nostra applicazione. ad es.

Domain

dati

Logic

WebUI

contenitore Il nostro castello di Windsor viene fatto riferimento dal nostro livello di web e abbiamo poi a cascata queste dipendenze attraverso i nostri strati. Per esempio ...

// In Domain 
public interface IFooRepository 
{ 
    void DoSomething(); 
} 

// In Data 
public class FooRepository : IFooRepository 
{ 
    public void DoSomething() 
    { 
     // Something is done 
    } 
} 

// In Logic 
public class MyThingManager 
{ 
    private readonly IFooRepository fooRepository; 

    public MyThingManager(IFooRepository fooRepository) 
    { 
     this.fooRepository = fooRepository; 
    } 

    public void AMethod() 
    { 
     this.fooRepository.DoSomething(); 
    } 

} 

// In Web 
// in some controller.... 
var newManager = new MyThingManager(WindsorContainer.Resolve<IFooRepository>()); 
newManager.DoSomething(); 

e questo funziona bene fino a quando i nostri manager hanno un sacco di membri che hanno le proprie dipendenze. Quando ciò accade, finiamo per risolvere sia le dipendenze dei manager che le loro dipendenze e le distribuzioni dipendenti dal livello web. Questo risulta essere alcuni costruttori piuttosto grandi.

C'è un modo più elegante di, ad esempio se i componenti interni di un gestore risolvono le proprie dipendenze senza avere accesso al contenitore?

Ricordare che SOLO il livello Web ha accesso al contenitore (per evitare una dipendenza di progetto circolare), quindi solo il livello Web può attivare attivamente WindsorContainer.Resolve() il livello logico non può quindi l'unico modo per eseguire una cascata una dipendenza senza l'assistenza dei contenitori era quella di risolverlo nel livello Web e poi di passarlo sulla catena usando la sua interfaccia.

Answer 1

La risposta breve è che ogni volta che si vede .Resolve<T> si è probabilmente doing it wrong. Come menzionato @Steven, si desidera utilizzare le funzionalità integrate di Windsor per fornire l'iniezione del costruttore (e/o l'iniezione di proprietà). Ciò significa che WindsorContainer deve conoscere l'oggetto che si trova nella radice del grafico dell'oggetto.

Nel tuo caso, dovresti risalire l'albero degli oggetti (da MyThingyManager) fino a raggiungere l'oggetto radice. Ad esempio, in un'applicazione ASP.NET MVC questo sarebbe il controller che contiene l'azione che viene chiamata. Per il caso MVC3, si utilizzerà uno DependencyResolver per avviare l'iniezione di tutte le dipendenze.

Inoltre, ciò che ho trovato utile con Windsor in passato è avere un Installer diverso per componente (assieme). E quindi registrare questi programmi di installazione alla base del processo che ospita l'applicazione.

Quindi, in ogni componente si avrebbe un programma di installazione come:

public class Installer : IWindsorInstaller 
{ 
     public void Install(Castle.Windsor.IWindsorContainer container, Castle.MicroKernel.SubSystems.Configuration.IConfigurationStore store) 
     { 
      container.Register(
       Component.For<IMyThingManager>().ImplementedBy<MyThingManager>(), 
       Component.For<IFooRepository>().ImplementedBy<FooRepository>() 
       ); 
     } 
} 

E poi in Global.asax.cs Application_Start si dovrebbe avere qualcosa di simile:

var container = new WindsorContainer(); 
container.Install(FromAssembly.This()); 
container.Install(FromAssembly.Containing(typeof(ComponentThatContains.MyThingManager.Installer))); 

Questo ti dà un modo per gestire tutte le dipendenze lungo l'intero grafico degli oggetti e risolverli tramite l'iniezione del costruttore. Spero che questo aiuti.