A:添加防火墙API

src/NetVizor.Backend/NetVizor.sln

@@ -22,6 +22,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Utils.ETW.Test", "Utils.ETW
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WinDivertNet", "WinDivertNet\WinDivertNet.csproj", "{16805469-CDF3-4ED6-9E6C-70DDFB0DF8B3}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Utils.Firewall", "Utils.Firewall\Utils.Firewall.csproj", "{596D1AAE-3763-4AB4-8BCD-262B2A54B781}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -72,5 +74,9 @@ Global
 		{16805469-CDF3-4ED6-9E6C-70DDFB0DF8B3}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{16805469-CDF3-4ED6-9E6C-70DDFB0DF8B3}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{16805469-CDF3-4ED6-9E6C-70DDFB0DF8B3}.Release|Any CPU.Build.0 = Release|Any CPU
+		{596D1AAE-3763-4AB4-8BCD-262B2A54B781}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{596D1AAE-3763-4AB4-8BCD-262B2A54B781}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{596D1AAE-3763-4AB4-8BCD-262B2A54B781}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{596D1AAE-3763-4AB4-8BCD-262B2A54B781}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 EndGlobal

src/NetVizor.Backend/Shell/App.xaml.cs

@@ -22,6 +22,7 @@ using Serilog.Events;
 using Shell;
 using Shell.Views;
 using Utils.ETW.Etw;
+using Utils.Firewall;
 
 namespace NetVizor;
 
@@ -45,10 +46,21 @@ public partial class App : System.Windows.Application
         // NetView
         // var netView = new NetView();
         // netView.Show();
-        
-        var window = new NetView();
-        window.Show();
 
+        Mouth();
+
+        // var window = new NetView();
+        // window.Show();
+
+    }
+
+    private async void Mouth()
+    {
+        var firewallService = new FirewallService();
+        // 防火墙状态
+        // var statusAsync = await firewallService.GetStatusAsync();
+        var rulesAsync =await firewallService.GetRulesAsync();
+        Console.WriteLine(JsonHelper.ToJson(rulesAsync));
     }
 
     /// <summary>

src/NetVizor.Backend/Shell/Shell.csproj

@@ -22,6 +22,7 @@
       <ProjectReference Include="..\Data\Data.csproj" />
       <ProjectReference Include="..\Infrastructure\Infrastructure.csproj" />
       <ProjectReference Include="..\Utils.ETW\Utils.ETW.csproj" />
+      <ProjectReference Include="..\Utils.Firewall\Utils.Firewall.csproj" />
     </ItemGroup>
 
     <ItemGroup>

src/NetVizor.Backend/Utils.Firewall/Class1.cs

@@ -0,0 +1,5 @@
+namespace Utils.Firewall;
+
+public class Class1
+{
+}

src/NetVizor.Backend/Utils.Firewall/FirewallModel.cs

@@ -0,0 +1,202 @@
+namespace Utils.Firewall;
+
+/// <summary>
+/// 防火墙配置文件类型
+/// </summary>
+[Flags]
+public enum FirewallProfile
+{
+    Domain = 1,
+    Private = 2,
+    Public = 4,
+    All = Domain | Private | Public
+}
+
+/// <summary>
+/// 防火墙规则方向
+/// </summary>
+public enum RuleDirection
+{
+    Inbound = 1,
+    Outbound = 2
+}
+
+/// <summary>
+/// 防火墙规则动作
+/// </summary>
+public enum RuleAction
+{
+    Allow = 1,
+    Block = 0
+}
+
+/// <summary>
+/// 协议类型
+/// </summary>
+public enum ProtocolType
+{
+    Any = 256,
+    ICMPV4 = 1,
+    IGMP = 2,
+    TCP = 6,
+    UDP = 17,
+    IPv6 = 41,
+    IPv6Route = 43,
+    IPv6Frag = 44,
+    GRE = 47,
+    ICMPv6 = 58,
+    IPv6NoNxt = 59,
+    IPv6Opts = 60,
+    VRRP = 112,
+    PGM = 113,
+    L2TP = 115
+}
+
+/// <summary>
+/// 防火墙状态信息
+/// </summary>
+public class FirewallStatus
+{
+    public bool IsEnabled { get; set; }
+    public Dictionary<FirewallProfile, ProfileStatus> ProfileStatuses { get; set; } = new();
+    public int TotalRules { get; set; }
+    public int EnabledRules { get; set; }
+    public int InboundRules { get; set; }
+    public int OutboundRules { get; set; }
+    public DateTime LastModified { get; set; }
+}
+
+/// <summary>
+/// 配置文件状态
+/// </summary>
+public class ProfileStatus
+{
+    public FirewallProfile Profile { get; set; }
+    public bool IsEnabled { get; set; }
+    public bool BlockAllInboundTraffic { get; set; }
+    public bool NotifyOnListen { get; set; }
+    public bool UnicastResponsesDisabled { get; set; }
+    public RuleAction DefaultInboundAction { get; set; }
+    public RuleAction DefaultOutboundAction { get; set; }
+}
+
+/// <summary>
+/// 防火墙规则详细信息
+/// </summary>
+public class FirewallRule
+{
+    public string Name { get; set; } = string.Empty;
+    public string Description { get; set; } = string.Empty;
+    public string ApplicationName { get; set; } = string.Empty;
+    public string ServiceName { get; set; } = string.Empty;
+    public ProtocolType Protocol { get; set; }
+    public string LocalPorts { get; set; } = string.Empty;
+    public string RemotePorts { get; set; } = string.Empty;
+    public string LocalAddresses { get; set; } = string.Empty;
+    public string RemoteAddresses { get; set; } = string.Empty;
+    public string IcmpTypesAndCodes { get; set; } = string.Empty;
+    public RuleDirection Direction { get; set; }
+    public bool Enabled { get; set; }
+    public FirewallProfile Profiles { get; set; }
+    public bool EdgeTraversal { get; set; }
+    public RuleAction Action { get; set; }
+    public string Grouping { get; set; } = string.Empty;
+    public string InterfaceTypes { get; set; } = string.Empty;
+    public List<string> Interfaces { get; set; } = new();
+    public DateTime? CreationDate { get; set; }
+    public DateTime? ModificationDate { get; set; }
+
+    // 高级属性
+    public bool EdgeTraversalAllowed { get; set; }
+    public bool LooseSourceMapping { get; set; }
+    public bool LocalOnlyMapping { get; set; }
+    public string RemoteMachineAuthorizationList { get; set; } = string.Empty;
+    public string RemoteUserAuthorizationList { get; set; } = string.Empty;
+    public string EmbeddedContext { get; set; } = string.Empty;
+    public int Flags { get; set; }
+    public bool SecureFlags { get; set; }
+}
+
+/// <summary>
+/// 创建防火墙规则的请求
+/// </summary>
+public class CreateRuleRequest
+{
+    public string Name { get; set; } = string.Empty;
+    public string Description { get; set; } = string.Empty;
+    public string ApplicationName { get; set; } = string.Empty;
+    public string ServiceName { get; set; } = string.Empty;
+    public ProtocolType Protocol { get; set; } = ProtocolType.Any;
+    public string LocalPorts { get; set; } = string.Empty;
+    public string RemotePorts { get; set; } = string.Empty;
+    public string LocalAddresses { get; set; } = "*";
+    public string RemoteAddresses { get; set; } = "*";
+    public string IcmpTypesAndCodes { get; set; } = string.Empty;
+    public RuleDirection Direction { get; set; }
+    public bool Enabled { get; set; } = true;
+    public FirewallProfile Profiles { get; set; } = FirewallProfile.All;
+    public RuleAction Action { get; set; } = RuleAction.Allow;
+    public string Grouping { get; set; } = string.Empty;
+    public string InterfaceTypes { get; set; } = "All";
+    public List<string> Interfaces { get; set; } = new();
+
+    // 高级选项
+    public bool EdgeTraversal { get; set; } = false;
+    public bool EdgeTraversalAllowed { get; set; } = false;
+    public string RemoteMachineAuthorizationList { get; set; } = string.Empty;
+    public string RemoteUserAuthorizationList { get; set; } = string.Empty;
+}
+
+/// <summary>
+/// 更新防火墙规则的请求
+/// </summary>
+public class UpdateRuleRequest
+{
+    public string CurrentName { get; set; } = string.Empty;
+    public string? NewName { get; set; }
+    public string? Description { get; set; }
+    public bool? Enabled { get; set; }
+    public string? ApplicationName { get; set; }
+    public string? ServiceName { get; set; }
+    public ProtocolType? Protocol { get; set; }
+    public string? LocalPorts { get; set; }
+    public string? RemotePorts { get; set; }
+    public string? LocalAddresses { get; set; }
+    public string? RemoteAddresses { get; set; }
+    public FirewallProfile? Profiles { get; set; }
+    public RuleAction? Action { get; set; }
+    public string? Grouping { get; set; }
+    public bool? EdgeTraversal { get; set; }
+}
+
+/// <summary>
+/// 防火墙规则查询过滤器
+/// </summary>
+public class RuleFilter
+{
+    public string? NamePattern { get; set; }
+    public RuleDirection? Direction { get; set; }
+    public bool? Enabled { get; set; }
+    public FirewallProfile? Profile { get; set; }
+    public ProtocolType? Protocol { get; set; }
+    public RuleAction? Action { get; set; }
+    public string? ApplicationName { get; set; }
+    public string? Grouping { get; set; }
+    public string? Port { get; set; }
+}
+
+/// <summary>
+/// 防火墙统计信息
+/// </summary>
+public class FirewallStatistics
+{
+    public int TotalRules { get; set; }
+    public int EnabledRules { get; set; }
+    public int DisabledRules { get; set; }
+    public Dictionary<RuleDirection, int> RulesByDirection { get; set; } = new();
+    public Dictionary<ProtocolType, int> RulesByProtocol { get; set; } = new();
+    public Dictionary<FirewallProfile, int> RulesByProfile { get; set; } = new();
+    public Dictionary<RuleAction, int> RulesByAction { get; set; } = new();
+    public List<string> TopApplications { get; set; } = new();
+    public List<string> TopPorts { get; set; } = new();
+}

src/NetVizor.Backend/Utils.Firewall/FirewallRuleTemplates.cs

