WCS_Pedestal/WCS.WorkEngineering/Handlers/WorkHandler.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using WCS.Core;
using WCS.Core.BaseExtensions;
using WCS.Core.DataTrans;
using WCS.Core.Helpers;
using WCS.Core.Log;
using WCS.Entity;

namespace WCS.Service.Handlers
{
    /// <summary>
    /// 工作处理器
    /// </summary>
    public abstract class WorkHandler : LogicHandler
    {
        /// <summary>
        /// 所有被申明的工作处理器
        /// </summary>
        protected List<WorkInfo> Works = new List<WorkInfo>();

        protected WorkHandler()
        {
            var a = ReflectionHelper.GetTypesByImplementInterface<Work>();
            //所有被声明的处理器
            var arr = ReflectionHelper.GetTypesByImplementInterface<Work>().Where(v =>
                {
                    var attr = v.GetCustomAttribute<WorkTitleAttribute>();
                    if (attr == null)
                        return false;
                    return attr.Handler == this.GetType();
                });
            //TODO:加一层关于仓库的管控，通过
            var works = arr.Select(v => Activator.CreateInstance(v) as Work).Select(v =>
            {
                var attr = v.GetType().GetCustomAttribute<WorkTitleAttribute>();
                return new WorkInfo { Params = v.GetObjs(), Work = v.Execute, Title = attr.Title, Parallel = attr.Parallel };
            }).ToArray();
            Works.AddRange(works);
        }

        public override sealed void Start()
        {
        }

        /// <summary>
        /// 执行处理中心--中心级
        /// </summary>
        /// <param name="milliseconds"></param>
        public override void Update(double milliseconds)
        {
            if (ParallelRun)
            {
                Parallel.ForEach(Works, DoWork);
            }
            else
            {
                foreach (var w in Works)
                {
                    DoWork(w);
                }
            }
        }

        /// <summary>
        /// 执行级
        /// </summary>
        /// <param name="work"></param>
        protected virtual void DoWork(WorkInfo work)
        {
            if (work.Parallel)
            {
                Parallel.ForEach(work.Params, p =>
                {
                    Do(work, p);
                });
            }
            else
            {
                foreach (var p in work.Params)
                {
                    Do(work, p);
                }
            }
        }

        protected virtual void Do(WorkInfo wi, object p)
        {
            var dt = DateTime.Now;
            var channel = Description + "." + wi.Title + "." + p;
            var code = "";
            if (p is IProtocol protocol)
            {
                code = protocol.PROTOCOL().DEVICE.CODE;
            }
            try
            {
                Ltc.SetChannel(channel);
                Ltc.Log("开始---------------------------------------");
                wi.Work(p);
            }
            //下述日志处理方案可根据项目情况自定义
            //DoException为基础条件未满足，仅作记录文本日志
            catch (DoException ex)
            {
                InfoLog.INFO_INFO($"[{code}]--{ex.Message}");
            }
            //WarnException进阶条件未满足，添加数据库，记录文本日志、数据库，上抛WCS，上抛WMS
            catch (WarnException ex)
            {
                if (ex.RECORDTXT)
                {
                    InfoLog.INFO_WARN($"[{code}]--{ex.Message}");
                }
                if (ex.RECORDDB)
                {
                    Helpers.LogHelper.AddWCS_EXCEPTION(ex.Message, code, WCS_EXCEPTIONTYPE.无.ToString());
                }
                if (ex.REPORTWCS)
                {
                    Ltc.Log(ex.GetBaseException().Message);
                }
                if (ex.REPORTWMS)
                {
                    Configs.UploadException?.Invoke(p.ToString(), ex.GetBaseException().Message);
                }
            }
            //未知异常，仅记录文本日志，需定期排查该文件，检查系统是否有未知异常，并处理
            catch (Exception ex)
            {
                InfoLog.INFO_ERROR($"[{code}]--{ex.Message}--{ex.StackTrace}");
            }
            finally
            {
                var dd = (DateTime.Now - dt).TotalMilliseconds;
                if (dd > 500)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine(channel + "耗时" + dd);
                    Console.ResetColor();
                }

                if (dd > 10000)
                    Configs.UploadException?.Invoke(p.ToString(), wi.Title + "执行耗时" + Math.Floor(dd / 1000) + "秒");
                Ltc.Log("结束\n");
            }
        }
    }
}