Как продолжить следующую строку, когда результат задачи содержит определенную строку [duplicate]

Используя реализацию Task.WhenAny, вы можете создать как перегрузку расширения, которая также получает фильтр.

Этот метод возвращает Task, который будет завершен, когда любая из поставленных задач будет завершена, а результат передайте фильтр.

Что-то вроде этого:

static class TasksExtensions
{
    public static Task<Task<T>> WhenAny<T>(this IList<Task<T>> tasks, Func<T, bool> filter)
    {
        CompleteOnInvokePromiseFilter<T> action = new CompleteOnInvokePromiseFilter<T>(filter);

        bool flag = false;
        for (int i = 0; i < tasks.Count; i++)
        {
            Task<T> completingTask = tasks[i];

            if (!flag)
            {
                if (action.IsCompleted) flag = true;
                else if (completingTask.IsCompleted)
                {
                    action.Invoke(completingTask);
                    flag = true;
                }
                else completingTask.ContinueWith(t =>
                {
                    action.Invoke(t);
                });
            }
        }

        return action.Task;
    }
}

class CompleteOnInvokePromiseFilter<T>
{
    private int firstTaskAlreadyCompleted;
    private TaskCompletionSource<Task<T>> source;
    private Func<T, bool> filter;

    public CompleteOnInvokePromiseFilter(Func<T, bool> filter)
    {
        this.filter = filter;
        source = new TaskCompletionSource<Task<T>>();
    }

    public void Invoke(Task<T> completingTask)
    {
        if (completingTask.Status == TaskStatus.RanToCompletion && 
            filter(completingTask.Result) && 
            Interlocked.CompareExchange(ref firstTaskAlreadyCompleted, 1, 0) == 0)
        {
            source.TrySetResult(completingTask);
        }
    }

    public Task<Task<T>> Task { get { return source.Task; } }

    public bool IsCompleted { get { return source.Task.IsCompleted; } }
}

Вы можете использовать этот метод расширения следующим образом:

List<Task<int>> tasks = new List<Task<int>>();    
...Initialize Tasks...

var task = await tasks.WhenAny(x => x % 2 == 0);

//In your case would be something like tasks.WhenAny(b => b);

Джон Скит , Стивен Тууб и сам все имеют вариации подхода «порядок по завершению».

Однако я считаю, что обычно людям не нужна такая сложность, если они фокусируют свое внимание немного по-другому.

В этом случае у вас есть набор задач , и хотите, чтобы они были отменены, как только один из них вернется false. Вместо того, чтобы думать об этом с точки зрения контроллера («как может вызывающий код делать это»), подумайте об этом с точки зрения задачи («как каждая задача делает это »).

Если вы вводите асинхронную операцию более высокого уровня« выполните работу и затем отмените ее при необходимости », вы обнаружите, что ваш код вызова очищается красиво:

public async Task DoWorkAndCancel(Func<CancellationToken, Task<bool>> work,
    CancellationTokenSource cts)
{
  if (!await work(cts.Token))
    cts.Cancel();
}

List<Func<CancellationToken, Task<bool>>> allWork = ...;
var cts = new CancellationTokenSource();
var tasks = allWork.Select(x => DoWorkAndCancel(x, cts));
await Task.WhenAll(tasks);