.net core+topshelf+quartz創建windows定時任務服務-有解無憂

.net core+topshelf+quartz創建windows定時任務服務

準備作業

創建.net core 控制臺應用程式，這里不做過多介紹
添加TopShelf包：TopShelf；
添加Quartz包：Quartz、Quartz.Plugins；
添加依賴注入包：Microsoft.Extensions.DependencyInjection；
添加讀取組態檔包：Microsoft.Extensions.Configuration.Json；
添加訪問資料庫包：Microsoft.EntityFrameworkCore；
添加日志包：Serilog、Serilog.Sinks.Console、Serilog.Sinks.File

配置Quartz

創建appsettings.json檔案，右鍵檔案屬性，并更改屬性為始終復制內容

{
"quartz": {
    "scheduler": {
      "instanceName": "Job"
    },
    "threadPool": {
      "type": "Quartz.Simpl.SimpleThreadPool, Quartz",
      "threadPriority": "Normal",
      "threadCount": 10
    },
    "plugin": {
      "jobInitializer": {
        "type": "Quartz.Plugin.Xml.XMLSchedulingDataProcessorPlugin, Quartz.Plugins",
        "fileNames": "quartz_jobs.xml"
      }
    }
  }
}

創建QuartzOption 類

namespace Job
{
    public class QuartzOption
    {
        public QuartzOption(IConfiguration config)
        {
            if (config == null)
            {
                throw new ArgumentNullException(nameof(config));
            }

            var section = config.GetSection("quartz");
            section.Bind(this);
        }

        public Scheduler Scheduler { get; set; }

        public ThreadPool ThreadPool { get; set; }

        public Plugin Plugin { get; set; }

        public NameValueCollection ToProperties()
        {
            var properties = new NameValueCollection
            {
                ["quartz.scheduler.instanceName"] = Scheduler?.InstanceName,
                ["quartz.threadPool.type"] = ThreadPool?.Type,
                ["quartz.threadPool.threadPriority"] = ThreadPool?.ThreadPriority,
                ["quartz.threadPool.threadCount"] = ThreadPool?.ThreadCount.ToString(),
                ["quartz.plugin.jobInitializer.type"] = Plugin?.JobInitializer?.Type,
                ["quartz.plugin.jobInitializer.fileNames"] = Plugin?.JobInitializer?.FileNames
            };

            return properties;
        }
    }

    public class Scheduler
    {
        public string InstanceName { get; set; }
    }

    public class ThreadPool
    {
        public string Type { get; set; }

        public string ThreadPriority { get; set; }

        public int ThreadCount { get; set; }
    }

    public class Plugin
    {
        public JobInitializer JobInitializer { get; set; }
    }

    public class JobInitializer
    {
        public string Type { get; set; }
        public string FileNames { get; set; }
    }
}

添加一個Job

namespace Job
{
    public class SyncJob : IJob
    {
        private readonly IService _service;

        public SyncJob(IService service)
        {
            _service = service;
        }

        public async Task Execute(IJobExecutionContext context)
        {
            Log.Information("同步開始...");
            _service.DoSomeThing();
        }
    }
}

實作IJobFactory

namespace Job
{
    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();
        }
    }
}

創建Quartz調度的組態檔 quartz_jobs.xml

檔案名與appsetting中的quartz.plugin.jobInitializer.fileNames 保持一致

<?xml version="1.0" encoding="UTF-8"?>

<job-scheduling-data xmlns="http://quartznet.sourceforge.net/JobSchedulingData"
                     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                     version="2.0">

  <processing-directives>
    <overwrite-existing-data>true</overwrite-existing-data>
  </processing-directives>

  <schedule>
    <job>
      <name>SyncJob</name>
      <group>SyncGroup</group>
      <description>資料同步任務</description>
      <job-type>Mille.Job.SyncJob, Mille.Job</job-type>
      <durable>true</durable>
      <recover>false</recover>
    </job>
    <trigger>
      <cron>
        <name>SyncTrigger</name>
        <group>SyncGroup</group>
        <description>同步觸發器</description>
        <job-name>SyncDJob</job-name>
        <job-group>SyncGroup</job-group>
         <!--每晚23：50跑一次，具體參見cron運算式-->
        <cron-expression>0 50 23 ? * *</cron-expression>
      </cron>
    </trigger>

    <!--<trigger>
      <simple>
        <name>SyncTrigger</name>
        <group>SyncGroup</group>
        <description>資料同步觸發器</description>
        <job-name>SyncJob</job-name>
        <job-group>SyncGroup</job-group>
        <repeat-count>-1</repeat-count>
        2s跑一次
        <repeat-interval>2000</repeat-interval>
      </simple>
    </trigger>-->
  </schedule>
