技术老小子
🔥 C#开发实战：手把手教你打造专业级Ping工具
编辑
2025-10-11
C#
00

目录

💡 深度解析：为什么要自己开发Ping工具？
🔍 传统ping命令的局限性
🚀 C#自定义Ping工具的优势
🛠️ 解决方案一：基础Ping功能实现
📋 核心代码实现
🎮 使用示例
⚠️ 重要提醒
🚀 解决方案二：批量并发Ping检测
📊 并发检测实现
🎯 使用示例
📈 解决方案三：实时监控与报警
🔄 持续监控实现
🚨 监控使用示例
💎 解决方案四：高级功能集成
🎨 完整工具类实现
🎯 综合使用示例
🎯 核心要点总结
🔥 三个关键收获
💡 最佳实践建议

用C#开发一个功能完备的Ping工具，不仅能检测基础连通性，还能实现并发检测、持续监控、结果统计等高级功能。掌握这些技能，让你在处理网络问题时游刃有余！

💡 深度解析：为什么要自己开发Ping工具？

🔍 传统ping命令的局限性

  • 功能单一：只能逐个检测，效率低下
  • 信息有限：无法获取详细的网络质量数据
  • 不易集成：难以融入现有的C#应用系统
  • 缺乏定制：无法根据业务需求进行个性化开发

🚀 C#自定义Ping工具的优势

  • 高度可控：完全掌控检测逻辑和结果处理
  • 功能丰富：支持并发、统计、监控等高级特性
  • 易于集成：可无缝融入现有.NET应用
  • 扩展性强：可根据业务需求灵活定制

🛠️ 解决方案一：基础Ping功能实现

📋 核心代码实现

C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.NetworkInformation;
using System.Text;
using System.Threading.Tasks;

namespace AppPing
{
    /// <summary>
    /// 基础Ping工具类
    /// </summary>
    public class BasicPingTool
    {
        private readonly Ping _ping;
        private readonly PingOptions _options;

        public BasicPingTool()
        {
            _ping = new Ping();
            // 设置Ping选项：TTL=64，不允许分片
            _options = new PingOptions(64, true);
        }

        /// <summary>
        /// 执行单次Ping操作
        /// </summary>
        /// <param name="hostNameOrAddress">目标主机名或IP地址</param>
        /// <param name="timeout">超时时间（毫秒）</param>
        /// <returns>Ping结果</returns>
        public async Task<PingResult> PingAsync(string hostNameOrAddress, int timeout = 5000)
        {
            try
            {
                // 准备发送的数据包（32字节，与Windows ping一致）
                byte[] buffer = Encoding.ASCII.GetBytes("Hello World! This is a ping test.");

                // 执行异步Ping操作
                PingReply reply = await _ping.SendPingAsync(hostNameOrAddress, timeout, buffer, _options);

                return new PingResult
                {
                    HostName = hostNameOrAddress,
                    Status = reply.Status,
                    RoundTripTime = reply.RoundtripTime,
                    IsSuccess = reply.Status == IPStatus.Success,
                    ErrorMessage = reply.Status != IPStatus.Success ? reply.Status.ToString() : null
                };
            }
            catch (Exception ex)
            {
                return new PingResult
                {
                    HostName = hostNameOrAddress,
                    Status = IPStatus.Unknown,
                    IsSuccess = false,
                    ErrorMessage = ex.Message
                };
            }
        }

        /// <summary>
        /// 释放资源
        /// </summary>
        public void Dispose()
        {
            _ping?.Dispose();
        }
    }

    /// <summary>
    /// Ping结果数据模型
    /// </summary>
    public class PingResult
    {
        public string HostName { get; set; }
        public IPStatus Status { get; set; }
        public long RoundTripTime { get; set; }
        public bool IsSuccess { get; set; }
        public string ErrorMessage { get; set; }
        public DateTime Timestamp { get; set; } = DateTime.Now;

        public override string ToString()
        {
            if (IsSuccess)
            {
                return $"来自 {HostName} 的回复: 时间={RoundTripTime}ms TTL=64";
            }
            else
            {
                return $"Ping {HostName} 失败: {ErrorMessage}";
            }
        }
    }
}

