在TopShelf和Quartz范围问题中使用Microsoft DependencyInjection

Question

我使用TopShelf和Quartz将某些作业安排为Windows服务。对于依赖注入，我使用Microsoft.Extensions.DependencyInjection包。我的问题是作用域功能，我想在作用域生命周期中配置服务时（例如ISampleService），每轮运行的作业，处置作用域生命周期服务，并在下一轮再次实例化，但是作用域生命周期的行为类似于单例生命周期。以下是我的代码：

依赖关系：

using Microsoft.Extensions.DependencyInjection;
using Quartz;
using Quartz.Impl;
using Quartz.Spi;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Topshelf;

主要方法：

static void Main(string[] args)
{
    var provider = RegisterServices();

    HostFactory.Run(cfg =>
    {
        cfg.Service<SampleTask>(s =>
        {
            s.ConstructUsing(() => provider.GetService<SampleTask>());
            s.WhenStarted(async f => await f.Start(provider));
            s.WhenStopped(f => f.Stop());
        });

        cfg.RunAsLocalSystem();
        cfg.SetDescription("description");
        cfg.SetDisplayName("name");
        cfg.SetServiceName("service");
    });
}

RegisterServices方法

public static ServiceProvider RegisterServices()
{
    IServiceCollection services = new ServiceCollection();

    services.AddSingleton<ISchedulerFactory, StdSchedulerFactory>();

    services.AddTransient<SampleTask>();
    services.AddTransient<IJob, SampleJob>();
    services.AddScoped<ISampleService, SampleService>

    var provider = services.BuildServiceProvider();

    return provider;
}

JobFactory：

public class JobFactory : IJobFactory
{
    protected readonly IServiceProvider Container;

    public JobFactory(IServiceProvider container)
    {
        Container = container;
    }

    public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler)
    {
        return Container.GetService(bundle.JobDetail.JobType) as IJob;
    }

    public void ReturnJob(IJob job)
    {
        (job as IDisposable)?.Dispose();
    }
}

任务：

public class SampleTask
{
    private readonly ISchedulerFactory _schedulerFactory;

    public SampleTask(ISchedulerFactory schedulerFactory)
    {
        _schedulerFactory = schedulerFactory;
    }

    public async Task Start(ServiceProvider provider)
    {
        var scheduler = await _schedulerFactory.GetScheduler();
        scheduler.JobFactory = new JobFactory(provider);

        var job = JobBuilder.Create<IJob>().Build();

        var trigger = TriggerBuilder.Create()
            .WithIdentity("Sample1", "SampleGroup")
            .WithSimpleSchedule(x => x
                .WithIntervalInMinutes(10)
                .RepeatForever())
            .StartNow()
            .Build();

        await scheduler.ScheduleJob(job, trigger);

        await scheduler.Start();
    }

    public bool Stop()
    {
        return true;
    }
}

工作：

public class SampleJob : IJob
{
    private readonly ISampleService _sampleService;

    public SampleJob(ISampleService sampleService)
    {
        _sampleService = sampleService;
    }

    public async Task Execute(IJobExecutionContext context)
    {
        await Task.FromResult(0);
    }
}

Answer 1

我很想阅读您的解决方案Mohammad。您能分享一下吗？