Implement SubsequentRequest

Fix RequestContainer GetRequests issue
Update UnitTests

Author: Meyn

Requests/IRequest.cs

@@ -22,6 +22,16 @@ public interface IRequest : IDisposable
         /// </summary>
         public abstract RequestPriority Priority { get; }
 
+        /// <summary>
+        /// Specifies a request that should be executed immediately after this request completes, bypassing the queue.
+        /// </summary>
+        /// <remarks>
+        /// The subsequent request supports auto-starting if enabled, but this behavior can be disabled if not desired.
+        /// <br/>If the subsequent request is already running, it will not be started again.
+        /// <br/>If this request fails, the subsequent request will be canceled and disposed.
+        /// </remarks>
+        public abstract IRequest? SubsequentRequest { get; }
+
         /// <summary>
         /// Gets the <see cref="System.Threading.Tasks.Task"/> representing the completion status of this <see cref="IRequest"/>.
         /// </summary>
@@ -35,7 +45,7 @@ public interface IRequest : IDisposable
         /// <summary>
         /// Starts the execution of the <see cref="IRequest"/> created from this object.
         /// </summary>
-        protected internal Task StartRequestAsync();
+        public Task StartRequestAsync();
 
         /// <summary>
         /// Cancels the execution of the <see cref="IRequest"/>.

Requests/IRequestContainer.cs

@@ -14,6 +14,12 @@ public interface IRequestContainer<TRequest> : IEnumerable<TRequest>, IRequest w
         /// </summary>
         int Count { get; }
 
+        /// <summary>
+        /// Represents a task that completes when all the requests currently available in the container have completed.
+        /// This task does not include requests that may be added to the container in the future.
+        /// </summary>
+        Task CurrentTask { get; }
+
         /// <summary>
         /// Incorporates a <see cref="IRequest"/> into the <see cref="IRequestContainer{TRequest}"/>.
         /// </summary>

Requests/Options/IRequestOptions.cs

@@ -42,6 +42,16 @@ public interface IRequestOptions<TCompleated, TFailed>
         /// </summary>
         public CancellationToken? CancellationToken { get; set; }
 
+        /// <summary>
+        /// Specifies a request that should be executed immediately after this request completes, bypassing the queue.
+        /// </summary>
+        /// <remarks>
+        /// The subsequent request supports auto-starting if enabled, but this behavior can be disabled if not desired.
+        /// <br/>If the subsequent request is already running, it will not be started again.
+        /// <br/>If the holding request fails, the subsequent request will be canceled and disposed.
+        /// </remarks>
+        public IRequest? SubsequentRequest { get; set; }
+
         /// <summary>
         /// An event that will be triggered when the <see cref="IRequest"/> is cancelled.
         /// </summary>

Requests/Options/RequestOptions.cs

@@ -18,14 +18,19 @@ public record RequestOptions<TCompleated, TFailed> : IRequestOptions<TCompleated
 
         ///<inheritdoc />
         public TimeSpan? DeployDelay { get; set; } = null;
+
         ///<inheritdoc />
         public RequestHandler Handler { get; set; } = RequestHandler.MainRequestHandlers[0];
+
         ///<inheritdoc />
         public byte NumberOfAttempts { get; set; } = 3;
 
         ///<inheritdoc />
         public TimeSpan? DelayBetweenAttemps { get; set; } = null;
 
+        ///<inheritdoc />
+        public IRequest? SubsequentRequest { get; set; }
+
         ///<inheritdoc />
         public Notify<IRequest>? RequestStarted { get; set; }
 
@@ -51,6 +56,7 @@ protected RequestOptions(RequestOptions<TCompleated, TFailed> options)
             AutoStart = options.AutoStart;
             DelayBetweenAttemps = options.DelayBetweenAttemps;
             DeployDelay = options.DeployDelay;
+            SubsequentRequest = options.SubsequentRequest;
             RequestCancelled += options.RequestCancelled;
             RequestStarted += options.RequestStarted;
             RequestFailed += options.RequestFailed;

Requests/Request.cs

