Gibt es einen aufgabenbasierten Ersatz für System.Threading.Timer?

Ich bin neu in den Aufgaben von .Net 4.0 und konnte nicht finden, was ich für einen aufgabenbasierten Ersatz oder die Implementierung eines Timers hielt, z. B. eine periodische Aufgabe. Gibt es so etwas?

Update Ich habe eine Lösung für meine Anforderungen gefunden, die darin besteht, die "Timer" -Funktionalität in eine Aufgabe mit untergeordneten Aufgaben zu packen, die alle das CancellationToken nutzen, und die Aufgabe zurückzugeben, um an weiteren Aufgabenschritten teilnehmen zu können.

public static Task StartPeriodicTask(Action action, int intervalInMilliseconds, int delayInMilliseconds, CancellationToken cancelToken)
{ 
    Action wrapperAction = () =>
    {
        if (cancelToken.IsCancellationRequested) { return; }

        action();
    };

    Action mainAction = () =>
    {
        TaskCreationOptions attachedToParent = TaskCreationOptions.AttachedToParent;

        if (cancelToken.IsCancellationRequested) { return; }

        if (delayInMilliseconds > 0)
            Thread.Sleep(delayInMilliseconds);

        while (true)
        {
            if (cancelToken.IsCancellationRequested) { break; }

            Task.Factory.StartNew(wrapperAction, cancelToken, attachedToParent, TaskScheduler.Current);

            if (cancelToken.IsCancellationRequested || intervalInMilliseconds == Timeout.Infinite) { break; }

            Thread.Sleep(intervalInMilliseconds);
        }
    };

    return Task.Factory.StartNew(mainAction, cancelToken);
}      

Es hängt von 4.5 ab, aber das funktioniert.

public class PeriodicTask
{
    public static async Task Run(Action action, TimeSpan period, CancellationToken cancellationToken)
    {
        while(!cancellationToken.IsCancellationRequested)
        {
            await Task.Delay(period, cancellationToken);

            if (!cancellationToken.IsCancellationRequested)
                action();
        }
     }

     public static Task Run(Action action, TimeSpan period)
     { 
         return Run(action, period, CancellationToken.None);
     }
}

Natürlich können Sie eine generische Version hinzufügen, die auch Argumente akzeptiert. Dies ähnelt tatsächlich anderen vorgeschlagenen Ansätzen, da Task.Delay unter der Haube einen Timer-Ablauf als Quelle für den Abschluss der Aufgabe verwendet.

UPDATE Ich markiere die Antwort unten als "Antwort", da diese jetzt alt genug ist, um das asynchrone / wartende Muster zu verwenden. Sie müssen dies nicht mehr ablehnen. LOL

Wie Amy antwortete, gibt es keine Tasked-basierte periodische / Timer-Implementierung. Basierend auf meinem ursprünglichen UPDATE haben wir dies jedoch zu etwas sehr Nützlichem entwickelt und die Produktion getestet. Ich dachte, ich würde teilen:

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

namespace ConsoleApplication7
{
    class Program
    {
        static void Main(string[] args)
        {
            Task perdiodicTask = PeriodicTaskFactory.Start(() =>
            {
                Console.WriteLine(DateTime.Now);
            }, intervalInMilliseconds: 2000, // fire every two seconds...
               maxIterations: 10);           // for a total of 10 iterations...

            perdiodicTask.ContinueWith(_ =>
            {
                Console.WriteLine("Finished!");
            }).Wait();
        }
    }

