RELEASE v2.3.1 - comments and readme.md

Author: tomFlidr

Base.cs

@@ -209,12 +209,20 @@ protected virtual void executeTask (Task task) {
 			object taskResult = null;
 			object taskJob = task.Job;
 			try {
-				if (taskJob is TaskDelegate) {
-					(taskJob as TaskDelegate).Invoke(this);
-				} else if (taskJob is Func<Base, object>) {
-					taskResult = (taskJob as Func<Base, object>).Invoke(this);
-				} else {
-					throw new Exception("Pooler task has to be type 'delegate', 'Pooler.TaskDelegate' (void accepting first param to be 'Pooler.Base') or 'Func<Pooler.Base, object>'.");
+				if (taskJob is ParallelTaskDelegate) {
+					(taskJob as ParallelTaskDelegate).Invoke(this as Parallel);
+				} else if (taskJob is RepeaterTaskDelegate) {
+                    (taskJob as RepeaterTaskDelegate).Invoke(this as Repeater);
+                } else if (taskJob is Func<Parallel, object>) {
+					taskResult = (taskJob as Func<Parallel, object>).Invoke(this as Parallel);
+				} else if (taskJob is Func<Repeater, object>) {
+                    taskResult = (taskJob as Func<Repeater, object>).Invoke(this as Repeater);
+                } else {
+					throw new Exception(
+                        "Pooler task has to be type: "
+                        + "Pooler.ParallelTaskDelegate | Pooler.RepeaterTaskDelegate | "
+                        + "Func<Pooler.Parallel, object> | Func<Pooler.Repeater, object>."
+                    );
 				}
 			} catch (Exception e) {
 				lock (this.exceptionsLock) {

Delegates.cs

@@ -21,15 +21,10 @@
 	/// Any delegate added internaly into tasks store in Add() method with no params section or with single param accepting Pooler.Base type.
 	/// </summary>
 	/// <param name="pool">threads instance pool instance.</param>
-    public delegate void TaskDelegate (Base pool);
+	public delegate void ParallelTaskDelegate (Parallel pool);
     /// <summary>
 	/// Any delegate added internaly into tasks store in Add() method with no params section or with single param accepting Pooler.Base type.
 	/// </summary>
 	/// <param name="pool">threads instance pool instance.</param>
-	public delegate void TaskDelegateParallel (Parallel pool);
-    /// <summary>
-	/// Any delegate added internaly into tasks store in Add() method with no params section or with single param accepting Pooler.Base type.
-	/// </summary>
-	/// <param name="pool">threads instance pool instance.</param>
-	public delegate void TaskDelegateRepeater (Repeater pool);
+	public delegate void RepeaterTaskDelegate (Repeater pool);
 }

Parallel.cs

@@ -93,7 +93,7 @@ public Parallel Add (Func<Parallel, object> task, bool runInstantly = true, Thre
 		/// <param name="priority">Background thread priority for task executing.</param>
 		/// <param name="async">If task is using any other threads to work or async code, set this to true and call pool.AsyncTaskDone() call after your task is done manualy.</param>
 		/// <returns>Current threads pool instance.</returns>
-		public Parallel Add (TaskDelegateParallel task, bool runInstantly = true, ThreadPriority priority = ThreadPriority.Normal, bool async = false) {
+		public Parallel Add (ParallelTaskDelegate task, bool runInstantly = true, ThreadPriority priority = ThreadPriority.Normal, bool async = false) {
 			lock (this.runningTasksLock) {
 				this._store.Add(new Task {
 					Job = task,

Pooler.nuspec

@@ -2,7 +2,7 @@
 <package xmlns="http://schemas.microsoft.com/packaging/2011/08/nuspec.xsd">
 	<metadata>
 		<id>Pooler</id>
-		<version>2.3.0.0</version>
+		<version>2.3.1.0</version>
 		<title>Pooler</title>
 		<authors>Tom Flidr</authors>
 		<owners>Tom Flidr</owners>

Properties/AssemblyInfo.cs

@@ -36,5 +36,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("2.3.0.0")]
-[assembly: AssemblyFileVersion("2.3.0.0")]
+[assembly: AssemblyVersion("2.3.1.0")]
+[assembly: AssemblyFileVersion("2.3.1.0")]

README.md

@@ -33,7 +33,7 @@ Pooler.Parallel pool = Pooler.Parallel.CreateNew(10);
 for (int i = 0; i < 500; i++) {
 	pool.Add(
 		// any delegate or void to process
-		(Pooler.Base pool) => {
+		(Pooler.Parallel pool) => {
 			double dummyResult = Math.Pow(Math.PI, Math.PI);
 		},
 		// optional - do not run task instantly after adding, run them a few lines later together
@@ -55,13 +55,13 @@ pool.Add(delegate {
 	double dummyResult = Math.Pow(Math.PI, Math.PI);
 });
 // ... or to add task as any void function accepting first param as Pooler type:
-pool.Add((Pooler.Base p) => {
+pool.Add((Pooler.Parallel p) => {
 	double dummyResult = Math.Pow(Math.PI, Math.PI);
 });
 
-// ... or to add task as Func<Pooler.Base, object> function:
+// ... or to add task as Func<Pooler.Parallel, object> function:
 // accepting first param as Pooler type and returning any result:
-pool.Add((Pooler.Base p) => {
+pool.Add((Pooler.Parallel p) => {
 	return Math.Pow(Math.PI, Math.PI);
 });
 // ... then you can pick up returned result in pool.TaskDone event:
@@ -141,7 +141,7 @@ int pausemiliseconds = pool.GetPauseMiliseconds();
 
 2. Use `pool.Pause();` method sometimes in your hard task:
 ```cs
-pool.Add((Pooler.Base p) => {
+pool.Add((Pooler.Parallel p) => {
 	double someHardCode1 = Math.Pow(Math.PI, Math.PI);
 	p.Pause();
 	double someHardCode2 = Math.Pow(Math.PI, Math.PI);
@@ -169,7 +169,7 @@ pool = Pooler.Repeater.CreateNew(10, 500, 100);
 pool = new Pooler.Repeater(10, 500, 100);
 ```
 - First (optional) param is max. threads in background to executing one specific task. 10 by default.
-- Second (optional) param is how many times will be specific task executed. Null means infinite, then you need to use pool.StopAll(); somewhere in the future manualy.
+- Second (optional) param is how many times will be specific task executed. Null means infinite (zero - 0 - doesn't means infinite), then you need to use pool.StopAll(); or pool.StopCurrent(); somewhere in the task body in the future future manualy.
 - Third (optional) param is pause miliseconds to slow down CPU load or other resources by `pool.Pause();` calls inside your task, 0 by default.
 
 #### Repeater instance and single specific task setup:
@@ -180,13 +180,13 @@ pool.Set(delegate {
 	double dummyResult = Math.Pow(Math.PI, Math.PI);
 });
 // ... or set task as any void function accepting first param as Pooler type:
-pool.Set((Pooler.Base p) => {
+pool.Set((Pooler.Repeater p) => {
 	double dummyResult = Math.Pow(Math.PI, Math.PI);
 });
 
-// ... or set task as Func<Pooler.Base, object> function:
+// ... or set task as Func<Pooler.Repeater, object> function:
 // accepting first param as Pooler type and returning any result:
-pool.Set((Pooler.Base p) => {
+pool.Set((Pooler.Repeater p) => {
 	return Math.Pow(Math.PI, Math.PI);
 });
 // ... then you can pick up returned result as before in pool.TaskDone event:
@@ -223,7 +223,7 @@ To use any other threads or async code in your pool tasks, you need to tell pool
 ```cs
 pool.Add(
 	// any delegate or void to process
-	(Pooler.Base pool) => {
+	(Pooler.Parallel pool) => {
 		// some async code start here:
 		CustomDownloader client = new CustomDownloader(
 			"http://example.com/something/what/takes/some/time/to/load"

Repeater.cs

@@ -38,7 +38,7 @@ public class Repeater: Base {
 		/// Create and return new threads pool instance, nowhere regstered, just created.
 		/// </summary>
 		/// <param name="maxRunningTasks">Max threads running in parallel to execute given tasks.</param>
-		/// <param name="tasksCount">Tasks count to process repeatedly, zero means infinite.</param>
+		/// <param name="tasksCount">Tasks count to process repeatedly, null means infinite.</param>
 		/// <param name="pauseMiliseconds">Miliseconds for pooler.Pause(); call inside any task to slow down CPU or any other computer resources for each running thread in threads pool.</param>
 		public Repeater (int maxRunningTasks = 10, int? tasksCount = null, int pauseMiliseconds = 0) : base(maxRunningTasks, pauseMiliseconds) {
 			this._tasksCount = tasksCount;
@@ -47,7 +47,7 @@ public Repeater (int maxRunningTasks = 10, int? tasksCount = null, int pauseMili
 		/// Get single instance from Parallel.instance place created only once.
 		/// </summary>
 		/// <param name="maxRunningTasks">Max threads running in parallel to execute given tasks.</param>
-		/// <param name="tasksCount">Tasks count to process repeatedly, zero means infinite.</param>
+		/// <param name="tasksCount">Tasks count to process repeatedly, null means infinite.</param>
 		/// <param name="pauseMiliseconds">Miliseconds for pooler.Pause(); call inside any task to slow down CPU or any other computer resources for each running thread in threads pool.</param>
 		/// <returns>static instance created only once.</returns>
 		public static Repeater GetStaticInstance (int maxRunningTasks = Base.RUNNING_TASKS_MAX_DEFAULT, int? tasksCount = null, int pauseMiliseconds = Base.PAUSE_MILESECONDS_DEFAULT) {
@@ -60,7 +60,7 @@ public static Repeater GetStaticInstance (int maxRunningTasks = Base.RUNNING_TAS
 		/// Create and return new threads pool instance, nowhere regstered, just created.
 		/// </summary>
 		/// <param name="maxRunningTasks">Max threads running in parallel to execute given tasks.</param>
-		/// <param name="tasksCount">Tasks count to process repeatedly, zero means infinite.</param>
+		/// <param name="tasksCount">Tasks count to process repeatedly, null means infinite.</param>
 		/// <param name="pauseMiliseconds">Miliseconds for pooler.Pause(); call inside any task to slow down CPU or any other computer resources for each running thread in threads pool.</param>
 		/// <returns>New threads pool instance to use.</returns>
 		public static Repeater CreateNew (int maxRunningTasks = Base.RUNNING_TASKS_MAX_DEFAULT, int? tasksCount = null, int pauseMiliseconds = Base.PAUSE_MILESECONDS_DEFAULT) {
@@ -124,7 +124,7 @@ public Repeater Set (Func<Repeater, object> task, bool runInstantly = true, Thre
 		/// <param name="priority">Background thread priority for task executing.</param>
 		/// <param name="async">If task is using any other threads to work or async code, set this to true and call pool.AsyncTaskDone() call after your task is done manualy.</param>
 		/// <returns>Current threads pool instance.</returns>
-		public Repeater Set (TaskDelegateRepeater task, bool runInstantly = true, ThreadPriority priority = ThreadPriority.Normal, bool async = false) {
+		public Repeater Set (RepeaterTaskDelegate task, bool runInstantly = true, ThreadPriority priority = ThreadPriority.Normal, bool async = false) {
 			lock (this.runningTasksLock) {
 				this._task = new Task {
 					Job = task,