7

Title says it all, docs don't seem to say which should be preferred. They have the same arguments you can pass basically too.

https://learn.microsoft.com/en-us/dotnet/api/microsoft.maui.applicationmodel.mainthread.invokeonmainthreadasync?view=net-maui-7.0

https://learn.microsoft.com/en-us/dotnet/api/microsoft.maui.dispatching.dispatcherextensions.dispatchasync?view=net-maui-7.0#microsoft-maui-dispatching-dispatcherextensions-dispatchasync(microsoft-maui-dispatching-idispatcher-system-action)

I think they both do the same thing functionally but I need to know best practice for my company's app. I don't see this question around already either.

ShadyHippo
  • 71
  • 2
  • 3
  • 1
    Does this help? [Which is better MainThread.Being/Invoke... VS Dispatcher.Dispatch.](https://github.com/dotnet/maui/discussions/7518) – Liqun Shen-MSFT Dec 15 '22 at 05:05

1 Answers1

9

tl;dr: "best practice" is to call Dispatcher on some UI object.

mattleibow's explanation. Thanks to Ligun Shen-MSFT for this link as a comment on question.

... The MainThread is static so it is mostly correct. Let me explain.

When you have a UI component (BindableObject, Button, Page, Window), it knows which thread it is assigned to. Some platforms, like Windows and iOS, require that UI objects be created on the UI thread. It will throw otherwise. And, the dispatcher is initialized to that thread.

MainThread has no concept of the UI thread so picks the first one. In most cases, it is correct because most platforms only have 1 "main thread". Windows is an outlier to this because it supports windows on separate threads. ...

From senior Microsoft techie Rob Caplan's answer (google Rob Caplan Microsoft for more info about who he is):

"InvokeOnMainThread was an oversimplification - not all apps have a main thread or a singular UI thread. Associating the Dispatcher to a UI object (which will in turn be tied to a thread) is more general and better supports multi-window applications."

That is: accessing the Dispatcher on some UI object is "more general" than using MainThread.

MY SUMMARY:

IF this is a Single Window app, AND you are writing code that is not code-behind (not part of a UI object), THEN Application.Current.Dispatcher is convenient and safe. So is MainThread.BeginInvokeOnMainThread. These two behave identically; it doesn't matter which you use in this case. However, consider various points below, such that Dispatcher is slightly favored as "best practice".

  • MOCK TESTING: its easier to make a mock IDispatcher, than to replace MainThread static class.

DETAILS:

  • If you are in code-behind (code associated with some UI object), use this.Dispatcher.... (You can omit this.; I just added it for clarity.)

  • If you are NOT in code-behind, and ARE in a single window app, Application.Current.Dispatcher and MainThread methods behave identically. HOWEVER, Application.Current.Dispatcher is preferred, because it is an IDispatcher object. Thus, it has the same syntax as the above "code-behind" case. And you can easily refactor some logic, if you need to pass to a different IDispatcher. E.g. for MOCK TESTING. OR if in the future your code gets used in a multi-window app.

  • DO NOT use EITHER MainThread nor Application.Current.Dispatcher in a multi-window app. You MUST get hold of a UI object on the window being touched. If you are writing code in a UI element, use this.Dispatcher. [this. is optional; shown for clarity.] OR pass in to your method a reference to any UI element of that window (someUIElement.Dispatcher).

Technical Note:

Does the presence of Dispatcher property mean App is "a UI object"?

[OPINION] Not quite. IMHO, any class which descends from VisualElement is "a UI object". These can be shown on a display.

App is partially compatible with UI objects, because both VisualElement and App inherit from Microsoft.Maui.Controls.Element.

Importantly, for this answer, Element inherits from BindableObject, which defines Dispatcher property.

What's missing from App, that is in all VisualElements?

Navigation. Style. And a long list of Properties related to display (Window, IsVisible, Width and Height, etc.)

ToolmakerSteve
  • 18,547
  • 14
  • 94
  • 196
  • 2
    This seems correct and thank you for posting the correct answer. But then I am upset with MS for their abysmal documentation. It's absurd their official docs here https://learn.microsoft.com/en-us/dotnet/maui/platform-integration/appmodel/main-thread?view=net-maui-7.0 called "Create a thread on the .NET MAUI UI thread" is wrong then. I have been so so so frustrated with the documentation and bugs of Maui. I guess add this to the list. Why do the official docs have NO mention of the correct way, and the correct way is only found on some forum post? Obviously not your fault, ty again. – ShadyHippo Dec 16 '22 at 18:37
  • 1
    Ah, good observation re docs. Looks like what happened is they updated the doc from Xamarin Forms (where it was Device.BeginInvokeOnMainThread), without full feedback from the devs. `MainThread` was the way to do it, a bit earlier in Maui. Before "multiple window" support on desktop. And before anyone realized `Dispatcher` was better for "testability". It isn't too bad; `MainThread.BeginInvokeOnMainThread` will work fine for most apps. There has been a push to "streamline/simplify" Maui for new programmers, to make it easier to get into. I think `MainThread` is part of this. – ToolmakerSteve Dec 17 '22 at 00:44