System.Timers.Timer Comment obtenir le temps restant jusqu'à ce que Elapse

Question

En utilisant C #, comment puis-je obtenir le temps restant (avant l'événement s'écouler aura lieu) d'un objet System.Timers.Timer?

En d'autres termes, laissez-dire que je définir l'intervalle de minuterie à 6 heures, mais 3 heures plus tard, je veux savoir combien de temps restant. Comment puis-je obtenir l'objet de la minuterie pour révéler ce temps restant?

Answer 1

La minuterie intégrée ne fournit pas le temps restant avant s'écouler. Vous devrez créer votre propre classe qui enveloppe une minuterie et expose cette information.

Quelque chose comme cela devrait fonctionner.

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

Je suis conscient, que le sujet est âgé de plus de 3 ans. Cependant, je suis tombé sur elle tout en abordant exactement le même problème.

Inspiré par Samuel Neff, je suis venu avec une solution WinForms-moins en étendant la classe standard System.Timers.Timer:

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

J'espère que ça aide.

Answer 3

Je suppose que la meilleure méthode est de maintenir l'heure de début dans une variable puis calculer le temps écoulé comme

TimeSpan t = DateTime.Now - StartTime;