netdata.cs

using System.Net.NetworkInformation;
using System.Text;

namespace net
{
    public class NetworkStats
    {
        private const int IntervalSeconds = 1;

        private readonly System.Timers.Timer _timer;
        private readonly List<Sample> _samples = new();
        private readonly object _lock = new();

        private readonly NetworkInterface[] _nics;
        private readonly Dictionary<string, (long recv, long send)> _lastBytes = new();

        public NetworkStats()
        {
            _nics = NetworkInterface.GetAllNetworkInterfaces()
                .Where(nic =>
                    nic.OperationalStatus == OperationalStatus.Up &&
                    nic.NetworkInterfaceType != NetworkInterfaceType.Loopback &&
                    nic.Supports(NetworkInterfaceComponent.IPv4))
                .ToArray();

            if (_nics.Length == 0)
                throw new InvalidOperationException("No available IPv4 network interfaces found.");

            foreach (var nic in _nics)
            {
                var stats = nic.GetIPv4Statistics();
                _lastBytes[nic.Id] = (stats.BytesReceived, stats.BytesSent);
            }

            _timer = new System.Timers.Timer(IntervalSeconds * 1000);
            _timer.Elapsed += (_, _) => Collect();
            _timer.AutoReset = true;
            _timer.Start();
        }

        private void Collect()
        {
            long recvDelta = 0;
            long sendDelta = 0;
            var now = DateTime.UtcNow;

            lock (_lock)
            {
                foreach (var nic in _nics)
                {
                    var stats = nic.GetIPv4Statistics();
                    var last = _lastBytes[nic.Id];

                    recvDelta += stats.BytesReceived - last.recv;
                    sendDelta += stats.BytesSent - last.send;

                    _lastBytes[nic.Id] = (stats.BytesReceived, stats.BytesSent);
                }

                _samples.Add(new Sample
                {
                    Time = now,
                    ReceiveRate = recvDelta / (double)IntervalSeconds,
                    SendRate = sendDelta / (double)IntervalSeconds
                });

                // ������� 1 Сʱ������
                _samples.RemoveAll(s => (now - s.Time).TotalHours > 1);
            }
        }

        public string GetHtmlTable()
        {
            var now = DateTime.UtcNow;

            var ranges = new (string Name, TimeSpan Span)[]
            {
                ("Last 3 Seconds", TimeSpan.FromSeconds(3)),
                ("Last 10 Seconds", TimeSpan.FromSeconds(10)),
                ("Last 10 Minutes", TimeSpan.FromMinutes(10)),
                ("Last 1 Hour", TimeSpan.FromHours(1))
            };

            var sb = new StringBuilder();
            sb.Append("<table class=\"outer-table\">");

            sb.Append("<thead><tr>");
            sb.Append("<td>Time Range</td>");
            sb.Append("<td>Total Received</td>");
            sb.Append("<td>Total Sent</td>");
            sb.Append("<td>Avg Download</td>");
            sb.Append("<td>Avg Upload</td>");
            sb.Append("<td>Avg Total</td>");
            sb.Append("</tr></thead>");

            sb.Append("<tbody>");


            lock (_lock)
            {
                foreach (var r in ranges)
                {
                    var data = _samples
                        .Where(s => now - s.Time <= r.Span)
                        .ToList();

                    if (data.Count == 0)
                    {
                        sb.Append($"<tr><td>{r.Name}</td><td colspan='5'>No data</td></tr>");
                        continue;
                    }

                    var totalRecv = data.Sum(s => s.ReceiveRate) * IntervalSeconds;
                    var totalSend = data.Sum(s => s.SendRate) * IntervalSeconds;

                    var avgRecv = data.Average(s => s.ReceiveRate);
                    var avgSend = data.Average(s => s.SendRate);
                    var avgTotal = avgRecv + avgSend;

                    sb.Append("<tr>");
                    sb.Append($"<td>{r.Name}</td>");
                    sb.Append($"<td>{FormatBytes(totalRecv)}</td>");
                    sb.Append($"<td>{FormatBytes(totalSend)}</td>");
                    sb.Append($"<td>{FormatRate(avgRecv)}</td>");
                    sb.Append($"<td>{FormatRate(avgSend)}</td>");
                    sb.Append($"<td>{FormatRate(avgTotal)}</td>");
                    sb.Append("</tr>");
                }
            }

            sb.Append("</tbody>");
            sb.Append("</table>");

            return sb.ToString();
        }

        private static string FormatBytes(double bytes)
        {
            string[] units = { "B", "KB", "MB", "GB", "TB" };
            int unit = 0;

            while (bytes >= 1024 && unit < units.Length - 1)
            {
                bytes /= 1024;
                unit++;
            }

            return $"{bytes:F2} {units[unit]}";
        }

        private static string FormatRate(double bytesPerSecond)
        {
            return $"{FormatBytes(bytesPerSecond)}/s";
        }

        public Dictionary<string, object> GetJsonData()
        {
            var now = DateTime.UtcNow;

            var ranges = new (string Name, TimeSpan Span)[]
            {
                ("last_3_seconds", TimeSpan.FromSeconds(3)),
                ("last_10_seconds", TimeSpan.FromSeconds(10)),
                ("last_10_minutes", TimeSpan.FromMinutes(10)),
                ("last_1_hour", TimeSpan.FromHours(1))
            };

            var result = new Dictionary<string, object>();

            lock (_lock)
            {
                foreach (var r in ranges)
                {
                    var data = _samples
                        .Where(s => now - s.Time <= r.Span)
                        .ToList();

                    var rangeData = new Dictionary<string, object>
                    {
                        ["has_data"] = data.Count > 0
                    };

                    if (data.Count > 0)
                    {
                        var totalRecv = data.Sum(s => s.ReceiveRate) * IntervalSeconds;
                        var totalSend = data.Sum(s => s.SendRate) * IntervalSeconds;
                        var avgRecv = data.Average(s => s.ReceiveRate);
                        var avgSend = data.Average(s => s.SendRate);
                        var avgTotal = avgRecv + avgSend;

                        rangeData["total_received_bytes"] = totalRecv;
                        rangeData["total_sent_bytes"] = totalSend;
                        rangeData["avg_download_bytes_per_second"] = avgRecv;
                        rangeData["avg_upload_bytes_per_second"] = avgSend;
                        rangeData["avg_total_bytes_per_second"] = avgTotal;
                        rangeData["total_received_formatted"] = FormatBytes(totalRecv);
                        rangeData["total_sent_formatted"] = FormatBytes(totalSend);
                        rangeData["avg_download_formatted"] = FormatRate(avgRecv);
                        rangeData["avg_upload_formatted"] = FormatRate(avgSend);
                        rangeData["avg_total_formatted"] = FormatRate(avgTotal);
                    }

                    result[r.Name] = rangeData;
                }
            }

            return result;
        }

        private class Sample
        {
            public DateTime Time;
            public double ReceiveRate;
            public double SendRate;
        }
    }
}