updates

PSFramework/internal/scripts/runspaceWorkerCode.ps1

@@ -6,6 +6,7 @@
 	trap {
 		Write-PSFMessage -Level Error -Message "Runspace Worker Code failed" -ErrorRecord $_
 		$__PSF_Worker.State = 'Failed'
+		$__PSF_Worker.SignalEnd()
 		throw $_
 	}
 
@@ -32,6 +33,10 @@
 
 	$validStates = 'Starting', 'Running'
 	while ($validStates -contains $__PSF_Worker.State) {
+		# Inqueue is closed and all items processed?
+		if ($__PSF_Worker.Done) { break }
+		if ($__PSF_Worker.MaxItems -and $__PSF_Worker.MaxItems -ge $__PSF_Worker.CountInputCompleted)
+
 		if ($__PSF_Worker.Throttle) {
 			$__PSF_Worker.Throttle.GetSlot()
 		}
@@ -66,4 +71,6 @@
 			$__PSF_Worker.LastError = $_
 		}
 	}
+
+	$__PSF_Worker.SignalEnd()
 }

PSFramework/tests/functions/runspace/Add-PSFRunspaceWorker.Tests.ps1

@@ -76,10 +76,10 @@ $dis2 | Remove-PSFRunspaceDispatcher
 TODO: Open Dev Items
 
 - Worker:
-  - Should have a "MaxItems" property, to prevent endless circling when done
-  - Should have a way to match a closed inqueue against its total processed items to know when to self-terminate
-  - Should have a "CloseOutQueue" property, to have the last worker runspace close out the output queue when done.
-  - Should have a public Dispatcher property
+  - Should have a "MaxItems" property, to prevent endless circling when done [Done]
+  - Should have a way to match a closed inqueue against its total processed items to know when to self-terminate [Done]
+  - Should have a "CloseOutQueue" property, to have the last worker runspace close out the output queue when done. [Done]
+  - Should have a public Dispatcher property [Done]
 - Dispatcher
-  - Should ToString() to its name
+  - Should ToString() to its name [Done]
 #>

library/PSFramework/Runspace/RSDispatcher.cs

@@ -123,5 +123,14 @@ public void Stop()
             foreach (RSWorker worker in Workers.Values)
                 worker.Stop();
         }
+
+        /// <summary>
+        /// String form of the dispatcher
+        /// </summary>
+        /// <returns></returns>
+        public override string ToString()
+        {
+            return Name;
+        }
     }
 }

library/PSFramework/Runspace/RSWorker.cs

@@ -142,6 +142,11 @@ public ErrorRecord LastError
         /// </summary>
         public bool Completed => CountInputCompleted >= InQueueTotalItemCount;
 
+        /// <summary>
+        /// Whether the inqueue has been closed and fully processed. If so, processing can stop.
+        /// </summary>
+        public bool IsDone => dispatcher.Queues[InQueue].Closed && CountInputCompleted >= InQueueTotalItemCount;
+
         /// <summary>
         /// If this flag is set, worker runspaces will be hard-killed on stop, rather than waiting for them to gracefully shut down
         /// </summary>
@@ -177,6 +182,21 @@ public ErrorRecord LastError
         /// </summary>
         public ConcurrentDictionary<string, RSQueue> PerRSValues = new ConcurrentDictionary<string, RSQueue>(StringComparer.InvariantCultureIgnoreCase);
 
+        /// <summary>
+        /// The maximum number of items this worker will process.
+        /// </summary>
+        public int MaxItems;
+
+        /// <summary>
+        /// Whether the last worker runspace finishing should close the out-queue of this worker
+        /// </summary>
+        public bool CloseOutQueue;
+
+        /// <summary>
+        /// The Dispatcher owning the worker
+        /// </summary>
+        public RSDispatcher Dispatcher => dispatcher;
+
         private RunspacePool pool;
         private RSDispatcher dispatcher;
         private List<RSPowerShellWrapper> runtimes = new List<RSPowerShellWrapper>();
@@ -335,6 +355,28 @@ public ScriptBlock GetEnd()
             return _End.ToGlobal();
         }
 
+        /// <summary>
+        /// The tool for each runspace of the worker to signal it is done.
+        /// Any concluding post-processing is done here, once the last runspace calls it.
+        /// </summary>
+        public void SignalEnd()
+        {
+            bool terminate = false;
+            lock (this)
+            {
+                _CountDone++;
+                if (_CountDone < Count)
+                    terminate = true;
+            }
+            if (terminate)
+                return;
+
+            // Seal the out queue if desired, ensuring subsequent workers know not to expect further input
+            if (CloseOutQueue)
+                dispatcher.CloseQueue(OutQueue);
+        }
+        private int _CountDone = 0;
+
         /// <summary>
         /// The text form of the current worker
         /// </summary>