v3.1.0:

* Events added to ITask: BeforeRun, AfterRunSuccess
* Tests optimized, now takes only 12 seconds

Author: justdmitry

src/RecurrentTasks/ExceptionEventArgs.cs

@@ -2,9 +2,10 @@
 {
     using System;
 
-    public class ExceptionEventArgs : EventArgs
+    public class ExceptionEventArgs : ServiceProviderEventArgs
     {
-        public ExceptionEventArgs(Exception exception)
+        public ExceptionEventArgs(IServiceProvider serviceProvider, Exception exception)
+            :base(serviceProvider)
         {
             if (exception == null)
             {

src/RecurrentTasks/ITask.cs

@@ -38,7 +38,17 @@ public interface ITask
         TimeSpan Interval { get; set; }
 
         /// <summary>
-        /// Raises when exception catched during task run.
+        /// Called before Run() is called (even before IsRunningRightNow set to true).
+        /// </summary>
+        event EventHandler<ServiceProviderEventArgs> BeforeRun;
+
+        /// <summary>
+        /// Called after Run() sucessfully finished (after IsRunningRightNow set to false)
+        /// </summary>
+        event EventHandler<ServiceProviderEventArgs> AfterRunSuccess;
+
+        /// <summary>
+        /// Called after Run() failed (after IsRunningRightNow set to false)
         /// </summary>
         event EventHandler<ExceptionEventArgs> AfterRunFail;
 

src/RecurrentTasks/ServiceProviderEventArgs.cs

@@ -0,0 +1,18 @@
+namespace RecurrentTasks
+{
+    using System;
+
+    public class ServiceProviderEventArgs : EventArgs
+    {
+        public ServiceProviderEventArgs(IServiceProvider serviceProvider)
+        {
+            if (serviceProvider == null)
+            {
+                throw new ArgumentNullException(nameof(serviceProvider));
+            }
+            this.ServiceProvider = serviceProvider;
+        }
+
+        public IServiceProvider ServiceProvider { get; protected set; }
+    }
+}

src/RecurrentTasks/TaskRunner.cs

@@ -28,12 +28,21 @@ public TaskRunner(ILoggerFactory loggerFactory, IServiceScopeFactory serviceScop
             RunStatus = new TaskRunStatus();
         }
 
+        /// <inheritdoc />
+        public event EventHandler<ServiceProviderEventArgs> BeforeRun;
+
+        /// <inheritdoc />
         public event EventHandler<ExceptionEventArgs> AfterRunFail;
 
+        /// <inheritdoc />
+        public event EventHandler<ServiceProviderEventArgs> AfterRunSuccess;
+
         TaskRunStatus ITask.RunStatus { get { return RunStatus; } }
 
+        /// <inheritdoc />
         public TaskRunStatus RunStatus { get; protected set; }
 
+        /// <inheritdoc />
         public bool IsStarted
         {
             get
@@ -42,14 +51,18 @@ public bool IsStarted
             }
         }
 
+        /// <inheritdoc />
         public bool IsRunningRightNow { get; private set; }
 
+        /// <inheritdoc />
         public CultureInfo RunningCulture { get; set; }
 
+        /// <inheritdoc />
         public TimeSpan Interval { get; set; }
 
         private IServiceScopeFactory ServiceScopeFactory { get; set; }
 
+        /// <inheritdoc />
         public void Start(TimeSpan firstRunDelay)
         {
             if (firstRunDelay < TimeSpan.Zero)
@@ -69,6 +82,7 @@ public void Start(TimeSpan firstRunDelay)
             mainTask = Task.Run(() => MainLoop(firstRunDelay));
         }
 
+        /// <inheritdoc />
         public void Stop()
         {
             logger.LogInformation("Stop() called...");
@@ -79,6 +93,7 @@ public void Stop()
             breakEvent.Set();
         }
 
+        /// <inheritdoc />
         public void TryRunImmediately()
         {
             if (mainTask == null)
@@ -122,7 +137,7 @@ protected void MainLoop(TimeSpan firstRunDelay)
 
                     try
                     {
-                        OnBeforeRun();
+                        OnBeforeRun(scope.ServiceProvider);
 
                         IsRunningRightNow = true;
 
@@ -142,7 +157,7 @@ protected void MainLoop(TimeSpan firstRunDelay)
                         RunStatus.LastException = null;
                         IsRunningRightNow = false;
 
-                        OnAfterRunSuccess();
+                        OnAfterRunSuccess(scope.ServiceProvider);
                     }
                     catch (Exception ex)
                     {
@@ -156,16 +171,7 @@ protected void MainLoop(TimeSpan firstRunDelay)
                         RunStatus.FailsCount++;
                         IsRunningRightNow = false;
 
-                        OnAfterRunFail();
-
-                        try
-                        {
-                            AfterRunFail?.Invoke(this, new ExceptionEventArgs(ex));
-                        }
-                        catch (Exception ex2)
-                        {
-                            logger.LogError(0, ex2, "Error while processing AfterRunFail event (ignored)");
-                        }
+                        OnAfterRunFail(scope.ServiceProvider, ex);
                     }
                     finally
                     {
@@ -185,28 +191,48 @@ protected void MainLoop(TimeSpan firstRunDelay)
             logger.LogInformation("MainLoop() finished.");
         }
 
-        /// <summary>
-        /// Called before Run() is called (even before IsRunningRightNow set to true)
-        /// </summary>
-        protected virtual void OnBeforeRun()
+        /// <remarks>
+        /// Invokes <see cref="BeforeRun"/> event - don't forget to call base.OnBeforeRun in override
+        /// </remarks>
+        protected virtual void OnBeforeRun(IServiceProvider serviceProvider)
         {
-            // nothing
+            BeforeRun?.Invoke(this, new ServiceProviderEventArgs(serviceProvider));
         }
 
-        /// <summary>
-        /// Called after Run() sucessfully finished (after IsRunningRightNow set to false)
-        /// </summary>
-        protected virtual void OnAfterRunSuccess()
+        /// <remarks>
+        /// Invokes <see cref="AfterRunSuccess"/> event - don't forget to call base.OnAfterRunSuccess in override
+        /// </remarks>
+        /// <remarks>
+        /// Attention! Any exception, catched during AfterRunSuccess.Invoke, is written to error log and ignored.
+        /// </remarks>
+        protected virtual void OnAfterRunSuccess(IServiceProvider serviceProvider)
         {
-            // nothing
+            try
+            {
+                AfterRunSuccess?.Invoke(this, new ServiceProviderEventArgs(serviceProvider));
+            }
+            catch (Exception ex2)
+            {
+                logger.LogError(0, ex2, "Error while processing AfterRunSuccess event (ignored)");
+            }
         }
 
-        /// <summary>
-        /// Called after Run() falied (after IsRunningRightNow set to false)
-        /// </summary>
-        protected virtual void OnAfterRunFail()
+        /// <remarks>
+        /// Invokes <see cref="AfterRunFail"/> event - don't forget to call base.OnAfterRunSuccess in override
+        /// </remarks>
+        /// <remarks>
+        /// Attention! Any exception, catched during AfterRunFail.Invoke, is written to error log and ignored.
+        /// </remarks>
+        protected virtual void OnAfterRunFail(IServiceProvider serviceProvider, Exception ex)
         {
-            // nothing
+            try
+            {
+                AfterRunFail?.Invoke(this, new ExceptionEventArgs(serviceProvider, ex));
+            }
+            catch (Exception ex2)
+            {
+                logger.LogError(0, ex2, "Error while processing AfterRunFail event (ignored)");
+            }
         }
     }
 }

src/RecurrentTasks/project.json

@@ -1,12 +1,12 @@
 {
-  "version": "3.0.0",
+  "version": "3.1.0",
   "title": "RecurrentTasks",
   "copyright": "Dmitry Popov, 2016",
   "packOptions": {
     "summary": "RecurrentTasks for .NET allows you to run simple recurrent background tasks with specific intervals, without complex frameworks, persistance, etc...",
     "tags": [ "task", "job", "recurrent", "recurring", "aspnetcore" ],
     "owners": [ "Dmitry Popov" ],
-    "releaseNotes": "Initial v3 release",
+    "releaseNotes": "ITask.BeforeRun, ITask.AfterRunSuccess events added",
     "licenseUrl": "https://github.com/justdmitry/RecurrentTasks/blob/master/LICENSE",
     "projectUrl": "https://github.com/justdmitry/RecurrentTasks",
     "repository": {