如何在 C# 中每天在特定时间调用一个方法？

Question

我搜索过 SO 并找到了有关 Quartz.net 的答案。但对于我的项目来说似乎太大了。我想要一个等效的解决方案，但更简单并且（最多）在代码中（不需要外部库）。如何每天在特定时间调用一个方法？

我需要添加一些关于此的信息：

• 最简单（且丑陋）的方法是每秒/每分钟检查一次时间并调用该方法，在正确的时间

我想要一种更有效的方法来执行此操作，无需不断地检查时间，我可以控制工作是否完成。如果该方法失败（由于任何问题），程序应该知道写入日志/发送电子邮件。这就是为什么我需要调用一个方法，而不是安排一个工作。

我找到了这个解决方案在Java中的固定时间调用方法在爪哇。 C#中有类似的方法吗？

编辑：我已经做到了。我在 void Main() 中添加了一个参数，并创建了一个 bat（由 Windows 任务计划程序调度）来使用该参数运行程序。程序运行，完成工作，然后退出。如果作业失败，它可以写入日志并发送电子邮件。这个方法很符合我的要求:)

Answer 1

• 创建一个执行您所需操作的控制台应用程序
• 使用 Windows“计划任务”功能，让控制台应用程序在您需要运行时执行，

这确实是您所需要的！

更新：如果您想在应用程序中执行此操作，您有多种选择：

• 在 Windows 窗体应用程序中，您可以点击 Application.Idle 事件并检查以查看您是否已经到了一天中调用您的方法的时间。仅当您的应用程序不忙于其他事情时才会调用此方法。快速检查是否已达到目标时间不应给您的应用程序带来太大压力，我认为...
• 在 ASP.NET Web 应用程序中，有一些方法可以“模拟”发送计划事件 - 请查看这篇 CodeProject 文章
• 当然，您也可以简单地“推出您自己的”在任何 .NET 应用程序中 - 请查看此CodeProject 文章以获取示例实现

更新 #2：如果您想每 60 分钟检查一次，您可以创建一个每 60 分钟唤醒一次的计时器，如果时间到了，它会调用该方法。

像这样：

using System.Timers;

const double interval60Minutes = 60 * 60 * 1000; // milliseconds to one hour

Timer checkForTime = new Timer(interval60Minutes);
checkForTime.Elapsed += new ElapsedEventHandler(checkForTime_Elapsed);
checkForTime.Enabled = true;

然后在你的事件处理程序中：

void checkForTime_Elapsed(object sender, ElapsedEventArgs e)
{
    if (timeIsReady())
    {
       SendEmail();
    }
}

Answer 2

我创建了一个简单的调度程序，易于使用，您不需要使用外部库。 TaskScheduler 是一个单例，它保留对计时器的引用，因此计时器不会被垃圾收集，它可以调度多个任务。您可以设置第一次运行（小时和分钟），如果在安排时该时间已结束，则安排在第二天此时开始。但自定义代码很容易。

安排新任务是如此简单。示例：在 11:52，第一个任务每 15 秒执行一次，第二个示例每 5 秒执行一次。对于日常执行，将 24 设置为 3 参数。

TaskScheduler.Instance.ScheduleTask(11, 52, 0.00417, 
    () => 
    {
        Debug.WriteLine("task1: " + DateTime.Now);
        //here write the code that you want to schedule
    });

TaskScheduler.Instance.ScheduleTask(11, 52, 0.00139,
    () =>
    {
        Debug.WriteLine("task2: " + DateTime.Now);
        //here write the code that you want to schedule
    });

我的调试窗口：

task2: 07.06.2017 11:52:00
task1: 07.06.2017 11:52:00
task2: 07.06.2017 11:52:05
task2: 07.06.2017 11:52:10
task1: 07.06.2017 11:52:15
task2: 07.06.2017 11:52:15
task2: 07.06.2017 11:52:20
task2: 07.06.2017 11:52:25
...

只需将此类添加到您的项目中：

public class TaskScheduler
{
    private static TaskScheduler _instance;
    private List<Timer> timers = new List<Timer>();

    private TaskScheduler() { }

    public static TaskScheduler Instance => _instance ?? (_instance = new TaskScheduler());

    public void ScheduleTask(int hour, int min, double intervalInHour, Action task)
    {
        DateTime now = DateTime.Now;
        DateTime firstRun = new DateTime(now.Year, now.Month, now.Day, hour, min, 0, 0);
        if (now > firstRun)
        {
            firstRun = firstRun.AddDays(1);
        }

        TimeSpan timeToGo = firstRun - now;
        if (timeToGo <= TimeSpan.Zero)
        {
            timeToGo = TimeSpan.Zero;
        }

        var timer = new Timer(x =>
        {
            task.Invoke();
        }, null, timeToGo, TimeSpan.FromHours(intervalInHour));

        timers.Add(timer);
    }
}

