How do I bind to ObservableCollection<T> which is being updated Async or in another thread

Question

0.00/5 (No votes)

See more:

In my ViewModel I have a ObservableCollection of type Point which is bound to one of the chart's series within the View. When the user clicks a button the an asynchronous call is made to a method which executes a computationally intensive calculation and updates the ObservableCollection throughout the process.

When it gets to the line that updates an element within the ObservableCollection an InvalidOperationException is thrown with the explanation that "The calling thread cannot access this object because a different thread owns it." I understand that this is occurring because I am trying to change an object which is bound to a control on the UI thread.

How do people typically deal with this problem? I'm hoping there is a very clean and straightforward way? Or do I have to make a call using a delegate to invoke on the ObservableCollection?

Update with more information:

I didn't use the .ConfigureAwait when launching the asynchronous method. Simply:

<br />
await Task.Factory.StartNew(() => methodName(parameter1));

A little more information I gathered while trying to get this to work. Initially I had an ObservableCollection of type System.Windows.Point which has an X and a Y property which is being used in the chart. Because the X and Y do not have a Set attribute I had to create a new Point element looking something like

<br />
observableCollection1[0] = new System.Windows.Point(newPointX, newPointY);<br />

It is at that line where the InvalidOperationException is thrown.

I tried it another way of creating a List of type Point and added each new newXPoint and newYPoint value to the list and then outside the loop created a new ObservableCollection object initialized with the List elements like so:

<br />
observableCollection1 = new ObservableCollection<system.windows.point>(tempList);</system.windows.point>

This does not throw the InvalidOperationException and seems to work fine. I imagine this is probably the better way to do it as well since the NotifyPropertyChanged event will only fire once instead of every time that an element set to a new instance of a Point object. Is that correct??

Regardless of which method is better I am still very confused why I am getting the InvalidOperationException. Any thoughts?

Posted 9-Feb-15 10:19am

MrGlass3

Updated 11-Feb-15 5:36am

v2

Add a Solution

Comments

Kenneth Haugland 9-Feb-15 16:40pm

Pretty straight forward. Here is one example:
http://www.codeproject.com/Articles/865337/WPF-Apps-Screen

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Richard Deeming · Answer 1 · 2015-02-09T10:49:00

Solution 1

If you're using .NET 4.5, you can use the BindingOperations.EnableCollectionSynchronization method[^] to allow you to update the collection from other threads:

C#

private static object _lock = new object();
private readonly ObservableCollection<Point> _points = new ObservableCollection<Point>();

public YourViewModel()
{
    BindingOperations.EnableCollectionSynchronization(_points, _lock);
}

DataBinding Features in WPF 4.5 - DotNetCurry[^]

Alternatively, if you use async / await (without using .ConfigureAwait(false) on your awaitables), the code should always run on the UI thread, and you should never see this exception.

Posted 9-Feb-15 10:49am

Richard Deeming

Comments

MrGlass3 11-Feb-15 11:20am

I didn't use the .ConfigureAwait when launching the asynchronous method. Simply:


await Task.Factory.StartNew(() => methodName(parameter1));

A little more information I gathered while trying to get this to work. Initially I had an ObservableCollection of type System.Windows.Point which has an X and a Y property which is being used in the chart. Because the X and Y do not have a Set attribute I had to create a new Point element looking something like


observableCollection1[0] = new System.Windows.Point(newPointX, newPointY);

It is at that line where the InvalidOperationException is thrown.

I tried it another way of creating a List of type Point and added each new newXPoint and newYPoint value to the list and then outside the loop created a new ObservableCollection object initialized with the List elements like so:


observableCollection1 = new ObservableCollection<system.windows.point>(tempList);</system.windows.point>

This does not throw the InvalidOperationException and seems to work fine. I imagine this is probably the better way to do it as well since the NotifyPropertyChanged event will only fire once instead of every time that an element set to a new instance of a Point object. Is that correct??

Regardless of which method is better I am still very confused why I am getting the InvalidOperationException. Any thoughts?