    /// <summary>
    /// Factory class to create a periodic Task to simulate a <see cref="System.Threading.Timer"/> using <see cref="Task">Tasks.</see>
    /// </summary>
    public static class PeriodicTaskFactory
    {
        /// <summary>
        /// Starts the periodic task.
        /// </summary>
        /// <param name="action">The action.</param>
        /// <param name="intervalInMilliseconds">The interval in milliseconds.</param>
        /// <param name="delayInMilliseconds">The delay in milliseconds, i.e. how long it waits to kick off the timer.</param>
        /// <param name="duration">The duration.
        /// <example>If the duration is set to 10 seconds, the maximum time this task is allowed to run is 10 seconds.</example></param>
        /// <param name="maxIterations">The max iterations.</param>
        /// <param name="synchronous">if set to <c>true</c> executes each period in a blocking fashion and each periodic execution of the task
        /// is included in the total duration of the Task.</param>
        /// <param name="cancelToken">The cancel token.</param>
        /// <param name="periodicTaskCreationOptions"><see cref="TaskCreationOptions"/> used to create the task for executing the <see cref="Action"/>.</param>
        /// <returns>A <see cref="Task"/></returns>
        /// <remarks>
        /// Exceptions that occur in the <paramref name="action"/> need to be handled in the action itself. These exceptions will not be 
        /// bubbled up to the periodic task.
        /// </remarks>
        public static Task Start(Action action,
                                 int intervalInMilliseconds = Timeout.Infinite,
                                 int delayInMilliseconds = 0,
                                 int duration = Timeout.Infinite,
                                 int maxIterations = -1,
                                 bool synchronous = false,
                                 CancellationToken cancelToken = new CancellationToken(),
                                 TaskCreationOptions periodicTaskCreationOptions = TaskCreationOptions.None)
        {
            Stopwatch stopWatch = new Stopwatch();
            Action wrapperAction = () =>
            {
                CheckIfCancelled(cancelToken);
                action();
            };

            Action mainAction = () =>
            {
                MainPeriodicTaskAction(intervalInMilliseconds, delayInMilliseconds, duration, maxIterations, cancelToken, stopWatch, synchronous, wrapperAction, periodicTaskCreationOptions);
            };

            return Task.Factory.StartNew(mainAction, cancelToken, TaskCreationOptions.LongRunning, TaskScheduler.Current);
        }

        /// <summary>
        /// Mains the periodic task action.
        /// </summary>
        /// <param name="intervalInMilliseconds">The interval in milliseconds.</param>
        /// <param name="delayInMilliseconds">The delay in milliseconds.</param>
        /// <param name="duration">The duration.</param>
        /// <param name="maxIterations">The max iterations.</param>
        /// <param name="cancelToken">The cancel token.</param>
        /// <param name="stopWatch">The stop watch.</param>
        /// <param name="synchronous">if set to <c>true</c> executes each period in a blocking fashion and each periodic execution of the task
        /// is included in the total duration of the Task.</param>
        /// <param name="wrapperAction">The wrapper action.</param>
        /// <param name="periodicTaskCreationOptions"><see cref="TaskCreationOptions"/> used to create a sub task for executing the <see cref="Action"/>.</param>
        private static void MainPeriodicTaskAction(int intervalInMilliseconds,
                                                   int delayInMilliseconds,
                                                   int duration,
                                                   int maxIterations,
                                                   CancellationToken cancelToken,
                                                   Stopwatch stopWatch,
                                                   bool synchronous,
                                                   Action wrapperAction,
                                                   TaskCreationOptions periodicTaskCreationOptions)
        {
            TaskCreationOptions subTaskCreationOptions = TaskCreationOptions.AttachedToParent | periodicTaskCreationOptions;

            CheckIfCancelled(cancelToken);

            if (delayInMilliseconds > 0)
            {
                Thread.Sleep(delayInMilliseconds);
            }

            if (maxIterations == 0) { return; }

            int iteration = 0;

            ////////////////////////////////////////////////////////////////////////////
            // using a ManualResetEventSlim as it is more efficient in small intervals.
            // In the case where longer intervals are used, it will automatically use 
            // a standard WaitHandle....
            // see http://msdn.microsoft.com/en-us/library/vstudio/5hbefs30(v=vs.100).aspx
            using (ManualResetEventSlim periodResetEvent = new ManualResetEventSlim(false))
            {
                ////////////////////////////////////////////////////////////
                // Main periodic logic. Basically loop through this block
                // executing the action
                while (true)
                {
                    CheckIfCancelled(cancelToken);

                    Task subTask = Task.Factory.StartNew(wrapperAction, cancelToken, subTaskCreationOptions, TaskScheduler.Current);

                    if (synchronous)
                    {
                        stopWatch.Start();
                        try
                        {
                            subTask.Wait(cancelToken);
                        }
                        catch { /* do not let an errant subtask to kill the periodic task...*/ }
                        stopWatch.Stop();
                    }

                    // use the same Timeout setting as the System.Threading.Timer, infinite timeout will execute only one iteration.
                    if (intervalInMilliseconds == Timeout.Infinite) { break; }

                    iteration++;

                    if (maxIterations > 0 && iteration >= maxIterations) { break; }

                    try
                    {
                        stopWatch.Start();
                        periodResetEvent.Wait(intervalInMilliseconds, cancelToken);
                        stopWatch.Stop();
                    }
                    finally
                    {
                        periodResetEvent.Reset();
                    }

                    CheckIfCancelled(cancelToken);

                    if (duration > 0 && stopWatch.ElapsedMilliseconds >= duration) { break; }
                }
            }
        }