Answer 3

每当我构建需要此类功能的应用程序时，我总是通过我找到的一个简单的 .NET 库来使用 Windows 任务计划程序。

请请参阅我对类似问题的回答获取一些示例代码和更多说明。

Answer 4

正如其他人所说，您可以使用控制台应用程序按计划运行。其他人没有说的是，您可以此应用程序触发您在主应用程序中等待的跨进程 EventWaitHandle。

控制台应用程序：

class Program
{
    static void Main(string[] args)
    {
        EventWaitHandle handle = 
            new EventWaitHandle(true, EventResetMode.ManualReset, "GoodMutexName");
        handle.Set();
    }
}

主应用程序：

private void Form1_Load(object sender, EventArgs e)
{
    // Background thread, will die with application
    ThreadPool.QueueUserWorkItem((dumby) => EmailWait());
}

private void EmailWait()
{
    EventWaitHandle handle = 
        new EventWaitHandle(false, EventResetMode.ManualReset, "GoodMutexName");

    while (true)
    {
        handle.WaitOne();

        SendEmail();

        handle.Reset();
    }
}

Answer 5

这是使用 TPL 执行此操作的方法。无需创建/处置计时器等：

void ScheduleSomething()
{

    var runAt = DateTime.Today + TimeSpan.FromHours(16);

    if (runAt <= DateTime.Now)
    {
        DoSomething();
    }
    else
    {
        var delay = runAt - DateTime.Now;
        System.Threading.Tasks.Task.Delay(delay).ContinueWith(_ => DoSomething());
    }

}

void DoSomething()
{
    // do somethig
}

Answer 6

据我所知，最好的方法（可能也是最简单的方法）是使用 Windows 任务计划程序在一天中的特定时间执行代码，或者让应用程序永久运行并检查一天中的特定时间，或者编写一个执行以下操作的 Windows 服务：相同的。

Answer 7

我知道这很旧，但是这样怎么样：

构建一个在启动时触发的计时器，计算下次运行时间的时间。在第一次调用运行时时，取消第一个计时器并启动新的每日计时器。将每日更改为每小时或任何您想要的周期。

Answer 8

这个小程序应该是解决方案;-)

我希望这对每个人都有帮助。

using System;
using System.Threading;
using System.Threading.Tasks;

namespace DailyWorker
{
    class Program
    {
        static void Main(string[] args)
        {
            var cancellationSource = new CancellationTokenSource();

            var utils = new Utils();
            var task = Task.Run(
                () => utils.DailyWorker(12, 30, 00, () => DoWork(cancellationSource.Token), cancellationSource.Token));

            Console.WriteLine("Hit [return] to close!");
            Console.ReadLine();

            cancellationSource.Cancel();
            task.Wait();
        }

        private static void DoWork(CancellationToken token)
        {
            while (!token.IsCancellationRequested)
            {
                Console.Write(DateTime.Now.ToString("G"));
                Console.CursorLeft = 0;
                Task.Delay(1000).Wait();
            }
        }
    }

    public class Utils
    {
        public void DailyWorker(int hour, int min, int sec, Action someWork, CancellationToken token)
        {
            while (!token.IsCancellationRequested)
            {
                var dateTimeNow = DateTime.Now;
                var scanDateTime = new DateTime(
                    dateTimeNow.Year,
                    dateTimeNow.Month,
                    dateTimeNow.Day,
                    hour,       // <-- Hour when the method should be started.
                    min,  // <-- Minutes when the method should be started.
                    sec); // <-- Seconds when the method should be started.

                TimeSpan ts;
                if (scanDateTime > dateTimeNow)
                {
                    ts = scanDateTime - dateTimeNow;
                }
                else
                {
                    scanDateTime = scanDateTime.AddDays(1);
                    ts           = scanDateTime - dateTimeNow;
                }

                try
                {
                     Task.Delay(ts).Wait(token);
                }
                catch (OperationCanceledException)
                {
                    break;
                }

                // Method to start
                someWork();
            }
        }
    }
}

Answer 9

我最近刚刚编写了必须每天重新启动的 ac# 应用程序。我意识到这个问题已经很老了，但我认为添加另一个可能的解决方案并没有什么坏处。这就是我处理每日在指定时间重新启动的方式。

