Example #1
0
        private PingTestData GenerateData()
        {
            PingTestData data = new PingTestData(TestDataChartType.Doughnut);

            data.AddData("Successful pings", (int)pingGood);
            data.AddData("Unsuccessful pings", (int)pingBad);
            return(data);
        }
Example #2
0
        public async Task <DataActionResult <PingTestData> > TestConnectionAsync(
            IPAddress ip
            )
        {
            List <PingTestData> pingReplies = new List <PingTestData>();

            for (int i = 0; i < _maxRetry; i++)
            {
                DataActionResult <PingTestData> pingResult = await PingAsync(
                    _ping,
                    ip,
                    _timeout,
                    _buffer,
                    _options
                    );

                if (pingResult.Status.Failure())
                {
                    return(DataActionResult <PingTestData> .Failed(pingResult.Status));
                }
                pingReplies.Add(pingResult.Result);
                if (pingResult.Result.Avg < 50 && pingResult.Result.Failed == 0)
                {
                    break;
                }
            }

            PingTestData result = pingReplies.Aggregate((current, next) =>
            {
                current.Num    += next.Num;
                current.Avg    += next.Avg;
                current.Failed += next.Failed;
                return(current);
            });
            int successful = result.Num - result.Failed;

            if (successful != 0)
            {
                result.Avg /= successful;
            }
            return(DataActionResult <PingTestData> .Successful(result));
        }
Example #3
0
        public async Task <IPingTestData> TestConnectionAsync(IPAddress ip, int times)
        {
            IEnumerable <long> pingReplys =
                (await PingConsecutiveAsync(ip, times));
            var result = new PingTestData()
            {
                num = pingReplys.Count()
            };

            if (result.num > 0)
            {
                result.min = pingReplys.Min();
                result.avg = pingReplys.Sum() / result.num;
                result.max = pingReplys.Max();
            }
            else
            {
                result.min = result.avg = result.max = 0;
            }
            return(result);
        }
Example #4
0
        static async Task <DataActionResult <PingTestData> > PingAsync(
            Ping ping,
            IPAddress ip,
            int timeout,
            byte[] buffer,
            PingOptions options
            )
        {
            try
            {
                long         tripTime = -1;
                PingTestData result   = new PingTestData()
                {
                    Num = 1
                };
                var reply = await ping.SendPingAsync(ip, timeout, buffer, options);

                if (reply.Status == IPStatus.Success)
                {
                    tripTime = reply.RoundtripTime;
                }
                if (tripTime == -1)
                {
                    result.Avg    = 0;
                    result.Failed = 1;
                }
                else
                {
                    result.Avg = tripTime;
                }

                return(DataActionResult <PingTestData> .Successful(result));
            }
            catch (PingException)
            {
                return(DataActionResult <PingTestData> .Failed(
                           StatusMessage.PingExecutionServiceError
                           ));
            }
        }