Come utilizzare Autofac in un progetto di libreria di classi?

Question

Ho la seguente implementazione:

private INewsRepository newsRepository; 

public NewsService(INewsRepository newsRepository) 
{ 
    this.newsRepository = newsRepository; 
} 

Questo servizio è in un progetto separato rispetto a quello del mio progetto web. Dove e come specificare l'iniezione di dipendenza? Dovrei ancora metterlo nel mio file global.asax? Cosa succede se questo servizio viene utilizzato anche nelle altre mie app?

Answer 1

si dovrebbe fare riferimento solo il contenitore dal principale dell'applicazione (global.asax) .Questo è noto come Register Resolve Release pattern.

L'uso corretto di Iniezione costruttore assicura che è possibile riutilizzare la classe NewsService da altre applicazioni senza richiedere che tali altre applicazioni utilizzino un determinato contenitore DI (o alcuno affatto).

Questo è un buon inizio allo designing the service in a DI Friendly manner, pur mantenendo il contenitore agnostico.

Answer 2

Suppongo che dipenderà dall'intenzione di utilizzare lo stesso assembly in più applicazioni host. L'assemblaggio richiede davvero riferimenti ad AutoFac? Vorrei raccomandare contro questo, come se le tue esigenze cambiassero più tardi avresti un carico di riferimenti inutili. La tua applicazione host dovrebbe controllare come assemblare le parti modulari, quindi lascerei la configurazione sul tuo host (in questo caso la tua applicazione Web. Se vuoi esercitare un controllo sulla registrazione, puoi creare un tipo che gestisca la registrazione per te , ma come ho detto prima, l'assembly è essenzialmente legato all'utilizzo di all'autofac esempio:

public static class NewsRegistration() 
{ 
    public static void RegisterTypes(ContainerBuilder builder) 
    { 
     // Register your specific types here. 
     builder.RegisterType<NewsService>().As<INewsService>(); 
    } 
} 

in questo modo si potrebbe facilmente chiamare:

var builder = new ContainerBuilder(); 
// Register common types here? 

NewsRegistration.RegisterTypes(builder); 

var container = builder.Build(); 

Answer 3

[TestClass] 
public class LogTest 
{ 
    /// <summary> 
    /// Test project: autofac impl. 
    /// </summary> 
    private readonly ContainerBuilder _builder; 
    private readonly IContainer _container; 

    /// <summary> 
    /// Initializes a new instance of the <see cref="LogTest" /> class. 
    /// </summary> 
    public LogTest() 
    { 
     // 
     // Read autofac setup from the project we are testing 
     // 
     _builder = new ContainerBuilder(); 
     Register.RegisterTypes(_builder); 
     _container = _builder.Build(); 

     loggingService = _container.Resolve<ILoggingService>(new NamedParameter("theType", this)); 
    } 

    [TestMethod] 
    public void DebugMsgNoExectption() 
    { 
     var a = _container.Resolve<IHurraService>(); 
     var b = a.ItsMyBirthday(); 

public class HurraService : IHurraService 
{ 
    private IHurraClass _hurra; 

    /// <summary> 
    /// Initializes a new instance of the <see cref="HurraService" /> class. 
    /// </summary> 
    public HurraService(IHurraClass hurra) 
    { 
     _hurra = hurra; 
    } 

    /// <summary> 
    /// It my birthday. 
    /// </summary> 
    public string ItsMyBirthday() 
    { 
     return _hurra.Hurra(); 
    } 
} 

public static class Register 
{ 
    public static void RegisterTypes(ContainerBuilder builder) 
    { 
     builder.RegisterType<LoggingService>().As<ILoggingService>(); 
     builder.RegisterType<HurraService>().As<IHurraService>(); 
     builder.RegisterType<HurraClass>().As<IHurraClass>(); 
    } 
} 

All'interno della libreria di classi ho creato la classe "Register". Qui la configurazione di Autofac è fatta. Nel mio progetto di test ho letto questo file (Register.RegisterTypes) e ho avviato _container.

Ora ho accesso a Risolvere tutte le chicche all'interno del progetto che sto testando.