Improve performance

Author: Kahbazi

src/Middleware/ConcurrencyLimiter/src/QueuePolicies/QueuePolicy.cs

@@ -10,49 +10,49 @@ namespace Microsoft.AspNetCore.ConcurrencyLimiter
 {
     internal class QueuePolicy : IQueuePolicy, IDisposable
     {
-        private readonly int _maxConcurrentRequests;
-        private readonly int _requestQueueLimit;
+        private readonly int _maxTotalRequest;
         private readonly SemaphoreSlim _serverSemaphore;
 
         private object _totalRequestsLock = new object();
+
+        private readonly static ValueTask<bool> _falseValueTask = new ValueTask<bool>(false);
+
         public int TotalRequests { get; private set; }
 
         public QueuePolicy(IOptions<QueuePolicyOptions> options)
         {
-            _maxConcurrentRequests = options.Value.MaxConcurrentRequests;
-            if (_maxConcurrentRequests <= 0)
+            if (options.Value.MaxConcurrentRequests <= 0)
             {
-                throw new ArgumentException(nameof(_maxConcurrentRequests), "MaxConcurrentRequests must be a positive integer.");
+                throw new ArgumentException(nameof(options.Value.MaxConcurrentRequests), "MaxConcurrentRequests must be a positive integer.");
             }
 
-            _requestQueueLimit = options.Value.RequestQueueLimit;
-            if (_requestQueueLimit < 0)
+            if (options.Value.RequestQueueLimit < 0)
             {
-                throw new ArgumentException(nameof(_requestQueueLimit), "The RequestQueueLimit cannot be a negative number.");
+                throw new ArgumentException(nameof(options.Value.RequestQueueLimit), "The RequestQueueLimit cannot be a negative number.");
             }
 
-            _serverSemaphore = new SemaphoreSlim(_maxConcurrentRequests);
+            _serverSemaphore = new SemaphoreSlim(options.Value.MaxConcurrentRequests);
+
+            _maxTotalRequest = options.Value.MaxConcurrentRequests + options.Value.RequestQueueLimit;
         }
 
-        public async ValueTask<bool> TryEnterAsync()
+        public ValueTask<bool> TryEnterAsync()
         {
             // a return value of 'false' indicates that the request is rejected
             // a return value of 'true' indicates that the request may proceed
             // _serverSemaphore.Release is *not* called in this method, it is called externally when requests leave the server
 
             lock (_totalRequestsLock)
             {
-                if (TotalRequests >= _requestQueueLimit + _maxConcurrentRequests)
+                if (TotalRequests >= _maxTotalRequest)
                 {
-                    return false;
+                    return _falseValueTask;
                 }
 
                 TotalRequests++;
             }
 
-            await _serverSemaphore.WaitAsync();
-
-            return true;
+            return AwaitSemaphore();
         }
 
         public void OnExit()
@@ -69,5 +69,12 @@ public void Dispose()
         {
             _serverSemaphore.Dispose();
         }
+
+        private async ValueTask<bool> AwaitSemaphore()
+        {
+            await _serverSemaphore.WaitAsync();
+
+            return true;
+        }
     }
 }