Trouble with UI Threads and Backgroundworker

Question

What I'm trying to achieve is simple. I have a dynamic timer (one that can be changed by the user) which calls on background worker to go and fetch the user's external IP address. The combination of Timer and BackgroundWorker is causing some problems. Here's the code:

namespace IPdevices
{
    /// <summary>
    /// Interaction logic for Main.xaml
    /// </summary>
    public partial class Main : Window
    {

        private readonly BackgroundWorker worker;

        private IPret iprep;

        private Timer timer;


        public Main(Client client)
        {

            InitializeComponent();

            iprep = new IPret();

            startClock();

            worker  = new BackgroundWorker();
            worker.DoWork += worker_DoWork;
            worker.RunWorkerCompleted += worker_RunWorkerCompleted;
            worker.WorkerReportsProgress = true;
            worker.ProgressChanged += worker_ProgressChanged;

        }

        private void worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            ipAdd.Content = e.UserState;
        }

        private void startClock()
        {
            timer = new Timer();
            timer.Interval = 2000;
            timer.Elapsed += new ElapsedEventHandler(clockTimer_Tick);
            timer.Start();
        }

        private void clockTimer_Tick(object sender, ElapsedEventArgs e)
        {
            timer.Stop();
            worker.RunWorkerAsync();
        }

        private void worker_DoWork(object sender, DoWorkEventArgs e)
        {
            Console.WriteLine("Checking ip");
            iprep.refresh();
            worker.ReportProgress(0, iprep.getExternalIp());
            Console.WriteLine("Found ip");
        }

        private void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            timer.Start();
        }

    }
}

Essentially, once the timer fires, I wish to fetch the ip address and output on a label in the application. However, I get an exception in the ProgressChanged method saying that it can't be changed because another thread owns it. Which thread is that? Is it the iprep that is owned by another thread? In fact, RunWorkerCompleted never gets fired. I'm having trouble understanding which threads own what and how objects are locked...Any insight would be appreciated.

Answer 1

This appears to fix it in my test of it

    private void clockTimer_Tick(object sender, ElapsedEventArgs e)
    {
        timer.Stop();
        Action a = () =>
        {
            worker.RunWorkerAsync();
        };
        Application.Current.Dispatcher.BeginInvoke(a);
    }

Also, I'll note this is consistent behavior for Timer in WPF (I hadn't used it in WPF before); trying ipAdd.Content = "Tick"; in the clockTimer_Tick causes the same error. System.Timers.Timer's tick event does not happen on the UI thread.

Answer 2

ipAdd is an UI element if I am not mistaken. If it is then the problem lies on cross threading.

What happened is that Background worker is going to be running on a different thread than the UI thread. If you want to modify UI element's property you need to do it on the UI thread. One option is to use Dispatcher.Invoke but since you are using WPF, there is a better way to do it.

Do a search about MVVM design patter and move the background code into View Model. Then you could do something like

string _XXContent 
public string XXContent 
{
    get
    {
        return _XXContent;
    }
    set
    {
        _XXContent = value;
        OnPropertyChanged("XXContent");
    }
}


 private void worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
 {
     XXContent = e.UserState;
 }

xaml :

<TextBox Content={Binding XXContent}/>

Edit: If you are on c# 5 then you should look into async/IProgress as well an get rid of Background worker.

Answer 3

Replace all your code by the few lines shown below. The Tick handler is executed in the UI thread. Still it asynchronously runs a background operation and does not block the UI thread.

private void StartClock()
{
    var timer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(2) };
    timer.Tick += async (o, e) => await GetIP();
    timer.Start();
}

private async Task GetIP()
{
    Debug.WriteLine("Checking ip");

    await Task.Run(() =>
    {
        // Get the IP asynchronously here
    });

    Debug.WriteLine("Found ip");

    // Update the UI here
}