Richard Deeming 11-Feb-15 11:27am

Since you've used Task.Factory.StartNew, the methodName method is running on a background thread, not the UI thread. When it tries to update the collection, the collection changed event fires on that background thread, which WPF doesn't like.

Code that runs after the await line will still be running on the UI thread.

If you can't make methodName an async method, then the BindingOperations.EnableCollectionSynchronization approach is probably simplest.

Otherwise, you'd have to update methodName to not touch the collection, and return the list of changes instead. The calling method would then apply the changes to the collection, which would work since it's running on the UI thread.

MrGlass3 11-Feb-15 11:34am

I see what you are saying but I am confused at why there is no problem initializing a new ObservableCollection (which the chart is bound to) but there is a problem when initializing a new element within the ObservableCollection.

Richard Deeming 11-Feb-15 11:37am

Are you definitely raising the PropertyChanged event when you create a new collection?

If so, then it must be a quirk of how WPF collection data-binding works.

MrGlass3 11-Feb-15 11:43am

Positive. I went in and commented out the line which raises the PropertyChanged event just to make sure and now my chart does not get updated so the PropertyChanged event was definitely firing and updating the chart.

Hmmm this is going to bug me but I think the way I am currently doing it is better than my original plan so at least it works...

MrGlass3 16-Feb-15 13:15pm

I have been searching different forums trying to figure out this problem and throughout all my searching I stumbled on my own post again so I figured this is as good of a place as any to post another question.

Most places, and you as well, have suggested using the BindingOperations.EnableCollectionSynchronization however I have not found this to solve anything.

Perhaps I am using it incorrectly? The ObservableCollection is a parameter in the ViewModel and is bound to a chart in the View. I created a static object _lockObject in the ViewModel and in the constructor of the ViewModel I added the line BindingOperations.EnableCollectionSynchronization(observableCollection1, _lockObject); and that is it - is there more to be done?

In the Async method I created to test this I just did something simple like add 100 elements to observableCollection1 and the InvalidOperationException is thrown. Another odd thing I've found is this exception is not thrown when adding a low number of elements. If adding only 10 elements, the exception is never thrown while adding 1000 it is almost always thrown. Is something else going on here?

Richard Deeming 16-Feb-15 14:14pm

Everything I've seen suggests that calling BindingOperations.EnableCollectionSynchronization in the constructor should just work. You should then be able to add items from a background thread without getting the dispatcher thread error.

Async methods initiated from the UI thread should also work, because you're adding the items from the UI thread. Try writing the thread ID to the debug output before adding each item to make sure it's the UI thread, and to see if it changes.

MrGlass3 16-Feb-15 14:39pm

To try to figure out what is going on I have been creating a new thread and running the method on that to ensure modifications aren't on the main thread (partially to test and also because this will be how my application will actually run).

I haven't found that BindingOperations.EnableCollectionSynchronization does anything for me. I can modify the properties of the elements within the ObservableCollection without a problem (even when not using the EnableCollectionSynchronization) the problem only seems to exist when Adding elements.

The one workaround I found was capturing the Dispatcher within the constructor of the ViewModel by:


Dispatcher _dispatcher;

public ViewModelClass()
{
_dispatcher = Dispatcher.CurrentDispatcher;
}

public async AddItemsAsync()
{
_dispatcher.BeginInvoke( new Action( ()=> 
   {
     observableCollection1.Add(new Point(1,2));
}
   }

Richard Deeming 16-Feb-15 14:47pm

If you're calling AddItemsAsync from a background thread, that would explain why it doesn't run on the UI thread!

The typical async approach would be to call the method from the UI thread, which would use await to wait for the new items to load asynchronously, and then add the items to the collection. Without .ConfigureAwait(false), the code running after the await call will be running in the same context as the code before it.

MrGlass3 16-Feb-15 14:51pm

I am running the method on a different thread because it will take 10+ minutes to complete what it is doing. I want to update the collection throughout the process so the UI can be updated as to the progress. If I simply us an await on the UI thread, the window will just remain blank for 10 or so minutes until it is done.