Aguarde de forma assíncrona que a Tarefa <T> seja concluída com tempo limite

Quero aguardar que uma tarefa <T> seja concluída com algumas regras especiais: se ela não for concluída após X milissegundos, desejo exibir uma mensagem para o usuário. E se não for concluído após milissegundos Y, desejo solicitar automaticamente o cancelamento .

Eu posso usar Task.ContinueWith para aguardar assincronamente a tarefa (ou seja, agendar uma ação a ser executada quando a tarefa for concluída), mas isso não permite especificar um tempo limite. Posso usar o Task.Wait para aguardar de forma síncrona que a tarefa seja concluída com um tempo limite, mas isso bloqueia meu encadeamento. Como posso aguardar assincronamente a conclusão da tarefa com um tempo limite?

Que tal agora:

int timeout = 1000;
var task = SomeOperationAsync();
if (await Task.WhenAny(task, Task.Delay(timeout)) == task) {
    // task completed within timeout
} else { 
    // timeout logic
}

E aqui está uma excelente postagem no blog "Criando um método Task.TimeoutAfter" (da equipe da MS Parallel Library) com mais informações sobre esse tipo de coisa .

Além disso : a pedido de um comentário na minha resposta, aqui está uma solução expandida que inclui tratamento de cancelamento. Observe que passar o cancelamento para a tarefa e o cronômetro significa que há várias maneiras de o cancelamento ocorrer no seu código, e você deve testar e ter certeza de que lida com todos eles corretamente. Não deixe ao acaso várias combinações e espere que seu computador faça a coisa certa em tempo de execução.

int timeout = 1000;
var task = SomeOperationAsync(cancellationToken);
if (await Task.WhenAny(task, Task.Delay(timeout, cancellationToken)) == task)
{
    // Task completed within timeout.
    // Consider that the task may have faulted or been canceled.
    // We re-await the task so that any exceptions/cancellation is rethrown.
    await task;

}
else
{
    // timeout/cancellation logic
}

Aqui está uma versão do método de extensão que incorpora o cancelamento do tempo limite quando a tarefa original é concluída, conforme sugerido por Andrew Arnott em um comentário à sua resposta .

public static async Task<TResult> TimeoutAfter<TResult>(this Task<TResult> task, TimeSpan timeout) {

    using (var timeoutCancellationTokenSource = new CancellationTokenSource()) {

        var completedTask = await Task.WhenAny(task, Task.Delay(timeout, timeoutCancellationTokenSource.Token));
        if (completedTask == task) {
            timeoutCancellationTokenSource.Cancel();
            return await task;  // Very important in order to propagate exceptions
        } else {
            throw new TimeoutException("The operation has timed out.");
        }
    }
}

Você pode usar Task.WaitAnypara aguardar a primeira de várias tarefas.

Você pode criar duas tarefas adicionais (que são concluídas após os tempos limite especificados) e depois usar WaitAnypara aguardar o que for concluído primeiro. Se a tarefa que foi concluída primeiro for a sua "obra", você estará pronto. Se a tarefa que foi concluída primeiro for uma tarefa de tempo limite, você poderá reagir ao tempo limite (por exemplo, solicitar cancelamento).

Que tal algo assim?

    const int x = 3000;
    const int y = 1000;

    static void Main(string[] args)
    {
        // Your scheduler
        TaskScheduler scheduler = TaskScheduler.Default;

        Task nonblockingTask = new Task(() =>
            {
                CancellationTokenSource source = new CancellationTokenSource();

                Task t1 = new Task(() =>
                    {
                        while (true)
                        {
                            // Do something
                            if (source.IsCancellationRequested)
                                break;
                        }
                    }, source.Token);

                t1.Start(scheduler);

                // Wait for task 1
                bool firstTimeout = t1.Wait(x);

                if (!firstTimeout)
                {
                    // If it hasn't finished at first timeout display message
                    Console.WriteLine("Message to user: the operation hasn't completed yet.");

                    bool secondTimeout = t1.Wait(y);

                    if (!secondTimeout)
                    {
                        source.Cancel();
                        Console.WriteLine("Operation stopped!");
                    }
                }
            });

        nonblockingTask.Start();
        Console.WriteLine("Do whatever you want...");
        Console.ReadLine();
    }

Você pode usar a opção Task.Wait sem bloquear o thread principal usando outra tarefa.

Aqui está um exemplo completo, com base na resposta mais votada, que é:

int timeout = 1000;
var task = SomeOperationAsync();
if (await Task.WhenAny(task, Task.Delay(timeout)) == task) {
    // task completed within timeout
} else { 
    // timeout logic
}

A principal vantagem da implementação nesta resposta é que os genéricos foram adicionados, para que a função (ou tarefa) possa retornar um valor. Isso significa que qualquer função existente pode ser agrupada em uma função de tempo limite, por exemplo:

Antes:

int x = MyFunc();

Depois de:

// Throws a TimeoutException if MyFunc takes more than 1 second
int x = TimeoutAfter(MyFunc, TimeSpan.FromSeconds(1));

Este código requer o .NET 4.5.

using System;
using System.Threading;
using System.Threading.Tasks;

namespace TaskTimeout
{
    public static class Program
    {
        /// <summary>
        ///     Demo of how to wrap any function in a timeout.
        /// </summary>
        private static void Main(string[] args)
        {

            // Version without timeout.
            int a = MyFunc();
            Console.Write("Result: {0}\n", a);
            // Version with timeout.
            int b = TimeoutAfter(() => { return MyFunc(); },TimeSpan.FromSeconds(1));
            Console.Write("Result: {0}\n", b);
            // Version with timeout (short version that uses method groups). 
            int c = TimeoutAfter(MyFunc, TimeSpan.FromSeconds(1));
            Console.Write("Result: {0}\n", c);

            // Version that lets you see what happens when a timeout occurs.
            try
            {               
                int d = TimeoutAfter(
                    () =>
                    {
                        Thread.Sleep(TimeSpan.FromSeconds(123));
                        return 42;
                    },
                    TimeSpan.FromSeconds(1));
                Console.Write("Result: {0}\n", d);
            }
            catch (TimeoutException e)
            {
                Console.Write("Exception: {0}\n", e.Message);
            }

            // Version that works on tasks.
            var task = Task.Run(() =>
            {
                Thread.Sleep(TimeSpan.FromSeconds(1));
                return 42;
            });

            // To use async/await, add "await" and remove "GetAwaiter().GetResult()".
            var result = task.TimeoutAfterAsync(TimeSpan.FromSeconds(2)).
                           GetAwaiter().GetResult();

            Console.Write("Result: {0}\n", result);

            Console.Write("[any key to exit]");
            Console.ReadKey();
        }

        public static int MyFunc()
        {
            return 42;
        }

        public static TResult TimeoutAfter<TResult>(
            this Func<TResult> func, TimeSpan timeout)
        {
            var task = Task.Run(func);
            return TimeoutAfterAsync(task, timeout).GetAwaiter().GetResult();
        }

        private static async Task<TResult> TimeoutAfterAsync<TResult>(
            this Task<TResult> task, TimeSpan timeout)
        {
            var result = await Task.WhenAny(task, Task.Delay(timeout));
            if (result == task)
            {
                // Task completed within timeout.
                return task.GetAwaiter().GetResult();
            }
            else
            {
                // Task timed out.
                throw new TimeoutException();
            }
        }
    }
}

Ressalvas

Tendo dado essa resposta, geralmente não é uma boa prática ter exceções lançadas em seu código durante a operação normal, a menos que você precise:

• Cada vez que uma exceção é lançada, é uma operação extremamente pesada,
• Exceções podem tornar seu código lento por um fator de 100 ou mais se as exceções estiverem em um loop restrito.

Somente use esse código se você absolutamente não puder alterar a função que está chamando, para que o tempo limite seja excedido após um determinado TimeSpan.

Essa resposta é realmente aplicável apenas ao lidar com bibliotecas de bibliotecas de terceiros que você simplesmente não pode refatorar para incluir um parâmetro de tempo limite.

Como escrever código robusto

Se você deseja escrever um código robusto, a regra geral é esta:

Toda operação que pode potencialmente bloquear indefinidamente deve ter um tempo limite.

Se você não observar essa regra, seu código acabará atingindo uma operação que falhará por algum motivo, bloqueará indefinidamente e seu aplicativo será interrompido permanentemente.

Se houvesse um tempo limite razoável após algum tempo, seu aplicativo seria interrompido por um período extremo de tempo (por exemplo, 30 segundos). Ele exibia um erro e continuava em seu caminho alegre ou tentava novamente.

Usando a excelente biblioteca AsyncEx de Stephen Cleary , você pode:

TimeSpan timeout = TimeSpan.FromSeconds(10);

using (var cts = new CancellationTokenSource(timeout))
{
    await myTask.WaitAsync(cts.Token);
}

TaskCanceledException será lançado no caso de um tempo limite.

Esta é uma versão ligeiramente aprimorada das respostas anteriores.

• Além da resposta de Lawrence , ela cancela a tarefa original quando ocorre o tempo limite.
• Além das variantes de resposta 2 e 3 do sjb , você pode fornecer CancellationTokena tarefa original e, quando ocorre o tempo limite, você obtém o TimeoutExceptioninvés OperationCanceledException.

async Task<TResult> CancelAfterAsync<TResult>(
    Func<CancellationToken, Task<TResult>> startTask,
    TimeSpan timeout, CancellationToken cancellationToken)
{
    using (var timeoutCancellation = new CancellationTokenSource())
    using (var combinedCancellation = CancellationTokenSource
        .CreateLinkedTokenSource(cancellationToken, timeoutCancellation.Token))
    {
        var originalTask = startTask(combinedCancellation.Token);
        var delayTask = Task.Delay(timeout, timeoutCancellation.Token);
        var completedTask = await Task.WhenAny(originalTask, delayTask);
        // Cancel timeout to stop either task:
        // - Either the original task completed, so we need to cancel the delay task.
        // - Or the timeout expired, so we need to cancel the original task.
        // Canceling will not affect a task, that is already completed.
        timeoutCancellation.Cancel();
        if (completedTask == originalTask)
        {
            // original task completed
            return await originalTask;
        }
        else
        {
            // timeout
            throw new TimeoutException();
        }
    }
}

Uso

InnerCallAsyncpode levar muito tempo para concluir. CallAsyncenvolve com um tempo limite.

async Task<int> CallAsync(CancellationToken cancellationToken)
{
    var timeout = TimeSpan.FromMinutes(1);
    int result = await CancelAfterAsync(ct => InnerCallAsync(ct), timeout,
        cancellationToken);
    return result;
}

async Task<int> InnerCallAsync(CancellationToken cancellationToken)
{
    return 42;
}

Use um timer para lidar com a mensagem e o cancelamento automático. Quando a tarefa terminar, chame Dispose nos timers para que eles nunca disparem. Aqui está um exemplo; altere taskDelay para 500, 1500 ou 2500 para ver os diferentes casos:

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        private static Task CreateTaskWithTimeout(
            int xDelay, int yDelay, int taskDelay)
        {
            var cts = new CancellationTokenSource();
            var token = cts.Token;
            var task = Task.Factory.StartNew(() =>
            {
                // Do some work, but fail if cancellation was requested
                token.WaitHandle.WaitOne(taskDelay);
                token.ThrowIfCancellationRequested();
                Console.WriteLine("Task complete");
            });
            var messageTimer = new Timer(state =>
            {
                // Display message at first timeout
                Console.WriteLine("X milliseconds elapsed");
            }, null, xDelay, -1);
            var cancelTimer = new Timer(state =>
            {
                // Display message and cancel task at second timeout
                Console.WriteLine("Y milliseconds elapsed");
                cts.Cancel();
            }
                , null, yDelay, -1);
            task.ContinueWith(t =>
            {
                // Dispose the timers when the task completes
                // This will prevent the message from being displayed
                // if the task completes before the timeout
                messageTimer.Dispose();
                cancelTimer.Dispose();
            });
            return task;
        }

        static void Main(string[] args)
        {
            var task = CreateTaskWithTimeout(1000, 2000, 2500);
            // The task has been started and will display a message after
            // one timeout and then cancel itself after the second
            // You can add continuations to the task
            // or wait for the result as needed
            try
            {
                task.Wait();
                Console.WriteLine("Done waiting for task");
            }
            catch (AggregateException ex)
            {
                Console.WriteLine("Error waiting for task:");
                foreach (var e in ex.InnerExceptions)
                {
                    Console.WriteLine(e);
                }
            }
        }
    }
}

Além disso, o CTP assíncrono fornece um método TaskEx.Delay que agrupará os cronômetros em tarefas para você. Isso pode lhe dar mais controle para executar ações como definir o TaskScheduler para a continuação quando o Timer for disparado.