@@ -117,6 +117,9 @@ public virtual RequestState State
         /// </summary>
         public virtual RequestPriority Priority => Options.Priority;
 
+        /// <inheritdoc/>
+        IRequest? IRequest.SubsequentRequest => Options.SubsequentRequest;
+
         /// <summary>
         /// Constructor for the <see cref="Request{TOptions, TCompleted, TFailed}"/> class.
         /// </summary>
@@ -166,6 +169,7 @@ public virtual void Cancel()
             if (!_disposed)
                 _cts.Cancel();
             _isFinished.TrySetCanceled();
+            Options.SubsequentRequest?.Cancel();
         }
 
         /// <summary>

Requests/RequestContainer.cs

@@ -65,6 +65,15 @@ protected set
         /// </summary>
         public AggregateException? Exception => new(GetStored().Where(x => x?.Exception != null).Select(x => x!.Exception!));
 
+        /// <summary>
+        /// Represents a task that completes when all the requests currently available in the container have completed.
+        /// This task does not include requests that may be added to the container in the future.
+        /// </summary>
+        public Task CurrentTask => Task.WhenAll(GetStored().Select(request => request.Task));
+
+        /// <inheritdoc/>
+        IRequest? IRequest.SubsequentRequest => null;
+
         /// <summary>
         /// Constructor that merges <see cref="IRequest"/> instances together.
         /// </summary>
@@ -275,14 +284,15 @@ public virtual void Remove(params TRequest[] requests)
             while (Interlocked.CompareExchange(ref _writeInProgress, 1, 0) == 1)
                 Thread.Yield();
 
-            var storedRequests = GetStored().Where(x => !requests.Any(y => y.Equals(x))).ToArray();
+            TRequest[] storedRequests = GetStored().Where(x => !requests.Any(y => y.Equals(x))).ToArray();
 
-            int newSize = storedRequests.Length + 32;
+            int size = storedRequests.Length;
+            int newSize = size + 32;
 
             Array.Resize(ref storedRequests, newSize);
 
             _requests = storedRequests;
-            _count = _requests.Length;
+            _count = size;
 
             Interlocked.Exchange(ref _writeInProgress, 0);
 
@@ -300,7 +310,7 @@ public virtual void Remove(params TRequest[] requests)
         public void Cancel()
         {
             _isCanceled = true;
-            foreach (var request in GetStored())
+            foreach (TRequest request in GetStored())
                 request.Cancel();
 
         }

Requests/RequestHandler.cs

@@ -103,6 +103,20 @@ public int? StaticDegreeOfParallelism
         /// </summary>
         public int Count => _requestsChannel.Count;
 
+        /// <summary>
+        /// Represents a task that completes when all the requests currently present in the handler have finished processing.
+        /// This task does not account for any requests that may be added to the handler after its creation.
+        /// </summary>
+        /// <remarks>
+        /// <strong>Warning:</strong> This operation may block the handler for a period of time.
+        /// </remarks>
+        public Task CurrentTask => Task.WhenAll(_requestsChannel.ToArray().Select(requestPair => requestPair.Item.Task));
+
+        /// <summary>
+        /// Specifies a request that should be executed immediately after this request completes, bypassing the queue.
+        /// </summary>
+        IRequest? IRequest.SubsequentRequest => null;
+
         /// <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.
@@ -285,11 +299,38 @@ private async Task HandleRequests(PriorityItem<IRequest> pair)
             await request.StartRequestAsync();
 
             if (request.State is RequestState.Compleated or RequestState.Failed or RequestState.Cancelled)
+            {
                 request.Dispose();
+
+                if (request.SubsequentRequest != null)
+                    await SubsequentRequest(request);
+            }
             else if (request.State == RequestState.Idle)
                 await _requestsChannel.Writer.WriteAsync(pair);
         }
 
