Warten Sie asynchron, bis Task <T> mit Timeout abgeschlossen ist

Ich möchte auf eine warten Aufgabe <T> mit einigen speziellen Regeln abgeschlossen ist: Wenn sie nach X Millisekunden nicht abgeschlossen wurde, möchte ich dem Benutzer eine Nachricht anzeigen. Und wenn es nach Y Millisekunden nicht abgeschlossen ist, möchte ich automatisch eine Stornierung beantragen .

Ich kann Task.ContinueWith verwenden, um asynchron auf den Abschluss der Aufgabe zu warten (dh eine Aktion zu planen, die ausgeführt werden soll, wenn die Aufgabe abgeschlossen ist), aber dies erlaubt keine Angabe eines Zeitlimits. Ich kann Task.Wait verwenden, um synchron zu warten, bis die Aufgabe mit einem Timeout abgeschlossen ist, aber das blockiert meinen Thread. Wie kann ich asynchron warten, bis die Aufgabe mit einer Zeitüberschreitung abgeschlossen ist?

Wie wäre es damit:

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

Und hier ist ein großartiger Blog-Beitrag "Crafting a Task.TimeoutAfter Method" (vom MS Parallel Library-Team) mit weiteren Informationen zu solchen Dingen .

Ergänzung : Auf Anfrage eines Kommentars zu meiner Antwort finden Sie hier eine erweiterte Lösung, die die Bearbeitung von Stornierungen umfasst. Beachten Sie, dass das Übergeben der Stornierung an die Aufgabe und den Timer bedeutet, dass es mehrere Möglichkeiten gibt, die Stornierung in Ihrem Code zu erfahren. Sie sollten sicher sein, dass Sie alle Stornierungen testen und sicher sein, dass Sie alle ordnungsgemäß verarbeiten. Überlassen Sie nicht dem Zufall verschiedene Kombinationen und hoffen Sie, dass Ihr Computer zur Laufzeit das Richtige tut.

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
}

Hier ist eine Version der Erweiterungsmethode, die das Abbrechen des Zeitlimits beinhaltet, wenn die ursprüngliche Aufgabe abgeschlossen ist, wie von Andrew Arnott in einem Kommentar zu seiner Antwort vorgeschlagen .

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.");
        }
    }
}

Sie können Task.WaitAnydamit die erste von mehreren Aufgaben abwarten.

Sie können zwei zusätzliche Aufgaben erstellen (die nach den angegebenen Zeitüberschreitungen abgeschlossen werden) und dann WaitAnywarten, bis die Aufgaben abgeschlossen sind. Wenn die zuerst erledigte Aufgabe Ihre "Arbeits" -Aufgabe ist, sind Sie fertig. Wenn es sich bei der zuerst abgeschlossenen Aufgabe um eine Zeitüberschreitungsaufgabe handelt, können Sie auf die Zeitüberschreitung reagieren (z. B. Stornierung der Anforderung).

Was ist mit so etwas?

    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();
    }

Sie können die Option Task.Wait verwenden, ohne den Hauptthread mit einer anderen Task zu blockieren.

Hier ist ein vollständig ausgearbeitetes Beispiel, das auf der am besten bewerteten Antwort basiert:

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

Der Hauptvorteil der Implementierung in dieser Antwort besteht darin, dass Generika hinzugefügt wurden, sodass die Funktion (oder Aufgabe) einen Wert zurückgeben kann. Dies bedeutet, dass jede vorhandene Funktion in eine Timeout-Funktion eingeschlossen werden kann, z.

Vor:

int x = MyFunc();

Nach:

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

Dieser Code erfordert .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();
            }
        }
    }
}

Vorsichtsmaßnahmen

Nachdem Sie diese Antwort gegeben haben, ist es im Allgemeinen keine gute Praxis, während des normalen Betriebs Ausnahmen in Ihren Code zu werfen, es sei denn, Sie müssen unbedingt:

• Jedes Mal, wenn eine Ausnahme ausgelöst wird, ist dies eine extrem schwere Operation.
• Ausnahmen können Ihren Code um den Faktor 100 oder mehr verlangsamen, wenn sich die Ausnahmen in einer engen Schleife befinden.

Verwenden Sie diesen Code nur, wenn Sie die aufgerufene Funktion absolut nicht ändern können, sodass nach einer bestimmten Zeit eine Zeitüberschreitung auftritt TimeSpan.

Diese Antwort gilt nur für Bibliotheksbibliotheken von Drittanbietern, die Sie einfach nicht umgestalten können, um einen Timeout-Parameter einzuschließen.

Wie schreibe ich robusten Code

Wenn Sie robusten Code schreiben möchten, lautet die allgemeine Regel:

Jede einzelne Operation, die möglicherweise auf unbestimmte Zeit blockiert werden kann, muss eine Zeitüberschreitung aufweisen.

Wenn Sie dies nicht tun diese Regel einhalten, wird Ihr Code möglicherweise einen Vorgang ausführen, der aus irgendeinem Grund fehlschlägt. Dann wird er auf unbestimmte Zeit blockiert und Ihre App ist gerade dauerhaft hängen geblieben.

Wenn nach einiger Zeit eine angemessene Zeitüberschreitung auftritt, bleibt Ihre App extrem lange hängen (z. B. 30 Sekunden). Dann wird entweder ein Fehler angezeigt und der fröhliche Weg fortgesetzt oder es wird erneut versucht.

Mit Stephen Clearys ausgezeichneter AsyncEx- Bibliothek können Sie Folgendes tun:

TimeSpan timeout = TimeSpan.FromSeconds(10);

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

TaskCanceledException wird im Falle einer Zeitüberschreitung ausgelöst.

Dies ist eine leicht verbesserte Version früherer Antworten.

• Zusätzlich zu Lawrences Antwort wird die ursprüngliche Aufgabe abgebrochen, wenn eine Zeitüberschreitung auftritt.
• Zusätzlich zu den Antwortvarianten 2 und 3 von sjb können Sie CancellationTokendie ursprüngliche Aufgabe bereitstellen , und wenn eine Zeitüberschreitung auftritt, erhalten Sie TimeoutExceptionstattdessen 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();
        }
    }
}

Verwendungszweck

InnerCallAsyncDie Fertigstellung kann lange dauern. CallAsyncschließt es mit einer Zeitüberschreitung ab.

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;
}

Verwenden Sie einen Timer , um die Nachricht und die automatische Stornierung zu verarbeiten. Wenn die Aufgabe abgeschlossen ist, rufen Sie Dispose für die Timer auf, damit sie niemals ausgelöst werden. Hier ist ein Beispiel; Ändern Sie taskDelay in 500, 1500 oder 2500, um die verschiedenen Fälle anzuzeigen:

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);
                }
            }
        }
    }
}

Außerdem bietet Async CTP eine TaskEx.Delay-Methode, mit der die Timer in Aufgaben für Sie eingeschlossen werden. Dies kann Ihnen mehr Kontrolle geben, um beispielsweise den TaskScheduler für die Fortsetzung festzulegen, wenn der Timer ausgelöst wird.

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;
}

Eine andere Möglichkeit, dieses Problem zu lösen, ist die Verwendung von Reactive Extensions:

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

Testen Sie oben mit dem folgenden Code in Ihrem Unit-Test, es funktioniert für mich

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);

Möglicherweise benötigen Sie den folgenden Namespace:

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;

Eine generische Version der obigen Antwort von @ Kevan unter Verwendung von Reactive Extensions.

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

Mit optionalem Scheduler:

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();
}

Übrigens: Wenn ein Timeout auftritt, wird eine Timeout-Ausnahme ausgelöst

Wenn Sie die Aufgabe mit einer BlockingCollection planen, kann der Produzent die möglicherweise lange laufende Aufgabe ausführen, und der Verbraucher kann die TryTake-Methode verwenden, in die ein Timeout- und Abbruchtoken integriert ist.

Ich fühlte die Task.Delay()Aufgabe und CancellationTokenSourcein den anderen Antworten ein bisschen viel für meinen Anwendungsfall in einer engen Netzwerkschleife.

Und obwohl Joe Hoags Crafting a Task.TimeoutAfter-Methode in MSDN-Blogs inspirierend war, war ich es ein wenig leid, sie zu verwendenTimeoutException aus dem gleichen Grund wie oben für die Flusskontrolle zu verwenden, da Timeouts häufiger erwartet werden als nicht.

Also habe ich mich dafür entschieden, das auch die im Blog erwähnten Optimierungen behandelt:

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;
    }
}

Ein Beispiel für einen Anwendungsfall ist folgender:

var receivingTask = conn.ReceiveAsync(ct);

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

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

Einige Varianten von Andrew Arnotts Antwort:

1. Wenn Sie auf eine vorhandene Aufgabe warten und herausfinden möchten, ob sie abgeschlossen oder abgelaufen ist, sie jedoch nicht abbrechen möchten, wenn das Zeitlimit auftritt:

   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. Wenn Sie eine Arbeitsaufgabe starten und die Arbeit abbrechen möchten, wenn das Zeitlimit auftritt:

   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. Wenn Sie bereits eine Aufgabe erstellt haben, die Sie abbrechen möchten, wenn eine Zeitüberschreitung auftritt:

   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
   }

Ein weiterer Kommentar: Diese Versionen brechen den Timer ab, wenn das Timeout nicht auftritt, sodass sich bei mehreren Anrufen keine Timer häufen.

sjb

Ich fasse die Ideen einiger anderer Antworten hier und diese Antwort in einem anderen Thread zu einer Erweiterungsmethode im Try-Stil zusammen. Dies hat einen Vorteil, wenn Sie eine Erweiterungsmethode wünschen und dennoch eine Ausnahme bei Zeitüberschreitung vermeiden möchten.

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);
    }
}    

Tun Sie dies auf keinen Fall, aber es ist eine Option, wenn ... mir kein gültiger Grund einfällt.

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