Comment les grands C# DI/Cio cadres de comparer?

Je suis tombé sur une autre performance de la comparaison(dernière mise à jour le 10 avril 2014). Il compare les suivantes:

• AutoFac
• LightCore (site allemand)
• LinFu
• Ninject
• Petite
• Simple Injecteur (le plus rapide de tous les candidats)
• Spring.NET
• StructureMap
• L'unité
• Windsor
• Hiro

Voici un rapide résumé du poste:

Conclusion

Ninject est certainement le plus lent du conteneur.

MEF, LinFu et Spring.NET sont plus rapides que Ninject, mais tout de même assez
lent. AutoFac, Catel et Windsor viennent ensuite, suivis par StructureMap,
L'unité et la LightCore. Un inconvénient de Spring.NET est, qui ne peut être
configuré avec XML.

SimpleInjector, Hiro, Funq, Munq et Dynamo offrir le meilleur
performance, ils sont extrêmement rapides. Leur donner un essai!

Particulièrement Simple Injecteur semble être un bon choix. Il est très rapide, a une bonne
documentation et prend également en charge les scénarios avancés comme l'interception
générique et les décorateurs.

Vous pouvez également essayer d'utiliser le Service Commun Sélecteur De Bibliothèque et espérons-le, essayez de multiples options et voir ce qui fonctionne le mieux pour vous.

Certains informtion sur les Services Communs du Sélecteur de Bibliothèque à partir du site:

La bibliothèque fournit une abstraction au-dessus du Cio de conteneurs et de service
les locators. À l'aide de la bibliothèque permet à une application d'accéder indirectement à
les capacités sans compter sur dur références. L'espoir est que
l'utilisation de cette bibliothèque, les applications tierces et les cadres peuvent commencer
à l'effet de levier du Cio/Service de Localisation, sans occuper d'eux-mêmes vers le bas pour un
de mise en œuvre spécifiques.

Mise à jour

13.09.2011: Funq et Munq ont été ajoutés à la liste des participants. Les graphiques ont été également mis à jour, et Spring.NET a été retiré en raison de ses mauvaises performances.

04.11.2011: ", a ajouté Simple Injecteur, le rendement est le meilleur de tous les candidats".

Avertissement: dès le début de 2015, il y a une bonne comparaison des Conteneur IoC caractéristiques de Jimmy Bogard, voici un résumé:

Par Rapport Conteneurs:

• Autofac
• Ninject
• Simple Injecteur
• StructureMap
• L'unité
• Windsor

Le scénario est le suivant: j'ai une interface, IMediator, dans lequel je peux envoyer une seule demande/réponse ou une notification à plusieurs destinataires:

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

J'ai ensuite créé un ensemble de base de requêtes/réponses/avis:

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 { }

Je me suis intéressé à la recherche à un certain nombre de choses avec ce qui concerne la prise en charge du conteneur pour les génériques:

• De configuration pour ouvrir les génériques (enregistrement IRequestHandler<,> facilement)
• D'installation pour les inscriptions multiples d'ouvrir les génériques (deux ou plus
  INotificationHandlers)

Le programme d'installation pour le générique de la variance (enregistrement des gestionnaires de base de INotification/création de la demande des pipelines)
Mon les gestionnaires sont assez simples, ils ont juste sortie de la 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();

• Ouvrir les génériques: oui, implicitement
• Multiples ouvrir les génériques: oui, implicitement
• Générique contravariance: oui, explicitement

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

• Ouvrir les génériques: oui, implicitement
• Multiples ouvrir les génériques: oui, implicitement
• Générique contravariance: oui, construit par l'utilisateur extensions

Simple Injecteur

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

• Ouvrir les génériques: oui, explicitement
• Multiples ouvrir les génériques: oui, explicitement
• Générique contravariance: oui, implicitement (avec mise à jour 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<>));
    });
});

• Ouvrir les génériques: oui, explicitement
• Multiples ouvrir les génériques: oui, explicitement
• Générique contravariance: oui, implicitement

L'unité

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

• Ouvrir les génériques: oui, implicitement
• Multiples ouvrir les génériques: oui, construit par l'utilisateur de l'extension
• Générique contravariance: 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());

• Ouvrir les génériques: oui, implicitement
• Multiples ouvrir les génériques: oui, implicitement
• Générique contravariance: oui, construit par l'utilisateur de l'extension

Bien, après avoir regardé autour, la meilleure comparaison que j'ai trouvé pour l'instant est:

• 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

C'était un sondage réalisé en Mars 2010.

Un point d'intérêt pour moi, c'est que les gens qui ont utilisé une DI/Cio Cadre et aimé/détesté ça, StructureMap semble prendre le dessus.

Également de ce sondage, il semble que Château.Windsor et StructureMap semblent être les plus fortement favorisée.

Il est intéressant de noter, L'unité et Spring.Net semblent être les options populaires qui sont le plus généralement détesté. (J'envisage de l'Unité de la paresse (et Microsoft insigne/support), mais je vais y regarder de plus près, au Château de Windsor et de StructureMap maintenant.)

Bien sûr, cela sans doute (?) ne s'applique pas à l'Unité 2.0 qui a été publié en Mai 2010.

J'espère que quelqu'un d'autre peut fournir une comparaison basée sur l'expérience directe.