如何确保任务中的循环至少运行过一次

Question

假设我有一个名为Scheduler的类，它包含<UserId, Task>的Dictionary，Task会不断循环并使用数据库中的信息更新该用户<UserId, Schedule>的内部Dictionary和Schedules，即我希望实时更新信息。

我想在Scheduler类GetScheduleForUser上有一个方法，它检查是否有该用户的任务，如果没有，它将创建任务，直到它完成，然后检索该用户的Schedules（惰性加载）。

我的问题是，在任务的第一次迭代之后，我会有一个可用的时间表，我可以检索时间表。。。没问题，但对于第一次迭代，我需要等待任务完成至少一次，然后才能检索时间表。

我可以开始任务并创建一个while循环，直到第一次循环完成时设置了某个标志，但在我看来有更好的方法，它只对第一次迭代有用。之后，时间表将始终可用，我将不需要该功能。

有人有一个干净的方法来实现这一点吗？

Answer 1

我能想到的最好的解决方案是使用TaskCompletionSource，Eser在他的评论中提到了这一点。下面是一个带有大量控制台输出的粗略代码示例，以便更容易地了解它的操作。我还将IDisposable添加到Scheduler calss和CancellationTokenSource字典中，这样，当您完成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