🎮 使用示例

C#
namespace AppPing
{
    internal class Program
    {
        static async Task Main(string[] args)
        {
            var pingTool = new BasicPingTool();

            // 测试Bing
            var result = await pingTool.PingAsync("www.bing.com");
            Console.WriteLine(result);

            // 测试本地回环
            var localResult = await pingTool.PingAsync("127.0.0.1");
            Console.WriteLine(localResult);

            pingTool.Dispose();

            Console.ReadKey();
        }
    }
}

image.png

⚠️ 重要提醒

  • 异步调用：使用async/await避免阻塞UI线程
  • 资源释放：记得调用Dispose()释放Ping对象
  • 异常处理：网络操作必须做好异常捕获

🚀 解决方案二：批量并发Ping检测

📊 并发检测实现

C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.NetworkInformation;
using System.Text;
using System.Threading.Tasks;

namespace AppPing
{
    /// <summary>
    /// 高级Ping工具类 - 支持并发检测
    /// </summary>
    public class AdvancedPingTool : IDisposable
    {
        private readonly List<Ping> _pingInstances;
        private readonly SemaphoreSlim _semaphore;
        private readonly PingOptions _options;

        public AdvancedPingTool(int maxConcurrency = 10)
        {
            _pingInstances = new List<Ping>();
            _semaphore = new SemaphoreSlim(maxConcurrency, maxConcurrency);
            _options = new PingOptions(64, true);
        }

        /// <summary>
        /// 批量并发Ping检测
        /// </summary>
        /// <param name="hosts">主机列表</param>
        /// <param name="timeout">超时时间</param>
        /// <param name="pingCount">每个主机Ping次数</param>
        /// <returns>检测结果列表</returns>
        public async Task<List<BatchPingResult>> BatchPingAsync(
            IEnumerable<string> hosts,
            int timeout = 5000,
            int pingCount = 4)
        {
            var tasks = hosts.Select(host => PingHostMultipleTimesAsync(host, timeout, pingCount));
            var results = await Task.WhenAll(tasks);
            return results.ToList();
        }

        /// <summary>
        /// 对单个主机执行多次Ping并统计结果
        /// </summary>
        private async Task<BatchPingResult> PingHostMultipleTimesAsync(string host, int timeout, int count)
        {
            await _semaphore.WaitAsync(); // 控制并发数

            try
            {
                var ping = new Ping();
                _pingInstances.Add(ping); // 记录实例用于后续释放

                var results = new List<PingResult>();
                byte[] buffer = new byte[32]; // 32字节数据包

                // 执行多次Ping
                for (int i = 0; i < count; i++)
                {
                    try
                    {
                        var reply = await ping.SendPingAsync(host, timeout, buffer, _options);
                        results.Add(new PingResult
                        {
                            HostName = host,
                            Status = reply.Status,
                            RoundTripTime = reply.RoundtripTime,
                            IsSuccess = reply.Status == IPStatus.Success
                        });
                    }
                    catch (Exception ex)
                    {
                        results.Add(new PingResult
                        {
                            HostName = host,
                            Status = IPStatus.Unknown,
                            IsSuccess = false,
                            ErrorMessage = ex.Message
                        });
                    }

                    // 避免过于频繁的请求
                    if (i < count - 1) await Task.Delay(100);
                }

                return CalculateBatchResult(host, results);
            }
            finally
            {
                _semaphore.Release(); // 释放信号量
            }
        }

        /// <summary>
        /// 计算批量Ping的统计结果
        /// </summary>
        private BatchPingResult CalculateBatchResult(string host, List<PingResult> results)
        {
            var successResults = results.Where(r => r.IsSuccess).ToList();

            return new BatchPingResult
            {
                HostName = host,
                TotalCount = results.Count,
                SuccessCount = successResults.Count,
                FailureCount = results.Count - successResults.Count,
                SuccessRate = (double)successResults.Count / results.Count * 100,
                MinRoundTripTime = successResults.Any() ? successResults.Min(r => r.RoundTripTime) : 0,
                MaxRoundTripTime = successResults.Any() ? successResults.Max(r => r.RoundTripTime) : 0,
                AverageRoundTripTime = successResults.Any() ? successResults.Average(r => r.RoundTripTime) : 0,
                IsReachable = successResults.Any()
            };
        }

