RequestContainer minor improvements

Author: Meyn

Requests/RequestContainer.cs

@@ -274,10 +274,17 @@ public virtual void Remove(params TRequest[] requests)
 
             while (Interlocked.CompareExchange(ref _writeInProgress, 1, 0) == 1)
                 Thread.Yield();
-            _requests = GetStored().Where(x => !requests.Any(y => y.Equals(x))).ToArray();
+
+            var storedRequests = GetStored().Where(x => !requests.Any(y => y.Equals(x))).ToArray();
+
+            int newSize = storedRequests.Length + 32;
+
+            Array.Resize(ref storedRequests, newSize);
+
+            _requests = storedRequests;
             _count = _requests.Length;
 
-            Interlocked.Exchange(ref _writeInProgress, 0); // Release the write lock
+            Interlocked.Exchange(ref _writeInProgress, 0);
 
             if (_count > 0 && !Task.IsCompleted)
                 NewTaskCompletion();

Requests/RequestHandler.cs

@@ -1,5 +1,6 @@
 using Requests.Channel;
 using Requests.Options;
+using System.Text;
 
 namespace Requests
 {
@@ -45,8 +46,8 @@ protected set
         /// <summary>
         /// Represents the combined task of the requests.
         /// </summary>
-        public Task Task => _task.Task;
-        private readonly TaskCompletionSource _task = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public Task Task => _task ?? Task.CompletedTask;
+        private Task? _task;
 
         /// <summary>
         /// Gets the aggregate exception associated with the <see cref="RequestHandler"/> instance.
@@ -102,6 +103,24 @@ public int? StaticDegreeOfParallelism
         /// </summary>
         public int Count => _requestsChannel.Count;
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequestHandler"/> class with a priority channel.
+        /// If the priority count is zero, an exception is thrown; otherwise, a fixed-size priority channel is created.
+        /// If the priority count is null, a dynamic-size priority channel is created.
+        /// </summary>
+        /// <param name="priorityCount">The number of priority levels for the fixed-size priority channel. If zero, an exception is thrown. If null, a dynamic-size priority channel is used.</param>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown if the priority count is negative or zero.</exception>
+        public RequestHandler(int priorityCount = 3)
+        {
+            if (priorityCount < 0)
+                throw new ArgumentOutOfRangeException(nameof(priorityCount), "Priority count cannot be negative.");
+
+            _requestsChannel = priorityCount > 0 ?
+                 new FixedPriorityChannel<IRequest>(priorityCount)
+                : new DynamicPriorityChannel<IRequest>();
+        }
+
+
         /// <summary>
         /// Constructor for the <see cref="RequestHandler"/> class.
         /// </summary>
@@ -113,20 +132,6 @@ public RequestHandler(params IRequest[] requests) : this()
             _requestsChannel.Options.MaxDegreeOfParallelism = Math.Min(AutoParallelism.Invoke(), MaxParallelism);
         }
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="RequestHandler"/> class with a priority channel.
-        /// If the priority count is zero, a dynamic-size priority channel is created; otherwise, a fixed-size priority channel is created.
-        /// </summary>
-        /// <param name="priorityCount">The number of priority levels for the fixed-size priority channel. If zero, a dynamic-size priority channel is used.</param>
-        /// <exception cref="ArgumentOutOfRangeException">Thrown if the priority count is negative.</exception>
-        public RequestHandler(int priorityCount = 3)
-        {
-            if (priorityCount < 0)
-                throw new ArgumentOutOfRangeException(nameof(priorityCount), "Priority count cannot be negative.");
-
-            _requestsChannel = priorityCount == 0 ? new DynamicPriorityChannel<IRequest>() : new FixedPriorityChannel<IRequest>(priorityCount);
-        }
-
         /// <summary>
         /// Method to add a single instance of the <see cref="IRequest"/> interface to the handler.
         /// </summary>
@@ -211,7 +216,11 @@ public void CreateCTS()
         /// <summary>
         /// Cancels the main <see cref="CancellationTokenSource"/> for all instances of the <see cref="IRequest"/> interface in this RequestHandler.
         /// </summary>
-        public void Cancel() => _cts.Cancel();
+        public void Cancel()
+        {
+            _cts.Cancel();
+            State = RequestState.Cancelled;
+        }
 
         /// <summary>
         /// Cancels the main <see cref="CancellationTokenSource"/> for all instances of the <see cref="IRequest"/> interface in the Main RequestHandlers.
@@ -228,16 +237,15 @@ public void CreateCTS()
         /// </summary>
         public static void ReusmeMain() => Array.ForEach(MainRequestHandlers, handler => handler.Start());
 
-
         /// <summary>
         /// This method is responsible for executing the instances of the  <see cref="IRequest"/> if the handler is not currently running.
         /// It updates the degree of parallelism based on the current system environment and runs the request channel.
         /// </summary>
         public void RunRequests()
         {
-            if (State == RequestState.Running || CancellationToken.IsCancellationRequested || _pts.IsPaused)
+            if (State != RequestState.Idle)
                 return;
-            Task.Run(async () => await RunChannel());
+            Task.Run(async () => await ((IRequest)this).StartRequestAsync());
         }
 
         /// <summary>
