Fix continuing when something fails

Author: shana

src/GitHub.Api/Tasks/TaskBase.cs

@@ -382,49 +382,64 @@ protected virtual void RaiseOnStart()
             OnStart?.Invoke(this);
         }
 
+        protected virtual bool RaiseFaultHandlers(Exception ex)
+        {
+            taskFailed = true;
+            exception = ex;
+            if (catchHandler == null)
+                return false;
+            foreach (var handler in catchHandler.GetInvocationList())
+            {
+                if ((bool)handler.DynamicInvoke(new object[] { ex }))
+                {
+                    exceptionWasHandled = true;
+                    break;
+                }
+            }
+            // if a catch handler returned true, don't throw
+            return exceptionWasHandled;
+        }
+
         protected virtual void RaiseOnEnd()
         {
             OnEnd?.Invoke(this, !taskFailed, exception);
+            SetupContinuations();
+            //Logger.Trace($"Finished {ToString()}");
+        }
+
+        protected void SetupContinuations()
+        {
             if (!taskFailed || exceptionWasHandled)
             {
-                if (continuationOnSuccess == null)
-                    CallFinallyHandler();
+                var taskToContinueWith = continuationOnSuccess ?? continuationOnAlways;
+                if (taskToContinueWith != null)
+                    SetContinuation(taskToContinueWith, runOnSuccessOptions);
                 else
-                    SetContinuation(continuationOnSuccess, runOnSuccessOptions);
+                { // there are no more tasks to schedule, call a finally handler if it exists
+                  // we need to do this only when there are no more continuations
+                  // so that the in-thread finally handler is guaranteed to run after any Finally tasks
+                    CallFinallyHandler();
+                }
             }
             else
             {
-                if (continuationOnFailure == null)
-                    CallFinallyHandler();
+                var taskToContinueWith = continuationOnFailure ?? continuationOnAlways;
+                if (taskToContinueWith != null)
+                    SetContinuation(taskToContinueWith, runOnFaultOptions);
                 else
-                    SetContinuation(continuationOnFailure, runOnSuccessOptions);
+                { // there are no more tasks to schedule, call a finally handler if it exists
+                  // we need to do this only when there are no more continuations
+                  // so that the in-thread finally handler is guaranteed to run after any Finally tasks
+                    CallFinallyHandler();
+                }
             }
-            //Logger.Trace($"Finished {ToString()}");
         }
 
-        protected void CallFinallyHandler()
+        protected virtual void CallFinallyHandler()
         {
             finallyHandler?.Invoke(!taskFailed);
         }
 
-        protected virtual bool RaiseFaultHandlers(Exception ex)
-        {
-            taskFailed = true;
-            exception = ex;
-            if (catchHandler == null)
-                return continuationOnFailure != null;
-            foreach (var handler in catchHandler.GetInvocationList())
-            {
-                if ((bool)handler.DynamicInvoke(new object[] { ex }))
-                {
-                    exceptionWasHandled = true;
-                    break;
-                }
-            }
-            // if a catch handler returned true or we have a continuation for failure cases, don't throw
-            return exceptionWasHandled || continuationOnFailure != null;
-        }
-
         protected Exception GetThrownException()
         {
             if (DependsOn == null)
@@ -617,16 +632,15 @@ protected virtual void RaiseOnEnd(TResult data)
         {
             this.result = data;
             OnEnd?.Invoke(this, result, !taskFailed, exception);
-            if (continuationOnSuccess == null && continuationOnFailure == null)
-            {
-                finallyHandler?.Invoke(!taskFailed, result);
-                CallFinallyHandler();
-            }
-            else if (continuationOnSuccess != null)
-                SetContinuation(continuationOnSuccess, runOnSuccessOptions);
+            SetupContinuations();
             //Logger.Trace($"Finished {ToString()} {result}");
         }
 
+        protected override void CallFinallyHandler()
+        {
+            finallyHandler?.Invoke(!taskFailed, result);
+        }
+
         public new Task<TResult> Task
         {
             get { return base.Task as Task<TResult>; }

src/tests/TaskSystemIntegrationTests/Tests.cs

@@ -850,7 +850,7 @@ public async Task RunningDifferentTasksDependingOnPreviousResult()
             var callOrder = new List<string>();
 
             var taskEnd = new ActionTask(Token, () => callOrder.Add("chain completed")) { Name = "Chain Completed" };
-            var final = taskEnd.Finally((_, __) => { });
+            var final = taskEnd.Finally((_, __) => { }, TaskAffinity.Concurrent);
 
             var taskStart = new FuncTask<bool>(Token, _ =>
                 {