The waiter creation process has been made into a function.

Author: tosh-coding

src/AsyncFiberWorks/Procedures/SequentialHandlerExtensions.cs

@@ -0,0 +1,25 @@
+using System.Threading;
+
+namespace AsyncFiberWorks.Procedures
+{
+    /// <summary>
+    /// A collection of useful FiberAndHandlerPairList operations.
+    /// </summary>
+    public static class SequentialHandlerExtensions
+    {
+        /// <summary>
+        /// Creates a registered waiter in the handler list.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="handlerList"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public static SequentialHandlerWaiter<T> CreateWaiter<T>(this FiberAndHandlerPairList<T> handlerList, CancellationToken cancellationToken = default)
+        {
+            var waiter = new SequentialHandlerWaiter<T>(cancellationToken);
+            var unregister = handlerList.Add(waiter.Handler);
+            waiter.SetDisposable(unregister);
+            return waiter;
+        }
+    }
+}

src/AsyncFiberWorks/Procedures/SequentialHandlerWaiter.cs

@@ -21,6 +21,7 @@ public class SequentialHandlerWaiter<T> : IDisposable
         private CancellationToken _cancellationTokenExternal;
         private readonly CancellationTokenSource _onDispose = new CancellationTokenSource();
         private readonly ProcessedFlagEventArgs<T> _currentValue = new ProcessedFlagEventArgs<T>();
+        private IDisposable _extraDisposable;
 
         /// <summary>
         /// Constructor.
@@ -32,6 +33,15 @@ public SequentialHandlerWaiter(CancellationToken cancellationToken = default)
             _cancellationTokenExternal = cancellationToken;
         }
 
+        /// <summary>
+        /// Register additional objects you want to destroy when Dispose is performed.
+        /// </summary>
+        /// <param name="disposable"></param>
+        public void SetDisposable(IDisposable disposable)
+        {
+            _extraDisposable = disposable;
+        }
+
         /// <summary>
         /// Execute a handler.
         /// </summary>
@@ -168,6 +178,8 @@ public void Dispose()
                 _notifierExecutionRequested.Dispose();
                 _notifierExecutionFinished.Dispose();
             }
+            _extraDisposable?.Dispose();
+            _extraDisposable = null;
             _thread.Dispose();
         }
     }

src/AsyncFiberWorks/Procedures/SequentialTaskExtensions.cs

@@ -0,0 +1,24 @@
+using System.Threading;
+
+namespace AsyncFiberWorks.Procedures
+{
+    /// <summary>
+    /// A collection of useful FiberAndTaskPairList operations.
+    /// </summary>
+    public static class SequentialTaskExtensions
+    {
+        /// <summary>
+        /// Creates a registered waiter in the task list.
+        /// </summary>
+        /// <param name="taskList"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>The created waiter is configured to be unregistered from the task list when it is Disposed.</returns>
+        public static SequentialTaskWaiter CreateWaiter(this FiberAndTaskPairList taskList, CancellationToken cancellationToken = default)
+        {
+            var waiter = new SequentialTaskWaiter(cancellationToken);
+            var unregister = taskList.Add(waiter.ExecuteTask);
+            waiter.SetDisposable(unregister);
+            return waiter;
+        }
+    }
+}

src/AsyncFiberWorks/Procedures/SequentialTaskWaiter.cs

@@ -19,6 +19,7 @@ public class SequentialTaskWaiter : IDisposable
         private bool _inExecuting;
         private CancellationToken _cancellationTokenExternal;
         private readonly CancellationTokenSource _onDispose = new CancellationTokenSource();
+        private IDisposable _extraDisposable;
 
         /// <summary>
         /// Constructor.
@@ -30,6 +31,15 @@ public SequentialTaskWaiter(CancellationToken cancellationToken = default)
             _cancellationTokenExternal = cancellationToken;
         }
 
+        /// <summary>
+        /// Register additional objects you want to destroy when Dispose is performed.
+        /// </summary>
+        /// <param name="disposable"></param>
+        public void SetDisposable(IDisposable disposable)
+        {
+            _extraDisposable = disposable;
+        }
+
         /// <summary>
         /// Execute a task.
         /// </summary>
@@ -152,6 +162,8 @@ public void Dispose()
                 _notifierExecutionRequested.Dispose();
                 _notifierExecutionFinished.Dispose();
             }
+            _extraDisposable?.Dispose();
+            _extraDisposable = null;
             _thread.Dispose();
         }
     }

src/AsyncFiberWorksTests/SequentialTaskWaiterTests.cs

@@ -19,8 +19,7 @@ public async Task TestWait()
 
             Func<int, Task> func = async (maxCount) =>
             {
-                using (var activator = new SequentialTaskWaiter())
-                using (var unsubscriber = taskList.Add(activator.ExecuteTask))
+                using (var activator = taskList.CreateWaiter())
                 {
                     int counter = 0;
                     while (counter < maxCount)
@@ -60,8 +59,7 @@ public async Task TestCancellation()
 
             var func = new Func<Task>(async () =>
             {
-                using (var activator = new SequentialTaskWaiter(cancellationToken))
-                using (var unsubscriber = taskList.Add(activator.ExecuteTask))
+                using (var activator = taskList.CreateWaiter(cancellationToken))
                 {
                     try
                     {
@@ -103,8 +101,7 @@ public async Task TestWaitingOfT()
 
             Func<int, Task> func = async (maxCount) =>
             {
-                using (var reg = new SequentialHandlerWaiter<int>())
-                using (var unsubscriber = handlerList.Add(reg.Handler))
+                using (var reg = handlerList.CreateWaiter())
                 {
                     int counter = 0;
                     while (counter < maxCount)
@@ -150,8 +147,7 @@ public async Task TestCancellationOfT()
 
             var func = new Func<Task>(async () =>
             {
-                using (var reg = new SequentialHandlerWaiter<int>(cancellationToken))
-                using (var unsubscriber = handlerList.Add(reg.Handler))
+                using (var reg = handlerList.CreateWaiter(cancellationToken))
                 {
                     try
                     {
@@ -196,8 +192,7 @@ public async Task TestWaitingOfProcessedFlagEventArgs()
             var cts = new CancellationTokenSource();
             Func<int, Task> func = async (threshold) =>
             {
-                using (var reg = new SequentialHandlerWaiter<int>(cts.Token))
-                using (var unsubscriber = handlerList.Add(reg.Handler))
+                using (var reg = handlerList.CreateWaiter(cts.Token))
                 {
                     while (true)
                     {