Correct way to access UI from background thread in UWP

Question

When trying to add data to an ObservableCollection, which is x:Binded in XAML to a ListView on the UI, I get this error:The application called an interface that was marshalled for a different thread (Exception from HRESULT: 0x8001010E (RPC_E_WRONG_THREAD))

My app implements MVVM. VieModel pulls data with an eventhandler. I have tried various SO and other solutions, such as:

var ignored = Window.Current.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,() =>ViewList.Add(msg));

This gives the error: Current.Get == null

Can't access Dispatcher directly, as it is being called in the ViewModel. Also no .Invoke or .BeginInvoke access that I could find which several solutions suggested.

I tried using DispatcherTimer, as accoring to: Updating ObservableCollection from non UI thread. I get the "WRONG_THREAD" error message when trying to instantiate DispatcherTimer in the ViewModel, to access the UI thread:

disPatchTimer = new DispatcherTimer();

There is one suggestion that works, which many have upvoted here: The application called an interface that was marshalled for a different thread - Windows Store App

Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
    {
        // Your UI update code goes here!
    }
);

Which does not, at least, look like an elegant solution the "creators" had in mind to properly use code?

`Dispatcher.RunAsync` is a [correct way](https://stackoverflow.com/a/38150056/1997232) to invoke into UI thread. Your problem is to get `Dispatcher` instance (you are getting `null`, can't tell you why). In wpf there is a concept of application dispatcher, which is available *always* (as long as there is window on screen at least), see [this question](https://stackoverflow.com/q/54886699/1997232). — Sinatr, Aug 16 '19 at 10:17
@LucaLindholm, I only mention wpf to explain why linked question is applicable. I am well aware it's uwp question. — Sinatr, Aug 16 '19 at 11:20

score 4 · Answer 1 · answered Aug 16 '19 at 12:55

What you should do is to inject your view model with an interface that has a RunOnUIThreadAsync method or similar.

You would then create a class that implements this interface and calls Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync in the UWP app where you can assume that the CoreApplicationView is always available.

In your unit tests against the view model where there is no CoreApplicationView, you could simply mock the interface.

The other option would be to look into the BindingOperations.EnableCollectionSynchronization API that lets you access the collection from multiple threads.

score 4 · Accepted Answer · answered Aug 16 '19 at 15:04

The VieModel pulls data from the model into it's ObservableCollecton via a subscribed event.

You mention both "pull" and "event". Events are by nature "push" systems - the event is pushed to your code. However, there are some systems that produce asynchronous results via an event, so I assume that is what you're dealing with here since you specify the data is "pulled".

If this is correct, then the best solution is to first write a wrapper for the event-based asynchrony so it becomes task-based asynchrony. If you have a data service that looks like this:

class MyDataService
{
  public void DownloadData();
  public event MyDataArrivedEventHandler MyDataArrived;
}

then the wrapper would look something like this:

public static Task<MyData> GetMyDataAsync(this MyDataService service)
{
  var tcs = new TaskCompletionSource<MyData>();
  MyDataArrivedEventHandler handler = null;
  handler = (s,e) =>
  {
    service.MyDataArrived -= handler;
    if (e.Error != null) 
      tcs.TrySetException(e.Error);
    else 
      tcs.TrySetResult(e.Data);
  };
  service.MyDataArrived += handler;
  service.DownloadData();
  return tcs.Task;
}

Once you have a Task-based asynchronous pattern method, then consuming it and updating your viewmodel is straightforward:

// From UI thread.
var data = await service.GetMyDataAsync();
viewModel.AddRange(data); // or whatever

This approach allows you to use the context-capturing nature of await so that you don't have to do any thread transitions yourself.

Apologies @Stephen Cleary , I updated my question: "The VieModel gets the data from the model into it's ObservableCollecton via a normal subscribed event - subscribing to an instance of the Models' ObservableCollection.CollectionChanged+=" — Allstar, Aug 19 '19 at 07:29
@Allstar: In that case, your model is (indirectly) data-bound to the UI, so the easiest solution would be to treat it as part of the UI as well. My answer still applies, just changing "updating your viewmodel" to "updating your model". — Stephen Cleary, Aug 19 '19 at 12:03

Correct way to access UI from background thread in UWP

2 Answers2

Linked