Dispatcher Invoke(…) vs BeginInvoke(…) confusion

by

When you use Dispatcher.BeginInvoke it means that it schedules the given action for execution in the UI thread at a later point in time, and then returns control to allow the current thread to continue executing. Invoke blocks the caller until the scheduled action finishes.

When you use BeginInvoke your loop is going to run super fast since BeginInvoke returns right away. This means that you’re adding lot and lots of actions to the message queue. You’re adding them much faster than they can actually be processed. This means that there’s a long time between when you schedule a message and when it actually gets a chance to be run.

The actual action that you’re running uses the field _number. But _number is being modified by the other thread very quickly and while the action is in the queue. This means that it won’t display the value of _number at the time you scheduled the action, but rather what it is after it has been continuing on in it’s very tight loop.

If you use Dispatcher.Invoke instead then it prevents the loop from “getting ahead of itself” and having multiple scheduled events, which ensures that the value that it’s writing is always the “current” value. Additionally, by forcing each iteration of the loop to wait for the message to be run it makes the loop a lot less “tight”, so it can’t run as quickly in general.

If you want to use BeginInvoke the first thing you really need to do is slow down your loop. If you want it to update the text every second, or ever 10ms, or whatever, then you can use Thread.Sleep to wait the appropriate amount of time.

Next, you need to take a copy of _number before passing it to the Dispatcher so that it displays the value at the time you scheduled it, not at the time it is executed:

while (true)
{
    if (_number++ > 10000)
        _number = 0;
    int copy = _number;
    this.Dispatcher.BeginInvoke(new Action(() => UpdateText(copy))
        , System.Windows.Threading.DispatcherPriority.Background, null);
    Thread.Sleep(200);
}

private void UpdateText(int number)
{
    this.Text = number.ToString();
}

More Related Contents:

  1. What’s the difference between Invoke() and BeginInvoke()
  2. Cross-thread operation not valid: Control accessed from a thread other than the thread it was created on
  3. Cross-thread operation not valid: Control ‘textBox1’ accessed from a thread other than the thread it was created on [duplicate]
  4. Change WPF controls from a non-main thread using Dispatcher.Invoke
  5. The calling thread cannot access this object because a different thread owns it.WPF [duplicate]
  6. Cannot convert lambda expression to type ‘System.Delegate’
  7. Display progress bar while doing some work in C#?
  8. c# – Volatile keyword usage vs lock
  9. Using the C# Dispatcher in WPF Applications
  10. Using C# MethodInvoker.Invoke() for a GUI app… is this good?
  11. What’s wrong with using Thread.Abort()
  12. Volatile vs. Interlocked vs. lock
  13. How to pass parameters to ThreadStart method in Thread?
  14. How to kill a thread instantly in C#?
  15. Alternatives to Thread.Sleep()
  16. Updating an ObservableCollection in a separate thread
  17. What are the differences between various threading synchronization options in C#?
  18. Code for a simple thread pool in C# [closed]
  19. How to catch exceptions from a ThreadPool.QueueUserWorkItem?
  20. COM object that has been separated from its underlying RCW cannot be used
  21. WPF UI multitasking
  22. Show Loading animation during loading data in other thread
  23. How to keep a .NET console app running?
  24. Cross-thread Winforms control editing [duplicate]
  25. The application called an interface that was marshalled for a different thread – Windows Store App
  26. How to handle Task.Run Exception
  27. How to let Timer skip tick if the previous thread is still busy
  28. C# multithreading chat server, handle disconnect
  29. Writing to file in a thread safe manner
  30. How can I enumerate all managed threads in C#?

Leave a Comment