Some redesign

Author: justdmitry

README.md

@@ -15,6 +15,7 @@ Written for **ASP.NET Core** (ASP.NET 5, ASP.NET vNext).
 ## Main features
 
 * Start and Stop your task at any time;
+* CancelationToken may be used for Stopping;
 * First run (after Start) is delayed at random value (10-30 sec, customizable) to prevent app freeze during statup;
 * Run "immediately" (without waiting for next scheduled time);
 * Change run interval while running;
@@ -40,7 +41,7 @@ public class MyFirstTask : IRunnable
         this.logger = logger;
     }
 
-    public void Run(ITask currentTask, CancellationToken cancellationToken)
+    public Task RunAsync(ITask currentTask, IServiceProvider scopeServiceProvider, CancellationToken cancellationToken)
     {
         // Place your code here
     }
@@ -49,6 +50,8 @@ public class MyFirstTask : IRunnable
 
 You can add any parameters to constructor, while they are resolvable from DI container (including scope-lifetime services, because new scope is created for every task run).
 
+By default, new instance of `IRunnable` is created for every task run, but you may change lifetime in `AddTask` (see below). Use `IServiceProvider` passed to `RunAsync` to obtain scope-wide services if you force your task be singleton.
+
 ### 2. Register and start your task in `Startup.cs`
 
 
@@ -70,11 +73,28 @@ public void Configure(IApplicationBuilder app, ...)
 
 And voila! Your task will run every 5 minutes. Until your application ends, of course.
 
