Jab

C# Source Generator based dependency injection container implementation.
Alternatives To Jab
Project NameStarsDownloadsRepos Using ThisPackages Using ThisMost Recent CommitTotal ReleasesLatest ReleaseOpen IssuesLicenseLanguage
Awilix3,0722943422 months ago78October 12, 2023mitTypeScript
Extremely powerful Inversion of Control (IoC) container for Node.JS
Jab941
2 days ago36November 22, 202315mitC#
C# Source Generator based dependency injection container implementation.
Dryioc9271221532 days ago449November 12, 202342mitC#
DryIoc is fast, small, full-featured IoC Container for .NET
Stronginject66212 years ago296May 24, 202217mitC#
compile time dependency injection for .NET
Swinjectstoryboard254
832 months ago15September 05, 202126mitSwift
Swinject extension for automatic dependency injection via Storyboard
Swinjectautoregistration217
187 months ago10February 06, 20233mitSwift
Swinject extension to automatically register your services
Autofac.annotation200123 months ago6January 28, 2020mitC#
DI容器,依赖注入,AOP,动态代理等用注解来load autofac 摆脱代码或者xml配置和java的spring的注解注入一样的体验
Stashbox13118229 days ago367November 18, 2023mitC#
A lightweight, fast, and portable dependency injection framework for .NET-based solutions.
Autofac.extras.quartz11625188 months ago181March 27, 20234mitC#
Autofac integration for Quartz.Net
Kickstart41113 months ago72August 20, 20228mitC#
Application initialization helper
Alternatives To Jab
Select To Compare


Alternative Project Comparisons
Readme

Jab Compile Time Dependency Injection

Nuget (with prereleases)

Nuget (with prereleases)

Jab provides a C# Source Generator based dependency injection container implementation.

  • Fast startup (200x faster than Microsoft.Extensions.DependencyInjection). Details.

  • Fast resolution (7x faster than Microsoft.Extensions.DependencyInjection). Details.

  • No runtime dependencies.

  • AOT and linker friendly, all code is generated during project compilation.

  • Clean stack traces:

    stacktrace

  • Readable generated code:

    generated code

  • Registration validation. Container configuration issues become compiler errors:

    generated code

  • Incremental generation, .NET 5/6 SDK support, .NET Standard 2.0 support

Example

Add Jab package reference:

<ItemGroup>
    <PackageReference Include="Jab" Version="0.8.6" PrivateAssets="all" />
</ItemGroup>

Define a service and implementation:

internal interface IService
{
    void M();
}

internal class ServiceImplementation : IService
{
    public void M()
    {
    }
}

Define a composition root and register services:

[ServiceProvider]
[Transient(typeof(IService), typeof(ServiceImplementation))]
internal partial class MyServiceProvider { }

Use the service provider:

MyServiceProvider c = new MyServiceProvider();
IService service = c.GetService<IService>();

Features

  • No runtime dependency, safe to use in libraries
  • Transient, Singleton, Scoped service registration
  • Factory registration
  • Instance registration
  • IEnumerable resolution
  • IDisposable and IAsyncDisposable support
  • IServiceProvider support

The plan is to support the minimum feature set Microsoft.Extensions.DependencyInjection.Abstraction requires but NOT the IServiceCollection-based registration syntax as it is runtime based.

Singleton services

Singleton services are created once per container lifetime in a thread-safe manner and cached. To register a singleton service use the SingletonAttribute:

[ServiceProvider]
[Singleton(typeof(IService), typeof(ServiceImplementation))]
internal partial class MyServiceProvider { }

Singleton Instances

If you want to use an existing object as a service define a property in the container declaration and use the Instance property of the SingletonAttribute to register the service:

[ServiceProvider]
[Singleton(typeof(IService), Instance = nameof(MyServiceInstance))]
internal partial class MyServiceProvider {
    public IService MyServiceInstance { get;set; }
}

Then initialize the property during the container creation:

MyServiceProvider c = new MyServiceProvider();
c.MyServiceInstance = new ServiceImplementation();

IService service = c.GetService<IService>();

Factories

Sometimes it's useful to provide a custom way to create a service instance without using the automatic construction selection. To do this define a method in the container declaration and use the Factory property of the SingletonAttribute or TransientAttribute to register the service:

[ServiceProvider]
[Transient(typeof(IService), Factory = nameof(MyServiceFactory))]
internal partial class MyServiceProvider {
    public IService MyServiceFactory() => new ServiceImplementation();
}

MyServiceProvider c = new MyServiceProvider();
IService service = c.GetService<IService>();

