从 NLite 到 Vane.Container 1.0:压箱十六年的自研 DI 容器开源

本文背景很简单:2010 年前后,我在研究 DI 容器内部实现时写过一个 Mini 容器(当年 NLite 组件库里的 DI 部分),也在博客园留过一组学习笔记。NLite 当年曾发布在 CodePlex 上;CodePlex 被微软关闭后迁到 GitHub,后来账号密码遗失,旧仓库再也找不回来。发布之后受工作原因影响,这套代码一直没有再更新,也没有对外发 NuGet 包,只在内部随项目迭代。

这一轮做的,是把积累多年的 Vane 系列基础设施陆续整理开源、发布 NuGet 包。前段已经发布的有:MiniLog(零依赖高性能日志框架,计划后续迁移并统一发布为 Vane.Log(暂未发布))、Vane.Dispatch(容器无关的服务分发引擎,对应之前NLite 中的Ndf),以及以老东家名义发出的历史 NuGet 包 Acl.Excel(旧版仅支持 xlsx);后续表格库将以 Vane.Sheet(暂未发布)重新发布,把 xlsx / xls / xlsb / csv / ndjson 五类表格数据收进同一套微内核接口;流式读写、有界缓存,文件规模只受可用存储约束,与内存解耦。其余库也都会统一以 Vane. 前缀命名发布。本篇聚焦系列里的容器:这个小容器随 Vane 系列一起打磨至今,今天以 Vane.Container 1.0.0 的身份重新发布,基础能力和当年那版一脉相承,这一版重点补上了快照模式,让它能堂堂正正地走进 BS(Browser/Server)环境,并在 API 形状上与 Microsoft.Extensions.DependencyInjection(下文简称 MS-DI)对齐。

一、这版是什么

Vane.Container 是一个轻量、高性能的 .NET IoC 容器:

  • 核心程序集只依赖 BCL ,没有任何外部 PackageReference;
  • 公开 API 的动词形状对齐 MS-DI(Add* / Get* / Build*),但类型全部独立命名;
  • 同时覆盖 BS 与 CS 两类场景:冻结快照给 Web/Worker/批处理,动态容器给 WinForm/WPF/MAUI/插件宿主;
  • 目标框架 net8.0 与 net10.0,附带编译期注册源生成器(注册期无反射;解析期仍有动态生成,见第七节边界)。
bash 复制代码
dotnet add package Vane.Container              # 核心容器
dotnet add package Vane.Container.Prism       # Prism 8 适配(net8.0)
dotnet add package Vane.Container.AspNetCore  # ASP.NET Core 接线(net10.0)

源码与示例都在 Gitee:gitee.com/netcasewqs/Vane.Container。

二、延续下来的基础能力

当年笔记里讲过的核心用法,这一版基本都还在,只是类型名按现在的微内核口径重新收敛过了一遍。

1. 三种生命周期

Singleton / Transient / Scoped,语义与主流容器一致:

  • Singleton:root 容器持有唯一实例,随 root 释放;
  • Scoped :单个 CreateScope() 作用域内复用,跨作用域隔离,随 scope 释放;
  • Transient:每次解析新建,容器只追踪 root 与 scope 内的可释放实例。

作用域支持嵌套,容器 Dispose 时单例与 Scoped 都按逆创建序释放,保证依赖先于被依赖者释放。

与旧版的对照:当年 Mini 容器有一类按线程持有实例 的线程生命周期;这一版不再按线程划分,改由作用域(scope) 承接这层边界------实例共享范围从"同一线程"变为"同一个 CreateScope()",跨作用域隔离,释放责任也归该 scope。线程维度的生命周期概念随之移除。

2. 构造、字段、属性、方法注入

构造函数注入默认生效,无需贴特性;需要显式指定构造函数时在构造器上标 [Inject]。字段、属性、方法注入沿用当年的标注思路:

csharp 复制代码
using Vane.Container;
using Vane.Container.Annotations;

public sealed class HostWithMember
{
    [Inject] public IClock Clock { get; set; }
    [Inject] private IGreeter _greeter = null!;

