Korrekter Weg, um den Start einer Aufgabe zu verzögern

Möchte ich so planen Sie einen task zu starten, in x-ms und in der Lage sein, um Sie abzubrechen, bevor es beginnt (oder erst am Anfang der Aufgabe).

Der erste Versuch wäre so etwas wie

var _cancelationTokenSource = new CancellationTokenSource();

var token = _cancelationTokenSource.Token;
Task.Factory.StartNew(() =>
    {
        token.ThrowIfCancellationRequested();
        Thread.Sleep(100);
        token.ThrowIfCancellationRequested();
    }).ContinueWith(t =>
    {
        token.ThrowIfCancellationRequested();
        DoWork();
        token.ThrowIfCancellationRequested();
    }, token);

Aber ich fühle mich wie es sollte eine bessere Weise, als wäre dies ein thread, während in den Schlaf, während dessen könnte es abgebrochen werden.

Was sind meine anderen Optionen?

InformationsquelleAutor der Frage Bruno Lopes | 2011-02-14

  1. 28

    Wie Damien_The_Unbeliever erwähntdie Async CTP umfasst Task.Delay. Zum Glück haben wir Reflektor:

    public static class TaskEx
{
    static readonly Task _sPreCompletedTask = GetCompletedTask();
    static readonly Task _sPreCanceledTask = GetPreCanceledTask();

    public static Task Delay(int dueTimeMs, CancellationToken cancellationToken)
    {
        if (dueTimeMs < -1)
            throw new ArgumentOutOfRangeException("dueTimeMs", "Invalid due time");
        if (cancellationToken.IsCancellationRequested)
            return _sPreCanceledTask;
        if (dueTimeMs == 0)
            return _sPreCompletedTask;

        var tcs = new TaskCompletionSource<object>();
        var ctr = new CancellationTokenRegistration();
        var timer = new Timer(delegate(object self)
        {
            ctr.Dispose();
            ((Timer)self).Dispose();
            tcs.TrySetResult(null);
        });
        if (cancellationToken.CanBeCanceled)
            ctr = cancellationToken.Register(delegate
                                                 {
                                                     timer.Dispose();
                                                     tcs.TrySetCanceled();
                                                 });

        timer.Change(dueTimeMs, -1);
        return tcs.Task;
    }

    private static Task GetPreCanceledTask()
    {
        var source = new TaskCompletionSource<object>();
        source.TrySetCanceled();
        return source.Task;
    }

    private static Task GetCompletedTask()
    {
        var source = new TaskCompletionSource<object>();
        source.TrySetResult(null);
        return source.Task;
    }
}

    InformationsquelleAutor der Antwort Ohad Schneider

  2. 19

    Da .NET 4.5 hat der jetzt veröffentlicht wurde, gibt es eine sehr einfache integrierte Weise zu verzögern, eine Aufgabe: benutzen Sie einfach Aufgabe.Delay(). hinter den kulissen, es verwendet die Implementierung, die ohadsc dekompiliert.

    InformationsquelleAutor der Antwort skolima

  3. 8

    Die richtige Antwort in der Zukunft wohl Task.Delay. Allerdings ist dies derzeit nur durch die Async CTP (und in der CTP-Version, es ist auf TaskEx eher als Aufgabe).

    Leider, weil es nur in CTP, gibt es nicht viele gute links zur Dokumentation für Sie.

    InformationsquelleAutor der Antwort Damien_The_Unbeliever

  4. 4

    Blick auf die TaskFactoryExtensions_Delayed in "Parallele Programmierung mit .NET 4 Proben".

    InformationsquelleAutor der Antwort jyoung

  5. 4

    Habe ich noch nicht getestet, aber hier ist ein first-pass-auf-wrapper-Methoden zum erstellen einer anfänglichen 'Delay' - Aufgabe oder fortsetzen nach einer Verzögerung. Wenn Sie Probleme feststellen, fühlen Sie sich frei, zu korrigieren.

        public static Task StartDelayTask(int delay, CancellationToken token)
    {
        var source = new TaskCompletionSource<Object>();
        Timer timer = null;

        timer = new Timer(s =>
        {
            source.TrySetResult(null);
            timer.Dispose();
        }, null, delay, -1);
        token.Register(() => source.TrySetCanceled());

        return source.Task;
    }

    public static Task ContinueAfterDelay
      (this Task task, 
           int delay, Action<Task> continuation, 
           CancellationToken token)
    {
        var source = new TaskCompletionSource<Object>();
        Timer timer = null;

        var startTimer = new Action<Task>(t =>
        {
            timer = new Timer(s =>
            {
                source.TrySetResult(null);
                timer.Dispose();
            },null,delay,-1);
        });

        task.ContinueWith
          (startTimer, 
           token, 
           TaskContinuationOptions.OnlyOnRanToCompletion, 
           TaskScheduler.Current);
        token.Register(() => source.TrySetCanceled());
        return source.Task.ContinueWith(continuation, token);
    }

    InformationsquelleAutor der Antwort Dan Bryant

  6. 3

    Können Sie Token.WaitHandle.WaitOne(int32 milliseconds) überlast-Methode geben Sie die Anzahl von Millisekunden zu warten, für Ihre Aufgabe. Aber wichtige Unterschied zwischen Thread.Sleep(xxx) und Token.WaitHandle.WaitOne(xxx), die später blockiert thread, bis die angegebene Zeit verstrichen oder das token freigegeben wurde.

    Hier ist ein Beispiel

    void Main()
{
    var tokenSource = new CancellationTokenSource();
    var token = tokenSource.Token;

    var task = Task.Factory.StartNew(() =>
    {
        //wait for 5 seconds or user hit Enter key cancel the task
        token.WaitHandle.WaitOne(5000);
        token.ThrowIfCancellationRequested();
        Console.WriteLine("Task started its work");
    });

    Console.WriteLine("Press 'Enter' key to cancel your task");

    Console.Read();

    tokenSource.Cancel();
}

    InformationsquelleAutor der Antwort Vlad Bezden

Schreibe einen Kommentar