Welche Konventionen / Idiome / Muster verwenden Sie IOC Container mit den neuen Fluent Interfaces Konfiguration

Question

Ich bin in der Mitte über einen großen Bestand an Code zu Castle Trunk bewegter, die für die Konfiguration des Behälters die neue Fluent Interface enthält. Da das Projekt eine riesige windsorConfig XML-Datei hat, die über wartbar ist, dachte ich, ich würde die Vorteile dieser neuen Funktion zu nutzen beginnen. Ich weiß, dass andere Behälter (z StructureMap 2.0) auch fließend Schnittstellen für Container-Konfiguration enthalten, so wird diese Frage nicht auf Basis Windsor.

Meine Frage ist, was Konventionen / Idiome / Muster werden Sie für Container Konfiguration mit dem neuen fließend Stil Schnittstellen?

Mein erster Gedanke war eine statische Methode irgendwo (z ContainerConfig.Config) zu erstellen, die alle relevanten Arten geladen werden würde, dass die App in den Behälter verwendet. Meine Sorge ist schließlich diese monolithische Funktion fast so wartbaren als XML-Konfigurationsdatei am Ende als würde (abzüglich der Winkel Steuer).

Mein zweiter Gedanke war, es zu brechen so jede abhängige Assembly, vereinbarungsgemäß die Standardkonfiguration exportiert. Ich sehe dies für Hierarchien nützlich gewesen intern von der Baugruppe verwendet. Aber für Typen verwendet extern sollte Konfiguration auch intern definiert werden?

Je mehr ich darüber nachdachte, desto mehr Fragen, die ich schien zu erhöhen. Was sind Ihre Gedanken dazu?

Answer 1

Nehmen Sie einen tieferen Blick auf StructureMap 2.5. Es bietet mehrere Funktionen dramatisch die Arbeit reduzieren die IOC-Container Bootstrap. Es bietet eine Konvention über Konfiguration Technik (siehe die Blog-Einträge unten)

Auch die folgenden aktuellen Blog-Beiträge von Jeremy Miller (Autor von StructureMap)

erstellen Sie Ihr eigenes Auto Registration Convention mit StructureMap

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

StructureMap 2.5.2 ist freigegeben

Answer 2

hatte ich ein Projekt, bei dem wir die Einheit verwendet haben, und ich sah ein Video über StructureMap und ich mochte die Registrierung Idee von Anfang an.

Also habe ich die folgende Schnittstelle:

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

Und haben Baugruppen bieten eine Standard-Konfigurator Klasse. Wir haben auch unsere Unity IoC mit einer statischen Klasse gewickelt, so dass wir IoC.Resolve<T> nennen kann, und habe ich nur noch die folgenden Funktionen dieser 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.
    }

So in der Initialisierung Form entweder das Programm oder die Website würde ich rufe Sie einfach an:

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

In der BLL gibt es eine Klasse wie folgt aus:

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

Der einzige Nachteil ist, dass alles, was Sie sind Schichten der gewählten IoC Behälter gekoppelt sind.

Aktualisieren : Da diese Antwort habe ich einen Artikel auf meinem Blog gepostet haben die Unity Wrapper .

Answer 3

Knifflige Fragen [und ich bin kein Experte IoC] aber denken Sie daran, dass jede „monolithische statische Funktion“ sollte nicht fast so beängstigend wie die Konfigurationsdatei. Sie können Ihre eigenen Konventionen für Dinge definieren, und versuchen, abstrakte Dinge nach unten. Ich benutze Ninject, aber für Windsor, ich würde es sich vorstellen würde mit der AllTypesOf Strategie machen kurze wenig Funktionen Dinge wie Register beinhalten:

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

Sie wissen nicht, über die internen Hierarchien ihre eigene Standardkonfiguration zu exportieren. Das scheint ein wenig beängstigend und umgewendet.

Answer 4

Sie könnten versuchen, den Ninject Rahmen zu untersuchen. Sehr einfach, Fluent Interface und blitzschnelle;) Keine XML-Konfiguration und die API ist ganz einfach. Sehr zu empfehlen

Ninject