WCS-Pedestal/WCS.Core/LogicHandler.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using WCS.Entity;

namespace WCS.Core
{
    /// <summary>
    /// 逻辑处理器
    /// </summary>
    public abstract class LogicHandler
    {
        /// <summary>
        /// 停止
        /// </summary>
        protected bool Stoped = false;

        /// <summary>
        /// 描述
        /// </summary>
        protected string Description { get; private set; }

        /// <summary>
        /// 所有对象
        /// </summary>
        public static List<object> AllObjects = new List<object>();

        /// <summary>
        /// 所有处理器
        /// </summary>
        private static List<LogicHandler> Handlers = new List<LogicHandler>();

        /// <summary>
        /// 日志委托
        /// </summary>
        public static Action<string, string, string> DbLog;

        /// <summary>
        /// 逻辑处理器
        /// </summary>
        public LogicHandler()
        {
            var attr = this.GetType().GetCustomAttributes(false).OfType<DescriptionAttribute>().FirstOrDefault();
            if (attr != null)
                Description = attr.Description;
            else
                Description = this.GetType().Name;
        }

        /// <summary>
        /// 开始
        /// </summary>
        public abstract void Start();

        /// <summary>
        /// 是否并行
        /// </summary>
        public virtual bool ParallelRun
        {
            get
            {
                return false;
            }
        }

        /// <summary>
        /// 数据刷新时触发
        /// </summary>
        /// <param name="milliseconds">离上次触发的间隔时间（毫秒）</param>
        public abstract void Update(double milliseconds);

        /// <summary>
        /// 停止
        /// </summary>
        public void Stop()
        {
            Stoped = true;
        }

        /// <summary>
        /// 添加处理器
        /// </summary>
        /// <param name="handler">处理器</param>
        public static void AddManager(LogicHandler handler)
        {
            Handlers.Add(handler);
        }

        /// <summary>
        /// 启动所有的处理器
        /// </summary>
        public static void StartAll()
        {
            foreach (var h in Handlers)
            {
                h.Start();
            }
            var th = new Thread(new ThreadStart(Loop));
            th.IsBackground = true; //前台线程即主线程关闭，立即结束该线程
            th.Start();
        }

        /// <summary>
        /// 最后一次执行结束的时间
        /// </summary>
        private static DateTime last = DateTime.Now;

        /// <summary>
        ///逻辑耗时
        /// </summary>
        private static int logicTimes;

        public static DateTime Frame { get; private set; }

        /// <summary>
        /// 主循环体，用于PLC数据的读取与逻辑执行
        /// </summary>
        private static void Loop()
        {
            var arr = AllObjects.OfType<WCS_DEVICE>().Where(v => v.ENABLED).SelectMany(v => v.PROTOCOLS)
                .Where(v => v.ENABLED && v.DB.ENABLED && v.DB.PLC.ENABLED)
                .GroupBy(v => v.DB).Select(v => v.Key)
                .ToArray();

            while (true)
            {
                var dd = DateTime.Now;
                Frame = DateTime.Now;
                Parallel.ForEach(arr, db =>
                {
                    try
                    {
                        Ltc.SetChannel("刷新");
                        db.Ex().DataRefresh();
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("更新" + db.NAME + "数据失败:" + ex.Message);
                    }
                });
                var dbTimes = (DateTime.Now - dd).TotalMilliseconds;

                var total = (DateTime.Now - last).TotalMilliseconds;
                var s = (int)(600 - total);
                if (s > 0)
                    Thread.Sleep(s);
                total = (DateTime.Now - last).TotalMilliseconds;
                Console.ForegroundColor = ConsoleColor.Blue;
                //此处打印的logicTimes实际是上一个周期的业务处理时长
                Console.WriteLine("------刷新DB块数据耗时:" + ((int)dbTimes).ToString().PadRight(4, ' ') + "；业务逻辑耗时：" + ((int)logicTimes).ToString().PadRight(4, ' ') + "；周期总耗时" + ((int)total).ToString().PadRight(4, ' ') + "");
                Console.ResetColor();
                last = DateTime.Now;

                Parallel.ForEach(Handlers, m =>
                {
                    var dm = DateTime.Now;
                    try
                    {
                        m.Update(total);
                    }
                    catch (Exception ex)
                    {
                        //TODO:增加一个异常记录
                    }
                    var dm2 = (DateTime.Now - dm).TotalMilliseconds;
                });

                Configs.Publish();
                logicTimes = (int)(DateTime.Now - last).TotalMilliseconds;
            }
        }

