.Net 中的闹钟应用程序

Question

我并不是真的在编写闹钟应用程序，但它有助于说明我的问题。

假设我的应用程序中有一个方法，并且我希望每小时整点调用此方法（例如，在晚上 7:00、晚上 8:00、晚上 9:00 等）。我可以创建一个计时器并将其间隔设置为 3600000，但最终这会与系统时钟不同步。或者我可以使用while() 循环和Thread.Sleep(n) 定期检查系统时间并在达到所需时间时调用该方法，但我也不喜欢这样（Thread.Sleep(n) 是对我来说有很大的代码味道）。

我正在寻找的是 .Net 中的一些方法，它可以让我传入未来的 DateTime 对象和方法委托或事件处理程序，但我找不到任何这样的东西。我怀疑 Win32 API 中有一个方法可以做到这一点，但我也找不到。

Answer 1

或者，您可以创建一个间隔为 1 秒的计时器，并每隔一秒检查一次当前时间，直到达到事件时间，如果是，您就发起您的事件。

您可以为此制作一个简单的包装器：

public class AlarmClock
{
    public AlarmClock(DateTime alarmTime)
    {
        this.alarmTime = alarmTime;

        timer = new Timer();
        timer.Elapsed += timer_Elapsed;
        timer.Interval = 1000;
        timer.Start();

        enabled = true;
    }

    void  timer_Elapsed(object sender, ElapsedEventArgs e)
    {
        if(enabled && DateTime.Now > alarmTime)
        {
            enabled = false;
            OnAlarm();
            timer.Stop();
        }
    }

    protected virtual void OnAlarm()
    {
        if(alarmEvent != null)
            alarmEvent(this, EventArgs.Empty);
    }


    public event EventHandler Alarm
    {
        add { alarmEvent += value; }
        remove { alarmEvent -= value; }
    }

    private EventHandler alarmEvent;
    private Timer timer;
    private DateTime alarmTime;
    private bool enabled;
}

用法：

AlarmClock clock = new AlarmClock(someFutureTime);
clock.Alarm += (sender, e) => MessageBox.Show("Wake up!");

请注意，上面的代码非常粗略，不是线程安全的。

Answer 2

有趣的是，我实际上遇到了一个非常相似的问题，并在 .Net 框架中寻找一种可以处理这种情况的方法。最后，我们最终实现了我们自己的解决方案，它是一个带有 Thread.Sleep(n) 的 while 循环的变体，其中 n 越接近所需的目标时间越小（实际上是对数，但有一些合理的阈值，所以当你接近目标时间时，你并没有最大化 CPU。）这是一个非常简单的实现，它只是从现在到目标时间的一半时间休眠。

class Program
{
    static void Main(string[] args)
    {
        SleepToTarget Temp = new SleepToTarget(DateTime.Now.AddSeconds(30),Done);
        Temp.Start();
        Console.ReadLine();
    }

    static void Done()
    {
        Console.WriteLine("Done");
    }
}

class SleepToTarget
{
    private DateTime TargetTime;
    private Action MyAction;
    private const int MinSleepMilliseconds = 250;

    public SleepToTarget(DateTime TargetTime,Action MyAction)
    {
        this.TargetTime = TargetTime;
        this.MyAction = MyAction;
    }

    public void Start()
    {
        new Thread(new ThreadStart(ProcessTimer)).Start();
    }

    private void ProcessTimer()
    {
        DateTime Now = DateTime.Now;

        while (Now < TargetTime)
        {
            int SleepMilliseconds = (int) Math.Round((TargetTime - Now).TotalMilliseconds / 2);
            Console.WriteLine(SleepMilliseconds);
            Thread.Sleep(SleepMilliseconds > MinSleepMilliseconds ? SleepMilliseconds : MinSleepMilliseconds);
            Now = DateTime.Now;
        }

        MyAction();
    }
}

Answer 3

您可以简单地在每次触发时重置计时器持续时间，如下所示：

// using System.Timers;

private void myMethod()
{
    var timer = new Timer { 
        AutoReset = false, Interval = getMillisecondsToNextAlarm() };
    timer.Elapsed += (src, args) =>
    {
        // Do timer handling here.

        timer.Interval = getMillisecondsToNextAlarm();
        timer.Start();
    };
    timer.Start();
}

