Refactor

Author: JamesNK

src/Grpc.Net.Client/Internal/GrpcCall.cs

@@ -186,10 +186,7 @@ public void Dispose()
 
                 // If the call was disposed then observe any potential response exception
                 // Observe the task's exception to prevent TaskScheduler.UnobservedTaskException from firing.
-                if (_responseTcs != null)
-                {
-                    ObserveException(_responseTcs.Task);
-                }
+                _responseTcs?.Task.ObserveException();
             }
         }
 
@@ -329,10 +326,7 @@ private async Task<Metadata> GetResponseHeadersCoreAsync()
                 // If there was an error fetching response headers then it's likely the same error is reported
                 // by response TCS. The user is unlikely to observe both errors.
                 // Observe the task's exception to prevent TaskScheduler.UnobservedTaskException from firing.
-                if (_responseTcs != null)
-                {
-                    ObserveException(_responseTcs.Task);
-                }
+                _responseTcs?.Task.ObserveException();
 
                 if (ResolveException(ErrorStartingCallMessage, ex, out _, out var resolvedException))
                 {
@@ -606,43 +600,30 @@ private async Task RunCall(HttpRequestMessage request, TimeSpan? timeout)
 
                     // Update HTTP response TCS before clean up. Needs to happen first because cleanup will
                     // cancel the TCS for anyone still listening.
-                    SetTcsException(_httpResponseTcs, resolvedException, observeException: true);
+                    _httpResponseTcs.TrySetException(resolvedException);
+                    _httpResponseTcs.Task.ObserveException();
 
                     Cleanup(status.Value);
 
                     // Update response TCS after overall call status is resolved. This is required so that
                     // the call is completed before an error is thrown from ResponseAsync. If it happens
                     // afterwards then there is a chance GetStatus() will error because the call isn't complete.
-                    SetTcsException(_responseTcs, resolvedException, observeException: IsCancellationOrDeadlineException(ex));
+                    if (_responseTcs != null)
+                    {
+                        _responseTcs.TrySetException(resolvedException);
+                        
+                        // Always observe cancellation-like exceptions.
+                        if (IsCancellationOrDeadlineException(ex))
+                        {
+                            _responseTcs.Task.ObserveException();
+                        }
+                    }
                 }
 
                 // Verify that FinishCall is called in every code path of this method.
                 // Should create an "Unassigned variable" compiler error if not set.
                 Debug.Assert(finished);
             }
-
-            static void SetTcsException<T>(TaskCompletionSource<T>? tcs, Exception ex, bool observeException)
-            {
-                if (tcs != null)
-                {
-                    tcs.TrySetException(ex);
-
-                    // It's possible the TCS is never awaited.
-                    // Observe the task's exception to prevent TaskScheduler.UnobservedTaskException from firing.
-                    if (observeException)
-                    {
-                        ObserveException(tcs.Task);
-                    }
-                }
-            }
-        }
-
-        private static void ObserveException(Task task)
-        {
-            if (task.IsFaulted)
-            {
-                _ = task.Exception;
-            }
         }
 
         private bool IsCancellationOrDeadlineException(Exception ex)

src/Grpc.Net.Client/Internal/TaskExtensions.cs

@@ -0,0 +1,51 @@
+#region Copyright notice and license
+
+// Copyright 2019 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#endregion
+
+namespace Grpc.Net.Client.Internal
+{
+    internal static class TaskExtensions
+    {
+        private static readonly Action<Task> IgnoreTaskContinuation = t => { _ = t.Exception; };
+
+        /// <summary>
+        /// Observes and ignores a potential exception on a given Task.
+        /// If a Task fails and throws an exception which is never observed, it will be caught by the .NET finalizer thread.
+        /// This function awaits the given task and if the exception is thrown, it observes this exception and simply ignores it.
+        /// This will prevent the escalation of this exception to the .NET finalizer thread.
+        /// </summary>
+        /// <param name="task">The task to be ignored.</param>
+        public static void ObserveException(this Task task)
+        {
+            if (task.IsCompleted)
+            {
+                if (task.IsFaulted)
+                {
+                    _ = task.Exception;
+                }
+            }
+            else
+            {
+                task.ContinueWith(
+                    IgnoreTaskContinuation,
+                    CancellationToken.None,
+                    TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously,
+                    TaskScheduler.Default);
+            }
+        }
+    }
+}