C# / WPF Databinding and backgroundworkers

Question

Update2

I've rewritten the entire question, because some things became a lot clearer, the issue now seems to be that I created a list of DependencyProperties on a different thread than where the DependencyProperties will be used :(.

When I do some work on a BackgroundWorker the XAML bindings cause an ArgumentException

Must create DependencySource on same Thread as the DependencyObject.

I've got the following setup:

I've got a simple class that implements INotifyPropertyChanged which contains a few ints, list's and Dictionaries.

public class Calculator : INotifyPropertyChanged
{
    //Note that InstanceGroup is a dependency object
    private List<InstanceGroup> instanceGroups = new List<InstanceGroup>();
    public List<InstanceGroup> InstanceGroups
    {
        get { return instanceGroups; }
        set { instanceGroups = value; }
    }

    // snip //

    public void Calculate()
    {
        InstanceGroups = MyNewFilledInstanceGroup;
            if (PropertyChanged != null)
            {
              PropertyChanged(this, new PropertyChangedEventArgs("instanceGroups"));
            }
    }
}

In a UserControl I use a BackgroundWorker to run the Calculate method, because it can take a lot of time:

BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += delegate(object o, DoWorkEventArgs args)
{
    lock (Calculator)
    {       
        Calculator.Calculate();
    }
};
worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted);
worker.RunWorkerAsync();

In the XAML file of the UserControl I have multiple bindings to the Calculator, like {Binding Path=Calculator.InstanceGroups, Path=userControlName}.

(The overall goal is to be able to do all the work in the Calculate method on a separate thread so I can show a progress bar or something like that)

score 2 · Answer 1 · edited Aug 23 '13 at 00:03

2

I am not convinced that you need to use DP for this Observable collection. Best to store it in ViewModel.

ObservableCollections are not thread-safe, and you need to use Dispatcher to update the collection.

Google there were some posts with Extension to ObservableCollection which used Dispatcher.

This link might help

edited Aug 23 '13 at 00:03

Alex Klaus

8,168
8
71
87

answered Aug 16 '11 at 12:07

Bek Raupov

3,782
3
24
42

Hey Anvarbek, I've (temporarily) replaced the ObservableCollection with a normal List<> but the problem persists. – Roy T. Aug 16 '11 at 12:14

score 1 · Answer 2 · answered Aug 16 '11 at 12:35

1

Any DependencyObject includes a Dispatcher property that can help you push work to the correct thread for that object.

You can use Dispatcher.Invoke or Dispatcher.BeginInvoke to run code on the correct thread.

answered Aug 16 '11 at 12:35

Dan Puzey

33,626
4
73
96

Alex Klaus · Answer 3 · 2013-08-23T01:32:36.683

For the sake of completeness I'd mention two solutions of WPF guru Dean Chalk:

Create a thread-safe observable collection. It's an old school solution that just works. To get the source code check a short article in his blog. This one was mentioned by anvarbek raupov in this thread earlier. Similar solution is in Sasha Barber's blog.
Use Reactive Extensions library. See this article for an example. It's a bit bulky for one task, but meanwhile it brings a bunch of modern tools what come in handy.

score 0 · Accepted Answer · edited May 23 '17 at 11:55

0

The only solution seems to be to not create DependencyProperties ( How to handle ObservableCollection<> result from a parallelized Task in MVVM? ) in a background task, this weird behavior costed me the better part of the day. But at least now I know what the problem was.

edited May 23 '17 at 11:55

Community

1
1

answered Aug 16 '11 at 13:37

Roy T.

9,429
2
48
70

C# / WPF Databinding and backgroundworkers

4 Answers4