Refactor network configuration and cellular network services

CoreAgent.API/Controllers/BaseApiController.cs

@@ -1,3 +1,4 @@
+using CoreAgent.Domain.Exceptions;
 using CoreAgent.Domain.Models.Common;
 using MediatR;
 using Microsoft.AspNetCore.Mvc;
@@ -24,12 +25,13 @@ namespace CoreAgent.API.Controllers
         {
             try
             {
-                _logger.LogInformation("Handling request of type {RequestType}", typeof(TRequest).Name);
+                _logger.LogInformation("开始处理请求: {RequestType}", typeof(TRequest).Name);
                 var response = await _mediator.Send(request);
-                return ApiActionResult<TResponse>.Ok(response);
+                return response as IActionResult;
             }
             catch (Exception ex)
             {
+                _logger.LogError(ex, "处理请求时发生错误: {RequestType}", typeof(TRequest).Name);
                 return HandleException<TResponse>(ex);
             }
         }
@@ -51,8 +53,19 @@ namespace CoreAgent.API.Controllers
 
         private IActionResult HandleException<T>(Exception ex)
         {
-            _logger.LogError(ex, "Error handling request");
+            return ex switch
-            return ApiActionResult<T>.Error(ex.Message, "INTERNAL_ERROR", HttpStatusCode.InternalServerError);
+            {
+                ValidationException validationEx => 
+                    ApiActionResult<T>.Error(validationEx.Message, "VALIDATION_ERROR", HttpStatusCode.BadRequest),
+                NotFoundException notFoundEx => 
+                    ApiActionResult<T>.Error(notFoundEx.Message, "NOT_FOUND", HttpStatusCode.NotFound),
+                UnauthorizedAccessException => 
+                    ApiActionResult<T>.Error("您没有权限访问此资源", "UNAUTHORIZED", HttpStatusCode.Unauthorized),
+                _ => ApiActionResult<T>.Error(
+                    "服务器内部错误，请稍后重试", 
+                    "INTERNAL_ERROR", 
+                    HttpStatusCode.InternalServerError)
+            };
         }
 
         private IActionResult HandleException(Exception ex)
@@ -61,10 +74,10 @@ namespace CoreAgent.API.Controllers
             return ApiActionResult.Error(ex.Message, "INTERNAL_ERROR", HttpStatusCode.InternalServerError);
         }
 
-        protected IActionResult Success<T>(T data, string message = null) => 
+        protected IActionResult Success<T>(T data, string message = "操作成功") => 
             ApiActionResult<T>.Ok(data, message);
 
-        protected IActionResult Success(string message = null) => 
+        protected IActionResult Success(string message = "操作成功") => 
             ApiActionResult.Ok(message);
 
         protected IActionResult Error(string message, string errorCode = "ERROR", HttpStatusCode statusCode = HttpStatusCode.BadRequest) => 

CoreAgent.API/Controllers/CellularNetworkController.cs

@@ -1,4 +1,5 @@
 using CoreAgent.Application.Commands.CellularNetwork;
+using CoreAgent.Domain.Models.Common;
 using CoreAgent.Domain.Models.Network;
 using MediatR;
 using Microsoft.AspNetCore.Mvc;
@@ -27,10 +28,13 @@ public class CellularNetworkController : BaseApiController
     /// <param name="command">启动命令</param>
     /// <returns>操作结果</returns>
     [HttpPost("start")]
+    [ProducesResponseType(typeof(ApiActionResult<CellularNetworkOperationResult>), 200)]
+    [ProducesResponseType(typeof(ApiActionResult<CellularNetworkOperationResult>), 400)]
+    [ProducesResponseType(typeof(ApiActionResult<CellularNetworkOperationResult>), 500)]
     public async Task<IActionResult> Start([FromBody] StartCellularNetworkCommand command)
     {
         _logger.LogInformation("收到启动蜂窝网络请求: {ConfigKey}", command.Key);
-        return await HandleRequest<StartCellularNetworkCommand, CellularNetworkOperationResult>(command);
+        return await HandleRequest<StartCellularNetworkCommand, ApiActionResult<CellularNetworkOperationResult>>(command);
     }
 
     /// <summary>
@@ -39,9 +43,12 @@ public class CellularNetworkController : BaseApiController
     /// <param name="command">停止命令</param>
     /// <returns>操作结果</returns>
     [HttpPost("stop")]
+    [ProducesResponseType(typeof(ApiActionResult<bool>), 200)]
+    [ProducesResponseType(typeof(ApiActionResult<bool>), 400)]
+    [ProducesResponseType(typeof(ApiActionResult<bool>), 500)]
     public async Task<IActionResult> Stop([FromBody] StopCellularNetworkCommand command)
     {
-        _logger.LogInformation("收到停止蜂窝网络请求: {InterfaceName}", command.InterfaceName);
+        _logger.LogInformation("收到停止蜂窝网络请求: {InterfaceName}", command.Key);
-        return await HandleRequest<StopCellularNetworkCommand, bool>(command);
+        return await HandleRequest<StopCellularNetworkCommand, ApiActionResult<bool>>(command);
     }
 } 

CoreAgent.API/Controllers/NetworkConfigController.cs

@@ -1,8 +1,9 @@
 using System.Threading.Tasks;
 using CoreAgent.Application.Commands.NetworkConfig;
-using CoreAgent.Application.Queries.NetworkConfig;
 using CoreAgent.Domain.Entities;
+using CoreAgent.Domain.Models.Common;
 using MediatR;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Logging;
 
@@ -29,10 +30,11 @@ namespace CoreAgent.API.Controllers
         /// </summary>
         /// <returns>网络配置列表</returns>
         [HttpGet]
