c# - System.Timers.Timer Cómo obtener el tiempo restante hasta que transcurra

windows-services elapsedtime

Question

Con C #, ¿cómo puedo obtener el tiempo restante (antes de que ocurra el evento transcurrido) de un objeto System.Timers.Timer ?

En otras palabras, digamos que establezco el intervalo del temporizador en 6 horas, pero 3 horas más tarde, quiero saber cuánto tiempo queda. ¿Cómo obtendría el objeto temporizador para revelar este tiempo restante?

Answer 1

El temporizador incorporado no proporciona el tiempo restante hasta que transcurre. Tendrá que crear su propia clase que envuelva un temporizador y exponga esta información.

Algo como esto debería funcionar.

public class TimerPlus : IDisposable
{
private readonly TimerCallback _realCallback;
private readonly Timer _timer;
private TimeSpan _period;
private DateTime _next;
public TimerPlus(TimerCallback callback, object state, TimeSpan dueTime, TimeSpan period)
{
_timer = new Timer(Callback, state, dueTime, period);
_realCallback = callback;
_period = period;
_next = DateTime.Now.Add(dueTime);
}
private void Callback(object state)
{
_next = DateTime.Now.Add(_period);
_realCallback(state);
}
public TimeSpan Period
{
get
{
return _period;
}
}
public DateTime Next
{
get
{
return _next;
}
}
public TimeSpan DueTime
{
get
{
return _next - DateTime.Now;
}
}
public bool Change(TimeSpan dueTime, TimeSpan period)
{
_period = period;
_next = DateTime.Now.Add(dueTime);
return _timer.Change(dueTime, period);
}
public void Dispose()
{
_timer.Dispose();
}
}

Answer 2

Soy consciente de que el tema tiene más de 3 años. Sin embargo, lo encontré mientras abordaba exactamente el mismo problema.

Inspirado por Samuel Neff, se me ocurrió una solución sin WinForms al extender la clase estándar de temporizadores System.Timers:

 public class TimerPlus : System.Timers.Timer
{
private DateTime m_dueTime;
public TimerPlus() : base()
{
this.Elapsed += this.ElapsedAction;
}
protected new void Dispose()
{
this.Elapsed -= this.ElapsedAction;
base.Dispose();
}
public double TimeLeft
{
get
{
return (this.m_dueTime - DateTime.Now).TotalMilliseconds;
}
}
public new void Start()
{
this.m_dueTime = DateTime.Now.AddMilliseconds(this.Interval);
base.Start();
}
private void ElapsedAction(object sender, System.Timers.ElapsedEventArgs e)
{
if (this.AutoReset)
{
this.m_dueTime = DateTime.Now.AddMilliseconds(this.Interval);
}
}
}

Espero que ayude.

Answer 3

Supongo que el mejor método es mantener la hora de inicio en una variable y luego calcular el tiempo transcurrido como

TimeSpan t = DateTime.Now - StartTime;