        public void Dispose()
        {
            _pingInstances.ForEach(p => p?.Dispose());
            _pingInstances.Clear();
            _semaphore?.Dispose();
        }
    }

    /// <summary>
    /// 批量Ping结果统计
    /// </summary>
    public class BatchPingResult
    {
        public string HostName { get; set; }
        public int TotalCount { get; set; }
        public int SuccessCount { get; set; }
        public int FailureCount { get; set; }
        public double SuccessRate { get; set; }
        public long MinRoundTripTime { get; set; }
        public long MaxRoundTripTime { get; set; }
        public double AverageRoundTripTime { get; set; }
        public bool IsReachable { get; set; }

        public override string ToString()
        {
            return $"{HostName}: {SuccessCount}/{TotalCount} ({SuccessRate:F1}%) " +
                   $"最小/平均/最大 = {MinRoundTripTime}/{AverageRoundTripTime:F0}/{MaxRoundTripTime}ms";
        }
    }
}

🎯 使用示例

C#
namespace AppPing
{
    internal class Program
    {
        static async Task Main(string[] args)
        {
            var pingTool = new AdvancedPingTool(maxConcurrency: 20);

            // 定义要检测的主机列表
            var hosts = new[]
            {
                "www.bing.com",
                "www.google.com",
                "www.github.com",
                "192.168.1.1",
                "8.8.8.8"
            };

            Console.WriteLine("开始批量Ping检测...");
            var stopwatch = System.Diagnostics.Stopwatch.StartNew();

            var results = await pingTool.BatchPingAsync(hosts, timeout: 3000, pingCount: 4);

            stopwatch.Stop();
            Console.WriteLine($"检测完成，耗时：{stopwatch.ElapsedMilliseconds}ms\n");

            // 输出结果
            foreach (var result in results)
            {
                Console.WriteLine(result);
            }

            pingTool.Dispose();

            Console.ReadKey();
        }
    }
}

image.png

📈 解决方案三：实时监控与报警

🔄 持续监控实现

C#
using System;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Concurrent;

/// <summary>
/// Ping监控工具 - 支持实时监控和报警
/// </summary>
public class PingMonitor : IDisposable
{
    private readonly CancellationTokenSource _cancellationTokenSource;
    private readonly ConcurrentDictionary<string, MonitoringHost> _monitoringHosts;
    private readonly Timer _reportTimer;
    private bool _disposed = false;

    public event EventHandler<PingAlertEventArgs> OnAlert;
    public event EventHandler<PingStatusChangedEventArgs> OnStatusChanged;

