Updated extensions.

Author: Oren (electricessence)

CancellableTask.cs

@@ -94,7 +94,7 @@ public static CancellableTask Start(TimeSpan delay, Action action = null, TaskSc
 				{
 					cancellable.ContinueWith(t => cancellable.Cancel()); // If this is arbitrarily run before the delay, then cancel the delay.
 					Delay(delay, token)
-						.OnFullfilled(() => cancellable.Start(scheduler));
+						.OnFullfilled(() => cancellable.EnsureStarted(scheduler));
 				}
 			}
 

Open.Threading.csproj

@@ -10,7 +10,7 @@
 Part of the "Open" set of libraries.</Description>
     <PackageLicenseUrl>https://github.com/electricessence/Open.Threading/blob/master/LISCENSE.md</PackageLicenseUrl>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
-    <Version>1.1.0</Version>
+    <Version>1.1.1</Version>
     <AssemblyVersion>1.0.0.1</AssemblyVersion>
     <FileVersion>1.0.0.1</FileVersion>
     <Copyright>https://github.com/electricessence/Open.Threading/blob/master/LISCENSE.md</Copyright>
@@ -24,6 +24,13 @@ Part of the "Open" set of libraries.</Description>
     <Compile Remove="AsyncReadWriteModificationSynchronizer.cs" />
   </ItemGroup>
 
+  <ItemGroup>
+    <None Remove=".git" />
+    <None Remove=".gitignore" />
+    <None Remove="LISCENSE.md" />
+    <None Remove="README.md" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="Open.Diagnostics" Version="1.0.1" />
     <PackageReference Include="Open.Threading.ReadWrite" Version="1.0.1" />

TaskExtensions.cs

@@ -5,6 +5,9 @@ namespace Open.Threading
 {
 	public static class TaskExtensions
 	{
+		/// <summary>
+		/// Returns true if the target Task has not yet run, is waiting, or is running, else returns false.
+		/// </summary>
 		public static bool IsActive(this Task target)
 		{
 			if (target == null)
@@ -18,83 +21,130 @@ public static bool IsActive(this Task target)
 				case TaskStatus.WaitingForChildrenToComplete:
 				case TaskStatus.WaitingToRun:
 					return true;
-				case TaskStatus.Canceled:
-				case TaskStatus.Faulted:
-				case TaskStatus.RanToCompletion:
-					return false;
+				//case TaskStatus.Canceled:
+				//case TaskStatus.Faulted:
+				//case TaskStatus.RanToCompletion:
+				//	return false;
 			}
 
 			return false;
 		}
 
-
-
-		public static Task OnFullfilled(this Task target, Action action)
+		/// <summary>
+		/// Checks the status of the task and attempts to start it if waiting to start (TaskStatus.Created).
+		/// </summary>
+		/// <param name="scheduler">Optional scheduler to use.</param>
+		/// <returns>True if start attempt was successful.</returns>
+		public static bool EnsureStarted(this Task target, TaskScheduler scheduler = null)
 		{
-			return target.ContinueWith(task =>
-			{
-				if (task.IsCompleted) action();
-			});
-		}
+			if(target==null) throw new NullReferenceException();
 
-		public static Task OnFullfilled<T>(this Task target, Func<T> action)
-		{
-			return target.ContinueWith(task =>
+			if(target.Status==TaskStatus.Created)
 			{
-				if (task.IsCompleted) action();
-			});
+				try
+				{
+					if (scheduler == null)
+						target.Start();
+					else
+						target.Start(scheduler);
+
+					return true;
+				}
+				catch(InvalidOperationException)
+				{
+					// Even though we've checked the status, it's possible it could have been started.  We can't guarantee proper handling without a trap here.
+					if (target.Status == TaskStatus.Created)
+						throw; // Something wierd must have happened if we arrived here.
+				}
+			}
+
+			return false;
 		}
 
