WcsFramework/WCS.Core/World.cs

using FreeRedis;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Xml.Schema; 

namespace WCS.Core
{
    /// <summary>
    /// 世界用来管理下属System的执行周期，此为默认世界。也可以通过继承此类创建多个不同世界，不同世界的执行周期相互独立，不受其它世界延迟干扰。
    /// </summary>
    [Description("默认世界")]
    public class World: DescriptionClass
    {
        [DllImport("winmm.dll", EntryPoint = "timeBeginPeriod")]
        public static extern uint MM_BeginPeriod(uint uMilliseconds);
        [DllImport("winmm.dll", EntryPoint = "timeEndPeriod")]
        public static extern uint MM_EndPeriod(uint uMilliseconds);

        #region Static
        static List<World> _Worlds;
        internal static List<World> Worlds
        {
            get
            {
                if (_Worlds == null)
                {
                    _Worlds = new List<World>();
                    _Worlds.Add(new World());//默认世界
                    var arr = Assembly.GetEntryAssembly().GetTypes().Where(v => typeof(World).IsAssignableFrom(v)).Select(v => Activator.CreateInstance(v)).OfType<World>().ToArray();//自定义世界
                    _Worlds.AddRange(arr);
                }
                return _Worlds;
            }
        }

         
        public static void StartAll()
        { 
            //MM_BeginPeriod(1);
            Worlds.ForEach(w => w.Init());
            foreach (World w in Worlds)
            {
                if (w.SystemTypes.Length == 0)
                    continue; 
                w.Start();
            }
            var arr = Worlds.SelectMany(v => v.SystemGroups).SelectMany(v => v.Value)
                .SelectMany(v => v.GetObjects().OfType<EntityEx<Device>>().Select(d => new { Sys = v, Obj = d }))
                .GroupBy(v => v.Obj.Entity.Code)
                .Select(v => new { Code = v.Key, Systems = v.Select(d => d.Sys.GetType().Name).ToArray(), Worlds = v.Select(d => d.Sys.World.GetType().Name).Distinct().ToArray() })
                .Where(v => v.Systems.Length > 1).ToArray();
            if (arr.Length > 0)
            {
                var msgs = arr.Select(v => $"设备{v.Code}同时存在于{v.Systems.Length}个系统:({string.Join(',', v.Systems)}),{v.Worlds.Length}个世界:({string.Join(',', v.Worlds)})中").ToArray();
                var str = string.Join('\n', msgs);
                Console.ForegroundColor = ConsoleColor.DarkYellow;
                Console.WriteLine(str);
                Console.ResetColor();
            }
        }



        public static void StopAll()
        {
            //MM_EndPeriod(1);
            foreach (World w in Worlds)
                w.Stop();
        }
        #endregion

        #region Dynamic
        public bool Stoped;
        Dictionary<Type, int> TypeOrder = new Dictionary<Type, int>();
        Dictionary<int, List<SystemBase>> SystemGroups = new Dictionary<int, List<SystemBase>>();
        protected Type[] SystemTypes;
          

        /// <summary>
        /// 周期最小间隔时间(毫秒)
        /// </summary>
        protected int Interval = 800; 
        public World()
        {
            SystemTypes = GetSystemTypes(); 
        }

        protected virtual Type[] GetSystemTypes()
        { 
            var sysTypes = Assembly.GetEntryAssembly().GetTypes()
                .Where(v => !v.IsAbstract)
                .Where(v => typeof(SystemBase).IsAssignableFrom(v))
                .Where(v =>
                {
                    var attr = v.GetCustomAttribute<BelongToAttribute>();
                    if (attr == null)
                        return GetType() == typeof(World);
                    if (attr.WorldType == this.GetType())
                        return true;
                    return false;
                }).ToArray();
            return sysTypes; 
        }


        public List<Device> Devices;
        

