Await list of async predicates, but drop out on first false

Question

Imagine the following class:

public class Checker
{
   public async Task<bool> Check() { ... }
}

Now, imagine a list of instances of this class:

IEnumerable<Checker> checkers = ...

Now I want to control that every instance will return true:

checkers.All(c => c.Check());

Now, this won't compile, since Check() returns a Task<bool> not a bool.

So my question is: How can I best enumerate the list of checkers? And how can I shortcut the enumeration as soon as a checker returns false? (something I presume All( ) does already)

Answer 1

"Asynchronous sequences" can always cause some confusion. For example, it's not clear whether your desired semantics are:

1. Start all checks simultaneously, and evaluate them as they complete.
2. Start the checks one at a time, evaluating them in sequence order.

There's a third possibility (start all checks simultaneously, and evaluate them in sequence order), but that would be silly in this scenario.

I recommend using Rx for asynchronous sequences. It gives you a lot of options, and it a bit hard to learn, but it also forces you to think about exactly what you want.

The following code will start all checks simultaneously and evaluate them as they complete:

IObservable<bool> result = checkers.ToObservable()
    .SelectMany(c => c.Check()).All(b => b);

It first converts the sequence of checkers to an observable, calls Check on them all, and checks whether they are all true. The first Check that completes with a false value will cause result to produce a false value.

In contrast, the following code will start the checks one at a time, evaluating them in sequence order:

IObservable<bool> result = checkers.Select(c => c.Check().ToObservable())
    .Concat().All(b => b);

It first converts the sequence of checkers to a sequence of observables, and then concatenates those sequences (which starts them one at a time).

If you do not wish to use observables much and don't want to mess with subscriptions, you can await them directly. E.g., to call Check on all checkers and evaluate the results as they complete:

bool all = await checkers.ToObservable().SelectMany(c => c.Check()).All(b => b);

Answer 2

And how can I shortcut the enumeration as soon as a checker returns false?

This will check the tasks' result in order of completion. So if task #5 is the first to complete, and returns false, the method returns false immediately, regardless of the other tasks. Slower tasks (#1, #2, etc) would never be checked.

public static async Task<bool> AllAsync(this IEnumerable<Task<bool>> source)
{
    var tasks = source.ToList();

    while(tasks.Count != 0)
    {
        var finishedTask = await Task.WhenAny(tasks);

        if(! finishedTask.Result)
            return false;

        tasks.Remove(finishedTask);
    }

    return true;
}

Usage:

bool result = await checkers.Select(c => c.Check())
                            .AllAsync();