+        /// <summary>
+        /// Processes the subsequent request of the given request. Starts it if the current request completes,
+        /// or disposes it and processes the chain if the current request fails or is canceled.
+        /// </summary>
+        /// <param name="request">The request to process.</param>
+        /// <returns>A task representing the operation.</returns>
+        private async Task SubsequentRequest(IRequest request)
+        {
+            IRequest subRequest = request.SubsequentRequest!;
+            if (request.State == RequestState.Compleated)
+            {
+                if (subRequest.State != RequestState.Running && subRequest.TrySetIdle())
+                    await HandleRequests(new PriorityItem<IRequest>(subRequest.Priority, subRequest));
+            }
+            else
+            {
+                subRequest.Dispose();
+                if (subRequest.SubsequentRequest != null)
+                    await SubsequentRequest(subRequest.SubsequentRequest);
+            }
+        }
+
         /// <summary>
         /// Sets the priority for the <see cref="RequestContainer{TRequest}"/>.
         /// Not to the contained <see cref="IRequest"/> objects.
@@ -313,7 +354,7 @@ public void UpdateAutoParallelism()
         public bool TrySetIdle()
         {
             Pause();
-            var requests = _requestsChannel.ToArray();
+            PriorityItem<IRequest>[] requests = _requestsChannel.ToArray();
             foreach (PriorityItem<IRequest> priorityItem in requests)
                 _ = priorityItem.Item.TrySetIdle();
             return requests.All(x => x.Item.State == RequestState.Idle);
@@ -339,7 +380,7 @@ public void Dispose()
         /// <returns>A string that represents the current state of the <see cref="RequestHandler"/>.</returns>
         public override string ToString()
         {
-            var sb = new StringBuilder();
+            StringBuilder sb = new();
 
             sb.AppendLine("RequestHandler State:");
             sb.AppendLine($"  Disposed: {_disposed}");
@@ -369,21 +410,25 @@ public void Remove(params IRequest[] requests)
             if (requests == null || requests.Length == 0)
                 throw new ArgumentNullException(nameof(requests), "Requests cannot be null or empty.");
 
-            foreach (var request in requests)
+            foreach (IRequest request in requests)
                 if (!_requestsChannel.TryRemove(new(request.Priority, request)))
                     throw new InvalidOperationException($"Failed to remove request: {request}");
         }
 
         /// <summary>
-        /// Returns an enumerator that iterates through the collection of requests. 
-        /// Blocks the Handler for a amout of time.
+        /// Returns an enumerator that iterates through the collection of requests.
+        /// <remarks>
+        /// <strong>Warning:</strong> This operation may block the handler for a period of time.
+        /// </remarks>
         /// </summary>
-        /// <returns>An enumerator that can be used to iterate through the collection.</returns>
+        /// <returns>An enumerator that can be used to iterate through the collection of requests.</returns>
         public IEnumerator<IRequest> GetEnumerator() => _requestsChannel.ToArray().Select(pair => pair.Item).GetEnumerator();
 
         /// <summary>
-        /// Returns an enumerator that iterates through a collection.
-        /// Blocks the Handler for a amout of time.
+        /// Returns an enumerator that iterates through the collection of requests.
+        /// <remarks>
+        /// <strong>Warning:</strong> This operation may block the handler for a period of time.
+        /// </remarks>
         /// </summary>
         /// <returns>An <see cref="System.Collections.IEnumerator"/> object that can be used to iterate through the collection.</returns>
         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();

Requests/Requests.csproj

@@ -16,14 +16,12 @@
     <PackageTags>async; channel; priority; request; parallel; </PackageTags>
     <RepositoryUrl>https://github.com/TypNull/Requests</RepositoryUrl>
     <PackageIcon>logo.png</PackageIcon>
-    <Version>2.1.6</Version>
+    <Version>2.2.0</Version>
     <PackageRequireLicenseAcceptance>True</PackageRequireLicenseAcceptance>
     <PackageLicenseFile>LICENSE.txt</PackageLicenseFile>
     <PackageId>Shard.Requests</PackageId>
-    <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>
+    <PackageReleaseNotes>Implement SubsequentRequest
+Fix RequestContainer GetRequests issue</PackageReleaseNotes>
   </PropertyGroup>
 
   <ItemGroup>