        /// <summary>
        /// 停止所有的处理器
        /// </summary>
        public static void StopAll()
        {
            foreach (var h in Handlers)
            {
                try
                {
                    h.Stop();
                }
                catch { }
            }
        }
    }

    /// <summary>
    /// 逻辑处理器 泛型
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public abstract class LogicHandler<T> : LogicHandler where T : EntityEx<WCS_DEVICE>
    {
        /// <summary>
        /// 业务类集合
        /// </summary>
        protected List<WorkInfo<T>> Works = new List<WorkInfo<T>>();

        /// <summary>
        /// TODO:？
        /// </summary>
        private IEnumerable<T> _Objects = null;

        protected IEnumerable<T> Objects
        {
            get
            {
                if (_Objects == null)
                {
                    _Objects = AllObjects.OfType<WCS_DEVICE>().Where(v => SelectDevice(v)).Select(v => Activator.CreateInstance(typeof(T), v)).OfType<T>().ToArray();
                }
                return _Objects.Where(v => v.Entity.ENABLED && v.Entity.PROTOCOLS.All(d => d.ENABLED && d.DB.ENABLED && d.DB.PLC.ENABLED));
            }
        }

        private bool SelectDevice(WCS_DEVICE dev)
        {
            var typenames = typeof(T).GenericTypeArguments.Select(v => v.AssemblyQualifiedName).ToArray();
            var res = typenames.All(v => dev.PROTOCOLS.Any(d => d.DB.PROTOCOL == v));
            return res;
        }

        public LogicHandler()
        {
        }

        public void AddWork(Func<T, bool> condition, Action<T> work, bool parallel = false)
        {
            var title = work.Method.Name;
            var attr = work.Method.GetCustomAttributes(false).OfType<DescriptionAttribute>().FirstOrDefault();
            if (attr != null)
                title = attr.Description;
            var arr = Objects.Where(condition).ToArray();
            this.Works.Add(new WorkInfo<T> { Work = work, Params = arr, Title = title, Parallel = parallel });
        }

        public void AddWork(IEnumerable<T> arr, Action<T> work, bool parallel = false)
        {
            var title = work.Method.Name;
            var attr = work.Method.GetCustomAttributes(false).OfType<DescriptionAttribute>().FirstOrDefault();
            if (attr != null)
                title = attr.Description;

            this.Works.Add(new WorkInfo<T> { Work = work, Params = arr, Title = title, Parallel = parallel });
        }

        public override void Update(double milliseconds)
        {
            if (ParallelRun)
            {
                Parallel.ForEach(Works, w =>
                {
                    DoWork(w);
                });
            }
            else
            {
                foreach (var w in Works)
                {
                    DoWork(w);
                }
            }
        }

        protected virtual void DoWork(WorkInfo<T> 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<T> wi, T p)
        {
            var channel = Description + "." + wi.Title + "." + p.ToString();
            try
            {
                Ltc.SetChannel(channel);
                Ltc.Log("开始---------------------------------------");

                wi.Work(p);
            }
            catch (Exception ex)
            {
                Ltc.Log(ex.GetBaseException().Message);
                Log(wi, p, ex);
            }
            finally
            {
                Ltc.Log("结束\n");
            }
        }

        protected virtual void Log(WorkInfo<T> wi, T p, Exception ex)
        {
            try
            {
                var msg = Description + "--" + wi.Title + "--";
                if (p is IProtocol)
                {
                    msg += (p as IProtocol).PROTOCOL().DEVICE.CODE;
                }
                var con = ex.GetBaseException().Message.Split("|");

                msg = msg + "：" + con[0];
                //Console.WriteLine(msg);

                DbLog.Invoke(msg, con[1], con[2]);
            }
            catch (Exception ex2)
            {
            }
        }

        private static object lockobj = new object();

        protected void Log(string msg)
        {
            lock (lockobj)
            {
                try
                {
                    var str = "-----------" + DateTime.Now.ToString("yyyyMMdd HH:mm:ss:fff") + "-----------\r\n";
                    str += msg;
                    if (!Directory.Exists(logPath))
                        Directory.CreateDirectory(logPath);
                    var file = logPath + DateTime.Now.ToString("yyyyMMdd") + ".log";
                    var writer = File.AppendText(file);
                    writer.WriteLine(str);
                    writer.Flush();
                    writer.Close();
                }
                catch (Exception ex)
                {
                }
            }
        }

        /// <summary>
        /// 此方法不会被自动调用，请在Start方法中使用AddWork将其添加至工作队列
        /// </summary>
        /// <param name="dev"></param>
        [Description("执行")]
        protected abstract void Execute(T dev);
    }

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

