Quartz.net Core 中的依赖注入找不到已注册的服务

Question

I am getting a DI registration issue when trying to setup Quartz, the job is a simple test job to confirm DI is working (that just outputs text to the console).

The code where the error is thrown is in the last class JobFactory .

Program.cs

static async Task Main(string[] args)
{

    var isService = !(Debugger.IsAttached || ((IList)args).Contains("--console"));

    var path = Path.GetDirectoryName(new Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath);

    var webHost = new HostBuilder()
        .ConfigureAppConfiguration((cxt, config) =>
        {
            config.SetBasePath(path);
            config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
            config.AddJsonFile($"appsettings.{environmentName}.json", optional: true, reloadOnChange: true);
            config.AddEnvironmentVariables();

            if (args != null)
            {
                config.AddCommandLine(args);
            }

            Log.Logger = new LoggerConfiguration()
                    .ReadFrom.Configuration(config.Build())
                    .Enrich.FromLogContext()
                    .CreateLogger();
        })
        .ConfigureServices((cxt, services) =>
        {
            var configuration = cxt.Configuration;

            var bw = new BackgroundWorker(services.BuildServiceProvider());
            services.AddSingleton<IHostedService>(bw);
            services.AddLogging(loggingBuilder => loggingBuilder.AddSerilog(dispose: true));

            //services.AddSingleton<ISchedulerFactory, SchedulerFactory>();
            //services.AddSingleton<ScopedJobFactory>();

            services.AddScoped(_ => new SomeJob(configuration));
            //services.AddTransient<IJob>(_ => new SomeJob(configuration));

    var token = tokenSource.Token;
    if (isService)
    {
        await webHost.RunAsServiceAsync(token);
    }
    else
    {
        await webHost.RunConsoleAsync(token);
    }
}

Setup the Quartz job factory:

private static async Task<IScheduler> InitiateQuartzScheduler(IServiceProvider serviceProvider)
{
    try
    {
        var factory = new StdSchedulerFactory();
        var scheduler = await factory.GetScheduler();
        scheduler.JobFactory = new JobFactory(serviceProvider);

        await scheduler.Start();

        return scheduler;

    }
    catch (SchedulerException se)
    {
        Log.Logger.Fatal(se, "Error at starting the Quartz Scheduler");
    }

    return null;
}

Background worker:

private class BackgroundWorker : IHostedService
{
    private IScheduler quartzScheduler;
    private readonly IServiceProvider serviceProvider;

    public BackgroundWorker(IServiceProvider serviceProvider)
    {
        this.serviceProvider = serviceProvider;
    }

    public async Task StartAsync(CancellationToken cancellationToken)
    {
        //Log.Logger = SetupSerilog();
        Log.Logger.Information("Starting Quartz BackgroundWorker.");

        quartzScheduler = await InitiateQuartzScheduler(serviceProvider);
    }

    public async Task StopAsync(CancellationToken cancellationToken)
    {
        Log.Logger.Information("Quartz Background Worker is stopping.");
    }
}

Job factory (where the error occurs):

internal class JobFactory : IJobFactory
{
    protected readonly IServiceProvider serviceProvider;

    protected readonly ConcurrentDictionary<IJob, IServiceScope> _scopes = new ConcurrentDictionary<IJob, IServiceScope>();

    public JobFactory(IServiceProvider serviceProvider)
    {
        this.serviceProvider = serviceProvider;
    }

    public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler)
    {
        var scope = serviceProvider.CreateScope();
        IJob job;

        try
        {
            //
            // **ERROR HERE**
            //
            job = scope.ServiceProvider.GetRequiredService(bundle.JobDetail.JobType) as IJob;

        }
        catch
        {
            // Failed to create the job -> ensure scope gets disposed
            scope.Dispose();
            throw;
        }

        // Add scope to dictionary so we can dispose it once the job finishes
        if (!_scopes.TryAdd(job, scope))
        {
            // Failed to track DI scope -> ensure scope gets disposed
            scope.Dispose();
            throw new Exception("Failed to track DI scope");
        }

        return job;
    }

    public void ReturnJob(IJob job)
    {
        if (_scopes.TryRemove(job, out var scope))
        {
            // The Dispose() method ends the scope lifetime.
            // Once Dispose is called, any scoped services that have been resolved from ServiceProvider will be disposed.
            scope.Dispose();
        }
    }
}

Runtime error:

System.InvalidOperationException: 'No service for type 'xxx.yyy.SomeJob' has been registered.'

Answer 1

The background worker is being given a provider before all the required dependencies are added.

//...

var configuration = cxt.Configuration;

var bw = new BackgroundWorker(services.BuildServiceProvider()); //<---This service provider
services.AddSingleton<IHostedService>(bw);
services.AddLogging(loggingBuilder => loggingBuilder.AddSerilog(dispose: true));

services.AddScoped(_ => new SomeJob(configuration)); //<--knows nothing about this service

//...or any other service added after services.BuildServiceProvider()

//...

Once a service collection is built, any changes (additions/removal) from the collection have no effect on an already built provider.

Consider changing approach and using a deferred delegate factory when registering the worker

//...

services.AddSingleton<IHostedService>(serviceProvider => new BackgroundWorker(serviceProvider));

//...