-        [ProducesResponseType(typeof(List<NetworkConfiguration>), 200)]
+        [ProducesResponseType(typeof(ApiActionResult<List<NetworkConfiguration>>), 200)]
+        [ProducesResponseType(typeof(ApiActionResult<List<NetworkConfiguration>>), 500)]
         public async Task<IActionResult> GetAll()
         {
-            return await HandleRequest<GetAllNetworkConfigurationsQuery, List<NetworkConfiguration>>(
+            return await HandleRequest<GetAllNetworkConfigurationsQuery, ApiActionResult<List<NetworkConfiguration>>>(
                 new GetAllNetworkConfigurationsQuery());
         }
 
@@ -42,11 +44,12 @@ namespace CoreAgent.API.Controllers
         /// <param name="configKey">配置键值</param>
         /// <returns>网络配置</returns>
         [HttpGet("{configKey}")]
-        [ProducesResponseType(typeof(NetworkConfiguration), 200)]
+        [ProducesResponseType(typeof(ApiActionResult<NetworkConfiguration>), 200)]
-        [ProducesResponseType(404)]
+        [ProducesResponseType(typeof(ApiActionResult<NetworkConfiguration>), 404)]
+        [ProducesResponseType(typeof(ApiActionResult<NetworkConfiguration>), 500)]
         public async Task<IActionResult> GetByKey(string configKey)
         {
-            return await HandleRequest<GetNetworkConfigurationByKeyQuery, NetworkConfiguration>(
+            return await HandleRequest<GetNetworkConfigurationByKeyQuery, ApiActionResult<NetworkConfiguration>>(
                 new GetNetworkConfigurationByKeyQuery { ConfigKey = configKey });
         }
 
@@ -56,18 +59,12 @@ namespace CoreAgent.API.Controllers
         /// <param name="command">创建网络配置命令</param>
         /// <returns>创建的网络配置</returns>
         [HttpPost]
-        [ProducesResponseType(typeof(NetworkConfiguration), 201)]
+        [ProducesResponseType(typeof(ApiActionResult<NetworkConfiguration>), 200)]
-        [ProducesResponseType(400)]
+        [ProducesResponseType(typeof(ApiActionResult<NetworkConfiguration>), 400)]
+        [ProducesResponseType(typeof(ApiActionResult<NetworkConfiguration>), 500)]
         public async Task<IActionResult> Create([FromBody] CreateNetworkConfigurationCommand command)
         {
-            var result = await HandleRequest<CreateNetworkConfigurationCommand, NetworkConfiguration>(command);
+            return await HandleRequest<CreateNetworkConfigurationCommand, ApiActionResult<NetworkConfiguration>>(command);
-            if (result is OkObjectResult okResult)
-            {
-                return CreatedAtAction(nameof(GetByKey), 
-                    new { configKey = command.ConfigKey }, 
-                    okResult.Value);
-            }
-            return result;
         }
 
         /// <summary>
@@ -76,12 +73,13 @@ namespace CoreAgent.API.Controllers
         /// <param name="configKey">配置键值</param>
         /// <returns>操作结果</returns>
         [HttpDelete("{configKey}")]
-        [ProducesResponseType(204)]
+        [ProducesResponseType(typeof(ApiActionResult<bool>), 200)]
-        [ProducesResponseType(404)]
+        [ProducesResponseType(typeof(ApiActionResult<bool>), 400)]
+        [ProducesResponseType(typeof(ApiActionResult<bool>), 500)]
         public async Task<IActionResult> Delete(string configKey)
         {
             var command = new DeleteNetworkConfigurationCommand { ConfigKey = configKey };
-            return await HandleRequest<DeleteNetworkConfigurationCommand, Unit>(command);
+            return await HandleRequest<DeleteNetworkConfigurationCommand, ApiActionResult<bool>>(command);
         }
     }
 } 

CoreAgent.Application/Commands/CellularNetwork/StartCellularNetworkCommand.cs

@@ -1,3 +1,4 @@
+using CoreAgent.Domain.Models.Common;
 using CoreAgent.Domain.Models.Network;
 using MediatR;
 
@@ -6,7 +7,7 @@ namespace CoreAgent.Application.Commands.CellularNetwork;
 /// <summary>
 /// 启动蜂窝网络命令
 /// </summary>