    public PingMonitor()
    {
        _cancellationTokenSource = new CancellationTokenSource();
        _monitoringHosts = new ConcurrentDictionary<string, MonitoringHost>();
        
        // 每分钟生成一次监控报告
        _reportTimer = new Timer(GenerateReport, null, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1));
    }

    /// <summary>
    /// 添加监控主机
    /// </summary>
    /// <param name="hostName">主机名或IP</param>
    /// <param name="interval">检测间隔（秒）</param>
    /// <param name="alertThreshold">连续失败次数报警阈值</param>
    public void AddHost(string hostName, int interval = 30, int alertThreshold = 3)
    {
        if (_monitoringHosts.ContainsKey(hostName))
        {
            Console.WriteLine($"主机 {hostName} 已在监控列表中");
            return;
        }

        var monitoringHost = new MonitoringHost
        {
            HostName = hostName,
            Interval = TimeSpan.FromSeconds(interval),
            AlertThreshold = alertThreshold,
            Statistics = new PingStatistics()
        };

        _monitoringHosts.TryAdd(hostName, monitoringHost);
        
        // 启动该主机的监控任务
        Task.Run(() => MonitorHostAsync(monitoringHost, _cancellationTokenSource.Token));
        
        Console.WriteLine($"已添加主机 {hostName} 到监控列表，检测间隔: {interval}秒");
    }

    /// <summary>
    /// 监控单个主机
    /// </summary>
    private async Task MonitorHostAsync(MonitoringHost host, CancellationToken cancellationToken)
    {
        using var ping = new Ping();
        var options = new PingOptions(64, true);
        var buffer = new byte[32];

        while (!cancellationToken.IsCancellationRequested)
        {
            try
            {
                var reply = await ping.SendPingAsync(host.HostName, 5000, buffer, options);
                var isSuccess = reply.Status == IPStatus.Success;
                
                // 更新统计信息
                UpdateStatistics(host, isSuccess, reply.RoundtripTime);
                
                // 检查状态变化
                CheckStatusChange(host, isSuccess);
                
                // 检查是否需要报警
                CheckAlert(host, isSuccess);
                
                await Task.Delay(host.Interval, cancellationToken);
            }
            catch (OperationCanceledException)
            {
                break; // 正常取消
            }
            catch (Exception ex)
            {
                Console.WriteLine($"监控 {host.HostName} 时发生异常: {ex.Message}");
                await Task.Delay(host.Interval, cancellationToken);
            }
        }
    }

    /// <summary>
    /// 更新统计信息
    /// </summary>
    private void UpdateStatistics(MonitoringHost host, bool isSuccess, long responseTime)
    {
        var stats = host.Statistics;
        stats.TotalAttempts++;
        
        if (isSuccess)
        {
            stats.SuccessfulAttempts++;
            stats.TotalResponseTime += responseTime;
            stats.LastSuccessTime = DateTime.Now;
            host.ConsecutiveFailures = 0; // 重置连续失败计数
        }
        else
        {
            stats.FailedAttempts++;
            host.ConsecutiveFailures++;
            stats.LastFailureTime = DateTime.Now;
        }
        
        stats.AvailabilityPercentage = (double)stats.SuccessfulAttempts / stats.TotalAttempts * 100;
        if (stats.SuccessfulAttempts > 0)
        {
            stats.AverageResponseTime = (double)stats.TotalResponseTime / stats.SuccessfulAttempts;
        }
    }

    /// <summary>
    /// 检查状态变化
    /// </summary>
    private void CheckStatusChange(MonitoringHost host, bool currentStatus)
    {
        if (host.LastStatus.HasValue && host.LastStatus.Value != currentStatus)
        {
            OnStatusChanged?.Invoke(this, new PingStatusChangedEventArgs
            {
                HostName = host.HostName,
                PreviousStatus = host.LastStatus.Value,
                CurrentStatus = currentStatus,
                Timestamp = DateTime.Now
            });
        }
        
        host.LastStatus = currentStatus;
    }

    /// <summary>
    /// 检查报警条件
    /// </summary>
    private void CheckAlert(MonitoringHost host, bool isSuccess)
    {
        if (!isSuccess && host.ConsecutiveFailures >= host.AlertThreshold)
        {
            // 避免重复报警（每次连续失败只报警一次）
            if (host.ConsecutiveFailures == host.AlertThreshold)
            {
                OnAlert?.Invoke(this, new PingAlertEventArgs
                {
                    HostName = host.HostName,
                    AlertType = AlertType.HostUnreachable,
                    Message = $"主机 {host.HostName} 连续 {host.ConsecutiveFailures} 次Ping失败",
                    Timestamp = DateTime.Now,
                    Statistics = host.Statistics
                });
            }
        }
    }

    /// <summary>
    /// 生成监控报告
    /// </summary>
    private void GenerateReport(object state)
    {
        Console.WriteLine($"\n=== Ping监控报告 ({DateTime.Now:yyyy-MM-dd HH:mm:ss}) ===");
        
        foreach (var kvp in _monitoringHosts)
        {
            var host = kvp.Value;
            var stats = host.Statistics;
            
            Console.WriteLine($"主机: {host.HostName}");
            Console.WriteLine($"  可用性: {stats.AvailabilityPercentage:F2}% ({stats.SuccessfulAttempts}/{stats.TotalAttempts})");
            Console.WriteLine($"  平均响应时间: {stats.AverageResponseTime:F2}ms");
            Console.WriteLine($"  最后成功时间: {stats.LastSuccessTime:HH:mm:ss}");
            Console.WriteLine($"  连续失败次数: {host.ConsecutiveFailures}");
            Console.WriteLine();
        }
    }

    public void Dispose()
    {
        if (_disposed) return;
        
        _cancellationTokenSource?.Cancel();
        _reportTimer?.Dispose();
        _cancellationTokenSource?.Dispose();
        _disposed = true;
        
        Console.WriteLine("Ping监控服务已停止");
    }
}

