Aplicación de reloj despertador en .Net

Question

No estoy realmente escribiendo una aplicación de reloj de alarma, pero ayudará a ilustrar mi pregunta.

Digamos que tengo un método en mi aplicación, y quiero que este método se llame cada hora en la hora (por ejemplo, a las 7:00 p.m., 8:00 p.m., 9:00 p.m., etc.). I podría crear un temporizador y configurar su intervalo en 3600000, pero eventualmente esto se saldría de sincronización con el reloj del sistema. O I podría utilizar un while() bucle con Thread.Sleep(n) para comprobar periódicamente la hora del sistema y llamar al método cuando se alcanza el tiempo deseado, pero tampoco me gusta esto (Thread.Sleep(n) es un gran olor a código para mí).

Lo que estoy buscando es algún método en .Net que me permita pasar en un futuro objeto DateTime y un método delegado o manejador de eventos, pero no he podido encontrar tal cosa. Sospecho que hay un método en la API de Win32 que hace esto, pero tampoco he podido encontrarlo.

Answer 1

O bien, puede crear un temporizador con un intervalo de 1 segundo y verificar la hora actual cada segundo hasta que se llegue a la hora del evento, si es así, levanta su evento.

Usted puede hacer un simple envoltorio para ello:

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; 
} 

Uso:

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

Tenga en cuenta que el código anterior es muy esquemática y no seguro para subprocesos.

Answer 2

Puede crear una clase de alarma que tenga una secuencia dedicada que se suspenda hasta la hora especificada, pero utilizará el método Thread.Sleep. Algo así como:

/// <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 3

Simplemente podría restablecer el temporizador de duración cada vez que se dispara, como esto:

// 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

¿Qué pasa con la clase System.Timers.Timer? Ver http://msdn.microsoft.com/en-us/library/system.timers.timer.aspx

Answer 5

Interesante, me he encontrado con un problema muy similar y fui en busca de un método en el .Net framework que manejaría este escenario. Al final, terminamos implementando nuestra propia solución que era una variación en un ciclo while w/Thread.Sleep (n) donde n se hace más pequeño cuanto más se acerca al tiempo objetivo deseado (logarítmicamente en realidad, pero con algunos umbrales razonables para no estás maximizando la CPU cuando te acercas al tiempo objetivo.) Aquí hay una implementación realmente simple que simplemente duerme la mitad del tiempo entre ahora y el tiempo objetivo.

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 6

he utilizado esto antes con gran éxito:

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(); 
    } 
} 

no sé si las obras de C#, pero el vb funciona bien.

Uso en VB:

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

A continuación, sólo tiene que añadir un controlador de eventos para el evento SoundAlarm.