[Server] Make EndpointIncomingRequest a ReadonlyStruct & pool ValueTaks (#3363)

romanett · web-flow · commit 4459e70d98b7 · 2025-12-02T09:57:28.000+01:00
* Make EndpointIncomingRequest a readonly struct
* Switch to ValueTask &amp; pool ValueTasks using ValueTaskSource
diff --git a/Stack/Opc.Ua.Core/Stack/Server/EndpointBase.cs b/Stack/Opc.Ua.Core/Stack/Server/EndpointBase.cs
@@ -13,6 +13,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Security.Cryptography.X509Certificates;
 using System.Threading;
 using System.Threading.Tasks;
@@ -76,7 +77,7 @@ protected EndpointBase(ServerBase server)
         }
 
         /// <inheritdoc/>
-        public Task<IServiceResponse> ProcessRequestAsync(
+        public ValueTask<IServiceResponse> ProcessRequestAsync(
             SecureChannelContext secureChannelContext,
             IServiceRequest request,
             CancellationToken cancellationToken = default)
@@ -670,7 +671,7 @@ public IServiceResponse Invoke(IServiceRequest request, SecureChannelContext sec
                 {
                     logger.LogWarning(
                         "Async Service invoced sychronously. Prefer using InvokeAsync for best performance.");
-                    return InvokeAsync(request, null).GetAwaiter().GetResult();
+                    return InvokeAsync(request, secureChannelContext).GetAwaiter().GetResult();
                 }
                 return m_invokeService?.Invoke(request, secureChannelContext);
             }
@@ -777,7 +778,7 @@ public void CallSynchronously()
             /// thread that calls IServerBase.ScheduleIncomingRequest().
             /// This method always traps any exceptions and reports them to the client as a fault.
             /// </remarks>
-            public async Task CallAsync(CancellationToken cancellationToken = default)
+            public async ValueTask CallAsync(CancellationToken cancellationToken = default)
             {
                 await OnProcessRequestAsync(null, cancellationToken).ConfigureAwait(false);
             }
@@ -1042,7 +1043,7 @@ .Body is AdditionalParametersType parameters &&
                         else
                         {
                             // call the service even when there is no trace information
-                            m_response = await m_service.InvokeAsync(Request,SecureChannelContext, cancellationToken)
+                            m_response = await m_service.InvokeAsync(Request, SecureChannelContext, cancellationToken)
                                 .ConfigureAwait(false);
                         }
                     }
@@ -1074,26 +1075,25 @@ .Body is AdditionalParametersType parameters &&
         /// <summary>
         /// An object that handles an incoming request for an endpoint.
         /// </summary>
-        protected class EndpointIncomingRequest : IEndpointIncomingRequest
+        protected readonly struct EndpointIncomingRequest : IEndpointIncomingRequest, IEquatable<EndpointIncomingRequest>
         {
             /// <summary>
             /// Initialize the Object with a Request
             /// </summary>
             public EndpointIncomingRequest(
                 EndpointBase endpoint,
                 SecureChannelContext context,
-                IServiceRequest request)
+                IServiceRequest request,
+                CancellationToken cancellationToken = default)
             {
                 m_endpoint = endpoint;
                 SecureChannelContext = context;
                 Request = request;
-                m_tcs = new TaskCompletionSource<IServiceResponse>(
-                    TaskCreationOptions.RunContinuationsAsynchronously);
+                m_vts = ServiceResponsePooledValueTaskSource.Create();
+                m_service = m_endpoint.FindService(Request.TypeId);
+                m_cancellationToken = cancellationToken;
             }
 
-            /// <inheritdoc/>
-            public object Calldata { get; set; }
-
             /// <inheritdoc/>
             public SecureChannelContext SecureChannelContext { get; }
 
