Using System.Threading.Timer in Compact Framework

Question

I am using a System.Threading.Timer in a CF project (Windows Embedded CE 6.0), VS2005 C#, .NET 2.0. This timer is desired because there is no possibility of reentrancy when used like this:

    private System.Threading.Timer mainTimer;

    private void MainForm_Load(object sender, EventArgs e)
    {
        // other initializations
        mainTimer = new System.Threading.Timer(new TimerCallback(timerMain_Tick),
                null, 100, Timeout.Infinite);
    }

Which is to say, dueTime parameter is used but period is not. As long as period is Timeout.Infinite, the timer will fire once only. The timer is made thread-safe by checking for the form's InvokeRequired property. Note the check for null. It relates to my question, which I am getting to quickly.

    private void timerMain_Tick(object stateInfo)
    {
        if (mainTimer != null)
        {
            if (this.InvokeRequired)
            {
                this.Invoke((ThreadStart)delegate
                {
                    TimerProcess();
                });
            }
            else
            {
                TimerProcess();
            }
        }
    }

The timer must restart itself before it exits.

    private void TimerProcess()
    {
        try
        {
                // do work here
        }
        finally
        {
            // retrigger
            mainTimer.Change(mainTimerInterval, Timeout.Infinite);
        }
    }

The problem I am having is gracefully stopping this darn thing.

    private void MainForm_Closing(object sender, CancelEventArgs e)
    {
        // shut down timer
        mainTimer.Change(Timeout.Infinite, Timeout.Infinite);
        mainTimer.Dispose();
        mainTimer = null;
    }

About 3 times in 10, the timer fires anyway, and I get an Object Disposed error. The timer code is trying to invoke the timer method AFTER the check for null. I suspect that the timer fires, and its thread is suspended while the form is closing. I tried a state machine enumeration:

Normal state Running

Form_Closing sets Stopping state and waits in a Thread.Sleep() loop for Stopped state

Timer sees Stopping and sets Stopped state (rather than retriggering itself)

Problem I had with this is that the timer thread would not preempt the form closing method, so get stuck in endless loop. How to fix this problem? Note that in CF, there is no Dispose(WaitHandle) method.

Answer 1

I had the same issue just now and ran across your post today. Eventhough it's more than 10 years old I figured it still might be interesting for anybody out there, so here is my answer. I believe your conclusion, that there is still some unfinished matters left at the time the program closes, is right. What solved it for me was to add Application.DoEvents. So if you adapt your code as follows, you should be fine:

// shut down timer
Application.DoEvents();
mainTimer.Dispose();

The Application.DoEvents command takes out the unfinished matters just before closing.

Hope it helps.

Answer 2

I'm using MVP so my layout is a little different, but essentially I had the same two problems to fix:

1. Stop the timer firing after targets in the process method are disposed
2. Stop the timer firing DURING disposal

First one is easily fixed as pwrgreg007 shows above, just shutdown and null the timer sometime in your 'closing' process (before the form targets are disposed) and then do a null check at the start of your timer processing event.

Second issue is a bit trickier, even if the timer (and your form) are running at the start of your processing loop, nothing stops it getting shutdown mid way through the process as it is running on a different thread. To prevent this I created a lock to be used both during the timer execution AND the timer shutdown.

//simplified presenter
public class Presenter
{
    private const int REFRESH_TIME_MILLISECONDS = 5000;
    private view _view;
    private Timer _timer;
    private object _timerLock = new object();   

    //CTOR
    public Presenter()
    {   
        _view = new View();

        Startup();
    }

    //spin up presenter
    public void Startup(){

        //bind view shutdown event
        _view.ViewClosing += Shutdown;

        //start timer
        _timer = new Timer(DoTimerStuff, null, REFRESH_TIME_MILLISECONDS, Timeout.Infinite);
    }

    //spin down presenter
    public void Shutdown()
    {
        //wait for any DoTimerStuff locks to expire
        lock (_timerLock)
        {
            //stop the timer
            _timer.Change(Timeout.Infinite, Timeout.Infinite);
            _timer.Dispose();
            _timer = null;                
        }

        //close the view
        _view.Shutdown();
    }

    //timer tick
    private void DoTimerStuff(object state)
    {
        //grab a lock so we can ensure the timer doesn't get shutdown mid way through
        lock (_timerLock)
        {
            //make sure the timer isn't shutdown (from form closing)
            if (_timer == null) return;

            //do your stuff here
            _view.SomeInvokedCheckedProperty = "SomeValue";
            //etc...

            //schedule next timer execute (runs every runtime + refresh time)
            _timer.Change(REFRESH_TIME_MILLISECONDS, Timeout.Infinite);
        }
    }
}

//simplified view
public class View : Form
{

    //view properties (make sure they are invoke checked)
    public SomeInvokedCheckedProperty {get;set;}

    //Bound to ViewClosing
    private void View_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            //stop the view closing itself
            e.Cancel = true;

            //tell the presenter to handle closing instead
            if (ViewClosing != null) ViewClosing.Invoke();
        }
}

That way..

• The timer will wait to shutdown (holding up your form close) if DoTimerStuff() has the lock and is currently running
• Conversely, DoTimerStuff() will wait if the timer shutdown has the lock and when it gets to continue it will correctly see the timer is shutdown (and do nothing).

Answer 3

Interesting problem. There do not seem to be many options with the Timer in the Compact Framework.

I'm not sure how your specific code works, so adding a single static Boolean value may or may not fix your issues.

Here is how I changed your code to accept a timerOK value. If this does not solve your problem, it could give you ideas on how to approach this.

private static bool timerOK;
private static long mainTimerInterval = 200;
private System.Threading.Timer mainTimer;

private void MainForm_Load(object sender, EventArgs e) {
  timerOK = true;
  mainTimer = new System.Threading.Timer(new TimerCallback(timerMain_Tick), null, 100, Timeout.Infinite);
}

private void MainForm_Closing(object sender, CancelEventArgs e) {
  timerOK = false;
  mainTimer.Change(Timeout.Infinite, Timeout.Infinite);
  mainTimer.Dispose();
  mainTimer = null;
}

private void timerMain_Tick(object stateInfo) {
  if (timerOK && (mainTimer != null)) {
    if (this.InvokeRequired) {
      this.Invoke((ThreadStart)delegate {
        TimerProcess();
      });
    } else {
      TimerProcess();
    }
  }
}

private void TimerProcess() {
  if (!timerOK) return;
  try {
    // do work here
  } finally {
    // retrigger
    mainTimer.Change(mainTimerInterval, Timeout.Infinite);
  }
}