SampleCode/BandWidthMonitor/BandwidthLogger.cs at master · JonCole/SampleCode · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
using System;
using System.Net.NetworkInformation;
using System.Threading.Tasks;

namespace BandwidthMonitor
{
    class BandwidthLogger : IDisposable
    {
        private TimeSpan _logFrequency;
        private bool _disposed;
        private long _previousReadBytes;
        private long _previousWriteBytes;
        DateTimeOffset _previousComputeTime;

        public BandwidthLogger(TimeSpan logFrequency)
        {
            if (logFrequency <= TimeSpan.Zero)
            {
                throw new ArgumentOutOfRangeException("logFrequency");
            }

            _logFrequency = logFrequency;
            _previousComputeTime = DateTimeOffset.UtcNow;
            GetNetworkUsage(out _previousReadBytes, out _previousWriteBytes);
            StartLogging();
        }

        private async void StartLogging()
        {
            try
            {
                const long bitsPerByte = 8;
                const double oneMeg = 1024 * 1024;


                while (!_disposed)
                {
                    await Task.Delay(_logFrequency);

                    long bytesRead;
                    long bytesWrite;
                    GetNetworkUsage(out bytesRead, out bytesWrite);

                    DateTimeOffset currentTime = DateTimeOffset.UtcNow;
                    TimeSpan elapsed = currentTime - _previousComputeTime;

                    long readDelta = (bytesRead - _previousReadBytes);
                    long writeDelta = (bytesWrite - _previousWriteBytes);

                    _previousReadBytes = bytesRead;
                    _previousWriteBytes = bytesWrite;
                    _previousComputeTime = currentTime;

                    double mbitsReadPerSecond = readDelta <= 0 ? 0 : ((readDelta * bitsPerByte) / oneMeg) / elapsed.TotalSeconds;
                    double mbitsWritePerSecond = writeDelta <= 0 ? 0 : ((writeDelta * bitsPerByte) / oneMeg) / elapsed.TotalSeconds;

                    LogUsage(mbitsReadPerSecond, mbitsWritePerSecond);
                }
            }
            catch(Exception)
            {

            }
        }

        protected virtual void LogUsage(double mbitsReadPerSecond, double mbitsWritePerSecond)
        {
            Console.WriteLine("[{0}] BandWidth Usage ==> READ: {1} MBits/Sec, WRITE: {2} MBits/Sec",
                DateTimeOffset.UtcNow.ToString("u"),
                Math.Round(mbitsReadPerSecond, 2),
                Math.Round(mbitsWritePerSecond, 2)
                );
        }

        private static void GetNetworkUsage(out long bytesRead, out long bytesWrite)
        {
            bytesRead = 0L;
            bytesWrite = 0L;
            try
            {
                var nics = NetworkInterface.GetAllNetworkInterfaces();

                foreach (var nic in nics)
                {
                    long nicbytesRead = nic.GetIPStatistics().BytesReceived;
                    long nicbytesWrite = nic.GetIPStatistics().BytesSent;
                    bytesRead += nicbytesRead;
                    bytesWrite += nicbytesWrite;
                }
            }
            catch(Exception)
            {

            }
        }

        public void Dispose()
        {
            _disposed = true;
        }
    }
}