#region 辅助类和事件参数

/// <summary>
/// 监控主机信息
/// </summary>
public class MonitoringHost
{
    public string HostName { get; set; }
    public TimeSpan Interval { get; set; }
    public int AlertThreshold { get; set; }
    public int ConsecutiveFailures { get; set; }
    public bool? LastStatus { get; set; }
    public PingStatistics Statistics { get; set; }
}

/// <summary>
/// Ping统计信息
/// </summary>
public class PingStatistics
{
    public int TotalAttempts { get; set; }
    public int SuccessfulAttempts { get; set; }
    public int FailedAttempts { get; set; }
    public double AvailabilityPercentage { get; set; }
    public long TotalResponseTime { get; set; }
    public double AverageResponseTime { get; set; }
    public DateTime? LastSuccessTime { get; set; }
    public DateTime? LastFailureTime { get; set; }
}

/// <summary>
/// 报警事件参数
/// </summary>
public class PingAlertEventArgs : EventArgs
{
    public string HostName { get; set; }
    public AlertType AlertType { get; set; }
    public string Message { get; set; }
    public DateTime Timestamp { get; set; }
    public PingStatistics Statistics { get; set; }
}

/// <summary>
/// 状态变化事件参数
/// </summary>
public class PingStatusChangedEventArgs : EventArgs
{
    public string HostName { get; set; }
    public bool PreviousStatus { get; set; }
    public bool CurrentStatus { get; set; }
    public DateTime Timestamp { get; set; }
}

/// <summary>
/// 报警类型
/// </summary>
public enum AlertType
{
    HostUnreachable,
    HighLatency,
    PacketLoss
}

#endregion

🚨 监控使用示例

C#
namespace AppPing
{
    internal class Program
    {
        static void Main(string[] args)
        {
            var monitor = new PingMonitor();

            // 注册事件处理器
            monitor.OnAlert += (sender, e) =>
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine($"    报警: {e.Message}");
                Console.WriteLine($"    时间: {e.Timestamp:yyyy-MM-dd HH:mm:ss}");
                Console.WriteLine($"    可用性: {e.Statistics.AvailabilityPercentage:F2}%");
                Console.ResetColor();
            };

            monitor.OnStatusChanged += (sender, e) =>
            {
                var status = e.CurrentStatus ? "恢复" : "断开";
                Console.WriteLine($"{status} {e.HostName} 状态变化: {e.PreviousStatus} -> {e.CurrentStatus}");
            };

            // 添加监控主机
            monitor.AddHost("www.bing.com", interval: 10, alertThreshold: 2);
            monitor.AddHost("8.8.8.8", interval: 15, alertThreshold: 3);
            monitor.AddHost("192.168.1.1", interval: 30, alertThreshold: 2);


            Console.WriteLine("监控已启动，按任意键停止...");
            Console.ReadKey();

            monitor.Dispose();
        }
    }
}

image.png

💎 解决方案四：高级功能集成

🎨 完整工具类实现

C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.NetworkInformation;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

namespace AppPing
{
    /// <summary>
    /// 专业级Ping工具套件
    /// </summary>
    public class ProfessionalPingToolkit : IDisposable
    {
        private readonly List<Ping> _pingPool;
        private readonly object _lockObject = new object();

