C# language equivalent to ScheduledExecutorService

Question

I'm working with a RF reader device which has C# API.Based on its API, you'll need to manually invoke its read function to read/badge a card.

So my workaround is to use Timer to execute reading every 'n' seconds.

My problem is that Timer continuously executing, regardless of Thread.sleep() was invoke inside it's action.

Timer timer = new Timer(TimerCallback, null, 500, 1000); // From main() method

// The action that Timer executes
private void TimerCallback(Object o)
{
     scan(); // Action for reading/badging card
     scand.WaitOne(); // AutoResetEvent(true)
     GC.Collect(); // Force garbage collection
}

Thread.sleep() invoke inside the scan().

In Java, I use synchronized() to wait the other thread to call invoke(). I've searched for the whole day and I can't see a workaround that will be equivalent to ScheduledExecutorService and synchronized().

I hope there is a workaround with this cause I need it as soon as possible.

Thanks!

did you have a look at the Task class? http://stackoverflow.com/questions/13211334/how-do-i-wait-until-task-is-finished-in-c — fuchs777, Sep 04 '14 at 15:22
I saw Task class when I'm searching but the code @Erno de Weerd given solved my problem. But thanks anyway. — Erieze Lagera, Sep 05 '14 at 12:56

Emond · Accepted Answer · 2014-09-05T06:32:12.713

The most reliable way I could find was by re-starting the timer in the callback. This way the callback is not interrupted when active.

Timer timer = new Timer(TimerCallback, null, 500, 0); 

private void TimerCallback(Object o)
{
     scan(); 
     scand.WaitOne(); 
     timer.Change(500, 0);
}

The timer.Change re-schedules the timer.

Note: I removed the repetition in the Timer start up.

BTW: I removed the GC.Collect() as I consider that bad practice and useless in most cases.

Additionally you could get the time at the start of the method (Use Stopwatch) and calculate the required time delta to be passed to timer.Change :

Timer timer = new Timer(TimerCallback, null, 500, 0);
Stopwatch stopwatch = Stopwatch.StartNew();

private void TimerCallback(Object o)
{
     var entered = stopwatch.ElapsedMilliseconds;
     scan(); 
     scand.WaitOne(); 
     var duration = stopwatch.ElapsedMilliseconds - entered;
     var delay = Math.Max(0, 500 - duration);
     timer.Change(delay, 0);
}

This way the callback will be invoked after 500 ms minus the time it took to execute the scan functions. Set up like this and you might remove the Sleep from the Scan.

The reason for the double callback in your code is probably that the timer executes the callback on another thread when the first thread is still executing the callback.

Another solution might be to not use a Timer at all. Just loop and use a Stopwatch to calculate a time period to Sleep:

private void Scan()
{
     while(scanning)
     {
         var entered = stopwatch.ElapsedMilliseconds;
         scan(); 
         scand.WaitOne();
         var duration = stopwatch.ElapsedMilliseconds - entered;
         var delay = Math.Max(0, 500 - duration);
         Thread.Sleep(delay);
     }
}

Make sure you call this method on a separate thread (you could use a Task)

Thank you for your brief response. Your correct, my problem is that my existing code is resulting to an endless deferred callbacks. Your 2nd illustrated code was the one I use and it works perfectly as I required. Your recommended `timer.Change()` did the trick. Thanks! — Erieze Lagera, Sep 05 '14 at 12:55

C# language equivalent to ScheduledExecutorService

1 Answers1