[JackOfAllTrades]

Don't sweat it

[eclipsed4utoo]

We have a number of snippets and tutorials on writing to the UI from a different thread.

[eclipsed4utoo]

The concept is still the same. Also, you can use the BackgroundWorker in both WinForms and WPF. It's probably the easiest way of doing threading.

We have a tutorial on using the BackgroundWorker.

[ragingben]

Also just a quick note, as all UI elements (TextBoxes, Buttons, Labels etc) are owned by the thread that they were created on, you cannot edit them from another thread.

So the background worker can do the work, but it will not be able to update any UI values.

However you can use the .Dispatcher property on your window or control to update a value safely from a background thread. I find using this with lambda expressions is for me the quickest and simplist way of updating a value.

For example, you need to create a public delegate that you will use to update the values, I've done it just outside my main window class...

namespace WpfApplication1
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }
    }

    /// <summary>
    /// Deletage used for updating values
    /// </summary>
    public delegate void UpdaterDelegate();
}

...and then you can simply use the objects dispatcher to call a delegate that will update the object, using a parameterless lambda expression containing the update code. That sentance sounds more complicated than it actually is

// call this from wherever you want to update the values from on a non UI thread. In this example "this" is Window1...

// to update one line of code, for example change the background of the window
this.Dispatcher.BeginInvoke(new UpdaterDelegate(() => this.Background = Brushes.Red));

// or you can update multiple lines in a block of code
this.Dispatcher.BeginInvoke(new UpdaterDelegate(() =>
{
    // update background
    this.Background = Brushes.Red;

    // change title
    this.Title = "Hello";
}));

To see what I mean just create a new WPF app, and paste this over the Window1 code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.ComponentModel;
using System.Threading;

namespace WpfApplication1
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
    public partial class Window1 : Window
    {
        // the worker for this example
        BackgroundWorker worker;

        public Window1()
        {
            InitializeComponent();
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            // create worker
            this.worker = new BackgroundWorker();

            // subscribe to do work event - this is called when the worker runs...
            worker.DoWork += new DoWorkEventHandler(worker_DoWork);

            // now run
            worker.RunWorkerAsync();
        }

        void worker_DoWork(object sender, DoWorkEventArgs e)
        {
            // wait a sec so we can see change... notice that we can call this and the UI remains responsive, only the worker is sleeping not the UI thread
            Thread.Sleep(1000);

            // to update one line of code, for example change the background of the window
            this.Dispatcher.BeginInvoke(new UpdaterDelegate(() => this.Background = Brushes.Red));

            // wait again
            Thread.Sleep(1000);

            // or you can update multiple lines in a block of code
            this.Dispatcher.BeginInvoke(new UpdaterDelegate(() =>
            {
                // update background
                this.Background = Brushes.Yellow;

                // change title
                this.Title = "Updating on UI...";
            }));

            // wait again
            Thread.Sleep(1000);

            // or you can update multiple lines in a block of code
            this.Dispatcher.BeginInvoke(new UpdaterDelegate(() =>
            {
                // update background
                this.Background = Brushes.Blue;

                // change title
                this.Title = "Hope that helped :)/>";
            }));
        }
    }

    /// <summary>
    /// Deletage used for updating values
    /// </summary>
    public delegate void UpdaterDelegate();
}

Hope that helps

This post has been edited by ragingben: 09 September 2010 - 03:23 AM

[ragingben]

Well, Im no expert, but this is basically whats going on as far as I understand:

All WPF FrameworkElements, which all visual controls etc are derieved from inherit directly from DispatcherObject. DispatcherObject has a Dispatcher property which is the pump for all viusal updates and rendering of UI elements, and also controls which order certain tasks are carried out in, which can be specified by a DispatcherPriority.

Just google any of these classes and there are loads of descriptions of whats going on with them, and how they work. Because all controls and all windows derieve from DispatcherObject in WPF, they all have a Dispatcher property.

What is actually happening when you call Dispatcher.BeginInvoke() on your window, is you are passing the Dispatcher a task to do (the delegate), which it inserts into it's pending queue, and carries out when it's turn comes around (determined by the tasks DispatcherPriority, which you can explicitly specify as a parameter to the Dispatcher.BeginInvoke() method). So by using a delegate, you are saying "Carry out all these operations", the same as when you subscribe to events like MouseDown, Click etc. Because the dispatcher is now carrying out the operations, and the dispatcher is owned by the window, they are carried out on the UI thread. Remember that the UI thread controls all the rendering and user interaction, so the more code you pass the dispatcher to do, the less responsive the window will become. Go ahead and try it - in one of lambda blocks in the sample I posted put a...

for(Int32 index = 0; index < 10000000; index++)
{
    // just keeping the processor busy...
}

...and watch your UI grind to a halt. Always be a bit careful of this. By using the lambda approach that I posted you are basically just using a delegate to contain a block of code for the dispatcher to carry out. But this could be also method, and you could just use a delegate to call that method, which is useful if the code you want to execute is used elsewhere in the program.

Threading is C#/WPF takes a bit of time to get your head around - it is a complicated topic, but once you do it will all swing into focus and be pretty clear why things are the way they are. It would get pretty messy if different threads could update the same UI element...

I hope this helps, don't take any of it as gospel because it is just my understanding of how it works and it may not be 100% correct, but it's how I think of it There's a heap of info on google about threading in C#, most of it much clearer than what I've just tapped out!