Improve Form.ShowAsync and Form.ShowDialogAsync (#13808)

* Added unit tests for `ShowAsync`
* Improved `ShowAsync` and `ShowDialogAsync` by associating the Form via
`WeakReference` with the returned Task's `AsyncState`, so that it's easy
to retrieve the Form from a returned Task in `Task.WhenAny` scenarios.
* Added unit test for that particular scenario.

###### Microsoft Reviewers: [Open in
CodeFlow](https://microsoft.github.io/open-pr/?codeflow=https://github.com/dotnet/winforms/pull/13808)

Author: KlausLoeffelmann

src/System.Windows.Forms/System/Windows/Forms/Form.cs

@@ -5574,18 +5574,21 @@ public void Show(IWin32Window? owner)
     ///  <para>Thrown if the owner window is trying to set itself as its own owner.</para>
     /// </exception>
     [Experimental(DiagnosticIDs.ExperimentalAsync, UrlFormat = DiagnosticIDs.UrlFormat)]
-    public async Task ShowAsync(IWin32Window? owner = null)
+    public Task ShowAsync(IWin32Window? owner = null)
     {
         // We lock the access to the task completion source to prevent
         // multiple calls to ShowAsync from interfering with each other.
         lock (_lock)
         {
-            if (_nonModalFormCompletion is not null || _modalFormCompletion is not null)
+            if (_nonModalFormCompletion is not null
+                || _modalFormCompletion is not null)
             {
                 throw new InvalidOperationException(SR.Form_HasAlreadyBeenShownAsync);
             }
 
-            _nonModalFormCompletion = new(TaskCreationOptions.RunContinuationsAsynchronously);
+            _nonModalFormCompletion = new(
+                new WeakReference<Form>(this),
+                TaskCreationOptions.RunContinuationsAsynchronously);
         }
 
         if (SynchronizationContext.Current is null)
@@ -5598,20 +5601,7 @@ public async Task ShowAsync(IWin32Window? owner = null)
 
         syncContext.Post((state) => ShowFormInternally(owner), null);
 
-        // Wait until the form is closed or disposed.
-        try
-        {
-            await _nonModalFormCompletion.Task.ConfigureAwait(true);
-        }
-        catch (Exception ex)
-        {
-            // We need to rethrow the exception on the caller's context.
-            Application.OnThreadException(ex);
-        }
-        finally
-        {
-            _nonModalFormCompletion = null;
-        }
+        return _nonModalFormCompletion.Task;
 
         void ShowFormInternally(IWin32Window? owner)
         {
@@ -5623,6 +5613,7 @@ void ShowFormInternally(IWin32Window? owner)
             catch (Exception ex)
             {
                 _nonModalFormCompletion.TrySetException(ex);
+                _nonModalFormCompletion = null;
             }
         }
     }
@@ -5891,12 +5882,15 @@ private Task<DialogResult> ShowDialogAsyncInternal(IWin32Window? owner)
     {
         lock (_lock)
         {
-            if (_nonModalFormCompletion is not null || _modalFormCompletion is not null)
+            if (_nonModalFormCompletion is not null
+                || _modalFormCompletion is not null)
             {
                 throw new InvalidOperationException(SR.Form_HasAlreadyBeenShownAsync);
             }
 
-            _modalFormCompletion = new TaskCompletionSource<DialogResult>(TaskCreationOptions.RunContinuationsAsynchronously);
+            _modalFormCompletion = new TaskCompletionSource<DialogResult>(
+                state: new WeakReference<Form>(this),
+                creationOptions: TaskCreationOptions.RunContinuationsAsynchronously);
         }
 
         if (SynchronizationContext.Current is null)
@@ -5918,11 +5912,11 @@ void ShowDialogProc(ref TaskCompletionSource<DialogResult> modalFormCompletion,
             try
             {
                 DialogResult result = ShowDialog(owner);
-                modalFormCompletion.SetResult(result);
+                modalFormCompletion.TrySetResult(result);
             }
             catch (Exception ex)
             {
-                modalFormCompletion.SetException(ex);
+                modalFormCompletion.TrySetException(ex);
             }
             finally
             {

src/test/unit/System.Windows.Forms/System/Windows/Forms/FormAsyncExtensions.cs

@@ -0,0 +1,40 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#nullable disable
+
+namespace System.Windows.Forms.Tests;
+
+internal static class FormAsyncExtensions
+{
+    public static Task WaitForHandleCreatedAsync(this Form form)
+    {
+        ArgumentNullException.ThrowIfNull(form, nameof(form));
+
+        TaskCompletionSource tcs = new TaskCompletionSource(new WeakReference(form));
+        form.HandleCreated += Form_HandleCreated;
+
+        return tcs.Task;
+
+        void Form_HandleCreated(object sender, EventArgs e)
+        {
+            ((Form)sender).HandleCreated -= Form_HandleCreated;
+            tcs.TrySetResult();
+        }
+    }
+
+    public static Form ToForm(this Task task)
+    {
+        ArgumentNullException.ThrowIfNull(task, nameof(task));
+
+        if (task.AsyncState is WeakReference<Form> weakRefToForm)
+        {
+            if (weakRefToForm.TryGetTarget(out Form form))
+            {
+                return form;
+            }
+        }
+
+        return null;
+    }
+}

src/test/unit/System.Windows.Forms/System/Windows/Forms/FormTests.cs

@@ -9,7 +9,7 @@
 
 namespace System.Windows.Forms.Tests;
 
-public class FormTests
+public partial class FormTests
 {
     [WinFormsFact]
     public void Form_Ctor_Default()
@@ -2656,6 +2656,71 @@ public void Form_Show_SetsOwnerToTopLevelForm_WhenShownWithOwner(Action<Form, Co
         Assert.False(child.IsHandleCreated);
     }
 
+#pragma warning disable WFO5002 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
+    [WinFormsFact]
+    public async Task Form_ShowAsync_GeneralTaskTests()
+    {
+        using Form mainForm = new();
+
+        Task frmTask = mainForm.ShowAsync();
+
+        Task closerTask = Task.Run(async () =>
+        {
+            await Task.Delay(100).ConfigureAwait(false);
+            mainForm.Close();
+        });
+
+        await Task.WhenAll(frmTask, closerTask)
+            .ConfigureAwait(false);
+    }
+
+    [WinFormsFact]
+    public async Task Form_ShowAsync_GetFormFromReturnedTask()
+    {
+        Dictionary<Task, Form> formControlTasks = [];
+        Random random = new();
+
+        for (int i = 0; i < 5; i++)
+        {
+            Form form = new()
+            {
+                Text = $"Form {i}",
+                Size = new Size(200, 200),
+            };
+
+            form.Load += async (sender, e) =>
+            {
+                await Task.Delay(random.Next(20, 100))
+                    .ConfigureAwait(true);
+
+                ((Form)sender).Close();
+            };
+
+            formControlTasks.Add(
+                key: form.ShowAsync(),
+                value: form);
+        }
+
+        while (formControlTasks.Count > 0)
+        {
+            Task finishedTask = await Task
+                .WhenAny(formControlTasks.Keys)
+                .ConfigureAwait(false);
+
+            if (finishedTask.ToForm() is Form form)
+            {
+                Assert.Same(
+                    // The form, which we got through the task's AsyncState.
+                    form,
+                    // The form, which got through the lookup.
+                    formControlTasks[finishedTask]);
+            }
+
+            formControlTasks.Remove(finishedTask);
+        }
+    }
+#pragma warning restore WFO5002 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
+
     [WinFormsFact]
     public void Form_ParentThenSetShowInTaskbarToFalse()
     {