-public class StartCellularNetworkCommand : IRequest<CellularNetworkOperationResult>
+public class StartCellularNetworkCommand : IRequest<ApiActionResult<CellularNetworkOperationResult>>
 {
     /// <summary>
     /// 网络配置键

CoreAgent.Application/Commands/CellularNetwork/StopCellularNetworkCommand.cs

@@ -1,3 +1,4 @@
+using CoreAgent.Domain.Models.Common;
 using MediatR;
 
 namespace CoreAgent.Application.Commands.CellularNetwork;
@@ -5,10 +6,10 @@ namespace CoreAgent.Application.Commands.CellularNetwork;
 /// <summary>
 /// 停止蜂窝网络命令
 /// </summary>
-public class StopCellularNetworkCommand : IRequest<bool>
+public class StopCellularNetworkCommand : IRequest<ApiActionResult<bool>>
 {
     /// <summary>
     /// 网络接口名称
     /// </summary>
-    public string InterfaceName { get; set; }
+    public string Key { get; set; }
 } 

CoreAgent.Application/Commands/NetworkConfig/CreateNetworkConfigurationCommand.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using CoreAgent.Domain.Entities;
+using CoreAgent.Domain.Models.Common;
 using MediatR;
 
 namespace CoreAgent.Application.Commands.NetworkConfig
@@ -7,7 +8,7 @@ namespace CoreAgent.Application.Commands.NetworkConfig
     /// <summary>
     /// 创建网络配置命令
     /// </summary>
-    public class CreateNetworkConfigurationCommand : IRequest<NetworkConfiguration>
+    public class CreateNetworkConfigurationCommand : IRequest<ApiActionResult<NetworkConfiguration>>
     {
         /// <summary>
         /// 配置键值

CoreAgent.Application/Commands/NetworkConfig/DeleteNetworkConfigurationCommand.cs

@@ -1,3 +1,4 @@
+using CoreAgent.Domain.Models.Common;
 using MediatR;
 
 namespace CoreAgent.Application.Commands.NetworkConfig
@@ -5,7 +6,7 @@ namespace CoreAgent.Application.Commands.NetworkConfig
     /// <summary>
     /// 删除网络配置命令
     /// </summary>
-    public class DeleteNetworkConfigurationCommand : IRequest<Unit>
+    public class DeleteNetworkConfigurationCommand : IRequest<ApiActionResult<bool>>
     {
         /// <summary>
         /// 配置键值

CoreAgent.Application/Commands/NetworkConfig/GetAllNetworkConfigurationsQuery.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+using CoreAgent.Domain.Entities;
+using CoreAgent.Domain.Models.Common;
+using MediatR;
+
+namespace CoreAgent.Application.Commands.NetworkConfig
+{
+    /// <summary>
+    /// 获取所有网络配置查询
+    /// </summary>
+    public class GetAllNetworkConfigurationsQuery : IRequest<ApiActionResult<List<NetworkConfiguration>>>
+    {
+    }
+} 

CoreAgent.Application/Commands/NetworkConfig/GetNetworkConfigurationByKeyQuery.cs

@@ -0,0 +1,17 @@
+using CoreAgent.Domain.Entities;
+using CoreAgent.Domain.Models.Common;
+using MediatR;
+
+namespace CoreAgent.Application.Commands.NetworkConfig
+{
+    /// <summary>
+    /// 根据配置键获取网络配置查询
+    /// </summary>
+    public class GetNetworkConfigurationByKeyQuery : IRequest<ApiActionResult<NetworkConfiguration>>
+    {
+        /// <summary>
+        /// 配置键值
+        /// </summary>
+        public string ConfigKey { get; set; }
+    }
+} 

CoreAgent.Application/Handlers/CellularNetwork/StartCellularNetworkCommandHandler.cs

@@ -1,5 +1,6 @@
 using CoreAgent.Application.Commands.CellularNetwork;
 using CoreAgent.Domain.Interfaces.Network;
+using CoreAgent.Domain.Models.Common;
 using CoreAgent.Domain.Models.Network;
 using MediatR;
 using Microsoft.Extensions.Logging;
@@ -9,7 +10,7 @@ namespace CoreAgent.Application.Handlers.CellularNetwork;
 /// <summary>
 /// 启动蜂窝网络命令处理器
 /// </summary>
-public class StartCellularNetworkCommandHandler : IRequestHandler<StartCellularNetworkCommand, CellularNetworkOperationResult>
+public class StartCellularNetworkCommandHandler : IRequestHandler<StartCellularNetworkCommand, ApiActionResult<CellularNetworkOperationResult>>
 {
     private readonly ICellularNetworkService _cellularNetworkService;
     private readonly ILogger<StartCellularNetworkCommandHandler> _logger;
@@ -22,7 +23,7 @@ public class StartCellularNetworkCommandHandler : IRequestHandler<StartCellularN
         _logger = logger;
     }
 
-    public async Task<CellularNetworkOperationResult> Handle(StartCellularNetworkCommand request, CancellationToken cancellationToken)
+    public async Task<ApiActionResult<CellularNetworkOperationResult>> Handle(StartCellularNetworkCommand request, CancellationToken cancellationToken)
     {
         try
         {
@@ -34,18 +35,24 @@ public class StartCellularNetworkCommandHandler : IRequestHandler<StartCellularN
             if (result.IsSuccess)
             {
                 _logger.LogInformation("蜂窝网络配置 {ConfigKey} 启动成功", request.Key);
+                return ApiActionResult<CellularNetworkOperationResult>.Ok(result, "蜂窝网络启动成功");
             }
             else
             {
                 _logger.LogWarning("蜂窝网络配置 {ConfigKey} 启动失败: {Error}", request.Key, result.ErrorMessage);
+                return ApiActionResult<CellularNetworkOperationResult>.Error(
+                    result.ErrorMessage,
+                    "NETWORK_START_ERROR",
+                    System.Net.HttpStatusCode.BadRequest);
             }
-            
-            return result;
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "启动蜂窝网络配置 {ConfigKey} 失败", request.Key);
-            return CellularNetworkOperationResult.Failure($"启动蜂窝网络失败: {ex.Message}");
+            return ApiActionResult<CellularNetworkOperationResult>.Error(
+                $"启动蜂窝网络失败: {ex.Message}",
+                "INTERNAL_ERROR",
+                System.Net.HttpStatusCode.InternalServerError);
         }
     }
 } 

CoreAgent.Application/Handlers/CellularNetwork/StopCellularNetworkCommandHandler.cs

@@ -1,5 +1,6 @@
 using CoreAgent.Application.Commands.CellularNetwork;
 using CoreAgent.Domain.Interfaces.Network;
+using CoreAgent.Domain.Models.Common;
 using MediatR;
 using Microsoft.Extensions.Logging;
 
@@ -8,7 +9,7 @@ namespace CoreAgent.Application.Handlers.CellularNetwork;
 /// <summary>
 /// 停止蜂窝网络命令处理器
 /// </summary>
-public class StopCellularNetworkCommandHandler : IRequestHandler<StopCellularNetworkCommand, bool>
+public class StopCellularNetworkCommandHandler : IRequestHandler<StopCellularNetworkCommand, ApiActionResult<bool>>
 {
     private readonly ICellularNetworkService _cellularNetworkService;
     private readonly ILogger<StopCellularNetworkCommandHandler> _logger;
@@ -21,39 +22,36 @@ public class StopCellularNetworkCommandHandler : IRequestHandler<StopCellularNet
         _logger = logger;
     }
 
-    public async Task<bool> Handle(StopCellularNetworkCommand request, CancellationToken cancellationToken)
+    public async Task<ApiActionResult<bool>> Handle(StopCellularNetworkCommand request, CancellationToken cancellationToken)
     {
         try
         {
-            _logger.LogInformation("正在停止蜂窝网络接口: {InterfaceName}", request.InterfaceName);
+            _logger.LogInformation("正在停止蜂窝网络: {InterfaceName}", request.Key);
             
             // 停止网络
-            var result = await _cellularNetworkService.StopAsync();
+            var result = await _cellularNetworkService.StopAsync(request.Key);
             
-            if (result)
+            if (result.IsSuccess)
             {
-                _logger.LogInformation("蜂窝网络接口 {InterfaceName} 停止成功", request.InterfaceName);
+                _logger.LogInformation("蜂窝网络 {InterfaceName} 停止成功", request.Key);
-                
+                return ApiActionResult<bool>.Ok(true, "蜂窝网络停止成功");
-                // 获取全局状态
-                //var status = await _cellularNetworkService.GetGlobalStatusAsync();
-                //_logger.LogInformation(
-                //    "蜂窝网络状态: 已连接={IsConnected}, 信号强度={SignalStrength}, 网络类型={NetworkType}, 发射功率={TransmitPower}",
-                //    status.CurrentStatus == NetworkStatus.Connected,
-                //    status.CurrentSignalStrength,
-                //    status.CurrentNetworkType,
-                //    status.CurrentTransmitPower);
             }
             else
             {
-                _logger.LogWarning("蜂窝网络接口 {InterfaceName} 停止失败", request.InterfaceName);
+                _logger.LogWarning("蜂窝网络 {InterfaceName} 停止失败: {Error}", request.Key, result.ErrorMessage);
+                return ApiActionResult<bool>.Error(
+                    result.ErrorMessage,
+                    "NETWORK_STOP_ERROR",
+                    System.Net.HttpStatusCode.BadRequest);
             }
-            
-            return result;
         }
         catch (Exception ex)
         {
-            _logger.LogError(ex, "停止蜂窝网络接口 {InterfaceName} 失败", request.InterfaceName);
+            _logger.LogError(ex, "停止蜂窝网络 {InterfaceName} 失败", request.Key);
-            return false;
+            return ApiActionResult<bool>.Error(
+                $"停止蜂窝网络失败: {ex.Message}",
+                "INTERNAL_ERROR",
+                System.Net.HttpStatusCode.InternalServerError);
         }
     }
 } 

