Rename AsyncRegister to FiberTaskWaiter.

Author: tosh-coding

src/AsyncFiberWorks/Procedures/AsyncRegister.cs renamed to src/AsyncFiberWorks/Procedures/FiberTaskWaiter.cs

@@ -6,42 +6,38 @@
 namespace AsyncFiberWorks.Procedures
 {
     /// <summary>
-    /// Keep only one value. It provides a task from setting the flag
-    /// to the completion of processing, and a task until it is set.
+    /// Asynchronous context switching.
     /// </summary>
-    public class AsyncRegister : IDisposable
+    public class FiberTaskWaiter : IDisposable
     {
         private readonly object _lockObj = new object();
-        private IDisposable _subscription;
-        private bool _hasValue;
+        private IDisposable _unsubscriber;
+        private bool _executionRequested;
         private bool _isDisposed;
-        private readonly ManualResetEventSlim _notifierSet = new ManualResetEventSlim();
-        private readonly ManualResetEventSlim _notifierClear = new ManualResetEventSlim();
+        private readonly ManualResetEventSlim _notifierExecutionRequested = new ManualResetEventSlim();
+        private readonly ManualResetEventSlim _notifierExecutionFinished = new ManualResetEventSlim();
         private readonly UserThreadPool _thread;
-        private bool _reading;
+        private bool _inExecuting;
         private CancellationToken _cancellationToken;
 
         /// <summary>
-        /// Subscribe a task list.
+        /// Register a task to the sequential task list.
         /// </summary>
         /// <param name="taskList"></param>
         /// <param name="cancellationToken"></param>
-        public AsyncRegister(ISequentialTaskListRegistry taskList, CancellationToken cancellationToken = default)
+        public FiberTaskWaiter(ISequentialTaskListRegistry taskList, CancellationToken cancellationToken = default)
         {
             _thread = UserThreadPool.StartNew(1);
             _cancellationToken = cancellationToken;
-            _subscription = taskList.Add(async () =>
-            {
-                await SetFlagAndWaitClearing().ConfigureAwait(false);
-            });
+            _unsubscriber = taskList.Add(ExecuteAsync);
         }
 
         /// <summary>
-        /// Set the flag and wait for it to be cleared.
+        /// Execute a task.
         /// </summary>
         /// <returns></returns>
         /// <exception cref="InvalidOperationException"></exception>
-        public async Task SetFlagAndWaitClearing()
+        public async Task ExecuteAsync()
         {
             lock (_lockObj)
             {
@@ -53,27 +49,27 @@ public async Task SetFlagAndWaitClearing()
                 {
                     return;
                 }
-                if (_hasValue)
+                if (_executionRequested)
                 {
                     throw new InvalidOperationException();
                 }
-                if (_reading)
+                if (_inExecuting)
                 {
                     throw new InvalidOperationException();
                 }
-                if (_notifierSet.IsSet)
+                if (_notifierExecutionRequested.IsSet)
                 {
                     throw new InvalidOperationException();
                 }
 
-                _hasValue = true;
-                _notifierClear.Reset();
-                _notifierSet.Set();
+                _executionRequested = true;
+                _notifierExecutionFinished.Reset();
+                _notifierExecutionRequested.Set();
             }
 
             try
             {
-                await _thread.RegisterWaitForSingleObjectAsync(_notifierClear.WaitHandle, _cancellationToken).ConfigureAwait(false);
+                await _thread.RegisterWaitForSingleObjectAsync(_notifierExecutionFinished.WaitHandle, _cancellationToken).ConfigureAwait(false);
             }
             catch (OperationCanceledException)
             {
@@ -86,12 +82,12 @@ public async Task SetFlagAndWaitClearing()
         }
 
         /// <summary>
-        /// Wait for the flag to be set.
+        /// Wait for task execution.
         /// </summary>
         /// <returns></returns>
         /// <exception cref="ObjectDisposedException"></exception>
         /// <exception cref="OperationCanceledException"></exception>
-        public async Task WaitSetting()
+        public async Task ExecutionStarted()
         {
             lock (_lockObj)
             {
@@ -103,25 +99,25 @@ public async Task WaitSetting()
                 {
                     throw new OperationCanceledException();
                 }
-                if (_hasValue && _reading)
+                if (_executionRequested && _inExecuting)
                 {
-                    _hasValue = false;
-                    _reading = false;
-                    _notifierSet.Reset();
-                    _notifierClear.Set();
+                    _executionRequested = false;
+                    _inExecuting = false;
+                    _notifierExecutionRequested.Reset();
+                    _notifierExecutionFinished.Set();
                 }
             }
 
-            await _thread.RegisterWaitForSingleObjectAsync(_notifierSet.WaitHandle, _cancellationToken).ConfigureAwait(false);
+            await _thread.RegisterWaitForSingleObjectAsync(_notifierExecutionRequested.WaitHandle, _cancellationToken).ConfigureAwait(false);
 
             lock (_lockObj)
             {
-                _reading = true;
+                _inExecuting = true;
             }
         }
 
         /// <summary>
-        /// Unsubscribe.
+        /// Unregister.
         /// </summary>
         public void Dispose()
         {
@@ -132,13 +128,13 @@ public void Dispose()
                     return;
                 }
                 _isDisposed = true;
-                _hasValue = false;
-                _reading = false;
-                _notifierClear.Dispose();
-                _notifierSet.Dispose();
-            }
 
-            _subscription.Dispose();
+                _executionRequested = false;
+                _inExecuting = false;
+                _unsubscriber.Dispose();
+                _notifierExecutionRequested.Dispose();
+                _notifierExecutionFinished.Dispose();
+            }
         }
     }
 }