@@ -0,0 +1,218 @@
+namespace Utils.Firewall;
+
+/// <summary>
+/// 防火墙规则模板
+/// </summary>
+/// <summary>
+/// 防火墙规则模板静态类
+/// 提供常用的防火墙规则模板，简化规则创建过程
+/// </summary>
+/// <remarks>
+/// 这个类包含了一系列预定义的规则模板，涵盖了常见的网络服务和应用场景：
+/// - Web服务器规则（HTTP/HTTPS）
+/// - 远程桌面规则
+/// - 数据库服务器规则
+/// - 网络诊断规则（Ping）
+/// 
+/// 使用模板的好处：
+/// 1. 减少手动配置错误
+/// 2. 确保规则的一致性和安全性
+/// 3. 提高开发效率
+/// 4. 便于维护和更新
+/// </remarks>
+public static class FirewallRuleTemplates
+{
+    /// <summary>
+    /// 创建Web服务器防火墙规则模板
+    /// </summary>
+    /// <param name="name">规则名称，建议使用描述性名称如"WebServer-HTTP"</param>
+    /// <param name="port">Web服务端口号，默认为80（HTTP）。HTTPS通常使用443</param>
+    /// <returns>配置完成的Web服务器规则创建请求</returns>
+    /// <remarks>
+    /// 此模板创建的规则特点：
+    /// - 协议：TCP（Web服务基于TCP协议）
+    /// - 方向：入站（允许外部访问Web服务）
+    /// - 动作：允许（permit traffic）
+    /// - 配置文件：所有（Domain、Private、Public）
+    /// - 状态：启用
+    /// 
+    /// 常用端口：
+    /// - HTTP: 80
+    /// - HTTPS: 443
+    /// - HTTP备用: 8080, 8443
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// // 创建HTTP服务规则
+    /// var httpRule = FirewallRuleTemplates.CreateWebServerRule("MyWebSite-HTTP", 80);
+    /// await firewallService.CreateRuleAsync(httpRule);
+    /// 
+    /// // 创建HTTPS服务规则
+    /// var httpsRule = FirewallRuleTemplates.CreateWebServerRule("MyWebSite-HTTPS", 443);
+    /// await firewallService.CreateRuleAsync(httpsRule);
+    /// </code>
+    /// </example>
+    public static CreateRuleRequest CreateWebServerRule(string name, int port = 80)
+    {
+        return new CreateRuleRequest
+        {
+            Name = name,
+            Description = $"Allow inbound traffic on port {port} for web server",
+            Protocol = ProtocolType.TCP, // Web服务使用TCP协议
+            LocalPorts = port.ToString(), // 指定监听端口
+            Direction = RuleDirection.Inbound, // 允许外部连接到本地服务
+            Action = RuleAction.Allow, // 允许连接
+            Profiles = FirewallProfile.All, // 在所有网络配置文件中生效
+            Enabled = true // 规则创建后立即启用
+        };
+    }
+
+    /// <summary>
+    /// 创建远程桌面连接防火墙规则模板
+    /// </summary>
+    /// <param name="name">规则名称，建议使用"RemoteDesktop"或"RDP"</param>
+    /// <returns>配置完成的远程桌面规则创建请求</returns>
+    /// <remarks>
+    /// 此模板创建的规则特点：
+    /// - 协议：TCP
+    /// - 端口：3389（RDP标准端口）
+    /// - 方向：入站
+    /// - 动作：允许
+    /// - 配置文件：Domain和Private（出于安全考虑，不包括Public）
+    /// - 状态：启用
+    /// 
+    /// 安全注意事项：
+    /// 1. 远程桌面规则不应在公共网络配置文件中启用
+    /// 2. 建议配合强密码和网络级身份验证使用
+    /// 3. 在生产环境中考虑更改默认端口号
+    /// 4. 建议限制允许连接的IP地址范围
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// var rdpRule = FirewallRuleTemplates.CreateRemoteDesktopRule("Allow-RDP");
+    /// await firewallService.CreateRuleAsync(rdpRule);
+    /// </code>
+    /// </example>
+    public static CreateRuleRequest CreateRemoteDesktopRule(string name)
+    {
+        return new CreateRuleRequest
+        {
+            Name = name,
+            Description = "Allow Remote Desktop Protocol",
+            Protocol = ProtocolType.TCP, // RDP使用TCP协议
+            LocalPorts = "3389", // RDP默认端口
+            Direction = RuleDirection.Inbound, // 允许外部RDP连接
+            Action = RuleAction.Allow, // 允许连接
+            Profiles = FirewallProfile.Domain | FirewallProfile.Private, // 仅在受信任网络中启用
+            Enabled = true // 立即启用
+        };
+    }
+
+    /// <summary>
+    /// 创建SQL Server数据库服务防火墙规则模板
+    /// </summary>
+    /// <param name="name">规则名称，建议包含实例名称如"SQLServer-Production"</param>
+    /// <param name="port">SQL Server端口号，默认为1433（默认实例）</param>
+    /// <returns>配置完成的SQL Server规则创建请求</returns>
+    /// <remarks>
+    /// 此模板创建的规则特点：
+    /// - 协议：TCP
+    /// - 端口：可配置（默认1433）
+    /// - 方向：入站
+    /// - 动作：允许
+    /// - 配置文件：仅Domain（企业环境）
+    /// - 状态：启用
+    /// 
+    /// SQL Server端口说明：
+    /// - 默认实例：1433
+    /// - 命名实例：动态端口或自定义固定端口
+    /// - SQL Browser服务：1434（UDP）
+    /// 
+    /// 安全建议：
+    /// 1. 仅在域环境中启用，避免在公共网络暴露数据库
+    /// 2. 使用强密码和SQL Server身份验证
+    /// 3. 考虑使用VPN或专用网络连接
+    /// 4. 定期更新和打补丁
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// // 默认实例
+    /// var sqlRule = FirewallRuleTemplates.CreateSQLServerRule("SQLServer-Default");
+    /// 
+    /// // 命名实例使用自定义端口
+    /// var sqlNamedRule = FirewallRuleTemplates.CreateSQLServerRule("SQLServer-Instance1", 1435);
+    /// 
+    /// await firewallService.CreateRuleAsync(sqlRule);
+    /// await firewallService.CreateRuleAsync(sqlNamedRule);
+    /// </code>
+    /// </example>
+    public static CreateRuleRequest CreateSQLServerRule(string name, int port = 1433)
+    {
+        return new CreateRuleRequest
+        {
+            Name = name,
+            Description = $"Allow SQL Server traffic on port {port}",
+            Protocol = ProtocolType.TCP, // SQL Server使用TCP协议
+            LocalPorts = port.ToString(), // SQL Server监听端口
+            Direction = RuleDirection.Inbound, // 允许客户端连接到数据库
+            Action = RuleAction.Allow, // 允许连接
+            Profiles = FirewallProfile.Domain, // 仅在域环境中启用（安全考虑）
+            Enabled = true // 立即启用
+        };
+    }
+
+    /// <summary>
+    /// 创建ICMP Ping防火墙规则模板
+    /// </summary>
+    /// <param name="name">规则名称，建议使用"ICMP-Echo"或"Allow-Ping"</param>
+    /// <param name="allowPing">是否允许Ping，true为允许，false为阻止</param>
+    /// <returns>配置完成的ICMP规则创建请求</returns>
+    /// <remarks>
+    /// 此模板创建的规则特点：
+    /// - 协议：ICMPv4
+    /// - ICMP类型：8（Echo Request）
+    /// - 方向：入站
+    /// - 动作：根据allowPing参数决定（允许/阻止）
+    /// - 配置文件：所有
+    /// - 状态：启用
+    /// 
+    /// ICMP类型说明：
+    /// - Type 8: Echo Request (ping请求)
+    /// - Type 0: Echo Reply (ping回复)
+    /// - "*": 表示所有代码
+    /// 
+    /// 使用场景：
+    /// 1. 网络诊断和故障排除
+    /// 2. 监控系统的连通性检查
+    /// 3. 网络拓扑发现
+    /// 
+    /// 安全考虑：
+    /// - 在生产环境中可能需要禁用ping以避免网络扫描
+    /// - 某些安全策略要求阻止ICMP流量
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// // 允许ping
+    /// var allowPingRule = FirewallRuleTemplates.CreatePingRule("Allow-ICMP-Ping", true);
+    /// 
+    /// // 阻止ping
+    /// var blockPingRule = FirewallRuleTemplates.CreatePingRule("Block-ICMP-Ping", false);
+    /// 
+    /// await firewallService.CreateRuleAsync(allowPingRule);
+    /// </code>
+    /// </example>
+    public static CreateRuleRequest CreatePingRule(string name, bool allowPing = true)
+    {
+        return new CreateRuleRequest
+        {
+            Name = name,
+            Description = allowPing ? "Allow ICMP Echo Request" : "Block ICMP Echo Request",
+            Protocol = ProtocolType.ICMPV4, // IPv4的ICMP协议
+            IcmpTypesAndCodes = "8:*", // Type 8: Echo Request, Code: Any
+            Direction = RuleDirection.Inbound, // 处理入站ping请求
+            Action = allowPing ? RuleAction.Allow : RuleAction.Block, // 根据参数决定动作
+            Profiles = FirewallProfile.All, // 在所有网络配置文件中生效
+            Enabled = true // 立即启用规则
+        };
+    }
+}

src/NetVizor.Backend/Utils.Firewall/FirewallService.cs

@@ -0,0 +1,194 @@
+namespace Utils.Firewall;
+
+/// <summary>
+/// 防火墙服务实现
+/// </summary>
+
+/// <summary>
+/// 防火墙服务的具体实现类
+/// 提供对Windows防火墙的完整管理功能，实现了 <see cref="IFirewallService"/> 接口
+/// </summary>
+/// <remarks>
+/// 这个类是防火墙服务的主要实现，它：
+/// 1. 将同步的防火墙API调用包装为异步方法
+/// 2. 提供线程安全的防火墙操作
+/// 3. 处理底层API的异常并转换为友好的返回值
+/// 4. 支持依赖注入，便于测试和替换实现
+/// </remarks>
+public class FirewallService : IFirewallService
+{
+    /// <summary>
+    /// 底层防火墙API接口实例
+    /// </summary>
+    /// <remarks>
+    /// 通过接口依赖，可以方便地切换不同的防火墙实现
+    /// 目前默认使用Windows防火墙API
+    /// </remarks>
+    private readonly IFirewallApi _api;
+
+    /// <summary>
+    /// 初始化防火墙服务实例
+    /// </summary>
+    /// <remarks>
+    /// 构造函数中创建Windows防火墙API实例
+    /// 在实际项目中，建议通过依赖注入容器来管理API实例
+    /// </remarks>
+    public FirewallService()
+    {
+        // 创建Windows防火墙API实例
+        // TODO: 考虑通过构造函数参数注入，以提高可测试性
+        _api = new WindowsFirewallApi();
+    }
+
+    /// <summary>
+    /// 异步获取防火墙状态信息
+    /// </summary>
+    /// <returns>防火墙状态对象，包含各配置文件的启用状态</returns>
+    /// <remarks>
+    /// 使用Task.Run将同步调用转换为异步调用，避免阻塞UI线程
+    /// 在高并发场景下，建议使用更高级的异步模式
+    /// </remarks>
+    public Task<FirewallStatus> GetStatusAsync()
+    {
+        return Task.Run(() => _api.GetFirewallStatus());
+    }
+
+    /// <summary>
+    /// 异步获取防火墙规则列表
+    /// </summary>
+    /// <param name="filter">规则过滤器，为null时返回所有规则</param>
+    /// <returns>符合条件的防火墙规则列表</returns>
+    /// <remarks>
+    /// 根据是否提供过滤器来决定调用不同的API方法
+    /// 获取所有规则可能耗时较长，建议在必要时使用过滤器
+    /// </remarks>
+    public Task<List<FirewallRule>> GetRulesAsync(RuleFilter? filter = null)
+    {
+        return Task.Run(() => filter == null ? _api.GetAllRules() : _api.GetRulesByFilter(filter));
+    }
+
+    /// <summary>
+    /// 异步根据名称获取特定防火墙规则
+    /// </summary>
+    /// <param name="ruleName">要查找的规则名称</param>
+    /// <returns>匹配的规则对象，未找到时返回null</returns>
+    /// <remarks>
+    /// 规则名称查找是精确匹配且区分大小写
+    /// 建议在调用前验证规则名称的有效性
+    /// </remarks>
+    public Task<FirewallRule?> GetRuleAsync(string ruleName)
+    {
+        return Task.Run(() => _api.GetRuleByName(ruleName));
+    }
+
+    /// <summary>
+    /// 异步创建新的防火墙规则
+    /// </summary>
+    /// <param name="request">规则创建请求，包含所有必要的规则信息</param>
+    /// <returns>创建成功返回true，失败返回false</returns>
+    /// <remarks>
+    /// 创建规则是一个原子操作，要么完全成功，要么完全失败
+    /// 如果规则名称冲突，底层API会抛出异常
+    /// </remarks>
+    public Task<bool> CreateRuleAsync(CreateRuleRequest request)
+    {
+        return Task.Run(() => _api.CreateRule(request));
+    }
+
+    /// <summary>
+    /// 异步更新现有防火墙规则
+    /// </summary>
+    /// <param name="request">规则更新请求，必须包含要更新的规则名称</param>
+    /// <returns>更新成功返回true，失败返回false</returns>
+    /// <remarks>
+    /// 更新操作会完全替换现有规则的所有属性
+    /// 建议在更新前先获取现有规则信息作为备份
+    /// </remarks>
+    public Task<bool> UpdateRuleAsync(UpdateRuleRequest request)
+    {
+        return Task.Run(() => _api.UpdateRule(request));
+    }
+
+    /// <summary>
+    /// 异步删除指定名称的防火墙规则
+    /// </summary>
+    /// <param name="ruleName">要删除的规则名称</param>
+    /// <returns>删除成功返回true，失败返回false</returns>
+    /// <remarks>
+    /// 删除操作是不可逆的，请谨慎操作
+    /// 如果规则不存在，某些实现可能返回true（认为目标已达成）
+    /// </remarks>
+    public Task<bool> DeleteRuleAsync(string ruleName)
+    {
+        return Task.Run(() => _api.DeleteRule(ruleName));
+    }
+
+    /// <summary>
+    /// 异步启用指定配置文件的防火墙
+    /// </summary>
+    /// <param name="profile">要启用的防火墙配置文件</param>
+    /// <returns>启用成功返回true，失败返回false</returns>
+    /// <remarks>
+    /// 启用防火墙会立即生效，影响所有网络连接
+    /// 在某些环境中可能需要管理员权限
+    /// </remarks>
+    public Task<bool> EnableFirewallAsync(FirewallProfile profile = FirewallProfile.All)
+    {
+        return Task.Run(() => _api.EnableFirewall(profile));
+    }
+
+    /// <summary>
+    /// 异步禁用指定配置文件的防火墙
+    /// </summary>
+    /// <param name="profile">要禁用的防火墙配置文件</param>
+    /// <returns>禁用成功返回true，失败返回false</returns>
+    /// <remarks>
+    /// 禁用防火墙会立即生效，可能降低系统安全性
+    /// 建议只在必要的故障排除场景中使用
+    /// </remarks>
+    public Task<bool> DisableFirewallAsync(FirewallProfile profile = FirewallProfile.All)
+    {
+        return Task.Run(() => _api.DisableFirewall(profile));
+    }
+
+    /// <summary>
+    /// 异步获取防火墙运行统计信息
+    /// </summary>
+    /// <returns>包含各种统计数据的对象</returns>
+    /// <remarks>
+    /// 统计信息的准确性取决于底层防火墙的实现
+    /// 某些统计数据可能只在防火墙启用时才会更新
+    /// </remarks>
+    public Task<FirewallStatistics> GetStatisticsAsync()
+    {
+        return Task.Run(() => _api.GetStatistics());
+    }
+
+    /// <summary>
+    /// 异步阻止指定应用程序的所有网络访问
+    /// </summary>
+    /// <param name="applicationPath">应用程序的完整文件路径</param>
+    /// <returns>阻止成功返回true，失败返回false</returns>
+    /// <remarks>
+    /// 此方法会创建一个出站阻止规则来禁止应用程序联网
+    /// 应用程序路径必须是有效的可执行文件路径
+    /// </remarks>
+    public Task<bool> BlockApplicationAsync(string applicationPath)
+    {
+        return Task.Run(() => _api.BlockApplication(applicationPath));
+    }
+
+    /// <summary>
+    /// 异步解除对指定应用程序的网络访问阻止
+    /// </summary>
+    /// <param name="applicationPath">应用程序的完整文件路径</param>
+    /// <returns>解除阻止成功返回true，失败返回false</returns>
+    /// <remarks>
+    /// 此方法会删除之前为该应用程序创建的阻止规则
+    /// 如果应用程序没有相关的阻止规则，操作通常会成功返回
+    /// </remarks>
+    public Task<bool> UnblockApplicationAsync(string applicationPath)
+    {
+        return Task.Run(() => _api.UnblockApplication(applicationPath));
+    }
+}