        public WorkHandler()
        {
            var arr = Assembly.GetEntryAssembly().GetTypes().Where(v => v.IsSubclassOf(typeof(Work))).Where(v =>
            {
                var attr = v.GetCustomAttribute<WorkTitleAttribute>();
                if (attr == null)
                    return false;
                return attr.Handler == this.GetType();
            });
            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, w =>
                {
                    DoWork(w);
                });
            }
            else
            {
                foreach (var w in Works)
                {
                    DoWork(w);
                }
            }
        }

        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.ToString();
            try
            {
                Ltc.SetChannel(channel);
                Ltc.Log("开始---------------------------------------");
                wi.Work(p);
            }
            catch (Exception ex)
            {
                Ltc.Log(ex.GetBaseException().Message);
                Log(wi, p, ex);
                Configs.UploadException?.Invoke(p.ToString(), ex.GetBaseException().Message);
            }
            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");
            }
        }

        protected virtual void Log(WorkInfo wi, object p, Exception ex)
        {
            try
            {
                var msg = Description + "--" + wi.Title + "--";
                if (p is IProtocol)
                {
                    msg += (p as IProtocol).PROTOCOL().DEVICE.CODE;
                }
                var con = ex.GetBaseException().Message.Split("|");
                msg = msg + "：" + con[0];
                //Console.WriteLine(msg);

                DbLog.Invoke(msg, con[1], con[2]);
            }
            catch (Exception ex2)
            {
            }
        }

        private static object lockobj = new object();

        protected void Log(string msg)
        {
            lock (lockobj)
            {
                try
                {
                    var str = "-----------" + DateTime.Now.ToString("yyyyMMdd HH:mm:ss:fff") + "-----------\r\n";
                    str += msg;
                    if (!Directory.Exists(logPath))
                        Directory.CreateDirectory(logPath);
                    var file = logPath + DateTime.Now.ToString("yyyyMMdd") + ".log";
                    var writer = File.AppendText(file);
                    writer.WriteLine(str);
                    writer.Flush();
                    writer.Close();
                }
                catch (Exception ex)
                {
                }
            }
        }
    }

    public class WorkTitleAttribute : Attribute
    {
        public Type Handler { get; set; }
        public string Title { get; set; }
        public bool Parallel { get; set; }

        public WorkTitleAttribute(Type handler, string title, bool parallel = false)
        {
            this.Handler = handler;
            this.Title = title;
            this.Parallel = parallel;
        }
    }

    public abstract class Work
    {
        public abstract IEnumerable<Object> GetObjs();

        public abstract void Execute(object obj);
    }

    public abstract class Work<T> : Work
    {
        public override sealed void Execute(object obj)
        {
            Do((T)obj);
        }

        public override sealed IEnumerable<object> GetObjs()
        {
            return InitObjects().OfType<object>().ToArray();
        }

        protected abstract void Do(T obj);

        protected abstract bool SelectDevice(WCS_DEVICE dev);

        protected virtual IEnumerable<T> InitObjects()
        {
            var arr = Device.Where(v => v.ENABLED)
                     .Where(v => SelectDevice(v)).ToArray();
            var res = arr.Select(v => (T)Activator.CreateInstance(typeof(T), v));
            return res;
        }
    }

    public abstract class DeviceWork<T> : Work<T> where T : EntityEx<WCS_DEVICE>
    {
        private string[] typenames;

        public DeviceWork()
        {
            typenames = typeof(T).GenericTypeArguments.Select(v => v.AssemblyQualifiedName).ToArray();
        }

        protected abstract override void Do(T obj);

        protected override sealed IEnumerable<T> InitObjects()
        {
            var arr = Device.Where(v => v.ENABLED && v.PROTOCOLS.All(d => d.ENABLED && d.DB.ENABLED && d.DB.PLC.ENABLED))
                   .Where(v => typenames.All(d => v.PROTOCOLS.Any(e => e.DB.PROTOCOL == d)))
                   .Where(v => SelectDevice(v)).ToArray();
            var res = arr.Select(v => Activator.CreateInstance(typeof(T), v) as T);

            return res;
        }
    }
}