Có thay thế dựa trên Tác vụ cho System.Threading.Timer không?

Question

Tôi mới sử dụng các tác vụ của .Net 4.0 và tôi không thể tìm thấy những gì tôi nghĩ là thay thế dựa trên Tác vụ hoặc triển khai Bộ hẹn giờ, ví dụ: một nhiệm vụ định kỳ. Có một điều như vậy?

Cập nhật tôi đến với những gì tôi nghĩ là một giải pháp cho nhu cầu của tôi mà là để quấn "Timer" chức năng bên trong một công tác với nhiệm vụ con tất cả lợi dụng việc CancellationToken và trả về nhiệm vụ được có thể tham gia các bước Nhiệm vụ tiếp theo.

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

Answer 1

Nó phụ thuộc vào 4.5, nhưng công trình này.

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

Rõ ràng bạn cũng có thể thêm phiên bản chung cũng có đối số. Điều này thực sự tương tự như các phương pháp tiếp cận được đề xuất khác kể từ dưới Task.Delay mui xe đang sử dụng hết hạn bộ hẹn giờ làm nguồn hoàn thành nhiệm vụ.

Answer 2

Nó không phải chính xác trong System.Threading.Tasks, nhưng Observable.Timer (hoặc đơn giản hơn Observable.Interval) từ thư viện phản Extensions có lẽ là những gì bạn đang tìm kiếm.

Answer 3

CẬP NHẬT Tôi marking the answer below là "câu trả lời" vì đây là đủ tuổi bây giờ mà chúng ta nên sử dụng async/chờ đợi mẫu. Không cần phải downvote nữa. LOL

---

Như Amy đã trả lời, không có công việc định kỳ dựa trên giờ/giờ. Tuy nhiên, dựa trên UPDATE ban đầu của tôi, chúng tôi đã phát triển điều này thành một cái gì đó khá hữu ích và sản xuất thử nghiệm. Nghĩ tôi sẽ chia sẻ:

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

Output:

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 . . . 

Answer 4

Cho đến bây giờ tôi sử dụng một nhiệm vụ LongRunning TPL cho CPU cyclic ràng buộc công việc nền thay vì bộ đếm thời gian luồng, vì:

• nhiệm vụ TPL hỗ trợ hủy
• bộ đếm thời gian luồng có thể bắt đầu một chủ đề trong khi programm tắt nguồn gây ra các vấn đề có thể xảy ra với các tài nguyên được xử lý
• cơ hội bị tràn: bộ đếm luồng có thể bắt đầu một luồng khác trong khi trước đó vẫn đang được xử lý do công việc lâu dài bất ngờ (tôi biết, nó có thể được ngăn chặn bằng cách dừng và khởi động lại bộ hẹn giờ)

Tuy nhiên, giải pháp TPL luôn xác nhận một chuỗi chuyên dụng không cần thiết trong khi chờ hành động tiếp theo (phần lớn thời gian). Tôi muốn sử dụng giải pháp được đề xuất của Jeff để thực hiện công việc cyclic CPU bị ràng buộc trên nền bởi vì nó chỉ cần một thread threadpool khi có công việc để làm đó là tốt hơn cho khả năng mở rộng (đặc biệt là khi khoảng thời gian là lớn).

Để đạt được điều đó, tôi sẽ đề nghị 4 adaptions:

1. Thêm ConfigureAwait(false) đến Task.Delay() để thực hiện doWork hành động trên một sợi bơi thread, nếu không doWork sẽ được thực hiện trên các thread kêu gọi mà không phải là ý tưởng song song
2. Stick với mẫu hủy bằng cách ném một TaskCanceledException (vẫn còn cần thiết?)
3. Chuyển tiếp các CancellationToken để doWork để kích hoạt nó để hủy bỏ nhiệm vụ
4. Thêm một tham số của loại đối tượng để cung cấp thông tin trạng thái công việc (như một nhiệm vụ TPL)

Về điểm 2 Tôi không chắc chắn, không async chờ đợi vẫn đòi hỏi sự TaskCanceledExecption hoặc là nó chỉ thực hành tốt nhất?

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

Xin vui lòng cho ý kiến ​​của bạn với các giải pháp đề xuất ...

Cập nhật 2016-8-30

Các giải pháp trên không ngay lập tức gọi doWork() nhưng bắt đầu với await Task.Delay().ConfigureAwait(false) để đạt được công tắc chủ đề cho doWork(). Giải pháp dưới đây khắc phục vấn đề này bằng cách gói cuộc gọi doWork() đầu tiên vào số Task.Run() và chờ nó.

Dưới đây là thay thế async \ await đang chờ cải tiến cho Threading.Timer thực hiện công việc tuần hoàn có thể hủy và có thể mở rộng (so với giải pháp TPL) vì nó không chiếm bất kỳ chủ đề nào trong khi chờ hành động tiếp theo.

Lưu ý rằng ngược lại với Bộ hẹn giờ, thời gian chờ (period) là không đổi và không phải là thời gian chu kỳ; thời gian chu kỳ là tổng thời gian chờ đợi và thời lượng doWork() có thể thay đổi.

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

Answer 5

Tôi chạy vào một vấn đề tương tự và viết một lớp TaskTimer mà trả về một seris của nhiệm vụ mà đầy đủ về timer: https://github.com/ikriv/tasktimer/.

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