private static Task CreateTaskWithTimeout(
    int xDelay, int yDelay, int taskDelay)
{
    var cts = new CancellationTokenSource();
    var token = cts.Token;
    var task = Task.Factory.StartNew(() =>
    {
        // Do some work, but fail if cancellation was requested
        token.WaitHandle.WaitOne(taskDelay);
        token.ThrowIfCancellationRequested();
        Console.WriteLine("Task complete");
    });

    var timerCts = new CancellationTokenSource();

    var messageTask = TaskEx.Delay(xDelay, timerCts.Token);
    messageTask.ContinueWith(t =>
    {
        // Display message at first timeout
        Console.WriteLine("X milliseconds elapsed");
    }, TaskContinuationOptions.OnlyOnRanToCompletion);

    var cancelTask = TaskEx.Delay(yDelay, timerCts.Token);
    cancelTask.ContinueWith(t =>
    {
        // Display message and cancel task at second timeout
        Console.WriteLine("Y milliseconds elapsed");
        cts.Cancel();
    }, TaskContinuationOptions.OnlyOnRanToCompletion);

    task.ContinueWith(t =>
    {
        timerCts.Cancel();
    });

    return task;
}

Outra maneira de resolver esse problema é usar extensões reativas:

public static Task TimeoutAfter(this Task task, TimeSpan timeout, IScheduler scheduler)
{
        return task.ToObservable().Timeout(timeout, scheduler).ToTask();
}

Teste acima usando o código abaixo no seu teste de unidade, ele funciona para mim

TestScheduler scheduler = new TestScheduler();
Task task = Task.Run(() =>
                {
                    int i = 0;
                    while (i < 5)
                    {
                        Console.WriteLine(i);
                        i++;
                        Thread.Sleep(1000);
                    }
                })
                .TimeoutAfter(TimeSpan.FromSeconds(5), scheduler)
                .ContinueWith(t => { }, TaskContinuationOptions.OnlyOnFaulted);

scheduler.AdvanceBy(TimeSpan.FromSeconds(6).Ticks);

Você pode precisar do seguinte espaço para nome:

using System.Threading.Tasks;
using System.Reactive.Subjects;
using System.Reactive.Linq;
using System.Reactive.Threading.Tasks;
using Microsoft.Reactive.Testing;
using System.Threading;
using System.Reactive.Concurrency;

Uma versão genérica da resposta de @ Kevan acima, usando Extensões Reativas.

public static Task<T> TimeoutAfter<T>(this Task<T> task, TimeSpan timeout, IScheduler scheduler)
{
    return task.ToObservable().Timeout(timeout, scheduler).ToTask();
}

Com o Agendador opcional:

public static Task<T> TimeoutAfter<T>(this Task<T> task, TimeSpan timeout, Scheduler scheduler = null)
{
    return scheduler is null 
       ? task.ToObservable().Timeout(timeout).ToTask() 
       : task.ToObservable().Timeout(timeout, scheduler).ToTask();
}

BTW: Quando ocorrer um tempo limite, uma exceção de tempo limite será lançada

Se você usar um BlockingCollection para agendar a tarefa, o produtor poderá executar a tarefa potencialmente demorada e o consumidor poderá usar o método TryTake, que possui um token de tempo limite e cancelamento incorporado.

Eu senti a Task.Delay()tarefa e CancellationTokenSourcenas outras respostas um pouco demais para o meu caso de uso em um loop restrito de rede.

E embora o método Crafting a Task.TimeoutAfter de Joe Hoag nos blogs do MSDN tenha sido inspirador, eu estava um pouco cansado de usar o TimeoutExceptioncontrole de fluxo pelo mesmo motivo acima, porque os tempos limite são esperados com mais frequência do que não.

Então eu fui com isso, que também lida com as otimizações mencionadas no blog:

public static async Task<bool> BeforeTimeout(this Task task, int millisecondsTimeout)
{
    if (task.IsCompleted) return true;
    if (millisecondsTimeout == 0) return false;

    if (millisecondsTimeout == Timeout.Infinite)
    {
        await Task.WhenAll(task);
        return true;
    }

    var tcs = new TaskCompletionSource<object>();

    using (var timer = new Timer(state => ((TaskCompletionSource<object>)state).TrySetCanceled(), tcs,
        millisecondsTimeout, Timeout.Infinite))
    {
        return await Task.WhenAny(task, tcs.Task) == task;
    }
}

Um exemplo de caso de uso é o seguinte:

var receivingTask = conn.ReceiveAsync(ct);

while (!await receivingTask.BeforeTimeout(keepAliveMilliseconds))
{
    // Send keep-alive
}

