YG-MW-WCS/Projects/永冠/WCS.Service/Worker.cs

using DBHelper;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using WCS.Core;
using WCS.Entity;
using WCS.Service.Helpers;
using WCS.Service.WebApi.ViewModels;

namespace WCS.Service
{
    public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> _logger;

        public Worker(ILogger<Worker> logger)
        {
            _logger = logger;
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            if (stoppingToken.IsCancellationRequested)
                return;
            _logger.LogInformation("WCS开始启动");
            Configs.DebugRedisUrl = "127.0.0.1";
            Configs.ProtocolProxyBaseType = typeof(ProtocolProxy);
            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
            Configs.StringEncoding = Encoding.UTF8;

            DB.SetDefaultDbContextType<WCSDB>();

            Configs.PublishEvent += () =>
            {
                WMS.UploadDevInfo();
                ProtocolProxy.Do();
            };
            Configs.UploadException = (d, s) =>
            {
                if (s == "接口调用中")
                    return;
                if (ProtocolProxy.AllDatas.ContainsKey(d))
                {
                    ProtocolProxy.AllDatas[d].Info = s;
                    ProtocolProxy.AllDatas[d].Frame = LogicHandler.Frame;
                }
                WMS.TaskException(d, s);
            };

            LogicHandler.DbLog = (msg, time) => LogHelper.AddWCS_EXCEPTION(msg, time);

          

            PLCAccessor.Creater = new PLCAccessors.PLCAccessorsCreater();
            try
            {
                DB.Do(db =>
                {
                    var items = db.Default.Set<WCS_DEVICEPROTOCOL>()
                   //.Where(v => v.ENABLED && v.DEVICE.ENABLED && v.DB.ENABLED && v.DB.PLC.ENABLED)
                   .Include(v => v.DEVICE.ROUTES)
                   .Include(v => v.DEVICE.PATHS)
                   .Include(v => v.DB.PLC).ToArray();
                    items.Select(v => v.Data()).ToArray();
                    LogicHandler.AllObjects.AddRange(items);

                    //var devices = items.GroupBy(v => v.DEVICE).Select(v => v.Key).ToArray();
                    var devices = db.Default.Set<WCS_DEVICE>().Include(v => v.ROUTES).Include(v => v.PATHS).ToArray();
                    LogicHandler.AllObjects.AddRange(devices);
                });

                var managerTypes = Assembly.GetExecutingAssembly().GetTypes().Where(v => v.IsSubclassOf(typeof(LogicHandler)) && !v.IsGenericType && !v.IsAbstract).ToArray();
                foreach (var type in managerTypes)
                {
                    var m = Activator.CreateInstance(type);
                    LogicHandler.AddManager(m as LogicHandler);
                }

                LogicHandler.StartAll();
                
                _logger.LogInformation("WCS启动成功");
            }
            catch (Exception ex)
            {
                _logger.LogError("WCS启动失败{0}", ex.Message);
            }
        }

        private bool Stoped = false;

        public override Task StopAsync(CancellationToken cancellationToken)
        {
            _logger.LogError("WCS关闭");
            LogicHandler.StopAll();
            //Uploader.Stop();
            return base.StopAsync(cancellationToken);
        }
    }
}