src/AsyncFiberWorksTests/AsyncRegisterTests.cs renamed to src/AsyncFiberWorksTests/FiberTaskWaiterTests.cs

@@ -8,23 +8,23 @@
 namespace AsyncFiberWorksTests
 {
     [TestFixture]
-    public class AsyncRegisterTests
+    public class FiberTaskWaiterTests
     {
         [Test]
-        public async Task WaitingOfAsyncRegister()
+        public async Task TestWait()
         {
             var taskList = new FiberAndTaskPairList();
             int resultCounter = 0;
             var lockObj = new object();
 
             Func<int, Task> func = async (maxCount) =>
             {
-                using (var reg = new AsyncRegister(taskList))
+                using (var activator = new FiberTaskWaiter(taskList))
                 {
                     int counter = 0;
                     while (counter < maxCount)
                     {
-                        await reg.WaitSetting();
+                        await activator.ExecutionStarted();
                         lock (lockObj)
                         {
                             resultCounter += 1;
@@ -48,7 +48,7 @@ public async Task WaitingOfAsyncRegister()
         }
 
         [Test]
-        public async Task CancellationOfAsyncRegister()
+        public async Task TestCancellation()
         {
             var taskList = new FiberAndTaskPairList();
             int resultCounter = 0;
@@ -59,13 +59,13 @@ public async Task CancellationOfAsyncRegister()
 
             var func = new Func<Task>(async () =>
             {
-                using (var reg = new AsyncRegister(taskList, cancellationToken))
+                using (var activator = new FiberTaskWaiter(taskList, cancellationToken))
                 {
                     try
                     {
                         while (true)
                         {
-                            await reg.WaitSetting();
+                            await activator.ExecutionStarted();
                             lock (lockObj)
                             {
                                 resultCounter += 1;
@@ -93,7 +93,7 @@ public async Task CancellationOfAsyncRegister()
         }
 
         [Test]
-        public async Task WaitingOfAsyncRegisterOfT()
+        public async Task TestWaitingOfT()
         {
             var handlerList = new FiberAndHandlerPairList<int>();
             int resultCounter = 0;
@@ -135,7 +135,7 @@ int Sigma(int n)
         }
 
         [Test]
-        public async Task CancellationOfAsyncRegisterOfT()
+        public async Task TestCancellationOfT()
         {
             var handlerList = new FiberAndHandlerPairList<int>();
             int resultCounter = 0;
@@ -183,7 +183,7 @@ public async Task CancellationOfAsyncRegisterOfT()
         }
 
         [Test]
-        public async Task WaitingOfProcessedFlagEventArgs()
+        public async Task TestWaitingOfProcessedFlagEventArgs()
         {
             var driver = new FiberAndHandlerPairList<int>();
             int resultCounter = 0;