refactor:完成重构设备的添加，删除，更新。

DMS.Application/Services/AppDataService.cs

@@ -6,12 +6,12 @@ using DMS.Core.Models.Triggers;
 
 namespace DMS.Application.Services;
 
-public class AppStorageService : IAppStorageService
+public class AppDataService : IAppDataService
 {
     /// <summary>
     /// 安全字典，用于存储所有设备数据
     /// </summary>
-            public ConcurrentDictionary<int, Device> Devices { get; } = new();
+    public ConcurrentDictionary<int, Device> Devices { get; } = new();
     /// <summary>
     /// 安全字典，用于存储所有变量表数据
     /// </summary>
@@ -36,15 +36,15 @@ public class AppStorageService : IAppStorageService
     /// 安全字典，用于存储所有MQTT服务器数据
     /// </summary>
     public ConcurrentDictionary<int, MqttServer> MqttServers { get; } = new();
-    
-    
+
+
     /// <summary>
     /// 安全字典，用于存储所有MQTT变量别名的数据
     /// </summary>
     public ConcurrentDictionary<int, MqttAlias> MqttAliases { get; } = new();
-    
-        
-    
+
+
+
     /// <summary>
     /// 安全字典，用于存储所有历史记录
     /// </summary>
@@ -54,7 +54,7 @@ public class AppStorageService : IAppStorageService
     /// 安全字典，用于存储所有日志数据
     /// </summary>
     public ConcurrentDictionary<int, NlogDto> Nlogs { get; } = new();
-    
+
     /// <summary>
     /// 安全字典，用于存储所有触发器定义数据
     /// </summary>

DMS.Application/Services/Database/DeviceAppService.cs

@@ -16,6 +16,7 @@ namespace DMS.Application.Services.Database;
 public class DeviceAppService : IDeviceAppService
 {
     private readonly IRepositoryManager _repoManager;
+    private readonly IAppDataService _appDataService;
     private readonly IMapper _mapper;
 
     /// <summary>
@@ -23,9 +24,10 @@ public class DeviceAppService : IDeviceAppService
     /// </summary>
     /// <param name="repoManager">仓储管理器实例。</param>
     /// <param name="mapper">AutoMapper 实例。</param>
-    public DeviceAppService(IRepositoryManager repoManager, IMapper mapper)
+    public DeviceAppService(IRepositoryManager repoManager, IAppDataService appStorageService, IMapper mapper)
     {
         _repoManager = repoManager;
+        _appDataService = appStorageService;
         _mapper = mapper;
     }
 
@@ -39,7 +41,6 @@ public class DeviceAppService : IDeviceAppService
         var device = await _repoManager.Devices.GetByIdAsync(id);
         return device;
     }
-
     /// <summary>
     /// 异步获取所有设备数据传输对象列表。
     /// </summary>
@@ -86,7 +87,6 @@ public class DeviceAppService : IDeviceAppService
                         $"添加设备变量表失败,设备：{dto.Device.Name},变量表：{dto?.VariableTable?.Name}");
                 }
 
-                dto.VariableTable.Device = dto.Device;
 
                 // 假设有设备菜单
                 if (dto.VariableTableMenu is not null && dto.VariableTableMenu is not null)
@@ -94,11 +94,6 @@ public class DeviceAppService : IDeviceAppService
                     dto.VariableTableMenu.ParentId = dto.DeviceMenu.Id; // 关联设备菜单作为父级
                     dto.VariableTableMenu.TargetId = dto.VariableTable.Id;
                     dto.VariableTableMenu = await _repoManager.Menus.AddAsync(dto.VariableTableMenu);
-                    if (dto.VariableTableMenu == null || dto.VariableTableMenu.Id == 0)
-                    {
-                        throw new InvalidOperationException(
-                            $"添加设备变量表菜单失败,变量表：{dto.VariableTable.Name},变量表菜单：{dto.VariableTableMenu.Header}");
-                    }
                 }
             }
 
