System.Threading.Timerのタスクベースの置換はありますか？
私は.Net 4.0のタスクを初めて使用し、タスクベースのタイマーの置き換えまたは実装と思われるものを見つけることができませんでした。定期的なタスク。そのようなことはありますか？
更新私は、「タイマー」機能を子タスクを持つタスクはすべてCancellationTokenを利用し、タスクを返して以降のタスクステップに参加できるようにします。
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);
}
4.5に依存しますが、これは機能します。
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);
}
}
もちろん、引数を取る汎用バージョンを追加することもできます。これは、実際にはTask.Delayがタイマーの期限切れをタスク完了ソースとして使用しているため、他の推奨されるアプローチに似ています。
[〜＃〜] update [〜＃〜]私は 以下の回答にマーク これが「回答」として十分に古いため、async/awaitパターンを使用する必要があります。これをもう投票する必要はありません。笑
エイミーが答えたように、タスクベースの定期的/タイマーの実装はありません。ただし、元の更新に基づいて、これを非常に有用なものに進化させ、生産テストを実施しました。私が共有すると思った：
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();
}
}
}
出力：
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 . . .
正確にはSystem.Threading.Tasksにはありませんが、Reactive Extensionsライブラリの Observable.Timer （またはより単純な Observable.Interval ）がおそらく探しているものですために。
これまで、スレッドタイマーの代わりに、循環CPUにバインドされたバックグラウンド作業にLongRunning TPLタスクを使用しました。
- tPLタスクはキャンセルをサポートします
- スレッドタイマーは、プログラムがシャットダウンしている間に別のスレッドを開始し、破棄されたリソースに問題を引き起こす可能性があります。
- オーバーランの可能性：スレッドタイマーは、予期しない長い作業のために前のスレッドがまだ処理されている間に別のスレッドを開始する可能性があります（タイマーを停止して再起動することで防止できます）
ただし、TPLソリューションは常に、次のアクション（ほとんどの場合）を待機している間は不要な専用スレッドを要求します。提案されたジェフのソリューションを使用して、バックグラウンドでCPUバインドの循環作業を実行します。これは、スケーラビリティに優れた作業が必要な場合（特に間隔が大きい場合）にスレッドプールスレッドのみが必要になるためです。
それを達成するために、4つの適応策を提案します。
ConfigureAwait(false)をTask.Delay()に追加して、スレッドプールスレッドでdoWorkアクションを実行します。それ以外の場合、doWorkは呼び出しスレッドで実行されますが、並列処理のアイデア- TaskCanceledExceptionをスローしてキャンセルパターンに固執します（まだ必要ですか？）
- CancellationTokenを
doWorkに転送して、タスクをキャンセルできるようにします - タイプオブジェクトのパラメーターを追加して、タスク状態情報（TPLタスクなど）を提供します。
ポイント2についてはわかりませんが、async awaitはTaskCanceledExecptionを必要としますか、それともベストプラクティスですか？
_ 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);
}
_提案されたソリューションへのコメントをお願いします...
更新2016-8-
上記の解決策は、すぐにdoWork()を呼び出しませんが、await Task.Delay().ConfigureAwait(false)のスレッド切り替えを実現するためにdoWork()で始まります。以下の解決策は、最初のdoWork()呼び出しをTask.Run()でラップして待機することにより、この問題を解決します。
以下は、キャンセル可能な循環作業を実行し、（TPLソリューションと比較して）スケーラブルな_Threading.Timer_の改良されたasync\await置換です。次のアクションを待機している間、スレッドを占有しないためです。
タイマーとは異なり、待機時間（period）は一定であり、サイクル時間ではありません。サイクルタイムは、待機時間とdoWork()の持続時間の合計であり、変化する可能性があります。
_ 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);
}
_同期メソッドから繰り返し非同期タスクをトリガーする必要がありました。
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);
}
}
}
これは、Jeffの答えを修正したものです。 Func<Task>また、次の遅延の期間からタスクの実行時間を差し引くことにより、期間が実行される頻度であることを確認します。
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}");
}
}
同様の問題にぶつかり、タイマーで完了するタスクの一連を返すTaskTimerクラスを作成しました： https://github.com/ikriv/tasktimer/ 。
using (var timer = new TaskTimer(1000).Start())
{
// Call DoStuff() every second
foreach (var task in timer)
{
await task;
DoStuff();
}
}