Autofac l'injection de dépendance de la mise en œuvre

J'ai commencé à travailler sur un nouveau projet et je viens d'une directe et "naïve" de la programmation.

Droit maintenant, je suis sujet à propos de l'utilisation conteneur IoC, en particulier sur l'Injection de Dépendance formulation à l'aide de Autofac.

Disons que j'ai une session d'usine :

namespace Warehouse.Data
{
    public class SessionFactory
    {
        private static ISessionFactory _sessionFactory;
        private static ISystemSetting _systemSetting;

        SessionFactory(ISystemSetting systemSetting)
        {
            _systemSetting = systemSetting;

            InitializeSessionFactory();
        }

        private static void InitializeSessionFactory()
        {
            _sessionFactory = Fluently.Configure()
                .Database(DatabaseConfiguration)
                .Mappings(m => m.FluentMappings.AddFromAssemblyOf<MyMap>())
                .BuildSessionFactory();
        }

        public static ISession OpenSession()
        {
            return _sessionFactory.OpenSession();
        }
    }
}

Et dans le Bootstrap.cs, j'ai configurer autofac comme ceci :

namespace Warehouse.Infrastructure
{
    using Autofac;

    public class Bootstrap
    {
        public IContainer Configure()
        {
            var builder = new ContainerBuilder();

            builder.RegisterType<SystemSetting>().As<ISystemSetting>();
            builder.RegisterType<UserRepository>().As<IUserRepository>();

            return builder.Build();
        }
    }
}

Ma question est: est-ce

  1. Comment puis-je utiliser Autofac pour résoudre SessionFactory dépendance à ISystemSetting?
    Dois-je utiliser builder.Resolve<ISystemSetting> en tant que paramètre à chaque fois que je veux utiliser SessionFactory?
  2. L'Injection de dépendance motif, ou peut-être juste Autofac, est livré avec de nombreuses nouvelles word tels que le Service, Résoudre, Singleton, etc. Où puis-je apprendre ces choses à partir de zéro? Est-il le même pour tous les autres DI-Cadre?
  3. J'ai besoin de comprendre comment le Conteneur IoC travaille dans un projet avec plusieurs couche, faire chaque couche a besoin d'une référence à l'Autofac?

Merci.

ce que je ne comprends pas dans votre exemple, votre sessionfactory, car il contient également un "statique ISessionFactory _sessionFactory;". si vous encapsuler une sessionfactory dans une session d'usine? il me semble que vous voulez faire une séance de classe.

OriginalL'auteur Samuel Adam | 2013-04-26

  1. 8

    1. vous avez déjà fait dans votre fichier d'amorçage.

      builder.RegisterType<SystemSetting>().As<ISystemSetting>();

      qui signifie que chaque oject qui a une dépendance ISystemSettings obtient une instance de la configuration du Système. donc, si vous utilisez

      var mySessionFactory = myContainer.Resolve<SessionFactory>();

      quelque part dans votre code (vous devriez vraiment le faire dans votre composition de la racine), le conteneur va faire le travail pour vous. Si vous avez beaucoup d'objets, avec de multiples dépendances, vous allez commencer à comprendre pourquoi les Cio, les contenants sont "magiques" 😉

    2. bien .. beaucoup de Cio conteneurs utiliser le mot résoudre. ça veut juste dire "donnez-moi un objet avec ses dépendances".
      service et singleton sont des mots de la conception orientée objet langue. ils ne sont pas spécifiques à conteneurs IoC. vous pouvez google. Je pense qu'il y a pas de résumé pour des trucs comme ça. vous l'obtiendrez en temps en lisant des livres, des articles et des tutoriels.

    3. pas. en fait ce serait un no go. il s'agit d'un modèle appelé servicelocator qui est considéré par certains d'être un antipattern. si vous suivez ce modèle, tous vos objets ont exactement une dépendance, le conteneur! et ils ont eux-même de sortir de ce dont ils ont besoin.

      public class MyClass
{
    private DependencyOne dep1;

    public MyClass(WhatEverContainer container)
    {
        dep1 = container.Resolve<DependencyOne>();
    }
}

      ... dans ce cas, votre conteneur de loi comme un servicelocator et tous les objets qui ont besoin d'une dépendance demander le servicelocator pour obtenir que la dépendance.
      qui porterait atteinte à la valeur entière de l'INVERSION de contrôle et de vos objets dépend d'un conteneur. injecter ce que les objets ont réellement besoin, pas ce dont ils ont besoin pour trouver ce dont ils ont réellement besoin ;D

      laissez vos objets conteneur agnostique. et l'utilisation de votre conteneur dans votre composition de la racine, c'est là que tu colle les objets et les couches de votre application. ici quelque chose à lire: http://blog.ploeh.dk/2011/07/28/CompositionRoot/

    OriginalL'auteur Egi