Is it possible to get Timer.Tick event after diposing it

Question

I have a question about System.Windows.Forms.Timer. Is it possible to get Tick event after disposing it? For example, if the message is in the message loop and I dispose the timer meanwhile. If it is possible what is the best way to prevent against it. Do you now any good sources explaining it, because I couldn't find anything explaining it. Here is same code explaining my problem:

namespace TestTimer
{
    public partial class Form1 : Form
    {
        ObjectWithTimer obj = null;
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            if(obj != null) 
            {
                obj.Deinit();
                obj = null;
            }
            obj = new ObjectWithTimer();
        }
    }

    public class ObjectWithTimer
    {
        public Object o = new object();
        public Timer timer = new Timer();
        bool disposed = false;

        public ObjectWithTimer()
        {
            timer.Interval = 10;
            timer.Tick += new EventHandler(timer_Tick);
            timer.Enabled = true;
        }

        public void Deinit()
        {
            timer.Enabled = false;
            timer.Tick -= new EventHandler(timer_Tick);
            timer.Dispose();
            timer = null;
            disposed = true;
        }

        private void timer_Tick(object sender, EventArgs e)
        {
            if (disposed)
            {
                //Is it possible to get here
                if (timer.Enabled) return;
            }
            //doing something 
        }
    }
}

Answer 1

Understanding how timers work can help you feel better about it. They are implemented by the operating system, the underlying winapi call to start a timer is SetTimer(). The OS then posts a notification whenever the timer ticks, you get a WM_TIMER message. The plumbing in Winforms ensures that your Tick event handler runs when this message is received.

These messages are stored in the message queue, an internal data structure associated with a window. This queue serializes messages, it is the basic mechanism that ensures that you for example can never lose a mouse click or a keyboard key press, even when the window is unresponsive because the UI thread is busy with something else.

This queue gives reason to be cautious, what happens when the queue stores a WM_TIMER message when you disposed the timer? Unless something drastic is done, you'd still get that message and your Tick event handler will fire.

But no need to worry, WM_TIMER belongs to a small group of messages that are generated in a special way. They are synthesized messages, it is only ever generated when your program asks for a message with GetMessage(). Other common messages that belong that group are WM_PAINT, it fires the Paint event. Note how you can call Invalidate() as often as you like, you still get only a single Paint event. WM_MOUSEMOVE is another one, it fires the MouseMove event. Something you can reason about, no matter how fast you move the mouse, you can never flood the message queue with mouse-move messages.

Another characteristic of these synthesized messages is that they appear to have a "low priority". Given is that they are only ever synthesized when the message queue is empty. Which is why keyboard messages and mouse clicks always generate an event ahead of a paint.

Long story short, you can only get a WM_TIMER message if you ask for a message and the timer is still alive. The Timer.Dispose() method calls KillTimer() under the hood. Which ends any opportunity to still get a Tick event. Only possible way that could get screwed up is when you call the Stop() or Dispose() methods from a worker thread. Don't do that.

Answer 2

The Windows Forms Timer is single threaded so is not possible that while disposing it you are in timer_Tick.

Also you are not detaching your event in deinit function.

Answer 3

This is very easy to test. I've modified your code a bit:

public class Form1 : Form
{
    public Form1()
    {
        var button = new Button();
        button.Click += button1_Click;

        Controls.Add(button);
    }

    private void button1_Click(object sender, EventArgs e)
    {
        var obj = new ObjectWithTimer();

        Thread.Sleep(2000);

        obj.Deinit();
    }
}

public class ObjectWithTimer
{
    public System.Windows.Forms.Timer timer = new System.Windows.Forms.Timer();
    bool disposed = false;

    public ObjectWithTimer()
    {
      timer.Interval = 100;
      timer.Tick += new EventHandler(timer_Tick);
      timer.Enabled = true;
    }

    public void Deinit()
    {
      timer.Enabled = false;
      timer.Tick -= new EventHandler(timer_Tick);
      timer.Dispose();
      timer = null;
      disposed = true;
    }

    private void timer_Tick(object sender, EventArgs e)
    {
      "Ticked".Dump();
    }
}

The Thread.Sleep ensures the UI thread is occupied while the timer does its ticking.

The result? No, the Tick will not fire after the timer is disabled. Even the timer.Tick -= new EventHandler(timer_Tick); is unnecessary.