[*] Refactor

PowerThreadPool/Core/PowerThreadPool.cs

@@ -13,6 +13,9 @@
 
 namespace PowerThreadPool
 {
+    /// <summary>
+    /// A comprehensive and efficient lock-free thread pool with granular work control, flexible concurrency, and robust error handling, alongside an easy-to-use API for diverse work submissions.
+    /// </summary>
     public partial class PowerPool : IDisposable
     {
         private bool _disposed = false;

PowerThreadPool/Helpers/DelegateHelper.cs

@@ -6,19 +6,30 @@ internal static class DelegateHelper<TResult>
     {
         internal static Func<object[], TResult> ToNormalFunc(Func<TResult> function)
         {
-            TResult func(object[] param) { return function(); }
+            TResult func(object[] param)
+            {
+                return function();
+            }
             return func;
         }
 
         internal static Func<object[], TResult> ToNormalFunc(Action action)
         {
-            TResult func() { action(); return default; }
+            TResult func()
+            {
+                action();
+                return default;
+            }
             return DelegateHelper<TResult>.ToNormalFunc(func);
         }
 
         internal static Func<object[], TResult> ToNormalFunc(Action<object[]> action, object[] param)
         {
-            TResult func(object[] p) { action(param); return default; }
+            TResult func(object[] p)
+            {
+                action(param);
+                return default;
+            }
             return func;
         }
     }
@@ -27,13 +38,20 @@ internal static class DelegateHelper<T1, TResult>
     {
         internal static Func<object[], TResult> ToNormalFunc(Action<T1> action, T1 param1)
         {
-            TResult func(T1 p) { action(p); return default; }
+            TResult func(T1 p)
+            {
+                action(p);
+                return default;
+            }
             return DelegateHelper<T1, TResult>.ToNormalFunc(func, param1);
         }
 
         internal static Func<object[], TResult> ToNormalFunc(Func<T1, TResult> function, T1 param1)
         {
-            TResult func() { return function(param1); }
+            TResult func()
+            {
+                return function(param1);
+            }
             return DelegateHelper<TResult>.ToNormalFunc(func);
         }
     }
@@ -42,13 +60,20 @@ internal static class DelegateHelper<T1, T2, TResult>
     {
         internal static Func<object[], TResult> ToNormalFunc(Action<T1, T2> action, T1 param1, T2 param2)
         {
-            TResult func(T1 p1, T2 p2) { action(p1, p2); return default; }
+            TResult func(T1 p1, T2 p2)
+            {
+                action(p1, p2);
+                return default;
+            }
             return DelegateHelper<T1, T2, TResult>.ToNormalFunc(func, param1, param2);
         }
 
         internal static Func<object[], TResult> ToNormalFunc(Func<T1, T2, TResult> function, T1 param1, T2 param2)
         {
-            TResult func() { return function(param1, param2); }
+            TResult func()
+            {
+                return function(param1, param2);
+            }
             return DelegateHelper<TResult>.ToNormalFunc(func);
         }
     }
@@ -57,13 +82,20 @@ internal static class DelegateHelper<T1, T2, T3, TResult>
     {
         internal static Func<object[], TResult> ToNormalFunc(Action<T1, T2, T3> action, T1 param1, T2 param2, T3 param3)
         {
-            TResult func(T1 p1, T2 p2, T3 p3) { action(p1, p2, p3); return default; }
+            TResult func(T1 p1, T2 p2, T3 p3)
+            {
+                action(p1, p2, p3);
+                return default;
+            }
             return DelegateHelper<T1, T2, T3, TResult>.ToNormalFunc(func, param1, param2, param3);
         }
 
         internal static Func<object[], TResult> ToNormalFunc(Func<T1, T2, T3, TResult> function, T1 param1, T2 param2, T3 param3)
         {
-            TResult func() { return function(param1, param2, param3); }
+            TResult func()
+            {
+                return function(param1, param2, param3);
+            }
             return DelegateHelper<TResult>.ToNormalFunc(func);
         }
     }
@@ -72,13 +104,20 @@ internal static class DelegateHelper<T1, T2, T3, T4, TResult>
     {
         internal static Func<object[], TResult> ToNormalFunc(Action<T1, T2, T3, T4> action, T1 param1, T2 param2, T3 param3, T4 param4)
         {
-            TResult func(T1 p1, T2 p2, T3 p3, T4 p4) { action(p1, p2, p3, p4); return default; }
+            TResult func(T1 p1, T2 p2, T3 p3, T4 p4)
+            {
+                action(p1, p2, p3, p4);
+                return default;
+            }
             return DelegateHelper<T1, T2, T3, T4, TResult>.ToNormalFunc(func, param1, param2, param3, param4);
         }
 
         internal static Func<object[], TResult> ToNormalFunc(Func<T1, T2, T3, T4, TResult> function, T1 param1, T2 param2, T3 param3, T4 param4)
         {
-            TResult func() { return function(param1, param2, param3, param4); }
+            TResult func()
+            {
+                return function(param1, param2, param3, param4);
+            }
             return DelegateHelper<TResult>.ToNormalFunc(func);
         }
     }
@@ -87,13 +126,20 @@ internal static class DelegateHelper<T1, T2, T3, T4, T5, TResult>
     {
         internal static Func<object[], TResult> ToNormalFunc(Action<T1, T2, T3, T4, T5> action, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5)
         {
-            TResult func(T1 p1, T2 p2, T3 p3, T4 p4, T5 p5) { action(p1, p2, p3, p4, p5); return default; }
+            TResult func(T1 p1, T2 p2, T3 p3, T4 p4, T5 p5)
+            {
+                action(p1, p2, p3, p4, p5);
+                return default;
+            }
             return DelegateHelper<T1, T2, T3, T4, T5, TResult>.ToNormalFunc(func, param1, param2, param3, param4, param5);
         }
 
         internal static Func<object[], TResult> ToNormalFunc(Func<T1, T2, T3, T4, T5, TResult> function, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5)
         {
-            TResult func() { return function(param1, param2, param3, param4, param5); }
+            TResult func()
+            {
+                return function(param1, param2, param3, param4, param5);
+            }
             return DelegateHelper<TResult>.ToNormalFunc(func);
         }
     }

PowerThreadPool/Options/PowerPoolOption.cs

@@ -4,13 +4,13 @@
 
 namespace PowerThreadPool.Options
 {
-    public enum QueueType { FIFO, LIFO }
+    public enum QueueType
+    {
+        FIFO,
+        LIFO
+    }
     public class PowerPoolOption
     {
-        public PowerPoolOption()
-        {
-        }
-
         /// <summary>
         /// The maximum number of threads that the thread pool can support.
         /// </summary>

PowerThreadPool/Options/RetryOption.cs

@@ -1,7 +1,17 @@
 namespace PowerThreadPool.Options
 {
-    public enum RetryBehavior { ImmediateRetry, Requeue }
-    public enum RetryPolicy { Limited, Unlimited }
+    public enum RetryBehavior
+    {
+        ImmediateRetry,
+        Requeue
+    }
+
+    public enum RetryPolicy
+    {
+        Limited,
+        Unlimited
+    }
+
     public class RetryOption
     {
         /// <summary>

PowerThreadPool/Options/TimeoutOption.cs

@@ -2,10 +2,6 @@
 {
     public class TimeoutOption
     {
-        public TimeoutOption()
-        {
-        }
-
         /// <summary>
         /// The maximum amount of time (ms).
         /// </summary>

PowerThreadPool/Options/WorkOption.cs

@@ -7,10 +7,6 @@ namespace PowerThreadPool.Options
 {
     public class WorkOption<TResult>
     {
-        public WorkOption()
-        {
-        }
-
         /// <summary>
         /// The custom work ID. If set to null, the thread pool will use a Guid as the work ID.
         /// </summary>
@@ -70,8 +66,5 @@ public WorkOption()
 
     public class WorkOption : WorkOption<object>
     {
-        public WorkOption()
-        {
-        }
     }
 }