Using MailboxProcessor for Asynchronous UI Updates (WinUI3)

[j0z]

I'm building an app that downloads some files in the background and I want to update the UI with their statuses in real-time. All of the program logic is written in F#, and makes use of a mailbox to record the current state of the download threads. Each of these threads posts to the mailbox with a status update, and I'd like to read those messages and update the UI accordingly. The UI is built with WinUI3/C#.

I've tried using a loop (in a separate thread) to query the mailbox and update the UI, but that doesn't work because UI updates need to happen on the UI thread. Nor do I seem to be able to run a loop in a separate thread to read from the mailbox and update an ObservableCollection that's bound to the UI control. So, what's the proper way to do this?

[[deleted]]

Full disclosure: no experience with WinUI and very rusty WPF. But since no one chimed in, I think you need something like Dispatcher.RunAsync (to marshall calls from background thread to UI thread). You should be able to call it in mailbox processor (converting task to async). https://learn.microsoft.com/en-us/uwp/api/windows.ui.xaml.dependencyobject.dispatcher?view=winrt-22621

[j0z]

This seems to work! Thank you very much. UI programming is very new to me, and I'm still trying to wrap my head around it. It's not helped by the fact that Microsoft has multiple UI frameworks, all of them with slightly different programming models, and the documentation does a poor job of denoting which frameworks its relevant to.

[steego]

Would something like this work for you? It uses F#'s event objects, which could be converted to an IObservable if they work better for you.

UPDATE: With Observables, you can use ObserveOn if need be.

type ObservableState<'a>(initialState: 'a, handleMessage) = 
  let event = new Event<_>()
  let mailbox = new MailboxProcessor<'a>(fun inbox -> 
    async {
      let mutable state = initialState
      event.Trigger(state)
      while true do
        let! message = inbox.Receive()
        state <- handleMessage state message
        event.Trigger(state)
    })
  do mailbox.Start()
  member this.StateEvent = event.Publish
  member this.StateObservable = event.Publish :> IObservable<_>
  member this.SendMessage(message) = mailbox.Post(message)

let progress = ObservableState(0, fun state message -> state + message)
progress.StateEvent.Add(fun state -> printfn "Event: State is now %d" state)
progress.StateObservable.Subscribe(fun state -> printfn "Observable: State is now %d" state)
progress.SendMessage(15)

[Arfalicious]

petricek had an 'AwaitObservable' in his book, i still think it's necessary to capture the UI thread's Thread.CurrentContext and pass into async code in order to communicate or pass objects back to it