Quali convenzioni / modi di dire / schemi stai usando configurando i contenitori IOC usando le nuove interfacce fluide

Question

Mi sto spostando su un grande corpus di codice su Castle Trunk, che include la nuova interfaccia fluida per la configurazione del container. Dal momento che il progetto ha un enorme file xml windsorConfig che è al di là della manutenibilità, ho pensato di iniziare a sfruttare questa nuova funzionalità. Conosco altri container (ad esempio StructureMap 2.0) che contengono anche interfacce fluide per la configurazione dei container, quindi questa domanda non si basa su Windsor.

La mia domanda è: quali convenzioni / modi di dire / schemi stai usando per la configurazione del container usando le nuove interfacce di stile fluente?

Il mio primo pensiero è stato quello di creare un metodo statico da qualche parte (ad esempio ContainerConfig.Config) che avrebbe caricato tutti i tipi pertinenti che l'app utilizza nel contenitore. La mia preoccupazione è che questa funzione monolitica finisca per essere quasi non mantenibile come il file di configurazione XML (meno la tassa sulla parentesi angolare).

Il mio secondo pensiero è stato quello di scomporlo in modo che ogni assembly dipendente, per convenzione, esporti la sua configurazione predefinita. Vedo che questo è stato utile per le gerarchie utilizzate internamente dall'assembly. Ma per i tipi usati esternamente dovrebbe esserci una configurazione definita internamente?

Più ci pensavo, più domande mi sembrava di sollevare. Cosa ne pensi?

Answer 1

Dai un'occhiata più approfondita a StructureMap 2.5. Offre diverse funzionalità per ridurre drasticamente il lavoro di bootstrap del contenitore IOC. Offre una convenzione sulla tecnica di configurazione (vedere le voci del blog in basso)

Vedi i seguenti post recenti del blog di Jeremy Miller (autore di StructureMap)

Crea la tua convenzione di registrazione automatica con StructureMap

        // Example from the blog post above
        var container = new Container(registry =>
        {
            registry.Scan(x =>
            {
                x.TheCallingAssembly();
                x.With<DefaultConventionScanner>();
            });
        });

Rilasciata StructureMap 2.5.2

Answer 2

Avevo un progetto in cui stavamo usando Unity e ho guardato un video su StructureMap e mi è piaciuta l'idea di registrazione fin dall'inizio.

Quindi ho creato la seguente interfaccia:

/// <summary>
/// An interface which must be implemented to create a configurator class for the UnityContainer.
/// </summary>
public interface IUnityContainerConfigurator
{
    /// <summary>
    /// This method will be called to actually configure the container.
    /// </summary>
    /// <param name="destination">The container to configure.</param>
    void Configure(IUnityContainer destination);
}

E gli assembly offrono una classe Configurator predefinita. Abbiamo anche spostato il nostro Unity IoC usando una classe statica in modo da poter chiamare IoC.Resolve<T> e ho appena aggiunto le seguenti funzioni a quel wrapper:

    /// <summary>
    /// Configure the IoC
    /// </summary>
    public static class Configure
    {
        /// <summary>
        /// Configure the IoC using by calling the supplied configurator.
        /// </summary>
        /// <typeparam name="TConfigurator">The configurator to use</typeparam>
        public static void From<TConfigurator>() where TConfigurator : IUnityContainerConfigurator, new()
        {
            From(new TConfigurator());
        }
        /// <summary>
        /// Configure the IoC using by calling the supplied configurator.
        /// </summary>
        /// <param name="configurationInterface">The configurator instance to use</param>
        public static void From(IUnityContainerConfigurator configurationInterface)
        {
            configurationInterface.Configure(instance);
        }
        // other configuration.
    }

Quindi nel modulo di inizializzazione o il programma o il sito Web che chiamerei semplicemente:

IoC.Configure.From<BLL.DefaultMapping>();

Nel BLL esiste una classe come questa:

public class DefaultMapping:IUnityContainerConfigurator
{
    public void Configure(IUnityContainer destination)
    {
        destionation.RegisterType<IRepository, SQLRepository>();
        // and more..
    }
}

L'unico aspetto negativo è che tutti i livelli sono accoppiati al contenitore IoC scelto.

Aggiorna : da questa risposta ho pubblicato un articolo sul mio blog contenente Unity wrapper .

Answer 3

Domande difficili [e non sono un esperto di IoC] ma tieni presente che qualsiasi " funzione statica monolitica " non dovrebbe essere quasi spaventoso come il file di configurazione. Puoi definire le tue convenzioni per le cose e provare a sottrarre le cose. Uso Ninject, ma per Windsor, immagino che comporterebbe la realizzazione di piccole funzioni usando cose come Register with the AllTypesOf strategy:

kernel.Register(AllTypesOf<ISomethingProvider>.
    FromAssembly(Assembly.Load("SomeAssembly")));

Non conosco le gerarchie interne che esportano la propria configurazione predefinita. Sembra un po 'spaventoso e invertito.

Answer 4

Potresti provare a esaminare il framework Ninject. Interfaccia molto semplice, fluida e velocissima;) Nessuna configurazione XML e l'API è abbastanza semplice. Altamente raccomandato

Ninject