CODEWITHSUNDEEP
c#multithreadingping
eddie_cat
eddie_cat

Reputation: 2583

How can I make many pings asynchronously at the same time?

I just can't seem to understand how to structure an asynchronous call to SendPingAsync. I want to loop through a list of IP addresses and ping them all asynchronously before moving on in the program... right now it takes forever to go through all of them one at a time. I asked a question about it earlier thinking I'd be able to figure out async but apparently I was wrong. 

private void button1_Click(object sender, EventArgs e)
{
    this.PingLoop();
    MessageBox.Show("hi"); //for testing

}

public async void PingLoop()
{
    Task<int> longRunningTask = PingAsync();

    int result = await longRunningTask;
    MessageBox.Show("async call is finished!"); 

    //eventually want to loop here but for now just want to understand how this works
}

private async Task<int> PingAsync()
{
    Ping pingSender = new Ping();
    string reply = pingSender.SendPingAsync("www.google.com", 2000).ToString();
    pingReplies.Add(reply); //what should i be awaiting here?? 
    return 1;
}

I'm afraid I just don't get what is really going on here enough... when should I return a task? When I run this as is I just get a frozen UI and a ping error. I have read the MSDN documentation and tons of questions here and I'm just not getting it.

Upvotes: 11

Views: 22421

Answers (5)

Reed Copsey
Reed Copsey

Reputation: 564403

You'd want to do something like:

private async Task<List<PingReply>> PingAsync()
{
    var tasks = theListOfIPs.Select(ip => new Ping().SendPingAsync(ip, 2000));
    var results = await Task.WhenAll(tasks);

    return results.ToList();
}

This will start off one request per IP in theListOfIPs asynchronously, then asynchronously wait for them all to complete. It will then return the list of replies.

Note that it's almost always better to return the results vs. setting them in a field, as well. The latter can lead to bugs if you go to use the field (pingReplies) before the asynchronous operation completes - by returning, and adding the range to your collection after the call is made with await, you make the code more clear and less bug prone.

Upvotes: 19

Haddad
Haddad

Reputation: 307

public static async Task<bool> PingAsync(string host)
{
    try
    {
        var ping = new System.Net.NetworkInformation.Ping();
        var reply = await ping.SendTaskAsync(host);

        return (reply.Status == System.Net.NetworkInformation.IPStatus.Success);
    }
    catch { return false; }
}

Upvotes: 0

Tsukasa
Tsukasa

Reputation: 6552

Here is how I do it

private delegate void scanTargetDelegate(IPAddress ipaddress);

private Task<PingReply> pingAsync(IPAddress ipaddress)
    {
        var tcs = new TaskCompletionSource<PingReply>();
        try
        {

            AutoResetEvent are = new AutoResetEvent(false);

            Ping ping = new Ping();
            ping.PingCompleted += (obj, sender) =>
                {
                    tcs.SetResult(sender.Reply);
                };
            ping.SendAsync(ipaddress, new object { });

        }
        catch (Exception)
        {
        }
        return tcs.Task;
    }

in a BackgroundWorker I do this

List<Task<PingReply>> pingTasks = new List<Task<PingReply>>();

        addStatus("Scanning Network");
        foreach (var ip in range)
        {
            pingTasks.Add(pingAsync(ip));
        }

        Task.WaitAll(pingTasks.ToArray());

        addStatus("Network Scan Complete");

        scanTargetDelegate d = null;
        IAsyncResult r = null;

foreach (var pingTask in pingTasks)
        {
            if (pingTask.Result.Status.Equals(IPStatus.Success))
            {
                d = new scanTargetDelegate(scanTarget); //do something with the ip
                r = d.BeginInvoke(pingTask.Result.Address, null, null);
                Interlocked.Increment(ref Global.queuedThreads);
            }
            else
            {
                if (!ownIPs.Contains(pingTask.Result.Address))
                {
                    failed.Add(pingTask.Result.Address);
                }
            }
        }

        if (r != null)
        {
            WaitHandle[] waits = new WaitHandle[] { r.AsyncWaitHandle };
            WaitHandle.WaitAll(waits);
        }

Upvotes: 0

usr
usr

Reputation: 171188

What you want is to start all pings at once:

var pingTargetHosts = ...; //fill this in
var pingTasks = pingTargetHosts.Select(
     host => new Ping().SendPingAsync(host, 2000)).ToList();

Now the pings are running. Collect their results:

var pingResults = await Task.WhenAll(pingTasks);

Now the concurrent phase of the processing is done and you can examine and process the results.

Upvotes: 2

L.B
L.B

Reputation: 116108

What you do here pingSender.SendPingAsync("www.google.com", 2000).ToString(); doesn't make much sense.

Instead you should return pingSender.SendPingAsync("www.google.com", 2000) and

await Task.WhenAll(your all ping requests)

Upvotes: 2

Related Questions