@@ -123,16 +118,10 @@ public class DeviceAppService : IDeviceAppService
     public async Task<int> UpdateDeviceAsync(Device device)
     {
         await _repoManager.BeginTranAsync();
-        var existingDevice = await _repoManager.Devices.GetByIdAsync(device.Id);
-        if (existingDevice == null)
-        {
-            throw new ApplicationException($"Device with ID {device.Id} not found.");
-        }
-
-        _mapper.Map(device, existingDevice);
-        int res = await _repoManager.Devices.UpdateAsync(existingDevice);
-        var menu = await _repoManager.Menus.GetMenuByTargetIdAsync(MenuType.DeviceMenu, device.Id);
-        if (menu != null)
+        int res = await _repoManager.Devices.UpdateAsync(device);
+        //获取到设备对应的菜单
+        var menu = _appDataService.Menus.Values.FirstOrDefault(m => m.MenuType == MenuType.DeviceMenu && m.TargetId == device.Id);
+        if (menu is not null && menu.Header!=device.Name)
         {
             menu.Header = device.Name;
             await _repoManager.Menus.UpdateAsync(menu);
@@ -156,19 +145,17 @@ public class DeviceAppService : IDeviceAppService
         {
             await _repoManager.BeginTranAsync();
             var delRes = await _repoManager.Devices.DeleteAsync(device);
-            if (delRes == 0)
-            {
-                throw new InvalidOperationException($"删除设备失败：设备ID:{device.Id}，请检查设备Id是否存在");
-            }
 
-// 删除关联的变量
-            await _repoManager.Variables.DeleteByVariableTableIdAsync(device.Id);
             // 删除关联的变量表
             await _repoManager.VariableTables.DeleteAsync(device.VariableTables);
 
-
-            // 删除关联的菜单树
-            await _repoManager.Menus.DeleteMenuTreeByTargetIdAsync(MenuType.DeviceMenu, device.Id);
+           var menu= _appDataService.Menus.Values.FirstOrDefault(m => m.MenuType == MenuType.DeviceMenu && m.TargetId == device.Id);
+            if (menu is not null)
+            {
+                // 删除关联的菜单树
+                await _repoManager.Menus.DeleteAsync(menu);
+            }
+           
 
             await _repoManager.CommitAsync();
             return true;

DMS.Application/Services/Database/MenuAppService.cs

@@ -1,8 +1,7 @@
 using AutoMapper;
+using DMS.Application.Interfaces;
 using DMS.Core.Interfaces;
 using DMS.Core.Models;
-using DMS.Application.Interfaces.Database;
-using DMS.Application.Interfaces;
 
 namespace DMS.Application.Services.Database;
 
@@ -53,20 +52,9 @@ public class MenuAppService : IMenuAppService
     /// <param name="menu">要创建的菜单。</param>
     /// <returns>新创建菜单的ID。</returns>
     /// <exception cref="ApplicationException">如果创建菜单时发生错误。</exception>
-    public async Task<int> CreateMenuAsync(MenuBean menu)
+    public async Task<MenuBean> AddAsync(MenuBean menu)
     {
-        try
-        {
-            await _repoManager.BeginTranAsync();
-            await _repoManager.Menus.AddAsync(menu);
-            await _repoManager.CommitAsync();
-            return menu.Id;
-        }
-        catch (Exception ex)
-        {
-            await _repoManager.RollbackAsync();
-            throw new ApplicationException("创建菜单时发生错误，操作已回滚。", ex);
-        }
+        return await _repoManager.Menus.AddAsync(menu);
     }
 
     /// <summary>
@@ -75,57 +63,20 @@ public class MenuAppService : IMenuAppService
     /// <param name="menu">要更新的菜单。</param>
     /// <returns>受影响的行数。</returns>
     /// <exception cref="ApplicationException">如果找不到菜单或更新菜单时发生错误。</exception>
-    public async Task<int> UpdateMenuAsync(MenuBean menu)
+    public async Task<int> UpdateAsync(MenuBean menu)
     {
-        try
-        {
-            await _repoManager.BeginTranAsync();
-            var dbmenu = await _repoManager.Menus.GetByIdAsync(menu.Id);
-            if (dbmenu == null)
-            {
-                throw new ApplicationException($"Menu with ID {menu.Id} not found.");
-            }
-            _mapper.Map(menu, dbmenu);
-            int res = await _repoManager.Menus.UpdateAsync(dbmenu);
-            await _repoManager.CommitAsync();
-            return res;
-        }
-        catch (Exception ex)
-        {
-            await _repoManager.RollbackAsync();
-            throw new ApplicationException("更新菜单时发生错误，操作已回滚。", ex);
-        }
+             return await _repoManager.Menus.UpdateAsync(menu);
     }
 
     /// <summary>
     /// 异步删除一个菜单（事务性操作）。
     /// </summary>
-    /// <param name="id">要删除菜单的ID。</param>
     /// <returns>如果删除成功则为 true，否则为 false。</returns>
     /// <exception cref="InvalidOperationException">如果删除菜单失败。</exception>
     /// <exception cref="ApplicationException">如果删除菜单时发生其他错误。</exception>
-    public async Task<bool> DeleteMenuAsync(int id)
+    public async Task<bool> DeleteAsync(MenuBean menu)
     {
-        try
-        {
-            await _repoManager.BeginTranAsync();
-            var menu = await _repoManager.Menus.GetByIdAsync(id);
-            if (menu == null)
-            {
-                throw new InvalidOperationException($"删除菜单失败：菜单ID:{id}，请检查菜单Id是否存在");
-            }
-            var delRes = await _repoManager.Menus.DeleteAsync(menu);
-            if (delRes == 0)
-            {
-                throw new InvalidOperationException($"删除菜单失败：菜单ID:{id}，请检查菜单Id是否存在");
-            }
-            await _repoManager.CommitAsync();
-            return true;
-        }
-        catch (Exception ex)
-        {
-            await _repoManager.RollbackAsync();
-            throw new ApplicationException("删除菜单时发生错误，操作已回滚。", ex);
-        }
+        var delRes = await _repoManager.Menus.DeleteAsync(menu);
+        return delRes > 0;
     }
 }

DMS.Application/Services/Database/MqttAliasAppService.cs

@@ -12,16 +12,16 @@ namespace DMS.Application.Services.Database;
 public class MqttAliasAppService : IMqttAliasAppService
 {
     private readonly IRepositoryManager _repoManager;
-    private readonly IAppStorageService _appStorageService;
+    private readonly IAppDataService _appDataService;
     private readonly IMapper _mapper;
 
     /// <summary>
     /// 构造函数。
     /// </summary>
-    public MqttAliasAppService(IRepositoryManager repoManager,IAppStorageService appStorageService, IMapper mapper)
+    public MqttAliasAppService(IRepositoryManager repoManager,IAppDataService appStorageService, IMapper mapper)
     {
         _repoManager = repoManager;
-        _appStorageService = appStorageService;
+        _appDataService = appStorageService;
         _mapper = mapper;
     }
 

DMS.Application/Services/Database/TriggerAppService.cs

@@ -107,24 +107,24 @@ namespace DMS.Application.Services.Database
                 if (dto.TriggerMenu != null)
                 {
                     // 使用现有的菜单查找逻辑来获取父菜单
-                    var parentMenu = await _repositoryManager.Menus.GetMenuByTargetIdAsync(Core.Enums.MenuType.TriggerMenu, 0);
-                    if (parentMenu != null)
-                    {
-                        // 设置菜单的关联信息
-                        dto.TriggerMenu.ParentId = parentMenu.Id;
-                        dto.TriggerMenu.MenuType = Core.Enums.MenuType.TriggerMenu;
-                        dto.TriggerMenu.TargetId = createdTrigger.Id;
+                    //var parentMenu = await _repositoryManager.Menus.GetMenuByTargetIdAsync(Core.Enums.MenuType.TriggerMenu, 0);
+                    //if (parentMenu != null)
+                    //{
+                    //    // 设置菜单的关联信息
+                    //    dto.TriggerMenu.ParentId = parentMenu.Id;
+                    //    dto.TriggerMenu.MenuType = Core.Enums.MenuType.TriggerMenu;
+                    //    dto.TriggerMenu.TargetId = createdTrigger.Id;
 
-                        // 添加菜单到数据库
-                        var addMenu = await _repositoryManager.Menus.AddAsync(dto.TriggerMenu);
-                        if (addMenu == null || addMenu.Id == 0)
-                        {
-                            throw new InvalidOperationException($"添加触发器菜单失败：{addMenu}");
-                        }
+                    //    // 添加菜单到数据库
+                    //    var addMenu = await _repositoryManager.Menus.AddAsync(dto.TriggerMenu);
+                    //    if (addMenu == null || addMenu.Id == 0)
+                    //    {
+                    //        throw new InvalidOperationException($"添加触发器菜单失败：{addMenu}");
+                    //    }
 
-                        // 更新dto中的菜单对象
-                        dto.TriggerMenu = addMenu;
-                    }
+                    //    // 更新dto中的菜单对象
+                    //    dto.TriggerMenu = addMenu;
+                    //}
                 }
 
                 await _repositoryManager.CommitAsync();

DMS.Application/Services/Database/VariableAppService.cs

@@ -38,27 +38,7 @@ public class VariableAppService : IVariableAppService
         return variable;
     }
 
-    /// <summary>
-    /// 异步根据OPC UA NodeId获取变量数据传输对象。
-    /// </summary>
-    /// <param name="opcUaNodeId">OPC UA NodeId。</param>
-    /// <returns>变量数据传输对象。</returns>
-    public async Task<Variable?> GetVariableByOpcUaNodeIdAsync(string opcUaNodeId)
-    {
-        var variable = await _repoManager.Variables.GetByOpcUaNodeIdAsync(opcUaNodeId);
-        return variable ;
-    }
 
-    /// <summary>
-    /// 异步根据OPC UA NodeId列表获取变量数据传输对象列表。
-    /// </summary>
-    /// <param name="opcUaNodeIds">OPC UA NodeId列表。</param>
-    /// <returns>变量数据传输对象列表。</returns>
-    public async Task<List<Variable>> GetVariableByOpcUaNodeIdsAsync(List<string> opcUaNodeIds)
-    {
-        var variables = await _repoManager.Variables.GetByOpcUaNodeIdsAsync(opcUaNodeIds);
-        return variables;
-    }
 
     /// <summary>
     /// 异步获取所有变量数据传输对象列表。
@@ -73,13 +53,13 @@ public class VariableAppService : IVariableAppService
     /// <summary>
     /// 异步创建一个新变量（事务性操作）。
     /// </summary>
-/// <param name="variable">要创建的变量数据传输对象。</param>
-    public async Task<Variable> CreateVariableAsync(Variable variable)
+    /// <param name="variable">要创建的变量数据传输对象。</param>
+    public async Task<Variable> AddAsync(Variable variable)
     {
         try
         {
             await _repoManager.BeginTranAsync();
-            var addedVariable = await _repoManager.Variables.AddAsync(variable);            await _repoManager.CommitAsync();
+            var addedVariable = await _repoManager.Variables.AddAsync(variable); await _repoManager.CommitAsync();
             return _mapper.Map<Variable>(addedVariable);
         }
         catch (Exception ex)
@@ -92,8 +72,8 @@ public class VariableAppService : IVariableAppService
     /// <summary>
     /// 异步更新一个已存在的变量（事务性操作）。
     /// </summary>
-/// <param name="variable">要更新的变量数据传输对象。</param>
-    public async Task<int> UpdateVariableAsync(Variable variable)
+    /// <param name="variable">要更新的变量数据传输对象。</param>
+    public async Task<int> UpdateAsync(Variable variable)
     {
         try
         {
@@ -121,13 +101,13 @@ public class VariableAppService : IVariableAppService
     /// <param name="variables">要更新的变量数据传输对象列表。</param>
     /// <returns>受影响的行数。</returns>
     /// <exception cref="ApplicationException">如果更新变量时发生错误。</exception>
-    public async Task<int> UpdateVariablesAsync(List<Variable> variables)
+    public async Task<int> UpdateAsync(List<Variable> variables)
     {
         try
         {
             await _repoManager.BeginTranAsync();
             int totalAffected = 0;
-            
+
             foreach (var variable in variables)
             {
                 var existingVariable = await _repoManager.Variables.GetByIdAsync(variable.Id);
@@ -139,7 +119,7 @@ public class VariableAppService : IVariableAppService
                 int res = await _repoManager.Variables.UpdateAsync(existingVariable);
                 totalAffected += res;
             }
-            
+
             await _repoManager.CommitAsync();
             return totalAffected;
         }
@@ -153,24 +133,19 @@ public class VariableAppService : IVariableAppService
     /// <summary>
     /// 异步删除一个变量（事务性操作）。
     /// </summary>
-    /// <param name="id">要删除变量的ID。</param>
+    /// <param name="variable1"></param>
     /// <returns>如果删除成功则为 true，否则为 false。</returns>
     /// <exception cref="InvalidOperationException">如果删除变量失败。</exception>
     /// <exception cref="ApplicationException">如果删除变量时发生其他错误。</exception>
-    public async Task<bool> DeleteVariableAsync(int id)
+    public async Task<bool> DeleteAsync(Variable variable)
     {
         try
         {
             await _repoManager.BeginTranAsync();
-            var variable = await _repoManager.Variables.GetByIdAsync(id);
-            if (variable == null)
-            {
-                throw new InvalidOperationException($"删除变量失败：变量ID:{id}，请检查变量Id是否存在");
-            }
             var delRes = await _repoManager.Variables.DeleteAsync(variable);
             if (delRes == 0)
             {
-                throw new InvalidOperationException($"删除变量失败：变量ID:{id}，请检查变量Id是否存在");
+                throw new InvalidOperationException($"删除变量失败：变量ID:{variable.Id}，请检查变量Id是否存在");
             }
             await _repoManager.CommitAsync();
             return true;
@@ -185,30 +160,26 @@ public class VariableAppService : IVariableAppService
     /// <summary>
     /// 异步批量删除变量（事务性操作）。
     /// </summary>
-    /// <param name="ids">要删除的变量ID列表。</param>
+    /// <param name="variables"></param>
     /// <returns>如果删除成功则为 true，否则为 false。</returns>
     /// <exception cref="ArgumentException">如果ID列表为空或null。</exception>
     /// <exception cref="ApplicationException">如果删除变量时发生错误。</exception>
-    public async Task<bool> DeleteVariablesAsync(List<int> ids)
+    public async Task<bool> DeleteAsync(List<Variable> variables)
     {
-        if (ids == null || !ids.Any())
-        {
-            throw new ArgumentException("变量ID列表不能为空", nameof(ids));
-        }
 
         try
         {
             await _repoManager.BeginTranAsync();
-            
+
             // 批量删除变量
-            // var deletedCount = await _repoManager.Variables.DeleteByIdsAsync(ids);
-            //
-            // // 检查是否所有变量都被成功删除
-            // if (deletedCount != ids.Count)
-            // {
-            //     throw new InvalidOperationException($"删除变量失败：请求删除 {ids.Count} 个变量，实际删除 {deletedCount} 个变量");
-            // }
-            
+            var deletedCount = await _repoManager.Variables.DeleteAsync(variables);
+
+            // 检查是否所有变量都被成功删除
+            if (deletedCount != variables.Count)
+            {
+                throw new InvalidOperationException($"删除变量失败：请求删除 {variables.Count} 个变量，实际删除 {deletedCount} 个变量");
+            }
+
             await _repoManager.CommitAsync();
             return true;
         }
@@ -219,68 +190,8 @@ public class VariableAppService : IVariableAppService
         }
     }
 
-    public async Task<List<Variable>> BatchImportVariablesAsync(List<Variable> variables)
+    public async Task<List<Variable>> AddAsync(List<Variable> variables)
     {
-        try
-        {
-            var variableModels = _mapper.Map<List<Variable>>(variables);
-            var addedVariables = await _repoManager.Variables.AddAsync(variableModels);
-            return _mapper.Map<List<Variable>>(addedVariables);
-        }
-        catch (Exception ex)
-        {
-            throw new ApplicationException($"批量导入变量时发生错误,错误信息:{ex.Message}", ex);
-        }
-    }
-
-    public async Task<List<Variable>> FindExistingVariablesAsync(IEnumerable<Variable> variablesToCheck)
-    {
-        if (variablesToCheck == null || !variablesToCheck.Any())
-        {
-            return new List<Variable>();
-        }
-
-        var names = variablesToCheck.Select(v => v.Name).Where(n => !string.IsNullOrEmpty(n)).Distinct().ToList();
-        var s7Addresses = variablesToCheck.Select(v => v.S7Address).Where(a => !string.IsNullOrEmpty(a)).Distinct().ToList();
-        var opcUaNodeIds = variablesToCheck.Select(v => v.OpcUaNodeId).Where(id => !string.IsNullOrEmpty(id)).Distinct().ToList();
-
-        var allVariables = await _repoManager.Variables.GetAllAsync();
-        var existingVariablesFromDb = allVariables.Where(v =>
-            (names.Any() && !string.IsNullOrEmpty(v.Name) && names.Contains(v.Name)) ||
-            (s7Addresses.Any() && !string.IsNullOrEmpty(v.S7Address) && s7Addresses.Contains(v.S7Address)) ||
-            (opcUaNodeIds.Any() && !string.IsNullOrEmpty(v.OpcUaNodeId) && opcUaNodeIds.Contains(v.OpcUaNodeId)))
-            .ToList();
-
-        if (existingVariablesFromDb == null || !existingVariablesFromDb.Any())
-        {
-            return new List<Variable>();
-        }
-
-        var existingNames = new HashSet<string>(existingVariablesFromDb.Select(v => v.Name).Where(n => !string.IsNullOrEmpty(n)));
-        var existingS7Addresses = new HashSet<string>(existingVariablesFromDb.Select(v => v.S7Address).Where(a => !string.IsNullOrEmpty(a)));
-        var existingOpcUaNodeIds = new HashSet<string>(existingVariablesFromDb.Select(v => v.OpcUaNodeId).Where(id => !string.IsNullOrEmpty(id)));
-
-        var result = existingVariablesFromDb.Where(v =>
-            (names.Any() && !string.IsNullOrEmpty(v.Name) && names.Contains(v.Name)) ||
-            (s7Addresses.Any() && !string.IsNullOrEmpty(v.S7Address) && s7Addresses.Contains(v.S7Address)) ||
-            (opcUaNodeIds.Any() && !string.IsNullOrEmpty(v.OpcUaNodeId) && opcUaNodeIds.Contains(v.OpcUaNodeId)))
-            .ToList();
-
-        return result;
-    }
-
-    public async Task<Variable?> FindExistingVariableAsync(Variable variableToCheck)
-    {
-        if (variableToCheck == null)
-        {
-            return null;
-        }
-
-        // 创建一个包含单个元素的列表以便复用现有的逻辑
-        var variablesToCheck = new List<Variable> { variableToCheck };
-        var existingVariables = await FindExistingVariablesAsync(variablesToCheck);
-
-        // 如果找到了匹配的变量，返回第一个（也是唯一一个）
-        return existingVariables.FirstOrDefault();
+        return await _repoManager.Variables.AddAsync(variables);
     }
 }

DMS.Application/Services/Database/VariableTableAppService.cs

@@ -74,21 +74,21 @@ namespace DMS.Application.Services.Database
                 if (createDto.Menu!=null)
                 {
                     // 获取设备菜单，作为变量表菜单的父级
-                    var deviceMenu
-                        = await _repositoryManager.Menus.GetMenuByTargetIdAsync(
-                            MenuType.DeviceMenu, createDto.DeviceId);
-                    if (deviceMenu == null)
-                    {
-                        throw new ApplicationException($"添加变量表菜单时，找不到设备ID:{createDto.DeviceId},请检查。");
-                    }
+                    //var deviceMenu
+                    //    = await _repositoryManager.Menus.GetMenuByTargetIdAsync(
+                    //        MenuType.DeviceMenu, createDto.DeviceId);
+                    //if (deviceMenu == null)
+                    //{
+                    //    throw new ApplicationException($"添加变量表菜单时，找不到设备ID:{createDto.DeviceId},请检查。");
+                    //}
 
                     // 映射菜单实体并设置关联信息
-                    var menu = _mapper.Map<MenuBean>(createDto.Menu);
-                    menu.ParentId = deviceMenu.Id;
-                    menu.TargetId = createdVariableTable.Id;
-                    menu.MenuType = MenuType.VariableTableMenu;
-                   var addMenu= await _repositoryManager.Menus.AddAsync(menu);
-                   _mapper.Map(addMenu, createDto.Menu);
+                   // var menu = _mapper.Map<MenuBean>(createDto.Menu);
+                   // menu.ParentId = deviceMenu.Id;
+                   // menu.TargetId = createdVariableTable.Id;
+                   // menu.MenuType = MenuType.VariableTableMenu;
+                   //var addMenu= await _repositoryManager.Menus.AddAsync(menu);
+                   //_mapper.Map(addMenu, createDto.Menu);
                 }
                 
 
@@ -164,7 +164,7 @@ namespace DMS.Application.Services.Database
                 // await _repositoryManager.MqttAlias.DeleteByVariableTableIdAsync(id);
 
                 // 删除关联的菜单树
-                await _repositoryManager.Menus.DeleteMenuTreeByTargetIdAsync(MenuType.VariableTableMenu, id);
+                //await _repositoryManager.Menus.DeleteMenuTreeByTargetIdAsync(MenuType.VariableTableMenu, id);
 
                 await _repositoryManager.CommitAsync();
                 return true;

DMS.Application/Services/EventService.cs

@@ -9,11 +9,11 @@ namespace DMS.Application.Services;
 /// </summary>
 public class EventService : IEventService
 {
-    private readonly IAppStorageService _appStorageService;
+    private readonly IAppDataService _appDataService;
 
-    public EventService(IAppStorageService appStorageService)
+    public EventService(IAppDataService appStorageService)
     {
-        _appStorageService = appStorageService;
+        _appDataService = appStorageService;
     }
 
     #region 设备事件

DMS.Application/Services/Management/DeviceManagementService.cs

@@ -1,3 +1,4 @@
+using AutoMapper;
 using DMS.Application.DTOs;
 using DMS.Application.Events;
 using DMS.Application.Interfaces;
@@ -13,14 +14,16 @@ namespace DMS.Application.Services.Management;
 /// </summary>
 public class DeviceManagementService : IDeviceManagementService
 {
+    private readonly IMapper _mapper;
     private readonly IDeviceAppService _deviceAppService;
-    private readonly IAppStorageService _appStorageService;
+    private readonly IAppDataService _appDataService;
     private readonly IEventService _eventService;
 
-    public DeviceManagementService(IDeviceAppService deviceAppService, IAppStorageService appStorageService, IEventService eventService)
+    public DeviceManagementService(IMapper mapper, IDeviceAppService deviceAppService, IAppDataService appStorageService, IEventService eventService)
     {
+        _mapper = mapper;
         _deviceAppService = deviceAppService;
-        _appStorageService = appStorageService;
+        _appDataService = appStorageService;
         _eventService = eventService;
     }
 
@@ -45,39 +48,58 @@ public class DeviceManagementService : IDeviceManagementService
     /// </summary>
     public async Task<CreateDeviceWithDetailsDto> CreateDeviceWithDetailsAsync(CreateDeviceWithDetailsDto dto)
     {
-       
-        
-        
+
+
+
         var result = await _deviceAppService.CreateDeviceWithDetailsAsync(dto);
-        
+
         // 创建成功后，将设备添加到内存中
         if (result?.Device != null)
         {
-            if (_appStorageService.Devices.TryAdd(result.Device.Id, result.Device))
+            if (_appDataService.Devices.TryAdd(result.Device.Id, result.Device))
             {
+
+                if (result.VariableTable is not null)
+                {
+                    if (_appDataService.VariableTables.TryAdd(result.VariableTable.Id, result.VariableTable))
+                    {
+                        result.VariableTable.Device = result.Device;
+                        //将默认变量表添加到设备中
+                        result.Device.VariableTables.Add(result.VariableTable);
+
+                        _eventService.RaiseVariableTableChanged(this, new VariableTableChangedEventArgs(DataChangeType.Added, result.VariableTable));
+                    }
+                }
+
                 _eventService.RaiseDeviceChanged(this, new DeviceChangedEventArgs(DataChangeType.Added, result.Device));
             }
-            if (result.VariableTable is not null)
-            {
-                if (_appStorageService.VariableTables.TryAdd(result.VariableTable.Id, result.VariableTable))
-                {
-                    _eventService.RaiseVariableTableChanged(this, new VariableTableChangedEventArgs(DataChangeType.Added, result.VariableTable));
-                }
-            }
 
+            //关联菜单
             if (result.DeviceMenu is not null)
             {
-                _appStorageService.Menus.TryAdd(result.DeviceMenu.Id, result.DeviceMenu);
+
+                var deviceRootMenu = _appDataService.Menus.Values.FirstOrDefault(m => m.TargetViewKey == "DevicesViewModel" && m.TargetId == 0);
+                if (deviceRootMenu is not null)
+                {
+                    _appDataService.Menus.TryAdd(result.DeviceMenu.Id, result.DeviceMenu);
+                    //将设备菜单添加到根菜单中
+                    deviceRootMenu.Children.Add(result.DeviceMenu);
+
+                    if (result.VariableTableMenu is not null)
+                    {
+                        _appDataService.Menus.TryAdd(result.VariableTableMenu.Id, result.VariableTableMenu);
+                        //将变量表菜单添加到设备菜单中
+                        result.DeviceMenu.Children.Add(result.VariableTableMenu);
+                    }
+                }
+
             }
 
-            if (result.VariableTableMenu is not null)
-            {
-                _appStorageService.Menus.TryAdd(result.VariableTableMenu.Id, result.VariableTableMenu);
-            }
+
 
 
         }
-        
+
         return result;
     }
 
@@ -87,14 +109,19 @@ public class DeviceManagementService : IDeviceManagementService
     public async Task<int> UpdateDeviceAsync(Device device)
     {
         var result = await _deviceAppService.UpdateDeviceAsync(device);
-        
+
         // 更新成功后，更新内存中的设备
-        if (result > 0 && device != null)
+        if (result > 0)
         {
-            _appStorageService.Devices.AddOrUpdate(device.Id, device, (key, oldValue) => device);
+            var deviceMenu = _appDataService.Menus.Values.FirstOrDefault(m => m.MenuType == MenuType.DeviceMenu && m.TargetId == device.Id);
+            if (deviceMenu is not null && deviceMenu.Header != device.Name)
+            {
+                deviceMenu.Header = device.Name;
+            }
+
             _eventService.RaiseDeviceChanged(this, new DeviceChangedEventArgs(DataChangeType.Updated, device));
         }
-        
+
         return result;
     }
 
@@ -104,28 +131,41 @@ public class DeviceManagementService : IDeviceManagementService
     public async Task<bool> DeleteAsync(Device device)
     {
         var result = await _deviceAppService.DeleteAsync(device);
-        
+
         // 删除成功后，从内存中移除设备
-        if (result )
+        if (result)
         {
-            if (_appStorageService.Devices.TryGetValue(device.Id, out var deviceInStorage))
+            if (_appDataService.Devices.TryGetValue(device.Id, out var deviceInStorage))
             {
+                //删除设备的所有变量表和变量
                 foreach (var variableTable in deviceInStorage.VariableTables)
                 {
                     foreach (var variable in variableTable.Variables)
                     {
-                        _appStorageService.Variables.TryRemove(variable.Id, out _);
+                        _appDataService.Variables.TryRemove(variable.Id, out _);
                     }
 
-                    _appStorageService.VariableTables.TryRemove(variableTable.Id, out _);
+                    _appDataService.VariableTables.TryRemove(variableTable.Id, out _);
+                }
+                //删除菜单
+                var deviceMenu = _appDataService.Menus.Values.FirstOrDefault(m => m.MenuType == MenuType.DeviceMenu && m.TargetId == device.Id);
+                if (deviceMenu is not null)
+                {
+                    foreach (var menu in deviceMenu.Children)
+                    {
+                        _appDataService.Menus.TryRemove(menu.Id, out _);
+                    }
+
+                    _appDataService.Menus.TryRemove(deviceMenu.Id, out _);
                 }
 
-                _appStorageService.Devices.TryRemove(device.Id, out _);
+                //删除设备
+                _appDataService.Devices.TryRemove(device.Id, out _);
 
                 _eventService.RaiseDeviceChanged(this, new DeviceChangedEventArgs(DataChangeType.Deleted, deviceInStorage));
             }
         }
-        
+
         return result;
     }
 
@@ -135,12 +175,12 @@ public class DeviceManagementService : IDeviceManagementService
     public async Task ToggleDeviceActiveStateAsync(int id)
     {
         await _deviceAppService.ToggleDeviceActiveStateAsync(id);
-        
+
         // 更新内存中的设备状态
         var device = await _deviceAppService.GetDeviceByIdAsync(id);
         if (device != null)
         {
-            _appStorageService.Devices.AddOrUpdate(device.Id, device, (key, oldValue) => device);
+            _appDataService.Devices.AddOrUpdate(device.Id, device, (key, oldValue) => device);
             _eventService.RaiseDeviceChanged(this, new DeviceChangedEventArgs(DataChangeType.Updated, device));
         }
     }
@@ -150,14 +190,14 @@ public class DeviceManagementService : IDeviceManagementService
     /// </summary>
     public async Task LoadAllDevicesAsync()
     {
-        _appStorageService.Devices.Clear();
+        _appDataService.Devices.Clear();
         var devices = await _deviceAppService.GetAllDevicesAsync();
-        
+
         // 建立设备与变量表的关联
         foreach (var device in devices)
         {
             // 将设备添加到安全字典
-            _appStorageService.Devices.TryAdd(device.Id, device);
+            _appDataService.Devices.TryAdd(device.Id, device);
         }
     }
 

DMS.Application/Services/Management/LogManagementService.cs

@@ -13,17 +13,17 @@ namespace DMS.Application.Services.Management;
 public class LogManagementService : ILogManagementService
 {
     private readonly INlogAppService _nlogAppService;
-    private readonly IAppStorageService _appStorageService;
+    private readonly IAppDataService _appDataService;
 
     /// <summary>
     /// 当日志数据发生变化时触发
     /// </summary>
     public event EventHandler<NlogChangedEventArgs> OnLogChanged;
 
-    public LogManagementService(INlogAppService nlogAppService,IAppStorageService appStorageService)
+    public LogManagementService(INlogAppService nlogAppService,IAppDataService appStorageService)
     {
         _nlogAppService = nlogAppService;
-        _appStorageService = appStorageService;
+        _appDataService = appStorageService;
     }
 
     /// <summary>
@@ -63,7 +63,7 @@ public class LogManagementService : ILogManagementService
     /// </summary>
     public void AddNlogToMemory(NlogDto nlogDto)
     {
-        if (_appStorageService.Nlogs.TryAdd(nlogDto.Id, nlogDto))
+        if (_appDataService.Nlogs.TryAdd(nlogDto.Id, nlogDto))
         {
             OnLogChanged?.Invoke(this,new NlogChangedEventArgs(DataChangeType.Added, nlogDto));
         }
@@ -74,7 +74,7 @@ public class LogManagementService : ILogManagementService
     /// </summary>
     public void UpdateNlogInMemory(NlogDto nlogDto)
     {
-        _appStorageService.Nlogs.AddOrUpdate(nlogDto.Id, nlogDto, (key, oldValue) => nlogDto);
+        _appDataService.Nlogs.AddOrUpdate(nlogDto.Id, nlogDto, (key, oldValue) => nlogDto);
         OnLogChanged?.Invoke(this,new NlogChangedEventArgs(DataChangeType.Updated, nlogDto));
     }
 
@@ -83,7 +83,7 @@ public class LogManagementService : ILogManagementService
     /// </summary>
     public void RemoveNlogFromMemory(int nlogId)
     {
-        if (_appStorageService.Nlogs.TryRemove(nlogId, out var nlogDto))
+        if (_appDataService.Nlogs.TryRemove(nlogId, out var nlogDto))
         {
             OnLogChanged?.Invoke(this,new NlogChangedEventArgs(DataChangeType.Deleted, nlogDto));
         }
@@ -94,12 +94,12 @@ public class LogManagementService : ILogManagementService
     /// </summary>
     public async Task LoadAllNlogsAsync(int count)
     {
-        _appStorageService.Nlogs.Clear();
+        _appDataService.Nlogs.Clear();
         var nlogDtos = await _nlogAppService.GetLatestLogsAsync(count);
         // 加载日志数据到内存
         foreach (var nlogDto in nlogDtos)
         {
-            _appStorageService.Nlogs.TryAdd(nlogDto.Id, nlogDto);
+            _appDataService.Nlogs.TryAdd(nlogDto.Id, nlogDto);
         }
     }
 

DMS.Application/Services/Management/MenuManagementService.cs

@@ -12,7 +12,7 @@ namespace DMS.Application.Services.Management;
 public class MenuManagementService : IMenuManagementService
 {
     private readonly IMenuAppService _menuService;
-    private readonly IAppStorageService _appStorageService;
+    private readonly IAppDataService _appDataService;
     private readonly IEventService _eventService;
 
     /// <summary>
@@ -20,10 +20,10 @@ public class MenuManagementService : IMenuManagementService
     /// </summary>
     public event EventHandler<MenuChangedEventArgs> MenuChanged;
 
-    public MenuManagementService(IMenuAppService menuService, IAppStorageService appStorageService, IEventService eventService)
+    public MenuManagementService(IMenuAppService menuService, IAppDataService appStorageService, IEventService eventService)
     {
         _menuService = menuService;
-        _appStorageService = appStorageService;
+        _appDataService = appStorageService;
         _eventService = eventService;
     }
 
@@ -46,41 +46,40 @@ public class MenuManagementService : IMenuManagementService
     /// <summary>
     /// 异步创建一个新菜单。
     /// </summary>
-    public async Task<int> CreateMenuAsync(MenuBean menu)
+    public async Task<MenuBean> AddAsync(MenuBean menu)
     {
-        var result = await _menuService.CreateMenuAsync(menu);
+        var resMenu = await _menuService.AddAsync(menu);
         
         // 创建成功后，将菜单添加到内存中
-        if (result > 0)
+        if (resMenu is not null)
         {
-            menu.Id = result; // 假设返回的ID是新创建的
-            if (_appStorageService.Menus.TryAdd(menu.Id, menu))
+            if (_appDataService.Menus.TryAdd(resMenu.Id, resMenu))
             {
                 MenuBean parentMenu = null;
-                if (menu.ParentId > 0 && _appStorageService.Menus.TryGetValue(menu.ParentId.Value, out var parent))
+                if (resMenu.ParentId > 0 && _appDataService.Menus.TryGetValue(resMenu.ParentId.Value, out var parent))
                 {
                     parentMenu = parent;
-                    parent.Children.Add(menu);
+                    parent.Children.Add(resMenu);
                 }
 
-                _eventService.RaiseMenuChanged(this, new MenuChangedEventArgs(DataChangeType.Added, menu));
+                _eventService.RaiseMenuChanged(this, new MenuChangedEventArgs(DataChangeType.Added, resMenu));
             }
         }
         
-        return result;
+        return resMenu;
     }
 
     /// <summary>
     /// 异步更新一个已存在的菜单。
     /// </summary>
-    public async Task<int> UpdateMenuAsync(MenuBean menu)
+    public async Task<int> UpdateAsync(MenuBean menu)
     {
-        var result = await _menuService.UpdateMenuAsync(menu);
+        var result = await _menuService.UpdateAsync(menu);
         
         // 更新成功后，更新内存中的菜单
         if (result > 0)
         {
-            if (_appStorageService.Menus.TryGetValue(menu.Id,out var mMenu))
+            if (_appDataService.Menus.TryGetValue(menu.Id,out var mMenu))
             {
                 mMenu.Header = menu.Header;
             }
@@ -94,18 +93,17 @@ public class MenuManagementService : IMenuManagementService
     /// <summary>
     /// 异步删除一个菜单。
     /// </summary>
-    public async Task<bool> DeleteMenuAsync(int id)
+    public async Task<bool> DeleteAsync(MenuBean menu)
     {
-        var menu = await _menuService.GetMenuByIdAsync(id); // 获取菜单信息用于内存删除
-        var result = await _menuService.DeleteMenuAsync(id);
+        var result = await _menuService.DeleteAsync(menu);
         
         // 删除成功后，从内存中移除菜单
         if (result && menu != null)
         {
-            if (_appStorageService.Menus.TryRemove(id, out var menuData))
+            if (_appDataService.Menus.TryRemove(menu.Id, out var menuData))
             {
                 // 从父菜单中移除子菜单
-                if (menuData.ParentId > 0 && _appStorageService.Menus.TryGetValue(menuData.ParentId.Value, out var parentMenu))
+                if (menuData.ParentId > 0 && _appDataService.Menus.TryGetValue(menuData.ParentId.Value, out var parentMenu))
                 {
                     parentMenu.Children.Remove(menuData);
                 }
@@ -117,41 +115,49 @@ public class MenuManagementService : IMenuManagementService
         return result;
     }
 
-    /// <summary>
-    /// 获取根菜单列表
-    /// </summary>
-    public List<MenuBean> GetRootMenus()
-    {
-        return _appStorageService.Menus.Values.Where(m => m.ParentId == 0)
-                    .ToList();
-    }
+
+
 
     /// <summary>
-    /// 根据父级ID获取子菜单列表
+    /// 构建菜单树。
     /// </summary>
-    /// <param name="parentId">父级菜单ID</param>
-    /// <returns>子菜单列表</returns>
-    public List<MenuBean> GetChildMenus(int parentId)
+    public void BuildMenuTrees()
     {
-        return _appStorageService.Menus.Values.Where(m => m.ParentId == parentId)
-                    .ToList();
-    }
+        // 创建一个新的临时列表来存储根菜单
+        var newRootMenus = new List<MenuBean>();
 
-    /// <summary>
-    /// 构建菜单树结构
-    /// </summary>
-    public void BuildMenuTree()
-    {
-        // 清空现有菜单树
-        _appStorageService.MenuTrees.Clear();
-
-        // 获取所有根菜单
-        var rootMenus = GetRootMenus();
-
-        // 将根菜单添加到菜单树中
-        foreach (var rootMenu in rootMenus)
+        // 首先，确保所有菜单项的Children集合是干净的
+        foreach (var menu in _appDataService.Menus.Values)
         {
-            _appStorageService.MenuTrees.TryAdd(rootMenu.Id, rootMenu);
+            // 避免循环引用，清空Children集合
+            menu.Children.Clear();
+        }
+
+        // 遍历所有菜单项，构建树形结构
+        foreach (var menu in _appDataService.Menus.Values)
+        {
+            var parentMenu = _appDataService.Menus.Values.FirstOrDefault(m => m.Id == menu.ParentId);
+            // 检查是否有父ID，并且父ID不为0（通常0或null表示根节点）
+            if (parentMenu != null && menu.ParentId != 0)
+            {
+                // 将当前菜单添加到父菜单的Children列表中
+                if (!parentMenu.Children.Contains(menu))
+                {
+                    parentMenu.Children.Add(menu);
+                }
+            }
+            else
+            {
+                // 如果没有父ID，则这是一个根菜单
+                newRootMenus.Add(menu);
+            }
+        }
+
+        // 在UI线程安全地更新MenuTrees集合
+        _appDataService.MenuTrees.Clear();
+        foreach (var rootMenu in newRootMenus)
+        {
+            _appDataService.MenuTrees.TryAdd(rootMenu.Id,rootMenu);
         }
     }
 
@@ -168,13 +174,15 @@ public class MenuManagementService : IMenuManagementService
     /// </summary>
     public async Task LoadAllMenusAsync()
     {
-        _appStorageService.Menus.Clear();
-        _appStorageService.MenuTrees.Clear();
+        _appDataService.Menus.Clear();
+        _appDataService.MenuTrees.Clear();
         var menus = await _menuService.GetAllMenusAsync();
         // 将菜单添加到安全字典
         foreach (var menuBean in menus)
         {
-            _appStorageService.Menus.TryAdd(menuBean.Id, menuBean);
+            _appDataService.Menus.TryAdd(menuBean.Id, menuBean);
         }
+
+        BuildMenuTrees();
     }
 }

DMS.Application/Services/Management/MqttAliasManagementService.cs

@@ -12,11 +12,11 @@ public class MqttAliasManagementService : IMqttAliasManagementService
 {
     private readonly IMqttAliasAppService _appService;
     private readonly IEventService _eventService;
-    private readonly IAppStorageService _storageService;
+    private readonly IAppDataService _storageService;
     private readonly IMapper _mapper;
 
     public MqttAliasManagementService(IMqttAliasAppService appService, IEventService eventService,
-                                      IAppStorageService storageService, IMapper mapper)
+                                      IAppDataService storageService, IMapper mapper)
     {
         _appService = appService;
         _eventService = eventService;

DMS.Application/Services/Management/MqttManagementService.cs

@@ -15,15 +15,15 @@ namespace DMS.Application.Services.Management;
 public class MqttManagementService : IMqttManagementService
 {
     private readonly IMqttAppService _mqttAppService;
-    private readonly IAppStorageService _appStorageService;
+    private readonly IAppDataService _appDataService;
     private readonly IEventService _eventService;
 
     public MqttManagementService(IMqttAppService mqttAppService, 
-                                IAppStorageService appStorageService, 
+                                IAppDataService appStorageService, 
                                 IEventService eventService)
     {
         _mqttAppService = mqttAppService;
-        _appStorageService = appStorageService;
+        _appDataService = appStorageService;
         _eventService = eventService;
     }
 
@@ -32,7 +32,7 @@ public class MqttManagementService : IMqttManagementService
     /// </summary>
     public async Task<MqttServer> GetMqttServerByIdAsync(int id)
     {
-        if (_appStorageService.MqttServers.TryGetValue(id,out var mqttServer))
+        if (_appDataService.MqttServers.TryGetValue(id,out var mqttServer))
         {
             return mqttServer;
         }
@@ -44,7 +44,7 @@ public class MqttManagementService : IMqttManagementService
     /// </summary>
     public async Task<List<MqttServer>> GetAllMqttServersAsync()
     {
-        return _appStorageService.MqttServers.Values.ToList();
+        return _appDataService.MqttServers.Values.ToList();
     }
 
     /// <summary>
@@ -67,7 +67,7 @@ public class MqttManagementService : IMqttManagementService
         {
             foreach (var mqttServer in mqttServers)
             {
-                if (_appStorageService.MqttServers.TryGetValue(mqttServer.Id, out var mMqttServer))
+                if (_appDataService.MqttServers.TryGetValue(mqttServer.Id, out var mMqttServer))
                 {
                     // 比较旧值和新值，确定哪个属性发生了变化
                     var changedProperties = GetChangedProperties(mMqttServer, mqttServer);
@@ -99,7 +99,7 @@ public class MqttManagementService : IMqttManagementService
                 else
                 {
                     // 如果内存中不存在该MQTT服务器，则直接添加
-                    _appStorageService.MqttServers.TryAdd(mqttServer.Id, mqttServer);
+                    _appDataService.MqttServers.TryAdd(mqttServer.Id, mqttServer);
                     _eventService.RaiseMqttServerChanged(
                         this, new MqttServerChangedEventArgs(ActionChangeType.Added, mqttServer, MqttServerPropertyType.All));
                 }
@@ -120,7 +120,7 @@ public class MqttManagementService : IMqttManagementService
         // 删除成功后，从内存中移除MQTT服务器
         if (result && mqttServer != null)
         {
-            if (_appStorageService.MqttServers.TryRemove(id, out var mqttServerFromCache))
+            if (_appDataService.MqttServers.TryRemove(id, out var mqttServerFromCache))
             {
                 _eventService.RaiseMqttServerChanged(
                     this, new MqttServerChangedEventArgs(ActionChangeType.Deleted, mqttServerFromCache));
@@ -142,7 +142,7 @@ public class MqttManagementService : IMqttManagementService
         // {
         //     foreach (var id in ids)
         //     {
-        //         if (_appStorageService.MqttServers.TryRemove(id, out var mqttServer))
+        //         if (_appDataService.MqttServers.TryRemove(id, out var mqttServer))
         //         {
         //             _eventService.RaiseMqttServerChanged(
         //                 this, new MqttServerChangedEventArgs(ActionChangeType.Deleted, mqttServer));
@@ -168,7 +168,7 @@ public class MqttManagementService : IMqttManagementService
             
             
             // 将MQTT服务器添加到内存中
-            if (_appStorageService.MqttServers.TryAdd(mqttServer.Id, mqttServer))
+            if (_appDataService.MqttServers.TryAdd(mqttServer.Id, mqttServer))
             {
                 _eventService.RaiseMqttServerChanged(
                     this, new MqttServerChangedEventArgs(ActionChangeType.Added, mqttServer));
@@ -240,12 +240,12 @@ public class MqttManagementService : IMqttManagementService
     /// </summary>
     public async Task LoadAllMqttServersAsync()
     {
-        _appStorageService.MqttServers.Clear();
+        _appDataService.MqttServers.Clear();
         var mqttServers = await _mqttAppService.GetAllMqttServersAsync();
         // 加载MQTT服务器数据到内存
         foreach (var mqttServer in mqttServers)
         {
-            _appStorageService.MqttServers.TryAdd(mqttServer.Id, mqttServer);
+            _appDataService.MqttServers.TryAdd(mqttServer.Id, mqttServer);
         }
     }
 }

DMS.Application/Services/Management/TriggerManagementService.cs

@@ -17,14 +17,14 @@ namespace DMS.Application.Services.Management
     /// </summary>
     public class TriggerManagementService : ITriggerManagementService
     {
-        private readonly IAppStorageService _appStorageService;
+        private readonly IAppDataService _appDataService;
         private readonly ITriggerAppService _triggerAppService;
         private readonly IMapper _mapper;
         private readonly IEventService _eventService;
 
-        public TriggerManagementService(IAppStorageService appStorageService, ITriggerAppService triggerAppService, IMapper mapper, IEventService eventService)
+        public TriggerManagementService(IAppDataService appStorageService, ITriggerAppService triggerAppService, IMapper mapper, IEventService eventService)
         {
-            _appStorageService = appStorageService;
+            _appDataService = appStorageService;
             _triggerAppService = triggerAppService;
             _mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
             _eventService = eventService;
@@ -35,7 +35,7 @@ namespace DMS.Application.Services.Management
         /// </summary>
         public List<Trigger> GetAllTriggersAsync()
         {
-            var triggers = _appStorageService.Triggers.Values.ToList();
+            var triggers = _appDataService.Triggers.Values.ToList();
             return _mapper.Map<List<Trigger>>(triggers);
         }
 
@@ -44,7 +44,7 @@ namespace DMS.Application.Services.Management
         /// </summary>
         public async Task<Trigger?> GetTriggerByIdAsync(int id)
         {
-            _appStorageService.Triggers.TryGetValue(id, out var trigger);
+            _appDataService.Triggers.TryGetValue(id, out var trigger);
             return trigger;
         }
 
@@ -59,7 +59,7 @@ namespace DMS.Application.Services.Management
             // 创建成功后，将触发器添加到内存中
             if (createdTrigger != null)
             {
-                if (_appStorageService.Triggers.TryAdd(createdTrigger.Id, createdTrigger))
+                if (_appDataService.Triggers.TryAdd(createdTrigger.Id, createdTrigger))
                 {
                     _eventService.RaiseTriggerChanged(this, new TriggerChangedEventArgs(DataChangeType.Added, createdTrigger));
                 }
@@ -81,12 +81,12 @@ namespace DMS.Application.Services.Management
                 return null;
             }
 
-            if (_appStorageService.Triggers.TryAdd(result.Trigger.Id, result.Trigger))
+            if (_appDataService.Triggers.TryAdd(result.Trigger.Id, result.Trigger))
             {
                 _eventService.RaiseTriggerChanged(this, new TriggerChangedEventArgs(DataChangeType.Added, result.Trigger));
             }
 
-            if (_appStorageService.Menus.TryAdd(result.TriggerMenu.Id, result.TriggerMenu))
+            if (_appDataService.Menus.TryAdd(result.TriggerMenu.Id, result.TriggerMenu))
             {
                 _eventService.RaiseMenuChanged(this, new MenuChangedEventArgs(DataChangeType.Added, result.TriggerMenu));
             }
@@ -107,7 +107,7 @@ namespace DMS.Application.Services.Management
                 return res;
 
             // 6. 同步更新AppDataStorageService中的Triggers字典
-            if (_appStorageService.Triggers.TryGetValue(trigger.Id, out var memTrigger))
+            if (_appDataService.Triggers.TryGetValue(trigger.Id, out var memTrigger))
             {
                 _mapper.Map(trigger, memTrigger);
             }
@@ -125,7 +125,7 @@ namespace DMS.Application.Services.Management
             // 如果删除成功，也从AppDataStorageService中的Triggers字典中移除
             if (await _triggerAppService.DeleteTriggerByIdAsync(id))
             {
-                _appStorageService.Triggers.TryRemove(id, out _);
+                _appDataService.Triggers.TryRemove(id, out _);
                 return true;
             }
             else
@@ -150,11 +150,11 @@ namespace DMS.Application.Services.Management
         /// </summary>
         public async Task LoadAllTriggersAsync()
         {
-            _appStorageService.Triggers.Clear();
+            _appDataService.Triggers.Clear();
             var triggerDefinitions = await _triggerAppService.GetAllTriggersAsync();
             foreach (var triggerDefinition in triggerDefinitions)
             {
-                _appStorageService.Triggers.TryAdd(triggerDefinition.Id, triggerDefinition);
+                _appDataService.Triggers.TryAdd(triggerDefinition.Id, triggerDefinition);
             }
 
         }

DMS.Application/Services/Management/TriggerVariableManagementService.cs

@@ -12,13 +12,13 @@ namespace DMS.Application.Services.Management;
 public class TriggerVariableManagementService : ITriggerVariableManagementService
 {
     private readonly ITriggerVariableAppService _triggerVariableAppService;
-    private readonly IAppStorageService _appStorageService;
+    private readonly IAppDataService _appDataService;
     private readonly IEventService _eventService;
 
-    public TriggerVariableManagementService(ITriggerVariableAppService triggerVariableAppService,IAppStorageService appStorageService,IEventService eventService)
+    public TriggerVariableManagementService(ITriggerVariableAppService triggerVariableAppService,IAppDataService appStorageService,IEventService eventService)
     {
         _triggerVariableAppService = triggerVariableAppService;
-        _appStorageService = appStorageService;
+        _appDataService = appStorageService;
         _eventService = eventService;
     }
 
@@ -28,7 +28,7 @@ public class TriggerVariableManagementService : ITriggerVariableManagementServic
         if (newTriggerVariable != null)
         {
             // Add to cache
-            _appStorageService.TriggerVariables.TryAdd(newTriggerVariable.Id, newTriggerVariable);
+            _appDataService.TriggerVariables.TryAdd(newTriggerVariable.Id, newTriggerVariable);
 
             _eventService.RaiseTriggerVariableChanged(this, new TriggerVariableChangedEventArgs(ActionChangeType.Added, newTriggerVariable));
         }
@@ -42,12 +42,12 @@ public class TriggerVariableManagementService : ITriggerVariableManagementServic
         foreach (var triggerVariable in triggerVariables)
         {
             // Add to cache
-            _appStorageService.TriggerVariables.TryAdd(triggerVariable.Id, triggerVariable);
+            _appDataService.TriggerVariables.TryAdd(triggerVariable.Id, triggerVariable);
 
 
-            if (_appStorageService.Triggers.TryGetValue(triggerVariable.TriggerDefinitionId, out var trigger))
+            if (_appDataService.Triggers.TryGetValue(triggerVariable.TriggerDefinitionId, out var trigger))
             {
-                if (_appStorageService.Variables.TryGetValue(triggerVariable.VariableId, out var variable))
+                if (_appDataService.Variables.TryGetValue(triggerVariable.VariableId, out var variable))
                 {
                     trigger.Variables.Add(variable);
                     variable.Triggers.Add(trigger);
@@ -68,7 +68,7 @@ public class TriggerVariableManagementService : ITriggerVariableManagementServic
         if (res > 0)
         {
             // Update cache
-            if (_appStorageService.TriggerVariables.TryGetValue(triggerVariable.Id, out var existingTriggerVariable))
+            if (_appDataService.TriggerVariables.TryGetValue(triggerVariable.Id, out var existingTriggerVariable))
             {
                 existingTriggerVariable.TriggerDefinitionId = triggerVariable.TriggerDefinitionId;
                 existingTriggerVariable.VariableId = triggerVariable.VariableId;
@@ -82,9 +82,9 @@ public class TriggerVariableManagementService : ITriggerVariableManagementServic
         var result = await _triggerVariableAppService.RemoveTriggerVariableAsync(id);
         if (result == 0) return false;
 
-        if (_appStorageService.TriggerVariables.TryGetValue(id, out var triggerVariable))
+        if (_appDataService.TriggerVariables.TryGetValue(id, out var triggerVariable))
         {
-            _appStorageService.TriggerVariables.TryRemove(triggerVariable.Id, out _);
+            _appDataService.TriggerVariables.TryRemove(triggerVariable.Id, out _);
             _eventService.RaiseTriggerVariableChanged(
                 this, new TriggerVariableChangedEventArgs(ActionChangeType.Deleted, triggerVariable));
         }
@@ -107,7 +107,7 @@ public class TriggerVariableManagementService : ITriggerVariableManagementServic
         foreach (var triggerVariable in addedTriggerVariables)
         {
             // Add to cache
-            _appStorageService.TriggerVariables.TryAdd(triggerVariable.Id, triggerVariable);
+            _appDataService.TriggerVariables.TryAdd(triggerVariable.Id, triggerVariable);
             _eventService.RaiseTriggerVariableChanged(this, new TriggerVariableChangedEventArgs(ActionChangeType.Added, triggerVariable));
         }
 

DMS.Application/Services/Management/VariableManagementService.cs

@@ -18,20 +18,20 @@ public class VariableManagementService : IVariableManagementService
     private readonly IVariableAppService _variableAppService;
     private readonly IEventService _eventService;
     private readonly IMapper _mapper;
-    private readonly IAppStorageService _appStorageService;
+    private readonly IAppDataService _appDataService;
     private readonly IDataProcessingService _dataProcessingService;
 
 
     public VariableManagementService(IVariableAppService variableAppService,
                                      IEventService eventService,
                                      IMapper mapper,
-                                     IAppStorageService appStorageService,
+                                     IAppDataService appStorageService,
                                      IDataProcessingService dataProcessingService)
     {
         _variableAppService = variableAppService;
         _eventService = eventService;
         _mapper = mapper;
-        _appStorageService = appStorageService;
+        _appDataService = appStorageService;
         _dataProcessingService = dataProcessingService;
     }
 
@@ -56,24 +56,24 @@ public class VariableManagementService : IVariableManagementService
     /// </summary>
     public async Task<Variable> CreateVariableAsync(Variable variable)
     {
-        var result = await _variableAppService.CreateVariableAsync(variable);
-        
+        var result = await _variableAppService.AddAsync(variable);
+
         // 创建成功后，将变量添加到内存中
         if (result != null)
         {
-            if (_appStorageService.VariableTables.TryGetValue(result.VariableTableId, out var variableTable))
+            if (_appDataService.VariableTables.TryGetValue(result.VariableTableId, out var variableTable))
             {
                 result.VariableTable = variableTable;
                 variableTable.Variables.Add(result);
             }
 
-            if (_appStorageService.Variables.TryAdd(result.Id, result))
+            if (_appDataService.Variables.TryAdd(result.Id, result))
             {
                 _eventService.RaiseVariableChanged(
                     this, new VariableChangedEventArgs(ActionChangeType.Added, result));
             }
         }
-        
+
         return result;
     }
 
@@ -82,7 +82,7 @@ public class VariableManagementService : IVariableManagementService
     /// </summary>
     public async Task<int> UpdateVariableAsync(Variable variable)
     {
-        return await UpdateVariablesAsync(new List<Variable>() { variable});
+        return await UpdateVariablesAsync(new List<Variable>() { variable });
     }
 
     /// <summary>
@@ -90,18 +90,18 @@ public class VariableManagementService : IVariableManagementService
     /// </summary>
     public async Task<int> UpdateVariablesAsync(List<Variable> variables)
     {
-        var result = await _variableAppService.UpdateVariablesAsync(variables);
-        
+        var result = await _variableAppService.UpdateAsync(variables);
+
         // 批量更新成功后，更新内存中的变量
         if (result > 0 && variables != null)
         {
             foreach (var variable in variables)
             {
-                if (_appStorageService.Variables.TryGetValue(variable.Id, out var mVariable))
+                if (_appDataService.Variables.TryGetValue(variable.Id, out var mVariable))
                 {
                     // 比较旧值和新值，确定哪个属性发生了变化
                     var changedProperties = GetChangedProperties(mVariable, variable);
-                    
+
                     // 更新内存中的变量
                     _mapper.Map(variable, mVariable);
 
@@ -111,81 +111,75 @@ public class VariableManagementService : IVariableManagementService
                         _eventService.RaiseVariableChanged(
                             this, new VariableChangedEventArgs(ActionChangeType.Updated, variable, property));
                     }
-                    
+
                     // 如果没有任何属性发生变化，至少触发一次更新事件
                     if (changedProperties.Count == 0)
                     {
                         _eventService.RaiseVariableChanged(
-                            this, new VariableChangedEventArgs(ActionChangeType.Updated, variable, VariablePropertyType.All));
+                            this,
+                            new VariableChangedEventArgs(ActionChangeType.Updated, variable, VariablePropertyType.All));
                     }
                 }
                 else
                 {
                     // 如果内存中不存在该变量，则直接添加
-                    _appStorageService.Variables.TryAdd(variable.Id, variable);
+                    _appDataService.Variables.TryAdd(variable.Id, variable);
                     _eventService.RaiseVariableChanged(
                         this, new VariableChangedEventArgs(ActionChangeType.Added, variable, VariablePropertyType.All));
                 }
             }
         }
-        
+
         return result;
     }
 
     /// <summary>
     /// 异步删除一个变量。
     /// </summary>
-    public async Task<bool> DeleteVariableAsync(int id)
+    public async Task<bool> DeleteAsync(Variable variable)
     {
-        var result = await _variableAppService.DeleteVariableAsync(id);
-        
+        var result = await _variableAppService.DeleteAsync(variable);
+
         // 删除成功后，从内存中移除变量
         if (result)
         {
-            if (_appStorageService.Variables.TryRemove(id, out var variable))
+            if (_appDataService.Variables.TryRemove(variable.Id, out var mVariable))
             {
-                if (variable != null && _appStorageService.VariableTables.TryGetValue(variable.VariableTableId, out var variableTable))
+                if (variable != null &&
+                    _appDataService.VariableTables.TryGetValue(variable.VariableTableId, out var variableTable))
                 {
                     variableTable.Variables.Remove(variable);
-                   
                 }
 
                 _eventService.RaiseVariableChanged(
-                   this, new VariableChangedEventArgs(ActionChangeType.Deleted, variable));
+                    this, new VariableChangedEventArgs(ActionChangeType.Deleted, variable));
             }
         }
-        
+
         return result;
     }
 
     /// <summary>
     /// 异步批量导入变量。
     /// </summary>
-    public async Task<List<Variable>> BatchImportVariablesAsync(List<Variable> variables)
+    public async Task<List<Variable>> AddAsync(List<Variable> variables)
     {
-        var result = await _variableAppService.BatchImportVariablesAsync(variables);
-        foreach (var variable in result)
-        {
-            if (_appStorageService.VariableTables.TryGetValue(variable.VariableTableId ,out var variableTable))
-            {
-                variable.VariableTable = variableTable;
-            }
-            
-        }
-        
-        
+        var result = await _variableAppService.AddAsync(variables);
         // 批量导入成功后，触发批量导入事件
         if (result != null && result.Any())
         {
+            foreach (var variable in result)
+            {
+                if (_appDataService.VariableTables.TryGetValue(variable.VariableTableId, out var variableTable))
+                {
+                    variable.VariableTable = variableTable;
+                    variableTable.Variables.Add(variable);
+                }
+            }
             _eventService.RaiseBatchImportVariables(this, new BatchImportVariablesEventArgs(result));
         }
-        
-        return result;
-    }
 
-    public async Task<List<Variable>> FindExistingVariablesAsync(IEnumerable<Variable> variablesToCheck)
-    {
-        return await _variableAppService.FindExistingVariablesAsync(variablesToCheck);
+        return result;
     }
 
     /// <summary>
@@ -200,45 +194,45 @@ public class VariableManagementService : IVariableManagementService
 
         if (oldVariable.Name != newVariable.Name)
             changedProperties.Add(VariablePropertyType.Name);
-        
+
         if (oldVariable.S7Address != newVariable.S7Address)
             changedProperties.Add(VariablePropertyType.S7Address);
-        
+
         if (oldVariable.DataType != newVariable.DataType)
             changedProperties.Add(VariablePropertyType.DataType);
-        
+
         if (oldVariable.ConversionFormula != newVariable.ConversionFormula)
             changedProperties.Add(VariablePropertyType.ConversionFormula);
-        
+
         if (oldVariable.OpcUaUpdateType != newVariable.OpcUaUpdateType)
             changedProperties.Add(VariablePropertyType.OpcUaUpdateType);
-        
+
         if (oldVariable.MqttAliases != newVariable.MqttAliases)
             changedProperties.Add(VariablePropertyType.MqttAlias);
-        
+
         if (oldVariable.Description != newVariable.Description)
             changedProperties.Add(VariablePropertyType.Description);
-        
+
         if (oldVariable.VariableTableId != newVariable.VariableTableId)
             changedProperties.Add(VariablePropertyType.VariableTableId);
 
         if (oldVariable.DataValue != newVariable.DataValue)
             changedProperties.Add(VariablePropertyType.Value);
-            
+
         if (oldVariable.IsActive != newVariable.IsActive)
             changedProperties.Add(VariablePropertyType.IsActive);
         if (oldVariable.IsHistoryEnabled != newVariable.IsHistoryEnabled)
             changedProperties.Add(VariablePropertyType.IsHistoryEnabled);
-            
+
         if (oldVariable.OpcUaNodeId != newVariable.OpcUaNodeId)
             changedProperties.Add(VariablePropertyType.OpcUaNodeId);
-            
+
         if (oldVariable.PollingInterval != newVariable.PollingInterval)
             changedProperties.Add(VariablePropertyType.PollingInterval);
-            
+
         if (oldVariable.SignalType != newVariable.SignalType)
             changedProperties.Add(VariablePropertyType.SignalType);
-            
+
         if (oldVariable.Protocol != newVariable.Protocol)
             changedProperties.Add(VariablePropertyType.Protocol);
 
@@ -249,52 +243,45 @@ public class VariableManagementService : IVariableManagementService
     /// <summary>
     /// 异步批量删除变量。
     /// </summary>
-    public async Task<bool> DeleteVariablesAsync(List<int> ids)
+    public async Task<bool> DeleteAsync(List<Variable> variables)
     {
-        var result = await _variableAppService.DeleteVariablesAsync(ids);
-        
-        // 批量删除成功后，从内存中移除变量
-        if (result && ids != null)
-        {
-            foreach (var id in ids)
-            {
-                if (_appStorageService.Variables.TryRemove(id, out var variable))
-                {
-                    if (variable != null && _appStorageService.VariableTables.TryGetValue(variable.VariableTableId, out var variableTable))
-                    {
-                        variableTable.Variables.Remove(variable);
-                    }
+        var result = await _variableAppService.DeleteAsync(variables);
 
-                    _eventService.RaiseVariableChanged(
-                        this, new VariableChangedEventArgs(ActionChangeType.Deleted, variable));
-                }
+        // 批量删除成功后，从内存中移除变量
+        if (result)
+        {
+            foreach (var variable in variables)
+            {
+                variable.VariableTable.Variables.Remove(variable);
+                _appDataService.Variables.TryRemove(variable.Id, out _);
+                _eventService.RaiseVariableChanged(
+                    this, new VariableChangedEventArgs(ActionChangeType.Deleted, variable));
             }
         }
-        
+
         return result;
     }
 
-    
+
     /// <summary>
     /// 异步加载所有变量数据到内存中。
     /// </summary>
     public async Task LoadAllVariablesAsync()
     {
-        _appStorageService.Variables.Clear();
+        _appDataService.Variables.Clear();
 
         var variables = await _variableAppService.GetAllVariablesAsync();
         // 将变量添加到安全字典
         foreach (var variable in variables)
         {
-            if (_appStorageService.VariableTables.TryGetValue(variable.VariableTableId,
-                                                                  out var variableTable))
+            if (_appDataService.VariableTables.TryGetValue(variable.VariableTableId,
+                                                              out var variableTable))
             {
                 variable.VariableTable = variableTable;
                 variableTable.Variables.Add(variable);
             }
 
-            _appStorageService.Variables.TryAdd(variable.Id, variable);
+            _appDataService.Variables.TryAdd(variable.Id, variable);
         }
     }
-
 }

DMS.Application/Services/Management/VariableTableManagementService.cs

@@ -14,7 +14,7 @@ namespace DMS.Application.Services.Management;
 public class VariableTableManagementService : IVariableTableManagementService
 {
     private readonly IVariableTableAppService _variableTableAppService;
-    private readonly IAppStorageService _appStorageService;
+    private readonly IAppDataService _appDataService;
     private readonly IEventService _eventService;
 
     /// <summary>
@@ -23,11 +23,11 @@ public class VariableTableManagementService : IVariableTableManagementService
     public event EventHandler<VariableTableChangedEventArgs> OnVariableTableChanged;
 
     public VariableTableManagementService(IVariableTableAppService variableTableAppService,
-                                         IAppStorageService appStorageService,
+                                         IAppDataService appStorageService,
                                          IEventService eventService)
     {
         _variableTableAppService = variableTableAppService;
-        _appStorageService = appStorageService;
+        _appDataService = appStorageService;
         _eventService = eventService;
     }
 
@@ -58,8 +58,8 @@ public class VariableTableManagementService : IVariableTableManagementService
         if (result?.VariableTable != null)
         {
             // 添加null检查
-            if (_appStorageService.Devices != null &&
-                _appStorageService.Devices.TryGetValue(result.VariableTable.DeviceId, out var device))
+            if (_appDataService.Devices != null &&
+                _appDataService.Devices.TryGetValue(result.VariableTable.DeviceId, out var device))
             {
                 // 确保VariableTables不为null
                 if (device.VariableTables == null)
@@ -73,7 +73,7 @@ public class VariableTableManagementService : IVariableTableManagementService
             }
 
             // 确保_variableTables和result.VariableTable不为null
-            if (_appStorageService.VariableTables.TryAdd(result.VariableTable.Id, result.VariableTable))
+            if (_appDataService.VariableTables.TryAdd(result.VariableTable.Id, result.VariableTable))
             {
                 _eventService.RaiseVariableTableChanged(this, new VariableTableChangedEventArgs(
                                            DataChangeType.Added,
@@ -94,7 +94,7 @@ public class VariableTableManagementService : IVariableTableManagementService
         // 更新成功后，更新内存中的变量表
         if (result > 0 && variableTable != null)
         {
-            _appStorageService.VariableTables.AddOrUpdate(variableTable.Id, variableTable, (key, oldValue) => variableTable);
+            _appDataService.VariableTables.AddOrUpdate(variableTable.Id, variableTable, (key, oldValue) => variableTable);
             _eventService.RaiseVariableTableChanged(this, new VariableTableChangedEventArgs(
                                              DataChangeType.Updated,
                                              variableTable));
@@ -113,9 +113,9 @@ public class VariableTableManagementService : IVariableTableManagementService
         // 删除成功后，从内存中移除变量表
         if (result )
         {
-            if (_appStorageService.VariableTables.TryRemove(id, out var variableTable))
+            if (_appDataService.VariableTables.TryRemove(id, out var variableTable))
             {
-                if (variableTable != null && _appStorageService.Devices.TryGetValue(variableTable.DeviceId, out var device))
+                if (variableTable != null && _appDataService.Devices.TryGetValue(variableTable.DeviceId, out var device))
                 {
                     if (device.VariableTables != null)
                         device.VariableTables.Remove(variableTable);
@@ -136,12 +136,12 @@ public class VariableTableManagementService : IVariableTableManagementService
     /// </summary>
     public async Task LoadAllVariableTablesAsync()
     {
-        _appStorageService.VariableTables.Clear();
+        _appDataService.VariableTables.Clear();
         var variableTables = await _variableTableAppService.GetAllVariableTablesAsync();
         // 建立变量表与变量的关联
         foreach (var variableTable in variableTables)
         {
-            if (_appStorageService.Devices.TryGetValue(variableTable.DeviceId, out var device))
+            if (_appDataService.Devices.TryGetValue(variableTable.DeviceId, out var device))
             {
                 variableTable.Device = device;
                 if (device.VariableTables == null)
@@ -150,7 +150,7 @@ public class VariableTableManagementService : IVariableTableManagementService
             }
 
             // 将变量表添加到安全字典
-            _appStorageService.VariableTables.TryAdd(variableTable.Id, variableTable);
+            _appDataService.VariableTables.TryAdd(variableTable.Id, variableTable);
         }
     }
 

DMS.Application/Services/Monitoring/DeviceMonitoringService.cs

@@ -17,7 +17,7 @@ public class DeviceMonitoringService : IDeviceMonitoringService, IDisposable
 {
     private readonly ILogger<DeviceMonitoringService> _logger;
     private readonly IEventService _eventService;
-    private readonly IAppStorageService _appStorageService;
+    private readonly IAppDataService _appDataService;
     private readonly IAppCenterService _appCenterService;
 
 
@@ -27,12 +27,12 @@ public class DeviceMonitoringService : IDeviceMonitoringService, IDisposable
     /// <param name="logger">日志记录器</param>
     /// <param name="deviceAppService">设备应用服务</param>
     public DeviceMonitoringService(ILogger<DeviceMonitoringService> logger, IEventService eventService,
-                                   IAppStorageService appStorageService,
+                                   IAppDataService appStorageService,
                                    IAppCenterService appCenterService)
     {
         _logger = logger;
         _eventService = eventService;
-        _appStorageService = appStorageService;
+        _appDataService = appStorageService;
         _appCenterService = appCenterService;
         _eventService.OnDeviceStateChanged += OnDeviceStateChanged;
     }
@@ -42,7 +42,7 @@ public class DeviceMonitoringService : IDeviceMonitoringService, IDisposable
         // 只处理激活状态变化事件
         if (e.StateType == Core.Enums.DeviceStateType.Active)
         {
-            if (_appStorageService.Devices.TryGetValue(e.DeviceId, out var device))
+            if (_appDataService.Devices.TryGetValue(e.DeviceId, out var device))
             {
                 // 更新设备激活状态 - 同时更新数据库和内存
                 _ = Task.Run(async () =>