private double getMillisecondsToNextAlarm()
{
    // This is an example of making the alarm go off at every "o'clock"
    var now = DateTime.Now;
    var inOneHour = now.AddHours(1.0);
    var roundedNextHour = new DateTime(
        inOneHour.Year, inOneHour.Month, inOneHour.Day, inOneHour.Hour, 0, 0);
    return (roundedNextHour - now).TotalMilliseconds;
}

Answer 4

您可以创建一个具有专用线程的 Alarm 类，该线程会在指定时间之前进入睡眠状态，但这将使用 Thread.Sleep 方法。比如：

/// <summary>
/// Alarm Class
/// </summary>
public class Alarm
{
    private TimeSpan wakeupTime;

    public Alarm(TimeSpan WakeUpTime)
    {
        this.wakeupTime = WakeUpTime;
        System.Threading.Thread t = new System.Threading.Thread(TimerThread) { IsBackground = true, Name = "Alarm" };
        t.Start();
    }

    /// <summary>
    /// Alarm Event
    /// </summary>
    public event EventHandler AlarmEvent = delegate { };

    private void TimerThread()
    {
        DateTime nextWakeUp = DateTime.Today + wakeupTime;
        if (nextWakeUp < DateTime.Now) nextWakeUp = nextWakeUp.AddDays(1.0);

        while (true)
        {
            TimeSpan ts = nextWakeUp.Subtract(DateTime.Now);

            System.Threading.Thread.Sleep((int)ts.TotalMilliseconds);

            try { AlarmEvent(this, EventArgs.Empty); }
            catch { }

            nextWakeUp = nextWakeUp.AddDays(1.0);
        }
    }
}

Answer 5

我知道这是一个老问题，但我在寻找其他问题的答案时遇到了这个问题。因为我最近遇到了这个特殊问题，所以我想我会在这里投入两分钱。

您可以做的另一件事是像这样安排方法：

/// Schedule the given action for the given time.
public async void ScheduleAction ( Action action , DateTime ExecutionTime )
{
    try
    {
        await Task.Delay ( ( int ) ExecutionTime.Subtract ( DateTime.Now ).TotalMilliseconds );
        action ( );
    }
    catch ( Exception )
    {
        // Something went wrong
    }
}

请记住，它最多只能等待 int 32 的最大值（大约一个月左右），它应该可以满足您的目的。用法：

void MethodToRun ( )
{
    Console.WriteLine ("Hello, World!");
}

void CallingMethod ( )
{
    var NextRunTime = DateTime.Now.AddHours(1);
    ScheduleAction ( MethodToRun, NextRunTime );
}

你应该在一小时内收到一条控制台消息。

Answer 6

System.Timers.Timer 类呢？见http://msdn.microsoft.com/en-us/library/system.timers.timer.aspx

Answer 7

我以前用过这个很成功：

vb.net：

Imports System.Threading
Public Class AlarmClock
    Public startTime As Integer = TimeOfDay.Hour
    Public interval As Integer = 1
    Public Event SoundAlarm()
    Public Sub CheckTime()
        While TimeOfDay.Hour < startTime + interval
            Application.DoEvents()
        End While
        RaiseEvent SoundAlarm()
    End Sub
    Public Sub StartClock()
        Dim clockthread As Thread = New Thread(AddressOf CheckTime)
        clockthread.Start()
    End Sub
End Class

C#：

using System.Threading;
public class AlarmClock
{
    public int startTime = TimeOfDay.Hour;
    public int interval = 1;
    public event SoundAlarmEventHandler SoundAlarm;
    public delegate void SoundAlarmEventHandler();
    public void CheckTime()
    {
        while (TimeOfDay.Hour < startTime + interval) {
            Application.DoEvents();
        }
        if (SoundAlarm != null) {
            SoundAlarm();
        }
    }
    public void StartClock()
    {
        Thread clockthread = new Thread(CheckTime);
        clockthread.Start();
    }
}

我不知道c#能不能用，但是vb能用就好了。

在VB中的使用：

Dim clock As New AlarmClock
clock.interval = 1 'Interval is in hours, could easily convert to anything else
clock.StartClock()

然后，只需为 SoundAlarm 事件添加一个事件处理程序。