    public string Describe() => _greeter.Greet() + " at " + Clock.Now;
}

3. 集合与插件注入、元数据视图

当年笔记里的「InjectMany 式多组件注入」依然对应现在的 [InjectMany] 与集合解析。同一个契约注册多次,单值解析取最后一条,集合解析按注册顺序物化。支持的集合形态比 MS-DI 宽不少:

T[]、IEnumerable<T>、List<T>、IList<T>、ICollection<T>、IReadOnlyList<T>、IReadOnlyCollection<T>、ImmutableArray<T>,外加 Lazy<T> 与带元数据的 Lazy<T, TMetadata> 视图。

4. Lazy 注入

和当年一样,成员或构造参数包一层 Lazy<T> 即延迟到首次访问才构造;组件模型下还能拿到 Lazy<T, TMetadata> 元数据视图,做插件目录式的查询。

5. Keyed 服务、开放泛型

按 Key 标记服务 ID 的能力从当年那版保留了下来:同一个契约用一把"钥匙"区分不同实现。变化在于键的类型 ------旧版只支持字符串,这一版放宽为任意 object(参与相等比较与哈希,null 等价于非 keyed 注册),与新版 MS-DI 的 keyed 服务对齐:字符串、枚举、值类型等可做相等比较的对象都能当键。

csharp 复制代码
services.AddKeyedSingleton<INotifier, EmailNotifier>("email");
services.AddKeyedSingleton<INotifier, SmsNotifier>("sms");

var email = container.GetRequiredKeyedService<INotifier>("email");

带键注册用 AddKeyedSingleton / AddKeyedScoped / AddKeyedTransient,解析用 GetRequiredKeyedService<T>(key);开放泛型走 Type 重载:

csharp 复制代码
services.AddTransient(typeof(IRepository<>), typeof(Repository<>));

6. AOP 拦截与装饰器

AOP 这一版收窄为接口代理 :底层用 BCL 的 DispatchProxy,只接受接口契约,非接口(密封类、具体类)会抛 NotSupportedException;不再像旧版那样支持全面的代理形态。代理的每次方法调用都要经过拦截器链分发,有额外开销,建议只对非热路径契约开启。

作为补充,这一版新增了装饰器支持 。横切关注点(日志、校验、缓存、权限等)想做的事,基本都可以写成装饰器:它就是普通的构造函数包装,解析期由编译期绑定的工厂直接构造一个包装实例,没有代理转发这一层,更轻量、热路径性能更高 。包装按注册顺序进行,先注册的在最内层,整体形成 Decorator(AopProxy(Real)) 的外层套内层结构:

csharp 复制代码
services.AddSingleton<ICalc, Calc>();
services.AddDecorator<ICalc, DoublingCalc>();   // 装饰器:普通包装,轻量、高性能
services.Intercept<ICalc, TraceInterceptor>();   // AOP:接口代理,走拦截器链分发

日常优先用装饰器实现横切逻辑;只有确实需要运行期按规则叠加拦截、或拦截逻辑不便写成包装类时,再用 AOP 接口代理。

7. MEF 式组件模型

类型级与字段、属性、方法级导出,方法导出按签名推断 Func / Action 委托;IComponentQuery 承载查询与手动组合。需要注意:组件模型是动态容器独占能力 ,冻结快照上调用组件查询会抛 InvalidOperationException,而不是返回空集合------避免出现「方法在、结果永远为空」的假可用面。这些特性和用法旧版基本一致。

三、本次重点:新增快照模式,对齐 MS-DI,走进 BS 环境

为什么要加快照

当年那版 Mini 容器是按桌面/插件场景设计的:容器活到进程结束,运行期还能增删注册。但 MS-DI 走的是另一条路------IServiceCollection 收集 → BuildServiceProvider() 构建 → 之后只能解析,构建即冻结。这不是实现选择,而是 BS 场景的天然形态:进程启动时装好容器,之后按请求开 scope,请求结束释放,生命周期与进程同寿,运行期根本不需要改注册表。

过去我自己写 Web 后端时,这就成了一个别扭点:动态容器的灵活性在 BS 场景用不上,却要背着可变注册表的成本。这一版把两种形态用同一个引擎统一起来,按场景选入口:

形态 入口 注册表 适用场景
快照(BS) BuildServiceProvider() / BuildMiniContainer() 构造即冻结,Register / Unregister 抛 InvalidOperationException(ContainerFrozen) ASP.NET Core、Worker、批处理;与 MS-DI 同场景,冻结后解析路径最短
动态(CS / 桌面) new MiniContainer(registry) 容器即注册表,运行期可增删注册 WinForm、WPF、MAUI、控制台插件宿主、任何需要运行期改注册的场合

快照长什么样

csharp 复制代码
using Vane.Container;

var services = new ContainerBuilder();
services.AddSingleton<IClock, SystemClock>();
services.AddTransient<IGreeter, ChineseGreeter>();

// 入口一:MS-DI 兼容视图,编译期看不到写方法
IServiceLocator locator = services.BuildServiceProvider();

// 入口二:完整能力,零强转
MiniContainer container = services.BuildMiniContainer();

var greeter = container.GetRequiredService<IGreeter>();

using var scope = container.CreateScope();
var session = scope.ServiceLocator.GetRequiredService<ISession>();

BuildServiceProvider() 返回 IServiceLocator(MS-DI 兼容解析视图,本身继承 System.IServiceProvider),静态类型上看不到 Register / Unregister / CreateInstance / IsRegistered 与组件模型;BuildMiniContainer() 直接给完整容器类型。两者产出的是同一个冻结容器,区别只在编译期可见的能力面。

动态形态的关键语义也保留了下来:写入只发布新快照,后续解析按新规则走;已经注入出去的实例不会被替换,也不会被释放。所以热替换是安全的,不会把已经交给界面的对象悄悄换掉。

与 MS-DI 的关系:形状对齐,类型独立

迁移过来的人最关心这一条。结论是三句话:

  1. 动词对齐 :AddSingleton / AddScoped / AddTransient、AddKeyedSingleton / AddKeyedScoped / AddKeyedTransient、GetService / GetRequiredService / GetRequiredKeyedService、BuildServiceProvider 写法与 MS-DI 一致,用过 ASP.NET Core DI 会感到熟悉。
  2. 类型独立 :契约是 IServiceRegistry / IMiniContainer / IContainerScope / IServiceLocator,容器是 MiniContainer,注册表是 ContainerBuilder,描述符是 ServiceRegistration,生命周期枚举是 LifestyleType。它不定义与 MS-DI 同名的 IServiceCollection / IServiceScope / ServiceLifetime,也不引用 MS-DI 包,因此同时 using 两个命名空间不会产生 CS0104 类型歧义。
  3. 类型不可互换 :形状对齐而非二进制兼容,ContainerBuilder 不能直接传给要求 MS-DI IServiceCollection 的 API,需要在边界处桥接。唯一的互通点是 BCL 的 System.IServiceProvider。

接进 ASP.NET Core

BS 场景的接线由独立适配包 Vane.Container.AspNetCore 承担:VaneServiceProviderFactory 实现 IServiceProviderFactory<ContainerBuilder>,把 ServiceDescriptor(实现类型、实例、工厂、keyed 四种形态)逐条翻译进冻结容器,不改写调用方的 IServiceCollection;UseVaneContainer() 是宿主接入点。完整接线示例、翻译规则与请求作用域边界见第五节「ASP.NET Core」小节。

四、事件钩子为性能做了简化

当年笔记里有一组监听器:启动监听器、停止监听器、初始化监听器、释放监听器、AOP 监听器,钩子种类不少。这一版为了热路径性能,把事件钩子收敛成了两个观察者接口:

  • IInstanceLifetimeObserver:OnCreated(实例首次进入解析管线时触发一次)、OnDestroying(容器按逆创建序释放实例之前触发,早于 IDisposable.Dispose);
  • IReinjectionObserver:组件依赖被运行期重新赋值后回调,参数是本次实际重新赋值的成员名。