        public ProfessionalPingToolkit()
        {
            _pingPool = new List<Ping>();
        }

        /// <summary>
        /// 路由跟踪 - 类似tracert命令
        /// </summary>
        /// <param name="hostName">目标主机</param>
        /// <param name="maxHops">最大跳数</param>
        /// <returns>路由跟踪结果</returns>
        public async Task<List<TraceRouteHop>> TraceRouteAsync(string hostName, int maxHops = 30)
        {
            var results = new List<TraceRouteHop>();

            for (int ttl = 1; ttl <= maxHops; ttl++)
            {
                using var ping = new Ping();
                var options = new PingOptions(ttl, true);
                var buffer = new byte[32];

                try
                {
                    var reply = await ping.SendPingAsync(hostName, 5000, buffer, options);

                    var hop = new TraceRouteHop
                    {
                        HopNumber = ttl,
                        Address = reply.Address?.ToString(),
                        RoundTripTime = reply.RoundtripTime,
                        Status = reply.Status
                    };

                    results.Add(hop);

                    // 如果到达目标或者超过最大跳数，停止跟踪
                    if (reply.Status == IPStatus.Success)
                    {
                        Console.WriteLine($"跟踪完成，到达目标 {hostName}");
                        break;
                    }

                    Console.WriteLine($"第{ttl}跳: {hop}");

                    // 添加小延迟避免过于频繁的请求
                    await Task.Delay(100);
                }
                catch (Exception ex)
                {
                    results.Add(new TraceRouteHop
                    {
                        HopNumber = ttl,
                        Address = "超时",
                        Status = IPStatus.TimedOut,
                        ErrorMessage = ex.Message
                    });
                }
            }

            return results;
        }

        /// <summary>
        /// 网络质量测试 - 丢包率和延迟抖动分析
        /// </summary>
        /// <param name="hostName">目标主机</param>
        /// <param name="testDuration">测试持续时间（分钟）</param>
        /// <param name="intervalSeconds">测试间隔（秒）</param>
        /// <returns>网络质量报告</returns>
        public async Task<NetworkQualityReport> AnalyzeNetworkQualityAsync(
            string hostName,
            int testDuration = 5,
            int intervalSeconds = 1)
        {
            var results = new List<PingResult>();
            var endTime = DateTime.Now.AddMinutes(testDuration);

            Console.WriteLine($"开始网络质量分析: {hostName}，测试时长: {testDuration}分钟");

            using var ping = new Ping();
            var options = new PingOptions(64, true);
            var buffer = new byte[32];

            while (DateTime.Now < endTime)
            {
                try
                {
                    var reply = await ping.SendPingAsync(hostName, 5000, buffer, options);

                    results.Add(new PingResult
                    {
                        HostName = hostName,
                        Status = reply.Status,
                        RoundTripTime = reply.RoundtripTime,
                        IsSuccess = reply.Status == IPStatus.Success,
                        Timestamp = DateTime.Now
                    });

                    await Task.Delay(TimeSpan.FromSeconds(intervalSeconds));
                }
                catch (Exception ex)
                {
                    results.Add(new PingResult
                    {
                        HostName = hostName,
                        Status = IPStatus.Unknown,
                        IsSuccess = false,
                        ErrorMessage = ex.Message,
                        Timestamp = DateTime.Now
                    });
                }
            }

            return GenerateQualityReport(hostName, results);
        }