        /// <summary>
        /// Checks if cancelled.
        /// </summary>
        /// <param name="cancelToken">The cancel token.</param>
        private static void CheckIfCancelled(CancellationToken cancellationToken)
        {
            if (cancellationToken == null)
                throw new ArgumentNullException("cancellationToken");

            cancellationToken.ThrowIfCancellationRequested();
        }
    }
}

Ausgabe:

2/18/2013 4:17:13 PM
2/18/2013 4:17:15 PM
2/18/2013 4:17:17 PM
2/18/2013 4:17:19 PM
2/18/2013 4:17:21 PM
2/18/2013 4:17:23 PM
2/18/2013 4:17:25 PM
2/18/2013 4:17:27 PM
2/18/2013 4:17:29 PM
2/18/2013 4:17:31 PM
Finished!
Press any key to continue . . .

Es ist nicht genau in System.Threading.Tasks, aber Observable.Timer(oder einfacher Observable.Interval) aus der Reactive Extensions-Bibliothek ist wahrscheinlich das, wonach Sie suchen.

Bisher habe ich anstelle des Threading-Timers eine LongRunning-TPL-Task für zyklische CPU-gebundene Hintergrundarbeiten verwendet, weil:

• Die TPL-Task unterstützt das Abbrechen
• Der Threading-Timer könnte einen anderen Thread starten, während das Programm heruntergefahren wird, was zu möglichen Problemen mit den verfügbaren Ressourcen führen kann
• Überlaufgefahr: Der Threading-Timer könnte aufgrund unerwartet langer Arbeit einen anderen Thread starten, während der vorherige noch verarbeitet wird (ich weiß, dies kann durch Anhalten und Neustarten des Timers verhindert werden.)

Die TPL-Lösung beansprucht jedoch immer einen dedizierten Thread, der nicht erforderlich ist, während auf die nächste Aktion gewartet wird (was meistens der Fall ist). Ich möchte die vorgeschlagene Lösung von Jeff verwenden, um CPU-gebundene zyklische Arbeit im Hintergrund auszuführen, da nur dann ein Threadpool-Thread benötigt wird, wenn Arbeit zu erledigen ist, die für die Skalierbarkeit besser ist (insbesondere wenn die Intervallperiode groß ist).

Um dies zu erreichen, würde ich 4 Anpassungen vorschlagen:

1. Fügen Sie hinzu ConfigureAwait(false), Task.Delay()um die doWorkAktion ansonsten für einen Thread-Pool-Thread auszuführendoWork wird sie für den aufrufenden Thread ausgeführt, was nicht die Idee der Parallelität ist
2. Halten Sie sich an das Stornierungsmuster, indem Sie eine TaskCanceledException auslösen (noch erforderlich?)
3. Leiten Sie das CancellationToken an weiter doWork , damit es die Aufgabe abbrechen kann
4. Fügen Sie einen Parameter vom Typ Objekt hinzu, um Informationen zum Aufgabenstatus bereitzustellen (z. B. eine TPL-Aufgabe).

