Como as principais estruturas C / DI / IoC se comparam? [fechadas]

Correndo o risco de entrar no território da guerra santa, quais são os pontos fortes e fracos dessas estruturas populares de DI / IoC e se poderia facilmente ser considerado o melhor? ..:

• Ninject
• Unidade
• Castle.Windsor
• Autofac
• StructureMap

Existem outras estruturas de DI / IoC para C # que não listei aqui?

No contexto do meu caso de uso, estou criando um aplicativo cliente WPF e uma infraestrutura de serviços WCF / SQL, facilidade de uso (especialmente em termos de sintaxe clara e concisa), documentação consistente, bom suporte e desempenho da comunidade são fatores importantes na minha escolha.

Atualizar:

Os recursos e as perguntas duplicadas citadas parecem estar desatualizados. Alguém com conhecimento de todas essas estruturas pode apresentar e fornecer algumas informações reais?

Sei que é provável que a maioria das opiniões sobre esse assunto seja tendenciosa, mas espero que alguém tenha estudado todas essas estruturas e tenha pelo menos uma comparação geralmente objetiva.

Estou bastante disposto a fazer minhas próprias investigações se isso não tiver sido feito antes, mas presumi que isso fosse algo que pelo menos algumas pessoas já haviam feito.

Segunda atualização:

Se você tem experiência com mais de um contêiner de DI / IoC, classifique e resuma os prós e os contras deles, obrigado. Este não é um exercício para descobrir todos os pequenos recipientes obscuros que as pessoas criaram. Estou procurando comparações entre as estruturas populares (e ativas).

Embora uma resposta abrangente a essa pergunta ocupe centenas de páginas do meu livro , aqui está um gráfico de comparação rápida em que ainda estou trabalhando:

Me deparei com outra comparação de desempenho (última atualização em 10 de abril de 2014). Ele compara o seguinte:

• AutoFac
• LightCore (o site é alemão)
• LinFu
• Ninject
• Petite
• Injetor Simples (o mais rápido de todos os participantes)
• Spring.NET
• StructureMap
• Unidade
• Windsor
• Hiro

Aqui está um rápido resumo do post:

Conclusão

Ninject é definitivamente o recipiente mais lento.

MEF, LinFu e Spring.NET são mais rápidos que o Ninject, mas ainda bem lentos. AutoFac, Catel e Windsor são os próximos, seguidos por StructureMap, Unity e LightCore. Uma desvantagem do Spring.NET é que isso só pode ser configurado com XML.

SimpleInjector, Hiro, Funq, Munq e Dynamo oferecem o melhor desempenho, eles são extremamente rápidos. Experimente!

O Injetor especialmente simples parece ser uma boa escolha. É muito rápido, possui uma boa documentação e também suporta cenários avançados como interceptação e decoradores genéricos.

Você também pode tentar usar a Common Service Selector Library e, esperançosamente, tentar várias opções e ver o que funciona melhor para você.

Algumas informações sobre o Common Service Selector Library do site:

A biblioteca fornece uma abstração sobre contêineres IoC e localizadores de serviço. O uso da biblioteca permite que um aplicativo acesse indiretamente os recursos sem depender de referências concretas. A esperança é que, usando essa biblioteca, aplicativos e estruturas de terceiros possam começar a alavancar o IoC / Service Location sem se limitar a uma implementação específica.

Atualizar

13.09.2011: Funq e Munq foram adicionados à lista de participantes. Os gráficos também foram atualizados e o Spring.NET foi removido devido ao seu baixo desempenho.

11.04.2011: "adicionado Injetor Simples , o desempenho é o melhor de todos os participantes".

Basta ler este ótimo blog de comparação de contêineres .Net DI de Philip Mat.

Ele faz alguns testes completos de comparação de desempenho;

• Autofac
• StructureMap
• Ninject
• Unidade
• Castle.Windsor
• Spring.Net

Ele recomenda o Autofac , pois é pequeno, rápido e fácil de usar ... Concordo. Parece que Unity e Ninject são os mais lentos em seus testes.

Isenção de responsabilidade: Desde o início de 2015, há uma excelente comparação dos recursos de IoC Container de Jimmy Bogard , aqui está um resumo:

Recipientes comparados:

• Autofac
• Ninject
• Injetor Simples
• StructureMap
• Unidade
• Windsor

O cenário é o seguinte: Eu tenho uma interface, IMediator, na qual posso enviar uma única solicitação / resposta ou uma notificação para vários destinatários:

public interface IMediator 
{ 
    TResponse Send<TResponse>(IRequest<TResponse> request);

    Task<TResponse> SendAsync<TResponse>(IAsyncRequest<TResponse> request);

    void Publish<TNotification>(TNotification notification)
        where TNotification : INotification;

    Task PublishAsync<TNotification>(TNotification notification)
        where TNotification : IAsyncNotification; 
}

Criei um conjunto básico de solicitações / respostas / notificações:

public class Ping : IRequest<Pong>
{
    public string Message { get; set; }
}
public class Pong
{
    public string Message { get; set; }
}
public class PingAsync : IAsyncRequest<Pong>
{
    public string Message { get; set; }
}
public class Pinged : INotification { }
public class PingedAsync : IAsyncNotification { }

Eu estava interessado em examinar algumas coisas em relação ao suporte a contêiner para genéricos:

• Configuração para genéricos abertos (registrando IRequestHandler <,> facilmente)
• Configuração para vários registros de genéricos abertos (dois ou mais INotificationHandlers)

Configuração para variação genérica (registrando manipuladores para INotification base / criando pipelines de solicitação) Meus manipuladores são bem diretos, eles apenas enviam para o console:

public class PingHandler : IRequestHandler<Ping, Pong> { /* Impl */ }
public class PingAsyncHandler : IAsyncRequestHandler<PingAsync, Pong> { /* Impl */ }

public class PingedHandler : INotificationHandler<Pinged> { /* Impl */ }
public class PingedAlsoHandler : INotificationHandler<Pinged> { /* Impl */ }
public class GenericHandler : INotificationHandler<INotification> { /* Impl */ }

public class PingedAsyncHandler : IAsyncNotificationHandler<PingedAsync> { /* Impl */ }
public class PingedAlsoAsyncHandler : IAsyncNotificationHandler<PingedAsync> { /* Impl */ }

Autofac

var builder = new ContainerBuilder();
builder.RegisterSource(new ContravariantRegistrationSource());
builder.RegisterAssemblyTypes(typeof (IMediator).Assembly).AsImplementedInterfaces();
builder.RegisterAssemblyTypes(typeof (Ping).Assembly).AsImplementedInterfaces();

• Genéricos abertos: sim, implicitamente
• Vários genéricos abertos: sim, implicitamente
• Contravariância genérica: sim, explicitamente

Ninject

var kernel = new StandardKernel();
kernel.Components.Add<IBindingResolver, ContravariantBindingResolver>();
kernel.Bind(scan => scan.FromAssemblyContaining<IMediator>()
    .SelectAllClasses()
    .BindDefaultInterface());
kernel.Bind(scan => scan.FromAssemblyContaining<Ping>()
    .SelectAllClasses()
    .BindAllInterfaces());
kernel.Bind<TextWriter>().ToConstant(Console.Out);

• Genéricos abertos: sim, implicitamente
• Vários genéricos abertos: sim, implicitamente
• Contravariância genérica: sim, com extensões criadas pelo usuário

Injetor Simples

var container = new Container();
var assemblies = GetAssemblies().ToArray();
container.Register<IMediator, Mediator>();
container.Register(typeof(IRequestHandler<,>), assemblies);
container.Register(typeof(IAsyncRequestHandler<,>), assemblies);
container.RegisterCollection(typeof(INotificationHandler<>), assemblies);
container.RegisterCollection(typeof(IAsyncNotificationHandler<>), assemblies);

• Genéricos abertos: sim, explicitamente
• Vários genéricos abertos: sim, explicitamente
• Contravariância genérica: sim, implicitamente (com atualização 3.0)

StructureMap

var container = new Container(cfg =>
{
    cfg.Scan(scanner =>
    {
        scanner.AssemblyContainingType<Ping>();
        scanner.AssemblyContainingType<IMediator>();
        scanner.WithDefaultConventions();
        scanner.AddAllTypesOf(typeof(IRequestHandler<,>));
        scanner.AddAllTypesOf(typeof(IAsyncRequestHandler<,>));
        scanner.AddAllTypesOf(typeof(INotificationHandler<>));
        scanner.AddAllTypesOf(typeof(IAsyncNotificationHandler<>));
    });
});