csharp 复制代码
public sealed class LifecycleTracker : IInstanceLifetimeObserver
{
    public void OnCreated(object instance) => Console.WriteLine($"created: {instance.GetType().Name}");
    public void OnDestroying(object instance) => Console.WriteLine($"destroying: {instance.GetType().Name}");
}

services.AddInstanceLifetimeObserver(new LifecycleTracker());

两个设计上的取舍值得说清楚:

  • 观察者集合在构建期冻结:容器建好之后再登记不生效,避免运行期为通知派发反复加锁。
  • 可以整体关闭派发 :TrackInstanceLifetime(false) 之后,已注册的观察者收不到回调,解析管线在构建期就跳过该部件,热路径零成本 ;它只关通知,不影响实例自身的 Dispose。默认开启。

AOP 保留为注册表直接持有的内置部件,但收窄为接口代理(见上一节);横切逻辑优先用装饰器。两类部件在构建期冻结成固定顺序的解析管线,对外只暴露 Intercept / AddDecorator 注册扩展,不再提供「把自定义钩子挂进解析管线」的开放扩展点。这也是微内核口径下反复出现的收敛方向:少一条语义路径,就少一类分叉出来、难排查的行为差异。

五、周边整合:MiniLog 日志、Vane.Dispatch 分发器、Prism 与 ASP.NET Core 适配

容器自身刻意保持微内核,不内置日志、总线等设施;周边能力以普通契约的方式接进来。下面四个例子都来自仓库示例工程:日志框架 MiniLog(包 MiniLog,计划后续迁移为 Vane.Log,暂未发布)、服务分发器 Vane.Dispatch(包 Vane.Dispatch),以及两个宿主适配包------面向 Prism 桌面 MVVM 的 Vane.Container.Prism,和面向 ASP.NET Core 的 Vane.Container.AspNetCore。

1. MiniLog:ILog 只是一个普通契约(1.0 GA 发布博客)

容器对日志没有任何专用扩展点。MiniLog 启动时一句 Initialize 读配置文件,之后把 ILog 当成普通单例契约注册进容器即可,消费方只依赖 ILog,不知道日志框架的存在:

csharp 复制代码
using MiniLog;
using Vane.Container;

LogManager.Initialize("log.config.xml");   // 相对路径基于程序基目录

var builder = new ContainerBuilder();
builder.AddSingleton<ILog>(_ => LogManager.GetLogger("Vane.Samples.Billing"));
builder.AddSingleton<IPaymentGateway, SandboxPaymentGateway>();
builder.AddSingleton<BillingService>();

using var container = new MiniContainer(builder);
BillingService billing = container.GetRequiredService<BillingService>();

几点口径:

  • ILog 注册为 Singleton:日志器无请求态,注册成 Transient 每次注入都多构造一层;
  • 日志器名是配置锚点,GetLogger("...") 只精确匹配同名 <Logger> 节点,未命中回退 Root,名不符不会报错;
  • 异步 appender 走有界队列,Shutdown() 要放在容器释放之后调,避免缓冲区尾部日志丢失。

2. Vane.Dispatch:容器就是引擎的解析器(1.0.0 发布博客 · 从零到实践教程)

Vane.Dispatch 与容器零耦合,唯一的接缝是一个委托 delegate object ServiceResolver(Type serviceType)。MiniContainer 本身实现了 IServiceProvider,BuildDispatchEngine(IServiceProvider) 这个重载把容器包成 ServiceResolver,所以接线只有一句 .BuildDispatchEngine():

csharp 复制代码
using MiniLog;
using Vane.Container;
using Vane.Dispatch;

var builder = new ContainerBuilder();
builder.AddSingleton<ILog>(_ => LogManager.GetLogger("Vane.Samples.Dispatch"));
builder.AddSingleton<IOrderStore, InMemoryOrderStore>();
builder.AddTransient<OrderController>();      // 引擎按类型向容器要控制器实例

using var container = new MiniContainer(builder);

