[ACCEPTED]-Is there a way to delay an event handler (say for 1 sec) in Windows Forms-events

Accepted answer
Score: 16

Perhaps you could make a method that creates 1 the timer?

void onButtonClick(object sender, EventArgs e)
    Delay(1000, (o,a) => MessageBox.Show("Test"));

static void Delay(int ms, EventHandler action)
    var tmp = new Timer {Interval = ms};
    tmp.Tick += new EventHandler((o, e) => tmp.Enabled = false);
    tmp.Tick += action;
    tmp.Enabled = true;
Score: 5

Before coming to your question, just having 9 read the summary bit from the main questions 8 page, a timer was exactly what I was going 7 to suggest.

This looks pretty clean to me. It 6 means you can easily "cancel" the delayed 5 event if you need to, by disabling the timer 4 again, for example. It also does everything 3 within the UI thread (but without reentrancy), which 2 makes life a bit simpler than other alternatives 1 might be.

Score: 5

If you're only doing this for one control, the 7 timer approach will work fine. A more robust 6 approach supporting multiple controls and 5 types of events looks something like this:

class Event
   public DateTime StartTime { get; set; }
   public Action Method { get; set; }

   public Event(Action method)
      Method = method;
      StartTime = DateTime.Now + TimeSpan.FromSeconds(1);

Maintain 4 a Queue<Event> in your form and have UI events that 3 need to be delayed add them to the queue, e.g.:

void onButtonClick( ..)
   EventQueue.Enqueue(new Event(MethodToCall));

Make 2 your timer tick 10 times a second or so, and 1 have its Tick event handler look like this:

void onTimerTick()
   if (EventQueue.Any() && EventQueue.First().StartTime >= DateTime.Now)
      Event e = EventQueue.Dequeue();
Score: 5

My solution uses System.Threading.Timer:

public static class ExecuteWithDelay
    class TimerState
        public Timer Timer;

    public static Timer Do(Action action, int dueTime)
        var state = new TimerState();
        state.Timer = new Timer(o =>
            lock (o) // The locking should prevent the timer callback from trying to free the timer prior to the Timer field having been set.
        }, state, dueTime, -1);
        return state.Timer;


Score: 4

For those limited to .NET 2.0, here is another 1 take on Bengt's helpful solution:

/// <summary>
/// Executes the specified method in a delayed context by utilizing
/// a temporary timer.
/// </summary>
/// <param name="millisecondsToDelay">The milliseconds to delay.</param>
/// <param name="methodToExecute">The method to execute.</param>
public static void DelayedExecute(int millisecondsToDelay, MethodInvoker methodToExecute)
    Timer timer = new Timer();
    timer.Interval = millisecondsToDelay;
    timer.Tick += delegate
                          // This will be executed on a single (UI) thread, so lock is not necessary
                          // but multiple ticks may have been queued, so check for enabled.
                          if (timer.Enabled)



Score: 1

Using Reactive Extensions:

First, install 1 the nuget package

PM> Install-Package Rx-Main


    private void CallMyCodeNow()
        label1.Text = "reactivated!";

    private void Form1_Load(object sender, EventArgs e)
        var o = Observable.FromEventPattern<EventHandler, EventArgs>(
            handler => button1.Click += handler
            , handler => button1.Click -= handler
            .ObserveOn(SynchronizationContext.Current)  // ensure event fires on UI thread
                ev => CallMyCodeNow()
                , ex => MessageBox.Show(ex.Message)
Score: 0

If you're looking for a more fancy solution, you 6 may want to take a look at my Reactive LINQ project. The 5 link doesn't show how to solve the particular 4 problem you're having, but it should be 3 possible to solve in quite an elegant style 2 using the technique described there (in 1 the whole 4-article series).

More Related questions