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

using DBHelper;
using FreeRedis;
using MessagePack;
using MessagePack.Resolvers;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Linq.Dynamic.Core;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using WCS.Core;
using WCS.Entity;
using WCS.Entity.Protocol;

namespace WCS.Service
{
    public class ProtocolProxy : ProtocolProxyBase
    {
        MethodInfo SetMethod;
        public ProtocolProxy(string id, WCS_DATABLOCK db, ushort start, WCS_DEVICEPROTOCOL protocol) : base(id, db, start, protocol)
        {
            SetMethod = typeof(DbContext).GetMethod("Set", new Type[] { }).MakeGenericMethod(this.ProtocolDataType); 
        }

        static ConcurrentDictionary<Type, object[]> LastDatas = new ConcurrentDictionary<Type, object[]>();

        protected override WCS_PROTOCOLDATA GetLastData(DB db)
        {
            if (!LastDatas.ContainsKey(this.ProtocolDataType))
            {

                dynamic q = SetMethod.Invoke(db.Default, null);
                try
                {
                    q = DynamicQueryableExtensions.Where(q, "ISLAST==@0", true);
                    q = DynamicQueryableExtensions.OrderBy(q, "ID");
                    q = DynamicQueryableExtensions.Select(q, "new(it.DEVICE.CODE as Code,it as Data)");
                    var arr = Enumerable.ToArray(q);
                    LastDatas[this.ProtocolDataType] = arr;
                }
                catch (Exception ex)
                {
                    throw;
                }

            }
            dynamic datas = LastDatas[this.ProtocolDataType];
            var list = new List<WCS_PROTOCOLDATA>();
            foreach (var data in datas)
            {
                if (data.Code == PROTOCOL.DEVICE.CODE)
                    list.Add(data.Data);
            }

            if (list.Count > 1)
            {

                for (int i = 0; i < list.Count - 1; i++)
                {
                    var obj = list[i];
                    db.Default.Attach(obj);
                    obj.ISLAST = false;
                }
                db.Default.SaveChanges();

            }
            var res = Enumerable.LastOrDefault(list);
            return res;


        }

        static int total;
        protected override WCS_PROTOCOLDATA SaveNewData(DB db, WCS_PROTOCOLDATA last, WCS_PROTOCOLDATA newobj, string user)
        {
            total++;

            if (last != null)
            {
                db.Default.Attach(last);
                last.ISLAST = false;
            }

            db.Default.Attach(PROTOCOL.DEVICE);

            newobj.DEVICE = PROTOCOL.DEVICE;
            newobj.ISLAST = true;
            newobj.UPDATETIME = DateTime.Now;
            newobj.UPDATEUSER = user;
            newobj.FRAME = LogicHandler.Frame;
            db.Default.Add(newobj);
            db.Default.SaveChanges();
            return newobj;

        }


        //static ConcurrentQueue<PackInfo> Packs = new ConcurrentQueue<PackInfo>();
        static Dictionary<string, Playerback> Clients = new Dictionary<string, Playerback>();
        static RedisClient Redis;
        public static RedisClient YGWCS150Redis;
        static ProtocolProxy()
        {
            MessagePackSerializer.DefaultOptions = StandardResolver.Options.WithCompression(MessagePackCompression.Lz4Block);
            Redis = new RedisClient("212.64.66.35,database=11");
            Redis.Serialize = obj =>
            {
                var bytes = MessagePackSerializer.Serialize(obj); 
                return bytes;
            };
            Redis.DeserializeRaw = (bytes, type) =>
            {
                var obj = MessagePackSerializer.Deserialize(type, bytes);
                return obj;
            };
            YGWCS150Redis = new RedisClient("192.168.249.120,password=123456,database=10");
            YGWCS150Redis.Serialize = obj =>
            {
                var bytes = MessagePackSerializer.Serialize(obj);
                return bytes;
            };
            YGWCS150Redis.DeserializeRaw = (bytes, type) =>
            {
                var obj = MessagePackSerializer.Deserialize(type, bytes);
                return obj;
            };
        }