• Genéricos abertos: sim, explicitamente
• Vários genéricos abertos: sim, explicitamente
• Contravariância genérica: sim, implicitamente

Unidade

container.RegisterTypes(AllClasses.FromAssemblies(typeof(Ping).Assembly),
   WithMappings.FromAllInterfaces,
   GetName,
   GetLifetimeManager);

/* later down */

static bool IsNotificationHandler(Type type)
{
    return type.GetInterfaces().Any(x => x.IsGenericType && (x.GetGenericTypeDefinition() == typeof(INotificationHandler<>) || x.GetGenericTypeDefinition() == typeof(IAsyncNotificationHandler<>)));
}

static LifetimeManager GetLifetimeManager(Type type)
{
    return IsNotificationHandler(type) ? new ContainerControlledLifetimeManager() : null;
}

static string GetName(Type type)
{
    return IsNotificationHandler(type) ? string.Format("HandlerFor" + type.Name) : string.Empty;
}

• Genéricos abertos: sim, implicitamente
• Vários genéricos abertos: sim, com extensão criada pelo usuário
• Contravariância genérica: derp

Windsor

var container = new WindsorContainer();
container.Register(Classes.FromAssemblyContaining<IMediator>().Pick().WithServiceAllInterfaces());
container.Register(Classes.FromAssemblyContaining<Ping>().Pick().WithServiceAllInterfaces());
container.Kernel.AddHandlersFilter(new ContravariantFilter());

• Genéricos abertos: sim, implicitamente
• Vários genéricos abertos: sim, implicitamente
• Contravariância genérica: sim, com extensão criada pelo usuário

Na verdade, existem toneladas de estruturas de IoC. Parece que todo programador tenta escrever um em algum momento de sua carreira. Talvez não para publicá-lo, mas para aprender o funcionamento interno.

Pessoalmente, prefiro o autofac, pois ele é bastante flexível e possui uma sintaxe que combina comigo (embora eu realmente odeie que todos os métodos de registro sejam métodos de extensão).

Algumas outras estruturas:

• https://simpleinjector.org/
• http://microioc.codeplex.com/
• http://munq.codeplex.com/
• http://funq.codeplex.com/

Bem, depois de procurar a melhor comparação que encontrei até agora, é:

• http://www.sturmnet.org/blog/2010/03/04/poll-ioc-containers-for-net

• http://www.sturmnet.org/blog/2010/03/04/poll-results-ioc-containers-for-net

Foi uma pesquisa realizada em março de 2010.

Um ponto de interesse para mim é que as pessoas que usaram um DI / IoC Framework e gostaram / não gostaram, o StructureMap parece estar no topo.

Também da pesquisa, parece que Castle.Windsor e StructureMap parecem ser os mais favorecidos.

Curiosamente, Unity e Spring.Net parecem ser as opções populares que geralmente não são apreciadas. (Eu estava pensando em Unity por preguiça (e crachá / suporte da Microsoft), mas examinarei mais de perto o Castle Windsor e o StructureMap agora.)

É claro que isso provavelmente (?) Não se aplica ao Unity 2.0, lançado em maio de 2010.

Espero que alguém possa fornecer uma comparação com base na experiência direta.

Veja uma comparação dos frameworks net-ioc-framework no código do Google, incluindo linfu e spring.net, que não estão na sua lista enquanto escrevo este texto.

Eu trabalhei com o spring.net: ele tem muitos recursos (aop, bibliotecas, docu, ...) e há muita experiência com ele no dotnet e no mundo java. Os recursos são modularizados para que você não precise usar todos os recursos. Os recursos são abstrações de problemas comuns, como banco de dados e abstração, registro e abstração. no entanto, é difícil fazer e depurar a configuração de IoC.

Pelo que li até agora: Se eu tivesse que escolher um projeto pequeno ou médio, usaria o ninject, pois a configuração do ioc é feita e depurável em c #. Mas ainda não trabalhei com isso. para sistemas modulares grandes, eu ficaria com o spring.net por causa das bibliotecas de abstração.