CoreAgent.Application/Handlers/NetworkConfig/Commands/CreateNetworkConfigurationCommandHandler.cs

@@ -4,24 +4,31 @@ using System.Threading.Tasks;
 using CoreAgent.Application.Commands.NetworkConfig;
 using CoreAgent.Domain.Entities;
 using CoreAgent.Domain.Interfaces;
+using CoreAgent.Domain.Models.Common;
 using MediatR;
+using Microsoft.Extensions.Logging;
 
 namespace CoreAgent.Application.Handlers.NetworkConfig.Commands
 {
     /// <summary>
     /// 创建网络配置命令处理器
     /// </summary>
-    public class CreateNetworkConfigurationCommandHandler : IRequestHandler<CreateNetworkConfigurationCommand, NetworkConfiguration>
+    public class CreateNetworkConfigurationCommandHandler : IRequestHandler<CreateNetworkConfigurationCommand, ApiActionResult<NetworkConfiguration>>
     {
         private readonly INetworkConfigurationService _service;
+        private readonly ILogger<CreateNetworkConfigurationCommandHandler> _logger;
 
         /// <summary>
         /// 构造函数
         /// </summary>
         /// <param name="service">网络配置服务</param>
-        public CreateNetworkConfigurationCommandHandler(INetworkConfigurationService service)
+        /// <param name="logger">日志记录器</param>
+        public CreateNetworkConfigurationCommandHandler(
+            INetworkConfigurationService service,
+            ILogger<CreateNetworkConfigurationCommandHandler> logger)
         {
             _service = service;
+            _logger = logger;
         }
 
         /// <summary>
@@ -29,17 +36,44 @@ namespace CoreAgent.Application.Handlers.NetworkConfig.Commands
         /// </summary>
         /// <param name="request">创建网络配置命令</param>
         /// <param name="cancellationToken">取消令牌</param>
-        /// <returns>创建的网络配置</returns>
+        /// <returns>创建的网络配置结果</returns>
-        public async Task<NetworkConfiguration> Handle(CreateNetworkConfigurationCommand request, CancellationToken cancellationToken)
+        public async Task<ApiActionResult<NetworkConfiguration>> Handle(CreateNetworkConfigurationCommand request, CancellationToken cancellationToken)
         {
-            return await _service.CreateAsync(
+            try
-                request.ConfigKey,
+            {
-                request.RagConfig,
+                _logger.LogInformation("正在创建网络配置: {ConfigKey}", request.ConfigKey);
-                request.CoreOrImsConfigs,
+
-                request.Apn,
+                var (success, config) = await _service.CreateAsync(
-                request.Band,
+                    request.ConfigKey,
-                request.Comment
+                    request.RagConfig,
-            );
+                    request.CoreOrImsConfigs,
+                    request.Apn,
+                    request.Band,
+                    request.Comment
+                );
+
+                if (success)
+                {
+                    _logger.LogInformation("网络配置创建成功: {ConfigKey}", request.ConfigKey);
+                    return ApiActionResult<NetworkConfiguration>.Ok(config, "网络配置创建成功");
+                }
+                else
+                {
+                    _logger.LogWarning("网络配置创建失败，配置键已存在: {ConfigKey}", request.ConfigKey);
+                    return ApiActionResult<NetworkConfiguration>.Error(
+                        "配置键已存在",
+                        "CONFIG_KEY_EXISTS",
+                        System.Net.HttpStatusCode.Conflict);
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "创建网络配置失败: {ConfigKey}", request.ConfigKey);
+                return ApiActionResult<NetworkConfiguration>.Error(
+                    $"创建网络配置失败: {ex.Message}",
+                    "INTERNAL_ERROR",
+                    System.Net.HttpStatusCode.InternalServerError);
+            }
         }
     }
 } 

CoreAgent.Application/Handlers/NetworkConfig/Commands/DeleteNetworkConfigurationCommandHandler.cs

@@ -1,26 +1,33 @@
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 using CoreAgent.Application.Commands.NetworkConfig;
 using CoreAgent.Domain.Interfaces;
+using CoreAgent.Domain.Models.Common;
 using MediatR;
