消息日志信息修改

преди 2 години · 924e847024
--- a/HKCardIN/HKCardIN.csproj
+++ b/HKCardIN/HKCardIN.csproj
@@ -30,6 +30,7 @@
    <None Remove="HKResouces\背景.jpg" />
  </ItemGroup>
  <ItemGroup>
    <PackageReference Include="BPA.Helper" Version="1.0.25" />
    <PackageReference Include="HandyControls" Version="3.4.1" />
    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="6.0.0" />
    <PackageReference Include="Microsoft.Extensions.Configuration" Version="6.0.1" />
--- a/HKCardIN/Helper/HKHelper.cs
+++ b/HKCardIN/Helper/HKHelper.cs
@@ -1,4 +1,5 @@
 using System;
 using BPA.Helper;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.InteropServices;
--- a/HKCardIN/Helper/ThreadManage.cs
+++ b/HKCardIN/Helper/ThreadManage.cs
@@ -1,445 +1,445 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;

 namespace HKCardIN.Helper
 {
    public class Singleton<T> where T : new()
    {
        private static object _async = new object();

        private static T _instance;

        static readonly Lazy<T> instance = new();
        /// <summary>
        /// 获取实例
        /// </summary>
        /// <returns></returns>
        public static T GetInstance()
        {
            return instance.Value;
        }
    }
    public class ThreadManage : Singleton<ThreadManage>
    {
        string guid = "871d7e28-c413-4675-8d28-64e4dca4c2d3-";
        private static readonly object _lock = new object();
        StringBuilder callbackKey = new StringBuilder();
        List<string> keys = new List<string>();
        ConcurrentDictionary<string, Task> Threads = new ConcurrentDictionary<string, Task>();
        ConcurrentDictionary<string, CancellationTokenSource> CancellationTokenSources = new ConcurrentDictionary<string, CancellationTokenSource>();

        /// <summary>
        /// 停止指定任务
        /// </summary>
        /// <param name="key">任务名</param>
        /// <param name="ExitCallback">任务结束的回调</param>
        public void StopTask(string key, Action ExitCallback = null)
        {
            if (CancellationTokenSources.ContainsKey(guid + key))
            {
                CancellationTokenSources[guid + key]?.Cancel();
                ActionManage.GetInstance.Register(ExitCallback, guid + key);
            }
            else
            {
                if (ExitCallback != null) ExitCallback();
            }
        }

        /// <summary>
        /// 长任务，带 while true 的循环
        /// </summary>
        /// <param name="action"></param>
        /// <param name="key"></param>
        public void StartLong(Action action, string key, bool IsRestart = false, Action RunComplete = null)
        {
            CancellationTokenSources.TryAdd(guid + key, new CancellationTokenSource());
            bool result = Threads.TryAdd(guid + key, Task.Factory.StartNew(new Action(() =>
            {
                Thread.CurrentThread.Name = key;
            ReStart:
                try
                {
                    while (!CancellationTokenSources[guid + key].IsCancellationRequested)
                    {
                        if (action != null) action();
                    }
                }
                catch (Exception ex)
                {
                    if (IsRestart)
                    {
                        Thread.Sleep(2000);
                        goto ReStart;
                    }
                    else
                    {
                        CancellationTokenSources.TryRemove(guid + key, out CancellationTokenSource temp);
                        Threads.TryRemove(guid + key, out Task temp1);
                    }
                }
            }), CancellationTokenSources[guid + key].Token).ContinueWith(new Action<Task, object>((t, o) =>
            {
                ThreadStatus(t, o.ToString());
                if (RunComplete != null) RunComplete();
            }), guid + key));
        }


        /// <summary>
        /// 不带 while true 的循环任务
        /// </summary>
        /// <param name="action"></param>
        /// <param name="key"></param>
        public void Start(Action action, string key, bool isRestart = false)
        {
            CancellationTokenSources.TryAdd(guid + key, new CancellationTokenSource());
            bool result = Threads.TryAdd(guid + key, Task.Factory.StartNew(new Action(() =>
            {
                Thread.CurrentThread.Name = key;
                try
                {
                    if (action != null) action();
                }
                catch (Exception ex)
                {
                    if (isRestart)
                    {
                        CancellationTokenSources.TryRemove(guid + key, out CancellationTokenSource item1);
                        Threads.TryRemove(guid + key, out Task item2);
                        Start(action, key, isRestart);
                    }
                    else
                    {
                    }
                }
            }), CancellationTokenSources[guid + key].Token).ContinueWith(new Action<Task, object>((t, o) =>
            {
                ThreadStatus(t, o.ToString());
            }), guid + key));
        }

        private void ThreadStatus(Task task, string key)
        {
            bool IsRemove = false;
            string name = key.Substring(key.LastIndexOf('-') + 1);
            switch (task.Status)
            {
                case TaskStatus.RanToCompletion:
                    IsRemove = true;
                    break;
                case TaskStatus.Faulted:
                    IsRemove = true;
                    break;
                case TaskStatus.Canceled:
                    IsRemove = true;
                    break;
                default:
                    break;
            }

            if (IsRemove)
            {
                if (Threads.ContainsKey(key))
                    Threads.TryRemove(key, out Task t);
                if (CancellationTokenSources.ContainsKey(key))
                    CancellationTokenSources.TryRemove(key, out CancellationTokenSource cts);
                ActionManage.GetInstance.Send(key);
            }
        }

        /// <summary>
        /// 释放所有线程资源
        /// </summary>
        public void Dispose()
        {
            for (int i = 0; i < CancellationTokenSources.Count; i++)
            {
                CancellationTokenSources.ElementAt(i).Value.Cancel();
            }
        }

        /// <summary>
        /// 判断指定线程是否完成
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool IsComplete(string key)
        {
            if (Threads.ContainsKey(guid + key)) return Threads[guid + key].IsCompleted;
            return false;
        }

    }
    internal class Delegation
    {
        /// <summary>
        /// 带参数的委托
        /// </summary>
        public Action<object> ActionPar { get; set; }
        /// <summary>
        /// 带参数的委托
        /// </summary>
        public Action<object[]> ActionPars { get; set; }
        /// <summary>
        /// 无参数的委托
        /// </summary>
        public Action ActionBus { get; set; }
        /// <summary>
        /// 有返回值的委托
        /// </summary>
        public Func<object> FuncObj { get; set; }
        /// <summary>
        /// 有返回值，有参数的委托
        /// </summary>
        public Func<object, object> FuncPar { get; set; }
    }
    public class ActionManage
    {

        private volatile static ActionManage _Instance;
        public static ActionManage GetInstance => _Instance ?? (_Instance = new ActionManage());
        private ActionManage() { }

        //private static ConcurrentDictionary<string, delegate> actions = new ConcurrentDictionary<string, delegate>();
        private static ConcurrentDictionary<string, Delegation> actions = new ConcurrentDictionary<string, Delegation>();

        static readonly object SendLock = new object();
        static readonly object SendParLock = new object();
        static readonly object RegisterLock = new object();

        /// <summary>
        /// 注销委托
        /// </summary>
        /// <param name="key"></param>
        public void CancelRegister(string key)
        {
            if (actions.ContainsKey(key))
                actions.TryRemove(key, out Delegation t);
        }

        /// <summary>
        /// 执行注册过的委托
        /// </summary>
        /// <param name="key">注册委托的key</param>
        /// <param name="par">委托参数</param>
        /// <param name="Callback">委托回调</param>
        public void Send(string key, object par, Action Callback = null)
        {
            lock (SendLock)
                if (actions.ContainsKey(key)) actions[key].ActionPar.Invoke(par, Callback);
        }

        /// <summary>
        /// 执行注册过的委托
        /// </summary>
        /// <param name="key">注册委托的key</param>
        /// <param name="par">委托参数</param>
        /// <param name="Callback">委托回调</param>
        public void Send(string key, object[] par, Action Callback = null)
        {
            lock (SendLock)
                if (actions.ContainsKey(key)) actions[key].ActionPars.Invokes(par, Callback);
        }

        /// <summary>
        /// 执行注册过的委托
        /// </summary>
        /// <param name="key">注册委托的key</param>
        /// <param name="Callback">委托回调</param>
        public void Send(string key, Action Callback = null)
        {
            lock (SendLock)
                if (actions.ContainsKey(key)) actions[key].ActionBus?.Invoke(Callback);
        }

        public object SendResult(string key, object par = null)
        {
            lock (SendLock)
                if (actions.ContainsKey(key))
                    if (par == null)
                    {
                        return actions[key].FuncObj?.Invoke();
                    }
                    else
                    {
                        return actions[key].FuncPar?.Invoke(par);
                    }
            return default;
        }

        public void Register<T>(T action, string key)
        {
            lock (RegisterLock)
            {
                if (action != null)
                {
                    if (!actions.ContainsKey(key))
                    {
                        if (action is Action actionBus)
                            actions.TryAdd(key, new Delegation() { ActionBus = actionBus });

                        if (action is Action<object> actionObj)
                            actions.TryAdd(key, new Delegation() { ActionPar = actionObj });

                        if (action is Action<object[]> actionObjs)
                            actions.TryAdd(key, new Delegation() { ActionPars = actionObjs });

                        if (action is Func<object> funcObj)
                            actions.TryAdd(key, new Delegation() { FuncObj = funcObj });

                        if (action is Func<object, object> puncPar)
                            actions.TryAdd(key, new Delegation() { FuncPar = puncPar });
                    }
                }
            }

        }

    }
    public static class ExpandMethod
    {
        /// <summary>
        /// 获取布尔数组指定值得索引
        /// </summary>
        /// <param name="obj">要获取索引的数组</param>
        /// <param name="value">要获取索引的值</param>
        /// <returns></returns>
        public static int GetIndex(this bool[] obj, bool value)
        {
            if (obj == null) return -1;
            return Array.FindIndex(obj, p => p == value);
        }

        /// <summary>
        /// 获取字符串数组指定值得索引
        /// </summary>
        /// <param name="obj">要获取索引的数组</param>
        /// <param name="value">要获取索引的值</param>
        /// <returns></returns>
        public static int GetIndex(this string[] obj, string value)
        {
            if (obj == null || value == null) return -1;
            return Array.FindIndex(obj, p => p == value && p.Length > 0);
        }

        /// <summary>
        /// 委托回调
        /// </summary>
        /// <param name="action">要执行的委托</param>
        /// <param name="callback">委托回调</param>
        public static void Invoke(this Action action, Action callback)
        {
            action?.Invoke();
            callback?.Invoke();
        }

        /// <summary>
        /// 委托回调
        /// </summary>
        /// <param name="action">要执行的委托</param>
        /// <param name="par">要执行的委托的参数</param>
        /// <param name="callback">委托回调</param>
        public static void Invoke(this Action<object> action, object par, Action callback)
        {
            action?.Invoke(par);
            callback?.Invoke();
        }

        public static void Invokes(this Action<object[]> action, object[] par, Action callback)
        {
            action?.Invoke(par);
            callback?.Invoke();
        }


        /// <summary>
        /// 字节数组转换成32位整数
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public static int BytesToInt(this byte[] bytes)
        {
            if (bytes.Length > 4) return -1;
            int ReturnVlaue = 0;
            for (int i = 0; i < bytes.Length; i++)
            {
                ReturnVlaue += (int)(bytes[i] << (i * 8));
            }
            return ReturnVlaue;
        }

        /// <summary>
        /// 字节数组转换成 ushort 数组
        /// </summary>
        /// <param name="bytes">要转换的字节数组</param>
        /// <param name="reverse">字节高度顺序控制</param>
        /// <returns></returns>
        public static ushort[] BytesToUshorts(this byte[] bytes, bool reverse = false)
        {
            int len = bytes.Length;

            byte[] srcPlus = new byte[len + 1];
            bytes.CopyTo(srcPlus, 0);
            int count = len >> 1;

            if (len % 2 != 0)
            {
                count += 1;
            }

            ushort[] dest = new ushort[count];
            if (reverse)
            {
                for (int i = 0; i < count; i++)
                {
                    dest[i] = (ushort)(srcPlus[i * 2] << 8 | srcPlus[2 * i + 1] & 0xff);
                }
            }
            else
            {
                for (int i = 0; i < count; i++)
                {
                    dest[i] = (ushort)(srcPlus[i * 2] & 0xff | srcPlus[2 * i + 1] << 8);
                }
            }

            return dest;
        }

        /// <summary>
        /// ushort 数组转换成字节数组
        /// </summary>
        /// <param name="src">需要转换的 ushort数组</param>
        /// <param name="reverse">高低字节的设置</param>
        /// <returns></returns>
        public static byte[] UshortsToBytes(this ushort[] src, bool reverse = false)
        {

            int count = src.Length;
            byte[] dest = new byte[count << 1];
            if (reverse)
            {
                for (int i = 0; i < count; i++)
                {
                    dest[i * 2] = (byte)(src[i] >> 8);
                    dest[i * 2 + 1] = (byte)(src[i] >> 0);
                }
            }
            else
            {
                for (int i = 0; i < count; i++)
                {
                    dest[i * 2] = (byte)(src[i] >> 0);
                    dest[i * 2 + 1] = (byte)(src[i] >> 8);
                }
            }
            return dest;
        }
    }
 }
 //using System;
 //using System.Collections.Concurrent;
 //using System.Collections.Generic;
 //using System.Linq;
 //using System.Text;
 //using System.Threading;
 //using System.Threading.Tasks;

 //namespace HKCardIN.Helper
 //{
 //    public class Singleton<T> where T : new()
 //    {
 //        private static object _async = new object();

 //        private static T _instance;

 //        static readonly Lazy<T> instance = new();
 //        /// <summary>
 //        /// 获取实例
 //        /// </summary>
 //        /// <returns></returns>
 //        public static T GetInstance()
 //        {
 //            return instance.Value;
 //        }
 //    }
 //    public class ThreadManage : Singleton<ThreadManage>
 //    {
 //        string guid = "871d7e28-c413-4675-8d28-64e4dca4c2d3-";
 //        private static readonly object _lock = new object();
 //        StringBuilder callbackKey = new StringBuilder();
 //        List<string> keys = new List<string>();
 //        ConcurrentDictionary<string, Task> Threads = new ConcurrentDictionary<string, Task>();
 //        ConcurrentDictionary<string, CancellationTokenSource> CancellationTokenSources = new ConcurrentDictionary<string, CancellationTokenSource>();

 //        /// <summary>
 //        /// 停止指定任务
 //        /// </summary>
 //        /// <param name="key">任务名</param>
 //        /// <param name="ExitCallback">任务结束的回调</param>
 //        public void StopTask(string key, Action ExitCallback = null)
 //        {
 //            if (CancellationTokenSources.ContainsKey(guid + key))
 //            {
 //                CancellationTokenSources[guid + key]?.Cancel();
 //                ActionManage.GetInstance.Register(ExitCallback, guid + key);
 //            }
 //            else
 //            {
 //                if (ExitCallback != null) ExitCallback();
 //            }
 //        }

 //        /// <summary>
 //        /// 长任务，带 while true 的循环
 //        /// </summary>
 //        /// <param name="action"></param>
 //        /// <param name="key"></param>
 //        public void StartLong(Action action, string key, bool IsRestart = false, Action RunComplete = null)
 //        {
 //            CancellationTokenSources.TryAdd(guid + key, new CancellationTokenSource());
 //            bool result = Threads.TryAdd(guid + key, Task.Factory.StartNew(new Action(() =>
 //            {
 //                Thread.CurrentThread.Name = key;
 //            ReStart:
 //                try
 //                {
 //                    while (!CancellationTokenSources[guid + key].IsCancellationRequested)
 //                    {
 //                        if (action != null) action();
 //                    }
 //                }
 //                catch (Exception ex)
 //                {
 //                    if (IsRestart)
 //                    {
 //                        Thread.Sleep(2000);
 //                        goto ReStart;
 //                    }
 //                    else
 //                    {
 //                        CancellationTokenSources.TryRemove(guid + key, out CancellationTokenSource temp);
 //                        Threads.TryRemove(guid + key, out Task temp1);
 //                    }
 //                }
 //            }), CancellationTokenSources[guid + key].Token).ContinueWith(new Action<Task, object>((t, o) =>
 //            {
 //                ThreadStatus(t, o.ToString());
 //                if (RunComplete != null) RunComplete();
 //            }), guid + key));
 //        }


 //        /// <summary>
 //        /// 不带 while true 的循环任务
 //        /// </summary>
 //        /// <param name="action"></param>
 //        /// <param name="key"></param>
 //        public void Start(Action action, string key, bool isRestart = false)
 //        {
 //            CancellationTokenSources.TryAdd(guid + key, new CancellationTokenSource());
 //            bool result = Threads.TryAdd(guid + key, Task.Factory.StartNew(new Action(() =>
 //            {
 //                Thread.CurrentThread.Name = key;
 //                try
 //                {
 //                    if (action != null) action();
 //                }
 //                catch (Exception ex)
 //                {
 //                    if (isRestart)
 //                    {
 //                        CancellationTokenSources.TryRemove(guid + key, out CancellationTokenSource item1);
 //                        Threads.TryRemove(guid + key, out Task item2);
 //                        Start(action, key, isRestart);
 //                    }
 //                    else
 //                    {
 //                    }
 //                }
 //            }), CancellationTokenSources[guid + key].Token).ContinueWith(new Action<Task, object>((t, o) =>
 //            {
 //                ThreadStatus(t, o.ToString());
 //            }), guid + key));
 //        }

 //        private void ThreadStatus(Task task, string key)
 //        {
 //            bool IsRemove = false;
 //            string name = key.Substring(key.LastIndexOf('-') + 1);
 //            switch (task.Status)
 //            {
 //                case TaskStatus.RanToCompletion:
 //                    IsRemove = true;
 //                    break;
 //                case TaskStatus.Faulted:
 //                    IsRemove = true;
 //                    break;
 //                case TaskStatus.Canceled:
 //                    IsRemove = true;
 //                    break;
 //                default:
 //                    break;
 //            }

 //            if (IsRemove)
 //            {
 //                if (Threads.ContainsKey(key))
 //                    Threads.TryRemove(key, out Task t);
 //                if (CancellationTokenSources.ContainsKey(key))
 //                    CancellationTokenSources.TryRemove(key, out CancellationTokenSource cts);
 //                ActionManage.GetInstance.Send(key);
 //            }
 //        }

 //        /// <summary>
 //        /// 释放所有线程资源
 //        /// </summary>
 //        public void Dispose()
 //        {
 //            for (int i = 0; i < CancellationTokenSources.Count; i++)
 //            {
 //                CancellationTokenSources.ElementAt(i).Value.Cancel();
 //            }
 //        }

 //        /// <summary>
 //        /// 判断指定线程是否完成
 //        /// </summary>
 //        /// <param name="key"></param>
 //        /// <returns></returns>
 //        public bool IsComplete(string key)
 //        {
 //            if (Threads.ContainsKey(guid + key)) return Threads[guid + key].IsCompleted;
 //            return false;
 //        }

 //    }
 //    internal class Delegation
 //    {
 //        /// <summary>
 //        /// 带参数的委托
 //        /// </summary>
 //        public Action<object> ActionPar { get; set; }
 //        /// <summary>
 //        /// 带参数的委托
 //        /// </summary>
 //        public Action<object[]> ActionPars { get; set; }
 //        /// <summary>
 //        /// 无参数的委托
 //        /// </summary>
 //        public Action ActionBus { get; set; }
 //        /// <summary>
 //        /// 有返回值的委托
 //        /// </summary>
 //        public Func<object> FuncObj { get; set; }
 //        /// <summary>
 //        /// 有返回值，有参数的委托
 //        /// </summary>
 //        public Func<object, object> FuncPar { get; set; }
 //    }
 //    public class ActionManage
 //    {

 //        private volatile static ActionManage _Instance;
 //        public static ActionManage GetInstance => _Instance ?? (_Instance = new ActionManage());
 //        private ActionManage() { }

 //        //private static ConcurrentDictionary<string, delegate> actions = new ConcurrentDictionary<string, delegate>();
 //        private static ConcurrentDictionary<string, Delegation> actions = new ConcurrentDictionary<string, Delegation>();

 //        static readonly object SendLock = new object();
 //        static readonly object SendParLock = new object();
 //        static readonly object RegisterLock = new object();

 //        /// <summary>
 //        /// 注销委托
 //        /// </summary>
 //        /// <param name="key"></param>
 //        public void CancelRegister(string key)
 //        {
 //            if (actions.ContainsKey(key))
 //                actions.TryRemove(key, out Delegation t);
 //        }

 //        /// <summary>
 //        /// 执行注册过的委托
 //        /// </summary>
 //        /// <param name="key">注册委托的key</param>
 //        /// <param name="par">委托参数</param>
 //        /// <param name="Callback">委托回调</param>
 //        public void Send(string key, object par, Action Callback = null)
 //        {
 //            lock (SendLock)
 //                if (actions.ContainsKey(key)) actions[key].ActionPar.Invoke(par, Callback);
 //        }

 //        /// <summary>
 //        /// 执行注册过的委托
 //        /// </summary>
 //        /// <param name="key">注册委托的key</param>
 //        /// <param name="par">委托参数</param>
 //        /// <param name="Callback">委托回调</param>
 //        public void Send(string key, object[] par, Action Callback = null)
 //        {
 //            lock (SendLock)
 //                if (actions.ContainsKey(key)) actions[key].ActionPars.Invokes(par, Callback);
 //        }

 //        /// <summary>
 //        /// 执行注册过的委托
 //        /// </summary>
 //        /// <param name="key">注册委托的key</param>
 //        /// <param name="Callback">委托回调</param>
 //        public void Send(string key, Action Callback = null)
 //        {
 //            lock (SendLock)
 //                if (actions.ContainsKey(key)) actions[key].ActionBus?.Invoke(Callback);
 //        }

 //        public object SendResult(string key, object par = null)
 //        {
 //            lock (SendLock)
 //                if (actions.ContainsKey(key))
 //                    if (par == null)
 //                    {
 //                        return actions[key].FuncObj?.Invoke();
 //                    }
 //                    else
 //                    {
 //                        return actions[key].FuncPar?.Invoke(par);
 //                    }
 //            return default;
 //        }

 //        public void Register<T>(T action, string key)
 //        {
 //            lock (RegisterLock)
 //            {
 //                if (action != null)
 //                {
 //                    if (!actions.ContainsKey(key))
 //                    {
 //                        if (action is Action actionBus)
 //                            actions.TryAdd(key, new Delegation() { ActionBus = actionBus });

 //                        if (action is Action<object> actionObj)
 //                            actions.TryAdd(key, new Delegation() { ActionPar = actionObj });

 //                        if (action is Action<object[]> actionObjs)
 //                            actions.TryAdd(key, new Delegation() { ActionPars = actionObjs });

 //                        if (action is Func<object> funcObj)
 //                            actions.TryAdd(key, new Delegation() { FuncObj = funcObj });

 //                        if (action is Func<object, object> puncPar)
 //                            actions.TryAdd(key, new Delegation() { FuncPar = puncPar });
 //                    }
 //                }
 //            }

 //        }

 //    }
 //    public static class ExpandMethod
 //    {
 //        /// <summary>
 //        /// 获取布尔数组指定值得索引
 //        /// </summary>
 //        /// <param name="obj">要获取索引的数组</param>
 //        /// <param name="value">要获取索引的值</param>
 //        /// <returns></returns>
 //        public static int GetIndex(this bool[] obj, bool value)
 //        {
 //            if (obj == null) return -1;
 //            return Array.FindIndex(obj, p => p == value);
 //        }

 //        /// <summary>
 //        /// 获取字符串数组指定值得索引
 //        /// </summary>
 //        /// <param name="obj">要获取索引的数组</param>
 //        /// <param name="value">要获取索引的值</param>
 //        /// <returns></returns>
 //        public static int GetIndex(this string[] obj, string value)
 //        {
 //            if (obj == null || value == null) return -1;
 //            return Array.FindIndex(obj, p => p == value && p.Length > 0);
 //        }

 //        /// <summary>
 //        /// 委托回调
 //        /// </summary>
 //        /// <param name="action">要执行的委托</param>
 //        /// <param name="callback">委托回调</param>
 //        public static void Invoke(this Action action, Action callback)
 //        {
 //            action?.Invoke();
 //            callback?.Invoke();
 //        }

 //        /// <summary>
 //        /// 委托回调
 //        /// </summary>
 //        /// <param name="action">要执行的委托</param>
 //        /// <param name="par">要执行的委托的参数</param>
 //        /// <param name="callback">委托回调</param>
 //        public static void Invoke(this Action<object> action, object par, Action callback)
 //        {
 //            action?.Invoke(par);
 //            callback?.Invoke();
 //        }

 //        public static void Invokes(this Action<object[]> action, object[] par, Action callback)
 //        {
 //            action?.Invoke(par);
 //            callback?.Invoke();
 //        }


 //        /// <summary>
 //        /// 字节数组转换成32位整数
 //        /// </summary>
 //        /// <param name="bytes"></param>
 //        /// <returns></returns>
 //        public static int BytesToInt(this byte[] bytes)
 //        {
 //            if (bytes.Length > 4) return -1;
 //            int ReturnVlaue = 0;
 //            for (int i = 0; i < bytes.Length; i++)
 //            {
 //                ReturnVlaue += (int)(bytes[i] << (i * 8));
 //            }
 //            return ReturnVlaue;
 //        }

 //        /// <summary>
 //        /// 字节数组转换成 ushort 数组
 //        /// </summary>
 //        /// <param name="bytes">要转换的字节数组</param>
 //        /// <param name="reverse">字节高度顺序控制</param>
 //        /// <returns></returns>
 //        public static ushort[] BytesToUshorts(this byte[] bytes, bool reverse = false)
 //        {
 //            int len = bytes.Length;

 //            byte[] srcPlus = new byte[len + 1];
 //            bytes.CopyTo(srcPlus, 0);
 //            int count = len >> 1;

 //            if (len % 2 != 0)
 //            {
 //                count += 1;
 //            }

 //            ushort[] dest = new ushort[count];
 //            if (reverse)
 //            {
 //                for (int i = 0; i < count; i++)
 //                {
 //                    dest[i] = (ushort)(srcPlus[i * 2] << 8 | srcPlus[2 * i + 1] & 0xff);
 //                }
 //            }
 //            else
 //            {
 //                for (int i = 0; i < count; i++)
 //                {
 //                    dest[i] = (ushort)(srcPlus[i * 2] & 0xff | srcPlus[2 * i + 1] << 8);
 //                }
 //            }

 //            return dest;
 //        }

 //        /// <summary>
 //        /// ushort 数组转换成字节数组
 //        /// </summary>
 //        /// <param name="src">需要转换的 ushort数组</param>
 //        /// <param name="reverse">高低字节的设置</param>
 //        /// <returns></returns>
 //        public static byte[] UshortsToBytes(this ushort[] src, bool reverse = false)
 //        {

 //            int count = src.Length;
 //            byte[] dest = new byte[count << 1];
 //            if (reverse)
 //            {
 //                for (int i = 0; i < count; i++)
 //                {
 //                    dest[i * 2] = (byte)(src[i] >> 8);
 //                    dest[i * 2 + 1] = (byte)(src[i] >> 0);
 //                }
 //            }
 //            else
 //            {
 //                for (int i = 0; i < count; i++)
 //                {
 //                    dest[i * 2] = (byte)(src[i] >> 0);
 //                    dest[i * 2 + 1] = (byte)(src[i] >> 8);
 //                }
 //            }
 //            return dest;
 //        }
 //    }
 //}