IDispatchEngine engine = container
    .BuildDispatchEngine()                     // 容器被包成 ServiceResolver
    .MapDispatchable<OrderController>()        // 登记契约路由
    .AddGlobalFilter(new TraceFilter(container.GetRequiredService<ILog>()))
    .Build();

int id = engine.Dispatch<int>("orders", "Create", new { sku = "SKU-1", qty = 2 });
OrderView view = engine.Send<OrderController, OrderView>("Get", id);

控制器长这样,构造依赖与 [FromServices] 参数都走同一张注册表:

csharp 复制代码
[Route("orders")]
public sealed class OrderController
{
    private readonly ILog _log;
    private readonly IOrderStore _store;
    public OrderController(ILog log, IOrderStore store) { _log = log; _store = store; }

    public int Create(string sku, int qty) => _store.Add(sku, qty);
    public OrderView Get(int id) => _store.Find(id);

    // [FromServices]:参数同样由容器提供,与构造注入共用同一张注册表
    public string Describe([FromServices] IOrderStore store) => $"store 订单数 {store.Count}";
}

整合点的归属要分清:

分发侧的依赖 由谁提供 说明
控制器实例 容器 引擎按类型调 ServiceResolver,控制器必须先在容器里注册
控制器构造依赖 容器 同一张注册表,生命周期照常生效(Transient 控制器每次分发新建)
[FromServices] 参数 容器 与构造注入同一个 ServiceResolver,取到的是同一实例
过滤器实例与它的依赖 调用方 引擎不解析过滤器,自己 new 出来再 AddGlobalFilter,依赖自己从容器取

三条边界:

  • Build() 只做一次:构建期完成路由表与调用委托编译,放进每请求路径会重复编译,抹掉引擎的性能优势;典型形态是启动时建一次,引擎注册进容器供下游注入。
  • MapDispatchable<T>() 不注册服务 :它只把类型方法与路由写进路由表,实例仍向容器要;只 MapDispatchable 不注册,分发时解析不到控制器。
  • AOP 与装饰器对控制器同样生效 :控制器经容器构造,Intercept / AddDecorator 管线照旧;过滤器不走容器,过滤器上的拦截器不会触发。

3. Prism:桌面 MVVM 的容器适配

Vane.Container.Prism 是独立适配工程(net8.0,依赖 Prism.Core 8.1.97),程序集里唯一的容器入口是 VaneContainerExtension,实现 Prism 的 IContainerExtension、IContainerInfo 与 IContainerExtension<ContainerBuilder>。在 PrismApplication 里覆写 CreateContainerExtension() 把容器接进 Prism,服务仍在 RegisterTypes 里注册:

csharp 复制代码
using Prism.Ioc;
using Vane.Container.Prism;

public partial class App : PrismApplication
{
    protected override IContainerExtension CreateContainerExtension()
        => VaneContainerExtension.CreateContainer();

    protected override Window CreateShell() => Container.Resolve<MainWindow>();

    protected override void RegisterTypes(IContainerRegistry containerRegistry)
    {
        containerRegistry.RegisterSingleton<IMessage, Message>();
        containerRegistry.Register<IDialog, Dialog>("main");   // 命名注册映射为 keyed 服务
    }
}

几条对应关系:

  • 注册 API 一一映射 :RegisterInstance / RegisterSingleton / Register / RegisterScoped / RegisterMany / RegisterManySingleton(含具名重载),名字映射到容器的 ServiceKey;Prism 的 Singleton / Transient / Scoped 分别落到 LifestyleType.Singleton / Transient / Scoped。
  • 底层构建器可混用 :VaneContainerExtension.Instance 暴露底层 ContainerBuilder,Prism 的注册方法与本库的 AddSingleton / AddKeyed* 扩展方法都能用。
  • 解析与动态类型 :Resolve(Type)、Resolve(Type, name),以及带 (Type, object)[] 构造参数覆盖的重载;未注册的具体类型会动态创建(先解析、回落 CreateInstance),Prism MVVM 的 ViewModel 自动定位就依赖这个能力;参数覆盖语义下总是新建实例,对齐 ActivatorUtilities。
  • 作用域 :CreateScope() 返回新的 IScopedProvider,嵌套作用域经 root 另开一层,Scoped 实例落在正确作用域。