+using Microsoft.Extensions.Logging;
 
 namespace CoreAgent.Application.Handlers.NetworkConfig.Commands
 {
-
     /// <summary>
     /// 删除网络配置命令处理器
     /// </summary>
-    public class DeleteNetworkConfigurationCommandHandler : IRequestHandler<DeleteNetworkConfigurationCommand, Unit>
+    public class DeleteNetworkConfigurationCommandHandler : IRequestHandler<DeleteNetworkConfigurationCommand, ApiActionResult<bool>>
     {
         private readonly INetworkConfigurationService _service;
+        private readonly ILogger<DeleteNetworkConfigurationCommandHandler> _logger;
 
         /// <summary>
         /// 构造函数
         /// </summary>
         /// <param name="service">网络配置服务</param>
-        public DeleteNetworkConfigurationCommandHandler(INetworkConfigurationService service)
+        /// <param name="logger">日志记录器</param>
+        public DeleteNetworkConfigurationCommandHandler(
+            INetworkConfigurationService service,
+            ILogger<DeleteNetworkConfigurationCommandHandler> logger)
         {
             _service = service;
+            _logger = logger;
         }
 
         /// <summary>
@@ -29,10 +36,36 @@ namespace CoreAgent.Application.Handlers.NetworkConfig.Commands
         /// <param name="request">删除网络配置命令</param>
         /// <param name="cancellationToken">取消令牌</param>
         /// <returns>操作结果</returns>
-        public async Task<Unit> Handle(DeleteNetworkConfigurationCommand request, CancellationToken cancellationToken)
+        public async Task<ApiActionResult<bool>> Handle(DeleteNetworkConfigurationCommand request, CancellationToken cancellationToken)
         {
-            await _service.DeleteAsync(request.ConfigKey);
+            try
-            return Unit.Value;
+            {
+                _logger.LogInformation("正在删除网络配置: {ConfigKey}", request.ConfigKey);
+
+                var result = await _service.DeleteAsync(request.ConfigKey);
+                
+                if (result)
+                {
+                    _logger.LogInformation("网络配置删除成功: {ConfigKey}", request.ConfigKey);
+                    return ApiActionResult<bool>.Ok(true, "网络配置删除成功");
+                }
+                else
+                {
+                    _logger.LogWarning("网络配置删除失败，未找到配置: {ConfigKey}", request.ConfigKey);
+                    return ApiActionResult<bool>.Error(
+                        "未找到要删除的网络配置",
+                        "CONFIG_NOT_FOUND",
+                        System.Net.HttpStatusCode.NotFound);
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "删除网络配置失败: {ConfigKey}", request.ConfigKey);
+                return ApiActionResult<bool>.Error(
+                    $"删除网络配置失败: {ex.Message}",
+                    "INTERNAL_ERROR",
+                    System.Net.HttpStatusCode.InternalServerError);
+            }
         }
     }
 } 

CoreAgent.Application/Handlers/NetworkConfig/Commands/GetAllNetworkConfigurationsQueryHandler.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using CoreAgent.Application.Commands.NetworkConfig;
+using CoreAgent.Domain.Entities;
+using CoreAgent.Domain.Interfaces;
+using CoreAgent.Domain.Models.Common;
+using MediatR;
+using Microsoft.Extensions.Logging;
+
+namespace CoreAgent.Application.Handlers.NetworkConfig.Commands
+{
+    /// <summary>
+    /// 获取所有网络配置查询处理器
+    /// </summary>
+    public class GetAllNetworkConfigurationsQueryHandler : IRequestHandler<GetAllNetworkConfigurationsQuery, ApiActionResult<List<NetworkConfiguration>>>
+    {
+        private readonly INetworkConfigurationService _service;
+        private readonly ILogger<GetAllNetworkConfigurationsQueryHandler> _logger;
+
+        /// <summary>
+        /// 构造函数
+        /// </summary>
+        /// <param name="service">网络配置服务</param>
+        /// <param name="logger">日志记录器</param>
+        public GetAllNetworkConfigurationsQueryHandler(
+            INetworkConfigurationService service,
+            ILogger<GetAllNetworkConfigurationsQueryHandler> logger)
+        {
+            _service = service;
+            _logger = logger;
+        }
+
+        /// <summary>
+        /// 处理获取所有网络配置查询
+        /// </summary>
+        /// <param name="request">获取所有网络配置查询</param>
+        /// <param name="cancellationToken">取消令牌</param>
+        /// <returns>网络配置列表</returns>
+        public async Task<ApiActionResult<List<NetworkConfiguration>>> Handle(GetAllNetworkConfigurationsQuery request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                _logger.LogInformation("正在获取所有网络配置");
+
+                var configurations = await _service.GetAllAsync();
+                
+                _logger.LogInformation("成功获取所有网络配置，共 {Count} 条记录", configurations.Count);
+                return ApiActionResult<List<NetworkConfiguration>>.Ok(configurations, "成功获取所有网络配置");
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "获取所有网络配置失败");
+                return ApiActionResult<List<NetworkConfiguration>>.Error(
+                    $"获取所有网络配置失败: {ex.Message}",
+                    "INTERNAL_ERROR",
+                    System.Net.HttpStatusCode.InternalServerError);
+            }
+        }
+    }
+} 

