Question

How do you implement busy waiting in a not total inefficient way? I am facing the issue that I can load the data of my model only in a pull manner, which means I have to invoke getXYZ() methods in a continuous way.

This has to happen not fast enough for user interaction, but fast enought, that when a state in the GUI is changed, the model can be noticed and the new state is received by the getXYZ() methods.

My approach simply be:

while (c.hasChanged()) {
   Thread.sleep(500);
}
updateData();

Are there better mechanisms?

Answer 1

Your problem seems to be solvable with Threading.

In WPF you can do:

Thread t = new Thread((ThreadStart)delegate() {
   while (true) {
      Thread.sleep(500);
      if (c.hasChanged())
          Dispatcher.Invoke((Action)delegate() {updateData();});
   }

}).Start();

In WinForms

Thread t = new Thread((ThreadStart)delegate() {
   while (true) {
      Thread.sleep(500);
      // this must derive from Control
      if (c.hasChanged())
          this.Invoke((Action)delegate() {updateData();});
   }

}).Start();

There may be missing parameters to Invoke (which is needed to execute the code on the calling UI thread) but I’m writing this from my brain so no intellisense at disposal 😀

In .NET 4 you can use TaskFactory.StartNew instead of spawning a thread by yourself.
In .Net <= 4, you could use the TreadPool for the thread.
However I recall you need this to be run at once because you expect it to be there checking as soon as possible and the thread pool won’t assure you that (it could be already full, but not very likely:-).
Just don’t do silly things like spawning more of them in a loop!

And inside the thread you should put a check like

while (!Closing)

so that the thread can finish when you need it without having to resort to bad things like t.Abort();
An when exiting put the Closing to true and do a t.Join() to close the checker thread.

EDIT:

I forgot to say that the Closing should be a bool property or a VOLATILE boolean, not a simple boolean, because you won’t be ensured that the thread could ever finish (well it would in case you are closing the application, but it is good practice to make them finish by your will). the volatile keyword is intended to prevent the (pseudo)compiler from applying any optimizations on the code that assume values of variables cannot change