Question

我想每小时执行一个方法。我写了一些代码，但这还不足以实现我的目标。下面的代码每60分钟工作一次。

public void Start()
{
    System.Threading.Timer timerTemaUserBilgileri = new System.Threading.Timer(new System.Threading.TimerCallback(RunTakip), null, tmrTemaUserBilgileri, 0);
}

public void RunTakip(object temauserID)
{
    try 
    {
        string objID = "6143566557387";
        EssentialMethod(objID);
        TimeSpan span = DateTime.Now.Subtract(lastRunTime);
        if (span.Minutes > 60)
        {
            tmrTemaUserBilgileri = 1 * 1000;
            timerTemaUserBilgileri.Change(tmrTemaUserBilgileri, 0);
        }
        else
        {
            tmrTemaUserBilgileri = (60 - span.Minutes) * 60 * 1000;
            timerTemaUserBilgileri.Change(tmrTemaUserBilgileri, 0);
        }
        watch.Stop();
        var elapsedMs = watch.ElapsedMilliseconds;
    }
    catch (Exception ex)
    {
        timerTemaUserBilgileri.Change(30 * 60 * 1000, 0);
        Utils.LogYaz(ex.Message.ToString());
    }
}

public void EssentialMethod(objec obj)
{
    //some code
    lastRunTime = DateTime.Now;
    //send lastruntime to sql 
}

Answer 1

如果您希望每60分钟执行一次代码：

aTimer = new System.Timers.Timer(60 * 60 * 1000); //one hour in milliseconds
aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);
private static void OnTimedEvent(object source, ElapsedEventArgs e)
{
    //Do the stuff you want to be done every hour;
}

如果你想让你的代码每小时执行一次（即1：00,2：00,3：00）你可以用一些小的间隔创建一个计时器（让我们说一秒钟，取决于你需要的精度）和里面该计时器事件检查是否已经过了一个小时

aTimer = new System.Timers.Timer(1000); //One second, (use less to add precision, use more to consume less processor time
int lastHour = DateTime.Now.Hour;
aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);
private static void OnTimedEvent(object source, ElapsedEventArgs e)
{
    if(lastHour < DateTime.Now.Hour || (lastHour == 23 && DateTime.Now.Hour == 0))
     {
           lastHour = DateTime.Now.Hour;
           YourImportantMethod(); // Call The method with your important staff..
     }

}

Answer 2

基于/ Anarion解决方案的一个小评论我无法评论。

你可以用一些小间隔创建一个计时器（让我们说一秒钟，取决于你需要的精度）

你根本不需要任何精确度，你在想“如何检查这个小时是我要开火的时间”。你也可以选择“如何检查下一个小时是我想要开火的时间” - 一旦你认为你完全不需要任何精确度，只需每小时一次，然后设置一个线程。下个小时。如果你每小时打一次，你知道你会在下一个小时之前到达某个地方。

Dim dueTime As New DateTime(Date.Today.Year, Date.Today.Month, Date.Today.Day, DateTime.Now.Hour + 1, 0, 0)
Dim timeRemaining As TimeSpan = dueTime.Subtract(DateTime.Now)

t = New System.Threading.Timer(New System.Threading.TimerCallback(AddressOf Method), Nothing, CType(timeRemaining.TotalMilliseconds, Integer), System.Threading.Timeout.Infinite)

Answer 3

我同意SeñorSalt的观点，即chron工作应该是首选。然而，OP要求从c＃开始每小时一小时。为此，我设置了第一个定时事件，以便在一小时内触发：

int MilliSecondsLeftTilTheHour()
{
    int interval;

    int minutesRemaining = 59 - DateTime.Now.Minute;
    int secondsRemaining = 59 - DateTime.Now.Second;
    interval = ((minutesRemaining * 60) + secondsRemaining) * 1000;

    // If we happen to be exactly on the hour...
    if (interval == 0)
    {
        interval = 60 * 60 * 1000;
    }
    return interval;
}

Timer timer = new Timer();
timer.Tick += timer_Tick;
timer.Enabled = true;
timer.Interval = MilliSecondsLeftTilTheHour();