        /// <summary>
        /// 初始化，实例化世界下的所有系统
        /// </summary>
        public virtual void Init()
        {
            Ltc.SetChannel(new Channel { World = Description, Item = "初始化" });
            Ltc.ClearChannel();
            try
            {
                Devices = Protocols.Generate(this);
                foreach (var type in SystemTypes)
                {
                    Set(type, 0);
                }
                var arr = TypeOrder.OrderBy(v => v.Value).Select(v => v.Key).ToArray();
                var gs = TypeOrder.GroupBy(v => v.Value).OrderBy(v => v.Key).ToArray();
                for (int i = 0; i < gs.Length; i++)
                {
                    var g = gs[i];
                    var list = new List<SystemBase>();
                    var sysArr = g.Select(v => Activator.CreateInstance(v.Key)).OfType<SystemBase>().ToArray();
                    list.AddRange(sysArr);
                    SystemGroups.Add(i, list);
                }
            }
            catch (Exception ex)
            {
                Ltc.Log(ex.GetBaseException().Message, LogLevel.高, ErrorType.未知);
                throw;
            }
            finally 
            {
                Configs.OnLog?.Invoke(Ltc.GetLogInfo());
            }
        }

        int Set(Type type,int level)
        {
            if (!SystemTypes.Contains(type))
                throw new Exception($"OrderAttribute设置错误,与目标不属于同一世界。类型：{type}。");
            if (level > 10)
            { 
                throw new Exception($"OrderAttribute设置错误,导致死循环。类型：{type}。");
            }
            var attr = type.GetCustomAttribute<OrderAttribute>();
            if (attr != null)
            {
                level++;
                var num = Set(attr.SystemType, level);
                TypeOrder[type] = num + (int)attr.Order;
            }
            else
            {
                TypeOrder[type] = 0;
            }
            return TypeOrder[type];
        }

         /// <summary>
         /// 开启世界主循环
         /// </summary>
        public void Start()
        { 
            Stoped = false; 
            Task.Run(Loop);//不要使用Thread,可以使用ThreadPool
        }

        void Loop()
        { 
            var sw = new Stopwatch();
            while (!Stoped)
            {
                WorkTimes wt = new WorkTimes();
                wt.Key = this.GetType().Name;
                sw.Restart();
                BeforeUpdate();
                Update(wt.Items);
                AfterUpdate();
                sw.Stop();
                var workTimes = (int)sw.ElapsedMilliseconds;
                var ms = Interval - workTimes;
                sw.Start();
                if (ms > 0)
                {
                    Thread.Sleep(ms);//不要使用Task.Delay().Wait()      
                }
                else
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                }
                sw.Stop();
                var total = sw.ElapsedMilliseconds;
                wt.Total = total; 
                var aa = wt.GetInfo();
                Console.WriteLine(aa); 
                Console.ResetColor(); 
            } 
        }

        public void Stop()
        {
            Stoped = true;
        }

        void Update(List<WorkTimes> list)
        {
            var wt = new WorkTimes();
            wt.Key = "读取PLC数据";
            var sw=new Stopwatch();
            sw.Start();
            LoadPlcData(wt.Items);
            sw.Stop();
            wt.Total = sw.ElapsedMilliseconds;
            list.AddSafe(wt);

            wt = new WorkTimes();
            wt.Key = "系统业务";
            sw.Restart();
            DoLogics(wt.Items);
            sw.Stop();
            wt.Total = sw.ElapsedMilliseconds;
            list.AddSafe(wt); 
        }
         
        void LoadPlcData(List<WorkTimes> list)
        {
            var logs = new List<LogInfo>();
            Parallel.ForEach(this.GetDataBlocks(), db =>
            {
                var channel = new Channel
                {
                    World = GetType().Name,
                    System = "读取PLC",
                    Item = $"{db.Entity.PLCInfo.IP}_{db.Entity.No}"
                };
                var sw = new Stopwatch();
                sw.Start();
                try
                {
                    db.RefreshData();
                }
                catch (KnownException ex)
                {
                    logs.AddSafe(new LogInfo { Channel = channel, Message = $"{ex.GetBaseException().Message}", Level = ex.Level, Type = ErrorType.已知 });
                    this.Ex().Publish(channel, ex.GetBaseException().Message);
                }
                catch (Exception ex)
                {
                    logs.AddSafe(new LogInfo { Channel = channel, Message = $"{ex.GetBaseException().Message}", Level = LogLevel.高, Type = ErrorType.未知 });
                    this.Ex().Publish(channel, ex.GetBaseException().Message);
                }
                sw.Stop();
                list.AddSafe(new WorkTimes { Key = $"{db.Entity.PLCInfo.IP}/{db.Entity.No}", Total = sw.ElapsedMilliseconds }); 
            }); 
            Configs.OnLog?.Invoke(logs);
        }