两个容易踩的点:

  1. 脱离 Prism 单独使用时要手动固化 :注册之后必须调一次 FinalizeExtension()(内部走 BuildServiceProvider())才能解析;未固化就 Resolve 会抛 InvalidOperationException。Prism 宿主内由框架在启动流程中完成固化,应用代码不用手动调。
  2. 组件模型标注要写契约类型 :[Component(typeof(IContract))](或 [Component<IContract>]),只写 [Component] 会按实现类型自身作契约,用接口查不到。

脱离 Prism 的最小用法(样例、单测形态):

csharp 复制代码
IContainerExtension extension = VaneContainerExtension.CreateContainer();
extension.RegisterSingleton<IMessage, Message>();
extension.FinalizeExtension();          // 缺这一步 Resolve 会失败
var message = extension.Resolve<IMessage>();

4. ASP.NET Core:快照容器接管宿主

Vane.Container.AspNetCore(net10.0,依赖 Microsoft.Extensions.* 10.0.0)提供 IServiceProviderFactory<ContainerBuilder> 实现与一行接入的宿主扩展。接入后照常往 IServiceCollection 里注册,根提供程序由 Vane 的冻结快照接管:

csharp 复制代码
using Vane.Container.AspNetCore;

var builder = WebApplication.CreateBuilder(args);
builder.Host.UseVaneContainer();                 // 根提供程序由 Vane 接管

builder.Services.AddSingleton<IClock, SystemClock>();
builder.Services.AddScoped<IRequestId, RequestId>();

var app = builder.Build();

app.MapGet("/", (IClock clock, IRequestId id) => $"{clock.Now} / request {id.Value}");
app.Run();

UseVaneContainer(this IHostBuilder) 内部调用 UseServiceProviderFactory(new VaneServiceProviderFactory())。工厂做两件事:

  1. 逐条翻译描述符 :CreateBuilder(IServiceCollection) 把每个 ServiceDescriptor 翻成 ServiceRegistration,覆盖实现类型、已存在实例、工厂、keyed 四种形态;ServiceLifetime 的 Singleton / Scoped / Transient 映射到 LifestyleType,不改写调用方的 IServiceCollection。
  2. 构建冻结快照 :CreateServiceProvider(ContainerBuilder) 调 BuildServiceProvider() 产出冻结容器,构建期完成环检测,运行期不再接受注册写入。

请求作用域由工厂额外注册的单例 IServiceScopeFactory(VaneServiceScopeFactory)承接:CreateScope() 开出一个 IContainerScope 再包成 IServiceScope,其 ServiceProvider 返回该作用域的解析视图。这样同一请求内 Scoped 实例复用,跨请求隔离;请求结束随作用域释放。

一个必须避开的坑:不要自行注册 IServiceProvider 。容器已对作用域做了特殊处理,显式把 IServiceProvider 注册成单例反而会遮蔽这套作用域处理,让 scope 内拿到根实例。翻译规则本身不会产生这类注册,是自己加注册时要留意。

和 Prism 那条线对照着看:两个适配包共享同一个底层引擎,构建期都走 BuildServiceProvider() 固化,差别只在宿主入口与作用域包装------ASP.NET Core 面向 Web 后端、由工厂翻译 IServiceCollection,Prism 面向 CS 桌面 MVVM、由 IContainerRegistry 接线。

六、性能与内存:以 MS-DI 为标杆对照

MS-DI 是这一领域公认的性能标杆,下面的基准就以它为对照臂。测量形态:同进程两臂交错、绑定 P-core,被测为本仓库工作区,对照 MS-DI 9.0.0;机器 Core Ultra 5 225H、Windows、.NET SDK 11.0.100、net10.0。这是同 harness 内的相对比较,不能当作对外发布的绝对吞吐。

先立两条判读纪律:ns/op 是噪声,同形态重复常在 ±15% 内漂移,1.15 倍以内记为无差异;B/op 是确定性信号,同一二进制下逐次一致,可以直接下结论。

