Improved extensions handling with added source references.

Author: Oren (electricessence)

ActionRunner.cs

@@ -6,27 +6,23 @@ namespace Open.Threading.Tasks
 {
 	public class ActionRunner : ICancellable
 	{
-		public ActionRunner(Action action, TaskScheduler scheduler = null)
+		public ActionRunner(Action action, TaskScheduler? scheduler = default)
 		{
 			_action = action;
 			_scheduler = scheduler; // No need to hold a refernce to the default, just keep it null.
 			LastStart = DateTime.MaxValue;
 			LastComplete = DateTime.MaxValue;
 		}
 
-		public static ActionRunner Create(Action action, TaskScheduler scheduler = null)
-		{
-			return new ActionRunner(action, scheduler);
-		}
+		public static ActionRunner Create(Action action, TaskScheduler? scheduler = default)
+			=> new ActionRunner(action, scheduler);
 
-		public static ActionRunner Create<T>(Func<T> action, TaskScheduler scheduler = null)
-		{
-			return new ActionRunner(() => { action(); }, scheduler);
-		}
+		public static ActionRunner Create<T>(Func<T> action, TaskScheduler? scheduler = default)
+			=> new ActionRunner(() => { action(); }, scheduler);
 
-		Action _action;
+		Action? _action;
 		// ReSharper disable once NotAccessedField.Global
-		protected TaskScheduler _scheduler;
+		protected TaskScheduler? _scheduler;
 
 		protected int _count;
 		public int Count => _count;
@@ -70,7 +66,7 @@ public void Dispose()
 		Action GetAction()
 		{
 			var a = _action;
-			if (a == null)
+			if (a is null)
 				throw new ObjectDisposedException(typeof(ActionRunner).ToString());
 			return a;
 		}
@@ -85,33 +81,27 @@ public void RunSynchronously()
 			GetAction().Invoke();
 		}
 
-		// ReSharper disable once UnusedMember.Local
-		readonly object _taskLock = new object();
-		CancellableTask _task;
+		CancellableTask? _task;
 		CancellableTask Prepare()
 		{
 			LastStart = DateTime.Now;
 			var task = CancellableTask.Init(GetAction());
 			task
-				.OnFaulted(ex =>
-				{
-				})
-				.OnFullfilled(() =>
-				{
-					LastComplete = DateTime.Now;
-					Interlocked.Increment(ref _count);
-				})
 				.ContinueWith(t =>
 				{
+					if (t.Status == TaskStatus.RanToCompletion)
+					{
+						LastComplete = DateTime.Now;
+						Interlocked.Increment(ref _count);
+					}
 					Interlocked.CompareExchange(ref _task, null, task);
-				});
+				},
+				TaskContinuationOptions.ExecuteSynchronously);
 			return task;
 		}
 
 		public CancellableTask Run()
-		{
-			return Defer(TimeSpan.Zero);
-		}
+			=> Defer(TimeSpan.Zero);
 
 		public CancellableTask Defer(TimeSpan delay, bool clearSchedule = true)
 		{
@@ -120,7 +110,7 @@ public CancellableTask Defer(TimeSpan delay, bool clearSchedule = true)
 				Cancel(true); // Don't cancel defered if already running.
 			}
 
-			CancellableTask task;
+			CancellableTask? task;
 			if ((task = _task) != null) return task;
 			task = Prepare();
 			if (null == Interlocked.CompareExchange(ref _task, task, null))
@@ -131,9 +121,7 @@ public CancellableTask Defer(TimeSpan delay, bool clearSchedule = true)
 		}
 
 		public CancellableTask Defer(int millisecondsDelay, bool clearSchedule = true)
-		{
-			return Defer(TimeSpan.FromMilliseconds(millisecondsDelay), clearSchedule);
-		}
+			=> Defer(TimeSpan.FromMilliseconds(millisecondsDelay), clearSchedule);
 
 	}
 }

CancellableTask.cs

@@ -9,26 +9,25 @@ namespace Open.Threading.Tasks
 	/// </summary>
 	public class CancellableTask : Task, ICancellable
 	{
-		protected CancellationTokenSource TokenSource;
+		protected CancellationTokenSource? TokenSource;
 
 		public bool Cancel(bool onlyIfNotRunning)
 		{
-			var ts = Interlocked.Exchange(ref TokenSource, null); // Cancel can only be called once.
-
-			if (ts == null || ts.IsCancellationRequested || IsCanceled || IsFaulted || IsCompleted)
+			if (onlyIfNotRunning && Status == TaskStatus.Running || IsCanceled || IsFaulted || IsCompleted)
 				return false;
 
-			var isRunning = Status == TaskStatus.Running;
-			if (!onlyIfNotRunning || !isRunning)
+			var ts = Interlocked.Exchange(ref TokenSource, null); // Cancel can only be called once.
+			if (ts is null) return false;
+			using (ts)
+			{
+				if (ts.IsCancellationRequested) return false;
 				ts.Cancel();
+			}
 
-			return !isRunning;
+			return true;
 		}
 
-		public bool Cancel()
-		{
-			return Cancel(false);
-		}
+		public bool Cancel() => Cancel(false);
 
 		protected static void Blank() { }
 
@@ -38,12 +37,12 @@ protected override void Dispose(bool disposing)
 			base.Dispose(disposing);
 		}
 