src/NetVizor.Backend/Utils.Firewall/IFirewallApi.cs

@@ -0,0 +1,544 @@
+namespace Utils.Firewall;
+
+/// <summary>
+/// Windows防火墙管理API接口
+/// 定义了完整的Windows防火墙管理功能，包括状态管理、规则操作、配置文件管理、日志监控等
+/// 实现此接口的类应提供对Windows防火墙的全面控制能力
+/// </summary>
+public interface IFirewallApi
+{
+    #region 防火墙状态管理
+
+    /// <summary>
+    /// 获取防火墙的完整状态信息
+    /// 包括所有配置文件的状态、规则统计、启用状态等详细信息
+    /// </summary>
+    /// <returns>
+    /// 包含防火墙完整状态的FirewallStatus对象，包括：
+    /// - 整体启用状态
+    /// - 各配置文件的详细状态
+    /// - 规则数量统计（总数、已启用、入站、出站）
+    /// </returns>
+    FirewallStatus GetFirewallStatus();
+
+    /// <summary>
+    /// 启用指定配置文件的防火墙
+    /// 此操作通常需要管理员权限
+    /// </summary>
+    /// <param name="profile">
+    /// 要启用的防火墙配置文件，可以是：
+    /// - FirewallProfile.Domain（域网络）
+    /// - FirewallProfile.Private（私有网络）
+    /// - FirewallProfile.Public（公共网络）
+    /// - FirewallProfile.All（所有配置文件，默认值）
+    /// </param>
+    /// <returns>操作成功返回true，失败返回false（可能由于权限不足或系统错误）</returns>
+    bool EnableFirewall(FirewallProfile profile = FirewallProfile.All);
+
+    /// <summary>
+    /// 禁用指定配置文件的防火墙
+    /// 此操作通常需要管理员权限，禁用防火墙会降低系统安全性
+    /// </summary>
+    /// <param name="profile">
+    /// 要禁用的防火墙配置文件，可以是：
+    /// - FirewallProfile.Domain（域网络）
+    /// - FirewallProfile.Private（私有网络）
+    /// - FirewallProfile.Public（公共网络）
+    /// - FirewallProfile.All（所有配置文件，默认值）
+    /// </param>
+    /// <returns>操作成功返回true，失败返回false（可能由于权限不足或系统错误）</returns>
+    bool DisableFirewall(FirewallProfile profile = FirewallProfile.All);
+
+    /// <summary>
+    /// 获取指定配置文件的详细状态信息
+    /// 包括启用状态、默认动作、通知设置等配置细节
+    /// </summary>
+    /// <param name="profile">
+    /// 要查询的配置文件：
+    /// - FirewallProfile.Domain（域网络配置文件）
+    /// - FirewallProfile.Private（私有网络配置文件）
+    /// - FirewallProfile.Public（公共网络配置文件）
+    /// </param>
+    /// <returns>
+    /// 包含配置文件详细状态的ProfileStatus对象，包括：
+    /// - 启用状态
+    /// - 是否阻止所有入站流量
+    /// - 通知设置
+    /// - 单播响应设置
+    /// - 默认入站和出站动作
+    /// </returns>
+    ProfileStatus GetProfileStatus(FirewallProfile profile);
+
+    /// <summary>
+    /// 设置指定配置文件的状态和配置
+    /// 允许批量修改配置文件的各项设置
+    /// </summary>
+    /// <param name="profile">要修改的配置文件</param>
+    /// <param name="status">
+    /// 包含要设置的状态信息的ProfileStatus对象，可设置：
+    /// - 是否启用防火墙
+    /// - 是否阻止所有入站流量
+    /// - 通知开关
+    /// - 单播响应设置
+    /// - 默认入站和出站动作
+    /// </param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    bool SetProfileStatus(FirewallProfile profile, ProfileStatus status);
+
+    #endregion
+
+    #region 规则查询
+
+    /// <summary>
+    /// 获取系统中的所有防火墙规则
+    /// 包括系统预定义规则和用户自定义规则
+    /// </summary>
+    /// <returns>
+    /// 包含所有防火墙规则的列表，每个规则包含完整的配置信息
+    /// 如果无法访问防火墙（如权限不足），可能返回空列表
+    /// </returns>
+    List<FirewallRule> GetAllRules();
+
+    /// <summary>
+    /// 根据指定的过滤条件获取防火墙规则
+    /// 支持多种条件的组合过滤，提供灵活的规则查询能力
+    /// </summary>
+    /// <param name="filter">
+    /// 过滤条件对象，可包含以下条件：
+    /// - NamePattern: 规则名称模式匹配
+    /// - Direction: 流量方向（入站/出站）
+    /// - Enabled: 启用状态
+    /// - Profile: 适用的配置文件
+    /// - Protocol: 协议类型
+    /// - Action: 规则动作（允许/阻止）
+    /// - ApplicationName: 应用程序名称
+    /// - Grouping: 规则组名
+    /// - Port: 端口号
+    /// </param>
+    /// <returns>符合过滤条件的防火墙规则列表</returns>
+    List<FirewallRule> GetRulesByFilter(RuleFilter filter);
+
+    /// <summary>
+    /// 根据规则名称获取特定的防火墙规则
+    /// 规则名称在系统中应该是唯一的
+    /// </summary>
+    /// <param name="ruleName">要查找的规则名称，区分大小写</param>
+    /// <returns>
+    /// 找到的防火墙规则对象，如果规则不存在则返回null
+    /// </returns>
+    FirewallRule? GetRuleByName(string ruleName);
+
+    /// <summary>
+    /// 获取指定应用程序的所有相关防火墙规则
+    /// 用于查看某个应用程序的网络访问权限设置
+    /// </summary>
+    /// <param name="applicationPath">
+    /// 应用程序的完整路径，例如：
+    /// "C:\Program Files\MyApp\MyApp.exe"
+    /// 路径应使用反斜杠分隔符，区分大小写
+    /// </param>
+    /// <returns>与指定应用程序相关的所有防火墙规则列表</returns>
+    List<FirewallRule> GetRulesByApplication(string applicationPath);
+
+    /// <summary>
+    /// 获取指定端口和协议的所有相关防火墙规则
+    /// 用于查看某个端口的访问控制设置
+    /// </summary>
+    /// <param name="port">端口号，范围1-65535</param>
+    /// <param name="protocol">
+    /// 协议类型，可选值：
+    /// - ProtocolType.TCP
+    /// - ProtocolType.UDP
+    /// - ProtocolType.Any（默认值，匹配所有协议）
+    /// </param>
+    /// <returns>与指定端口和协议相关的所有防火墙规则列表</returns>
+    List<FirewallRule> GetRulesByPort(int port, ProtocolType protocol = ProtocolType.Any);
+
+    /// <summary>
+    /// 获取指定规则组的所有防火墙规则
+    /// 规则组用于将相关规则进行逻辑分组管理
+    /// </summary>
+    /// <param name="groupName">
+    /// 规则组名称，例如：
+    /// - "Core Networking"（核心网络）
+    /// - "Remote Desktop"（远程桌面）
+    /// - 自定义组名
+    /// </param>
+    /// <returns>属于指定组的所有防火墙规则列表</returns>
+    List<FirewallRule> GetRulesByGroup(string groupName);
+
+    #endregion
+
+    #region 规则管理
+
+    /// <summary>
+    /// 创建新的防火墙规则
+    /// 此操作通常需要管理员权限
+    /// </summary>
+    /// <param name="request">
+    /// 创建规则的请求对象，必须包含以下信息：
+    /// - Name: 规则名称（必须唯一）
+    /// - Direction: 流量方向（入站/出站）
+    /// - Action: 规则动作（允许/阻止）
+    /// - 其他可选配置如端口、地址、应用程序等
+    /// </param>
+    /// <returns>
+    /// 创建成功返回true，失败返回false
+    /// 失败原因可能包括：权限不足、规则名称重复、配置无效等
+    /// </returns>
+    bool CreateRule(CreateRuleRequest request);
+
+    /// <summary>
+    /// 更新现有的防火墙规则
+    /// 可以修改规则的各项配置，但规则必须已存在
+    /// </summary>
+    /// <param name="request">
+    /// 更新规则的请求对象，必须包含：
+    /// - CurrentName: 当前规则名称（用于定位规则）
+    /// - 要修改的属性（只有非null的属性会被更新）
+    /// </param>
+    /// <returns>
+    /// 更新成功返回true，失败返回false
+    /// 失败原因可能包括：规则不存在、权限不足、配置无效等
+    /// </returns>
+    bool UpdateRule(UpdateRuleRequest request);
+
+    /// <summary>
+    /// 删除指定名称的防火墙规则
+    /// 此操作不可逆，删除后规则无法恢复
+    /// </summary>
+    /// <param name="ruleName">要删除的规则名称，必须完全匹配</param>
+    /// <returns>
+    /// 删除成功返回true，失败返回false
+    /// 如果规则不存在，通常也返回true（幂等操作）
+    /// </returns>
+    bool DeleteRule(string ruleName);
+
+    /// <summary>
+    /// 删除指定组的所有防火墙规则
+    /// 批量删除操作，会删除组内的所有规则
+    /// </summary>
+    /// <param name="groupName">要删除的规则组名称</param>
+    /// <returns>
+    /// 所有规则都删除成功返回true
+    /// 如果部分规则删除失败，返回false
+    /// </returns>
+    bool DeleteRulesByGroup(string groupName);
+
+    /// <summary>
+    /// 启用指定名称的防火墙规则
+    /// 启用后规则将开始生效
+    /// </summary>
+    /// <param name="ruleName">要启用的规则名称</param>
+    /// <returns>
+    /// 启用成功返回true，失败返回false
+    /// 如果规则已经启用，通常返回true
+    /// </returns>
+    bool EnableRule(string ruleName);
+
+    /// <summary>
+    /// 禁用指定名称的防火墙规则
+    /// 禁用后规则将不再生效，但仍保留在系统中
+    /// </summary>
+    /// <param name="ruleName">要禁用的规则名称</param>
+    /// <returns>
+    /// 禁用成功返回true，失败返回false
+    /// 如果规则已经禁用，通常返回true
+    /// </returns>
+    bool DisableRule(string ruleName);
+
+    /// <summary>
+    /// 切换指定规则的启用状态
+    /// 如果规则当前启用则禁用，如果禁用则启用
+    /// </summary>
+    /// <param name="ruleName">要切换状态的规则名称</param>
+    /// <returns>
+    /// 切换成功返回true，失败返回false
+    /// 如果规则不存在，返回false
+    /// </returns>
+    bool ToggleRule(string ruleName);
+
+    #endregion
+
+    #region 批量操作
+
+    /// <summary>
+    /// 批量创建多个防火墙规则
+    /// 提供事务性的批量创建能力，提高操作效率
+    /// </summary>
+    /// <param name="requests">
+    /// 创建规则请求列表，每个请求都应包含完整的规则配置
+    /// 规则名称在列表中应该唯一
+    /// </param>
+    /// <returns>
+    /// 所有规则都创建成功返回true
+    /// 如果任何一个规则创建失败，返回false
+    /// 注意：部分实现可能采用"尽力而为"策略，即使部分失败也继续处理其他规则
+    /// </returns>
+    bool CreateRules(List<CreateRuleRequest> requests);
+
+    /// <summary>
+    /// 批量删除多个防火墙规则
+    /// 根据规则名称列表进行批量删除操作
+    /// </summary>
+    /// <param name="ruleNames">要删除的规则名称列表</param>
+    /// <returns>
+    /// 所有规则都删除成功返回true
+    /// 如果任何一个规则删除失败，返回false
+    /// 对于不存在的规则，通常视为删除成功
+    /// </returns>
+    bool DeleteRules(List<string> ruleNames);
+
+    /// <summary>
+    /// 批量启用多个防火墙规则
+    /// 根据规则名称列表进行批量启用操作
+    /// </summary>
+    /// <param name="ruleNames">要启用的规则名称列表</param>
+    /// <returns>
+    /// 所有规则都启用成功返回true
+    /// 如果任何一个规则启用失败，返回false
+    /// </returns>
+    bool EnableRules(List<string> ruleNames);
+
+    /// <summary>
+    /// 批量禁用多个防火墙规则
+    /// 根据规则名称列表进行批量禁用操作
+    /// </summary>
+    /// <param name="ruleNames">要禁用的规则名称列表</param>
+    /// <returns>
+    /// 所有规则都禁用成功返回true
+    /// 如果任何一个规则禁用失败，返回false
+    /// </returns>
+    bool DisableRules(List<string> ruleNames);
+
+    #endregion
+
+    #region 高级功能
+
+    /// <summary>
+    /// 将防火墙设置恢复为系统默认值
+    /// 此操作会删除所有自定义规则和设置，恢复到Windows默认状态
+    /// 操作不可逆，请谨慎使用
+    /// </summary>
+    /// <returns>
+    /// 恢复成功返回true，失败返回false
+    /// 此操作通常需要管理员权限
+    /// </returns>
+    bool RestoreDefaultSettings();
+
+    /// <summary>
+    /// 将所有防火墙规则导出到指定文件
+    /// 导出格式通常为JSON，包含规则的完整配置信息
+    /// </summary>
+    /// <param name="filePath">
+    /// 导出文件的完整路径，建议使用.json扩展名
+    /// 如果文件已存在将被覆盖
+    /// </param>
+    /// <returns>
+    /// 导出成功返回true，失败返回false
+    /// 失败原因可能包括：路径无效、权限不足、磁盘空间不足等
+    /// </returns>
+    bool ExportRules(string filePath);
+
+    /// <summary>
+    /// 从指定文件导入防火墙规则
+    /// 导入的规则将添加到现有规则中，不会覆盖现有规则
+    /// </summary>
+    /// <param name="filePath">
+    /// 包含规则配置的文件路径，通常为JSON格式
+    /// 文件格式应与ExportRules导出的格式兼容
+    /// </param>
+    /// <returns>
+    /// 导入成功返回true，失败返回false
+    /// 失败原因可能包括：文件不存在、格式错误、权限不足等
+    /// </returns>
+    bool ImportRules(string filePath);
+
+    /// <summary>
+    /// 获取防火墙规则的详细统计信息
+    /// 提供规则数量分析、分类统计、热门应用和端口等信息
+    /// </summary>
+    /// <returns>
+    /// 包含详细统计信息的FirewallStatistics对象，包括：
+    /// - 总规则数、启用/禁用规则数
+    /// - 按方向、协议、配置文件、动作分类的统计
+    /// - 规则最多的应用程序Top列表
+    /// - 使用最多的端口Top列表
+    /// </returns>
+    FirewallStatistics GetStatistics();
+
+    /// <summary>
+    /// 获取所有有防火墙规则的应用程序列表
+    /// 返回系统中已配置防火墙规则的应用程序路径
+    /// </summary>
+    /// <returns>
+    /// 应用程序完整路径的去重排序列表
+    /// 可用于了解哪些应用程序有网络访问配置
+    /// </returns>
+    List<string> GetApplicationsWithRules();
+
+    /// <summary>
+    /// 获取当前系统的活动网络连接列表
+    /// 显示当前正在进行的网络连接信息
+    /// </summary>
+    /// <returns>
+    /// 活动连接的描述列表，格式可能包含：
+    /// - 协议类型
+    /// - 本地地址和端口
+    /// - 远程地址和端口
+    /// - 连接状态
+    /// - 关联的进程信息
+    /// </returns>
+    List<string> GetActiveConnections();
+
+    /// <summary>
+    /// 阻止指定应用程序的所有网络访问
+    /// 自动创建入站和出站阻止规则，完全阻止应用程序的网络通信
+    /// </summary>
+    /// <param name="applicationPath">
+    /// 要阻止的应用程序完整路径
+    /// 例如："C:\Program Files\MyApp\MyApp.exe"
+    /// </param>
+    /// <returns>
+    /// 阻止成功返回true，失败返回false
+    /// 成功时会创建两个规则：入站阻止和出站阻止
+    /// </returns>
+    bool BlockApplication(string applicationPath);
+
+    /// <summary>
+    /// 解除对指定应用程序的网络访问阻止
+    /// 删除该应用程序的所有阻止规则，恢复其网络访问能力
+    /// </summary>
+    /// <param name="applicationPath">
+    /// 要解除阻止的应用程序完整路径
+    /// 路径必须与BlockApplication时使用的路径完全一致
+    /// </param>
+    /// <returns>
+    /// 解除阻止成功返回true，失败返回false
+    /// 将删除该应用程序的所有阻止类型规则
+    /// </returns>
+    bool UnblockApplication(string applicationPath);
+
+    #endregion
+
+    #region 配置文件管理
+
+    /// <summary>
+    /// 设置指定配置文件的默认入站动作
+    /// 当没有匹配的规则时，系统将使用此默认动作处理入站流量
+    /// </summary>
+    /// <param name="profile">
+    /// 目标配置文件：
+    /// - FirewallProfile.Domain（域网络）
+    /// - FirewallProfile.Private（私有网络）
+    /// - FirewallProfile.Public（公共网络）
+    /// </param>
+    /// <param name="action">
+    /// 默认动作：
+    /// - RuleAction.Allow（允许）- 安全性较低但兼容性好
+    /// - RuleAction.Block（阻止）- 安全性高但可能影响某些功能
+    /// </param>
+    /// <returns>设置成功返回true，失败返回false</returns>
+    bool SetDefaultInboundAction(FirewallProfile profile, RuleAction action);
+
+    /// <summary>
+    /// 设置指定配置文件的默认出站动作
+    /// 当没有匹配的规则时，系统将使用此默认动作处理出站流量
+    /// </summary>
+    /// <param name="profile">
+    /// 目标配置文件：
+    /// - FirewallProfile.Domain（域网络）
+    /// - FirewallProfile.Private（私有网络）
+    /// - FirewallProfile.Public（公共网络）
+    /// </param>
+    /// <param name="action">
+    /// 默认动作：
+    /// - RuleAction.Allow（允许）- 通常为默认设置
+    /// - RuleAction.Block（阻止）- 高安全环境下使用
+    /// </param>
+    /// <returns>设置成功返回true，失败返回false</returns>
+    bool SetDefaultOutboundAction(FirewallProfile profile, RuleAction action);
+
+    /// <summary>
+    /// 设置指定配置文件的通知开关
+    /// 控制当防火墙阻止程序时是否显示通知
+    /// </summary>
+    /// <param name="profile">目标配置文件</param>
+    /// <param name="enable">
+    /// 是否启用通知：
+    /// - true: 显示通知，用户体验好但可能干扰
+    /// - false: 不显示通知，静默处理
+    /// </param>
+    /// <returns>设置成功返回true，失败返回false</returns>
+    bool SetNotifications(FirewallProfile profile, bool enable);
+
+    /// <summary>
+    /// 设置指定配置文件的单播响应设置
+    /// 控制是否允许对多播和广播流量进行单播响应
+    /// 这个设置影响某些网络发现和文件共享功能
+    /// </summary>
+    /// <param name="profile">目标配置文件</param>
+    /// <param name="enable">
+    /// 是否允许单播响应：
+    /// - true: 允许，提高网络兼容性
+    /// - false: 禁用，提高安全性
+    /// </param>
+    /// <returns>设置成功返回true，失败返回false</returns>
+    bool SetUnicastResponses(FirewallProfile profile, bool enable);
+
+    #endregion
+
+    #region 日志和监控
+
+    /// <summary>
+    /// 获取防火墙日志记录
+    /// 从Windows防火墙日志文件中读取日志条目，用于安全分析和故障排除
+    /// </summary>
+    /// <param name="startTime">
+    /// 开始时间（可选），如果指定，只返回此时间之后的日志
+    /// 如果为null，返回所有可用日志
+    /// </param>
+    /// <param name="endTime">
+    /// 结束时间（可选），如果指定，只返回此时间之前的日志
+    /// 如果为null，返回到当前时间的所有日志
+    /// </param>
+    /// <returns>
+    /// 日志条目字符串列表，每个条目包含：
+    /// - 时间戳
+    /// - 动作（允许/阻止/丢弃）
+    /// - 协议
+    /// - 源和目标IP地址
+    /// - 端口信息
+    /// - 规则名称等信息
+    /// </returns>
+    List<string> GetFirewallLogs(DateTime? startTime = null, DateTime? endTime = null);
+
+    /// <summary>
+    /// 启用指定配置文件的防火墙日志记录
+    /// 配置防火墙记录被阻止或允许的连接到指定日志文件
+    /// </summary>
+    /// <param name="profile">要启用日志的配置文件</param>
+    /// <param name="logFilePath">
+    /// 日志文件的完整路径，例如：
+    /// "C:\Windows\System32\LogFiles\Firewall\pfirewall.log"
+    /// 路径目录必须存在且有写入权限
+    /// </param>
+    /// <returns>
+    /// 启用成功返回true，失败返回false
+    /// 失败原因可能包括：路径无效、权限不足等
+    /// </returns>
+    bool EnableLogging(FirewallProfile profile, string logFilePath);
+
+    /// <summary>
+    /// 禁用指定配置文件的防火墙日志记录
+    /// 停止记录防火墙活动到日志文件，可以节省磁盘空间和系统性能
+    /// </summary>
+    /// <param name="profile">要禁用日志的配置文件</param>
+    /// <returns>
+    /// 禁用成功返回true，失败返回false
+    /// 已经禁用的日志记录通常返回true
+    /// </returns>
+    bool DisableLogging(FirewallProfile profile);
+
+    #endregion
+}

