bpa
/
HKCard
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

消息日志信息修改

Lishi
pry 1 year ago
parent
924377498c
commit
924e847024
17 changed files with 1467 additions and 1449 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +1
    -0
      HKCardIN/HKCardIN.csproj
  2. +2
    -1
      HKCardIN/Helper/HKHelper.cs
  3. +445
    -445
      HKCardIN/Helper/ThreadManage.cs
  4. +5
    -3
      HKCardIN/Logic/BaseLogic.cs
  5. +2
    -1
      HKCardIN/ViewModels/RootViewModel.cs
  6. +4
    -3
      HKCardOUT/Bootstrapper.cs
  7. +1
    -0
      HKCardOUT/HKCardOUT.csproj
  8. +4
    -3
      HKCardOUT/Helper/HKHelpers.cs
  9. +445
    -445
      HKCardOUT/Helper/ThreadManage.cs
  10. +2
    -1
      HKCardOUT/ViewModels/AdWindowViewModel.cs
  11. +7
    -5
      HKCardOUT/ViewModels/RootViewModel.cs
  12. +11
    -2
      HKCardOUT/Views/AdWindow.xaml.cs
  13. +1
    -1
      HKControl/HKControl.csproj
  14. +1
    -22
      HKControl/Main.cs
  15. +19
    -0
      HKHelper/HKHelper.cs
  16. +72
    -72
      HKHelper/Json.cs
  17. +445
    -445
      HKHelper/ThreadManage.cs

+ 1
- 0
HKCardIN/HKCardIN.csproj View File

@@ -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" />


+ 2
- 1
HKCardIN/Helper/HKHelper.cs View File

@@ -1,4 +1,5 @@
using System;
using BPA.Helper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;


+ 445
- 445
HKCardIN/Helper/ThreadManage.cs View File

@@ -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;
// }
// }
//}

+ 5
- 3
HKCardIN/Logic/BaseLogic.cs View File

@@ -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();


+ 2
- 1
HKCardIN/ViewModels/RootViewModel.cs View File

@@ -1,4 +1,5 @@
using HandyControl.Data;
using BPA.Helper;
using HandyControl.Data;
using HKCardIN.Helper;
using HKCardIN.Logic;
using HKCardIN.Logic.Model;


+ 4
- 3
HKCardOUT/Bootstrapper.cs View File

@@ -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();
}


+ 1
- 0
HKCardOUT/HKCardOUT.csproj View File

@@ -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" />


+ 4
- 3
HKCardOUT/Helper/HKHelpers.cs View File

@@ -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);
}

}
}
}

+ 445
- 445
HKCardOUT/Helper/ThreadManage.cs View File

@@ -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;
// }
// }
//}

+ 2
- 1
HKCardOUT/ViewModels/AdWindowViewModel.cs View File

@@ -1,4 +1,5 @@
using DTO;
using BPA.Helper;
using DTO;
using HKCardOUT.Helper;
using HKCardOUT.Logic.Service;
using Microsoft.VisualBasic.ApplicationServices;


+ 7
- 5
HKCardOUT/ViewModels/RootViewModel.cs View File

@@ -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;


+ 11
- 2
HKCardOUT/Views/AdWindow.xaml.cs View File

@@ -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);
}
}
}

+ 1
- 1
HKControl/HKControl.csproj View File

@@ -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>



+ 1
- 22
HKControl/Main.cs View File

@@ -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;



+ 19
- 0
HKHelper/HKHelper.cs View File

@@ -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>


+ 72
- 72
HKHelper/Json.cs View File

@@ -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)]
// */


}
}
// }
//}

+ 445
- 445
HKHelper/ThreadManage.cs View File

@@ -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;
// }
// }
//}

Write Preview
Loading…
Cancel
Save