In my C# project I am pinging to multiple IP's. How can I get the ping replies of each IP immediatly independent of each other's ping result?

Question

I am using following code to ping to multiple IP's at the same time (one ping repeated 4 times). In general it works fine. But the only problem I have is, when I want to get the ping replies to show them for example on the screen.

Let's say ip1 is online and the ping reply is OK. ip2 is offline and the ping reply is "timed Out" When I want to show the ping results on the screen, while pinging I want that for ip1 the ping result is there immediatly when the reply comes. But the "OK" results for ip1 is coming delayed with the "timed out" replies of ip2.

How can I isolate the ping results so that in my example ip1's result is shown immediatly without waiting each time 4 seconds for the "timed out" message?

private async ValueTask PingMachine() 
{
  var timesToPing = 4;
  var counter = 1;

  while (counter <= timesToPing) {
    var reply = await Pinger();
    foreach (var r in reply) {
       TagService.log_PLC.AppendLine($" Pinged {TagService.IP_PLC_List} {counter} times time:{r.RoundtripTime} status: {r.Status.ToString()}");
    }
}
counter++;
}

private async Task<IEnumerable<PingReply>> Pinger() 
{
  List<string> addresses = new List<string>();
  if (Check_IP_Correct(TagService.IP_PLC_List) == true) 
  {
   addresses.Add(TagService.IP_PLC_List);
  }

  var tasks = addresses.Select(async ip => await new Ping().SendPingAsync(ip, 1000));
  var reply = await Task.WhenAll(tasks);
  return reply;
}

Answer 1

You can pass a callback to the Pinger function so that the callback is executed as soon as the result is available.

To address Theodor Zouliak's concern about guideline CA2008, here's an edited version that doesn't use ContinueWith:

private async ValueTask PingMachine() 
{
  var timesToPing = 4;
  var counter = 1;

  while (counter <= timesToPing) {
    await Pinger(r => TagService.log_PLC.AppendLine($" Pinged {TagService.IP_PLC_List} {counter} times time:{r.RoundtripTime} status: {r.Status}"));
    counter++;
  }
}

private async Task<IEnumerable<PingReply>> Pinger(Action<PingReply> callback) 
{
  List<string> addresses = new List<string>();
  if (Check_IP_Correct(TagService.IP_PLC_List) == true) 
  {
    addresses.Add(TagService.IP_PLC_List);
  }

  var tasks = addresses.Select(ip => PingOne(ip, callback));
  var reply = await Task.WhenAll(tasks);
  return reply;
}

static private async Task<PingReply> PingOne(string ip, Action<PingReply> callback) {
  final r = await new Ping().SendPingAsync(ip, 1000);
  if (callback != null) {
    callback(r);
  }
  return r;
}

If you want everything to run concurrently, then do not await Pinger, eg:

  var tasks = new List<Task>();

  while (counter <= timesToPing) {
    tasks.Add(Pinger(r => TagService.log_PLC.AppendLine($" Pinged {TagService.IP_PLC_List} {counter} times time:{r.RoundtripTime} status: {r.Status}")));
    counter++;
  }

  await Task.WhenAll(tasks);

Answer 2

Almost every scenario where you find yourself thinking "I want to do something as each of these tasks completes", the answer is actually to adjust how your tasks are composed.

Your current code is awaiting the response from every IP before displaying the results. To change it to display the results immediately, you just move the code that displays the results:

private async ValueTask PingMachine() 
{
  var timesToPing = 4;
  var counter = 1;

  while (counter <= timesToPing) {
    var reply = await Pinger(counter);
    counter++;
  }
}

private async Task<IEnumerable<PingReply>> Pinger(int counter)
{
  List<string> addresses = new List<string>();
  if (Check_IP_Correct(TagService.IP_PLC_List) == true) 
    addresses.Add(TagService.IP_PLC_List);

  var tasks = addresses.Select(async ip =>
  {
    var result = await new Ping().SendPingAsync(ip, 1000));
    TagService.log_PLC.AppendLine($" Pinged {ip} {counter} times time:{result.RoundtripTime} status: {result.Status.ToString()}");
    return result;
  });
  return await Task.WhenAll(tasks);
}

Update:

From the comments, it seems like you want to have an independent loop with a separate counter for each IP address, rather than looping over all of them. In that case, you can move the loop into the lambda as well:

private async Task Pinger()
{
  var timesToPing = 4;
  List<string> addresses = new List<string>();
  if (Check_IP_Correct(TagService.IP_PLC_List) == true) 
    addresses.Add(TagService.IP_PLC_List);

  var tasks = addresses.Select(async ip =>
  {
    for (var counter = 1; counter <= timesToPing; ++counter)
    {
      var result = await new Ping().SendPingAsync(ip, 1000));
      TagService.log_PLC.AppendLine($" Pinged {ip} {counter} times time:{result.RoundtripTime} status: {result.Status.ToString()}");
    }
  });
  await Task.WhenAll(tasks);
}