CoreAgent.Application/Handlers/NetworkConfig/Commands/GetNetworkConfigurationByKeyQueryHandler.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using CoreAgent.Application.Commands.NetworkConfig;
+using CoreAgent.Domain.Entities;
+using CoreAgent.Domain.Interfaces;
+using CoreAgent.Domain.Models.Common;
+using MediatR;
+using Microsoft.Extensions.Logging;
+
+namespace CoreAgent.Application.Handlers.NetworkConfig.Commands
+{
+    /// <summary>
+    /// 根据配置键获取网络配置查询处理器
+    /// </summary>
+    public class GetNetworkConfigurationByKeyQueryHandler : IRequestHandler<GetNetworkConfigurationByKeyQuery, ApiActionResult<NetworkConfiguration>>
+    {
+        private readonly INetworkConfigurationService _service;
+        private readonly ILogger<GetNetworkConfigurationByKeyQueryHandler> _logger;
+
+        /// <summary>
+        /// 构造函数
+        /// </summary>
+        /// <param name="service">网络配置服务</param>
+        /// <param name="logger">日志记录器</param>
+        public GetNetworkConfigurationByKeyQueryHandler(
+            INetworkConfigurationService service,
+            ILogger<GetNetworkConfigurationByKeyQueryHandler> logger)
+        {
+            _service = service;
+            _logger = logger;
+        }
+
+        /// <summary>
+        /// 处理根据配置键获取网络配置查询
+        /// </summary>
+        /// <param name="request">根据配置键获取网络配置查询</param>
+        /// <param name="cancellationToken">取消令牌</param>
+        /// <returns>网络配置</returns>
+        public async Task<ApiActionResult<NetworkConfiguration>> Handle(GetNetworkConfigurationByKeyQuery request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                _logger.LogInformation("正在获取网络配置: {ConfigKey}", request.ConfigKey);
+
+                var configuration = await _service.GetByConfigKeyAsync(request.ConfigKey);
+                if (configuration == null)
+                {
+                    _logger.LogWarning("未找到网络配置: {ConfigKey}", request.ConfigKey);
+                    return ApiActionResult<NetworkConfiguration>.Error(
+                        $"未找到网络配置: {request.ConfigKey}",
+                        "CONFIG_NOT_FOUND",
+                        System.Net.HttpStatusCode.NotFound);
+                }
+
+                _logger.LogInformation("成功获取网络配置: {ConfigKey}", request.ConfigKey);
+                return ApiActionResult<NetworkConfiguration>.Ok(configuration, "成功获取网络配置");
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "获取网络配置失败: {ConfigKey}", request.ConfigKey);
+                return ApiActionResult<NetworkConfiguration>.Error(
+                    $"获取网络配置失败: {ex.Message}",
+                    "INTERNAL_ERROR",
+                    System.Net.HttpStatusCode.InternalServerError);
+            }
+        }
+    }
+} 

CoreAgent.Application/Handlers/NetworkConfig/Queries/GetNetworkConfigurationQueryHandler.cs

@@ -1,66 +0,0 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using CoreAgent.Application.Queries.NetworkConfig;
-using CoreAgent.Domain.Entities;
-using CoreAgent.Domain.Interfaces;
-using MediatR;
-
-namespace CoreAgent.Application.Handlers.NetworkConfig.Queries
-{
-    /// <summary>
-    /// 获取所有网络配置查询处理器
-    /// </summary>
-    public class GetAllNetworkConfigurationsQueryHandler : IRequestHandler<GetAllNetworkConfigurationsQuery, List<NetworkConfiguration>>
-    {
-        private readonly INetworkConfigurationService _service;
-
-        /// <summary>
-        /// 构造函数
-        /// </summary>
-        /// <param name="service">网络配置服务</param>
-        public GetAllNetworkConfigurationsQueryHandler(INetworkConfigurationService service)
-        {
-            _service = service;
-        }
-
-        /// <summary>
-        /// 处理获取所有网络配置查询
-        /// </summary>
-        /// <param name="request">获取所有网络配置查询</param>
-        /// <param name="cancellationToken">取消令牌</param>
-        /// <returns>网络配置列表</returns>
-        public Task<List<NetworkConfiguration>> Handle(GetAllNetworkConfigurationsQuery request, CancellationToken cancellationToken)
-        {
-            return _service.GetAllAsync();
-        }
-    }
-
-    /// <summary>
-    /// 根据配置键获取网络配置查询处理器
-    /// </summary>
-    public class GetNetworkConfigurationByKeyQueryHandler : IRequestHandler<GetNetworkConfigurationByKeyQuery, NetworkConfiguration>
-    {
-        private readonly INetworkConfigurationService _service;
-
-        /// <summary>
-        /// 构造函数
-        /// </summary>
-        /// <param name="service">网络配置服务</param>
-        public GetNetworkConfigurationByKeyQueryHandler(INetworkConfigurationService service)
-        {
-            _service = service;
-        }
-
-        /// <summary>
-        /// 处理根据配置键获取网络配置查询
-        /// </summary>
-        /// <param name="request">根据配置键获取网络配置查询</param>
-        /// <param name="cancellationToken">取消令牌</param>
-        /// <returns>网络配置</returns>
-        public Task<NetworkConfiguration> Handle(GetNetworkConfigurationByKeyQuery request, CancellationToken cancellationToken)
-        {
-            return _service.GetByConfigKeyAsync(request.ConfigKey);
-        }
-    }
-} 

CoreAgent.Application/Interfaces/INetworkConfigurationService.cs

@@ -1,55 +0,0 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using CoreAgent.Domain.Entities;
-
-namespace CoreAgent.Application.Interfaces
-{
-    /// <summary>
-    /// 网络配置服务接口
-    /// </summary>
-    public interface INetworkConfigurationService
-    {
-        /// <summary>
-        /// 创建网络配置
-        /// </summary>
-        /// <param name="configKey">配置键值</param>
-        /// <param name="ragConfig">RAN配置文件路径</param>
-        /// <param name="coreOrImsConfigs">核心网和IMS配置列表</param>
-        /// <param name="apn">APN配置</param>
-        /// <param name="band">频段配置</param>
-        /// <param name="comment">配置说明</param>
-        /// <returns>创建的网络配置</returns>
-        Task<NetworkConfiguration> CreateAsync(
-            string configKey,
-            string ragConfig,
-            List<CoreImsConfig> coreOrImsConfigs,
-            string apn,
-            List<string> band,
-            string comment = null);
-
-        /// <summary>
-        /// 保存网络配置
-        /// </summary>
-        /// <param name="configuration">网络配置</param>
-        Task SaveAsync(NetworkConfiguration configuration);
-
-        /// <summary>
-        /// 删除网络配置
-        /// </summary>
-        /// <param name="configKey">配置键值</param>
-        Task DeleteAsync(string configKey);
-
-        /// <summary>
-        /// 获取所有网络配置
-        /// </summary>
-        /// <returns>网络配置列表</returns>
-        Task<List<NetworkConfiguration>> GetAllAsync();
-
-        /// <summary>
-        /// 根据配置键获取网络配置
-        /// </summary>
-        /// <param name="configKey">配置键值</param>
-        /// <returns>网络配置</returns>
-        Task<NetworkConfiguration> GetByConfigKeyAsync(string configKey);
-    }
-} 

CoreAgent.Application/Queries/NetworkConfig/GetNetworkConfigurationQuery.cs