src/NetVizor.Backend/Utils.Firewall/IFirewallService.cs

@@ -0,0 +1,155 @@
+namespace Utils.Firewall;
+
+/// <summary>
+/// 防火墙服务接口（用于依赖注入）
+/// </summary>
+
+/// <summary>
+/// 防火墙服务接口，用于依赖注入和测试
+/// 提供统一的防火墙管理功能，包括规则管理、状态控制和统计信息获取
+/// </summary>
+/// <remarks>
+/// 这个接口抽象了底层防火墙API的实现细节，使得可以：
+/// 1. 在不同的防火墙实现之间切换（Windows Defender、第三方防火墙等）
+/// 2. 方便进行单元测试（通过Mock接口）
+/// 3. 支持依赖注入，提高代码的可测试性和可维护性
+/// </remarks>
+public interface IFirewallService
+{
+    /// <summary>
+    /// 异步获取防火墙状态信息
+    /// </summary>
+    /// <returns>包含防火墙各配置文件启用状态的 <see cref="FirewallStatus"/> 对象</returns>
+    /// <remarks>
+    /// 返回的状态包括：
+    /// - Domain Profile（域配置文件）状态
+    /// - Private Profile（专用配置文件）状态  
+    /// - Public Profile（公用配置文件）状态
+    /// </remarks>
+    Task<FirewallStatus> GetStatusAsync();
+
+    /// <summary>
+    /// 异步获取防火墙规则列表
+    /// </summary>
+    /// <param name="filter">可选的规则过滤器，用于筛选特定条件的规则。如果为null，则返回所有规则</param>
+    /// <returns>符合筛选条件的防火墙规则列表</returns>
+    /// <remarks>
+    /// 过滤器可以根据以下条件筛选规则：
+    /// - 规则名称（支持模糊匹配）
+    /// - 协议类型（TCP、UDP、ICMP等）
+    /// - 方向（入站/出站）
+    /// - 动作（允许/阻止）
+    /// - 启用状态
+    /// </remarks>
+    Task<List<FirewallRule>> GetRulesAsync(RuleFilter? filter = null);
+
+    /// <summary>
+    /// 异步根据规则名称获取特定的防火墙规则
+    /// </summary>
+    /// <param name="ruleName">要查找的规则名称，大小写敏感</param>
+    /// <returns>匹配的防火墙规则，如果未找到则返回null</returns>
+    /// <exception cref="ArgumentNullException">当ruleName为null或空字符串时抛出</exception>
+    Task<FirewallRule?> GetRuleAsync(string ruleName);
+
+    /// <summary>
+    /// 异步创建新的防火墙规则
+    /// </summary>
+    /// <param name="request">包含新规则详细信息的创建请求</param>
+    /// <returns>如果规则创建成功返回true，否则返回false</returns>
+    /// <remarks>
+    /// 创建规则时需要注意：
+    /// 1. 规则名称必须唯一，不能与现有规则重复
+    /// 2. 端口范围格式：单个端口"80"，多个端口"80,443"，范围"1024-65535"
+    /// 3. IP地址格式：单个IP"192.168.1.1"，网段"192.168.1.0/24"，多个IP用逗号分隔
+    /// </remarks>
+    /// <exception cref="ArgumentNullException">当request为null时抛出</exception>
+    /// <exception cref="InvalidOperationException">当规则名称已存在时抛出</exception>
+    Task<bool> CreateRuleAsync(CreateRuleRequest request);
+
+    /// <summary>
+    /// 异步更新现有的防火墙规则
+    /// </summary>
+    /// <param name="request">包含更新信息的请求，必须指定要更新的规则名称</param>
+    /// <returns>如果规则更新成功返回true，否则返回false</returns>
+    /// <remarks>
+    /// 更新操作会完全替换现有规则的配置
+    /// 如果只需要启用/禁用规则，建议使用专门的启用/禁用方法
+    /// </remarks>
+    /// <exception cref="ArgumentNullException">当request为null时抛出</exception>
+    /// <exception cref="InvalidOperationException">当指定的规则不存在时抛出</exception>
+    Task<bool> UpdateRuleAsync(UpdateRuleRequest request);
+
+    /// <summary>
+    /// 异步删除指定的防火墙规则
+    /// </summary>
+    /// <param name="ruleName">要删除的规则名称</param>
+    /// <returns>如果规则删除成功返回true，否则返回false</returns>
+    /// <remarks>
+    /// 注意：删除操作是不可逆的，建议在删除前先备份重要规则
+    /// 系统内置的默认规则通常不能被删除
+    /// </remarks>
+    /// <exception cref="ArgumentNullException">当ruleName为null或空字符串时抛出</exception>
+    Task<bool> DeleteRuleAsync(string ruleName);
+
+    /// <summary>
+    /// 异步启用指定配置文件的防火墙
+    /// </summary>
+    /// <param name="profile">要启用的防火墙配置文件，默认为所有配置文件</param>
+    /// <returns>如果启用成功返回true，否则返回false</returns>
+    /// <remarks>
+    /// Windows防火墙包含三个配置文件：
+    /// - Domain: 当计算机连接到域时使用
+    /// - Private: 当计算机连接到私有网络时使用
+    /// - Public: 当计算机连接到公共网络时使用
+    /// </remarks>
+    Task<bool> EnableFirewallAsync(FirewallProfile profile = FirewallProfile.All);
+
+    /// <summary>
+    /// 异步禁用指定配置文件的防火墙
+    /// </summary>
+    /// <param name="profile">要禁用的防火墙配置文件，默认为所有配置文件</param>
+    /// <returns>如果禁用成功返回true，否则返回false</returns>
+    /// <remarks>
+    /// 警告：禁用防火墙会降低系统安全性，请谨慎操作
+    /// 建议只在必要的测试或故障排除场景中临时禁用
+    /// </remarks>
+    Task<bool> DisableFirewallAsync(FirewallProfile profile = FirewallProfile.All);
+
+    /// <summary>
+    /// 异步获取防火墙统计信息
+    /// </summary>
+    /// <returns>包含防火墙运行统计数据的 <see cref="FirewallStatistics"/> 对象</returns>
+    /// <remarks>
+    /// 统计信息包括：
+    /// - 阻止的连接数量
+    /// - 允许的连接数量  
+    /// - 活跃规则数量
+    /// - 最近活动的时间戳
+    /// </remarks>
+    Task<FirewallStatistics> GetStatisticsAsync();
+
+    /// <summary>
+    /// 异步阻止指定应用程序的网络访问
+    /// </summary>
+    /// <param name="applicationPath">应用程序的完整文件路径</param>
+    /// <returns>如果阻止操作成功返回true，否则返回false</returns>
+    /// <remarks>
+    /// 此方法会创建一个阻止规则来禁止指定应用程序的所有网络连接
+    /// 路径必须是可执行文件(.exe)的完整路径
+    /// </remarks>
+    /// <exception cref="ArgumentNullException">当applicationPath为null或空字符串时抛出</exception>
+    /// <exception cref="FileNotFoundException">当指定的应用程序文件不存在时抛出</exception>
+    Task<bool> BlockApplicationAsync(string applicationPath);
+
+    /// <summary>
+    /// 异步解除对指定应用程序的网络访问阻止
+    /// </summary>
+    /// <param name="applicationPath">应用程序的完整文件路径</param>
+    /// <returns>如果解除阻止操作成功返回true，否则返回false</returns>
+    /// <remarks>
+    /// 此方法会删除之前为该应用程序创建的阻止规则
+    /// 如果应用程序没有被阻止，操作仍会返回true
+    /// </remarks>
+    /// <exception cref="ArgumentNullException">当applicationPath为null或空字符串时抛出</exception>
+    Task<bool> UnblockApplicationAsync(string applicationPath);
+}