-		public static Task<T> OnFullfilled<T>(this Task<T> target, Action<T> action)
+		/// <summary>
+		/// Utility method that can be chained with other methods for reacting to Task results.  Only invokes the action if completed and not cancelled.
+		/// </summary>
+		/// <typeparam name="TTask">The return type is the same as the target.</typeparam>
+		/// <param name="action">The action to perform if fullfulled.</param>
+		/// <returns>The target object.  Allows for method chaining.</returns>
+		public static TTask OnFullfilled<TTask>(this TTask target, Action action)
+			where TTask : Task
 		{
-			return target.ContinueWith(task =>
+			target.ContinueWith(task =>
 			{
-				if (task.IsCompleted) action(task.Result);
-				return task.Result;
+				if (task.IsCompleted && !task.IsCanceled) action();
 			});
+
+			return target;
 		}
 
-		// Tasks don't behave like promises so even though this seems like we should call this "Catch", it's not doing that and a real catch statment needs to be wrapped around a wait call.
-		public static Task OnFaulted(this Task target, Action<Exception> action)
+		/// <summary>
+		/// Utility method that can be chained with other methods for reacting to Task results.  Only invokes the action if completed and not cancelled.
+		/// </summary>
+		/// <typeparam name="TTask">The return type is the same as the target.</typeparam>
+		/// <param name="action">The action to perform if fullfulled.</param>
+		/// <returns>The target object.  Allows for method chaining.</returns>
+		public static TTask OnFullfilled<TTask,T>(this TTask target, Func<T> action)
+			where TTask : Task
 		{
-			return target.ContinueWith(task =>
+			target.ContinueWith(task =>
 			{
-				if (task.IsFaulted) action(task.Exception);
+				if (task.IsCompleted && !task.IsCanceled) action();
 			});
+
+			return target;
 		}
 
-		public static Task<T> OnFaulted<T>(this Task<T> target, Action<Exception> action)
+		/// <summary>
+		/// Utility method that can be chained with other methods for reacting to Task results. Only invokes the action if faulted.
+		/// </summary>
+		/// <typeparam name="TTask">The return type is the same as the target.</typeparam>
+		/// <param name="action">The action to perform if faulted.</param>
+		/// <returns>The target object.  Allows for method chaining.</returns>
+		public static TTask OnFaulted<TTask>(this TTask target, Action<Exception> action)
+			where TTask : Task
 		{
-			return target.ContinueWith(task =>
+			target.ContinueWith(task =>
 			{
 				if (task.IsFaulted) action(task.Exception);
-				return task.Result;
 			});
-		}
 
-		public static Task OnCancelled(this Task target, Action action)
-		{
-			return target.ContinueWith(task =>
-			{
-				if (task.IsCanceled) action();
-			});
+			return target;
 		}
 
-		public static Task<T> OnCancelled<T>(this Task<T> target, Action action)
+
+		/// <summary>
+		/// Utility method that can be chained with other methods for reacting to Task results.  Only invokes the action if cancelled.
+		/// </summary>
+		/// <typeparam name="TTask">The return type is the same as the target.</typeparam>
+		/// <param name="action">The action to perform if cancelled.</param>
+		/// <returns>The target object.  Allows for method chaining.</returns>
+		public static TTask OnCancelled<TTask>(this TTask target, Action action)
+			where TTask : Task
 		{
-			return target.ContinueWith(task =>
+			target.ContinueWith(task =>
 			{
-				if (task.IsCanceled) action();
-				return task.Result;
+				if (!task.IsCanceled) action();
 			});
+
+			return target;
 		}
 
-		public static Task OnCancelled<T>(this Task target, Func<T> action)
+		/// <summary>
+		/// Utility method that can be chained with other methods for reacting to Task results.  Only invokes the action if cancelled.
+		/// </summary>
+		/// <typeparam name="TTask">The return type is the same as the target.</typeparam>
+		/// <param name="action">The action to perform if cancelled.</param>
+		/// <returns>The target object.  Allows for method chaining.</returns>
+		public static TTask OnCancelled<TTask, T>(this TTask target, Func<T> action)
+			where TTask : Task
 		{
-			return target.ContinueWith(task =>
+			target.ContinueWith(task =>
 			{
-				if (task.IsCanceled) action();
+				if (!task.IsCanceled) action();
 			});
+
+			return target;
 		}
 
 	}