+`AddTask` adds your `MyFirstTask` to DI container with transient lifetime (new instance will be created for every task run). Pass desired lifetime to `AddTask()` to override: `services.AddTask<MyFirstTask>(ServiceLifetime.Singleton)`.
+
+### Run immediately
+
+Anywhere in you app:
+
+```csharp
+// obtain reference to your task
+var myTask = serviceProvider.GetService<ITask<MyFirstTask>>();
+
+// poke it
+if (myTask.IsStarted)
+{
+    myTask.TryRunImmediately();
+}
+```
+
 ## Installation
 
 Use NuGet package [RecurrentTasks](https://www.nuget.org/packages/RecurrentTasks/)
 
-Target [framework/platform moniker](https://github.com/dotnet/corefx/blob/master/Documentation/architecture/net-platform-standard.md): **`netstandard1.3`**
+Target [framework/platform moniker](https://github.com/dotnet/corefx/blob/master/Documentation/architecture/net-platform-standard.md): **`net451`**, **`net46`**, **`netstandard1.3`**, **`netstandard2.0`**
 
 ### Dependencies
 

sample/RecurrentTasks.Sample/RecurrentTasks.Sample.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
   <PropertyGroup>
-    <TargetFramework>netcoreapp1.0</TargetFramework>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
     <PreserveCompilationContext>true</PreserveCompilationContext>
     <AssemblyName>RecurrentTasks.Sample</AssemblyName>
     <OutputType>Exe</OutputType>

sample/RecurrentTasks.Sample/SampleTask.cs

@@ -2,6 +2,7 @@
 {
     using System;
     using System.Threading;
+    using System.Threading.Tasks;
     using Microsoft.Extensions.Logging;
 
     public class SampleTask : IRunnable
@@ -16,14 +17,15 @@ public SampleTask(ILogger<SampleTask> logger, SampleTaskRunHistory runHistory)
             this.runHistory = runHistory;
         }
 
-        public void Run(ITask currentTask, CancellationToken cancellationToken)
+        public Task RunAsync(ITask currentTask, IServiceProvider scopeServiceProvider, CancellationToken cancellationToken)
         {
             var msg = string.Format("Run at: {0}", DateTimeOffset.Now);
             runHistory.Messages.Add(msg);
             logger.LogDebug(msg);
 
             // You can change interval for [all] next runs!
             currentTask.Interval = currentTask.Interval.Add(TimeSpan.FromSeconds(1));
+            return Task.CompletedTask;
         }
     }
 }

src/RecurrentTasks/ExceptionEventArgs.cs

@@ -2,9 +2,10 @@
 {
     using System;
     using System.Threading;
+    using System.Threading.Tasks;
 
     public interface IRunnable
     {
-        void Run(ITask currentTask, CancellationToken cancellationToken);
+        Task RunAsync(ITask currentTask, IServiceProvider scopeServiceProvider, CancellationToken cancellationToken);
     }
 }

src/RecurrentTasks/IRunnable.cs

@@ -2,23 +2,25 @@
 {
     using System;
     using System.Globalization;
+    using System.Threading;
+    using System.Threading.Tasks;
 
     public interface ITask
     {
         /// <summary>
         /// Called before Run() is called (even before IsRunningRightNow set to true).
         /// </summary>
-        event EventHandler<ServiceProviderEventArgs> BeforeRun;
+        Func<IServiceProvider, ITask, Task> BeforeRunAsync { get; set; }
 
         /// <summary>
         /// Called after Run() sucessfully finished (after IsRunningRightNow set to false)
         /// </summary>
-        event EventHandler<ServiceProviderEventArgs> AfterRunSuccess;
+        Func<IServiceProvider, ITask, Task> AfterRunSuccessAsync { get; set; }
 
         /// <summary>
         /// Called after Run() failed (after IsRunningRightNow set to false)
         /// </summary>
-        event EventHandler<ExceptionEventArgs> AfterRunFail;
+        Func<IServiceProvider, ITask, Exception, Task> AfterRunFailAsync { get; set; }
 
         /// <summary>
         ///   <b>true</b> when task is started and will run with specified intervals
@@ -59,6 +61,14 @@ public interface ITask
         /// <exception cref="InvalidOperationException">Task is already started</exception>
         void Start(TimeSpan firstRunDelay);
 
+        /// <summary>
+        /// Start task (and delay first run for specified interval) with cancellation token (instead of <see cref="Stop"/>)
+        /// </summary>
+        /// <param name="firstRunDelay">Delay before first task run (use TimeSpan.Zero for no delay)</param>
+        /// <param name="cancellationToken">Cancellation Token</param>
+        /// <exception cref="InvalidOperationException">Task is already started</exception>
+        void Start(TimeSpan firstRunDelay, CancellationToken cancellationToken);
+
         /// <summary>
         /// Stop task (will NOT break if currently running)
         /// </summary>

src/RecurrentTasks/ITask.cs

@@ -1,18 +1,18 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <Copyright>Dmitry Popov, 2016</Copyright>
+    <Copyright>Dmitry Popov, 2016-2018</Copyright>
     <AssemblyTitle>RecurrentTasks</AssemblyTitle>
-    <TargetFrameworks>net451;net46;netstandard1.3</TargetFrameworks>
+    <TargetFrameworks>net451;net46;netstandard1.3;netstandard2.0</TargetFrameworks>
     <NetStandardImplicitPackageVersion>1.6.0</NetStandardImplicitPackageVersion>
     <AssemblyName>RecurrentTasks</AssemblyName>
     <PackageId>RecurrentTasks</PackageId>
     <PackageTags>task;job;recurrent;recurring;aspnetcore</PackageTags>
-    <PackageReleaseNotes>`CancellationToken` added to `IRunnable.Run` (it becomes cancelled when `ITask.Stop()` is called).</PackageReleaseNotes>
+    <PackageReleaseNotes>https://github.com/justdmitry/RecurrentTasks/releases/tag/v5.0.0</PackageReleaseNotes>
     <PackageProjectUrl>https://github.com/justdmitry/RecurrentTasks</PackageProjectUrl>
     <PackageLicenseUrl>https://github.com/justdmitry/RecurrentTasks/blob/master/LICENSE</PackageLicenseUrl>
     <RepositoryType>git</RepositoryType>
     <RepositoryUrl>https://github.com/justdmitry/RecurrentTasks.git</RepositoryUrl>
-    <Version>4.0.0</Version>
+    <Version>5.0.0</Version>
     <Description>RecurrentTasks for .NET allows you to run simple recurrent background tasks with specific intervals, without complex frameworks, persistance, etc...</Description>
     <Authors>just_dmitry</Authors>
     <Company />

src/RecurrentTasks/RecurrentTasks.csproj

@@ -6,18 +6,20 @@
 
     public static class RecurrentTasksServiceCollectionExtensions
     {
-        public static IServiceCollection AddTask<TRunnable>(this IServiceCollection services)
+        public static IServiceCollection AddTask<TRunnable>(this IServiceCollection services, ServiceLifetime runnableLifetime = ServiceLifetime.Transient)
             where TRunnable : IRunnable
         {
             if (services == null)
             {
                 throw new ArgumentNullException(nameof(services));
             }
 
+            var runnableType = typeof(TRunnable);
+
             // Register TRunnable in DI container, if not registered already
-            if (!services.Any(x => x.ServiceType == typeof(TRunnable)))
+            if (!services.Any(x => x.ServiceType == runnableType))
             {
-                services.AddTransient(typeof(TRunnable));
+                services.Add(new ServiceDescriptor(runnableType, runnableType, runnableLifetime));
             }
 
             services.AddSingleton<ITask<TRunnable>, TaskRunner<TRunnable>>();

src/RecurrentTasks/RecurrentTasksServiceCollectionExtensions.cs

@@ -31,13 +31,13 @@ public TaskRunner(ILoggerFactory loggerFactory, IServiceScopeFactory serviceScop
         }
 
         /// <inheritdoc />
-        public event EventHandler<ServiceProviderEventArgs> BeforeRun;
+        public Func<IServiceProvider, ITask, Task> BeforeRunAsync { get; set; }
 
         /// <inheritdoc />
-        public event EventHandler<ExceptionEventArgs> AfterRunFail;
+        public Func<IServiceProvider, ITask, Task> AfterRunSuccessAsync { get; set; }
 
         /// <inheritdoc />
-        public event EventHandler<ServiceProviderEventArgs> AfterRunSuccess;
+        public Func<IServiceProvider, ITask, Exception, Task> AfterRunFailAsync { get; set; }
 
         /// <inheritdoc />
         public TaskRunStatus RunStatus { get; protected set; }
@@ -64,6 +64,12 @@ public bool IsStarted
 
         /// <inheritdoc />
         public void Start(TimeSpan firstRunDelay)
+        {
+            Start(firstRunDelay, CancellationToken.None);
+        }
+
+        /// <inheritdoc />
+        public void Start(TimeSpan firstRunDelay, CancellationToken cancellationToken)
         {
             if (firstRunDelay < TimeSpan.Zero)
             {
@@ -81,8 +87,9 @@ public void Start(TimeSpan firstRunDelay)
                 throw new InvalidOperationException("Already started");
             }
 
-            cancellationTokenSource = new CancellationTokenSource();
-            mainTask = Task.Run(() => MainLoop(firstRunDelay));
+            cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+
+            mainTask = Task.Run(() => MainLoop(firstRunDelay, cancellationTokenSource.Token));
         }
 
         /// <inheritdoc />
@@ -108,19 +115,18 @@ public void TryRunImmediately()
             runImmediately.Set();
         }
 
-        protected void MainLoop(TimeSpan firstRunDelay)
+        protected void MainLoop(TimeSpan firstRunDelay, CancellationToken cancellationToken)
         {
             logger.LogInformation("MainLoop() started. Running...");
-            var events = new WaitHandle[] { cancellationTokenSource.Token.WaitHandle, runImmediately };
             var sleepInterval = firstRunDelay;
+            var handles = new[] { cancellationToken.WaitHandle, runImmediately };
             while (true)
             {
                 logger.LogDebug("Sleeping for {0}...", sleepInterval);
                 RunStatus.NextRunTime = DateTimeOffset.Now.Add(sleepInterval);
-                var signaled = WaitHandle.WaitAny(events, sleepInterval);
+                WaitHandle.WaitAny(handles, sleepInterval);
 
-                // index of signalled handler. zero is for 'cancellationToken'
-                if (signaled == 0)
+                if (cancellationToken.IsCancellationRequested)
                 {
                     // must stop and quit
                     logger.LogWarning("CancellationToken signaled, stopping...");
@@ -155,7 +161,7 @@ protected void MainLoop(TimeSpan firstRunDelay)
                         var runnable = (TRunnable)scope.ServiceProvider.GetRequiredService(typeof(TRunnable));
 
                         logger.LogInformation("Calling Run()...");
-                        runnable.Run(this, cancellationTokenSource.Token);
+                        runnable.RunAsync(this, scope.ServiceProvider, cancellationToken).GetAwaiter().GetResult();
                         logger.LogInformation("Done.");
 
                         RunStatus.LastRunTime = startTime;
@@ -204,16 +210,19 @@ protected void MainLoop(TimeSpan firstRunDelay)
         }
 
         /// <summary>
-        /// Invokes <see cref="BeforeRun"/> event (don't forget to call base.OnBeforeRun in override)
+        /// Invokes <see cref="BeforeRunAsync"/> handler (don't forget to call base.OnBeforeRun in override)
         /// </summary>
         /// <param name="serviceProvider"><see cref="IServiceProvider"/> to be passed in event args</param>
         protected virtual void OnBeforeRun(IServiceProvider serviceProvider)
         {
-            BeforeRun?.Invoke(this, new ServiceProviderEventArgs(serviceProvider));
+            if (BeforeRunAsync != null)
+            {
+                BeforeRunAsync(serviceProvider, this).GetAwaiter().GetResult();
+            }
         }
 
         /// <summary>
-        /// Invokes <see cref="AfterRunSuccess"/> event (don't forget to call base.OnAfterRunSuccess in override)
+        /// Invokes <see cref="AfterRunSuccessAsync"/> handler (don't forget to call base.OnAfterRunSuccess in override)
         /// </summary>
         /// <param name="serviceProvider"><see cref="IServiceProvider"/> to be passed in event args</param>
         /// <remarks>
@@ -223,7 +232,10 @@ protected virtual void OnAfterRunSuccess(IServiceProvider serviceProvider)
         {
             try
             {
-                AfterRunSuccess?.Invoke(this, new ServiceProviderEventArgs(serviceProvider));
+                if (AfterRunSuccessAsync != null)
+                {
+                    AfterRunSuccessAsync(serviceProvider, this).GetAwaiter().GetResult();
+                }
             }
             catch (Exception ex2)
             {
@@ -232,7 +244,7 @@ protected virtual void OnAfterRunSuccess(IServiceProvider serviceProvider)
         }
 
         /// <summary>
-        /// Invokes <see cref="AfterRunFail"/> event - don't forget to call base.OnAfterRunSuccess in override
+        /// Invokes <see cref="AfterRunFailAsync"/> handler - don't forget to call base.OnAfterRunSuccess in override
         /// </summary>
         /// <param name="serviceProvider"><see cref="IServiceProvider"/> to be passed in event args</param>
         /// <param name="ex"><see cref="Exception"/> to be passes in event args</param>
@@ -243,7 +255,10 @@ protected virtual void OnAfterRunFail(IServiceProvider serviceProvider, Exceptio
         {
             try
             {
-                AfterRunFail?.Invoke(this, new ExceptionEventArgs(serviceProvider, ex));
+                if (AfterRunFailAsync != null)
+                {
+                    AfterRunFailAsync(serviceProvider, this, ex).GetAwaiter().GetResult();
+                }
             }
             catch (Exception ex2)
             {