Вот полностью проработанный пример, основанный на ответе с наибольшим количеством голосов:
int timeout = 1000;
var task = SomeOperationAsync();
if (await Task.WhenAny(task, Task.Delay(timeout)) == task) {
// task completed within timeout
} else {
// timeout logic
}
Основным преимуществом реализации в этом ответе является то, что дженерики были добавлены, поэтому функция (или задача) может возвращать значение. Это означает, что любая существующая функция может быть заключена в функцию тайм-аута, например ::10000
До:
int x = MyFunc();
После того, как:
// Throws a TimeoutException if MyFunc takes more than 1 second
int x = TimeoutAfter(MyFunc, TimeSpan.FromSeconds(1));
Для этого кода требуется .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();
}
}
}
}
Предостережения
Получив этот ответ, обычно не - это хорошая практика, когда в коде создаются исключения во время нормальной работы, если только вам абсолютно не нужно:
- Каждый раз, когда выдается исключение, это чрезвычайно тяжелая операция,
- Исключения могут замедлить ваш код в 100 и более раз, если исключения находятся в узком цикле.
Используйте этот код только в том случае, если вы абсолютно не можете изменить вызываемую функцию, поэтому время ожидания истекает после определенного TimeSpan.
Этот ответ действительно применим только при работе с библиотеками сторонних библиотек, в которых просто невозможно изменить рефакторинг для включения параметра времени ожидания.
Как написать надежный код
Если вы хотите написать надежный код, общее правило таково:
Каждая операция, которая потенциально может блокироваться на неопределенный срок, должна иметь тайм-аут.
Если вы не не соблюдаете это правило, ваш код в конечном итоге попадет в операцию, которая по какой-то причине не выполняется, затем он будет блокироваться на неопределенный срок, а ваше приложение просто навсегда зависло.
Если по истечении некоторого времени произошел разумный тайм-аут, то ваше приложение зависло бы в течение некоторого экстремального периода времени (например, 30 секунд), затем оно либо отобразило бы ошибку и продолжило бы работать, либо повторило попытку.