如何確保任務中的循環至少運行一次

Question

假設我有一個名為Scheduler的類，其中包含一個<UserId, Task>的Dictionary ，該任務不斷循環並使用來自數據庫的信息更新帶有用戶<UserId, Schedule>日程表的內部字典，即我想保留信息實時更新。

我想在Scheduler類GetScheduleForUser上有一個方法，它檢查是否有該用戶的任務，如果沒有，它將創建任務等待直到它完成，然后檢索該用戶的Schedules （延遲加載它）。

我的問題是，在任務的第一次迭代后，我將有一個可用的時間表，我可以只檢索時間表......沒問題但是對於第一次迭代我需要等到任務完成至少一次才能檢索日程安排。

我可以啟動任務並創建一個while循環，直到第一次循環完成時設置某個標志，但在我看來，有一種更好的方法，它只對第一次迭代有用。 之后，計划將始終可用，我將不需要該功能。

有沒有人有一個干凈的方法來完成這個？

Answer 1

我能想到的最好的解決方案是使用TaskCompletionSource ，Eser在他的評論中提到了這一點。 這是一個粗略的代碼示例，包含許多控制台輸出，以便更容易地遵循它正在做的事情。 我還在Scheduler calss和CancellationTokenSource字典中添加了IDisposable ，這樣當你完成Scheduler時，它就可以停止所有的任務。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

public class Program
{
    // Helper property to simplify console output
    public static string TimeString { get { return DateTime.Now.ToString("mm:ss.fff"); } }

    public static void Main(string[] args)
    {
        using (var scheduler = new Scheduler())
        {
            var userID = "1";

            Console.WriteLine(TimeString + " Main: Getting schedule for first time...");
            var sched1 = scheduler.GetScheduleForUser(userID);
            Console.WriteLine(TimeString + " Main: Got schedule: " + sched1);

            Console.WriteLine(TimeString + " Main: Waiting 2 seconds...");
            System.Threading.Thread.Sleep(2000);

            Console.WriteLine(TimeString + " Main: Getting schedule for second time...");
            var sched2 = scheduler.GetScheduleForUser(userID);
            Console.WriteLine(TimeString + " Main: Got schedule: " + sched2);
        }

        Console.WriteLine();
        Console.WriteLine("Press any key to end . . .");
        Console.ReadKey();
    }
}

public class Scheduler : IDisposable
{
    // Helper property to simplify console output
    public static string TimeString { get { return DateTime.Now.ToString("mm:ss.fff"); } }

    private Dictionary<string, Task> TasksDictionary { get; set; }
    private Dictionary<string, TaskCompletionSource<bool>> TaskCompletionSourcesDictionary { get; set; }
    private Dictionary<string, CancellationTokenSource> CancellationTokenSourcesDictionary { get; set; }
    private Dictionary<string, string> SchedulesDictionary { get; set; }

    public Scheduler()
    {
        TasksDictionary = new Dictionary<string, Task>();
        TaskCompletionSourcesDictionary = new Dictionary<string, TaskCompletionSource<bool>>();
        CancellationTokenSourcesDictionary = new Dictionary<string, CancellationTokenSource>();
        SchedulesDictionary = new Dictionary<string, string>();
    }

    public void Dispose()
    {
        if (TasksDictionary != null)
        {
            if (CancellationTokenSourcesDictionary != null)
            {
                foreach (var tokenSource in CancellationTokenSourcesDictionary.Values)
                    tokenSource.Cancel();

                Task.WaitAll(TasksDictionary.Values.ToArray(), 10000);

                CancellationTokenSourcesDictionary = null;
            }

            TasksDictionary = null;
        }

        CancellationTokenSourcesDictionary = null;
        SchedulesDictionary = null;
    }

    public string GetScheduleForUser(string userID)
    {
        // There's already a schedule, so get it
        if (SchedulesDictionary.ContainsKey(userID))
        {
            Console.WriteLine(TimeString + "     GetSchedule: Already had schedule for user " + userID);
            return SchedulesDictionary[userID];
        }

        // If there's no task yet, start one
        if (!TasksDictionary.ContainsKey(userID))
        {
            Console.WriteLine(TimeString + "     GetSchedule: Starting task for user " + userID);
            var tokenSource = new CancellationTokenSource();
            var token = tokenSource.Token;
            TaskCompletionSourcesDictionary.Add(userID, new TaskCompletionSource<bool>());
            var task = (new TaskFactory()).StartNew(() => GenerateSchedule(userID, token, TaskCompletionSourcesDictionary[userID]), token);
            TasksDictionary.Add(userID, task);
            CancellationTokenSourcesDictionary.Add(userID, tokenSource);
            Console.WriteLine(TimeString + "     GetSchedule: Started task for user " + userID);
        }

        // If there's a task running, wait for it
        Console.WriteLine(TimeString + "     GetSchedule: Waiting for first run to complete for user " + userID);
        var temp = TaskCompletionSourcesDictionary[userID].Task.Result;
        Console.WriteLine(TimeString + "     GetSchedule: First run complete for user " + userID);

        return SchedulesDictionary.ContainsKey(userID) ? SchedulesDictionary[userID] : "null";
    }

    private void GenerateSchedule(string userID, CancellationToken token, TaskCompletionSource<bool> tcs)
    {
        Console.WriteLine(TimeString + "         Task: Starting task for userID " + userID);

        bool firstRun = true;
        while (!token.IsCancellationRequested)
        {
            // Simulate work while building schedule
            if (token.WaitHandle.WaitOne(1000))
                break;

            // Update schedule
            SchedulesDictionary[userID] = "Schedule set at " + DateTime.Now.ToShortTimeString();
            Console.WriteLine(TimeString + "         Task: Updated schedule for userID " + userID);

            // If this was the first run, set the result for the TaskCompletionSource
            if (firstRun)
            {
                tcs.SetResult(true);
                firstRun = false;
            }
        }

        Console.WriteLine(TimeString + "         Task: Ended task for userID " + userID);
    }
}

這是一個顯示它在行動的小提琴 ： .NET Fiddle