Add RegisterWaitForSingleObjectAsync.

Author: tosh-coding

src/AsyncFiberWorks/Threading/ThreadPoolExtensions.cs

@@ -45,5 +45,33 @@ public static async Task QueueAsync(this IThreadPool threadPool, Action action)
         {
             await threadPool.QueueAsync((_) => action()).ConfigureAwait(false);
         }
+
+        /// <summary>
+        /// Wait for WaitHandle.
+        /// </summary>
+        /// <param name="threadPool">Thread pool used for waiting.</param>
+        /// <param name="waitHandle">Waiting target.</param>
+        /// <param name="cancellationToken">Handle for cancellation.</param>
+        /// <returns>Task waiting for WaitHandle to complete.</returns>
+        /// <exception cref="OperationCanceledException">An exception that occurs when canceled.</exception>
+        public static async Task RegisterWaitForSingleObjectAsync(this IThreadPool threadPool, WaitHandle waitHandle, CancellationToken cancellationToken)
+        {
+            await threadPool.QueueAsync(() =>
+            {
+                int index = WaitHandle.WaitAny(new WaitHandle[]
+                {
+                    waitHandle,
+                    cancellationToken.WaitHandle
+                });
+                if (index == 0)
+                {
+                    // completed.
+                }
+                else
+                {
+                    cancellationToken.ThrowIfCancellationRequested();
+                }
+            }).ConfigureAwait(false);
+        }
     }
 }

src/AsyncFiberWorksTests/ThreadPoolTests.cs

@@ -16,6 +16,12 @@ public class ThreadPoolTests
     {
         static int NumberOfMinThreads = 2;
 
+        static object[] ThreadPoolCreators =
+        {
+            new object[] { (Func<IThreadPool>)(() => DefaultThreadPool.Instance) },
+            new object[] { (Func<IThreadPool>)(() => UserThreadPool.StartNew(3)) },
+        };
+
         [OneTimeSetUp]
         public void Init()
         {
@@ -226,12 +232,33 @@ public async Task ThreadPoolQueueAsync(Func<IThreadPool> poolCreator)
             Assert.AreEqual(201, value);
         }
 
-
-        static object[] ThreadPoolCreators =
+        [Test, TestCaseSource(nameof(ThreadPoolCreators))]
+        public async Task ThreadPoolRegisterWaitForSingleObjectAsyncTest(Func<IThreadPool> poolCreator)
         {
-            new object[] { (Func<IThreadPool>)(() => DefaultThreadPool.Instance) },
-            new object[] { (Func<IThreadPool>)(() => UserThreadPool.StartNew(3)) },
-        };
+            var threadPool = poolCreator();
+            var cts = new CancellationTokenSource();
+            var manualResetEvent1 = new ManualResetEventSlim();
+            var t1 = threadPool.RegisterWaitForSingleObjectAsync(manualResetEvent1.WaitHandle, cts.Token);
+            Assert.IsFalse(t1.IsCompleted);
+            
+            manualResetEvent1.Set();
+            await t1.ConfigureAwait(false);
+            Assert.IsTrue(t1.IsCompleted);
 
+            var manualResetEvent2 = new ManualResetEventSlim();
+            var t2 = threadPool.RegisterWaitForSingleObjectAsync(manualResetEvent2.WaitHandle, cts.Token);
+            Assert.IsFalse(t2.IsCompleted);
+
+            cts.Cancel();
+            try
+            {
+                await t2.ConfigureAwait(false);
+            }
+            catch (OperationCanceledException)
+            {
+            }
+            Assert.IsTrue(t2.IsCompleted);
+            Assert.IsTrue(t2.IsCanceled);
+        }
     }
 }