-		protected CancellableTask(Action action, CancellationToken token)
+		protected CancellableTask(Action? action, CancellationToken token)
 			: base(action ?? Blank, token)
 		{
 		}
 
-		protected CancellableTask(Action action)
+		protected CancellableTask(Action? action)
 			: base(action ?? Blank)
 		{
 		}
@@ -59,7 +58,7 @@ protected CancellableTask()
 		}
 
 		// Only allow for static initilialization because this owns the TokenSource.
-		public static CancellableTask Init(Action action = null)
+		public static CancellableTask Init(Action? action = null)
 		{
 			var ts = new CancellationTokenSource();
 			var token = ts.Token;
@@ -69,15 +68,15 @@ public static CancellableTask Init(Action action = null)
 			};
 		}
 
-		public void Start(TimeSpan delay, TaskScheduler scheduler = null)
+		public void Start(TimeSpan delay, TaskScheduler? scheduler = null)
 		{
 			if (delay < TimeSpan.Zero)
 			{
 				RunSynchronously();
 			}
 			else if (delay == TimeSpan.Zero)
 			{
-				if (scheduler == null)
+				if (scheduler is null)
 					Start();
 				else
 					Start(scheduler);
@@ -93,7 +92,7 @@ public void Start(TimeSpan delay, TaskScheduler scheduler = null)
 						Cancel();
 				});
 
-				Delay(delay, TokenSource.Token)
+				Delay(delay, TokenSource!.Token)
 					.OnFullfilled(() =>
 					{
 						Interlocked.Increment(ref runState);
@@ -102,29 +101,23 @@ public void Start(TimeSpan delay, TaskScheduler scheduler = null)
 			}
 		}
 
-		public void Start(int millisecondsDelay, TaskScheduler scheduler = null)
-		{
-			Start(TimeSpan.FromMilliseconds(millisecondsDelay), scheduler);
-		}
+		public void Start(int millisecondsDelay, TaskScheduler? scheduler = default)
+			=> Start(TimeSpan.FromMilliseconds(millisecondsDelay), scheduler);
 
-		public static CancellableTask StartNew(TimeSpan delay, Action action = null, TaskScheduler scheduler = null)
+		public static CancellableTask StartNew(TimeSpan delay, Action? action = null, TaskScheduler? scheduler = default)
 		{
 			var task = new CancellableTask(action);
 			task.Start(delay, scheduler);
 			return task;
 		}
 
-		public static CancellableTask StartNew(int millisecondsDelay, Action action = null)
-		{
-			return StartNew(TimeSpan.FromMilliseconds(millisecondsDelay), action);
-		}
+		public static CancellableTask StartNew(int millisecondsDelay, Action? action = null)
+			=> StartNew(TimeSpan.FromMilliseconds(millisecondsDelay), action);
 
-		public static CancellableTask StartNew(Action action, TimeSpan? delay = null, TaskScheduler scheduler = null)
-		{
-			return StartNew(delay ?? TimeSpan.Zero, action, scheduler);
-		}
+		public static CancellableTask StartNew(Action action, TimeSpan? delay = null, TaskScheduler? scheduler = default)
+			=> StartNew(delay ?? TimeSpan.Zero, action, scheduler);
 
