Que convenções / Expressões / padrões que você está usando a configuração COI Containers usando o novo Fluent Interfaces

Question

Eu estou no meio de se mover ao longo de um grande corpo de código para Trunk Castelo que inclui a nova interface fluente para a configuração do recipiente. Desde que o projeto tem um enorme arquivo xml windsorConfig que está além de fácil manutenção, eu pensei que eu iria começar a tirar proveito desse novo recurso. Sei outros recipientes (por exemplo StructureMap 2.0) também contêm interfaces fluentes para a configuração do recipiente, assim que esta questão não é baseado em torno de Windsor.

A minha pergunta é o que convenções / expressões idiomáticas / padrões que você está usando para a configuração do recipiente utilizando as novas interfaces de estilo fluente?

O meu primeiro pensamento foi criar um método estático em algum lugar (por exemplo ContainerConfig.Config) que carregar todos os tipos relevantes que os usos de aplicativos para o recipiente. Minha preocupação é, eventualmente, esta função monolítica iria acabar por ser quase tão insustentável que o arquivo xml de configuração (menos o imposto cantoneira).

Meu segundo pensamento foi para quebrá-lo para baixo para que cada conjunto dependente, por convenção exporta sua configuração padrão. Eu posso ver este sido útil para hierarquias usados ??internamente pela assembleia. Mas para tipos usados ??externamente deve há configuração ainda ser definida internamente?

Quanto mais eu pensava nisso, mais perguntas que pareciam aumento. Quais são seus pensamentos sobre isso?

Answer 1

Tome um olhar mais profundo StructureMap 2.5. Ele oferece vários recursos para reduzir drasticamente o trabalho para o arranque do recipiente COI. Dispõe de uma convenção sobre a técnica de configuração (consulte as entradas do blog abaixo)

Veja as seguintes posts recentes de Jeremy Miller (autor de StructureMap)

Criar seu próprio Convenção de Registro automático com StructureMap

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

StructureMap 2.5.2 é liberado

Answer 2

Eu tinha um projeto em que estávamos usando Unidade, e eu assisti um vídeo sobre StructureMap e eu gostei da idéia de registro desde o início.

Então, eu criei a seguinte interface:

/// <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 têm montagens oferecer uma classe Configurator padrão. Nós também envolveu a nossa unidade IoC usando uma classe estática para que possamos chamar IoC.Resolve<T>, e eu acabamos de adicionar as seguintes funções para que fardos:

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

Assim, na forma de inicialização ou o programa ou o site que eu tinha acabado de chamar:

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

No BLL há uma classe como este:

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

A única desvantagem é que tudo que você está camadas são acoplados ao contêiner IoC escolhido.

Atualizar : Desde esta resposta que eu postei um artigo no meu blog que contém o Unidade invólucro .

Answer 3

perguntas difíceis [e eu não sou nenhum perito IoC], mas tenha em mente que qualquer "função monolítica estática" não deve ser quase tão assustador como o arquivo de configuração. Você pode definir suas próprias convenções para as coisas, e tentar coisas abstratas para baixo. Eu uso Ninject, mas para Windsor, Eu imagino que envolveria fazer funções curto pequenos usando coisas como Register com a estratégia AllTypesOf:

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

Não sei sobre as hierarquias internas exportadores sua própria configuração padrão. Isso parece um pouco assustador e invertido.

Answer 4

Você poderia tentar examinar o quadro Ninject. Muito simples, interface fluente e ultra-rápida;) Nenhuma configuração XML ea API é bastante simples. Altamente recomendado

Ninject