Align the names of task list waiters.

Author: tosh-coding

src/AsyncFiberWorks/Procedures/AsyncRegisterOfT.cs renamed to src/AsyncFiberWorks/Procedures/SequentialHandlerWaiter.cs

@@ -5,11 +5,10 @@
 namespace AsyncFiberWorks.Procedures
 {
     /// <summary>
-    /// Keep only one value. It provides a task from setting the value
-    /// to the completion of processing, and a task until it is set.
+    /// Use "await" to simply wait for the start of a task on a sequential handler list.
     /// </summary>
     /// <typeparam name="T"></typeparam>
-    public class AsyncRegister<T> : IDisposable
+    public class SequentialHandlerWaiter<T> : IDisposable
     {
         private readonly object _lockObj = new object();
         private readonly IDisposable _subscription;
@@ -22,23 +21,23 @@ public class AsyncRegister<T> : IDisposable
         private CancellationToken _cancellationToken;
 
         /// <summary>
-        /// Subscribe a handler list.
+        /// Register a handler to the sequential handler list.
         /// </summary>
         /// <param name="handlerList"></param>
         /// <param name="cancellationToken"></param>
-        public AsyncRegister(ISequentialHandlerListRegistry<T> handlerList, CancellationToken cancellationToken = default)
+        public SequentialHandlerWaiter(ISequentialHandlerListRegistry<T> handlerList, CancellationToken cancellationToken = default)
         {
             _cancellationToken = cancellationToken;
-            _subscription = handlerList.Add((arg) => SetValueAndWaitClearing(arg));
+            _subscription = handlerList.Add((arg) => ExecuteAsync(arg));
         }
 
         /// <summary>
-        /// Set the value and wait for it to be cleared.
+        /// Execute a handler.
         /// </summary>
         /// <param name="newValue"></param>
         /// <returns></returns>
         /// <exception cref="InvalidOperationException"></exception>
-        async Task<bool> SetValueAndWaitClearing(T newValue)
+        async Task<bool> ExecuteAsync(T newValue)
         {
             lock (_lockObj)
             {
@@ -81,12 +80,12 @@ async Task<bool> SetValueAndWaitClearing(T newValue)
         }
 
         /// <summary>
-        /// Wait for the value to be set.
+        /// Wait for handler execution.
         /// </summary>
         /// <returns></returns>
         /// <exception cref="ObjectDisposedException"></exception>
         /// <exception cref="OperationCanceledException"></exception>
-        public async Task<ProcessedFlagEventArgs<T>> WaitSetting()
+        public async Task<ProcessedFlagEventArgs<T>> ExecutionStarted()
         {
             lock (_lockObj)
             {
@@ -117,7 +116,7 @@ public async Task<ProcessedFlagEventArgs<T>> WaitSetting()
         }
 
         /// <summary>
-        /// Unsubscribe.
+        /// Unregister a handle from the sequential handler list.
         /// </summary>
         public void Dispose()
         {

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

@@ -8,7 +8,7 @@
 namespace AsyncFiberWorksTests
 {
     [TestFixture]
-    public class FiberTaskWaiterTests
+    public class SequentialTaskWaiterTests
     {
         [Test]
         public async Task TestWait()
@@ -101,12 +101,12 @@ public async Task TestWaitingOfT()
 
             Func<int, Task> func = async (maxCount) =>
             {
-                using (var reg = new AsyncRegister<int>(handlerList))
+                using (var reg = new SequentialHandlerWaiter<int>(handlerList))
                 {
                     int counter = 0;
                     while (counter < maxCount)
                     {
-                        var e = await reg.WaitSetting();
+                        var e = await reg.ExecutionStarted();
                         lock (lockObj)
                         {
                             resultCounter += e.Arg;
@@ -147,13 +147,13 @@ public async Task TestCancellationOfT()
 
             var func = new Func<Task>(async () =>
             {
-                using (var reg = new AsyncRegister<int>(handlerList, cancellationToken))
+                using (var reg = new SequentialHandlerWaiter<int>(handlerList, cancellationToken))
                 {
                     try
                     {
                         while (true)
                         {
-                            var ret = await reg.WaitSetting();
+                            var ret = await reg.ExecutionStarted();
                             lock (lockObj)
                             {
                                 totalCounter += ret.Arg;
@@ -192,11 +192,11 @@ public async Task TestWaitingOfProcessedFlagEventArgs()
             var cts = new CancellationTokenSource();
             Func<int, Task> func = async (threshold) =>
             {
-                using (var reg = new AsyncRegister<int>(driver, cts.Token))
+                using (var reg = new SequentialHandlerWaiter<int>(driver, cts.Token))
                 {
                     while (true)
                     {
-                        var e = await reg.WaitSetting();
+                        var e = await reg.ExecutionStarted();
                         if (e.Arg < threshold)
                         {
                             e.Processed = false;