--- a/HKCardIN/Logic/BaseLogic.cs
+++ b/HKCardIN/Logic/BaseLogic.cs
@@ -1,4 +1,5 @@
 using HandyControl.Controls;
 using BPA.Helper;
 using HandyControl.Controls;
 using HKCardIN.Helper;
 using HKCardIN.Logic.Model;
 using HKLog;
@@ -60,7 +61,7 @@ namespace HKCardIN.Logic
                HKLogImport.WriteError(ex);
                return false;
            }
        

        }
        /// <summary>
        /// 根据会员手机获取卡号
@@ -71,7 +72,8 @@ namespace HKCardIN.Logic
        {
            try
            {
                var data = IHttpMultiClient.HttpMulti.AddNode(t => {
                var data = IHttpMultiClient.HttpMulti.AddNode(t =>
                {
                    t.NodePath = ApiRoute.GetCardNoByPhone;
                    t.ReqType = MultiType.POST;
                    t.JsonParam = (new { phone = Phone }).ToJson();
--- a/HKCardIN/ViewModels/RootViewModel.cs
+++ b/HKCardIN/ViewModels/RootViewModel.cs
@@ -1,4 +1,5 @@
 using HandyControl.Data;
 using BPA.Helper;
 using HandyControl.Data;
 using HKCardIN.Helper;
 using HKCardIN.Logic;
 using HKCardIN.Logic.Model;
--- a/HKCardOUT/Bootstrapper.cs
+++ b/HKCardOUT/Bootstrapper.cs
@@ -17,6 +17,7 @@ using HKLog;
 using HKLib.RabbitMQ.Config;
 using HKLib.RabbitMQ.Subscriber;
 using System.Linq;
 using BPA.Helper;

 namespace HKCardOUT
 {
@@ -69,14 +70,14 @@ namespace HKCardOUT
            DataBus.SaasRoute = configer["SaasRoute"];
            HKLib.Configer.MqAddress = configer["MQ"];
            DataBus.Cron = configer["Cron"];
            DataBus.Span= configer["Span"].AsInt();
            DataBus.Span = configer["Span"].AsInt();
            DataBus.StoreId = configer["StoreId"];
            DataBus.COM = configer["COM"];
            DataBus.TenantId = configer["TenantId"];
            DataBus.StartDevice = configer["StartDevice"].AsBool();
            DataBus.Cancel = configer["Cancel"].AsBool();
            DataBus.Count = configer["Count"].AsInt();
            DataBus.Admin= configer.GetSection("Admin").GetChildren().Select(t => t.Value).ToList();
            DataBus.Admin = configer.GetSection("Admin").GetChildren().Select(t => t.Value).ToList();
            HKLib.Configer.SaasRoute = DataBus.SaasRoute;
            RemoteService.PullShopInfo();
            //初始化表
@@ -85,7 +86,7 @@ namespace HKCardOUT
            ServiceQueryExcute.QueryExcute.ExtuteMQ<TimeHandle, string>("TimeChanged", MQEnum.Push);
            //服务器拉取数据
            RemoteService.SyncTime();
           DataBus.UserListDto = HKLib.Interfaces.HKLibHelper.GetUserListSync("");
            DataBus.UserListDto = HKLib.Interfaces.HKLibHelper.GetUserListSync("");
            RemoteService.GetCardStuatas();
            base.Configure();
        }
--- a/HKCardOUT/HKCardOUT.csproj
+++ b/HKCardOUT/HKCardOUT.csproj
@@ -33,6 +33,7 @@
 		<None Remove="HKResouces\背景.jpg" />
 	</ItemGroup>
 	<ItemGroup>
 		<PackageReference Include="BPA.Helper" Version="1.0.25" />
 		<PackageReference Include="CalcBinding" Version="2.5.2" />
 		<PackageReference Include="HandyControls" Version="3.4.1" />
 		<PackageReference Include="Microsoft.Extensions.Configuration" Version="6.0.1" />
--- a/HKCardOUT/Helper/HKHelpers.cs
+++ b/HKCardOUT/Helper/HKHelpers.cs
@@ -1,4 +1,5 @@
 using System;
 using BPA.Helper;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.InteropServices;
@@ -8,7 +9,7 @@ using System.Threading.Tasks;

 namespace HKCardOUT.Helper
 {
    public class HKHelpers: Singleton<HKHelpers>
    public class HKHelpers : Singleton<HKHelpers>
    {
        /// <summary>
        /// 判断网络状况的方法,返回值true为连接，false为未连接  
@@ -27,5 +28,5 @@ namespace HKCardOUT.Helper
            return InternetGetConnectedState(out int i, 0);
        }

        }
    }
 }
--- a/HKCardOUT/Helper/ThreadManage.cs
+++ b/HKCardOUT/Helper/ThreadManage.cs
@@ -1,445 +1,445 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;

 namespace HKCardOUT.Helper
 {
    public class Singleton<T> where T : new()
    {
        private static object _async = new object();

        private static T _instance;

        static readonly Lazy<T> instance = new();
        /// <summary>
        /// 获取实例
        /// </summary>
        /// <returns></returns>
        public static T GetInstance()
        {
            return instance.Value;
        }
    }
    public class ThreadManage : Singleton<ThreadManage>
    {
        string guid = "871d7e28-c413-4675-8d28-64e4dca4c2d3-";
        private static readonly object _lock = new object();
        StringBuilder callbackKey = new StringBuilder();
        List<string> keys = new List<string>();
        ConcurrentDictionary<string, Task> Threads = new ConcurrentDictionary<string, Task>();
        ConcurrentDictionary<string, CancellationTokenSource> CancellationTokenSources = new ConcurrentDictionary<string, CancellationTokenSource>();

        /// <summary>
        /// 停止指定任务
        /// </summary>
        /// <param name="key">任务名</param>
        /// <param name="ExitCallback">任务结束的回调</param>
        public void StopTask(string key, Action ExitCallback = null)
        {
            if (CancellationTokenSources.ContainsKey(guid + key))
            {
                CancellationTokenSources[guid + key]?.Cancel();
                ActionManage.GetInstance.Register(ExitCallback, guid + key);
            }
            else
            {
                if (ExitCallback != null) ExitCallback();
            }
        }

        /// <summary>
        /// 长任务，带 while true 的循环
        /// </summary>
        /// <param name="action"></param>
        /// <param name="key"></param>
        public void StartLong(Action action, string key, bool IsRestart = false, Action RunComplete = null)
        {
            CancellationTokenSources.TryAdd(guid + key, new CancellationTokenSource());
            bool result = Threads.TryAdd(guid + key, Task.Factory.StartNew(new Action(() =>
            {
                Thread.CurrentThread.Name = key;
            ReStart:
                try
                {
                    while (!CancellationTokenSources[guid + key].IsCancellationRequested)
                    {
                        if (action != null) action();
                    }
                }
                catch (Exception ex)
                {
                    if (IsRestart)
                    {
                        Thread.Sleep(2000);
                        goto ReStart;
                    }
                    else
                    {
                        CancellationTokenSources.TryRemove(guid + key, out CancellationTokenSource temp);
                        Threads.TryRemove(guid + key, out Task temp1);
                    }
                }
            }), CancellationTokenSources[guid + key].Token).ContinueWith(new Action<Task, object>((t, o) =>
            {
                ThreadStatus(t, o.ToString());
                if (RunComplete != null) RunComplete();
            }), guid + key));
        }


        /// <summary>
        /// 不带 while true 的循环任务
        /// </summary>
        /// <param name="action"></param>
        /// <param name="key"></param>
        public void Start(Action action, string key, bool isRestart = false)
        {
            CancellationTokenSources.TryAdd(guid + key, new CancellationTokenSource());
            bool result = Threads.TryAdd(guid + key, Task.Factory.StartNew(new Action(() =>
            {
                Thread.CurrentThread.Name = key;
                try
                {
                    if (action != null) action();
                }
                catch (Exception ex)
                {
                    if (isRestart)
                    {
                        CancellationTokenSources.TryRemove(guid + key, out CancellationTokenSource item1);
                        Threads.TryRemove(guid + key, out Task item2);
                        Start(action, key, isRestart);
                    }
                    else
                    {
                    }
                }
            }), CancellationTokenSources[guid + key].Token).ContinueWith(new Action<Task, object>((t, o) =>
            {
                ThreadStatus(t, o.ToString());
            }), guid + key));
        }

        private void ThreadStatus(Task task, string key)
        {
            bool IsRemove = false;
            string name = key.Substring(key.LastIndexOf('-') + 1);
            switch (task.Status)
            {
                case TaskStatus.RanToCompletion:
                    IsRemove = true;
                    break;
                case TaskStatus.Faulted:
                    IsRemove = true;
                    break;
                case TaskStatus.Canceled:
                    IsRemove = true;
                    break;
                default:
                    break;
            }

            if (IsRemove)
            {
                if (Threads.ContainsKey(key))
                    Threads.TryRemove(key, out Task t);
                if (CancellationTokenSources.ContainsKey(key))
                    CancellationTokenSources.TryRemove(key, out CancellationTokenSource cts);
                ActionManage.GetInstance.Send(key);
            }
        }

        /// <summary>
        /// 释放所有线程资源
        /// </summary>
        public void Dispose()
        {
            for (int i = 0; i < CancellationTokenSources.Count; i++)
            {
                CancellationTokenSources.ElementAt(i).Value.Cancel();
            }
        }

        /// <summary>
        /// 判断指定线程是否完成
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool IsComplete(string key)
        {
            if (Threads.ContainsKey(guid + key)) return Threads[guid + key].IsCompleted;
            return false;
        }

    }
    internal class Delegation
    {
        /// <summary>
        /// 带参数的委托
        /// </summary>
        public Action<object> ActionPar { get; set; }
        /// <summary>
        /// 带参数的委托
        /// </summary>
        public Action<object[]> ActionPars { get; set; }
        /// <summary>
        /// 无参数的委托
        /// </summary>
        public Action ActionBus { get; set; }
        /// <summary>
        /// 有返回值的委托
        /// </summary>
        public Func<object> FuncObj { get; set; }
        /// <summary>
        /// 有返回值，有参数的委托
        /// </summary>
        public Func<object, object> FuncPar { get; set; }
    }
    public class ActionManage
    {

        private volatile static ActionManage _Instance;
        public static ActionManage GetInstance => _Instance ?? (_Instance = new ActionManage());
        private ActionManage() { }

        //private static ConcurrentDictionary<string, delegate> actions = new ConcurrentDictionary<string, delegate>();
        private static ConcurrentDictionary<string, Delegation> actions = new ConcurrentDictionary<string, Delegation>();

        static readonly object SendLock = new object();
        static readonly object SendParLock = new object();
        static readonly object RegisterLock = new object();

        /// <summary>
        /// 注销委托
        /// </summary>
        /// <param name="key"></param>
        public void CancelRegister(string key)
        {
            if (actions.ContainsKey(key))
                actions.TryRemove(key, out Delegation t);
        }

        /// <summary>
        /// 执行注册过的委托
        /// </summary>
        /// <param name="key">注册委托的key</param>
        /// <param name="par">委托参数</param>
        /// <param name="Callback">委托回调</param>
        public void Send(string key, object par, Action Callback = null)
        {
            lock (SendLock)
                if (actions.ContainsKey(key)) actions[key].ActionPar.Invoke(par, Callback);
        }

        /// <summary>
        /// 执行注册过的委托
        /// </summary>
        /// <param name="key">注册委托的key</param>
        /// <param name="par">委托参数</param>
        /// <param name="Callback">委托回调</param>
        public void Send(string key, object[] par, Action Callback = null)
        {
            lock (SendLock)
                if (actions.ContainsKey(key)) actions[key].ActionPars.Invokes(par, Callback);
        }

        /// <summary>
        /// 执行注册过的委托
        /// </summary>
        /// <param name="key">注册委托的key</param>
        /// <param name="Callback">委托回调</param>
        public void Send(string key, Action Callback = null)
        {
            lock (SendLock)
                if (actions.ContainsKey(key)) actions[key].ActionBus?.Invoke(Callback);
        }

        public object SendResult(string key, object par = null)
        {
            lock (SendLock)
                if (actions.ContainsKey(key))
                    if (par == null)
                    {
                        return actions[key].FuncObj?.Invoke();
                    }
                    else
                    {
                        return actions[key].FuncPar?.Invoke(par);
                    }
            return default;
        }

        public void Register<T>(T action, string key)
        {
            lock (RegisterLock)
            {
                if (action != null)
                {
                    if (!actions.ContainsKey(key))
                    {
                        if (action is Action actionBus)
                            actions.TryAdd(key, new Delegation() { ActionBus = actionBus });

                        if (action is Action<object> actionObj)
                            actions.TryAdd(key, new Delegation() { ActionPar = actionObj });

                        if (action is Action<object[]> actionObjs)
                            actions.TryAdd(key, new Delegation() { ActionPars = actionObjs });

                        if (action is Func<object> funcObj)
                            actions.TryAdd(key, new Delegation() { FuncObj = funcObj });

                        if (action is Func<object, object> puncPar)
                            actions.TryAdd(key, new Delegation() { FuncPar = puncPar });
                    }
                }
            }

        }

    }
    public static class ExpandMethod
    {
        /// <summary>
        /// 获取布尔数组指定值得索引
        /// </summary>
        /// <param name="obj">要获取索引的数组</param>
        /// <param name="value">要获取索引的值</param>
        /// <returns></returns>
        public static int GetIndex(this bool[] obj, bool value)
        {
            if (obj == null) return -1;
            return Array.FindIndex(obj, p => p == value);
        }

        /// <summary>
        /// 获取字符串数组指定值得索引
        /// </summary>
        /// <param name="obj">要获取索引的数组</param>
        /// <param name="value">要获取索引的值</param>
        /// <returns></returns>
        public static int GetIndex(this string[] obj, string value)
        {
            if (obj == null || value == null) return -1;
            return Array.FindIndex(obj, p => p == value && p.Length > 0);
        }

        /// <summary>
        /// 委托回调
        /// </summary>
        /// <param name="action">要执行的委托</param>
        /// <param name="callback">委托回调</param>
        public static void Invoke(this Action action, Action callback)
        {
            action?.Invoke();
            callback?.Invoke();
        }

        /// <summary>
        /// 委托回调
        /// </summary>
        /// <param name="action">要执行的委托</param>
        /// <param name="par">要执行的委托的参数</param>
        /// <param name="callback">委托回调</param>
        public static void Invoke(this Action<object> action, object par, Action callback)
        {
            action?.Invoke(par);
            callback?.Invoke();
        }

        public static void Invokes(this Action<object[]> action, object[] par, Action callback)
        {
            action?.Invoke(par);
            callback?.Invoke();
        }


        /// <summary>
        /// 字节数组转换成32位整数
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public static int BytesToInt(this byte[] bytes)
        {
            if (bytes.Length > 4) return -1;
            int ReturnVlaue = 0;
            for (int i = 0; i < bytes.Length; i++)
            {
                ReturnVlaue += (int)(bytes[i] << (i * 8));
            }
            return ReturnVlaue;
        }

        /// <summary>
        /// 字节数组转换成 ushort 数组
        /// </summary>
        /// <param name="bytes">要转换的字节数组</param>
        /// <param name="reverse">字节高度顺序控制</param>
        /// <returns></returns>
        public static ushort[] BytesToUshorts(this byte[] bytes, bool reverse = false)
        {
            int len = bytes.Length;

            byte[] srcPlus = new byte[len + 1];
            bytes.CopyTo(srcPlus, 0);
            int count = len >> 1;

            if (len % 2 != 0)
            {
                count += 1;
            }

            ushort[] dest = new ushort[count];
            if (reverse)
            {
                for (int i = 0; i < count; i++)
                {
                    dest[i] = (ushort)(srcPlus[i * 2] << 8 | srcPlus[2 * i + 1] & 0xff);
                }
            }
            else
            {
                for (int i = 0; i < count; i++)
                {
                    dest[i] = (ushort)(srcPlus[i * 2] & 0xff | srcPlus[2 * i + 1] << 8);
                }
            }

            return dest;
        }

        /// <summary>
        /// ushort 数组转换成字节数组
        /// </summary>
        /// <param name="src">需要转换的 ushort数组</param>
        /// <param name="reverse">高低字节的设置</param>
        /// <returns></returns>
        public static byte[] UshortsToBytes(this ushort[] src, bool reverse = false)
        {

            int count = src.Length;
            byte[] dest = new byte[count << 1];
            if (reverse)
            {
                for (int i = 0; i < count; i++)
                {
                    dest[i * 2] = (byte)(src[i] >> 8);
                    dest[i * 2 + 1] = (byte)(src[i] >> 0);
                }
            }
            else
            {
                for (int i = 0; i < count; i++)
                {
                    dest[i * 2] = (byte)(src[i] >> 0);
                    dest[i * 2 + 1] = (byte)(src[i] >> 8);
                }
            }
            return dest;
        }
    }
 }
 //using System;
 //using System.Collections.Concurrent;
 //using System.Collections.Generic;
 //using System.Linq;
 //using System.Text;
 //using System.Threading;
 //using System.Threading.Tasks;

 //namespace HKCardOUT.Helper
 //{
 //    public class Singleton<T> where T : new()
 //    {
 //        private static object _async = new object();

 //        private static T _instance;

 //        static readonly Lazy<T> instance = new();
 //        /// <summary>
 //        /// 获取实例
 //        /// </summary>
 //        /// <returns></returns>
 //        public static T GetInstance()
 //        {
 //            return instance.Value;
 //        }
 //    }
 //    public class ThreadManage : Singleton<ThreadManage>
 //    {
 //        string guid = "871d7e28-c413-4675-8d28-64e4dca4c2d3-";
 //        private static readonly object _lock = new object();
 //        StringBuilder callbackKey = new StringBuilder();
 //        List<string> keys = new List<string>();
 //        ConcurrentDictionary<string, Task> Threads = new ConcurrentDictionary<string, Task>();
 //        ConcurrentDictionary<string, CancellationTokenSource> CancellationTokenSources = new ConcurrentDictionary<string, CancellationTokenSource>();

 //        /// <summary>
 //        /// 停止指定任务
 //        /// </summary>
 //        /// <param name="key">任务名</param>
 //        /// <param name="ExitCallback">任务结束的回调</param>
 //        public void StopTask(string key, Action ExitCallback = null)
 //        {
 //            if (CancellationTokenSources.ContainsKey(guid + key))
 //            {
 //                CancellationTokenSources[guid + key]?.Cancel();
 //                ActionManage.GetInstance.Register(ExitCallback, guid + key);
 //            }
 //            else
 //            {
 //                if (ExitCallback != null) ExitCallback();
 //            }
 //        }

 //        /// <summary>
 //        /// 长任务，带 while true 的循环
 //        /// </summary>
 //        /// <param name="action"></param>
 //        /// <param name="key"></param>
 //        public void StartLong(Action action, string key, bool IsRestart = false, Action RunComplete = null)
 //        {
 //            CancellationTokenSources.TryAdd(guid + key, new CancellationTokenSource());
 //            bool result = Threads.TryAdd(guid + key, Task.Factory.StartNew(new Action(() =>
 //            {
 //                Thread.CurrentThread.Name = key;
 //            ReStart:
 //                try
 //                {
 //                    while (!CancellationTokenSources[guid + key].IsCancellationRequested)
 //                    {
 //                        if (action != null) action();
 //                    }
 //                }
 //                catch (Exception ex)
 //                {
 //                    if (IsRestart)
 //                    {
 //                        Thread.Sleep(2000);
 //                        goto ReStart;
 //                    }
 //                    else
 //                    {
 //                        CancellationTokenSources.TryRemove(guid + key, out CancellationTokenSource temp);
 //                        Threads.TryRemove(guid + key, out Task temp1);
 //                    }
 //                }
 //            }), CancellationTokenSources[guid + key].Token).ContinueWith(new Action<Task, object>((t, o) =>
 //            {
 //                ThreadStatus(t, o.ToString());
 //                if (RunComplete != null) RunComplete();
 //            }), guid + key));
 //        }


 //        /// <summary>
 //        /// 不带 while true 的循环任务
 //        /// </summary>
 //        /// <param name="action"></param>
 //        /// <param name="key"></param>
 //        public void Start(Action action, string key, bool isRestart = false)
 //        {
 //            CancellationTokenSources.TryAdd(guid + key, new CancellationTokenSource());
 //            bool result = Threads.TryAdd(guid + key, Task.Factory.StartNew(new Action(() =>
 //            {
 //                Thread.CurrentThread.Name = key;
 //                try
 //                {
 //                    if (action != null) action();
 //                }
 //                catch (Exception ex)
 //                {
 //                    if (isRestart)
 //                    {
 //                        CancellationTokenSources.TryRemove(guid + key, out CancellationTokenSource item1);
 //                        Threads.TryRemove(guid + key, out Task item2);
 //                        Start(action, key, isRestart);
 //                    }
 //                    else
 //                    {
 //                    }
 //                }
 //            }), CancellationTokenSources[guid + key].Token).ContinueWith(new Action<Task, object>((t, o) =>
 //            {
 //                ThreadStatus(t, o.ToString());
 //            }), guid + key));
 //        }

 //        private void ThreadStatus(Task task, string key)
 //        {
 //            bool IsRemove = false;
 //            string name = key.Substring(key.LastIndexOf('-') + 1);
 //            switch (task.Status)
 //            {
 //                case TaskStatus.RanToCompletion:
 //                    IsRemove = true;
 //                    break;
 //                case TaskStatus.Faulted:
 //                    IsRemove = true;
 //                    break;
 //                case TaskStatus.Canceled:
 //                    IsRemove = true;
 //                    break;
 //                default:
 //                    break;
 //            }

 //            if (IsRemove)
 //            {
 //                if (Threads.ContainsKey(key))
 //                    Threads.TryRemove(key, out Task t);
 //                if (CancellationTokenSources.ContainsKey(key))
 //                    CancellationTokenSources.TryRemove(key, out CancellationTokenSource cts);
 //                ActionManage.GetInstance.Send(key);
 //            }
 //        }

 //        /// <summary>
 //        /// 释放所有线程资源
 //        /// </summary>
 //        public void Dispose()
 //        {
 //            for (int i = 0; i < CancellationTokenSources.Count; i++)
 //            {
 //                CancellationTokenSources.ElementAt(i).Value.Cancel();
 //            }
 //        }

 //        /// <summary>
 //        /// 判断指定线程是否完成
 //        /// </summary>
 //        /// <param name="key"></param>
 //        /// <returns></returns>
 //        public bool IsComplete(string key)
 //        {
 //            if (Threads.ContainsKey(guid + key)) return Threads[guid + key].IsCompleted;
 //            return false;
 //        }

 //    }
 //    internal class Delegation
 //    {
 //        /// <summary>
 //        /// 带参数的委托
 //        /// </summary>
 //        public Action<object> ActionPar { get; set; }
 //        /// <summary>
 //        /// 带参数的委托
 //        /// </summary>
 //        public Action<object[]> ActionPars { get; set; }
 //        /// <summary>
 //        /// 无参数的委托
 //        /// </summary>
 //        public Action ActionBus { get; set; }
 //        /// <summary>
 //        /// 有返回值的委托
 //        /// </summary>
 //        public Func<object> FuncObj { get; set; }
 //        /// <summary>
 //        /// 有返回值，有参数的委托
 //        /// </summary>
 //        public Func<object, object> FuncPar { get; set; }
 //    }
 //    public class ActionManage
 //    {

 //        private volatile static ActionManage _Instance;
 //        public static ActionManage GetInstance => _Instance ?? (_Instance = new ActionManage());
 //        private ActionManage() { }

 //        //private static ConcurrentDictionary<string, delegate> actions = new ConcurrentDictionary<string, delegate>();
 //        private static ConcurrentDictionary<string, Delegation> actions = new ConcurrentDictionary<string, Delegation>();

 //        static readonly object SendLock = new object();
 //        static readonly object SendParLock = new object();
 //        static readonly object RegisterLock = new object();

 //        /// <summary>
 //        /// 注销委托
 //        /// </summary>
 //        /// <param name="key"></param>
 //        public void CancelRegister(string key)
 //        {
 //            if (actions.ContainsKey(key))
 //                actions.TryRemove(key, out Delegation t);
 //        }

 //        /// <summary>
 //        /// 执行注册过的委托
 //        /// </summary>
 //        /// <param name="key">注册委托的key</param>
 //        /// <param name="par">委托参数</param>
 //        /// <param name="Callback">委托回调</param>
 //        public void Send(string key, object par, Action Callback = null)
 //        {
 //            lock (SendLock)
 //                if (actions.ContainsKey(key)) actions[key].ActionPar.Invoke(par, Callback);
 //        }

 //        /// <summary>
 //        /// 执行注册过的委托
 //        /// </summary>
 //        /// <param name="key">注册委托的key</param>
 //        /// <param name="par">委托参数</param>
 //        /// <param name="Callback">委托回调</param>
 //        public void Send(string key, object[] par, Action Callback = null)
 //        {
 //            lock (SendLock)
 //                if (actions.ContainsKey(key)) actions[key].ActionPars.Invokes(par, Callback);
 //        }

 //        /// <summary>
 //        /// 执行注册过的委托
 //        /// </summary>
 //        /// <param name="key">注册委托的key</param>
 //        /// <param name="Callback">委托回调</param>
 //        public void Send(string key, Action Callback = null)
 //        {
 //            lock (SendLock)
 //                if (actions.ContainsKey(key)) actions[key].ActionBus?.Invoke(Callback);
 //        }

 //        public object SendResult(string key, object par = null)
 //        {
 //            lock (SendLock)
 //                if (actions.ContainsKey(key))
 //                    if (par == null)
 //                    {
 //                        return actions[key].FuncObj?.Invoke();
 //                    }
 //                    else
 //                    {
 //                        return actions[key].FuncPar?.Invoke(par);
 //                    }
 //            return default;
 //        }

 //        public void Register<T>(T action, string key)
 //        {
 //            lock (RegisterLock)
 //            {
 //                if (action != null)
 //                {
 //                    if (!actions.ContainsKey(key))
 //                    {
 //                        if (action is Action actionBus)
 //                            actions.TryAdd(key, new Delegation() { ActionBus = actionBus });

 //                        if (action is Action<object> actionObj)
 //                            actions.TryAdd(key, new Delegation() { ActionPar = actionObj });

 //                        if (action is Action<object[]> actionObjs)
 //                            actions.TryAdd(key, new Delegation() { ActionPars = actionObjs });

 //                        if (action is Func<object> funcObj)
 //                            actions.TryAdd(key, new Delegation() { FuncObj = funcObj });

 //                        if (action is Func<object, object> puncPar)
 //                            actions.TryAdd(key, new Delegation() { FuncPar = puncPar });
 //                    }
 //                }
 //            }

 //        }

 //    }
 //    public static class ExpandMethod
 //    {
 //        /// <summary>
 //        /// 获取布尔数组指定值得索引
 //        /// </summary>
 //        /// <param name="obj">要获取索引的数组</param>
 //        /// <param name="value">要获取索引的值</param>
 //        /// <returns></returns>
 //        public static int GetIndex(this bool[] obj, bool value)
 //        {
 //            if (obj == null) return -1;
 //            return Array.FindIndex(obj, p => p == value);
 //        }

 //        /// <summary>
 //        /// 获取字符串数组指定值得索引
 //        /// </summary>
 //        /// <param name="obj">要获取索引的数组</param>
 //        /// <param name="value">要获取索引的值</param>
 //        /// <returns></returns>
 //        public static int GetIndex(this string[] obj, string value)
 //        {
 //            if (obj == null || value == null) return -1;
 //            return Array.FindIndex(obj, p => p == value && p.Length > 0);
 //        }

 //        /// <summary>
 //        /// 委托回调
 //        /// </summary>
 //        /// <param name="action">要执行的委托</param>
 //        /// <param name="callback">委托回调</param>
 //        public static void Invoke(this Action action, Action callback)
 //        {
 //            action?.Invoke();
 //            callback?.Invoke();
 //        }

 //        /// <summary>
 //        /// 委托回调
 //        /// </summary>
 //        /// <param name="action">要执行的委托</param>
 //        /// <param name="par">要执行的委托的参数</param>
 //        /// <param name="callback">委托回调</param>
 //        public static void Invoke(this Action<object> action, object par, Action callback)
 //        {
 //            action?.Invoke(par);
 //            callback?.Invoke();
 //        }

 //        public static void Invokes(this Action<object[]> action, object[] par, Action callback)
 //        {
 //            action?.Invoke(par);
 //            callback?.Invoke();
 //        }


 //        /// <summary>
 //        /// 字节数组转换成32位整数
 //        /// </summary>
 //        /// <param name="bytes"></param>
 //        /// <returns></returns>
 //        public static int BytesToInt(this byte[] bytes)
 //        {
 //            if (bytes.Length > 4) return -1;
 //            int ReturnVlaue = 0;
 //            for (int i = 0; i < bytes.Length; i++)
 //            {
 //                ReturnVlaue += (int)(bytes[i] << (i * 8));
 //            }
 //            return ReturnVlaue;
 //        }

 //        /// <summary>
 //        /// 字节数组转换成 ushort 数组
 //        /// </summary>
 //        /// <param name="bytes">要转换的字节数组</param>
 //        /// <param name="reverse">字节高度顺序控制</param>
 //        /// <returns></returns>
 //        public static ushort[] BytesToUshorts(this byte[] bytes, bool reverse = false)
 //        {
 //            int len = bytes.Length;

 //            byte[] srcPlus = new byte[len + 1];
 //            bytes.CopyTo(srcPlus, 0);
 //            int count = len >> 1;

 //            if (len % 2 != 0)
 //            {
 //                count += 1;
 //            }

 //            ushort[] dest = new ushort[count];
 //            if (reverse)
 //            {
 //                for (int i = 0; i < count; i++)
 //                {
 //                    dest[i] = (ushort)(srcPlus[i * 2] << 8 | srcPlus[2 * i + 1] & 0xff);
 //                }
 //            }
 //            else
 //            {
 //                for (int i = 0; i < count; i++)
 //                {
 //                    dest[i] = (ushort)(srcPlus[i * 2] & 0xff | srcPlus[2 * i + 1] << 8);
 //                }
 //            }

 //            return dest;
 //        }

 //        /// <summary>
 //        /// ushort 数组转换成字节数组
 //        /// </summary>
 //        /// <param name="src">需要转换的 ushort数组</param>
 //        /// <param name="reverse">高低字节的设置</param>
 //        /// <returns></returns>
 //        public static byte[] UshortsToBytes(this ushort[] src, bool reverse = false)
 //        {

 //            int count = src.Length;
 //            byte[] dest = new byte[count << 1];
 //            if (reverse)
 //            {
 //                for (int i = 0; i < count; i++)
 //                {
 //                    dest[i * 2] = (byte)(src[i] >> 8);
 //                    dest[i * 2 + 1] = (byte)(src[i] >> 0);
 //                }
 //            }
 //            else
 //            {
 //                for (int i = 0; i < count; i++)
 //                {
 //                    dest[i * 2] = (byte)(src[i] >> 0);
 //                    dest[i * 2 + 1] = (byte)(src[i] >> 8);
 //                }
 //            }
 //            return dest;
 //        }
 //    }
 //}
--- a/HKCardOUT/ViewModels/AdWindowViewModel.cs
+++ b/HKCardOUT/ViewModels/AdWindowViewModel.cs
@@ -1,4 +1,5 @@
 using DTO;
 using BPA.Helper;
 using DTO;
 using HKCardOUT.Helper;
 using HKCardOUT.Logic.Service;
 using Microsoft.VisualBasic.ApplicationServices;
--- a/HKCardOUT/ViewModels/RootViewModel.cs
+++ b/HKCardOUT/ViewModels/RootViewModel.cs
@@ -1,4 +1,5 @@
 using DTO;
 using BPA.Helper;
 using DTO;
 using HKCardOUT.Helper;
 using HKCardOUT.Logic.Model;
 using HKCardOUT.Logic.Service;
@@ -88,8 +89,9 @@ namespace HKCardOUT.ViewModels
                                            if (res != null)
                                            {
                                                HKLog.HKLogImport.WriteInfo($"{DateTime.Now.ToString("HH:mm:ss")} 卡号地址：{res.Address}----------卡号数据：{res.ResData}");
                                                if (!res.ResData.IsNullOrEmpty()) {
                                                    if (res.ResData.Length==20)
                                                if (!res.ResData.IsNullOrEmpty())
                                                {
                                                    if (res.ResData.Length == 20)
                                                        ReadFunc?.Invoke(res);
                                                }
                                                Thread.Sleep(2000);
@@ -176,7 +178,7 @@ namespace HKCardOUT.ViewModels
                    var SC = System.Windows.Forms.Screen.AllScreens.Count();
                    for (int i = 0; i < SC; i++)
                    {
                        var win = new AdWindow(Ad[i].Ad,i);
                        var win = new AdWindow(Ad[i].Ad, i);
                        win.DataContext = new AdWindowViewModel();
                        var rectangle = System.Windows.Forms.Screen.AllScreens[i].WorkingArea;
                        win.Height = rectangle.Height;
@@ -190,7 +192,7 @@ namespace HKCardOUT.ViewModels
                catch (Exception ex)
                {
                    Debug.WriteLine(ex.ToString());
                    var win = new AdWindow("暂无广告",0);
                    var win = new AdWindow("暂无广告", 0);
                    var rectangle = System.Windows.Forms.Screen.AllScreens[0].WorkingArea;
                    win.Height = rectangle.Height;
                    win.Width = rectangle.Width;
--- a/HKCardOUT/Views/AdWindow.xaml.cs
+++ b/HKCardOUT/Views/AdWindow.xaml.cs
@@ -14,6 +14,7 @@ using System.Windows.Input;
 using System.Windows.Media;
 using System.Windows.Media.Imaging;
 using System.Windows.Shapes;
 using BPA.Helper;

 namespace HKCardOUT.Views
 {
@@ -26,6 +27,14 @@ namespace HKCardOUT.Views
        public AdWindow(string input, int bindScreen)
        {
            InitializeComponent();
            MessageLog.GetInstance.NotifyShow = new Action<string>((s) =>
              {
                  HKLog.HKLogImport.WriteInfo(s);
              });
            MessageLog.GetInstance.NotifyShowEx = new Action<string>((s) =>
            {
                HKLog.HKLogImport.WriteInfo(s);
            });
            this.Loaded += (sender, ev) =>
            {
                this.WindowState = WindowState.Maximized;
@@ -40,7 +49,7 @@ namespace HKCardOUT.Views
            };
            InitView2(input);
            BindScreen = bindScreen;
            


        }

@@ -54,6 +63,6 @@ namespace HKCardOUT.Views
            view2.CoreWebView2.Settings.AreDevToolsEnabled = false;
            view2.CoreWebView2.NavigateToString(html);
        }
        

    }
 }
--- a/HKControl/HKControl.csproj
+++ b/HKControl/HKControl.csproj
@@ -8,11 +8,11 @@
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="BPA.Helper" Version="1.0.25" />
    <PackageReference Include="S7netplus" Version="0.14.0" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\HKHelper\HKHelper.csproj" />
    <ProjectReference Include="..\HKLog\HKLog.csproj" />
  </ItemGroup>

--- a/HKControl/Main.cs
+++ b/HKControl/Main.cs
@@ -1,6 +1,6 @@
 using System.Collections.Concurrent;
 using System.Diagnostics;
 using HKHelper;
 using BPA.Helper;
 using S7.Net;

 namespace HKControl
@@ -26,22 +26,16 @@ namespace HKControl
            switch (CarNum)
            {
                case 1:
                    //Debug.WriteLine($"{CarNum} 号窗口反馈状态：{DataModels[1].LeftWindowData.IsSwipe}");
                    return DataModels[1].LeftWindowData.IsSwipe;
                case 2:
                    //Debug.WriteLine($"{CarNum} 号窗口反馈状态：{DataModels[1].RightWindowData.IsSwipe}");
                    return DataModels[1].RightWindowData.IsSwipe;
                case 3:
                    //Debug.WriteLine($"{CarNum} 号窗口反馈状态：{DataModels[1].LeftWindowData.IsSwipe}");
                    return DataModels[2].LeftWindowData.IsSwipe;
                case 4:
                    //Debug.WriteLine($"{CarNum} 号窗口反馈状态：{DataModels[1].RightWindowData.IsSwipe}");
                    return DataModels[2].RightWindowData.IsSwipe;
                case 5:
                    //Debug.WriteLine($"{CarNum} 号窗口反馈状态：{DataModels[1].LeftWindowData.IsSwipe}");
                    return DataModels[3].LeftWindowData.IsSwipe;
                case 6:
                    //Debug.WriteLine($"{CarNum} 号窗口反馈状态：{DataModels[1].RightWindowData.IsSwipe}");
                    return DataModels[3].LeftWindowData.IsSwipe;
                default:
                    break;
@@ -89,15 +83,6 @@ namespace HKControl
                              {
                                  HKLog.HKLogImport.WriteInfo(ex.ToString());
                              }



                              //DataModels[item.DeviceNum].LeftWindowData.IsSwipe = SiemensDicitonary[item.DeviceNum].Read<bool>("M7.0");
                              //DataModels[item.DeviceNum].LeftWindowData.Complete = SiemensDicitonary[item.DeviceNum].Read<bool>("M7.1");

                              //DataModels[item.DeviceNum].RightWindowData.IsSwipe = SiemensDicitonary[item.DeviceNum].Read<bool>("M7.2");
                              //DataModels[item.DeviceNum].RightWindowData.Complete = SiemensDicitonary[item.DeviceNum].Read<bool>("M7.3");

                              Thread.Sleep(100);
                          }), $"{item.DeviceNum} 号设备监听", true);
                      });
@@ -119,27 +104,21 @@ namespace HKControl
                        switch (carNum)
                        {
                            case 1:
                                //SiemensDicitonary[1].Write("M6.0", true);
                                Control(1, "M6.1");
                                break;
                            case 2:
                                //SiemensDicitonary[1].Write("M6.1", true);
                                Control(1, "M6.0");
                                break;
                            case 3:
                                //SiemensDicitonary[2].Write("M6.0", true);
                                Control(2, "M6.1");
                                break;
                            case 4:
                                //SiemensDicitonary[2].Write("M6.1", true);
                                Control(2, "M6.0");
                                break;
                            case 5:
                                //SiemensDicitonary[3].Write("M6.0", true);
                                Control(3, "M6.1");
                                break;
                            case 6:
                                //SiemensDicitonary[3].Write("M6.1", true);
                                Control(3, "M6.0");
                                break;

--- a/HKHelper/HKHelper.cs
+++ b/HKHelper/HKHelper.cs
@@ -8,6 +8,25 @@ using System.Threading.Tasks;

 namespace HKHelper
 {

    public class Singleton<T> where T : new()
    {
        private static object _async = new object();

        private static T _instance;

        static readonly Lazy<T> instance = new();
        /// <summary>
        /// 获取实例
        /// </summary>
        /// <returns></returns>
        public static T GetInstance()
        {
            return instance.Value;
        }
    }


    public class HKHelper : Singleton<HKHelper>
    {
        /// <summary>
--- a/HKHelper/Json.cs
+++ b/HKHelper/Json.cs
@@ -1,81 +1,81 @@
 using Newtonsoft.Json;
 using System;
 using System.IO;
 using System.Collections.Concurrent;
 using System.Reflection;
 //using Newtonsoft.Json;
 //using System;
 //using System.IO;
 //using System.Collections.Concurrent;
 //using System.Reflection;

 namespace HKHelper
 {
    /// <summary>
    /// Json参数服务类
    /// </summary>
    public class Json<T> where T : class, new()
    {
        static string path
        {
            get
            {
                Directory.CreateDirectory(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"AccessFile\\JSON"));
                return $"{AppDomain.CurrentDomain.BaseDirectory}AccessFile\\JSON\\{typeof(T).Name}.json";
            }
        }
 //namespace HKHelper
 //{
 //    /// <summary>
 //    /// Json参数服务类
 //    /// </summary>
 //    public class Json<T> where T : class, new()
 //    {
 //        static string path
 //        {
 //            get
 //            {
 //                Directory.CreateDirectory(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"AccessFile\\JSON"));
 //                return $"{AppDomain.CurrentDomain.BaseDirectory}AccessFile\\JSON\\{typeof(T).Name}.json";
 //            }
 //        }

        public static T Data { get; set; } = new T();
 //        public static T Data { get; set; } = new T();

        /// <summary>
        /// 保存数据
        /// </summary>
        public static void Save()
        {
            string outjson = JsonConvert.SerializeObject(Data);
            File.WriteAllText(path, outjson);
        }
 //        /// <summary>
 //        /// 保存数据
 //        /// </summary>
 //        public static void Save()
 //        {
 //            string outjson = JsonConvert.SerializeObject(Data);
 //            File.WriteAllText(path, outjson);
 //        }

        /// <summary>
        /// 获取保存的数据
        /// </summary>
        public static void Read()
        {
            if (File.Exists(path))
            {
                string JsonString = File.ReadAllText(path);
                var result = JsonConvert.DeserializeObject<T>(JsonString);
                if (result != null) { Data = result; }
            }
        }
 //        /// <summary>
 //        /// 获取保存的数据
 //        /// </summary>
 //        public static void Read()
 //        {
 //            if (File.Exists(path))
 //            {
 //                string JsonString = File.ReadAllText(path);
 //                var result = JsonConvert.DeserializeObject<T>(JsonString);
 //                if (result != null) { Data = result; }
 //            }
 //        }

        /// <summary>
        /// 保存带接口的对象
        /// </summary>
        public static void SaveInterface()
        {
            var settings = new JsonSerializerSettings();
            settings.TypeNameHandling = TypeNameHandling.Objects;
            string outjson = JsonConvert.SerializeObject(Data, Formatting.Indented, settings);
            File.WriteAllText(path, outjson);
        }
 //        /// <summary>
 //        /// 保存带接口的对象
 //        /// </summary>
 //        public static void SaveInterface()
 //        {
 //            var settings = new JsonSerializerSettings();
 //            settings.TypeNameHandling = TypeNameHandling.Objects;
 //            string outjson = JsonConvert.SerializeObject(Data, Formatting.Indented, settings);
 //            File.WriteAllText(path, outjson);
 //        }

        /// <summary>
        /// 获取带接口对象的字符串
        /// </summary>
        public static void ReadInterface()
        {
            if (File.Exists(path))
            {
                var settings = new JsonSerializerSettings();
                settings.TypeNameHandling = TypeNameHandling.Objects;
                string JsonString = File.ReadAllText(path);
                var result = JsonConvert.DeserializeObject<T>(JsonString, settings);
                if (result != null) { Data = result; }
            }
        }
 //        /// <summary>
 //        /// 获取带接口对象的字符串
 //        /// </summary>
 //        public static void ReadInterface()
 //        {
 //            if (File.Exists(path))
 //            {
 //                var settings = new JsonSerializerSettings();
 //                settings.TypeNameHandling = TypeNameHandling.Objects;
 //                string JsonString = File.ReadAllText(path);
 //                var result = JsonConvert.DeserializeObject<T>(JsonString, settings);
 //                if (result != null) { Data = result; }
 //            }
 //        }

        /*
         使用反序列化接口对象的方法
        一、使用 SaveInterface 方法保存成字符串，使用 ReadInterface 方法获取对象
        二、在接口属性上加一个特性 [JsonProperty(TypeNameHandling = TypeNameHandling.Auto)]
         */
 //        /*
 //         使用反序列化接口对象的方法
 //        一、使用 SaveInterface 方法保存成字符串，使用 ReadInterface 方法获取对象
 //        二、在接口属性上加一个特性 [JsonProperty(TypeNameHandling = TypeNameHandling.Auto)]
 //         */


    }
 }
 //    }
 //}
--- a/HKHelper/ThreadManage.cs
+++ b/HKHelper/ThreadManage.cs
@@ -1,445 +1,445 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;

 namespace HKHelper
 {
    public class Singleton<T> where T : new()
    {
        private static object _async = new object();

        private static T _instance;

        static readonly Lazy<T> instance = new();
        /// <summary>
        /// 获取实例
        /// </summary>
        /// <returns></returns>
        public static T GetInstance()
        {
            return instance.Value;
        }
    }
    public class ThreadManage : Singleton<ThreadManage>
    {
        string guid = "871d7e28-c413-4675-8d28-64e4dca4c2d3-";
        private static readonly object _lock = new object();
        StringBuilder callbackKey = new StringBuilder();
        List<string> keys = new List<string>();
        ConcurrentDictionary<string, Task> Threads = new ConcurrentDictionary<string, Task>();
        ConcurrentDictionary<string, CancellationTokenSource> CancellationTokenSources = new ConcurrentDictionary<string, CancellationTokenSource>();

        /// <summary>
        /// 停止指定任务
        /// </summary>
        /// <param name="key">任务名</param>
        /// <param name="ExitCallback">任务结束的回调</param>
        public void StopTask(string key, Action ExitCallback = null)
        {
            if (CancellationTokenSources.ContainsKey(guid + key))
            {
                CancellationTokenSources[guid + key]?.Cancel();
                ActionManage.GetInstance.Register(ExitCallback, guid + key);
            }
            else
            {
                if (ExitCallback != null) ExitCallback();
            }
        }

        /// <summary>
        /// 长任务，带 while true 的循环
        /// </summary>
        /// <param name="action"></param>
        /// <param name="key"></param>
        public void StartLong(Action action, string key, bool IsRestart = false, Action RunComplete = null)
        {
            CancellationTokenSources.TryAdd(guid + key, new CancellationTokenSource());
            bool result = Threads.TryAdd(guid + key, Task.Factory.StartNew(new Action(() =>
            {
                Thread.CurrentThread.Name = key;
            ReStart:
                try
                {
                    while (!CancellationTokenSources[guid + key].IsCancellationRequested)
                    {
                        if (action != null) action();
                    }
                }
                catch (Exception ex)
                {
                    if (IsRestart)
                    {
                        Thread.Sleep(2000);
                        goto ReStart;
                    }
                    else
                    {
                        CancellationTokenSources.TryRemove(guid + key, out CancellationTokenSource temp);
                        Threads.TryRemove(guid + key, out Task temp1);
                    }
                }
            }), CancellationTokenSources[guid + key].Token).ContinueWith(new Action<Task, object>((t, o) =>
            {
                ThreadStatus(t, o.ToString());
                if (RunComplete != null) RunComplete();
            }), guid + key));
        }


        /// <summary>
        /// 不带 while true 的循环任务
        /// </summary>
        /// <param name="action"></param>
        /// <param name="key"></param>
        public void Start(Action action, string key, bool isRestart = false)
        {
            CancellationTokenSources.TryAdd(guid + key, new CancellationTokenSource());
            bool result = Threads.TryAdd(guid + key, Task.Factory.StartNew(new Action(() =>
            {
                Thread.CurrentThread.Name = key;
                try
                {
                    if (action != null) action();
                }
                catch (Exception ex)
                {
                    if (isRestart)
                    {
                        CancellationTokenSources.TryRemove(guid + key, out CancellationTokenSource item1);
                        Threads.TryRemove(guid + key, out Task item2);
                        Start(action, key, isRestart);
                    }
                    else
                    {
                    }
                }
            }), CancellationTokenSources[guid + key].Token).ContinueWith(new Action<Task, object>((t, o) =>
            {
                ThreadStatus(t, o.ToString());
            }), guid + key));
        }

        private void ThreadStatus(Task task, string key)
        {
            bool IsRemove = false;
            string name = key.Substring(key.LastIndexOf('-') + 1);
            switch (task.Status)
            {
                case TaskStatus.RanToCompletion:
                    IsRemove = true;
                    break;
                case TaskStatus.Faulted:
                    IsRemove = true;
                    break;
                case TaskStatus.Canceled:
                    IsRemove = true;
                    break;
                default:
                    break;
            }

            if (IsRemove)
            {
                if (Threads.ContainsKey(key))
                    Threads.TryRemove(key, out Task t);
                if (CancellationTokenSources.ContainsKey(key))
                    CancellationTokenSources.TryRemove(key, out CancellationTokenSource cts);
                ActionManage.GetInstance.Send(key);
            }
        }

        /// <summary>
        /// 释放所有线程资源
        /// </summary>
        public void Dispose()
        {
            for (int i = 0; i < CancellationTokenSources.Count; i++)
            {
                CancellationTokenSources.ElementAt(i).Value.Cancel();
            }
        }

        /// <summary>
        /// 判断指定线程是否完成
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool IsComplete(string key)
        {
            if (Threads.ContainsKey(guid + key)) return Threads[guid + key].IsCompleted;
            return false;
        }

    }
    internal class Delegation
    {
        /// <summary>
        /// 带参数的委托
        /// </summary>
        public Action<object> ActionPar { get; set; }
        /// <summary>
        /// 带参数的委托
        /// </summary>
        public Action<object[]> ActionPars { get; set; }
        /// <summary>
        /// 无参数的委托
        /// </summary>
        public Action ActionBus { get; set; }
        /// <summary>
        /// 有返回值的委托
        /// </summary>
        public Func<object> FuncObj { get; set; }
        /// <summary>
        /// 有返回值，有参数的委托
        /// </summary>
        public Func<object, object> FuncPar { get; set; }
    }
    public class ActionManage
    {

        private volatile static ActionManage _Instance;
        public static ActionManage GetInstance => _Instance ?? (_Instance = new ActionManage());
        private ActionManage() { }

        //private static ConcurrentDictionary<string, delegate> actions = new ConcurrentDictionary<string, delegate>();
        private static ConcurrentDictionary<string, Delegation> actions = new ConcurrentDictionary<string, Delegation>();

        static readonly object SendLock = new object();
        static readonly object SendParLock = new object();
        static readonly object RegisterLock = new object();

        /// <summary>
        /// 注销委托
        /// </summary>
        /// <param name="key"></param>
        public void CancelRegister(string key)
        {
            if (actions.ContainsKey(key))
                actions.TryRemove(key, out Delegation t);
        }

        /// <summary>
        /// 执行注册过的委托
        /// </summary>
        /// <param name="key">注册委托的key</param>
        /// <param name="par">委托参数</param>
        /// <param name="Callback">委托回调</param>
        public void Send(string key, object par, Action Callback = null)
        {
            lock (SendLock)
                if (actions.ContainsKey(key)) actions[key].ActionPar.Invoke(par, Callback);
        }

        /// <summary>
        /// 执行注册过的委托
        /// </summary>
        /// <param name="key">注册委托的key</param>
        /// <param name="par">委托参数</param>
        /// <param name="Callback">委托回调</param>
        public void Send(string key, object[] par, Action Callback = null)
        {
            lock (SendLock)
                if (actions.ContainsKey(key)) actions[key].ActionPars.Invokes(par, Callback);
        }

        /// <summary>
        /// 执行注册过的委托
        /// </summary>
        /// <param name="key">注册委托的key</param>
        /// <param name="Callback">委托回调</param>
        public void Send(string key, Action Callback = null)
        {
            lock (SendLock)
                if (actions.ContainsKey(key)) actions[key].ActionBus?.Invoke(Callback);
        }

        public object SendResult(string key, object par = null)
        {
            lock (SendLock)
                if (actions.ContainsKey(key))
                    if (par == null)
                    {
                        return actions[key].FuncObj?.Invoke();
                    }
                    else
                    {
                        return actions[key].FuncPar?.Invoke(par);
                    }
            return default;
        }

        public void Register<T>(T action, string key)
        {
            lock (RegisterLock)
            {
                if (action != null)
                {
                    if (!actions.ContainsKey(key))
                    {
                        if (action is Action actionBus)
                            actions.TryAdd(key, new Delegation() { ActionBus = actionBus });

                        if (action is Action<object> actionObj)
                            actions.TryAdd(key, new Delegation() { ActionPar = actionObj });

                        if (action is Action<object[]> actionObjs)
                            actions.TryAdd(key, new Delegation() { ActionPars = actionObjs });

                        if (action is Func<object> funcObj)
                            actions.TryAdd(key, new Delegation() { FuncObj = funcObj });

                        if (action is Func<object, object> puncPar)
                            actions.TryAdd(key, new Delegation() { FuncPar = puncPar });
                    }
                }
            }

        }

    }
    public static class ExpandMethod
    {
        /// <summary>
        /// 获取布尔数组指定值得索引
        /// </summary>
        /// <param name="obj">要获取索引的数组</param>
        /// <param name="value">要获取索引的值</param>
        /// <returns></returns>
        public static int GetIndex(this bool[] obj, bool value)
        {
            if (obj == null) return -1;
            return Array.FindIndex(obj, p => p == value);
        }

        /// <summary>
        /// 获取字符串数组指定值得索引
        /// </summary>
        /// <param name="obj">要获取索引的数组</param>
        /// <param name="value">要获取索引的值</param>
        /// <returns></returns>
        public static int GetIndex(this string[] obj, string value)
        {
            if (obj == null || value == null) return -1;
            return Array.FindIndex(obj, p => p == value && p.Length > 0);
        }

        /// <summary>
        /// 委托回调
        /// </summary>
        /// <param name="action">要执行的委托</param>
        /// <param name="callback">委托回调</param>
        public static void Invoke(this Action action, Action callback)
        {
            action?.Invoke();
            callback?.Invoke();
        }

        /// <summary>
        /// 委托回调
        /// </summary>
        /// <param name="action">要执行的委托</param>
        /// <param name="par">要执行的委托的参数</param>
        /// <param name="callback">委托回调</param>
        public static void Invoke(this Action<object> action, object par, Action callback)
        {
            action?.Invoke(par);
            callback?.Invoke();
        }

        public static void Invokes(this Action<object[]> action, object[] par, Action callback)
        {
            action?.Invoke(par);
            callback?.Invoke();
        }


        /// <summary>
        /// 字节数组转换成32位整数
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public static int BytesToInt(this byte[] bytes)
        {
            if (bytes.Length > 4) return -1;
            int ReturnVlaue = 0;
            for (int i = 0; i < bytes.Length; i++)
            {
                ReturnVlaue += (int)(bytes[i] << (i * 8));
            }
            return ReturnVlaue;
        }

        /// <summary>
        /// 字节数组转换成 ushort 数组
        /// </summary>
        /// <param name="bytes">要转换的字节数组</param>
        /// <param name="reverse">字节高度顺序控制</param>
        /// <returns></returns>
        public static ushort[] BytesToUshorts(this byte[] bytes, bool reverse = false)
        {
            int len = bytes.Length;

            byte[] srcPlus = new byte[len + 1];
            bytes.CopyTo(srcPlus, 0);
            int count = len >> 1;

            if (len % 2 != 0)
            {
                count += 1;
            }

            ushort[] dest = new ushort[count];
            if (reverse)
            {
                for (int i = 0; i < count; i++)
                {
                    dest[i] = (ushort)(srcPlus[i * 2] << 8 | srcPlus[2 * i + 1] & 0xff);
                }
            }
            else
            {
                for (int i = 0; i < count; i++)
                {
                    dest[i] = (ushort)(srcPlus[i * 2] & 0xff | srcPlus[2 * i + 1] << 8);
                }
            }

            return dest;
        }

        /// <summary>
        /// ushort 数组转换成字节数组
        /// </summary>
        /// <param name="src">需要转换的 ushort数组</param>
        /// <param name="reverse">高低字节的设置</param>
        /// <returns></returns>
        public static byte[] UshortsToBytes(this ushort[] src, bool reverse = false)
        {

            int count = src.Length;
            byte[] dest = new byte[count << 1];
            if (reverse)
            {
                for (int i = 0; i < count; i++)
                {
                    dest[i * 2] = (byte)(src[i] >> 8);
                    dest[i * 2 + 1] = (byte)(src[i] >> 0);
                }
            }
            else
            {
                for (int i = 0; i < count; i++)
                {
                    dest[i * 2] = (byte)(src[i] >> 0);
                    dest[i * 2 + 1] = (byte)(src[i] >> 8);
                }
            }
            return dest;
        }
    }
 }
 //using System;
 //using System.Collections.Concurrent;
 //using System.Collections.Generic;
 //using System.Linq;
 //using System.Text;
 //using System.Threading;
 //using System.Threading.Tasks;

 //namespace HKHelper
 //{
 //    public class Singleton<T> where T : new()
 //    {
 //        private static object _async = new object();

 //        private static T _instance;

 //        static readonly Lazy<T> instance = new();
 //        /// <summary>
 //        /// 获取实例
 //        /// </summary>
 //        /// <returns></returns>
 //        public static T GetInstance()
 //        {
 //            return instance.Value;
 //        }
 //    }
 //    public class ThreadManage : Singleton<ThreadManage>
 //    {
 //        string guid = "871d7e28-c413-4675-8d28-64e4dca4c2d3-";
 //        private static readonly object _lock = new object();
 //        StringBuilder callbackKey = new StringBuilder();
 //        List<string> keys = new List<string>();
 //        ConcurrentDictionary<string, Task> Threads = new ConcurrentDictionary<string, Task>();
 //        ConcurrentDictionary<string, CancellationTokenSource> CancellationTokenSources = new ConcurrentDictionary<string, CancellationTokenSource>();

 //        /// <summary>
 //        /// 停止指定任务
 //        /// </summary>
 //        /// <param name="key">任务名</param>
 //        /// <param name="ExitCallback">任务结束的回调</param>
 //        public void StopTask(string key, Action ExitCallback = null)
 //        {
 //            if (CancellationTokenSources.ContainsKey(guid + key))
 //            {
 //                CancellationTokenSources[guid + key]?.Cancel();
 //                ActionManage.GetInstance.Register(ExitCallback, guid + key);
 //            }
 //            else
 //            {
 //                if (ExitCallback != null) ExitCallback();
 //            }
 //        }

 //        /// <summary>
 //        /// 长任务，带 while true 的循环
 //        /// </summary>
 //        /// <param name="action"></param>
 //        /// <param name="key"></param>
 //        public void StartLong(Action action, string key, bool IsRestart = false, Action RunComplete = null)
 //        {
 //            CancellationTokenSources.TryAdd(guid + key, new CancellationTokenSource());
 //            bool result = Threads.TryAdd(guid + key, Task.Factory.StartNew(new Action(() =>
 //            {
 //                Thread.CurrentThread.Name = key;
 //            ReStart:
 //                try
 //                {
 //                    while (!CancellationTokenSources[guid + key].IsCancellationRequested)
 //                    {
 //                        if (action != null) action();
 //                    }
 //                }
 //                catch (Exception ex)
 //                {
 //                    if (IsRestart)
 //                    {
 //                        Thread.Sleep(2000);
 //                        goto ReStart;
 //                    }
 //                    else
 //                    {
 //                        CancellationTokenSources.TryRemove(guid + key, out CancellationTokenSource temp);
 //                        Threads.TryRemove(guid + key, out Task temp1);
 //                    }
 //                }
 //            }), CancellationTokenSources[guid + key].Token).ContinueWith(new Action<Task, object>((t, o) =>
 //            {
 //                ThreadStatus(t, o.ToString());
 //                if (RunComplete != null) RunComplete();
 //            }), guid + key));
 //        }


 //        /// <summary>
 //        /// 不带 while true 的循环任务
 //        /// </summary>
 //        /// <param name="action"></param>
 //        /// <param name="key"></param>
 //        public void Start(Action action, string key, bool isRestart = false)
 //        {
 //            CancellationTokenSources.TryAdd(guid + key, new CancellationTokenSource());
 //            bool result = Threads.TryAdd(guid + key, Task.Factory.StartNew(new Action(() =>
 //            {
 //                Thread.CurrentThread.Name = key;
 //                try
 //                {
 //                    if (action != null) action();
 //                }
 //                catch (Exception ex)
 //                {
 //                    if (isRestart)
 //                    {
 //                        CancellationTokenSources.TryRemove(guid + key, out CancellationTokenSource item1);
 //                        Threads.TryRemove(guid + key, out Task item2);
 //                        Start(action, key, isRestart);
 //                    }
 //                    else
 //                    {
 //                    }
 //                }
 //            }), CancellationTokenSources[guid + key].Token).ContinueWith(new Action<Task, object>((t, o) =>
 //            {
 //                ThreadStatus(t, o.ToString());
 //            }), guid + key));
 //        }

 //        private void ThreadStatus(Task task, string key)
 //        {
 //            bool IsRemove = false;
 //            string name = key.Substring(key.LastIndexOf('-') + 1);
 //            switch (task.Status)
 //            {
 //                case TaskStatus.RanToCompletion:
 //                    IsRemove = true;
 //                    break;
 //                case TaskStatus.Faulted:
 //                    IsRemove = true;
 //                    break;
 //                case TaskStatus.Canceled:
 //                    IsRemove = true;
 //                    break;
 //                default:
 //                    break;
 //            }

 //            if (IsRemove)
 //            {
 //                if (Threads.ContainsKey(key))
 //                    Threads.TryRemove(key, out Task t);
 //                if (CancellationTokenSources.ContainsKey(key))
 //                    CancellationTokenSources.TryRemove(key, out CancellationTokenSource cts);
 //                ActionManage.GetInstance.Send(key);
 //            }
 //        }

 //        /// <summary>
 //        /// 释放所有线程资源
 //        /// </summary>
 //        public void Dispose()
 //        {
 //            for (int i = 0; i < CancellationTokenSources.Count; i++)
 //            {
 //                CancellationTokenSources.ElementAt(i).Value.Cancel();
 //            }
 //        }

 //        /// <summary>
 //        /// 判断指定线程是否完成
 //        /// </summary>
 //        /// <param name="key"></param>
 //        /// <returns></returns>
 //        public bool IsComplete(string key)
 //        {
 //            if (Threads.ContainsKey(guid + key)) return Threads[guid + key].IsCompleted;
 //            return false;
 //        }

 //    }
 //    internal class Delegation
 //    {
 //        /// <summary>
 //        /// 带参数的委托
 //        /// </summary>
 //        public Action<object> ActionPar { get; set; }
 //        /// <summary>
 //        /// 带参数的委托
 //        /// </summary>
 //        public Action<object[]> ActionPars { get; set; }
 //        /// <summary>
 //        /// 无参数的委托
 //        /// </summary>
 //        public Action ActionBus { get; set; }
 //        /// <summary>
 //        /// 有返回值的委托
 //        /// </summary>
 //        public Func<object> FuncObj { get; set; }
 //        /// <summary>
 //        /// 有返回值，有参数的委托
 //        /// </summary>
 //        public Func<object, object> FuncPar { get; set; }
 //    }
 //    public class ActionManage
 //    {

 //        private volatile static ActionManage _Instance;
 //        public static ActionManage GetInstance => _Instance ?? (_Instance = new ActionManage());
 //        private ActionManage() { }

 //        //private static ConcurrentDictionary<string, delegate> actions = new ConcurrentDictionary<string, delegate>();
 //        private static ConcurrentDictionary<string, Delegation> actions = new ConcurrentDictionary<string, Delegation>();

 //        static readonly object SendLock = new object();
 //        static readonly object SendParLock = new object();
 //        static readonly object RegisterLock = new object();

 //        /// <summary>
 //        /// 注销委托
 //        /// </summary>
 //        /// <param name="key"></param>
 //        public void CancelRegister(string key)
 //        {
 //            if (actions.ContainsKey(key))
 //                actions.TryRemove(key, out Delegation t);
 //        }

 //        /// <summary>
 //        /// 执行注册过的委托
 //        /// </summary>
 //        /// <param name="key">注册委托的key</param>
 //        /// <param name="par">委托参数</param>
 //        /// <param name="Callback">委托回调</param>
 //        public void Send(string key, object par, Action Callback = null)
 //        {
 //            lock (SendLock)
 //                if (actions.ContainsKey(key)) actions[key].ActionPar.Invoke(par, Callback);
 //        }

 //        /// <summary>
 //        /// 执行注册过的委托
 //        /// </summary>
 //        /// <param name="key">注册委托的key</param>
 //        /// <param name="par">委托参数</param>
 //        /// <param name="Callback">委托回调</param>
 //        public void Send(string key, object[] par, Action Callback = null)
 //        {
 //            lock (SendLock)
 //                if (actions.ContainsKey(key)) actions[key].ActionPars.Invokes(par, Callback);
 //        }

 //        /// <summary>
 //        /// 执行注册过的委托
 //        /// </summary>
 //        /// <param name="key">注册委托的key</param>
 //        /// <param name="Callback">委托回调</param>
 //        public void Send(string key, Action Callback = null)
 //        {
 //            lock (SendLock)
 //                if (actions.ContainsKey(key)) actions[key].ActionBus?.Invoke(Callback);
 //        }

 //        public object SendResult(string key, object par = null)
 //        {
 //            lock (SendLock)
 //                if (actions.ContainsKey(key))
 //                    if (par == null)
 //                    {
 //                        return actions[key].FuncObj?.Invoke();
 //                    }
 //                    else
 //                    {
 //                        return actions[key].FuncPar?.Invoke(par);
 //                    }
 //            return default;
 //        }

 //        public void Register<T>(T action, string key)
 //        {
 //            lock (RegisterLock)
 //            {
 //                if (action != null)
 //                {
 //                    if (!actions.ContainsKey(key))
 //                    {
 //                        if (action is Action actionBus)
 //                            actions.TryAdd(key, new Delegation() { ActionBus = actionBus });

 //                        if (action is Action<object> actionObj)
 //                            actions.TryAdd(key, new Delegation() { ActionPar = actionObj });

 //                        if (action is Action<object[]> actionObjs)
 //                            actions.TryAdd(key, new Delegation() { ActionPars = actionObjs });

 //                        if (action is Func<object> funcObj)
 //                            actions.TryAdd(key, new Delegation() { FuncObj = funcObj });

 //                        if (action is Func<object, object> puncPar)
 //                            actions.TryAdd(key, new Delegation() { FuncPar = puncPar });
 //                    }
 //                }
 //            }

 //        }

 //    }
 //    public static class ExpandMethod
 //    {
 //        /// <summary>
 //        /// 获取布尔数组指定值得索引
 //        /// </summary>
 //        /// <param name="obj">要获取索引的数组</param>
 //        /// <param name="value">要获取索引的值</param>
 //        /// <returns></returns>
 //        public static int GetIndex(this bool[] obj, bool value)
 //        {
 //            if (obj == null) return -1;
 //            return Array.FindIndex(obj, p => p == value);
 //        }

 //        /// <summary>
 //        /// 获取字符串数组指定值得索引
 //        /// </summary>
 //        /// <param name="obj">要获取索引的数组</param>
 //        /// <param name="value">要获取索引的值</param>
 //        /// <returns></returns>
 //        public static int GetIndex(this string[] obj, string value)
 //        {
 //            if (obj == null || value == null) return -1;
 //            return Array.FindIndex(obj, p => p == value && p.Length > 0);
 //        }

 //        /// <summary>
 //        /// 委托回调
 //        /// </summary>
 //        /// <param name="action">要执行的委托</param>
 //        /// <param name="callback">委托回调</param>
 //        public static void Invoke(this Action action, Action callback)
 //        {
 //            action?.Invoke();
 //            callback?.Invoke();
 //        }

 //        /// <summary>
 //        /// 委托回调
 //        /// </summary>
 //        /// <param name="action">要执行的委托</param>
 //        /// <param name="par">要执行的委托的参数</param>
 //        /// <param name="callback">委托回调</param>
 //        public static void Invoke(this Action<object> action, object par, Action callback)
 //        {
 //            action?.Invoke(par);
 //            callback?.Invoke();
 //        }

 //        public static void Invokes(this Action<object[]> action, object[] par, Action callback)
 //        {
 //            action?.Invoke(par);
 //            callback?.Invoke();
 //        }


 //        /// <summary>
 //        /// 字节数组转换成32位整数
 //        /// </summary>
 //        /// <param name="bytes"></param>
 //        /// <returns></returns>
 //        public static int BytesToInt(this byte[] bytes)
 //        {
 //            if (bytes.Length > 4) return -1;
 //            int ReturnVlaue = 0;
 //            for (int i = 0; i < bytes.Length; i++)
 //            {
 //                ReturnVlaue += (int)(bytes[i] << (i * 8));
 //            }
 //            return ReturnVlaue;
 //        }

 //        /// <summary>
 //        /// 字节数组转换成 ushort 数组
 //        /// </summary>
 //        /// <param name="bytes">要转换的字节数组</param>
 //        /// <param name="reverse">字节高度顺序控制</param>
 //        /// <returns></returns>
 //        public static ushort[] BytesToUshorts(this byte[] bytes, bool reverse = false)
 //        {
 //            int len = bytes.Length;

 //            byte[] srcPlus = new byte[len + 1];
 //            bytes.CopyTo(srcPlus, 0);
 //            int count = len >> 1;

 //            if (len % 2 != 0)
 //            {
 //                count += 1;
 //            }

 //            ushort[] dest = new ushort[count];
 //            if (reverse)
 //            {
 //                for (int i = 0; i < count; i++)
 //                {
 //                    dest[i] = (ushort)(srcPlus[i * 2] << 8 | srcPlus[2 * i + 1] & 0xff);
 //                }
 //            }
 //            else
 //            {
 //                for (int i = 0; i < count; i++)
 //                {
 //                    dest[i] = (ushort)(srcPlus[i * 2] & 0xff | srcPlus[2 * i + 1] << 8);
 //                }
 //            }

 //            return dest;
 //        }

 //        /// <summary>
 //        /// ushort 数组转换成字节数组
 //        /// </summary>
 //        /// <param name="src">需要转换的 ushort数组</param>
 //        /// <param name="reverse">高低字节的设置</param>
 //        /// <returns></returns>
 //        public static byte[] UshortsToBytes(this ushort[] src, bool reverse = false)
 //        {

 //            int count = src.Length;
 //            byte[] dest = new byte[count << 1];
 //            if (reverse)
 //            {
 //                for (int i = 0; i < count; i++)
 //                {
 //                    dest[i * 2] = (byte)(src[i] >> 8);
 //                    dest[i * 2 + 1] = (byte)(src[i] >> 0);
 //                }
 //            }
 //            else
 //            {
 //                for (int i = 0; i < count; i++)
 //                {
 //                    dest[i * 2] = (byte)(src[i] >> 0);
 //                    dest[i * 2 + 1] = (byte)(src[i] >> 8);
 //                }
 //            }
 //            return dest;
 //        }
 //    }
 //}