在 C# 中以不规则的间隔计划一系列任务

Question

假设我有一个文件，其中列出了要执行的任务以及执行这些任务的间隔，如下所示：

Task_A
2 seconds
Task_B
10 seconds
Task_C
1 minute
Task_A
...

因此，当这个列表被读入，然后允许执行时，它会Task_A，等待 2 秒，执行Task_B，等待 10 秒，依此类推。

我应该怎么做？ 我已经对System.threading.timer进行了一些研究，但这似乎是在执行重复任务的设定间隔内，但是在这种情况下，我正在阅读一个文件，该文件列出了要做什么以及您执行之前多长时间，就像上面一样（不同的语法，但这个更容易解释）。

这个函数在后台工作线程中，所以我可以做一个 Thread.Sleep（Timespan） 并且我的 GUI 没有任何问题，但这感觉就像用铁砧敲钉子一样。 作为System.threading.timer的OnTimedEvent的一部分，我也可以有一个部分来改变它自己的间隔，但我不确定这是否是一种好的做法，或者它是否有效。

最好的方法是什么？

Answer 1

System.Timers.Timer 可以提供帮助。

首先，任务的基本类，您可能会通过数据库或其他方式获得它。

public class Task
{
    public Task()
    { 
    }
    public Task(String tName, Int32 iInterval, Int16 iPriority)
    {
        this.taskName = tName;
        this.nextInterval = iInterval;
        this.priority = iPriority;
    }
    private String taskName = String.Empty;
    public String TaskName
    {
        get
        {
            return this.taskName;
        }
        set
        {
            this.taskName = value;
        }
    }
    private Int32 nextInterval = 1;
    public Int32 NextInterval
    {
        get
        {
            return this.nextInterval;
        }
        set
        {
            this.nextInterval = value;
        }
    }
    private Int16 priority = 1;
    public Int16 Priority
    {
        get
        {
            return this.priority;
        }
        set
        {
            this.priority = value;
        }
    }
}

然后是如何执行部分。

public class ExecuteTasks
{
    private System.Timers.Timer myTimer = new System.Timers.Timer();
    private Int32 TaskIndex = 0;
    private Int32 TaskCount = 3;
    protected void StartExecution()
    {
        myTimer.Interval = 1;
        myTimer.Elapsed += new System.Timers.ElapsedEventHandler(myTimer_Elapsed);
        myTimer.Start();
    }
    void myTimer_Elapsed(object sender, EventArgs e)
    {
        myTimer.Stop();
        if (TaskIndex < TaskCount)
        {             
            Task aTask = GetTasks()[TaskIndex++];
            StartTask(aTask.TaskName);
            SetNextTaskTimer(aTask.NextInterval);
        }
    }
    void SetNextTaskTimer(Int32 Seconds)
    {   
        myTimer.Interval = (Seconds * 1000) - DateTime.Now.Millisecond - 1;//Interval is set in miliseconds
        myTimer.Start();
    }
    void StartTask(String TaskName)
    {
        ProcessStartInfo objStartInfo = new ProcessStartInfo();
        objStartInfo.FileName = TaskName;
        Process objProcess = new Process();
        objProcess.StartInfo = objStartInfo;
        objProcess.Start();
    }
    //You will be reading your tasks from your database or a file
    List<Task> GetTasks()
    {
        List<Task> lstTasks = new List<Task>();
        lstTasks.Add(new Task("Task A", 2, 1));
        lstTasks.Add(new Task("Task B", 10, 2));
        lstTasks.Add(new Task("Task C", 60, 3));
        return lstTasks.OrderBy(le => le.Priority).ToList();
    }
}

当给定的时间过去时，我已经开始了一些过程。（您需要为该过程的启动提供正确的路径，即类似

ProcessStartInfo objStartInfo = new ProcessStartInfo();
objStartInfo.FileName = "C:\Windows\notepad.exe";

而不仅仅是任务名称。

最后触发执行部分。

ExecuteTasks iExecute = new ExecuteTasks();
iExecute.StartExecution();

对于多线程，您可以使用锁定机制，监视类等，无论您的需求如何。

lock(obj)//lock on an object
{
    ExecuteTasks iExecute = new ExecuteTasks();
    iExecute.StartExecution();
}