When using with TransientAttribute the factory method would be invoked for every service resolution. When used with SingletonAttribute it would only be invoked the first time the service is requested.

Scoped Services

Scoped services are created once per service provider scope. To create a scope use the CreateScope() method of the service provider. Service are resolved from the scope using the GetService<IService>() call.

[ServiceProvider]
[Scoped(typeof(IService), typeof(ServiceImplementation))]
internal partial class MyServiceProvider { }

MyServiceProvider c = new MyServiceProvider();
using MyServiceProvider.Scope scope = c.CreateScope();
IService service = scope.GetService<IService>();

When the scope is disposed all IDisposable and IAsyncDisposable services that were resolved from it are disposed as well.

Generic registration attributes

You can use generic attributes to register services if your project targets net7.0 or net6.0 and has LangVersion set to preview.

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFrameworks>net7.0</TargetFrameworks>
  </PropertyGroup>

</Project>

Generic attributes allow declaration to be more compact by avoiding the typeof calls:

[ServiceProvider]
[Scoped<IService, ServiceImplementation>]
[Import<IMyModule>]
internal partial class MyServiceProvider { }

Modules

Often, a set of service registrations would represent a distinct set of functionality that can be included into arbitrary service provider. Modules are used to implement registration sharing. To define a module create an interface and mark it with ServiceProviderModuleAttribute. Service registrations can be listed in module the same way they are in the service provider.

[ServiceProviderModule]
[Singleton(typeof(IService), typeof(ServiceImplementation))]
public interface IMyModule
{
}

To use the module apply the Import attribute to the service provider type:

[ServiceProvider]
[Import(typeof(IMyModule))]
internal partial class MyServiceProvider
{
}

MyServiceProvider c = new MyServiceProvider();
IService service = c.GetService<IEnumerable<IService>>();

Modules can import other modules as well.

NOTE: module service and implementation types have to be accessible from the project where service provider is generated.

Root services

By default, IEnumerable<...> service accessors are only generated when requested by other service constructors. If you would like to have a root IEnumerable<..> accessor generated use the RootService parameter of the ServiceProvider attribute. The generator also scans all the GetService<...> usages and tries to all collected type arguments as the root service.

[ServiceProvider(RootServices = new [] {typeof(IEnumerable<IService>)})]
[Singleton(typeof(IService), typeof(ServiceImplementation))]
[Singleton(typeof(IService), typeof(ServiceImplementation))]
[Singleton(typeof(IService), typeof(ServiceImplementation))]
internal partial class MyServiceProvider
{
}

MyServiceProvider c = new MyServiceProvider();
IService service = c.GetService<IEnumerable<IService>>();

Samples

Console application

Sample Jab usage in console application can be found in src/samples/ConsoleSample

Performance

The performance benchmark project is available in src/Jab.Performance/.

Startup time

The startup time benchmark measures time between application startup and the first service being resolved.

| Method |        Mean |     Error |    StdDev |  Ratio | RatioSD |  Gen 0 |  Gen 1 | Gen 2 | Allocated |
|------- |------------:|----------:|----------:|-------:|--------:|-------:|-------:|------:|----------:|
|   MEDI | 2,437.88 ns | 14.565 ns | 12.163 ns | 220.91 |    2.72 | 0.6332 | 0.0114 |     - |    6632 B |
|    Jab |    11.03 ns |  0.158 ns |  0.123 ns |   1.00 |    0.00 | 0.0046 |      - |     - |      48 B |

GetService

The GetService benchmark measures the provider.GetService<IService>() call.

| Method |      Mean |     Error |    StdDev | Ratio | RatioSD |  Gen 0 | Gen 1 | Gen 2 | Allocated |
|------- |----------:|----------:|----------:|------:|--------:|-------:|------:|------:|----------:|
|   MEDI | 39.340 ns | 0.2419 ns | 0.2263 ns |  7.01 |    0.09 | 0.0023 |     - |     - |      24 B |
|    Jab |  5.619 ns | 0.0770 ns | 0.0643 ns |  1.00 |    0.00 | 0.0023 |     - |     - |      24 B |

Debugging locally

Run dotnet build /t:CreateLaunchSettings in the Jab.Tests directory would update the Jab\Properties\launchSettings.json file to include csc invocation that allows F5 debugging of the generator targeting the Jab.Tests project.

Popular Dependency Injection Projects
Popular Registration Projects
Popular Software Architecture Categories
Related Searches

Get A Weekly Email With Trending Projects For These Categories
No Spam. Unsubscribe easily at any time.
C Sharp
Dependency Injection
Registration
Roslyn