1. 集合形态支持面(先看清谁支持什么)

注册 8 个 IPlugin 实现的探针实测,两家唯一共有的集合形态是 IEnumerable<T>,MS-DI 连 T[] 都不支持:

形态 Vane 快照 MS-DI
T[] 支持 不支持(返回 null)
IEnumerable<T> 支持 支持
List<T> / IList<T> / ICollection<T> 支持 不支持(返回 null)
IReadOnlyList<T> / IReadOnlyCollection<T> 支持 不支持(返回 null)
ImmutableArray<T> 支持 不支持(返回 null)

2. 解析耗时(ns/op,越小越好)

场景 MS-DI Vane 快照 Vane 动态
Transient0(无依赖) 6.61 5.81 6.32
Transient1(2 依赖) 17.81 14.75 15.17
Transient2(3 依赖) 28.81 32.97 30.37
Singleton 4.46 2.98 2.96
Singleton2(带依赖单例) 4.20 2.99 3.04
Scoped 28.27 7.34 7.40
Scoped2 23.99 7.33 7.22
ScopedDeep(嵌套作用域) 23.76 7.21 7.64
Keyed 9.34 5.96 5.98
OpenGeneric(IRepo<int>) 4.19 3.01 3.15
FastPathS(单例泛型入口) 5.30 1.75 2.35
DepOnSingleton(单例依赖单例) 7.62 9.28 9.30
IEnumerable<T> 集合 4.14 4.87 4.75

读法:

  • 单例与作用域解析 Vane 领先 :单例 2.96--3.04 ns 对 MS-DI 4.20--4.46 ns;作用域 7.21--7.40 ns 对 23.76--28.27 ns,约 3 倍,Scoped2 与 ScopedDeep 方向一致,不是单点优势。
  • 带依赖的 Transient 逐档看 :无依赖与两依赖 Vane 略快,三依赖一档反过来慢约 14%,记为打平范围内的互换;DepOnSingleton 是唯一稳定落后的单例场景,量级很小,没有粉饰。
  • 集合解析两边打平在 4--5 ns。

3. 每次解析的分配(B/op,确定性信号)

场景 MS-DI Vane 快照 Vane 动态
Transient0 / 1 / 2(0 / 2 / 3 依赖) 24 / 104 / 216 24 / 104 / 216 24 / 104 / 216
Singleton / Scoped / Keyed / OpenGeneric 0 0 0
IEnumerable<T> 集合及其他 Vane 集合形态 0(仅 IEnumerable) 0 0

Transient 的分配完全来自模型实例本身(24 B 空对象、104 B 两依赖宿主、216 B 三层链),两方一模一样,说明两条解析路径都没有额外中间分配;集合对象被缓存复用,重复解析不再分配。

4. 容器本体驻留内存(memprobe)

34 项注册、构建 200 个容器并全部持有、GC 后取增量:

容器 构建完成后 全量解析一轮后 每注册
Vane 注册表(只建注册表) 5,397 B 5,397 B 159 B
Vane 快照 9,200 B 35,929 B 1,057 B
Vane 动态 9,472 B 36,160 B 1,064 B
MS-DI 9,194 B 25,450 B 749 B
  • 构建后固定开销已与 MS-DI 收平 :9,200 B 对 9,194 B。空容器固定开销从早先的 13.3 KB 降到 3.7 KB,主要靠把 13 个并发字典的初始容量改小、去掉无内联依赖槽的共享空集合与 Freeze() 预热。
  • 全量解析后的增量 Vane 更高 :约 1.06 KB/注册,是 MS-DI 749 B 的 1.4 倍。这部分增量由每个槽的派生结构(Entry、字典节点、依赖集合、单例单元、编译委托)平摊,已归因判定为表达力带来的设计成本;再压缩只能改动热路径数据结构,收益上限约 2 KB 而风险进入解析路径,不值得。

5. 作用域:只认两条确定性证据

