1

hutongqing

2025-01-02 8c6fd742db249ad4cc819cf041eb98d880a3ef73

 WIDESEAWCS_Server/WIDESEAWCS_QuartzJob/QuartzExtensions/QuartzJobHostedService.cs

@@ -29,10 +29,14 @@
using WIDESEAWCS_QuartzJob.DeviceBase;
using WIDESEAWCS_QuartzJob.DTO;
using WIDESEAWCS_QuartzJob.Models;
using WIDESEAWCS_QuartzJob.QuartzNet;
using WIDESEAWCS_QuartzJob.Service;

namespace WIDESEAWCS_QuartzJob.QuartzExtensions
{
    /// <summary>
    /// 启动程序自动开启调度服务
    /// </summary>
    public class QuartzJobHostedService : IHostedService
    {
        private readonly ISchedulerCenter _schedulerCenter;
@@ -40,14 +44,19 @@
        private readonly IDeviceInfoService _deviceInfoService;
        private readonly IDispatchInfoService _dispatchInfoService;
        private readonly IDeviceProtocolDetailService _deviceProtocolDetailService;
        private readonly QuartzNetExtension _quartzNetExtension;

        public QuartzJobHostedService(ILogger<QuartzJobHostedService> logger, IDeviceInfoService deviceInfoService, IDispatchInfoService dispatchInfoService, ISchedulerCenter schedulerCenter, IDeviceProtocolDetailService deviceProtocolDetailService)
        /// <summary>
        /// 启动程序自动开启调度服务
        /// </summary>
        public QuartzJobHostedService(ILogger<QuartzJobHostedService> logger, IDeviceInfoService deviceInfoService, IDispatchInfoService dispatchInfoService, ISchedulerCenter schedulerCenter, IDeviceProtocolDetailService deviceProtocolDetailService, QuartzNetExtension quartzNetExtension)
        {
            _logger = logger;
            _deviceInfoService = deviceInfoService;
            _dispatchInfoService = dispatchInfoService;
            _schedulerCenter = schedulerCenter;
            _deviceProtocolDetailService = deviceProtocolDetailService;
            _quartzNetExtension = quartzNetExtension;
        }

        /// <summary>
@@ -57,69 +66,12 @@
        /// <returns></returns>
        public async Task StartAsync(CancellationToken cancellationToken)
        {
            try
            {
                List<DispatchInfoDTO> dispatches = _dispatchInfoService.QueryDispatchInfos();
                List<DeviceInfoDTO> deviceInfos = await _deviceInfoService.QueryDeviceProInfos();

                deviceInfos.ForEach(x =>
                {
                    if (dispatches.Exists(d => d.JobGroup == x.DeviceType))
                    {
                        #region 连接PLC
                        Assembly assembly = Assembly.Load($"WIDESEAWCS_Communicator");
                        Type? type = assembly.GetType($"WIDESEAWCS_Communicator.{x.DevicePlcType}");
                        object? obj = Activator.CreateInstance(type, new object[] { x.DeviceIp, x.DevicePort, x.DeviceName });
                        bool? connectResult = (bool)type.InvokeMember("Connect", BindingFlags.Default | BindingFlags.InvokeMethod, null, obj, new object[] { });
                        if (connectResult ?? false) ConsoleHelper.WriteSuccessLine(x.DeviceCode + "连接成功"); else ConsoleHelper.WriteErrorLine(x.DeviceCode + "连接失败");

                        #endregion

                        #region 实例化设备对象

                        List<DeviceProDTO> devicePros = x.ProtocolList.Select(d => new DeviceProDTO
                        {
                            DeviceChildCode = d.DeviceChildCode,
                            DeviceDataType = d.DeviceProDataType,
                            DeviceId = d.DeviceId,
                            DeviceProId = d.Id,
                            DeviceProDataBlock = d.DeviceProDataBlock,
                            DeviceProDataLength = d.DeviceProDataLength,
                            DeviceProOffset = d.DeviceProOffset,
                            DeviceProParamDes = d.DeviceProParamDes,
                            DeviceProParamName = d.DeviceProParamName,
                            DeviceProParamType = d.DeviceProParamType,
                        }).ToList();

                        List<DeviceProtocolDetailDTO> deviceProtocolDetails = _deviceProtocolDetailService.GetDeviceProtocolDetailsByDeviceType(x.DeviceType);

                        Assembly assemblyDevice = Assembly.Load($"WIDESEAWCS_QuartzJob");
                        Type typeDevice = assemblyDevice.GetType($"WIDESEAWCS_QuartzJob.{x.DeviceType}");
                        object deviceInstance = Activator.CreateInstance(typeDevice, new object[] { obj, devicePros, deviceProtocolDetails, x.DeviceCode, x.DeviceName });
                        #endregion

                        x.Device = (IDevice)deviceInstance;

                        Storage.Devices.Add((IDevice)deviceInstance);
                    }
                });
                for (int i = 0; i < dispatches.Count; i++)
                {
                    DeviceInfoDTO? deviceProInfo = deviceInfos.FirstOrDefault(x => x.Id == dispatches[i].Id);
                    dispatches[i].JobParams = deviceProInfo?.Device;
                    WebResponseContent responseContent = await _schedulerCenter.AddScheduleJobAsync(dispatches[i]);
                    if (responseContent.Status) ConsoleHelper.WriteSuccessLine(dispatches[i].JobGroup + "调度服务添加成功"); else ConsoleHelper.WriteErrorLine(dispatches[i].JobGroup + "调度服务添加失败");
                }
                await _schedulerCenter.StartScheduleAsync();
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "调度服务开启异常");
                Console.WriteLine("调度服务开启异常" + ex.ToString());
                throw;
            }
            await _quartzNetExtension.StartAsync();
        }

        /// <summary>
        /// 启动程序自动开启调度服务
        /// </summary>
        public Task StopAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("Stop QuartzJob Service!");