@@ -1104,25 +1104,22 @@ public EndpointIncomingRequest(
             /// Process an incoming request
             /// </summary>
             /// <returns></returns>
-            public Task<IServiceResponse> ProcessAsync(CancellationToken cancellationToken = default)
+            public ValueTask<IServiceResponse> ProcessAsync(CancellationToken cancellationToken = default)
             {
                 try
                 {
-                    m_cancellationToken = cancellationToken;
-                    m_cancellationToken.Register(() => m_tcs.TrySetCanceled());
-                    m_service = m_endpoint.FindService(Request.TypeId);
-                    m_endpoint.ServerForContext.ScheduleIncomingRequest(this, m_cancellationToken);
+                    m_endpoint.ServerForContext.ScheduleIncomingRequest(this, cancellationToken);
                 }
                 catch (Exception e)
                 {
-                    m_tcs.TrySetResult(m_endpoint.CreateFault(Request, e));
+                    m_vts.SetResult(m_endpoint.CreateFault(Request, e));
                 }
 
-                return m_tcs.Task;
+                return m_vts.Task;
             }
 
             /// <inheritdoc/>
-            public async Task CallAsync(CancellationToken cancellationToken = default)
+            public async ValueTask CallAsync(CancellationToken cancellationToken = default)
             {
                 using CancellationTokenSource timeoutHintCts = (int)Request.RequestHeader.TimeoutHint > 0 ?
                     new CancellationTokenSource((int)Request.RequestHeader.TimeoutHint) : null;
@@ -1157,7 +1154,7 @@ .Body is AdditionalParametersType parameters &&
                     using (activity)
                     {
                         IServiceResponse response = await m_service.InvokeAsync(Request, SecureChannelContext, linkedCts.Token).ConfigureAwait(false);
-                        m_tcs.TrySetResult(response);
+                        m_vts.SetResult(response);
                     }
                 }
                 catch (Exception e)
@@ -1166,8 +1163,7 @@ .Body is AdditionalParametersType parameters &&
                     {
                         e = new ServiceResultException(StatusCodes.BadTimeout);
                     }
-
-                    m_tcs.TrySetResult(m_endpoint.CreateFault(Request, e));
+                    m_vts.SetResult(m_endpoint.CreateFault(Request, e));
                 }
             }
 
@@ -1176,18 +1172,52 @@ public void OperationCompleted(IServiceResponse response, ServiceResult error)
             {
                 if (ServiceResult.IsBad(error))
                 {
-                    m_tcs.TrySetResult(m_endpoint.CreateFault(Request, new ServiceResultException(error)));
+                    m_vts.SetResult(m_endpoint.CreateFault(Request, new ServiceResultException(error)));
                 }
                 else
                 {
-                    m_tcs.TrySetResult(response);
+                    m_vts.SetResult(response);
                 }
             }
 
+            /// <inheritdoc/>
+            public override bool Equals(object obj)
+            {
+                if (obj is EndpointIncomingRequest other)
+                {
+                    return Request.RequestHeader.Equals(other.Request.RequestHeader);
+                }
+                return false;
+            }
+
+            /// <inheritdoc/>
+            public override int GetHashCode()
+            {
+                return Request.RequestHeader.GetHashCode();
+            }
+
+            /// <inheritdoc/>
+            public static bool operator ==(EndpointIncomingRequest left, EndpointIncomingRequest right)
+            {
+                return left.Equals(right);
+            }
+
+            /// <inheritdoc/>
+            public static bool operator !=(EndpointIncomingRequest left, EndpointIncomingRequest right)
+            {
+                return !(left == right);
+            }
+
+            /// <inheritdoc/>
+            public bool Equals(EndpointIncomingRequest other)
+            {
+                return Request.RequestHeader.Equals(other.Request.RequestHeader);
+            }
+
             private readonly EndpointBase m_endpoint;
-            private CancellationToken m_cancellationToken;
-            private ServiceDefinition m_service;
-            private readonly TaskCompletionSource<IServiceResponse> m_tcs;
+            private readonly ServiceDefinition m_service;
+            private readonly ServiceResponsePooledValueTaskSource m_vts;
+            private readonly CancellationToken m_cancellationToken;
         }
 
         /// <summary>
