Make BackgroundService run ExecuteAsync as task

Author: ericstj

src/libraries/Microsoft.Extensions.Hosting.Abstractions/src/BackgroundService.cs

@@ -42,8 +42,8 @@ public virtual Task StartAsync(CancellationToken cancellationToken)
             // Create linked token to allow cancelling executing task from provided token
             _stoppingCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
 
-            // Store the task we're executing
-            _executeTask = ExecuteAsync(_stoppingCts.Token);
+            // Execute all of ExecuteAsync as a background thread, and store the task we're executing so that we can wait for it later.
+            _executeTask = Task.Run(async () => await ExecuteAsync(_stoppingCts.Token).ConfigureAwait(false), _stoppingCts.Token);
 
             // If the task is completed then return it, this will bubble cancellation and failure to the caller
             if (_executeTask.IsCompleted)

src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/BackgroundServiceTests.cs

@@ -11,7 +11,7 @@ namespace Microsoft.Extensions.Hosting.Tests
     public class BackgroundServiceTests
     {
         [Fact]
-        public void StartReturnsCompletedTaskIfLongRunningTaskIsIncomplete()
+        public void StartReturnsCompletedTask()
         {
             var tcs = new TaskCompletionSource<object>();
             var service = new MyBackgroundService(tcs.Task);
@@ -26,28 +26,12 @@ public void StartReturnsCompletedTaskIfLongRunningTaskIsIncomplete()
         }
 
         [Fact]
-        public void StartReturnsCompletedTaskIfCancelled()
+        public async Task StartCancelledThrowsTaskCanceledException()
         {
-            var tcs = new TaskCompletionSource<object>();
-            tcs.TrySetCanceled();
-            var service = new MyBackgroundService(tcs.Task);
-
-            var task = service.StartAsync(CancellationToken.None);
-
-            Assert.True(task.IsCompleted);
-            Assert.Same(task, service.ExecuteTask);
-        }
-
-        [Fact]
-        public async Task StartReturnsLongRunningTaskIfFailed()
-        {
-            var tcs = new TaskCompletionSource<object>();
-            tcs.TrySetException(new Exception("fail!"));
-            var service = new MyBackgroundService(tcs.Task);
-
-            var exception = await Assert.ThrowsAsync<Exception>(() => service.StartAsync(CancellationToken.None));
+            var ct = new CancellationToken(true);
+            var service = new WaitForCancelledTokenService();
 
-            Assert.Equal("fail!", exception.Message);
+            await Assert.ThrowsAsync<TaskCanceledException>(() => service.StartAsync(ct));
         }
 
         [Fact]
@@ -116,6 +100,7 @@ public async Task StartAsyncThenCancelShouldCancelExecutingTask()
             var service = new WaitForCancelledTokenService();
 
             await service.StartAsync(tokenSource.Token);
+            await service.WaitForExecuteTask;
 
             tokenSource.Cancel();
 
@@ -130,13 +115,48 @@ public void CreateAndDisposeShouldNotThrow()
             service.Dispose();
         }
 
+        [Fact]
+        public async Task StartSynchronousAndStop()
+        {
+            var tokenSource = new CancellationTokenSource();
+            var service = new MySynchronousBackgroundService();
+
+            // should not block the start thread;
+            await service.StartAsync(tokenSource.Token);
+            await service.WaitForExecuteTask;
+            await service.StopAsync(CancellationToken.None);
+
+            Assert.True(service.WaitForEndExecuteTask.IsCompleted);
+        }
+
+        [Fact]
+        public async Task StartSynchronousExecuteShouldBeCancelable()
+        {
+            var tokenSource = new CancellationTokenSource();
+            var service = new MySynchronousBackgroundService();
+
+            await service.StartAsync(tokenSource.Token);
+            await service.WaitForExecuteTask;
+
+            tokenSource.Cancel();
+
+            await service.WaitForEndExecuteTask;
+        }
+
         private class WaitForCancelledTokenService : BackgroundService
         {
+            private TaskCompletionSource<object> _waitForExecuteTask = new TaskCompletionSource<object>();
+
             public Task ExecutingTask { get; private set; }
 
+            public Task WaitForExecuteTask => _waitForExecuteTask.Task;
+
             protected override Task ExecuteAsync(CancellationToken stoppingToken)
             {
                 ExecutingTask = Task.Delay(Timeout.Infinite, stoppingToken);
+
+                _waitForExecuteTask.TrySetResult(null);
+
                 return ExecutingTask;
             }
         }
@@ -191,5 +211,27 @@ private async Task ExecuteCore(CancellationToken stoppingToken)
                 await task;
             }
         }
+
+        private class MySynchronousBackgroundService : BackgroundService
+        {
+            private TaskCompletionSource<object> _waitForExecuteTask = new TaskCompletionSource<object>();
+            private TaskCompletionSource<object> _waitForEndExecuteTask = new TaskCompletionSource<object>();
+
+            public Task WaitForExecuteTask => _waitForExecuteTask.Task;
+            public Task WaitForEndExecuteTask => _waitForEndExecuteTask.Task;
+
+#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
+            protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+            {
+                _waitForExecuteTask.TrySetResult(null);
+                while (!stoppingToken.IsCancellationRequested)
+                {
+                    Thread.Sleep(100); // never await, just block the thread
+                }
+                _waitForEndExecuteTask.TrySetResult(null);
+            }
+#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
+
+        }
     }
 }