public void RestartApp()
{
  AppRestart = AppRestart.AddHours(5);
  AppRestart = AppRestart.AddMinutes(30);
  DateTime current = DateTime.Now;
  if (current > AppRestart) { AppRestart = AppRestart.AddDays(1); }

  TimeSpan UntilRestart = AppRestart - current;
  int MSUntilRestart = Convert.ToInt32(UntilRestart.TotalMilliseconds);

  tmrRestart.Interval = MSUntilRestart;
  tmrRestart.Elapsed += tmrRestart_Elapsed;
  tmrRestart.Start();
}

为了确保您的计时器保持在范围内，我建议使用 System.Timers.Timer tmrRestart = new System.Timers.Timer() 方法在方法之外创建它。将方法 RestartApp() 放入表单加载事件中。当应用程序启动时，如果 current 大于重启时间，它将设置 AppRestart 的值，我们在 AppRestart 上添加 1 天以确保重启准时发生，并且我们不会因将负值放入计时器而出现异常。在 tmrRestart_Elapsed 事件中运行您需要在该特定时间运行的任何代码。如果您的应用程序自行重新启动，您不一定需要停止计时器，但这也没有什么坏处，如果应用程序没有重新启动，只需再次调用 RestartApp() 方法即可很好，可以走了。

Answer 10

我发现这非常有用：

using System;
using System.Timers;

namespace ScheduleTimer
{
    class Program
    {
        static Timer timer;

        static void Main(string[] args)
        {
            schedule_Timer();
            Console.ReadLine();
        }

        static void schedule_Timer()
        {
            Console.WriteLine("### Timer Started ###");

            DateTime nowTime = DateTime.Now;
            DateTime scheduledTime = new DateTime(nowTime.Year, nowTime.Month, nowTime.Day, 8, 42, 0, 0); //Specify your scheduled time HH,MM,SS [8am and 42 minutes]
            if (nowTime > scheduledTime)
            {
                scheduledTime = scheduledTime.AddDays(1);
            }

            double tickTime = (double)(scheduledTime - DateTime.Now).TotalMilliseconds;
            timer = new Timer(tickTime);
            timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);
            timer.Start();
        }

        static void timer_Elapsed(object sender, ElapsedEventArgs e)
        {
            Console.WriteLine("### Timer Stopped ### \n");
            timer.Stop();
            Console.WriteLine("### Scheduled Task Started ### \n\n");
            Console.WriteLine("Hello World!!! - Performing scheduled task\n");
            Console.WriteLine("### Task Finished ### \n\n");
            schedule_Timer();
        }
    }
}

Answer 11

3线怎么样？

        DateTime startTime = DateTime.Today.AddDays(1).AddHours(8).AddMinutes(30); // Today starts at midnight, so add the number of days, hours and minutes until the desired start time, which in this case is the next day at 8:30 a.m.
        TimeSpan waitFor = startTime - DateTime.Now; // Calcuate how long it is until the start time
        await Task.Delay(waitFor); // Wait until the start time

Answer 12

如果您想要运行可执行文件，请使用 Windows 计划任务。我将假设（可能是错误的）您想要一个方法在当前程序中运行。

为什么不让一个连续运行的线程存储调用该方法的最后日期呢？

让它每分钟唤醒一次（例如），如果当前时间大于指定时间并且最后存储的日期不是当前日期，则调用该方法然后更新日期。

Answer 13

您可以计算剩余时间并将计时器设置为该时间的一半（或其他分数），而不是设置每 60 分钟每秒运行一次的时间。这样，您就不必过多地检查时间，但也可以保持一定程度的准确性，因为计时器间隔会随着您距离目标时间的距离而减少。

例如，如果您想在 60 分钟后执行某项操作，则计时器间隔约为：

30:00:00、15:00:00、07:30:00、03:45:00、...、00:00 :01，跑！

我使用下面的代码每天自动重新启动一次服务。我使用线程是因为我发现计时器在很长一段时间内不可靠，虽然在本例中成本更高，但它是为此目的创建的唯一一个，所以这并不重要。

（从 VB.NET 转换）

autoRestartThread = new System.Threading.Thread(autoRestartThreadRun);
autoRestartThread.Start();

...

