冒着涉足圣战领域的风险，这些热门DI/IoC框架的优缺点是什么？是否可以轻易地被认为是最好的？..:
还有其他未在此处列出的用于C#的DI/IoC框架吗？
在我的使用情况下，我正在构建一个客户端WPF应用程序和一个WCF/SQL服务基础设施，在选择中易用性（特别是在清晰简洁的语法方面）、一致的文档、良好的社区支持和性能都是重要因素。
引用的资源和重复问题似乎已过时，是否可以有知道所有这些框架的人提供一些真实的见解？
我意识到这个主题上的大多数意见可能是有偏见的，但我希望有人花时间研究所有这些框架，并至少有一个普遍客观的比较。
如果以前没有进行过这样的研究，我很愿意进行自己的调查，但我认为这是一些人已经做过的事情。
如果您具有使用多个DI/IoC容器的经验，请排名并总结这些容器的优缺点，谢谢。这不是发现所有人都制作的鲜为人知的小容器的练习，我正在寻找流行（且活跃）框架之间的比较。
虽然对这个问题的全面回答需要数百页的我的书，但以下是我正在制作的一个快速比较表：
我发现了另一个性能 比较（最新更新于2014年4月10日）。它比较了以下内容：
这里是帖子的简要概述：
结论 Ninject绝对是最慢的容器。 MEF、LinFu和Spring.NET比Ninject快，但仍然很慢。AutoFac、Catel和Windsor排名第二，接下来是StructureMap、Unity和LightCore。Spring.NET的一个缺点是只能用XML配置。 SimpleInjector、Hiro、Funq、Munq和Dynamo提供了最佳性能，它们非常快。试试它们吧！ 特别是Simple Injector似乎是一个不错的选择。它非常快，有良好的文档，并且还支持像拦截和通用装饰器这样的高级场景。04.11.2011: "添加了Simple Injector，性能是所有竞争者中最好的"。
我刚读了Philip Mat关于.Net DI容器比较的博客，链接在这里。
他在测试中对以下几个工具进行了彻底的性能比较：
免责声明：截至2015年初，Jimmy Bogard对IoC容器的功能进行了很好的比较，以下是摘要：
比较的容器：
场景是这样的：我有一个接口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 { }
我对容器支持泛型的几个方面感兴趣：
泛型差异的设置（为基础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);
Simple Injector
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);
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;
}
温莎（Windsor）
var container = new WindsorContainer();
container.Register(Classes.FromAssemblyContaining<IMediator>().Pick().WithServiceAllInterfaces());
container.Register(Classes.FromAssemblyContaining<Ping>().Pick().WithServiceAllInterfaces());
container.Kernel.AddHandlersFilter(new ContravariantFilter());
实际上有大量的IoC框架。似乎每个程序员都会在职业生涯中某个时刻尝试编写一个。也许不是为了发布，而是为了学习内部工作原理。
我个人喜欢autofac，因为它非常灵活，并且具有适合我的语法（尽管我真的很讨厌所有register方法都是扩展方法）。
其他一些框架：
RegisterControllers()），因此我认为围绕这种情况进行设计是值得的。（这是5年前设计的。） - Nicholas Blumhardt好的，经过搜索，我发现到目前为止最好的比较是：
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似乎是最不受欢迎的选项。（出于懒惰（和微软的支持），我曾考虑过Unity，但现在我会更仔细地研究Castle Windsor和StructureMap。）
当然，这可能（？）并不适用于于2010年5月发布的Unity 2.0。
希望其他人可以提供基于直接经验的比较。
对于google code上的net-ioc-frameworks，包括linfu和spring.net在内，与本文同时书写时未列入您的列表中，请参考进行比较。
我曾经使用过spring.net：它有许多功能（aop、库、文档等），并且在dotnet和java-world中有很多使用经验。这些功能是模块化的，因此您不需要使用全部功能。这些功能是常见问题的抽象，如数据库抽象、日志记录抽象。但是，编写和调试IoC配置非常困难。
根据我目前的了解：如果我必须选择一个小型或中型项目，我会使用ninject，因为ioc配置可以在c#中完成并进行调试。但我还没有使用过它。对于大型模块化系统，我会继续使用spring.net，因为它具有抽象化库。