diff --git a/Stack/Opc.Ua.Core/Stack/Server/IServerBase.cs b/Stack/Opc.Ua.Core/Stack/Server/IServerBase.cs
@@ -105,12 +105,6 @@ public interface IEndpointIncomingRequest
         /// <value>The secure channel context.</value>
         SecureChannelContext SecureChannelContext { get; }
 
-        /// <summary>
-        /// Gets or sets the call data associated with the request.
-        /// </summary>
-        /// <value>The call data.</value>
-        object Calldata { get; set; }
-
         /// <summary>
         /// Used to call the default asynchronous handler.
         /// </summary>
@@ -119,7 +113,7 @@ public interface IEndpointIncomingRequest
         /// thread that calls IServerBase.ScheduleIncomingRequest().
         /// This method always traps any exceptions and reports them to the client as a fault.
         /// </remarks>
-        Task CallAsync(CancellationToken cancellationToken = default);
+        ValueTask CallAsync(CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Used to indicate that the asynchronous operation has completed.
diff --git a/Stack/Opc.Ua.Core/Stack/Server/ServerBase.cs b/Stack/Opc.Ua.Core/Stack/Server/ServerBase.cs
@@ -1611,7 +1611,7 @@ protected virtual void Dispose(bool disposing)
 
                     foreach (IEndpointIncomingRequest request in m_queue.ToList())
                     {
-                        Utils.SilentDispose(request);
+                        request.OperationCompleted(null, StatusCodes.BadServerHalted);
                     }
 #if NETSTANDARD2_1_OR_GREATER
                     m_queue.Clear();
diff --git a/Stack/Opc.Ua.Core/Stack/Transport/ITransportListenerCallback.cs b/Stack/Opc.Ua.Core/Stack/Transport/ITransportListenerCallback.cs
@@ -28,7 +28,7 @@ public interface ITransportListenerCallback : IAuditEventCallback
         /// <param name="request">The incoming request.</param>
         /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>The response to return over the secure channel.</returns>
-        Task<IServiceResponse> ProcessRequestAsync(
+        ValueTask<IServiceResponse> ProcessRequestAsync(
             SecureChannelContext secureChannelContext,
             IServiceRequest request,
             CancellationToken cancellationToken = default);
diff --git a/Stack/Opc.Ua.Core/Types/Utils/ValueTask/ManualResetValueTaskSource.cs b/Stack/Opc.Ua.Core/Types/Utils/ValueTask/ManualResetValueTaskSource.cs
@@ -0,0 +1,73 @@
+/* Copyright (c) 1996-2022 The OPC Foundation. All rights reserved.
+   The source code in this file is covered under a dual-license scenario:
+     - RCL: for OPC Foundation Corporate Members in good-standing
+     - GPL V2: everybody else
+   RCL license terms accompanied with this source code. See http://opcfoundation.org/License/RCL/1.00/
+   GNU General Public License as published by the Free Software Foundation;
+   version 2 of the License are accompanied with this source code. See http://opcfoundation.org/License/GPLv2
+   This source code is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+*/
+
+using System;
+using System.Threading.Tasks;
+using System.Threading.Tasks.Sources;
+
+namespace Opc.Ua
+{
+    /// <summary>
+    /// A reusable value task source.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    internal class ManualResetValueTaskSource<T> : IValueTaskSource<T>, IValueTaskSource
+    {
+        private ManualResetValueTaskSourceCore<T> m_core;
+
+        public bool RunContinuationsAsynchronously
+        {
+            get => m_core.RunContinuationsAsynchronously;
+            set => m_core.RunContinuationsAsynchronously = value;
+        }
+
+        public short Version => m_core.Version;
+
+        public void Reset()
+        {
+            m_core.Reset();
+        }
+
+        public void SetResult(T result)
+        {
+            m_core.SetResult(result);
+        }
+
+        public void SetException(Exception error)
+        {
+            m_core.SetException(error);
+        }
+
+        public T GetResult(short token)
+        {
+            return m_core.GetResult(token);
+        }
+
+        void IValueTaskSource.GetResult(short token)
+        {
+            m_core.GetResult(token);
+        }
+
+        public ValueTaskSourceStatus GetStatus(short token)
+        {
+            return m_core.GetStatus(token);
+        }
+
+        public void OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
+        {
+            m_core.OnCompleted(continuation, state, token, flags);
+        }
+
+        public ValueTask<T> Task => new(this, m_core.Version);
+        public ValueTask SourceTask => new(this, m_core.Version);
+    }
+}
diff --git a/Stack/Opc.Ua.Core/Types/Utils/ValueTask/ObjectPool.cs b/Stack/Opc.Ua.Core/Types/Utils/ValueTask/ObjectPool.cs
@@ -0,0 +1,66 @@
+/* Copyright (c) 1996-2022 The OPC Foundation. All rights reserved.
+   The source code in this file is covered under a dual-license scenario:
+     - RCL: for OPC Foundation Corporate Members in good-standing
+     - GPL V2: everybody else
+   RCL license terms accompanied with this source code. See http://opcfoundation.org/License/RCL/1.00/
+   GNU General Public License as published by the Free Software Foundation;
+   version 2 of the License are accompanied with this source code. See http://opcfoundation.org/License/GPLv2
+   This source code is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+*/
+
+using System;
+using System.Collections.Concurrent;
+
+namespace Opc.Ua
+{
+    /// <summary>
+    /// A simple object pool implementation.
+    /// </summary>
+    /// <typeparam name="T">The type of object to pool.</typeparam>
+    internal class ObjectPool<T> where T : class
+    {
+        private readonly ConcurrentBag<T> m_objects;
+        private readonly Func<T> m_objectGenerator;
+        private readonly int m_maxSize;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ObjectPool{T}"/> class.
+        /// </summary>
+        /// <param name="objectGenerator">The function to generate new objects.</param>
+        /// <param name="maxSize">The maximum size of the pool.</param>
+        public ObjectPool(Func<T> objectGenerator, int maxSize)
+        {
+            m_objectGenerator = objectGenerator ?? throw new ArgumentNullException(nameof(objectGenerator));
+            m_maxSize = maxSize > 0 ? maxSize : throw new ArgumentOutOfRangeException(nameof(maxSize));
+            m_objects = new ConcurrentBag<T>();
+        }
+
+        /// <summary>
+        /// Gets an object from the pool.
+        /// </summary>
+        /// <returns>An object from the pool or a new one if the pool is empty.</returns>
+        public T Get()
+        {
+            if (m_objects.TryTake(out T item))
+            {
+                return item;
+            }
+
+            return m_objectGenerator();
+        }
+
+        /// <summary>
+        /// Returns an object to the pool.
+        /// </summary>
+        /// <param name="item">The object to return.</param>
+        public void Return(T item)
+        {
+            if (m_objects.Count < m_maxSize)
+            {
+                m_objects.Add(item);
+            }
+        }
+    }
+}
diff --git a/Stack/Opc.Ua.Core/Types/Utils/ValueTask/ServiceResponsePooledValueTaskSource.cs b/Stack/Opc.Ua.Core/Types/Utils/ValueTask/ServiceResponsePooledValueTaskSource.cs
diff --git a/Tests/Opc.Ua.Client.Tests/LoadTest.cs b/Tests/Opc.Ua.Client.Tests/LoadTest.cs

Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.`
`13`	`13`	`using System;`
`14`	`14`	`using System.Collections.Generic;`
`15`	`15`	`using System.Diagnostics;`
	`16`	`+using System.Diagnostics.CodeAnalysis;`
`16`	`17`	`using System.Security.Cryptography.X509Certificates;`
`17`	`18`	`using System.Threading;`
`18`	`19`	`using System.Threading.Tasks;`
`@@ -76,7 +77,7 @@ protected EndpointBase(ServerBase server)`
`76`	`77`	`}`
`77`	`78`
`78`	`79`	`/// <inheritdoc/>`
`79`		`- public Task<IServiceResponse> ProcessRequestAsync(`
	`80`	`+ public ValueTask<IServiceResponse> ProcessRequestAsync(`
`80`	`81`	`SecureChannelContext secureChannelContext,`
`81`	`82`	`IServiceRequest request,`
`82`	`83`	`CancellationToken cancellationToken = default)`
`@@ -670,7 +671,7 @@ public IServiceResponse Invoke(IServiceRequest request, SecureChannelContext sec`
`670`	`671`	`{`
`671`	`672`	`logger.LogWarning(`
`672`	`673`	`"Async Service invoced sychronously. Prefer using InvokeAsync for best performance.");`
`673`		`- return InvokeAsync(request, null).GetAwaiter().GetResult();`
	`674`	`+ return InvokeAsync(request, secureChannelContext).GetAwaiter().GetResult();`
`674`	`675`	`}`
`675`	`676`	`return m_invokeService?.Invoke(request, secureChannelContext);`
`676`	`677`	`}`
`@@ -777,7 +778,7 @@ public void CallSynchronously()`
`777`	`778`	`/// thread that calls IServerBase.ScheduleIncomingRequest().`
`778`	`779`	`/// This method always traps any exceptions and reports them to the client as a fault.`
`779`	`780`	`/// </remarks>`
`780`		`- public async Task CallAsync(CancellationToken cancellationToken = default)`
	`781`	`+ public async ValueTask CallAsync(CancellationToken cancellationToken = default)`
`781`	`782`	`{`
`782`	`783`	`await OnProcessRequestAsync(null, cancellationToken).ConfigureAwait(false);`
`783`	`784`	`}`
`@@ -1042,7 +1043,7 @@ .Body is AdditionalParametersType parameters &&`
`1042`	`1043`	`else`
`1043`	`1044`	`{`
`1044`	`1045`	`// call the service even when there is no trace information`
`1045`		`- m_response = await m_service.InvokeAsync(Request,SecureChannelContext, cancellationToken)`
	`1046`	`+ m_response = await m_service.InvokeAsync(Request, SecureChannelContext, cancellationToken)`
`1046`	`1047`	`.ConfigureAwait(false);`
`1047`	`1048`	`}`
`1048`	`1049`	`}`
`@@ -1074,26 +1075,25 @@ .Body is AdditionalParametersType parameters &&`
`1074`	`1075`	`/// <summary>`
`1075`	`1076`	`/// An object that handles an incoming request for an endpoint.`
`1076`	`1077`	`/// </summary>`
`1077`		`- protected class EndpointIncomingRequest : IEndpointIncomingRequest`
	`1078`	`+ protected readonly struct EndpointIncomingRequest : IEndpointIncomingRequest, IEquatable<EndpointIncomingRequest>`
`1078`	`1079`	`{`
`1079`	`1080`	`/// <summary>`
`1080`	`1081`	`/// Initialize the Object with a Request`
`1081`	`1082`	`/// </summary>`
`1082`	`1083`	`public EndpointIncomingRequest(`
`1083`	`1084`	`EndpointBase endpoint,`
`1084`	`1085`	`SecureChannelContext context,`
`1085`		`- IServiceRequest request)`
	`1086`	`+ IServiceRequest request,`
	`1087`	`+ CancellationToken cancellationToken = default)`
`1086`	`1088`	`{`
`1087`	`1089`	`m_endpoint = endpoint;`
`1088`	`1090`	`SecureChannelContext = context;`
`1089`	`1091`	`Request = request;`
`1090`		`- m_tcs = new TaskCompletionSource<IServiceResponse>(`
`1091`		`- TaskCreationOptions.RunContinuationsAsynchronously);`
	`1092`	`+ m_vts = ServiceResponsePooledValueTaskSource.Create();`
	`1093`	`+ m_service = m_endpoint.FindService(Request.TypeId);`
	`1094`	`+ m_cancellationToken = cancellationToken;`
`1092`	`1095`	`}`
`1093`	`1096`
`1094`		`- /// <inheritdoc/>`
`1095`		`- public object Calldata { get; set; }`
`1096`		`-`
`1097`	`1097`	`/// <inheritdoc/>`
`1098`	`1098`	`public SecureChannelContext SecureChannelContext { get; }`
`1099`	`1099`
`@@ -1104,25 +1104,22 @@ public EndpointIncomingRequest(`
`1104`	`1104`	`/// Process an incoming request`
`1105`	`1105`	`/// </summary>`
`1106`	`1106`	`/// <returns></returns>`
`1107`		`- public Task<IServiceResponse> ProcessAsync(CancellationToken cancellationToken = default)`
	`1107`	`+ public ValueTask<IServiceResponse> ProcessAsync(CancellationToken cancellationToken = default)`
`1108`	`1108`	`{`
`1109`	`1109`	`try`
`1110`	`1110`	`{`
`1111`		`- m_cancellationToken = cancellationToken;`
`1112`		`- m_cancellationToken.Register(() => m_tcs.TrySetCanceled());`
`1113`		`- m_service = m_endpoint.FindService(Request.TypeId);`
`1114`		`- m_endpoint.ServerForContext.ScheduleIncomingRequest(this, m_cancellationToken);`
	`1111`	`+ m_endpoint.ServerForContext.ScheduleIncomingRequest(this, cancellationToken);`
`1115`	`1112`	`}`
`1116`	`1113`	`catch (Exception e)`
`1117`	`1114`	`{`
`1118`		`- m_tcs.TrySetResult(m_endpoint.CreateFault(Request, e));`
	`1115`	`+ m_vts.SetResult(m_endpoint.CreateFault(Request, e));`
`1119`	`1116`	`}`
`1120`	`1117`
`1121`		`- return m_tcs.Task;`
	`1118`	`+ return m_vts.Task;`
`1122`	`1119`	`}`
`1123`	`1120`
`1124`	`1121`	`/// <inheritdoc/>`
`1125`		`- public async Task CallAsync(CancellationToken cancellationToken = default)`
	`1122`	`+ public async ValueTask CallAsync(CancellationToken cancellationToken = default)`
`1126`	`1123`	`{`
`1127`	`1124`	`using CancellationTokenSource timeoutHintCts = (int)Request.RequestHeader.TimeoutHint > 0 ?`
`1128`	`1125`	`new CancellationTokenSource((int)Request.RequestHeader.TimeoutHint) : null;`
`@@ -1157,7 +1154,7 @@ .Body is AdditionalParametersType parameters &&`
`1157`	`1154`	`using (activity)`
`1158`	`1155`	`{`
`1159`	`1156`	`IServiceResponse response = await m_service.InvokeAsync(Request, SecureChannelContext, linkedCts.Token).ConfigureAwait(false);`
`1160`		`- m_tcs.TrySetResult(response);`
	`1157`	`+ m_vts.SetResult(response);`
`1161`	`1158`	`}`
`1162`	`1159`	`}`
`1163`	`1160`	`catch (Exception e)`
`@@ -1166,8 +1163,7 @@ .Body is AdditionalParametersType parameters &&`
`1166`	`1163`	`{`
`1167`	`1164`	`e = new ServiceResultException(StatusCodes.BadTimeout);`
`1168`	`1165`	`}`
`1169`		`-`
`1170`		`- m_tcs.TrySetResult(m_endpoint.CreateFault(Request, e));`
	`1166`	`+ m_vts.SetResult(m_endpoint.CreateFault(Request, e));`
`1171`	`1167`	`}`
`1172`	`1168`	`}`
`1173`	`1169`
`@@ -1176,18 +1172,52 @@ public void OperationCompleted(IServiceResponse response, ServiceResult error)`
`1176`	`1172`	`{`
`1177`	`1173`	`if (ServiceResult.IsBad(error))`
`1178`	`1174`	`{`
`1179`		`- m_tcs.TrySetResult(m_endpoint.CreateFault(Request, new ServiceResultException(error)));`
	`1175`	`+ m_vts.SetResult(m_endpoint.CreateFault(Request, new ServiceResultException(error)));`
`1180`	`1176`	`}`
`1181`	`1177`	`else`
`1182`	`1178`	`{`
`1183`		`- m_tcs.TrySetResult(response);`
	`1179`	`+ m_vts.SetResult(response);`
`1184`	`1180`	`}`
`1185`	`1181`	`}`
`1186`	`1182`
	`1183`	`+ /// <inheritdoc/>`
	`1184`	`+ public override bool Equals(object obj)`
	`1185`	`+ {`
	`1186`	`+ if (obj is EndpointIncomingRequest other)`
	`1187`	`+ {`
	`1188`	`+ return Request.RequestHeader.Equals(other.Request.RequestHeader);`
	`1189`	`+ }`
	`1190`	`+ return false;`
	`1191`	`+ }`
	`1192`	`+`
	`1193`	`+ /// <inheritdoc/>`
	`1194`	`+ public override int GetHashCode()`
	`1195`	`+ {`
	`1196`	`+ return Request.RequestHeader.GetHashCode();`
	`1197`	`+ }`
	`1198`	`+`
	`1199`	`+ /// <inheritdoc/>`
	`1200`	`+ public static bool operator ==(EndpointIncomingRequest left, EndpointIncomingRequest right)`
	`1201`	`+ {`
	`1202`	`+ return left.Equals(right);`
	`1203`	`+ }`
	`1204`	`+`
	`1205`	`+ /// <inheritdoc/>`
	`1206`	`+ public static bool operator !=(EndpointIncomingRequest left, EndpointIncomingRequest right)`
	`1207`	`+ {`
	`1208`	`+ return !(left == right);`
	`1209`	`+ }`
	`1210`	`+`
	`1211`	`+ /// <inheritdoc/>`
	`1212`	`+ public bool Equals(EndpointIncomingRequest other)`
	`1213`	`+ {`
	`1214`	`+ return Request.RequestHeader.Equals(other.Request.RequestHeader);`
	`1215`	`+ }`
	`1216`	`+`
`1187`	`1217`	`private readonly EndpointBase m_endpoint;`
`1188`		`- private CancellationToken m_cancellationToken;`
`1189`		`- private ServiceDefinition m_service;`
`1190`		`- private readonly TaskCompletionSource<IServiceResponse> m_tcs;`
	`1218`	`+ private readonly ServiceDefinition m_service;`
	`1219`	`+ private readonly ServiceResponsePooledValueTaskSource m_vts;`
	`1220`	`+ private readonly CancellationToken m_cancellationToken;`
`1191`	`1221`	`}`
`1192`	`1222`
`1193`	`1223`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -1611,7 +1611,7 @@ protected virtual void Dispose(bool disposing)`
`1611`	`1611`
`1612`	`1612`	`foreach (IEndpointIncomingRequest request in m_queue.ToList())`
`1613`	`1613`	`{`
`1614`		`- Utils.SilentDispose(request);`
	`1614`	`+ request.OperationCompleted(null, StatusCodes.BadServerHalted);`
`1615`	`1615`	`}`
`1616`	`1616`	`#if NETSTANDARD2_1_OR_GREATER`
`1617`	`1617`	`m_queue.Clear();`