Wait until one of the tasks completes successfully

Question

I have an IP discover method where I test every IP address with a TcpClient, when any IP has a successful connection I set the WebServerIp in the memory, and that's when in my world the task is completed successfully. Is there a way to implement it here in my code? Or some kind of cancelation token when a task is "successful".

Here is my code:

public async Task<bool> DiscoverDeviceAsync()
{
    var ips = GeneralService.GetIPAddress();
    PhoneIp = string.Join(",", ips.Select(x => x.ToString()));

    await Task.Delay(1000);

    var tasks = new List<Task>();

    foreach (IPAddress ip in ips)
    {
        byte[] ipBytes = ip.GetAddressBytes();

        for (int i = 0; i <= 254; i++)
        {
            ipBytes[3] = (byte)i;
            IPAddress currentIPAddress = new(ipBytes);
            tasks.Add(ScanIPAddress(currentIPAddress, 9431));
        }
    }

    await Task.WhenAny(tasks);

    return WebServerIp != "";
}

async Task ScanIPAddress(IPAddress ipAddress, int port)
{
    try
    {
        using TcpClient tcpClient = new()
        {
            SendTimeout = 100,
            ReceiveTimeout = 100,
        };

        await tcpClient.ConnectAsync(ipAddress, port);

        WebServerIp = ipAddress.ToString();
    }
    catch
    {
        throw new Exception($"No device found at address: {ipAddress}");
    }
}

Answer 1

If you're happy to use Microsoft's Reactive Framework, then you could do this:

public async Task<string> DiscoverDeviceAsync() =>
    await
    (
        from ip in GeneralService.GetIPAddress().ToObservable()
        let ipPrefix = String.Concat(ip.GetAddressBytes().Take(3).Select(x => $"{x}."))
        from i in Observable.Range(0, 255)
        let currentIPAddress = IPAddress.Parse($"{ipPrefix}{i}")
        from scan in Observable.FromAsync(ct => ScanIPAddress(currentIPAddress, 9431, ct))
        where scan != null
        select scan
    ).FirstAsync();

async Task<string> ScanIPAddress(IPAddress ipAddress, int port, CancellationToken ct)
{
    try
    {
        using TcpClient tcpClient = new()
        {
            SendTimeout = 100,
            ReceiveTimeout = 100,
        };
        await tcpClient.ConnectAsync(ipAddress, port, ct);
        return ipAddress.ToString();
    }
    catch
    {
        return null;
    }
}

---

Of course, this is possible to use method syntax:

public async Task<string> DiscoverDeviceAsync() =>
    await
        GeneralService
            .GetIPAddress()
            .ToObservable()
            .Select(ip => String.Concat(ip.GetAddressBytes().Take(3).Select(x => $"{x}.")))
            .SelectMany(prefix => Observable.Range(0, 255), (prefix, i) => IPAddress.Parse($"{prefix}{i}"))
            .SelectMany(ip => Observable.FromAsync(ct => ScanIPAddress(ip, 9431, ct)))
            .Where(scan => scan != null)
            .FirstAsync();

The query syntax is only ever syntactic-sugar.

Answer 2

What you need is a way to signal to the main and other threads when the work is done.

For that you can use an EventWaitHandle in combination with a CancellationToken

First we create the handle and cancellation token:

 var waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset);
 var cts = new CancellationTokenSource();

Pass them to your method:

tasks.Add(ScanIPAddress(currentIPAddress, 9431, waitHandle, cts.Token));

Then inside the method set WaitHandle if connection is succesfull, also check the cancellation token:

async Task ScanIPAddress(IPAddress ipAddress, int port, EventWaitHandle waitHandle, CancellationToken cancellationToken)
{
    try
    {
        if (cancellationToken.IsCancellationRequested)
        {
            return;
        }
        
        using TcpClient tcpClient = new()
        {
            SendTimeout = 100,
            ReceiveTimeout = 100,
        };

        await tcpClient.ConnectAsync(ipAddress, port, cancellationToken);

        waitHandle.Set();
        WebServerIp = ipAddress.ToString();
    }
    catch
    {
        throw new Exception($"No device found at address: {ipAddress}");
    }
}

After this you can use WaitOne method of EventHandle to wait until the flag is set. This can mean one of two things, either one of the operations were successful, or all have failed:

// Set wait handle after all tasks are finished, so it doesn't wait forever if none of them are successful
// no await here is intentional as we don't wanna wait for all tasks to complete here.
Task.WhenAll(tasks).ContinueWith(_ => waitHandle.Set());
    
waitHandle.WaitOne();

cts.Cancel();

return WebServerIp != "";