Question

I searched a few links for Timer Control for both Windows and WPF applications but I would appreciate some advice on my situation…

As I’m using WPF it seems initial options are either System.Windows.Threading.DispatcherTimer or System.Diagnostics.Stopwatch

What I need to achieve is for each WPF DocumentPanel to request an update from an external API at a defined interval between typically 100ms Min – anytime Max with the interval unique to each DocumentPanel. Eg DP1 could be 100ms, DP2 could be 20,000ms etc.

Normally my app would start with 1 DocumentPanel but the user can expand panels without limit so it’s the users judgement on CPU ability and speed of app.

Criteria include:

1. Multiple DocumentPanels – Typically 1 – 20 minimum but any advice on scalability is welcome.

2. Variable event interval (Iv) (Minimum event interval 100ms – Max < 1day)

3. Accuracy – 1ms (cannot have interval below (Iv)ms under ANY circumstances, over is not as much concern but needs to be be within several ms) EDIT: 1ms is not strictly a requirement but average (Iv) must be maintained over a short timescale.

4. Each DocumentPanel must display live date/time but produce events based on set interval

I’m really after help with design consideration rather than actual code at the moment as WPF is confusing matters for me.

Currently, I’m verging towards using a single instance of System.Diagnostics.Stopwatch and allow each panel to act on the stopwatch event whether the interval time has been reached.

Can anyone advise?

Thank you
O

Answer 1

its better to use just one System.Windows.Threading.DispatcherTimer with 100ms as ticks, then use Tags to determine its own interval, for example you can use

struct IntervalComparer
{
     int myinterval; //the individual update interval (300ms for example)
     int currentinterval;
     public IntervalComparer(int myinterval)
    {
            this.myinterval=myinterval;
            this.currentinterval=0;
    }

        public void TickMe()
        {
            currentinterval++;
        }

        public void ResetkMe()
        {
            currentinterval = 0;
        }

        public bool CanIUpdate()
        {
            return myinterval == currentinterval;
        }
}

on the creation

.... Form_Loaded....
{
 .....
      mypanel=new Panel();
      mypanel.Tag= new IntervalComparer(2); // 2 * 100ms
 .....
}

.... Timer_Tick....
{
   ....
   (mypanel.Tag as IntervalComparer).TickMe();
    if((mypanel.Tag as IntervalComparer).CanIUpdate())
     {
       UpdateMyPanel();//your update method 
       (mypanel.Tag as IntervalComparer).ResetMe();
     }

   ....
}