        //static ConcurrentDictionary<string, DeviceData> Datas = new ConcurrentDictionary<string, DeviceData>();
        public override void Publish(string code,WCS_PROTOCOLDATA obj)
        { 
            try
            {
                var Datas = AllDatas;
                if (code.StartsWith("SC"))
                {
                    if (!Datas.ContainsKey(code))
                        Datas[code] = new SCData { Code=code }; 
                }
                else if (code.StartsWith("RGV"))
                {
                    if (!Datas.ContainsKey(code))
                        Datas[code] = new RGVData { Code = code };
                } 
                else if (code == "Robot")
                {
                    if (!Datas.ContainsKey(code))
                        Datas[code] = new RobotData { Code = code };
                }
                else if (code.Length == 4)
                {
                    if (!Datas.ContainsKey(code))
                        Datas[code] = new StationData { Code = code };
                }
                if (Datas.ContainsKey(code))
                {
                    var data = Datas[code];
                    data.Frame = LogicHandler.Frame;
                    var p = data.GetType().GetProperties().Where(v => v.PropertyType == obj.GetType()).FirstOrDefault();
                    if (p == null)
                    {
                        Console.WriteLine("类型" + data.GetType().Name + "不包含类型为" + obj.GetType().Name + "的属性");
                    }
                    else 
                    {
                        p.SetValue(data, obj);
                    }
                }

                //var type = obj.GetType();
                ////if (type == typeof(WCS_STATION521))
                //{
                //    var key = type.Name + "," + code;
                //    var json = JsonConvert.SerializeObject(obj);
                //    Redis.Set(key, json);
                //    Redis.Publish("View," + key, json);
                //}
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

        static Dictionary<string, string> LastInfo = new Dictionary<string, string>();

        public static ConcurrentDictionary<string, DeviceData> AllDatas = new ConcurrentDictionary<string, DeviceData>();
        public static void Do()
        {
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine($"更改:{total}");
            Console.ResetColor();
            total = 0;
            try
            {
                var gs = AllDatas.GroupBy(v => v.Value.GetType());

                //Parallel.ForEach(gs, g =>
                //{
                //    var value = g.Select(v => v.Value).ToArray();
                //    var etype = g.Key;
                //    var type = typeof(DeviceDataCollection<>).MakeGenericType(etype);
                //    var coll = Activator.CreateInstance(type, LogicHandler.Frame, value);
                //    Redis.Set(etype.Name, coll);
                //});
                DeviceDataPack pack = new DeviceDataPack();
                pack.Frame = LogicHandler.Frame;
                foreach (var g in gs)
                {
                    var value = g.Select(v => v.Value).ToArray();
                    var etype = g.Key;
                    var type = typeof(DeviceDataCollection<>).MakeGenericType(etype);
                    var coll = Activator.CreateInstance(type, LogicHandler.Frame, value);
                    var p = pack.GetType().GetProperties().Where(v => v.PropertyType == type).First();
                    p.SetValue(pack, coll); 
                }
                 

                var sw = new Stopwatch();
                sw.Start();
                Redis.Set(nameof(DeviceDataPack), pack);
                YGWCS150Redis.Set(nameof(DeviceDataPack), pack);
                sw.Stop();
                Console.ForegroundColor = ConsoleColor.Blue;
                Console.WriteLine($"Redis耗时{sw.ElapsedMilliseconds}");
                Console.ResetColor();

                Redis.RPush("Packs", pack);
                YGWCS150Redis.RPush("Packs", pack);

                var len = Redis.LLen("Packs");
                var len1 = YGWCS150Redis.LLen("Packs");
                if (len > 150000)
                {
                    Redis.LTrim("Packs", 20000, len);
                }
                if (len1 > 150000)
                {
                    YGWCS150Redis.LTrim("Packs", 20000, len);
                }


                foreach (var data in AllDatas)
                {
                   // LastInfo[data.Key] = data.Value.Info;
                    data.Value.Info = "";
                    if (data.Value is ProdLineData)
                    {
                        var pld = data.Value as ProdLineData;
                        pld.TaskList.Clear();
                        pld.Frame = LogicHandler.Frame;
                        pld.Code = data.Key;
                    }
                }
            }
            catch (Exception ex)
            {

            }
            //Datas.Clear();
        }
         
    }

    public class PackInfo
    {
        public DateTime Frame { get; set; }

        public byte[] Data { get; set; }
    }
}