@@ -246,9 +254,10 @@ public void RunRequests()
         /// </summary>
         async Task IRequest.StartRequestAsync()
         {
-            if (State == RequestState.Running || CancellationToken.IsCancellationRequested || _pts.IsPaused)
+            if (State != RequestState.Idle || CancellationToken.IsCancellationRequested || _pts.IsPaused)
                 return;
-            await RunChannel();
+            _task = RunChannel();
+            await Task;
         }
 
         /// <summary>
@@ -261,8 +270,8 @@ private async Task RunChannel()
             UpdateAutoParallelism();
             await _requestsChannel.RunParallelReader(async (pair, ct) => await HandleRequests(pair));
             State = RequestState.Idle;
-            if (_requestsChannel.Reader.Count != 0)
-                RunRequests();
+            if (_requestsChannel.Reader.Count > 0)
+                await ((IRequest)this).StartRequestAsync();
         }
 
         /// <summary>
@@ -299,7 +308,6 @@ public void UpdateAutoParallelism()
         /// <summary>
         /// Attempts to set all <see cref="IRequest"/> objects in the container's <see cref="State"/> to idle.
         /// No new requests will be started or read while processing. And the running requests will be paused.
-        /// After finishing, the request handler will still be paused.
         /// </summary>
         /// <returns>True if all <see cref="IRequest"/> objects are in an idle <see cref="RequestState"/>, otherwise false.</returns>
         public bool TrySetIdle()
@@ -319,13 +327,36 @@ public void Dispose()
             if (_disposed)
                 return;
 
-            _task.SetResult();
             Cancel();
             _cts.Dispose();
             _disposed = true;
             GC.SuppressFinalize(this);
         }
 
+        /// <summary>
+        /// Provides a detailed string representation of the current state of the <see cref="RequestHandler"/> instance.
+        /// </summary>
+        /// <returns>A string that represents the current state of the <see cref="RequestHandler"/>.</returns>
+        public override string ToString()
+        {
+            var sb = new StringBuilder();
+
+            sb.AppendLine("RequestHandler State:");
+            sb.AppendLine($"  Disposed: {_disposed}");
+            sb.AppendLine($"  Cancellation Requested: {_cts.IsCancellationRequested}");
+            sb.AppendLine($"  Paused: {_pts.IsPaused}");
+            sb.AppendLine($"  State: {State}");
+            sb.AppendLine($"  Priority: {Priority}");
+            sb.AppendLine($"  Task Status: {Task.Status}");
+            sb.AppendLine($"  Exception: {Exception?.Message ?? "None"}");
+            sb.AppendLine($"  Static Degree of Parallelism: {StaticDegreeOfParallelism?.ToString() ?? "Auto"}");
+            sb.AppendLine($"  Max Parallelism: {MaxParallelism}");
+            sb.AppendLine($"  Request Count: {Count}");
+            sb.AppendLine($"  CancellationToken: {CancellationToken.IsCancellationRequested}");
+            sb.AppendLine($"  PauseToken: {_pts.IsPaused}");
+
+            return sb.ToString();
+        }
         /// <summary>
         /// Attempts to remove the specified requests from the priority channel.
         /// </summary>

Requests/Requests.csproj

@@ -8,21 +8,22 @@
     <GenerateDocumentationFile>True</GenerateDocumentationFile>
     <Authors>Meyn</Authors>
     <Company>Shard</Company>
-    <Description>Requests is your go-to C# .NET 6 library for handling requests in a parallel async state. It’s like having a reliable co-pilot for your code. With features like priority settings, retry functions, and expandable classes, it’s the perfect companion for HTTP requests and other CPU-intensive tasks. Features include retry functions, priority settings, and notification delegates.</Description>
+    <Description>A C# .NET 6 library for parallel async request handling. Features include priority settings, retry functions, and expandable classes, making it ideal for HTTP requests and CPU-intensive tasks.</Description>
     <Copyright>Shard © 2024</Copyright>
     <PackageProjectUrl></PackageProjectUrl>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <RepositoryType>git</RepositoryType>
     <PackageTags>async; channel; priority; request; parallel; </PackageTags>
     <RepositoryUrl>https://github.com/TypNull/Requests</RepositoryUrl>
     <PackageIcon>logo.png</PackageIcon>
-    <Version>2.1.5</Version>
+    <Version>2.1.6</Version>
     <PackageRequireLicenseAcceptance>True</PackageRequireLicenseAcceptance>
     <PackageLicenseFile>LICENSE.txt</PackageLicenseFile>
     <PackageId>Shard.Requests</PackageId>
-    <PackageReleaseNotes>Fix CTS cancellation issue
-Enhance RequestContainer concurrency
-Expand unit test coverage</PackageReleaseNotes>
+    <PackageReleaseNotes>Introduced DynamicPriorityChannel to manage dynamic priority handling.
+Implemented RequestContainer interface into RequestHandler to add request logic.
+Changed RequestPriority to a floating type for enhanced flexibility.
+RequestHandler minor improvements</PackageReleaseNotes>
   </PropertyGroup>
 
   <ItemGroup>