Implementazione iniezione dipendenza Autofac

Question

Ho iniziato a lavorare su un nuovo progetto e provengo da una programmazione diretta e "ingenua".

In questo momento, mi preoccupo dell'utilizzo del contenitore IoC, in particolare del diagramma di distribuzione delle dipendenze con Autofac.

Diciamo che ho una semplice fabbrica di sessione:

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(); 
     } 
    } 
} 

E in Bootstrap.cs, ho configurare autofac come questo:

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(); 
     } 
    } 
} 

mia domanda è questa:

1. Come posso utilizzare Autofac per risolvere la dipendenza SessionFactory da ISystemSetting? Devo usare builder.Resolve<ISystemSetting> come parametro ogni volta che voglio usare SessionFactory?
2. Il pattern di iniezione delle dipendenze, o forse solo Autofac, include molte nuove parole come Service, Resolve, Singleton, ecc. Dove posso imparare queste cose da zero? È lo stesso per ogni altro DI Framework?
3. Ho bisogno di capire come IoC Container funziona in un progetto con più livelli, ogni livello ha bisogno di un riferimento a Autofac?

Grazie.

Answer 1

1. lo avete già fatto nel vostro bootstrap.

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

   significa che ogni oggetto che ha una dipendenza da ISystemSettings ottiene un'istanza di SystemSettings. quindi se si utilizza

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

   da qualche parte nel codice (si dovrebbe fare nella vostra radice composizione) del contenitore farà il lavoro per voi. Se hai molti oggetti, con più dipendenze inizierai a capire perché i contenitori IoC sono "magici";)

2. beh .. un sacco di contenitori IoC usano la parola risoluzione. significa solo "dammi un oggetto con le sue dipendenze". Il servizio e il singleton sono parole dal design laguage orientato agli oggetti. non sono specifici per i contenitori IoC. puoi google su. Penso che non ci sia un riassunto per cose come questa. lo otterrete in tempo leggendo libri, articoli e passando attraverso tutorial.

3. no. in realtà sarebbe un no. c'è uno schema per quello chiamato servicelocatore che viene considerato da alcune persone come un antipattern. se segui questo schema, tutti i tuoi oggetti hanno esattamente una dipendenza, il contenitore! e loro stessi ne escono di ciò di cui hanno bisogno.

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

   ... in quel caso il vostro contenitore fungerebbe da ServiceLocator e ogni oggetto che ha bisogno di una dipendenza avrebbe chiesto il ServiceLocator per ottenere che la dipendenza. che comprometterebbe l'intero valore di INVERSIONE del controllo e renderebbe gli oggetti dipendenti da un contenitore. iniettare ciò di cui gli oggetti hanno effettivamente bisogno, non ciò di cui hanno bisogno per individuare ciò di cui hanno effettivamente bisogno; D

   lasciare agganci indipendenti ai contenitori.e usa il tuo contenitore nella tua radice di composizione, questo è il punto in cui incollare gli oggetti e i livelli dell'applicazione insieme. qui qualcosa da leggere: http://blog.ploeh.dk/2011/07/28/CompositionRoot/