@@ -1,24 +0,0 @@
-using System.Collections.Generic;
-using CoreAgent.Domain.Entities;
-using MediatR;
-
-namespace CoreAgent.Application.Queries.NetworkConfig
-{
-    /// <summary>
-    /// 获取所有网络配置查询
-    /// </summary>
-    public class GetAllNetworkConfigurationsQuery : IRequest<List<NetworkConfiguration>>
-    {
-    }
-
-    /// <summary>
-    /// 根据配置键获取网络配置查询
-    /// </summary>
-    public class GetNetworkConfigurationByKeyQuery : IRequest<NetworkConfiguration>
-    {
-        /// <summary>
-        /// 配置键值
-        /// </summary>
-        public string ConfigKey { get; set; }
-    }
-} 

CoreAgent.Domain/Interfaces/INetworkConfigurationRepository.cs

@@ -31,13 +31,15 @@ namespace CoreAgent.Domain.Interfaces
         /// 保存网络配置
         /// </summary>
         /// <param name="configuration">网络配置</param>
-        Task SaveAsync(NetworkConfiguration configuration);
+        /// <returns>保存是否成功</returns>
+        Task<bool> SaveAsync(NetworkConfiguration configuration);
 
         /// <summary>
         /// 删除网络配置
         /// </summary>
         /// <param name="configKey">配置键值</param>
-        Task DeleteAsync(string configKey);
+        /// <returns>删除是否成功</returns>
+        Task<bool> DeleteAsync(string configKey);
 
         /// <summary>
         /// 获取所有网络配置

CoreAgent.Domain/Interfaces/INetworkConfigurationService.cs

@@ -18,8 +18,8 @@ namespace CoreAgent.Domain.Interfaces
         /// <param name="apn">APN配置</param>
         /// <param name="band">频段配置</param>
         /// <param name="comment">配置说明</param>