CreateScope 的 ns 受 GC 时机影响、换跑法方向就翻转,不可判读;可判读的只有:

  1. 分配:仅建作用域 Vane 120 B,小于 MS-DI 128 B。
  2. 零分配命中路径(复用已建作用域连续解析,循环内不产生垃圾):Vane 7.70 / 12.85 ns 对 MS-DI 26.97 / 24.12 ns,两次独立运行方向一致,至少快 1.8 倍。

6. 这组数据不能说明什么

不能得出"Vane 比 MS-DI 快 N 倍"的对外结论:同进程测量省掉了真实部署的进程边界与调度。本组全部单线程,未覆盖并发解析、AOP 与装饰器开启后的路径、[InjectMany] 的 Lazy<T>[] 形态、千级以上注册集,以及泛型闭合类型爆炸时的编译缓存上限。完整数据、判读纪律与复现命令见仓库的 性能基准文档。

七、边界与诚实说明

  • 类型独立、不可互换:与 MS-DI 之间要在边界处手动桥接,不能直接传类型。
  • 组件模型仅动态可用 :冻结快照不扫描组件目录,GetLazyServices / Compose 会抛异常。
  • AOP 仅接口代理 :Intercept 只接受接口契约,非接口抛 NotSupportedException;需要包装具体类或追求热路径性能时,用装饰器。
  • AOT 边界 :源生成器只消除注册期反射,解析期仍依赖表达式树与动态 IL emit,当前不满足 NativeAOT 与严格裁剪约束,包内 IsAotCompatible=false、IsTrimmable=false。
  • 循环依赖 :快照在构建期做依赖图检测,发现环抛 InvalidOperationException 并给出路径;动态容器的初始注册与运行期 Register 不重复校验,运行期新增的环不会被检出,需要自己保证依赖图无环。

八、写在最后

十六年前写那组笔记时,容器的核心命题是「怎么把对象造出来、把依赖注进去」;这一版重新发布,命题变成了「在不牺牲当年表达力的前提下,把形态收窄、把热路径做快、把边界讲清楚」。快照模式是这一轮最主要的结构性变化:它让同一个引擎既能服务桌面与插件宿主的动态场景,也能以与 MS-DI 对齐的姿势进入 Web 后端。

仓库里的入门手册覆盖从概念到内部实现的完整链路,API 参考列出全部公开 API 与从旧版本迁移的符号对照。当年看过 Mini 容器笔记的老朋友,欢迎对照着看看这一版;有问题或建议,直接在仓库里提。

容器只是这一轮 Vane 系列开源的一环:前段已经放出 MiniLog、Vane.Dispatch 与历史包 Acl.Excel;其中 MiniLog 计划后续迁移为 Vane.Log(暂未发布);旧版 Acl.Excel 仅支持 xlsx,后续表格库将以 Vane.Sheet(暂未发布)重发,统一 xlsx / xls / xlsb / csv / ndjson,微内核接口、流式读写;有界缓存下文件规模只受存储约束,只要存储够大,上千 GB 乃至更大的表都能处理,内存与行数解耦。后续还会有更多以 Vane. 前缀命名的基础库与 NuGet 包陆续发布,欢迎关注。


相关链接

相关推荐
Jeff-Tsai7 小时前
Day 21:业务逻辑定制与 Plugin 的四个时点
.net·架构设计·erp·definition-driven
IT规划师8 小时前
Redis 核心机制 | 键生命周期与 TTL 管理
redis·.net
Jeff-Tsai1 天前
Day 20:多语言定制与资源结构
.net·架构设计·erp·definition-driven
Jeff-Tsai2 天前
Day 19:定制层的范围与叠加粒度
.net·架构设计·erp·definition-driven
Jeff-Tsai3 天前
Day 18:错误契约与用户可见消息
.net·架构设计·erp·definition-driven
IT规划师3 天前
HybridCache-缓存架构决策框架落地
架构·.net
Jeff-Tsai4 天前
Day 17:Connector 与调用端的职责收敛
.net·架构设计·erp·definition-driven
IT规划师5 天前
NET10 高并发架构契约与落地实现
架构·.net
公子小六5 天前
基于.NET的Windows窗体编程之WinForms数据持久化(1)
windows·microsoft·c#·.net·winforms