Castle Windsor IoC w aplikacji MVC

Po pierwsze pewne konceptualne szczegóły. W ASP.NET aplikacja MVC typowym punktem wejścia dla żądania strony jest kontroler. Chcemy, aby Inwersja kontenera kontrolnego rozwiązywała nasze kontrolery za nas, ponieważ wtedy wszelkie zależności, które mają kontrolery, mogą być również automatycznie rozwiązywane po prostu wymieniając zależności jako argumenty w konstruktorach kontrolerów.

Zdezorientowany jeszcze? Oto przykład użycia IoC po jego skonfigurowaniu. Myślę, że wyjaśniając to w ten sposób wszystko jest łatwiejsze!

public class HomeController : Controller
{
    // lets say your home page controller depends upon two providers
    private readonly IMembershipProvider membershipProvider;
    private readonly IBlogProvider blogProvider;

    // constructor, with the dependencies being passed in as arguments
    public HomeController(
                IMembershipProvider membershipProvider,
                IBlogProvider blogProvider)
    {
        this.membershipProvider = membershipProvider;
        this.blogProvider = blogProvider;
    }

    // so taking your Registration example...
    [HttpPost]
    public ActionResult Register( Web.Models.Authentication.Registration model)
    {
        if (ModelState.IsValid)
        {
            this.membershipProvider.CreateUser(model.Email, model.Password);
        }

        // If we got this far, something failed, redisplay form
        return View(model);
    }
}

Zauważ, że nie musisz samodzielnie rozwiązywać problemów, po prostu określiłeś w kontrolerze, jakie są zależności. Nie podałeś też żadnych wskazówek, jak zaimplementowane są Zależności - to wszystko jest odsprzęgnięte. To bardzo proste nie ma tu nic skomplikowanego: -)

Mam nadzieję, że w tym momencie pytasz: "ale w jaki sposób konstruktor zostaje utworzony?"Tu zaczynamy urządzać Twój zamek kontener, a robimy to w całości w MVC Web project (nie Persistence czy Domain) . Edycja globalna.plik asax, ustawiający Castle Windsor jako fabrykę kontrolerów:

protected void Application_Start()
{
//...   
    ControllerBuilder.Current
        .SetControllerFactory(typeof(WindsorControllerFactory));
}

...i zdefiniuj WindsorControllerFactory tak, aby Twoje Kontrolery były utworzone przez Windsor:

/// Use Castle Windsor to create controllers and provide DI
public class WindsorControllerFactory : DefaultControllerFactory
{
    private readonly IWindsorContainer container;

    public WindsorControllerFactory()
    {
        container = ContainerFactory.Current();
    }

    protected override IController GetControllerInstance(
        RequestContext requestContext,
        Type controllerType)
    {
        return (IController)container.Resolve(controllerType);
    }
}

Metoda ContainerFactory.Current() jest statycznym singletonem, który zwraca skonfigurowany kontener Castle Windsor. Konfiguracja kontenera instruuje jak rozwiązać swój zależności aplikacji. Na przykład możesz mieć kontener skonfigurowany do rozwiązywania NHibernate SessionFactory i imembershipprovider.

Lubię konfigurować mój kontener Castle używając kilku "instalatorów". Każdy instalator odpowiada za inny typ zależności, więc miałbym instalatora kontrolera , instalatora NHibernate , Instalatora dostawcy .

Po pierwsze mamy ContainerFactory:

public class ContainerFactory
{
    private static IWindsorContainer container;
    private static readonly object SyncObject = new object();

    public static IWindsorContainer Current()
    {
        if (container == null)
        {
            lock (SyncObject)
            {
                if (container == null)
                {
                    container = new WindsorContainer();
                    container.Install(new ControllerInstaller());
                    container.Install(new NHibernateInstaller());
                    container.Install(new ProviderInstaller());
                }
            }
        }
        return container;
    }
}

...a potem potrzebujemy każdego z instalatorów. ControllerInstaller pierwszy:

public class ControllerInstaller : IWindsorInstaller
{
    public void Install(IWindsorContainer container, IConfigurationStore store)
    {
        container.Register(
            AllTypes
                .FromAssembly(Assembly.GetExecutingAssembly())
                .BasedOn<IController>()
                .Configure(c => c.Named(
                    c.Implementation.Name.ToLowerInvariant()).LifeStyle.PerWebRequest));
    }
}

... a oto mój NHibernateInstaller choć różni się od Twojego, możesz użyć własnej konfiguracji. Zauważ, że używam ponownie tej samej instancji ISessionFactory za każdym razem, gdy zostanie rozwiązana:

public class NHibernateInstaller : IWindsorInstaller
{
    private static ISessionFactory factory;
    private static readonly object SyncObject = new object();

    public void Install(IWindsorContainer container, IConfigurationStore store)
    {
        var windsorContainer = container.Register(
            Component.For<ISessionFactory>()
                .UsingFactoryMethod(SessionFactoryFactory));
    }

    private static ISessionFactory SessionFactoryFactory()
    {
        if (factory == null)
        {
            lock (SyncObject)
            {
                if (factory == null)
                {
                    var cfg = new Configuration();
                    factory = cfg.Configure().BuildSessionFactory();
                }
            }
        }

        return factory;
    }
}

I na koniec będziesz chciał zdefiniować swoje ProvidersInstaller:

public class ProvidersInstaller : IWindsorInstaller
{
    public void Install(IWindsorContainer container, IConfigurationStore store)
    {
        var windsorContainer = container
            .Register(
                Component
                    .For<IMembershipProvider>()
                    .ImplementedBy<SubjectQueries>())
            .Register(
                Component
                    .For<IBlogProvider>()
                    .ImplementedBy<SubjectQueries>());

            // ... and any more that your need to register
    }
}

To powinno wystarczyć, aby zacząć! mam nadzieję, że nadal jesteś ze mną jako piękno pojemnika Zamku staje się oczywiste bardzo szybko.

Kiedy definiujesz swoją implementację IMembershipProvider w warstwie persistence, pamiętaj, że ma ona zależność od NHibernate ISessionFactory. Wszystko co musisz zrobić to:

public class NHMembershipProvider : IMembershipProvider
{
    private readonly ISessionFactory sessionFactory;

    public NHMembershipProvider(ISessionFactory sessionFactory)
    {
        this.sessionFactory = sessionFactory;
    }
}

Zauważ, że ponieważ Castle Windsor tworzy twoje Kontrolery, a dostawcy są przekazywani do twojego konstruktora kontrolerów, dostawca jest automatycznie przekazywany ISessionFactory implementacji skonfigurowanej w Twoim kontenerze Windsor!

Nigdy nie musisz martw się o ponowne utworzenie jakichkolwiek zależności. Twój kontener zrobi to automatycznie za Ciebie.

Na koniec zauważ, że {[13] } powinien być zdefiniowany jako część twojej domeny, ponieważ definiuje interfejs dla zachowania Twojej domeny. Jak wspomniano powyżej, implementacja interfejsów domenowych, które zajmują się bazami danych, jest dodawana do warstwy trwałości.