-        /// <returns>创建的网络配置</returns>
+        /// <returns>(是否成功, 创建的网络配置)</returns>
-        Task<NetworkConfiguration> CreateAsync(
+        Task<(bool Success, NetworkConfiguration Configuration)> CreateAsync(
             string configKey,
             string ragConfig,
             List<CoreImsConfig> coreOrImsConfigs,
@@ -31,13 +31,15 @@ namespace CoreAgent.Domain.Interfaces
         /// 保存网络配置
         /// </summary>
         /// <param name="configuration">网络配置</param>
-        Task SaveAsync(NetworkConfiguration configuration);
+        /// <returns>保存是否成功</returns>
+        Task<bool> SaveAsync(NetworkConfiguration configuration);
 
         /// <summary>
         /// 删除网络配置
         /// </summary>
         /// <param name="configKey">配置键值</param>
-        Task DeleteAsync(string configKey);
+        /// <returns>删除是否成功</returns>
+        Task<bool> DeleteAsync(string configKey);
 
         /// <summary>
         /// 获取所有网络配置

CoreAgent.Domain/Interfaces/Network/ICellularNetworkService.cs

@@ -18,5 +18,5 @@ public interface ICellularNetworkService
     /// 停止蜂窝网络
     /// </summary>
     /// <returns>停止结果</returns>
-    Task<CellularNetworkOperationResult> StopAsync();
+    Task<CellularNetworkOperationResult> StopAsync(string Key);
 }

CoreAgent.Infrastructure/Repositories/NetworkConfigurationRepository.cs

@@ -7,6 +7,7 @@ using System.Threading.Tasks;
 using CoreAgent.Domain.Entities;
 using CoreAgent.Domain.Interfaces;
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
 
 namespace CoreAgent.Infrastructure.Repositories
 {
@@ -17,6 +18,7 @@ namespace CoreAgent.Infrastructure.Repositories
     {
         private static readonly object _lock = new object();
         private readonly string _configFilePath;
+        private readonly ILogger<NetworkConfigurationRepository> _logger;
         private static readonly JsonSerializerOptions _jsonOptions = new()
         {
             PropertyNameCaseInsensitive = true,
@@ -29,8 +31,10 @@ namespace CoreAgent.Infrastructure.Repositories
         /// 构造函数
         /// </summary>
         /// <param name="configuration">配置</param>
-        public NetworkConfigurationRepository(IConfiguration configuration)
+        /// <param name="logger">日志记录器</param>
+        public NetworkConfigurationRepository(IConfiguration configuration, ILogger<NetworkConfigurationRepository> logger)
         {
+            _logger = logger;
             var basePath = AppDomain.CurrentDomain.BaseDirectory;
             _configFilePath = Path.Combine(basePath, "Configurations", "NetworkConfig.json");
             
@@ -69,46 +73,80 @@ namespace CoreAgent.Infrastructure.Repositories
         /// <summary>
         /// 保存网络配置
         /// </summary>
-        public async Task SaveAsync(NetworkConfiguration configuration)
+        public async Task<bool> SaveAsync(NetworkConfiguration configuration)
         {
             if (configuration == null)
             {
+                _logger.LogError("保存网络配置失败：配置对象为空");
                 throw new ArgumentNullException(nameof(configuration));
             }
 
-            var configs = await GetAllAsync();
+            try
-            var existingConfig = configs.FirstOrDefault(c => c.ConfigKey == configuration.ConfigKey);
-            
-            if (existingConfig != null)
             {
-                var index = configs.IndexOf(existingConfig);
+                _logger.LogInformation("开始保存网络配置，配置键：{ConfigKey}", configuration.ConfigKey);
-                configs[index] = configuration;
+                
+                var configs = await GetAllAsync();
+                var existingConfig = configs.FirstOrDefault(c => c.ConfigKey == configuration.ConfigKey);
+                
+                if (existingConfig != null)
+                {
+                    _logger.LogInformation("更新已存在的网络配置，配置键：{ConfigKey}", configuration.ConfigKey);
+                    var index = configs.IndexOf(existingConfig);
+                    configs[index] = configuration;
+                }
+                else
+                {
+                    _logger.LogInformation("添加新的网络配置，配置键：{ConfigKey}", configuration.ConfigKey);
+                    configs.Add(configuration);
+                }
+
+                await SaveConfigurationsAsync(configs);
+                _logger.LogInformation("网络配置保存成功，配置键：{ConfigKey}", configuration.ConfigKey);
+                return true;
             }
-            else
+            catch (Exception ex)
             {
-                configs.Add(configuration);
+                _logger.LogError(ex, "保存网络配置失败，配置键：{ConfigKey}，错误信息：{ErrorMessage}", 
+                    configuration.ConfigKey, ex.Message);
+                return false;
             }
-
-            await SaveConfigurationsAsync(configs);
         }
 
         /// <summary>
         /// 删除网络配置
         /// </summary>
-        public async Task DeleteAsync(string configKey)
+        public async Task<bool> DeleteAsync(string configKey)
         {
             if (string.IsNullOrEmpty(configKey))
             {
+                _logger.LogError("删除网络配置失败：配置键为空");
                 throw new ArgumentException("配置键值不能为空", nameof(configKey));
             }
 
-            var configs = await GetAllAsync();
+            try
-            var config = configs.FirstOrDefault(c => c.ConfigKey == configKey);
-            
-            if (config != null)
             {
-                configs.Remove(config);
+                _logger.LogInformation("开始删除网络配置，配置键：{ConfigKey}", configKey);
-                await SaveConfigurationsAsync(configs);
+                
+                var configs = await GetAllAsync();
+                var config = configs.FirstOrDefault(c => c.ConfigKey == configKey);
+                
+                if (config != null)
+                {
+                    _logger.LogInformation("找到要删除的网络配置，配置键：{ConfigKey}", configKey);
+                    configs.Remove(config);
+                    await SaveConfigurationsAsync(configs);
+                    _logger.LogInformation("网络配置删除成功，配置键：{ConfigKey}", configKey);
+                    return true;
+                }
+                
+                _logger.LogWarning("未找到要删除的网络配置，配置键：{ConfigKey}", configKey);
+                return false;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "删除网络配置失败，配置键：{ConfigKey}，错误信息：{ErrorMessage}", 
+                    configKey, ex.Message);
+                return false;
             }
         }
 

CoreAgent.Infrastructure/Services/Network/CellularNetworkService.cs

@@ -134,7 +134,7 @@ public class CellularNetworkService : ICellularNetworkService
         }
     }
 
-    public async Task<CellularNetworkOperationResult> StopAsync()
+    public async Task<CellularNetworkOperationResult> StopAsync(string Key)
     {
         string neConfigKey = _context.GetNeConfigKey();
         try

CoreAgent.Infrastructure/Services/NetworkConfigurationService.cs

@@ -1,7 +1,9 @@
+using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using CoreAgent.Domain.Entities;
 using CoreAgent.Domain.Interfaces;
+using Microsoft.Extensions.Logging;
 
 namespace CoreAgent.Infrastructure.Services
 {
@@ -11,20 +13,25 @@ namespace CoreAgent.Infrastructure.Services
     public class NetworkConfigurationService : INetworkConfigurationService
     {
         private readonly INetworkConfigurationRepository _repository;
+        private readonly ILogger<NetworkConfigurationService> _logger;
 
         /// <summary>
         /// 构造函数
         /// </summary>
         /// <param name="repository">网络配置仓储</param>
-        public NetworkConfigurationService(INetworkConfigurationRepository repository)
+        /// <param name="logger">日志记录器</param>
+        public NetworkConfigurationService(
+            INetworkConfigurationRepository repository,
+            ILogger<NetworkConfigurationService> logger)
         {
             _repository = repository;
+            _logger = logger;
         }
 
         /// <summary>
         /// 创建网络配置
         /// </summary>
-        public Task<NetworkConfiguration> CreateAsync(
+        public async Task<(bool Success, NetworkConfiguration Configuration)> CreateAsync(
             string configKey,
             string ragConfig,
             List<CoreImsConfig> coreOrImsConfigs,
@@ -32,13 +39,42 @@ namespace CoreAgent.Infrastructure.Services
             List<string> band,
             string comment = null)
         {
-            return _repository.CreateAsync(configKey, ragConfig, coreOrImsConfigs, apn, band, comment);
+            try
+            {
+                _logger.LogInformation("开始创建网络配置，配置键：{ConfigKey}", configKey);
+                _logger.LogDebug("创建网络配置参数 - RAN配置：{RagConfig}, APN：{Apn}, 频段：{Band}, 说明：{Comment}", 
+                    ragConfig, apn, string.Join(",", band), comment);
+
+                // 检查配置键是否已存在
+                _logger.LogInformation("检查配置键是否存在：{ConfigKey}", configKey);
+                var existingConfig = await _repository.GetByConfigKeyAsync(configKey);
+                if (existingConfig != null)
+                {
+                    _logger.LogWarning("配置键已存在，创建失败：{ConfigKey}", configKey);
+                    return (false, null);
+                }
+
+                _logger.LogInformation("开始创建新的网络配置：{ConfigKey}", configKey);
+                var config = await _repository.CreateAsync(configKey, ragConfig, coreOrImsConfigs, apn, band, comment);
+                
+                _logger.LogInformation("网络配置创建成功：{ConfigKey}", configKey);
+                _logger.LogDebug("网络配置详情 - RAN配置：{RagConfig}, APN：{Apn}, 频段：{Band}, 说明：{Comment}", 
+                    config.RagConfig, config.Apn, string.Join(",", config.Band), config.Comment);
+                
+                return (true, config);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "创建网络配置失败，配置键：{ConfigKey}，错误信息：{ErrorMessage}", 
+                    configKey, ex.Message);
+                return (false, null);
+            }
         }
 
         /// <summary>
         /// 保存网络配置
         /// </summary>
-        public Task SaveAsync(NetworkConfiguration configuration)
+        public Task<bool> SaveAsync(NetworkConfiguration configuration)
         {
             return _repository.SaveAsync(configuration);
         }
@@ -46,7 +82,7 @@ namespace CoreAgent.Infrastructure.Services
         /// <summary>
         /// 删除网络配置
         /// </summary>
-        public Task DeleteAsync(string configKey)
+        public Task<bool> DeleteAsync(string configKey)
         {
             return _repository.DeleteAsync(configKey);
         }