Quelles conventions / idiomes / modèles utilisez-vous pour configurer les conteneurs IOC à l'aide des nouvelles interfaces Fluent

Question

Je suis en train de passer à Castle Trunk sur un gros corps de code, qui comprend la nouvelle interface fluide pour la configuration du conteneur. Étant donné que le projet contient un énorme fichier XML windsorConfig au-delà de la maintenance, j'ai pensé que je pourrais commencer à tirer parti de cette nouvelle fonctionnalité. Je sais que d’autres conteneurs (StructureMap 2.0, par exemple) contiennent également des interfaces fluides pour la configuration des conteneurs. Cette question n’est donc pas basée sur Windsor.

Ma question est la suivante: quels conventions / idiomes / modèles utilisez-vous pour la configuration du conteneur à l'aide des nouvelles interfaces de style fluent?

Ma première idée a été de créer une méthode statique quelque part (par exemple, ContainerConfig.Config) qui chargerait tous les types pertinents utilisés par l'application dans le conteneur. Mon souci est que cette fonction monolithique finisse par être presque aussi difficile à maintenir que le fichier de configuration xml (moins la taxe sur les équerres).

Ma deuxième idée était de le décomposer afin que chaque assemblage dépendant exporte par convention sa configuration par défaut. Je peux voir que cela a été utile pour les hiérarchies utilisées en interne par l’assemblée. Mais pour les types utilisés en externe, la configuration devrait-elle même être définie en interne?

Plus j'y pensais, plus il me semblait poser de questions. Quelles sont vos pensées à ce sujet?

Answer 1

Regardez de plus près StructureMap 2.5. Il offre plusieurs fonctionnalités pour réduire considérablement le travail d’amorçage du conteneur IOC. Il offre une convention sur la technique de configuration (voir les entrées de blog ci-dessous)

Voir les articles de blog récents de Jeremy Miller (auteur de StructureMap)

Créez votre propre convention d'enregistrement automatique avec StructureMap

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

Publication de StructureMap 2.5.2

Answer 2

J'avais un projet dans lequel nous utilisions Unity et j'ai regardé une vidéo sur StructureMap et j'ai aimé l'idée de l'enregistrement dès le début.

J'ai donc créé l'interface suivante:

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

Et que les assemblages offrent une classe de configurateur par défaut. Nous avons également intégré Unity IoC à l'aide d'une classe statique afin de pouvoir appeler IoC.Resolve<T>, et je viens d'ajouter les fonctions suivantes à cet emballage:

    /// <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.
    }

Donc, sous la forme d'initialisation, le programme ou le site Web que je viens d'appeler:

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

Dans le BLL, il existe une classe comme celle-ci:

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

Le seul inconvénient est que toutes vos couches sont couplées au conteneur IoC choisi.

Mise à jour : depuis cette réponse, j'ai posté sur mon blog un article contenant le Encapsuleur d'Unity .

Answer 3

Questions délicates [et je ne suis pas un expert IoC], mais gardez à l'esprit que toute & "fonction statique monolithique &"; ne devrait pas être presque aussi effrayant que le fichier de configuration. Vous pouvez définir vos propres conventions et essayer d’abstraire. J'utilise Ninject, mais pour Windsor, j'imagine que cela impliquerait de créer de courtes fonctions en utilisant des éléments tels que S'inscrire à la stratégie AllTypesOf:

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

Je ne sais pas si les hiérarchies internes exportent leur propre configuration par défaut. Cela semble un peu effrayant et inversé.

Answer 4

Vous pouvez essayer d’examiner le framework Ninject. Très simple, interface fluide et ultra-rapide;) Pas de configuration XML et l'API est assez simple. Fortement recommandé

Ninject