src/NetVizor.Backend/Utils.Firewall/Utils.Firewall.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <PackageReference Include="FirewallManager" Version="1.0.2" />
+      <PackageReference Include="System.Runtime.InteropServices" Version="4.3.0" />
+    </ItemGroup>
+
+</Project>

src/NetVizor.Backend/Utils.Firewall/WindowsFirewallApi.cs

@@ -0,0 +1,1140 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using NetFwTypeLib;
+
+namespace Utils.Firewall;
+
+/// <summary>
+/// Windows防火墙管理API实现
+/// 提供对Windows防火墙的完整控制，包括状态管理、规则操作、配置文件管理等功能
+/// 使用Windows COM接口NetFwTypeLib与系统防火墙进行交互
+/// </summary>
+public class WindowsFirewallApi : IFirewallApi
+{
+    /// <summary>
+    /// Windows防火墙策略对象，用于访问防火墙的全局设置和状态
+    /// </summary>
+    private readonly INetFwPolicy2? _fwPolicy;
+    
+    /// <summary>
+    /// Windows防火墙规则集合对象，用于管理防火墙规则
+    /// </summary>
+    private readonly INetFwRules? _fwRules;
+
+    /// <summary>
+    /// 初始化WindowsFirewallApi实例
+    /// 通过COM接口连接到Windows防火墙服务
+    /// </summary>
+    public WindowsFirewallApi()
+    {
+        try
+        {
+            // 通过ProgID获取Windows防火墙策略对象的类型
+            Type? netFwPolicy2Type = Type.GetTypeFromProgID("HNetCfg.FwPolicy2");
+            if (netFwPolicy2Type != null)
+            {
+                // 创建防火墙策略对象实例
+                _fwPolicy = (INetFwPolicy2?)Activator.CreateInstance(netFwPolicy2Type);
+                // 获取防火墙规则集合
+                _fwRules = _fwPolicy?.Rules;
+            }
+        }
+        catch (Exception)
+        {
+            // 初始化失败，通常是因为缺少管理员权限
+            // 在这种情况下，_fwPolicy和_fwRules将保持为null
+        }
+    }
+
+    #region 防火墙状态管理
+
+    /// <summary>
+    /// 获取防火墙的完整状态信息
+    /// 包括各配置文件的状态、规则统计等
+    /// </summary>
+    /// <returns>包含防火墙完整状态的FirewallStatus对象</returns>
+    public FirewallStatus GetFirewallStatus()
+    {
+        // 创建状态对象并获取基本启用状态
+        var status = new FirewallStatus
+        {
+            IsEnabled = IsFirewallEnabled(),
+            ProfileStatuses = new Dictionary<FirewallProfile, ProfileStatus>()
+        };
+
+        // 遍历所有防火墙配置文件（域、私有、公共）获取详细状态
+        foreach (FirewallProfile profile in Enum.GetValues(typeof(FirewallProfile)))
+        {
+            if (profile != FirewallProfile.All)
+            {
+                status.ProfileStatuses[profile] = GetProfileStatus(profile);
+            }
+        }
+
+        // 获取规则统计信息
+        var allRules = GetAllRules();
+        status.TotalRules = allRules.Count;                                    // 总规则数
+        status.EnabledRules = allRules.Count(r => r.Enabled);                // 已启用规则数
+        status.InboundRules = allRules.Count(r => r.Direction == RuleDirection.Inbound);   // 入站规则数
+        status.OutboundRules = allRules.Count(r => r.Direction == RuleDirection.Outbound); // 出站规则数
+
+        return status;
+    }
+
+    /// <summary>
+    /// 检查防火墙是否在任何配置文件中启用
+    /// </summary>
+    /// <returns>如果防火墙在至少一个配置文件中启用则返回true</returns>
+    private bool IsFirewallEnabled()
+    {
+        if (_fwPolicy == null) return false;
+
+        // 检查三个配置文件：域、私有网络、公共网络
+        return _fwPolicy.FirewallEnabled[NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_DOMAIN] ||
+               _fwPolicy.FirewallEnabled[NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_PRIVATE] ||
+               _fwPolicy.FirewallEnabled[NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_PUBLIC];
+    }
+
+    /// <summary>
+    /// 启用指定配置文件的防火墙
+    /// </summary>
+    /// <param name="profile">要启用的防火墙配置文件，默认为所有配置文件</param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool EnableFirewall(FirewallProfile profile = FirewallProfile.All)
+    {
+        try
+        {
+            SetFirewallEnabled(profile, true);
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// 禁用指定配置文件的防火墙
+    /// </summary>
+    /// <param name="profile">要禁用的防火墙配置文件，默认为所有配置文件</param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool DisableFirewall(FirewallProfile profile = FirewallProfile.All)
+    {
+        try
+        {
+            SetFirewallEnabled(profile, false);
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// 设置指定配置文件防火墙的启用状态
+    /// 内部方法，用于统一处理启用/禁用逻辑
+    /// </summary>
+    /// <param name="profile">目标配置文件</param>
+    /// <param name="enabled">是否启用</param>
+    private void SetFirewallEnabled(FirewallProfile profile, bool enabled)
+    {
+        if (_fwPolicy == null) return;
+
+        // 根据配置文件标志设置相应的防火墙状态
+        if (profile.HasFlag(FirewallProfile.Domain))
+            _fwPolicy.FirewallEnabled[NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_DOMAIN] = enabled;
+        if (profile.HasFlag(FirewallProfile.Private))
+            _fwPolicy.FirewallEnabled[NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_PRIVATE] = enabled;
+        if (profile.HasFlag(FirewallProfile.Public))
+            _fwPolicy.FirewallEnabled[NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_PUBLIC] = enabled;
+    }
+
+    /// <summary>
+    /// 获取指定配置文件的详细状态信息
+    /// </summary>
+    /// <param name="profile">目标配置文件</param>
+    /// <returns>包含配置文件详细状态的ProfileStatus对象</returns>
+    public ProfileStatus GetProfileStatus(FirewallProfile profile)
+    {
+        if (_fwPolicy == null)
+            return new ProfileStatus { Profile = profile };
+
+        var profileType = ConvertToNetFwProfile(profile);
+        return new ProfileStatus
+        {
+            Profile = profile,
+            IsEnabled = _fwPolicy.FirewallEnabled[profileType],                                    // 是否启用
+            BlockAllInboundTraffic = _fwPolicy.BlockAllInboundTraffic[profileType],              // 是否阻止所有入站流量
+            NotifyOnListen = _fwPolicy.NotificationsDisabled[profileType] == false,              // 是否显示通知
+            UnicastResponsesDisabled = _fwPolicy.UnicastResponsesToMulticastBroadcastDisabled[profileType], // 单播响应设置
+            DefaultInboundAction = (RuleAction)_fwPolicy.DefaultInboundAction[profileType],      // 默认入站动作
+            DefaultOutboundAction = (RuleAction)_fwPolicy.DefaultOutboundAction[profileType]     // 默认出站动作
+        };
+    }
+
+    /// <summary>
+    /// 设置指定配置文件的状态
+    /// </summary>
+    /// <param name="profile">目标配置文件</param>
+    /// <param name="status">要设置的状态信息</param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool SetProfileStatus(FirewallProfile profile, ProfileStatus status)
+    {
+        try
+        {
+            if (_fwPolicy == null) return false;
+
+            var profileType = ConvertToNetFwProfile(profile);
+            
+            // 设置各项配置
+            _fwPolicy.FirewallEnabled[profileType] = status.IsEnabled;
+            _fwPolicy.BlockAllInboundTraffic[profileType] = status.BlockAllInboundTraffic;
+            _fwPolicy.NotificationsDisabled[profileType] = !status.NotifyOnListen;
+            _fwPolicy.UnicastResponsesToMulticastBroadcastDisabled[profileType] = status.UnicastResponsesDisabled;
+            _fwPolicy.DefaultInboundAction[profileType] = (NET_FW_ACTION_)status.DefaultInboundAction;
+            _fwPolicy.DefaultOutboundAction[profileType] = (NET_FW_ACTION_)status.DefaultOutboundAction;
+            
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    #endregion
+
+    #region 规则查询
+
+    /// <summary>
+    /// 获取所有防火墙规则
+    /// </summary>
+    /// <returns>防火墙规则列表</returns>
+    public List<FirewallRule> GetAllRules()
+    {
+        var rules = new List<FirewallRule>();
+        if (_fwRules == null) return rules;
+
+        // 遍历Windows防火墙中的所有规则并转换为自定义格式
+        foreach (INetFwRule rule in _fwRules)
+        {
+            rules.Add(ConvertToFirewallRule(rule));
+        }
+
+        return rules;
+    }
+
+    /// <summary>
+    /// 根据过滤条件获取防火墙规则
+    /// </summary>
+    /// <param name="filter">过滤条件对象</param>
+    /// <returns>符合条件的防火墙规则列表</returns>
+    public List<FirewallRule> GetRulesByFilter(RuleFilter filter)
+    {
+        var allRules = GetAllRules();
+        var query = allRules.AsQueryable();
+
+        // 按规则名称模式过滤
+        if (!string.IsNullOrEmpty(filter.NamePattern))
+            query = query.Where(r => r.Name.Contains(filter.NamePattern, StringComparison.OrdinalIgnoreCase));
+
+        // 按流量方向过滤（入站/出站）
+        if (filter.Direction.HasValue)
+            query = query.Where(r => r.Direction == filter.Direction.Value);
+
+        // 按启用状态过滤
+        if (filter.Enabled.HasValue)
+            query = query.Where(r => r.Enabled == filter.Enabled.Value);
+
+        // 按配置文件过滤
+        if (filter.Profile.HasValue)
+            query = query.Where(r => r.Profiles.HasFlag(filter.Profile.Value));
+
+        // 按协议类型过滤
+        if (filter.Protocol.HasValue)
+            query = query.Where(r => r.Protocol == filter.Protocol.Value);
+
+        // 按动作过滤（允许/阻止）
+        if (filter.Action.HasValue)
+            query = query.Where(r => r.Action == filter.Action.Value);
+
+        // 按应用程序名称过滤
+        if (!string.IsNullOrEmpty(filter.ApplicationName))
+            query = query.Where(r =>
+                !string.IsNullOrEmpty(r.ApplicationName) &&
+                r.ApplicationName.Contains(filter.ApplicationName, StringComparison.OrdinalIgnoreCase));
+
+        // 按规则组过滤
+        if (!string.IsNullOrEmpty(filter.Grouping))
+            query = query.Where(r => r.Grouping == filter.Grouping);
+
+        // 按端口过滤（本地端口或远程端口）
+        if (!string.IsNullOrEmpty(filter.Port))
+            query = query.Where(r =>
+                (!string.IsNullOrEmpty(r.LocalPorts) && r.LocalPorts.Contains(filter.Port)) ||
+                (!string.IsNullOrEmpty(r.RemotePorts) && r.RemotePorts.Contains(filter.Port)));
+
+        return query.ToList();
+    }
+
+    /// <summary>
+    /// 根据规则名称获取特定的防火墙规则
+    /// </summary>
+    /// <param name="ruleName">规则名称</param>
+    /// <returns>找到的规则对象，如果不存在则返回null</returns>
+    public FirewallRule? GetRuleByName(string ruleName)
+    {
+        try
+        {
+            if (_fwRules == null) return null;
+
+            // 使用Windows防火墙API直接通过名称获取规则
+            INetFwRule rule = _fwRules.Item(ruleName);
+            return ConvertToFirewallRule(rule);
+        }
+        catch
+        {
+            // 规则不存在或访问出错
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// 获取指定应用程序的所有防火墙规则
+    /// </summary>
+    /// <param name="applicationPath">应用程序完整路径</param>
+    /// <returns>该应用程序的所有相关规则</returns>
+    public List<FirewallRule> GetRulesByApplication(string applicationPath)
+    {
+        return GetRulesByFilter(new RuleFilter { ApplicationName = applicationPath });
+    }
+
+    /// <summary>
+    /// 获取指定端口和协议的所有防火墙规则
+    /// </summary>
+    /// <param name="port">端口号</param>
+    /// <param name="protocol">协议类型，默认为任意协议</param>
+    /// <returns>该端口的所有相关规则</returns>
+    public List<FirewallRule> GetRulesByPort(int port, ProtocolType protocol = ProtocolType.Any)
+    {
+        var filter = new RuleFilter { Port = port.ToString() };
+        if (protocol != ProtocolType.Any)
+            filter.Protocol = protocol;
+        return GetRulesByFilter(filter);
+    }
+
+    /// <summary>
+    /// 获取指定组的所有防火墙规则
+    /// </summary>
+    /// <param name="groupName">规则组名称</param>
+    /// <returns>该组的所有规则</returns>
+    public List<FirewallRule> GetRulesByGroup(string groupName)
+    {
+        return GetRulesByFilter(new RuleFilter { Grouping = groupName });
+    }
+
+    #endregion
+
+    #region 规则管理
+
+    /// <summary>
+    /// 创建新的防火墙规则
+    /// </summary>
+    /// <param name="request">创建规则的请求对象，包含规则的所有配置信息</param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool CreateRule(CreateRuleRequest request)
+    {
+        try
+        {
+            if (_fwRules == null) return false;
+
+            // 通过ProgID获取防火墙规则对象类型
+            Type? netFwRuleType = Type.GetTypeFromProgID("HNetCfg.FWRule");
+            if (netFwRuleType == null) return false;
+
+            // 创建新的防火墙规则实例
+            INetFwRule? newRule = (INetFwRule?)Activator.CreateInstance(netFwRuleType);
+            if (newRule == null) return false;
+
+            // 设置规则的各项属性
+            newRule.Name = request.Name;                                    // 规则名称
+            newRule.Description = request.Description;                      // 规则描述
+            newRule.ApplicationName = request.ApplicationName;              // 应用程序路径
+            // 注意：INetFwRule 接口可能没有 ServiceName 属性，这里移除了对它的直接赋值
+            newRule.Protocol = (int)request.Protocol;                       // 协议类型
+            newRule.LocalPorts = request.LocalPorts;                        // 本地端口
+            newRule.RemotePorts = request.RemotePorts;                      // 远程端口
+            newRule.LocalAddresses = request.LocalAddresses;                // 本地地址
+            newRule.RemoteAddresses = request.RemoteAddresses;              // 远程地址
+            newRule.IcmpTypesAndCodes = request.IcmpTypesAndCodes;          // ICMP类型和代码
+            newRule.Direction = (NET_FW_RULE_DIRECTION_)request.Direction;  // 流量方向
+            newRule.Enabled = request.Enabled;                             // 是否启用
+            newRule.Profiles = ConvertToNetFwProfiles(request.Profiles);   // 适用的配置文件
+            newRule.Action = (NET_FW_ACTION_)request.Action;                // 规则动作
+            newRule.Grouping = request.Grouping;                           // 规则组
+            newRule.InterfaceTypes = request.InterfaceTypes;               // 接口类型
+
+            // 设置边缘遍历（用于某些特殊网络场景）
+            if (request.EdgeTraversal)
+                newRule.EdgeTraversal = request.EdgeTraversal;
+
+            // 将新规则添加到防火墙
+            _fwRules.Add(newRule);
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// 更新现有的防火墙规则
+    /// </summary>
+    /// <param name="request">更新规则的请求对象</param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool UpdateRule(UpdateRuleRequest request)
+    {
+        try
+        {
+            if (_fwRules == null) return false;
+
+            // 根据当前名称获取规则
+            INetFwRule rule = _fwRules.Item(request.CurrentName);
+
+            // 根据请求对象中的非空值更新规则属性
+            if (!string.IsNullOrEmpty(request.NewName))
+                rule.Name = request.NewName;
+            if (request.Description != null)
+                rule.Description = request.Description;
+            if (request.Enabled.HasValue)
+                rule.Enabled = request.Enabled.Value;
+            if (!string.IsNullOrEmpty(request.ApplicationName))
+                rule.ApplicationName = request.ApplicationName;
+            // 移除了对 ServiceName 的直接赋值
+            if (request.Protocol.HasValue)
+                rule.Protocol = (int)request.Protocol.Value;
+            if (request.LocalPorts != null)
+                rule.LocalPorts = request.LocalPorts;
+            if (request.RemotePorts != null)
+                rule.RemotePorts = request.RemotePorts;
+            if (request.LocalAddresses != null)
+                rule.LocalAddresses = request.LocalAddresses;
+            if (request.RemoteAddresses != null)
+                rule.RemoteAddresses = request.RemoteAddresses;
+            if (request.Profiles.HasValue)
+                rule.Profiles = ConvertToNetFwProfiles(request.Profiles.Value);
+            if (request.Action.HasValue)
+                rule.Action = (NET_FW_ACTION_)request.Action.Value;
+            if (request.Grouping != null)
+                rule.Grouping = request.Grouping;
+            if (request.EdgeTraversal.HasValue)
+                rule.EdgeTraversal = request.EdgeTraversal.Value;
+
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// 删除指定名称的防火墙规则
+    /// </summary>
+    /// <param name="ruleName">要删除的规则名称</param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool DeleteRule(string ruleName)
+    {
+        try
+        {
+            _fwRules?.Remove(ruleName);
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// 删除指定组的所有防火墙规则
+    /// </summary>
+    /// <param name="groupName">规则组名称</param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool DeleteRulesByGroup(string groupName)
+    {
+        try
+        {
+            // 先获取组中的所有规则
+            var rules = GetRulesByGroup(groupName);
+            
+            // 逐一删除组中的每个规则
+            foreach (var rule in rules)
+            {
+                _fwRules?.Remove(rule.Name);
+            }
+
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// 启用指定名称的防火墙规则
+    /// </summary>
+    /// <param name="ruleName">规则名称</param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool EnableRule(string ruleName)
+    {
+        return UpdateRule(new UpdateRuleRequest { CurrentName = ruleName, Enabled = true });
+    }
+
+    /// <summary>
+    /// 禁用指定名称的防火墙规则
+    /// </summary>
+    /// <param name="ruleName">规则名称</param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool DisableRule(string ruleName)
+    {
+        return UpdateRule(new UpdateRuleRequest { CurrentName = ruleName, Enabled = false });
+    }
+
+    /// <summary>
+    /// 切换指定规则的启用状态（启用变禁用，禁用变启用）
+    /// </summary>
+    /// <param name="ruleName">规则名称</param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool ToggleRule(string ruleName)
+    {
+        var rule = GetRuleByName(ruleName);
+        if (rule == null) return false;
+        return UpdateRule(new UpdateRuleRequest { CurrentName = ruleName, Enabled = !rule.Enabled });
+    }
+
+    #endregion
+
+    #region 批量操作
+
+    /// <summary>
+    /// 批量创建多个防火墙规则
+    /// </summary>
+    /// <param name="requests">创建规则请求列表</param>
+    /// <returns>所有规则都创建成功返回true，否则返回false</returns>
+    public bool CreateRules(List<CreateRuleRequest> requests)
+    {
+        bool allSuccess = true;
+        foreach (var request in requests)
+        {
+            if (!CreateRule(request))
+                allSuccess = false;
+        }
+
+        return allSuccess;
+    }
+
+    /// <summary>
+    /// 批量删除多个防火墙规则
+    /// </summary>
+    /// <param name="ruleNames">要删除的规则名称列表</param>
+    /// <returns>所有规则都删除成功返回true，否则返回false</returns>
+    public bool DeleteRules(List<string> ruleNames)
+    {
+        bool allSuccess = true;
+        foreach (var ruleName in ruleNames)
+        {
+            if (!DeleteRule(ruleName))
+                allSuccess = false;
+        }
+
+        return allSuccess;
+    }
+
+    /// <summary>
+    /// 批量启用多个防火墙规则
+    /// </summary>
+    /// <param name="ruleNames">要启用的规则名称列表</param>
+    /// <returns>所有规则都启用成功返回true，否则返回false</returns>
+    public bool EnableRules(List<string> ruleNames)
+    {
+        bool allSuccess = true;
+        foreach (var ruleName in ruleNames)
+        {
+            if (!EnableRule(ruleName))
+                allSuccess = false;
+        }
+
+        return allSuccess;
+    }
+
+    /// <summary>
+    /// 批量禁用多个防火墙规则
+    /// </summary>
+    /// <param name="ruleNames">要禁用的规则名称列表</param>
+    /// <returns>所有规则都禁用成功返回true，否则返回false</returns>
+    public bool DisableRules(List<string> ruleNames)
+    {
+        bool allSuccess = true;
+        foreach (var ruleName in ruleNames)
+        {
+            if (!DisableRule(ruleName))
+                allSuccess = false;
+        }
+
+        return allSuccess;
+    }
+
+    #endregion
+
+    #region 高级功能
+
+    /// <summary>
+    /// 将防火墙设置恢复为默认值
+    /// 这将清除所有自定义规则和设置
+    /// </summary>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool RestoreDefaultSettings()
+    {
+        try
+        {
+            _fwPolicy?.RestoreLocalFirewallDefaults();
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// 将所有防火墙规则导出到JSON文件
+    /// </summary>
+    /// <param name="filePath">导出文件的完整路径</param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool ExportRules(string filePath)
+    {
+        try
+        {
+            var rules = GetAllRules();
+            
+            // 配置JSON序列化选项，包括缩进和枚举转换
+            var json = JsonSerializer.Serialize(rules, new JsonSerializerOptions
+            {
+                WriteIndented = true,
+                Converters = { new JsonStringEnumConverter() }
+            });
+            
+            System.IO.File.WriteAllText(filePath, json);
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// 从JSON文件导入防火墙规则
+    /// </summary>
+    /// <param name="filePath">包含规则的JSON文件路径</param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool ImportRules(string filePath)
+    {
+        try
+        {
+            var json = System.IO.File.ReadAllText(filePath);
+            
+            // 反序列化JSON文件中的规则
+            var rules = JsonSerializer.Deserialize<List<FirewallRule>>(json, new JsonSerializerOptions
+            {
+                Converters = { new JsonStringEnumConverter() }
+            });
+
+            if (rules == null) return false;
+
+            // 为每个导入的规则创建对应的防火墙规则
+            foreach (var rule in rules)
+            {
+                CreateRule(new CreateRuleRequest
+                {
+                    Name = rule.Name,
+                    Description = rule.Description,
+                    ApplicationName = rule.ApplicationName,
+                    ServiceName = rule.ServiceName,
+                    Protocol = rule.Protocol,
+                    LocalPorts = rule.LocalPorts,
+                    RemotePorts = rule.RemotePorts,
+                    LocalAddresses = rule.LocalAddresses,
+                    RemoteAddresses = rule.RemoteAddresses,
+                    IcmpTypesAndCodes = rule.IcmpTypesAndCodes,
+                    Direction = rule.Direction,
+                    Enabled = rule.Enabled,
+                    Profiles = rule.Profiles,
+                    Action = rule.Action,
+                    Grouping = rule.Grouping,
+                    InterfaceTypes = rule.InterfaceTypes,
+                    Interfaces = rule.Interfaces,
+                    EdgeTraversal = rule.EdgeTraversal
+                });
+            }
+
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// 获取防火墙规则的详细统计信息
+    /// 包括规则数量、分类统计、热门应用和端口等
+    /// </summary>
+    /// <returns>包含统计信息的FirewallStatistics对象</returns>
+    public FirewallStatistics GetStatistics()
+    {
+        var rules = GetAllRules();
+        var stats = new FirewallStatistics
+        {
+            TotalRules = rules.Count,                           // 总规则数
+            EnabledRules = rules.Count(r => r.Enabled),        // 已启用规则数
+            DisabledRules = rules.Count(r => !r.Enabled)       // 已禁用规则数
+        };
+
+        // 按流量方向统计规则数量
+        stats.RulesByDirection[RuleDirection.Inbound] = rules.Count(r => r.Direction == RuleDirection.Inbound);
+        stats.RulesByDirection[RuleDirection.Outbound] = rules.Count(r => r.Direction == RuleDirection.Outbound);
+
+        // 按协议类型分组统计
+        var protocolGroups = rules.GroupBy(r => r.Protocol);
+        foreach (var group in protocolGroups)
+        {
+            stats.RulesByProtocol[group.Key] = group.Count();
+        }
+
+        // 按配置文件统计规则数量
+        foreach (FirewallProfile profile in Enum.GetValues(typeof(FirewallProfile)))
+        {
+            if (profile != FirewallProfile.All)
+            {
+                stats.RulesByProfile[profile] = rules.Count(r => r.Profiles.HasFlag(profile));
+            }
+        }
+
+        // 按动作统计规则数量
+        stats.RulesByAction[RuleAction.Allow] = rules.Count(r => r.Action == RuleAction.Allow);
+        stats.RulesByAction[RuleAction.Block] = rules.Count(r => r.Action == RuleAction.Block);
+
+        // 统计规则最多的应用程序（Top 10）
+        stats.TopApplications = rules
+            .Where(r => !string.IsNullOrEmpty(r.ApplicationName))
+            .GroupBy(r => r.ApplicationName)
+            .OrderByDescending(g => g.Count())
+            .Take(10)
+            .Select(g => g.Key)
+            .ToList();
+
+        // 统计使用最多的端口（Top 10）
+        var allPorts = new List<string>();
+        foreach (var rule in rules)
+        {
+            if (!string.IsNullOrEmpty(rule.LocalPorts))
+                allPorts.AddRange(rule.LocalPorts.Split(','));
+            if (!string.IsNullOrEmpty(rule.RemotePorts))
+                allPorts.AddRange(rule.RemotePorts.Split(','));
+        }
+
+        stats.TopPorts = allPorts
+            .Where(p => !string.IsNullOrWhiteSpace(p))
+            .GroupBy(p => p.Trim())
+            .OrderByDescending(g => g.Count())
+            .Take(10)
+            .Select(g => g.Key)
+            .ToList();
+
+        return stats;
+    }
+
+    /// <summary>
+    /// 获取所有有防火墙规则的应用程序列表
+    /// </summary>
+    /// <returns>应用程序路径的去重排序列表</returns>
+    public List<string> GetApplicationsWithRules()
+    {
+        return GetAllRules()
+            .Where(r => !string.IsNullOrEmpty(r.ApplicationName))
+            .Select(r => r.ApplicationName)
+            .Distinct()
+            .OrderBy(a => a)
+            .ToList();
+    }
+
+    /// <summary>
+    /// 获取当前活动的网络连接列表
+    /// 注意：此方法需要使用netstat或WMI来获取实际的连接信息
+    /// 当前为简化实现，返回空列表
+    /// </summary>
+    /// <returns>活动连接列表（当前返回空列表）</returns>
+    public List<string> GetActiveConnections()
+    {
+        // 这个需要使用netstat或WMI来获取活动连接
+        // 简化实现，返回空列表
+        return new List<string>();
+    }
+
+    /// <summary>
+    /// 阻止指定应用程序的所有网络访问
+    /// 创建入站和出站阻止规则
+    /// </summary>
+    /// <param name="applicationPath">应用程序的完整路径</param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool BlockApplication(string applicationPath)
+    {
+        var fileName = System.IO.Path.GetFileName(applicationPath);
+        
+        // 创建入站阻止规则
+        var blockInbound = CreateRule(new CreateRuleRequest
+        {
+            Name = $"Block {fileName} (Inbound)",
+            Description = $"Automatically created rule to block {applicationPath}",
+            ApplicationName = applicationPath,
+            Direction = RuleDirection.Inbound,
+            Action = RuleAction.Block,
+            Profiles = FirewallProfile.All,
+            Enabled = true
+        });
+
+        // 创建出站阻止规则
+        var blockOutbound = CreateRule(new CreateRuleRequest
+        {
+            Name = $"Block {fileName} (Outbound)",
+            Description = $"Automatically created rule to block {applicationPath}",
+            ApplicationName = applicationPath,
+            Direction = RuleDirection.Outbound,
+            Action = RuleAction.Block,
+            Profiles = FirewallProfile.All,
+            Enabled = true
+        });
+
+        return blockInbound && blockOutbound;
+    }
+
+    /// <summary>
+    /// 解除对指定应用程序的网络访问阻止
+    /// 删除该应用程序的所有阻止规则
+    /// </summary>
+    /// <param name="applicationPath">应用程序的完整路径</param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool UnblockApplication(string applicationPath)
+    {
+        // 获取该应用程序的所有规则
+        var rules = GetRulesByApplication(applicationPath);
+        // 筛选出阻止规则
+        var blockedRules = rules.Where(r => r.Action == RuleAction.Block).ToList();
+
+        bool allSuccess = true;
+        foreach (var rule in blockedRules)
+        {
+            if (!DeleteRule(rule.Name))
+                allSuccess = false;
+        }
+
+        return allSuccess;
+    }
+
+    #endregion
+
+    #region 配置文件管理
+
+    /// <summary>
+    /// 设置指定配置文件的默认入站动作
+    /// </summary>
+    /// <param name="profile">目标配置文件</param>
+    /// <param name="action">默认动作（允许或阻止）</param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool SetDefaultInboundAction(FirewallProfile profile, RuleAction action)
+    {
+        try
+        {
+            if (_fwPolicy == null) return false;
+
+            var profileType = ConvertToNetFwProfile(profile);
+            _fwPolicy.DefaultInboundAction[profileType] = (NET_FW_ACTION_)action;
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// 设置指定配置文件的默认出站动作
+    /// </summary>
+    /// <param name="profile">目标配置文件</param>
+    /// <param name="action">默认动作（允许或阻止）</param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool SetDefaultOutboundAction(FirewallProfile profile, RuleAction action)
+    {
+        try
+        {
+            if (_fwPolicy == null) return false;
+
+            var profileType = ConvertToNetFwProfile(profile);
+            _fwPolicy.DefaultOutboundAction[profileType] = (NET_FW_ACTION_)action;
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// 设置指定配置文件的通知开关
+    /// </summary>
+    /// <param name="profile">目标配置文件</param>
+    /// <param name="enable">是否启用通知</param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool SetNotifications(FirewallProfile profile, bool enable)
+    {
+        try
+        {
+            if (_fwPolicy == null) return false;
+
+            var profileType = ConvertToNetFwProfile(profile);
+            // 注意：NotificationsDisabled是反向逻辑
+            _fwPolicy.NotificationsDisabled[profileType] = !enable;
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// 设置指定配置文件的单播响应设置
+    /// 控制是否允许对多播和广播流量的单播响应
+    /// </summary>
+    /// <param name="profile">目标配置文件</param>
+    /// <param name="enable">是否启用单播响应</param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool SetUnicastResponses(FirewallProfile profile, bool enable)
+    {
+        try
+        {
+            if (_fwPolicy == null) return false;
+
+            var profileType = ConvertToNetFwProfile(profile);
+            // 注意：UnicastResponsesToMulticastBroadcastDisabled是反向逻辑
+            _fwPolicy.UnicastResponsesToMulticastBroadcastDisabled[profileType] = !enable;
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    #endregion
+
+    #region 日志和监控
+
+    /// <summary>
+    /// 获取防火墙日志记录
+    /// 从Windows防火墙日志文件中读取日志条目
+    /// </summary>
+    /// <param name="startTime">开始时间（可选）</param>
+    /// <param name="endTime">结束时间（可选）</param>
+    /// <returns>日志条目列表</returns>
+    public List<string> GetFirewallLogs(DateTime? startTime = null, DateTime? endTime = null)
+    {
+        // 这需要读取Windows防火墙日志文件
+        // 通常位于 %windir%\system32\LogFiles\Firewall\pfirewall.log
+        var logs = new List<string>();
+
+        try
+        {
+            // 构造防火墙日志文件路径
+            string logPath = System.IO.Path.Combine(
+                Environment.GetFolderPath(Environment.SpecialFolder.System),
+                @"LogFiles\Firewall\pfirewall.log"
+            );
+
+            if (System.IO.File.Exists(logPath))
+            {
+                var lines = System.IO.File.ReadAllLines(logPath);
+                foreach (var line in lines)
+                {
+                    // 跳过注释行和空行
+                    if (!string.IsNullOrWhiteSpace(line) && !line.StartsWith("#"))
+                    {
+                        // TODO: 这里可以根据startTime和endTime参数进行时间过滤
+                        logs.Add(line);
+                    }
+                }
+            }
+        }
+        catch
+        {
+            // 日志文件可能需要管理员权限才能访问
+        }
+
+        return logs;
+    }
+
+    /// <summary>
+    /// 启用指定配置文件的防火墙日志记录
+    /// </summary>
+    /// <param name="profile">目标配置文件</param>
+    /// <param name="logFilePath">日志文件路径</param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool EnableLogging(FirewallProfile profile, string logFilePath)
+    {
+        try
+        {
+            if (_fwPolicy == null) return false;
+
+            // Windows防火墙日志设置通常需要通过注册表或组策略
+            // 这里提供一个简化的实现
+            // 实际实现需要修改注册表项或使用高级防火墙管理接口
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// 禁用指定配置文件的防火墙日志记录
+    /// </summary>
+    /// <param name="profile">目标配置文件</param>
+    /// <returns>操作成功返回true，失败返回false</returns>
+    public bool DisableLogging(FirewallProfile profile)
+    {
+        try
+        {
+            // 简化实现
+            // 实际实现需要修改相关的注册表设置
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    #endregion
+
+    #region 辅助方法
+
+    /// <summary>
+    /// 将Windows防火墙API的规则对象转换为自定义的FirewallRule对象
+    /// </summary>
+    /// <param name="rule">Windows防火墙API规则对象</param>
+    /// <returns>转换后的FirewallRule对象</returns>
+    private FirewallRule ConvertToFirewallRule(INetFwRule rule)
+    {
+        return new FirewallRule
+        {
+            Name = rule.Name ?? string.Empty,                               // 规则名称
+            Description = rule.Description ?? string.Empty,                // 规则描述
+            ApplicationName = rule.ApplicationName ?? string.Empty,        // 应用程序路径
+            // ServiceName 在某些版本的 INetFwRule 中可能不存在，使用默认值
+            ServiceName = string.Empty,                                     // 服务名称
+            Protocol = (ProtocolType)rule.Protocol,                        // 协议类型
+            LocalPorts = rule.LocalPorts ?? string.Empty,                  // 本地端口
+            RemotePorts = rule.RemotePorts ?? string.Empty,                // 远程端口
+            LocalAddresses = rule.LocalAddresses ?? string.Empty,          // 本地地址
+            RemoteAddresses = rule.RemoteAddresses ?? string.Empty,        // 远程地址
+            IcmpTypesAndCodes = rule.IcmpTypesAndCodes ?? string.Empty,    // ICMP类型和代码
+            Direction = (RuleDirection)rule.Direction,                     // 流量方向
+            Enabled = rule.Enabled,                                        // 是否启用
+            Profiles = ConvertFromNetFwProfiles(rule.Profiles),           // 适用的配置文件
+            EdgeTraversal = rule.EdgeTraversal,                           // 边缘遍历设置
+            Action = (RuleAction)rule.Action,                              // 规则动作
+            Grouping = rule.Grouping ?? string.Empty,                     // 规则组
+            InterfaceTypes = rule.InterfaceTypes ?? string.Empty,         // 接口类型
+            Interfaces = ParseInterfaces(rule.Interfaces)                  // 接口列表
+        };
+    }
+
+    /// <summary>
+    /// 解析接口对象数组为字符串列表
+    /// </summary>
+    /// <param name="interfaces">接口对象（可能是数组）</param>
+    /// <returns>接口名称字符串列表</returns>
+    private List<string> ParseInterfaces(object? interfaces)
+    {
+        var result = new List<string>();
+        if (interfaces is Array array)
+        {
+            foreach (var item in array)
+            {
+                if (item != null)
+                    result.Add(item.ToString() ?? string.Empty);
+            }
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// 将自定义的FirewallProfile枚举转换为Windows防火墙API的配置文件类型
+    /// </summary>
+    /// <param name="profile">自定义配置文件枚举</param>
+    /// <returns>Windows防火墙API配置文件类型</returns>
+    private NET_FW_PROFILE_TYPE2_ ConvertToNetFwProfile(FirewallProfile profile)
+    {
+        return profile switch
+        {
+            FirewallProfile.Domain => NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_DOMAIN,
+            FirewallProfile.Private => NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_PRIVATE,
+            FirewallProfile.Public => NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_PUBLIC,
+            _ => NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_ALL
+        };
+    }
+
+    /// <summary>
+    /// 将自定义的FirewallProfile标志转换为Windows防火墙API的配置文件掩码
+    /// 支持多个配置文件的组合
+    /// </summary>
+    /// <param name="profiles">配置文件标志组合</param>
+    /// <returns>Windows防火墙API配置文件掩码</returns>
+    private int ConvertToNetFwProfiles(FirewallProfile profiles)
+    {
+        int result = 0;
+        if (profiles.HasFlag(FirewallProfile.Domain))
+            result |= (int)NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_DOMAIN;
+        if (profiles.HasFlag(FirewallProfile.Private))
+            result |= (int)NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_PRIVATE;
+        if (profiles.HasFlag(FirewallProfile.Public))
+            result |= (int)NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_PUBLIC;
+        return result;
+    }
+
+    /// <summary>
+    /// 将Windows防火墙API的配置文件掩码转换为自定义的FirewallProfile标志
+    /// </summary>
+    /// <param name="profiles">Windows防火墙API配置文件掩码</param>
+    /// <returns>自定义配置文件标志组合</returns>
+    private FirewallProfile ConvertFromNetFwProfiles(int profiles)
+    {
+        FirewallProfile result = 0;
+        if ((profiles & (int)NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_DOMAIN) != 0)
+            result |= FirewallProfile.Domain;
+        if ((profiles & (int)NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_PRIVATE) != 0)
+            result |= FirewallProfile.Private;
+        if ((profiles & (int)NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_PUBLIC) != 0)
+            result |= FirewallProfile.Public;
+        return result;
+    }
+
+    #endregion
+}