现在的问题是，如果上面的timer.Interval恰好是45分32秒，那么计时器将继续每45:32一次点火，而不仅仅是第一次。因此，在timer_Tick方法中，您必须将timer.Interval重新调整为一小时。

 void timer_Tick(object sender, EventArgs e)
 {
     // The Interval could be hard wired here to  60 * 60 * 1000 but on clock 
     // resets and if the job ever goes longer than an hour, why not
     // recalculate once an hour to get back on track.
     timer.Interval = MilliSecondsLeftTilTheHour();
     DoYourThing();
 }

Answer 4

使用服务器上的Cron作业以指定的时间间隔调用函数

这是一个链接 http://www.thesitewizard.com/general/set-cron-job.shtml

Answer 5

更简单的事情怎么样？使用一分钟计时器检查小时：

    private void MainWindow_Ready(object sender, DataSet e)
    {
            foreach (table in e.Tables)
            {
                control = new LeagueControl(table);
                SP1.Children.Add(control);
            }
        });
    }

    void SomeMethod()
    {

    }

Answer 6

如果尝试下面的代码，循环将被确定为保存您的资源，并且它每隔一小时运行，即分钟和秒（并且几乎毫秒等于零：

using System;
using System.Threading.Tasks;

namespace COREserver{
    public static partial class COREtasks{   // partial to be able to split the same class in multiple files
        public static async void RunHourlyTasks(params Action[] tasks)
        {
            DateTime runHour = DateTime.Now.AddHours(1.0);
            TimeSpan ts = new TimeSpan(runHour.Hour, 0, 0);
            runHour = runHour.Date + ts;


            Console.WriteLine("next run will be at: {0} and current hour is: {1}", runHour, DateTime.Now);
            while (true)
            {
                TimeSpan duration = runHour.Subtract(DateTime.Now);
                if(duration.TotalMilliseconds <= 0.0)
                { 
                    Parallel.Invoke(tasks);
                    Console.WriteLine("It is the run time as shown before to be: {0} confirmed with system time, that is: {1}", runHour, DateTime.Now);
                    runHour = DateTime.Now.AddHours(1.0);
                    Console.WriteLine("next run will be at: {0} and current hour is: {1}", runHour, DateTime.Now);
                    continue;
                }
                int delay = (int)(duration.TotalMilliseconds / 2);
                await Task.Delay(30000);  // 30 seconds
            }
        }
    }
}

Answer 7

为什么每个人都试图用计时器来解决这个问题？

您正在做两件事...等到凌晨，然后每小时每小时运行一次计时器。

我有一个Windows Service，我需要同样的解决方案。我以非常冗长的方式编写了代码，以便任何人都可以轻松遵循。我知道有许多可以实现的快捷方式，但我留给您自己。

private readonly Timer _timer;
/// starts timer
internal void Start()
{
    int waitTime = calculateSleepTime();

    System.Threading.Thread.Sleep(waitTime);

    object t = new object();

    EventArgs e = new EventArgs();

    CheckEvents(t, e);

    _timer.Start();
}

///  runs business logic everytime timer goes off
internal void CheckEvents(object sender, EventArgs e)
{
    //  do your logic here      
}

///  Calculates how long to wait until the top of the hour
private int calculateSleepTime()
{
    DateTime now = DateTime.Now;

    int minutes = now.Minute * 60 * 1000;

    int seconds = now.Second * 1000;

    int substrahend = now.Millisecond + seconds + minutes;

    int minuend = 60 * 60 * 1000;

    return minuend - substrahend;
}

Answer 8

这是一个简单，稳定（自同步）的解决方案：

while(true) {
    DoStuff();
    var now = DateTime.UtcNow;
    var previousTrigger = new DateTime(now.Year, now.Month, now.Day, now.Hour, 0, 0, now.Kind);
    var nextTrigger = previousTrigger + TimeSpan.FromHours(1);
    Thread.Sleep(nextTrigger - now);
}

请注意，如果DoStuff()执行的时间超过一个小时，则可能会跳过迭代。

每小时执行一次方法

8 个答案: