Proper way to open dialog and wait for result

[brunocapu]

Hello

Intended Scenario

We have a console application which runs background work while may launch ephemerous dialogs for user interaction.
E.g.:

Console.WriteLine("Show Dialog 1");
await ShowDialogAsync();

Console.WriteLine("Do Some Work...");

Console.WriteLine("Show Dialog 2");
await ShowDialogAsync();

We currently have this implemented in WPF by simply calling WPF ShowDialog, which is already sync, on STA Thread, which is not the Console Application main thread.

MainLoop API Misuse Approach

I've understood that calling the Dispatcher.UIThread.MainLoop multiple times, after the method Show, its an API misuse: #5229
Although it used to work fine on v0.8.3 and still works (v0.10.2) on Windows, while on macOS it throws RunLoop failed.
There is an attached sample project (AvaloniaBadMainLoop.zip) using this approach just as an example for the intended scenario.

Full Async Approach

I've also come up with an attempt of making sure the Console App main work is not running on the UI Thread so it can avoid awaiting for dialog result inside the UI, blocking the thread.
But in this case the App just terminates with no message:

Show Dialog 1
... AvaloniaAsyncAwaitDialog.exe (process 15224) exited with code 0.

See sample project: AvaloniaAsyncAwaitDialog.zip
ShowDialogAsyncsnippet:

static async Task ShowDialogAsync() {
	if (Dispatcher.UIThread.CheckAccess()) {
		Console.WriteLine("SHOULD NOT HAPPEN!");
		return;
	}

	var taskCompletion = new TaskCompletionSource<bool>();

	// also tried with: Dispatcher.UIThread.Post(() => {
	_ = Dispatcher.UIThread.InvokeAsync(() => {
		var dialog = new TestWindow();
		dialog.Closed += (s, e) => taskCompletion.SetResult(true);
		dialog.ShowDialog(dialog);
	});

	// await dialog close outside UI thread
	await taskCompletion.Task;
}

Question

So I would like to know if there is a known proper way of opening dialogs and wait for their result.
Thank you.

Attachments

AvaloniaBadMainLoop.zip
AvaloniaAsyncAwaitDialog.zip

[kekekeks]

Note that with MacOS you have to run GUI on your first thread. Calls to any GUI-related functions from other threads will result in a crash.
That's a Cocoa limitation.

[brunocapu]

Appreciate. I did not test the full async sample on Mac. The crash was on Windows.
Is there any other way for implementing this?

[kekekeks]

Well, the proper way of spawning dialogs from a console app would be to run Avalonia main loop on the main thread and run the console app logic on another one.
e. g.

public static void Main(string[] args)
{
    BuildAvaloniaApp().Start(UIMain, args);
}


public static void UIMain(Application app, string[] args)
{
    // Avalonia is already initialized here, so it's safe to spawn the thread for console Main
    var task = Task.Run(() => ConsoleMain(args));

    // Once console Main is finished we cancel the token, so avalonia run loop will be stopped as well
    var cts = new CancellationTokenSource();
    task.ContinueWith(_ => cts.Cancel());
    
    app.Run(cts.Token);
    
    // Rethrow any exceptions from ConsoleMain
    task.Wait();
}

public static void ConsoleMain(string[] args)
{
    Console.WriteLine("Console thread asks for text");
    var text = QueryTextAsync().Result;
    Console.WriteLine("Console thread got text: " + text);
}

static Task<string> QueryTextAsync()
{
    return Dispatcher.UIThread.InvokeAsync(async () =>
    {
        var tcs = new TaskCompletionSource();
        var tb = new TextBox();
        var btn = new Button {Content = "OK"};
        var window = new Window()
        {
            Content = new StackPanel
            {
                Children =
                {
                    new TextBlock {Text = "Enter text"},
                    tb,
                    btn
                }
            }
        };
        btn.Click += delegate { window.Close(); };
        window.Show();
        window.Closed += delegate { tcs.SetResult(); };
        await tcs.Task;
        return tb.Text;
    });
}

public static AppBuilder BuildAvaloniaApp()
    => AppBuilder.Configure<App>()
        .UsePlatformDetect();

[grokys]

As @kekekeks mentions you're hitting the fact that MacOS is quite prescriptive about how the main loop runs. The is probably a way around it (using [this](https://developer.apple.com/documentation/appkit/nsapplication/1428436-runmodalforwindow?language=objc for example?) but there's likely going to be a impedance between MacOS and other platforms to overcome.

It's probably a silly question, but can you make your console application async? Async main has been supported for a while.

(Disclaimer: this isn't my area of expertise so could be I've got it wrong)

[danwalmsley]

That is one option, although iv also come across this in the past, and you need to ensure Avalonia is initialised before any other await keyword is called, otherwise Avalonia wont be able to use the first thread of its main loop, and OSX will just not work at all.