DispatcherTimer отметьте один раз

Question

Я хочу, чтобы объект таймера диспетчера выполнялся только один раз.

Итак, у меня есть базовый код:

DispatcherTimer dispatcherTimer = new DispatcherTimer();
dispatcherTimer.Tick += new EventHandler(dispatcherTimer_Tick);
dispatcherTimer.Interval = new TimeSpan(0, 0, 4);
dispatcherTimer.Start();

Тогда внутри события клика:

private void dispatcherTimer_Tick(object sender, EventArgs e)
        {
            this.Visibility = System.Windows.Visibility.Visible;
            // Now stop timer execution.. or kill the timer object
        }

Как я могу остановить таймер или убить объект после этого выполнения?

Answer 1

private void dispatcherTimer_Tick(object sender, EventArgs e)
        {
            this.Visibility = System.Windows.Visibility.Visible;
            (sender as DispatcherTimer).Stop();
        }

Answer 2

Вот альтернативный код с использованием лямбда-выражения:

var timer = new DispatcherTimer {Interval = TimeSpan.FromSeconds(4)};
timer.Tick += (sender, args) => 
{
    this.Visibility = System.Windows.Visibility.Visible;
    timer.Stop();
};

timer.Start();

Answer 3

private void dispatcherTimer_Tick(object sender, EventArgs e)
        {
            this.Visibility = System.Windows.Visibility.Visible;
            var dispatcherTimer = (DispatcherTimer)sender;
            dispatcherTimer.Stop();
        }     

Answer 4

ответы могут сработать, но вы должны отключить прослушиватель событий от события Tick, когда вам больше не нужен таймер. Я не доверяю обработчику событий и сборщику мусора;)

Я полагаю, что у этого замечательного подкласса DispatcherTimer есть удобный класс для таймеров одного тика.

public class DispatcherTimeout : DispatcherTimer
{
    #region Constructors and Destructors

    protected DispatcherTimeout(DispatcherPriority priority)
        : base(priority)
    {
    }

    #endregion

    #region Public Properties

    public Action<DispatcherTimeout> Callback { get; set; }

    #endregion

    #region Public Methods and Operators

    /// <summary>
    /// Instantiates a new DispatcherTimeout and starts it.
    /// </summary>
    /// <param name="priority">
    /// The dispatcher priority used for the timer. 
    /// </param>
    /// <param name="duration">
    /// The duration. 
    /// </param>
    /// <param name="callback">
    /// The callback which should be called on tick. 
    /// </param>
    /// <returns>
    /// An instance of DispatcherTimeout. 
    /// </returns>
    public static DispatcherTimeout Timeout(DispatcherPriority priority, TimeSpan duration, Action<DispatcherTimeout> callback)
    {
        var dispatcherTimeout = new DispatcherTimeout(priority);
        dispatcherTimeout.Interval = duration;
        dispatcherTimeout.Callback = callback;

        dispatcherTimeout.Tick += dispatcherTimeout.HandleTick;

        dispatcherTimeout.Start();

        return dispatcherTimeout;
    }

    #endregion

    #region Methods

    private void HandleTick(object sender, EventArgs e)
    {
        this.Stop();
        this.Tick -= this.HandleTick;

        if (this.Callback != null)
        {
            this.Callback(this);
        }
    }

    #endregion
}

Пример:

DispatcherTimeout.Timeout(
    DispatcherPriority.Normal,
    TimeSpan.FromSeconds(2.0),
    timeout => 
    {
        this.Visibility = System.Windows.Visibility.Visible;
    });

Answer 5

    /// <summary>
    /// Fires an action once after "seconds"
    /// </summary>
    public static void FireOnce(float seconds, Action onElapsed)
    {
        Action detach = null;
        var timer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(seconds) };

        var handler = new EventHandler((s, args) =>
        {
            onElapsed();
            // Note: When stop is called this DispatcherTimer handler will be GC'd (eventually). There is no need to unregister the event.
            timer.Stop();
            if (detach != null)
                detach();
        });
        detach = new Action(() => timer.Tick -= handler); // No need for deregistering but just for safety let's do it.

        timer.Tick += handler;
        timer.Start();
    }