System.Timers.Timer Come ottenere il tempo rimanente fino a Elapse

Question

Utilizzando C#, come posso ottenere il tempo rimanente (prima che si verifichi l'evento di durata) da un oggetto System.Timers.Timer?

In altre parole, diciamo che ho impostato l'intervallo del timer su 6 ore, ma 3 ore dopo, voglio sapere quanto tempo è rimasto. Come posso ottenere che l'oggetto del timer riveli questo tempo rimanente?

Answer 1

Il timer incorporato non fornisce il tempo rimanente prima della fine. Avrai bisogno di creare la tua classe che avvolge un timer e espone queste informazioni.

Qualcosa di simile dovrebbe funzionare.

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

Credo che il metodo migliore è quello di tenere il tempo di inizio in una variabile e quindi calcolare il tempo trascorso come

TimeSpan t = DateTime.Now - StartTime; 

Answer 3

Sono consapevole che il tema è più di 3 anni. Tuttavia mi sono imbattuto mentre affrontavo esattamente lo stesso problema.

Ispirato da Samuel Neff, mi si avvicinò con una soluzione WinForms-less estendendo la classe System.Timers.Timer di serie:

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

spero che aiuta.