Zu Punkt 2 Ich bin mir nicht sicher, ob für das asynchrone Warten noch die TaskCanceledExecption erforderlich ist, oder handelt es sich nur um eine bewährte Methode?

    public static async Task Run(Action<object, CancellationToken> doWork, object taskState, TimeSpan period, CancellationToken cancellationToken)
    {
        do
        {
            await Task.Delay(period, cancellationToken).ConfigureAwait(false);
            cancellationToken.ThrowIfCancellationRequested();
            doWork(taskState, cancellationToken);
        }
        while (true);
    }

Bitte geben Sie Ihre Kommentare zu der vorgeschlagenen Lösung ...

Update 30.08.2016

Die obige Lösung ruft nicht sofort auf, doWork()sondern beginnt mit await Task.Delay().ConfigureAwait(false)dem Erreichen des Thread-Wechsels für doWork(). Die folgende Lösung überwindet dieses Problem, indem der erste doWork()Anruf in a eingeschlossen Task.Run()und abgewartet wird.

Im Folgenden finden Sie die verbesserte asynchrone \ wait-Ersetzung Threading.Timer, die abbrechbare zyklische Arbeiten ausführt und skalierbar ist (im Vergleich zur TPL-Lösung), da sie beim Warten auf die nächste Aktion keinen Thread belegt.

Beachten Sie, dass im Gegensatz zum Timer die Wartezeit ( period) konstant ist und nicht die Zykluszeit. Die Zykluszeit ist die Summe der Wartezeit und deren Dauer doWork()variieren kann.

    public static async Task Run(Action<object, CancellationToken> doWork, object taskState, TimeSpan period, CancellationToken cancellationToken)
    {
        await Task.Run(() => doWork(taskState, cancellationToken), cancellationToken).ConfigureAwait(false);
        do
        {
            await Task.Delay(period, cancellationToken).ConfigureAwait(false);
            cancellationToken.ThrowIfCancellationRequested();
            doWork(taskState, cancellationToken);
        }
        while (true);
    }

Ich musste die wiederkehrenden asynchronen Aufgaben von einer synchronen Methode auslösen.

public static class PeriodicTask
{
    public static async Task Run(
        Func<Task> action,
        TimeSpan period,
        CancellationToken cancellationToken = default(CancellationToken))
    {
        while (!cancellationToken.IsCancellationRequested)
        {

            Stopwatch stopwatch = Stopwatch.StartNew();

            if (!cancellationToken.IsCancellationRequested)
                await action();

            stopwatch.Stop();

            await Task.Delay(period - stopwatch.Elapsed, cancellationToken);
        }
    }
}

Dies ist eine Adaption von Jeffs Antwort. Es wird geändert, um a aufzunehmen. Func<Task> Außerdem wird sichergestellt, dass der Zeitraum wie oft ausgeführt wird, indem die Laufzeit der Aufgabe von dem Zeitraum für die nächste Verzögerung abgezogen wird.

class Program
{
    static void Main(string[] args)
    {
        PeriodicTask
            .Run(GetSomething, TimeSpan.FromSeconds(3))
            .GetAwaiter()
            .GetResult();
    }

    static async Task GetSomething()
    {
        await Task.Delay(TimeSpan.FromSeconds(1));
        Console.WriteLine($"Hi {DateTime.UtcNow}");
    }
}

Ich bin auf ein ähnliches Problem TaskTimergestoßen und habe eine Klasse geschrieben, die eine Reihe von Aufgaben zurückgibt, die auf dem Timer ausgeführt werden: https://github.com/ikriv/tasktimer/ .

using (var timer = new TaskTimer(1000).Start())
{
    // Call DoStuff() every second
    foreach (var task in timer)
    {
        await task;
        DoStuff();
    }
}

static class Helper
{
    public async static Task ExecuteInterval(Action execute, int millisecond, IWorker worker)
    {
        while (worker.Worked)
        {
            execute();

            await Task.Delay(millisecond);
        }
    }
}


interface IWorker
{
    bool Worked { get; }
}

Einfach...