        void DoLogics(List<WorkTimes> list)
        {   
            foreach(var group in SystemGroups)
            {
                var wt=new WorkTimes();
                wt.Key = $"组{group.Key}";
                var sw = new Stopwatch();
                sw.Restart(); 
                Parallel.ForEach(group.Value, sys =>
                {
                    var wt2=new WorkTimes();
                    wt2.Key = sys.GetType().Name;
                    var sw2 = new Stopwatch();
                    sw2.Start();
                    try
                    {
                        sys.Update(wt2.Items);
                    }catch (Exception ex)
                    {
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine(ex.GetBaseException().Message);
                        Console.ResetColor();
                    }
                    sw2.Stop();
                    wt2.Total = sw2.ElapsedMilliseconds;
                    list.AddSafe(wt2);
                }); 
                sw.Stop();  
                wt.Total= sw.ElapsedMilliseconds;
                //list.AddSafe(wt);
            } 
        }
         
        protected virtual void BeforeUpdate()
        { 
            
        }

        protected virtual void AfterUpdate()
        {

        }

        #endregion
         
        public T GetSystem<T>() where T : SystemBase
        {
            var sys = Systems.Where(v => v.GetType() == typeof(T)).FirstOrDefault() as T;
            if (sys == null)
                throw new Exception($"世界{GetType().Name}中不存在系统{typeof(T).Name}");
            return sys;
        }

        public SystemBase[] Systems
        {
            get {
                return SystemGroups.SelectMany(v => v.Value).ToArray();
            }
        }
        
    }


    public class WorldEx : EntityEx<World>
    { 
        RedisClient Redis = new RedisClient(Configs.DebugRedisUrl);
        List<string> ChannelList = new List<string>();
        DateTime SubTime = DateTime.Now;

        public WorldEx(World ent) : base(ent)
        {
            Redis.Subscribe("Login", (channel, msg) =>
            {
                lock (ChannelList)
                {
                    ChannelList.Clear();
                    ChannelList.AddSafe(msg.ToString().Split(','));
                }
                SubTime = DateTime.Now;
                Console.WriteLine($"调试工具正在使用中,已订阅:{msg}");
            });
        }

        public void Publish(Channel channel, string msg)
        {
            if ((DateTime.Now - SubTime).TotalSeconds > 20)
                return;

            var flag = false;
            lock (ChannelList)
            {
                flag=ChannelList.Any(v =>
                {
                    var b = Regex.Match(channel.ToString(), $"^{v.Replace("*", ".*")}$");
                    return b.Success;
                });
            }
            if (flag)
                Redis.Publish(channel.ToString(), msg);
        }
    }

    public class WorkTimes
    {
        public string Key { get; set; } = "";
        public long Total { get; set; } 
        public List<WorkTimes> Items { get; set; } = new List<WorkTimes>();

        public override string ToString()
        {
            return $"{Key},明细:{Items.Count},耗时:{Total}";
        }

        public string GetInfo()
        {
            var str = $"[{ToString()}]";
            if (Items.Count > 0)
                str += $" > {Items.OrderBy(v => v.Total).LastOrDefault()?.GetInfo()}";
            return str;
        }
    }

    public abstract class AttrClass<T> where T : Attribute
    {
        public T? Attr { get; private set; }
        public AttrClass()
        {
            Attr = GetType().GetCustomAttribute<T>();
        }
    }

    public abstract class DescriptionClass:AttrClass<DescriptionAttribute> 
    {
        public string Description
        {
            get 
            {
                if (Attr != null)
                    return Attr.Description;
                else
                    return GetType().Name;
            }
        }
    }
}