// Read and do something with data
var data = await receivingTask;

Algumas variantes da resposta de Andrew Arnott:

1. Se você deseja aguardar uma tarefa existente e descobrir se ela foi concluída ou excedeu o tempo limite, mas não deseja cancelá-la se ocorrer o tempo limite:

   public static async Task<bool> TimedOutAsync(this Task task, int timeoutMilliseconds)
   {
       if (timeoutMilliseconds < 0 || (timeoutMilliseconds > 0 && timeoutMilliseconds < 100)) { throw new ArgumentOutOfRangeException(); }
   
       if (timeoutMilliseconds == 0) {
           return !task.IsCompleted; // timed out if not completed
       }
       var cts = new CancellationTokenSource();
       if (await Task.WhenAny( task, Task.Delay(timeoutMilliseconds, cts.Token)) == task) {
           cts.Cancel(); // task completed, get rid of timer
           await task; // test for exceptions or task cancellation
           return false; // did not timeout
       } else {
           return true; // did timeout
       }
   }

2. Se você deseja iniciar uma tarefa de trabalho e cancelar o trabalho se ocorrer o tempo limite:

   public static async Task<T> CancelAfterAsync<T>( this Func<CancellationToken,Task<T>> actionAsync, int timeoutMilliseconds)
   {
       if (timeoutMilliseconds < 0 || (timeoutMilliseconds > 0 && timeoutMilliseconds < 100)) { throw new ArgumentOutOfRangeException(); }
   
       var taskCts = new CancellationTokenSource();
       var timerCts = new CancellationTokenSource();
       Task<T> task = actionAsync(taskCts.Token);
       if (await Task.WhenAny(task, Task.Delay(timeoutMilliseconds, timerCts.Token)) == task) {
           timerCts.Cancel(); // task completed, get rid of timer
       } else {
           taskCts.Cancel(); // timer completed, get rid of task
       }
       return await task; // test for exceptions or task cancellation
   }

3. Se você já tiver uma tarefa criada que deseja cancelar se ocorrer um tempo limite:

   public static async Task<T> CancelAfterAsync<T>(this Task<T> task, int timeoutMilliseconds, CancellationTokenSource taskCts)
   {
       if (timeoutMilliseconds < 0 || (timeoutMilliseconds > 0 && timeoutMilliseconds < 100)) { throw new ArgumentOutOfRangeException(); }
   
       var timerCts = new CancellationTokenSource();
       if (await Task.WhenAny(task, Task.Delay(timeoutMilliseconds, timerCts.Token)) == task) {
           timerCts.Cancel(); // task completed, get rid of timer
       } else {
           taskCts.Cancel(); // timer completed, get rid of task
       }
       return await task; // test for exceptions or task cancellation
   }

Outro comentário: essas versões cancelarão o cronômetro se o tempo limite não ocorrer, portanto, várias chamadas não farão com que os cronômetros se acumulem.

sjb

Estou recombuindo as idéias de algumas outras respostas aqui e essa resposta em outro thread em um método de extensão no estilo Try. Isso tem um benefício se você deseja um método de extensão, evitando uma exceção após o tempo limite.

public static async Task<bool> TryWithTimeoutAfter<TResult>(this Task<TResult> task,
    TimeSpan timeout, Action<TResult> successor)
{

    using var timeoutCancellationTokenSource = new CancellationTokenSource();
    var completedTask = await Task.WhenAny(task, Task.Delay(timeout, timeoutCancellationTokenSource.Token))
                                  .ConfigureAwait(continueOnCapturedContext: false);

    if (completedTask == task)
    {
        timeoutCancellationTokenSource.Cancel();

        // propagate exception rather than AggregateException, if calling task.Result.
        var result = await task.ConfigureAwait(continueOnCapturedContext: false);
        successor(result);
        return true;
    }
    else return false;        
}     

async Task Example(Task<string> task)
{
    string result = null;
    if (await task.TryWithTimeoutAfter(TimeSpan.FromSeconds(1), r => result = r))
    {
        Console.WriteLine(result);
    }
}    

Definitivamente não faça isso, mas é uma opção se ... Não consigo pensar em um motivo válido.

((CancellationTokenSource)cancellationToken.GetType().GetField("m_source",
    System.Reflection.BindingFlags.NonPublic |
    System.Reflection.BindingFlags.Instance
).GetValue(cancellationToken)).Cancel();