        /// <summary>
        /// 生成网络质量报告
        /// </summary>
        private NetworkQualityReport GenerateQualityReport(string hostName, List<PingResult> results)
        {
            var successResults = results.Where(r => r.IsSuccess).ToList();
            var responseTime = successResults.Select(r => (double)r.RoundTripTime).ToList();

            var report = new NetworkQualityReport
            {
                HostName = hostName,
                TestStartTime = results.Min(r => r.Timestamp),
                TestEndTime = results.Max(r => r.Timestamp),
                TotalPackets = results.Count,
                SuccessfulPackets = successResults.Count,
                LostPackets = results.Count - successResults.Count,
                PacketLossPercentage = (double)(results.Count - successResults.Count) / results.Count * 100
            };

            if (responseTime.Any())
            {
                report.MinLatency = responseTime.Min();
                report.MaxLatency = responseTime.Max();
                report.AverageLatency = responseTime.Average();

                // 计算延迟抖动（标准差）
                var variance = responseTime.Select(x => Math.Pow(x - report.AverageLatency, 2)).Sum() / responseTime.Count;
                report.LatencyJitter = Math.Sqrt(variance);

                // 计算百分位数
                var sorted = responseTime.OrderBy(x => x).ToList();
                report.Latency95thPercentile = sorted[(int)(sorted.Count * 0.95)];
                report.Latency99thPercentile = sorted[(int)(sorted.Count * 0.99)];
            }

            // 网络质量评级
            report.QualityGrade = EvaluateNetworkQuality(report);

            return report;
        }

        /// <summary>
        /// 评估网络质量等级
        /// </summary>
        private NetworkQualityGrade EvaluateNetworkQuality(NetworkQualityReport report)
        {
            // 综合评估：丢包率 + 平均延迟 + 延迟抖动
            var score = 100;

            // 丢包率扣分
            if (report.PacketLossPercentage > 5) score -= 30;
            else if (report.PacketLossPercentage > 1) score -= 15;
            else if (report.PacketLossPercentage > 0.1) score -= 5;

            // 平均延迟扣分
            if (report.AverageLatency > 200) score -= 25;
            else if (report.AverageLatency > 100) score -= 15;
            else if (report.AverageLatency > 50) score -= 8;

            // 延迟抖动扣分
            if (report.LatencyJitter > 50) score -= 20;
            else if (report.LatencyJitter > 20) score -= 10;
            else if (report.LatencyJitter > 10) score -= 5;

            return score switch
            {
                >= 90 => NetworkQualityGrade.Excellent,
                >= 80 => NetworkQualityGrade.Good,
                >= 70 => NetworkQualityGrade.Fair,
                >= 60 => NetworkQualityGrade.Poor,
                _ => NetworkQualityGrade.Bad
            };
        }

        /// <summary>
        /// 导出结果到JSON文件
        /// </summary>
        /// <param name="data">要导出的数据</param>
        /// <param name="fileName">文件名</param>
        public async Task ExportToJsonAsync<T>(T data, string fileName)
        {
            var options = new JsonSerializerOptions
            {
                WriteIndented = true,
                PropertyNamingPolicy = JsonNamingPolicy.CamelCase
            };

            var json = JsonSerializer.Serialize(data, options);
            await File.WriteAllTextAsync(fileName, json);

            Console.WriteLine($"结果已导出到: {fileName}");
        }

        public void Dispose()
        {
            lock (_lockObject)
            {
                _pingPool.ForEach(p => p?.Dispose());
                _pingPool.Clear();
            }
        }
    }

    #region 数据模型

    /// <summary>
    /// 路由跟踪跳点信息
    /// </summary>
    public class TraceRouteHop
    {
        public int HopNumber { get; set; }
        public string Address { get; set; }
        public long RoundTripTime { get; set; }
        public IPStatus Status { get; set; }
        public string ErrorMessage { get; set; }

        public override string ToString()
        {
            if (Status == IPStatus.Success)
            {
                return $"{Address} ({RoundTripTime}ms)";
            }
            else if (Status == IPStatus.TtlExpired)
            {
                return $"{Address} ({RoundTripTime}ms) [TTL过期]";
            }
            else
            {
                return $"* 请求超时";
            }
        }
    }

    /// <summary>
    /// 网络质量报告
    /// </summary>
    public class NetworkQualityReport
    {
        public string HostName { get; set; }
        public DateTime TestStartTime { get; set; }
        public DateTime TestEndTime { get; set; }
        public int TotalPackets { get; set; }
        public int SuccessfulPackets { get; set; }
        public int LostPackets { get; set; }
        public double PacketLossPercentage { get; set; }
        public double MinLatency { get; set; }
        public double MaxLatency { get; set; }
        public double AverageLatency { get; set; }
        public double LatencyJitter { get; set; }
        public double Latency95thPercentile { get; set; }
        public double Latency99thPercentile { get; set; }
        public NetworkQualityGrade QualityGrade { get; set; }