-		public static CancellableTask StartNew(Action<CancellationToken> action, TimeSpan? delay = null, TaskScheduler scheduler = null)
+		public static CancellableTask StartNew(Action<CancellationToken> action, TimeSpan? delay = null, TaskScheduler? scheduler = default)
 		{
 			var ts = new CancellationTokenSource();
 			var token = ts.Token;

Open.Threading.Tasks.csproj

@@ -1,37 +1,41 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
+		<LangVersion>latest</LangVersion>
+		<Nullable>enable</Nullable>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Authors>electricessence</Authors>
-    <Company>electricessence</Company>
     <Description>A set of utilities and extensions for working with Tasks.
 
 Part of the "Open" set of libraries.</Description>
-    <Copyright>https://github.com/electricessence/Open.Threading.Tasks/blob/master/LISCENSE.md</Copyright>
-    <PackageProjectUrl>https://github.com/electricessence/Open.Threading.Tasks/</PackageProjectUrl>
-    <RepositoryUrl>https://github.com/electricessence/Open.Threading.Tasks/</RepositoryUrl>
+    <Copyright>https://github.com/Open-NET-Libraries/Open.Threading.Tasks/blob/master/LISCENSE.md</Copyright>
+    <PackageProjectUrl>https://github.com/Open-NET-Libraries/Open.Threading.Tasks/</PackageProjectUrl>
+    <RepositoryUrl>https://github.com/Open-NET-Libraries/Open.Threading.Tasks/</RepositoryUrl>
 		<PackageLicenseExpression>MIT</PackageLicenseExpression>
 		<RepositoryType>git</RepositoryType>
     <PackageTags>dotnet, dotnet-core, dotnetcore, cs, extensions, actionrunner, cancellable, cancellabletask, progress, task-extensions</PackageTags>
-    <Version>1.1.3</Version>
+    <Version>1.2.0</Version>
     <PackageReleaseNotes></PackageReleaseNotes>
+    <PackageIcon>logo.png</PackageIcon>
+		<PublishRepositoryUrl>true</PublishRepositoryUrl>
+		<IncludeSymbols>true</IncludeSymbols>
+		<SymbolPackageFormat>snupkg</SymbolPackageFormat>		
   </PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
-    <Optimize>True</Optimize>
-    <LangVersion>latest</LangVersion>
-  </PropertyGroup>
-
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
-    <LangVersion>latest</LangVersion>
-  </PropertyGroup>
+	<ItemGroup>
+		<PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
+	</ItemGroup>
 
   <ItemGroup>
     <None Remove=".git" />
     <None Remove=".gitignore" />
     <None Remove="LICENSE" />
     <None Remove="README.md" />
+    <None Include="logo.png">
+      <Pack>True</Pack>
+      <PackagePath></PackagePath>
+    </None>
   </ItemGroup>
 
 </Project>

TaskExtensions.cs

@@ -10,7 +10,7 @@ public static class TaskExtensions
 		/// </summary>
 		public static bool IsActive(this Task target)
 		{
-			if (target == null)
+			if (target is null)
 				throw new NullReferenceException();
 
 			switch (target.Status)
@@ -36,14 +36,14 @@ public static bool IsActive(this Task target)
 		/// <param name="target">The task to ensure start.</param>
 		/// <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)
+		public static bool EnsureStarted(this Task target, TaskScheduler? scheduler = default)
 		{
-			if (target == null) throw new NullReferenceException();
+			if (target is null) throw new NullReferenceException();
 
 			if (target.Status != TaskStatus.Created) return false;
 			try
 			{
-				if (scheduler == null)
+				if (scheduler is null)
 					target.Start();
 				else
 					target.Start(scheduler);

TimeoutHandler.cs

@@ -6,30 +6,41 @@ namespace Open.Threading.Tasks
 {
 	public class TimeoutHandler : IDisposable
 	{
-		readonly CancellationTokenSource TokenSource;
-		TimeoutHandler(int delay, Action<int> onComplete)
+		CancellationTokenSource? TokenSource;
+		TimeoutHandler(TimeSpan delay, Action<TimeSpan> onTimeout)
 		{
 			TokenSource = new CancellationTokenSource();
 			Task.Delay(delay, TokenSource.Token).ContinueWith(t =>
 			{
-				if (!t.IsCanceled) onComplete(delay);
+				Interlocked.Exchange(ref TokenSource, null)?.Dispose();
+				if (!t.IsCanceled) onTimeout(delay);
 			});
 		}
 
-		public static TimeoutHandler New(int delay, Action<int> onComplete)
+		public static TimeoutHandler New(TimeSpan delay, Action<TimeSpan> onTimeout)
+			=> new TimeoutHandler(delay, onTimeout);
+
+		public static bool New(TimeSpan delay, out IDisposable timeout, Action<TimeSpan> onTimeout)
 		{
-			return new TimeoutHandler(delay, onComplete);
+			timeout = New(delay, onTimeout);
+			return true;
 		}
 
-		public static bool New(int delay, out IDisposable timeout, Action<int> onComplete)
+		public static TimeoutHandler New(double delay, Action<double> onTimeout)
+			=> New(TimeSpan.FromMilliseconds(delay), ts=> onTimeout(ts.TotalMilliseconds));
+
+		public static bool New(double delay, out IDisposable timeout, Action<double> onTimeout)
 		{
-			timeout = New(delay, onComplete);
+			timeout = New(delay, onTimeout);
 			return true;
 		}
 
 		public void Dispose()
 		{
-			TokenSource.Cancel();
+			var ts = Interlocked.Exchange(ref TokenSource, null);
+			if (ts is null) return;
+			ts.Cancel();
+			ts.Dispose();
 		}
 	}
 }