304 lines
12 KiB
C#
304 lines
12 KiB
C#
using DeviceCommand.Base;
|
||
using Logger;
|
||
using Model.Models;
|
||
using Prism.Ioc;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.IO.Ports;
|
||
using System.Linq;
|
||
using System.Reflection;
|
||
using UIShare.UIViewModel;
|
||
|
||
namespace UIShare.GlobalVariable
|
||
{
|
||
/// <summary>
|
||
/// 设备管理器：根据 <see cref="SystemConfig.DeviceList"/> 反射实例化所有启用的设备，
|
||
/// 通过 <see cref="IBaseInterface"/> 多态统一管理，避免为每种设备单独硬编码字段。
|
||
/// </summary>
|
||
public class DeviceManager
|
||
{
|
||
private object _lockObj = new object();
|
||
public SystemConfig _systemConfig { get; set; }
|
||
|
||
/// <summary>按 DeviceName 索引的设备字典，便于业务层按名取实例。</summary>
|
||
public IDictionary<string, IBaseInterface> DeviceMap { get; private set; }
|
||
= new Dictionary<string, IBaseInterface>(StringComparer.OrdinalIgnoreCase);
|
||
|
||
/// <summary>类名 → Type 的反射缓存（仅扫描一次）。</summary>
|
||
private static readonly IReadOnlyDictionary<string, Type> _deviceTypeMap = BuildDeviceTypeMap();
|
||
|
||
public DeviceManager(SystemConfig systemConfig)
|
||
{
|
||
_systemConfig = systemConfig;
|
||
InitDevices();
|
||
}
|
||
private void InitDevices()
|
||
{
|
||
DeviceMap = new Dictionary<string, IBaseInterface>(StringComparer.OrdinalIgnoreCase);
|
||
|
||
if (_systemConfig?.DeviceList == null) return;
|
||
|
||
foreach (var config in _systemConfig.DeviceList)
|
||
{
|
||
if (config == null || !config.IsEnabled) continue;
|
||
|
||
if (string.IsNullOrWhiteSpace(config.DeviceType) ||
|
||
!_deviceTypeMap.TryGetValue(config.DeviceType, out var deviceType))
|
||
{
|
||
LoggerHelper.Warn($"未识别的设备类型 [{config.DeviceType}]，已跳过 [{config.DeviceName}]。");
|
||
continue;
|
||
}
|
||
|
||
try
|
||
{
|
||
IBaseInterface? instance = config.ConnectionType switch
|
||
{
|
||
"Tcp" => CreateTcpDevice(deviceType, config.TcpConfig),
|
||
"Serial" => CreateSerialDevice(deviceType, config.SerialPortConfig),
|
||
_ => null
|
||
};
|
||
|
||
if (instance == null)
|
||
{
|
||
LoggerHelper.Warn($"设备 [{config.DeviceName}] 连接方式 [{config.ConnectionType}] 不支持，已跳过。");
|
||
continue;
|
||
}
|
||
if (!string.IsNullOrWhiteSpace(config.DeviceName))
|
||
{
|
||
DeviceMap[config.DeviceName] = instance;
|
||
}
|
||
|
||
LoggerHelper.Info($"已加载设备 [{config.DeviceName} / {config.DeviceType} / {config.ConnectionType}]");
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
var inner = ex.InnerException?.Message ?? ex.Message;
|
||
LoggerHelper.ErrorWithNotify($"设备 [{config.DeviceName}] 实例化失败：{inner}");
|
||
}
|
||
}
|
||
}
|
||
|
||
public async Task ConnectAllDevices(CancellationToken ct = default)
|
||
{
|
||
if (_systemConfig?.DeviceList == null || DeviceMap.Count == 0) return;
|
||
|
||
var tasks = new List<Task>();
|
||
foreach (var info in _systemConfig.DeviceList)
|
||
{
|
||
if (info == null || !info.IsEnabled) continue;
|
||
if (string.IsNullOrWhiteSpace(info.DeviceName)) continue;
|
||
if (!DeviceMap.TryGetValue(info.DeviceName, out var device)) continue;
|
||
|
||
tasks.Add(ConnectInternalAsync(info, device, ct));
|
||
}
|
||
|
||
await Task.WhenAll(tasks);
|
||
}
|
||
|
||
|
||
public async Task ConnectSpecifiedDevice(string deviceName, CancellationToken ct = default)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(deviceName))
|
||
{
|
||
LoggerHelper.Warn("ConnectSpecifiedDevice：设备名为空。");
|
||
return;
|
||
}
|
||
|
||
if (!DeviceMap.TryGetValue(deviceName, out var device))
|
||
{
|
||
LoggerHelper.Warn($"ConnectSpecifiedDevice：未找到设备 [{deviceName}]。");
|
||
return;
|
||
}
|
||
|
||
var info = _systemConfig?.DeviceList?
|
||
.FirstOrDefault(d => d != null && string.Equals(d.DeviceName, deviceName, StringComparison.OrdinalIgnoreCase));
|
||
|
||
await ConnectInternalAsync(info, device, ct);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 异步关闭指定设备，释放底层连接并更新 UI 状态
|
||
/// </summary>
|
||
public async Task CloseDeviceAsync(string deviceName)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(deviceName)) return;
|
||
|
||
IBaseInterface? device;
|
||
DeviceInfoVM? info;
|
||
|
||
lock (_lockObj)
|
||
{
|
||
if (!DeviceMap.TryGetValue(deviceName, out device)) return;
|
||
|
||
info = _systemConfig?.DeviceList?
|
||
.FirstOrDefault(d => d != null && string.Equals(d.DeviceName, deviceName, StringComparison.OrdinalIgnoreCase));
|
||
}
|
||
|
||
await CloseInternalAsync(info, device);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 异步关闭所有设备
|
||
/// </summary>
|
||
public async Task CloseAllDevicesAsync()
|
||
{
|
||
List<Task> tasks = new List<Task>();
|
||
|
||
lock (_lockObj)
|
||
{
|
||
if (DeviceMap.Count == 0) return;
|
||
|
||
foreach (var kvp in DeviceMap)
|
||
{
|
||
string deviceName = kvp.Key;
|
||
var device = kvp.Value;
|
||
var info = _systemConfig?.DeviceList?
|
||
.FirstOrDefault(d => d != null && string.Equals(d.DeviceName, deviceName, StringComparison.OrdinalIgnoreCase));
|
||
|
||
tasks.Add(CloseInternalAsync(info, device));
|
||
}
|
||
}
|
||
|
||
await Task.WhenAll(tasks);
|
||
LoggerHelper.Info("所有设备已执行关闭操作。");
|
||
}
|
||
|
||
#region 辅助方法
|
||
private async Task CloseInternalAsync(DeviceInfoVM? info, IBaseInterface device)
|
||
{
|
||
string name = info?.DeviceName ?? device.GetType().Name;
|
||
string conn = info?.ConnectionType ?? "?";
|
||
|
||
try
|
||
{
|
||
// 如果设备本身已经是断开状态，直接更新 UI 并返回
|
||
if (!device.IsConnected)
|
||
{
|
||
if (info != null) info.IsConnected = false;
|
||
LoggerHelper.Info($"设备 [{name}] 本就处于断开状态。");
|
||
return;
|
||
}
|
||
await Task.Run(() => device.Close());
|
||
|
||
LoggerHelper.Info($"设备 [{name}/{conn}] 已成功关闭连接。");
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
var inner = ex.InnerException?.Message ?? ex.Message;
|
||
LoggerHelper.Error($"设备 [{name}/{conn}] 关闭连接时出现异常: {inner}");
|
||
}
|
||
finally
|
||
{
|
||
// 无论关闭时是否抛出异常，均强制同步 UI 状态为未连接
|
||
if (info != null)
|
||
{
|
||
info.IsConnected = false;
|
||
}
|
||
}
|
||
}
|
||
private async Task ConnectInternalAsync(DeviceInfoVM? info, IBaseInterface device, CancellationToken ct)
|
||
{
|
||
string name = info?.DeviceName ?? device.GetType().Name;
|
||
string conn = info?.ConnectionType ?? "?";
|
||
|
||
try
|
||
{
|
||
if (device.IsConnected)
|
||
{
|
||
if (info != null) info.IsConnected = true;
|
||
LoggerHelper.Info($"设备 [{name}] 已连接，跳过。");
|
||
return;
|
||
}
|
||
|
||
bool ok = conn switch
|
||
{
|
||
"Tcp" => await ConnectTcpAsync(name, device, ct),
|
||
"Serial" => await ConnectSerialAsync(name, device, ct),
|
||
_ => false
|
||
};
|
||
|
||
if (info != null) info.IsConnected = ok;
|
||
|
||
if (ok)
|
||
LoggerHelper.Info($"设备 [{name}/{conn}] 连接成功。");
|
||
else
|
||
LoggerHelper.Warn($"设备 [{name}/{conn}] 连接失败。");
|
||
}
|
||
catch (OperationCanceledException)
|
||
{
|
||
if (info != null) info.IsConnected = false;
|
||
LoggerHelper.Warn($"设备 [{name}/{conn}] 连接已取消。");
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
if (info != null) info.IsConnected = false;
|
||
var inner = ex.InnerException?.Message ?? ex.Message;
|
||
LoggerHelper.ErrorWithNotify($"设备 [{name}/{conn}] 连接异常：{inner}");
|
||
}
|
||
}
|
||
|
||
private static async Task<bool> ConnectTcpAsync(string name, IBaseInterface device, CancellationToken ct)
|
||
{
|
||
if (device is not ITcp tcp)
|
||
{
|
||
LoggerHelper.Warn($"设备 [{name}] 配置为 Tcp 但未实现 ITcp，实际类型为 {device.GetType().Name}。");
|
||
return false;
|
||
}
|
||
return await tcp.ConnectAsync(ct);
|
||
}
|
||
|
||
private static async Task<bool> ConnectSerialAsync(string name, IBaseInterface device, CancellationToken ct)
|
||
{
|
||
if (device is not ISerialPort sp)
|
||
{
|
||
LoggerHelper.Warn($"设备 [{name}] 配置为 Serial 但未实现 ISerialPort，实际类型为 {device.GetType().Name}。");
|
||
return false;
|
||
}
|
||
return await sp.ConnectAsync(ct);
|
||
}
|
||
private static IReadOnlyDictionary<string, Type> BuildDeviceTypeMap()
|
||
{
|
||
try
|
||
{
|
||
return typeof(IBaseInterface).Assembly
|
||
.GetTypes()
|
||
.Where(t => t.IsClass && !t.IsAbstract && typeof(IBaseInterface).IsAssignableFrom(t))
|
||
.ToDictionary(t => t.Name, t => t, StringComparer.OrdinalIgnoreCase);
|
||
}
|
||
catch (ReflectionTypeLoadException ex)
|
||
{
|
||
LoggerHelper.Error($"扫描设备类型失败：{ex.Message}");
|
||
return new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase);
|
||
}
|
||
}
|
||
private static IBaseInterface? CreateTcpDevice(Type type, TcpConfigVM? vm)
|
||
{
|
||
vm ??= new TcpConfigVM();
|
||
var cfg = new TcpConfig
|
||
{
|
||
IPAddress = vm.IPAddress,
|
||
Port = vm.Port,
|
||
SendTimeout = vm.SendTimeout,
|
||
ReceiveTimeout = vm.ReceiveTimeout
|
||
};
|
||
return Activator.CreateInstance(type, cfg) as IBaseInterface;
|
||
}
|
||
private static IBaseInterface? CreateSerialDevice(Type type, SerialPortConfigVM? vm)
|
||
{
|
||
vm ??= new SerialPortConfigVM();
|
||
var cfg = new SerialPortConfig
|
||
{
|
||
PortName = vm.PortName,
|
||
BaudRate = vm.BaudRate,
|
||
DataBits = vm.DataBits,
|
||
StopBits = Enum.TryParse<StopBits>(vm.StopBits, true, out var sb) ? sb : StopBits.One,
|
||
Parity = Enum.TryParse<Parity>(vm.Parity, true, out var pa) ? pa : Parity.None,
|
||
ReadTimeout = vm.ReadTimeout,
|
||
WriteTimeout = vm.WriteTimeout
|
||
};
|
||
return Activator.CreateInstance(type, cfg) as IBaseInterface;
|
||
}
|
||
#endregion
|
||
}
|
||
}
|