[ACCEPTED]-DispatcherTimer tick once-wpf

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

0

Score: 25

Here is alternative code using lambda expression:

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

timer.Start();

0

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

0

Score: 2

the answers might work out but you should 6 detach your event listener from the Tick 5 Event when you do not need the timer any 4 longer. I don't trust eventhandler and the 3 garbage collector ;)

I worte this nice subclass 2 of DispatcherTimer to have a convinient 1 class for single tick timers.

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
}

Example:

DispatcherTimeout.Timeout(
    DispatcherPriority.Normal,
    TimeSpan.FromSeconds(2.0),
    timeout => 
    {
        this.Visibility = System.Windows.Visibility.Visible;
    });
Score: 2
    /// <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();
    }

0

More Related questions