Cancellation management in InitializeApplicationAsync

src/Microsoft.VisualStudio.ProjectSystem.Managed.VS/ProjectSystem/VS/HotReload/ProjectHotReloadSessionManager.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements. The .NET Foundation licenses this file to you under the MIT license. See the LICENSE.md file in the project root for more information.
 
 using System.Diagnostics;
+using System.Xml.Linq;
 using Microsoft.VisualStudio.Debugger.Contracts.HotReload;
 using Microsoft.VisualStudio.Debugger.Interop;
 using Microsoft.VisualStudio.HotReload.Components.DeltaApplier;
@@ -201,24 +202,54 @@ async Task ActivateSessionInternalAsync()
         {
             if (_pendingSessionState is { Session: IProjectHotReloadSession session })
             {
-                Process process = Process.GetProcessById((int)vsDebugTargetProcessInfo.dwProcessId);
-                _pendingSessionState.LaunchedProcess = launchedProcess;
-                _pendingSessionState.Process = process;
+                Process? process = null;
+                try
+                {
+                    _pendingSessionState.LaunchedProcess = launchedProcess;
+                    process = Process.GetProcessById((int)vsDebugTargetProcessInfo.dwProcessId);
+                    _pendingSessionState.Process = process;
+                }
+                catch (ArgumentException)
+                {
+                    // process might have been exited in some cases.
+                    // in that case, we early return without starting hotreload session
+                    // one way to mimic this is to hit control + C as fast as you can once hit F5/Control + F5
+                    _pendingSessionState = null;
+                    return;
+                }
+
+                CancellationTokenSource cts = new CancellationTokenSource();
+                process.Exited += (sender, e) =>
+                {
+                    DebugTrace("Process exited");
+                    cts.Cancel();
+                };
 
                 if (!process.HasExited)
                 {
-                    process.Exited += (sender, e) =>
-                    {
-                        _threadingService.ExecuteSynchronously(() => session.StopSessionAsync(CancellationToken.None));
-                    };
                     process.EnableRaisingEvents = true;
-
-                    await _pendingSessionState.Session.StartSessionAsync(CancellationToken.None);
-                    lock (_activeSessionStates)
+                    await _pendingSessionState.Session.StartSessionAsync(cts.Token);
+                    if (cts.IsCancellationRequested)
                     {
-                        _activeSessionStates.Add(_pendingSessionState);
+                        // Process exited before we could start the session
+                        DebugTrace("Hot Reload session not started because process exited.");
+                        _pendingSessionState = null;
+                        return;
+                    }
+                    else
+                    {
+                        DebugTrace("Hot Reload session started.");
+                        cts.Token.Register(() =>
+                        {
+                            DebugTrace("Cancellation requested, stopping session.");
+                            _threadingService.RunAndForget(() => session.StopSessionAsync(default), _unconfiguredProject);
+                        });
+                        lock (_activeSessionStates)
+                        {
+                            _activeSessionStates.Add(_pendingSessionState);
+                        }
+                        await _projectHotReloadNotificationService.Value.SetHotReloadStateAsync(isInHotReload: true);
                     }
-                    await _projectHotReloadNotificationService.Value.SetHotReloadStateAsync(isInHotReload: true);
                 }
 
                 _pendingSessionState = null;
@@ -301,4 +332,18 @@ public async Task<bool> StopProjectAsync(CancellationToken cancellationToken)
             return true;
         }
     }
+
+    private void DebugTrace(string message)
+    {
+#if DEBUG
+        var projectName = _unconfiguredProject.GetProjectName();
+        _hotReloadDiagnosticOutputService.Value.WriteLine(
+            new HotReloadLogMessage(
+                HotReloadVerbosity.Detailed,
+                message,
+                projectName,
+                errorLevel: HotReloadDiagnosticErrorLevel.Info),
+            CancellationToken.None);
+#endif
+    }
 }

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/HotReload/DeltaApplier.cs

@@ -33,7 +33,13 @@ public async ValueTask<ImmutableArray<string>> GetCapabilitiesAsync(Cancellation
 
     public async ValueTask InitializeApplicationAsync(CancellationToken cancellationToken)
     {
-        _ = await client.GetUpdateCapabilitiesAsync(cancellationToken);
+        // Not all clients respond correctly to cancellation tokens.
+        // For example, `DefaultHotreloadClient.GetUpdateCapabilitiesAsync(ct)`doesn't listen to the passed ct.
+        // Since DefaultHotreloadClient is defined in a source package, it can't be modified directly from project-system.
+        // Work around this by creating a TaskCompletionSource that completes when the token is cancelled.
+        TaskCompletionSource tcs = new TaskCompletionSource();
+        cancellationToken.Register(() => tcs.TrySetResult());
+        _ = Task.WaitAny(client.GetUpdateCapabilitiesAsync(cancellationToken), tcs.Task);
 
         // TODO: apply initial updates?
         // https://devdiv.visualstudio.com/DevDiv/_workitems/edit/2571676

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/HotReload/ProjectHotReloadSession.cs

@@ -185,7 +185,7 @@ public async Task StartSessionAsync(CancellationToken cancellationToken)
 
         await _hotReloadAgentManagerClient.Value.AgentStartedAsync(this, flags, processInfo, runningProjectInfo, cancellationToken);
 
-        WriteToOutputWindow(Resources.HotReloadStartSession, default);
+        WriteToOutputWindow(Resources.HotReloadStartSession, cancellationToken);
 
         if (await GetOrCreateDeltaApplierAsync(cancellationToken) is IDeltaApplierInternal applierInternal)
         {