private void autoRestartThreadRun()
{
    try {
        DateTime nextRestart = DateAndTime.Today.Add(CurrentSettings.AutoRestartTime);
        if (nextRestart < DateAndTime.Now) {
            nextRestart = nextRestart.AddDays(1);
        }

        while (true) {
            if (nextRestart < DateAndTime.Now) {
                LogInfo("Auto Restarting Service");
                Process p = new Process();
                p.StartInfo.FileName = "cmd.exe";
                p.StartInfo.Arguments = string.Format("/C net stop {0} && net start {0}", "\"My Service Name\"");
                p.StartInfo.LoadUserProfile = false;
                p.StartInfo.UseShellExecute = false;
                p.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
                p.StartInfo.CreateNoWindow = true;
                p.Start();
            } else {
                dynamic sleepMs = Convert.ToInt32(Math.Max(1000, nextRestart.Subtract(DateAndTime.Now).TotalMilliseconds / 2));
                System.Threading.Thread.Sleep(sleepMs);
            }
        }
    } catch (ThreadAbortException taex) {
    } catch (Exception ex) {
        LogError(ex);
    }
}

注意我设置了 1000 毫秒的最小间隔，可以根据您需要的精度增加、减少或删除该间隔。

请记住，当您的应用程序关闭时，也要停止您的线程/计时器。

Answer 14

我对此有一个简单的方法。这会在操作发生之前造成 1 分钟的延迟。您也可以添加秒数来使 Thread.Sleep();更短。

private void DoSomething(int aHour, int aMinute)
{
    bool running = true;
    while (running)
    {
        Thread.Sleep(1);
        if (DateTime.Now.Hour == aHour && DateTime.Now.Minute == aMinute)
        {
            Thread.Sleep(60 * 1000); //Wait a minute to make the if-statement false
            //Do Stuff
        }
    }
}

Answer 15

可能只是我的问题，但似乎大多数答案都不完整或无法正常工作。我做了一些又快又脏的东西。话虽这么说，不确定这样做有多好，但每次都很完美。

while (true)
{
    if(DateTime.Now.ToString("HH:mm") == "22:00")
    {
        //do something here
        //ExecuteFunctionTask();
        //Make sure it doesn't execute twice by pausing 61 seconds. So that the time is past 2200 to 2201
        Thread.Sleep(61000);
    }

    Thread.Sleep(10000);
}

Answer 16

24小时时间

var DailyTime = "16:59:00";
            var timeParts = DailyTime.Split(new char[1] { ':' });

            var dateNow = DateTime.Now;
            var date = new DateTime(dateNow.Year, dateNow.Month, dateNow.Day,
                       int.Parse(timeParts[0]), int.Parse(timeParts[1]), int.Parse(timeParts[2]));
            TimeSpan ts;
            if (date > dateNow)
                ts = date - dateNow;
            else
            {
                date = date.AddDays(1);
                ts = date - dateNow;
            }

            //waits certan time and run the code
            Task.Delay(ts).ContinueWith((x) => OnTimer());

public void OnTimer()
    {
        ViewBag.ErrorMessage = "EROOROOROROOROR";
    }

Answer 17

尝试使用 Windows 任务计划程序。创建一个不提示任何用户输入的 exe。

https://learn.microsoft.com/ en-us/windows/win32/taskschd/task-scheduler-start-page

Answer 18

一项任务的简单示例：

using System;
using System.Timers;

namespace ConsoleApp
{
    internal class Scheduler
    {
        private static readonly DateTime scheduledTime = 
            new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 10, 0, 0);
        private static DateTime dateTimeLastRunTask;

        internal static void CheckScheduledTask()
        {
            if (dateTimeLastRunTask.Date < DateTime.Today && scheduledTime.TimeOfDay < DateTime.Now.TimeOfDay)
            {
                Console.WriteLine("Time to run task");
                dateTimeLastRunTask = DateTime.Now;
            }
            else
            {
                Console.WriteLine("not yet time");
            }
        }
    }

    internal class Program
    {
        private static Timer timer;

        static void Main(string[] args)
        {
            timer = new Timer(5000);
            timer.Elapsed += OnTimer;
            timer.Start();
            Console.ReadLine();
        }

        private static void OnTimer(object source, ElapsedEventArgs e)
        {
            Scheduler.CheckScheduledTask();
        }
    }
}

Answer 19

System.Threading.Timer 的解决方案：

    private void nameOfMethod()
    {
        //do something
    }

    /// <summary>
    /// run method at 22:00 every day
    /// </summary>
    private void runMethodEveryDay()
    {
        var runAt = DateTime.Today + TimeSpan.FromHours(22);

        if(runAt.Hour>=22)
            runAt = runAt.AddDays(1.00d); //if aplication is started after 22:00 

        var dueTime = runAt - DateTime.Now; //time before first run ; 

        long broj3 = (long)dueTime.TotalMilliseconds;
        TimeSpan ts2 = new TimeSpan(24, 0, 1);//period of repeating method
        long broj4 = (long)ts2.TotalMilliseconds;
        timer2 = new System.Threading.Timer(_ => nameOfMethod(), null, broj3, broj4);
    }