        public override string ToString()
        {
            return $"""
            网络质量报告 - {HostName}
            测试时间: {TestStartTime:yyyy-MM-dd HH:mm:ss} - {TestEndTime:yyyy-MM-dd HH:mm:ss}
            数据包统计: {SuccessfulPackets}/{TotalPackets} (丢包率: {PacketLossPercentage:F2}%)
            延迟统计: 最小={MinLatency:F1}ms, 平均={AverageLatency:F1}ms, 最大={MaxLatency:F1}ms
            延迟抖动: {LatencyJitter:F1}ms
            95%延迟: {Latency95thPercentile:F1}ms, 99%延迟: {Latency99thPercentile:F1}ms
            网络质量: {QualityGrade} ⭐
            """;
        }
    }

    /// <summary>
    /// 网络质量等级
    /// </summary>
    public enum NetworkQualityGrade
    {
        Excellent = 5,  // 优秀
        Good = 4,       // 良好  
        Fair = 3,       // 一般
        Poor = 2,       // 较差
        Bad = 1         // 很差
    }

    #endregion
}

🎯 综合使用示例

C#
namespace AppPing
{
    internal class Program
    {
        static async Task Main(string[] args)
        {
            var toolkit = new ProfessionalPingToolkit();

            Console.WriteLine("=== 专业级Ping工具套件演示 ===\n");

            var target = "www.bing.com";

            // 1. 路由跟踪
            Console.WriteLine("1. 执行路由跟踪...");
            var traceRoute = await toolkit.TraceRouteAsync(target, maxHops: 15);
            await toolkit.ExportToJsonAsync(traceRoute, $"traceroute_{target}_{DateTime.Now:yyyyMMdd_HHmmss}.json");

            Console.WriteLine("\n" + "=".PadRight(50, '=') + "\n");

            // 2. 网络质量分析
            Console.WriteLine("2. 执行网络质量分析...");
            var qualityReport = await toolkit.AnalyzeNetworkQualityAsync(target, testDuration: 2, intervalSeconds: 1);
            Console.WriteLine(qualityReport);
            await toolkit.ExportToJsonAsync(qualityReport, $"quality_report_{target}_{DateTime.Now:yyyyMMdd_HHmmss}.json");

            toolkit.Dispose();

            Console.WriteLine("\n测试完成，按任意键退出...");
            Console.ReadKey();
        }
    }
}

image.png

🎯 核心要点总结

🔥 三个关键收获

  1. 异步编程是王道：使用async/await让Ping操作不阻塞主线程，提升用户体验
  2. 并发控制很重要：通过SemaphoreSlim控制并发数，避免网络拥塞和系统资源耗尽
  3. 统计分析更专业：不仅要知道通不通，更要知道质量如何，延迟抖动、丢包率等指标才是关键

💡 最佳实践建议

  • 资源管理：及时释放Ping对象，避免资源泄漏
  • 异常处理：网络操作必须做好异常捕获和容错处理
  • 性能优化：合理设置超时时间和并发数，平衡速度与稳定性
  • 结果持久化：将监控数据导出为结构化格式，便于后续分析

怎么样，学会了这套C# Ping工具开发技巧，是不是感觉网络故障排查更有底气了？

你在项目中遇到过哪些网络连通性问题？或者对这个Ping工具还有什么功能建议？ 欢迎在评论区分享你的经验和想法！

如果这篇文章对你有帮助，请点赞并转发给更多需要的同行，让我们一起提升C#开发技能！ 🚀

相关信息

通过网盘分享的文件：AppPing.zip 链接: https://pan.baidu.com/s/1Jsk-PcaC-2tf2QUj3uacJg?pwd=dz8e 提取码: dz8e --来自百度网盘超级会员v9的分享

本文作者:技术老小子

本文链接:

版权声明:本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！