</job-scheduling-data>

添加一個類，此類用戶服務啟動呼叫

namespace Job
{
    public class SyncService
    {
        public async Task StartAsync()
        {
            var provider = RegisterServices();
            Scheduler = provider.GetService(typeof(IScheduler)) as IScheduler;
            await Scheduler.Start();
            Log.Information("Quartz調度已啟動...");
        }

        public async Task StopAsync()
        {
            await Scheduler.Shutdown();
            Log.Information("Quartz調度結束...");
            Log.CloseAndFlush();
        }

        #region Utils
        private IScheduler Scheduler { get; set; }
        private static ServiceProvider RegisterServices()
        {
            Log.Information("配置依賴注入...");
            var configuration = ReadFromAppSettings();
            var services = new ServiceCollection();

            #region 

            services.AddScoped<SyncService>();
            services.AddDbContext<DataContext>(opt => opt.UseMySql(configuration.GetConnectionString("ConnStr")));
            services.AddScoped<IService,Service>();

            #endregion

            #region Quartz

            Log.Information("配置Quartz...");
            services.AddScoped<IJobFactory, JobFactory>();
            services.AddSingleton(service =>
            {
                var option = new QuartzOption(configuration);
                var sf = new StdSchedulerFactory(option.ToProperties());
                var scheduler = sf.GetScheduler().Result;
                scheduler.JobFactory = service.GetService<IJobFactory>();
                return scheduler;
            });
            services.AddScoped<SyncJob>(); 
            //此處不能寫成services.AddScoped<IJob,SyncJob>(); 會造成在找不到SyncJob

            #endregion

            var provider = services.BuildServiceProvider();
            return provider;
        }

        private static IConfigurationRoot ReadFromAppSettings()
        {
            //讀取appsettings.json
            return new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json", false)
                .Build();
        }
    
        #endregion
    }
}

配置TopShelf

詳情參見 https://topshelf.readthedocs.io/en/latest/configuration/quickstart.html

namespace Job
{
    public class Program
    {
        public static void Main(string[] args)
        {
            InstanceLog();
            var rc = HostFactory.Run(x =>
            {
                x.Service<SyncService>(s =>
                {
                    s.ConstructUsing(name => new SyncService());
                    s.WhenStarted(async tc => await tc.StartAsync()); //呼叫此方法前勿有太多操作，會造成服務啟動失敗
                    s.WhenStopped(async tc => await tc.StopAsync());
                });
                x.RunAsLocalSystem();

                x.SetDescription("SyncJob Description");
                x.SetDisplayName("SyncJob DisplayName");
                x.SetServiceName("SyncJob ServiceName");
            });
            var exitCode = (int)Convert.ChangeType(rc, rc.GetTypeCode());
            Environment.ExitCode = exitCode;
        }

        private static void InstanceLog()
        {
            //配置Serilog
            var template = "{Timestamp:HH:mm:ss} [{Level:u3}] {Message}{NewLine}{Exception}";
            Log.Logger = new LoggerConfiguration()
                .WriteTo.File(path: "logs/log.txt", outputTemplate: template, rollingInterval: RollingInterval.Day)
                .WriteTo.Console(LogEventLevel.Information)
                .CreateLogger();
        }
    }
}

然后在專案檔案中加上專案的運行環境相關配置

<PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3.0</TargetFramework>
    <RuntimeIdentifier>win7-x64</RuntimeIdentifier>//不同的環境RID不同
</PropertyGroup>

運行

編譯專案之后，進入到/bin/Debug/netcoreapp3.0/win7-x64目錄，在此處以管理員運行cmd，然后執行依次Job.exe install 安裝服務， Job.exe start 啟動服務

如果遇到啟動服務時報 1053錯誤：服務沒有及時回應啟動或控制請求，檢查Start函式呼叫之前是否還有其他操作，如有，請將這些操作移動到Start呼叫后執行；本人就是由于在Start之前執行了依賴注入等操作，導致服務啟動失敗，故寫下這篇文章

此文章有部分借鑒其他博主的博客，如有侵權，請聯系洗掉

轉載請註明出處，本文鏈接：https://www.uj5u.com/net/100128.html

標籤：.NET Core

上一篇：.NETCore下CI/CD之自動化測驗

下一篇：.NET Core Razor Pages中ajax get和post的使用