主要 C# DI/IoC 框架如何比较？

Question

Closed. This question needs to be more focused. It is not currently accepting answers.

---

想要改进这个问题？通过编辑这篇文章来更新问题，使其仅关注一个问题。

8 年前已关闭。

Answer 1

虽然这个问题的全面答案占据了我的书的数百页，但这里有一个快速比较图表，我仍在研究中：

Answer 2

我遇到了另一个性能比较（最新更新日期：2014 年 4 月 10 日）。它比较以下内容：

• AutoFac
• LightCore（网站为德语）
• LinFu
• <一个href="http://ninject.org/" rel="noreferrer">Ninject
• 娇小
• Simple Injector （所有参赛者中最快的）
• <一href="http://springframework.net/" rel="noreferrer">Spring.NET
• StructureMap
• Unity
• 温莎
• Hiro

以下是该帖子的快速摘要：

结论

Ninject 绝对是最慢的容器。

MEF、LinFu 和 Spring.NET 比 Ninject 更快，但仍然相当漂亮
慢的。 AutoFac、Catel 和 Windsor 接下来是 StructureMap，
Unity 和 LightCore。 Spring.NET 的一个缺点是，只能是
使用 XML 配置。

SimpleInjector、Hiro、Funq、Munq 和 Dynamo 提供最好的
性能，它们非常快。尝试一下！

特别简单的注射器似乎是一个不错的选择。速度非常快，效果很好
文档，还支持拦截等高级场景
和通用装饰器。

您还可以尝试使用通用服务选择器库，并希望尝试多个选项，看看哪种最适合您。

网站上有关公共服务选择器库的一些信息：

该库提供了 IoC 容器和服务的抽象
定位器。使用该库允许应用程序间接访问
的功能而不依赖于硬引用。希望是这样的
使用这个库，第三方应用程序和框架可以开始
利用 IoC/服务位置，而不将自己束缚于
具体实现。

更新

13.09.2011： Funq 和 Munq 已添加到参赛者列表中。图表也进行了更新，并且 Spring.NET 由于性能不佳而被删除。

04.11.2011: "添加了Simple Injector，表现是所有参赛者中最好的”。

Answer 3

只需阅读 Philip Mat 撰写的这篇精彩的.Net DI 容器比较博客即可。

他做了一些彻底的性能比较测试；

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

他推荐Autofac 因为它体积小、速度快且易于使用......我同意。看来 Unity 和 Ninject 是他的测试中最慢的。

Answer 4

免责声明：截至 2015 年初，功能进行了很好的比较13/generic-variance-in-di-containers/" rel="noreferrer">Jimmy Bogard，这里是一个总结：

比较容器：

• Autofac
• Ninject
• Simple Injector
• StructureMap
• Unity
• Windsor

场景是这样的：我有一个接口 IMediator，我可以在其中向多个接收者发送单个请求/响应或通知：

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

然后我创建了一组基本的请求/响应/通知：

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

我很感兴趣查看有关泛型容器支持的一些内容：

• 开放泛型的设置（轻松注册 IRequestHandler<,>）
• 开放泛型的多个注册的设置（两个或多个）
  INotificationHandlers）

通用差异的设置（注册基本 INotification 的处理程序/创建请求管道）
我的处理程序非常简单，它们只是输出到控制台：

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

• 开放泛型：是，隐式
• 多个开放泛型：是，隐式
• 泛型逆变：是，显式

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

• 开放泛型：是，隐式
• 多个开放泛型：是，隐式
• 泛型逆变：是，带有用户构建的扩展

简单注入器

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

• 开放泛型：是，显式
• 多个开放泛型：是，显式
• 通用逆变：是，隐式（更新 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<>));
    });
});

• 开放泛型：是，显式
• 多个开放泛型：是，显式
• 通用逆变：是，隐式

Unity

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

• 开放泛型：是，隐式
• 多个开放泛型：是，带有用户构建的扩展
• 泛型逆变：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());

• 开放泛型：是，隐式
• 多个开放泛型：是，隐式
• 通用逆变：是的，带有用户构建的扩展

Answer 5

实际上有大量的 IoC 框架。似乎每个程序员都会在其职业生涯的某个阶段尝试编写一个程序。也许不是为了发布它，而是为了了解其内部运作方式。

我个人更喜欢 autofac，因为它非常灵活并且具有适合我的语法（尽管我真的很讨厌所有寄存器方法都是扩展方法）。

其他一些框架：

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

Answer 6

好吧，在查看了迄今为止我发现的最佳比较后，我发现的是：

• 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

这是 2010 年 3 月进行的一项民意调查。

我感兴趣的一点是，人们对于使用过 DI/IoC 框架并且喜欢/不喜欢它的人来说，StructureMap 似乎名列前茅。

另外从民意调查来看，似乎 Castle.Windsor 和 StructureMap 似乎最受欢迎。

有趣的是， Unity 和 Spring.Net 似乎是最流行的选择，但最不受欢迎。 （我出于懒惰（以及 Microsoft 徽章/支持）而考虑使用 Unity，但现在我将更仔细地研究 Castle Windsor 和 StructureMap。）

当然，这可能（？）不适用于 2017 年发布的 Unity 2.0 。 2010 年 5 月。

希望其他人可以根据直接经验提供比较。

Answer 7

请参阅 google 代码上的 net-ioc-frameworks 比较，包括 linfu 和在我撰写本文时，spring.net 不在您的列表中。

我使用 spring.net：它有很多功能（aop、库、docu...），并且在 dotnet 和 java 世界中拥有很多使用它的经验。这些功能是模块化的，因此您不必采用所有功能。这些功能是常见问题的抽象，例如数据库抽象、日志记录抽象。然而，进行和调试 IoC 配置很困难。

从我到目前为止所读到的内容来看：如果我必须为小型或中型项目选择 h，我会使用 ninject，因为 ioc 配置已完成并且可以在 c# 中进行调试。但我还没有使用过它。对于大型模块化系统，由于抽象库，我会继续使用 spring.net。