From f2e549db68902d8b1bf870ae7a4a29112c9e9606 Mon Sep 17 00:00:00 2001
From: Kerry Jiang <kerry-jiang@hotmail.com>
Date: Fri, 30 Aug 2024 23:01:49 -0700
Subject: [PATCH] tried to fix the issue cannot receive on unity3d

---
 src/SuperSocket.Connection/PipeConnection.cs  |  4 +-
 .../TcpPipeConnection.cs                      |  5 ++-
 .../UdpPipeConnection.cs                      | 41 +++++++++++++++----
 3 files changed, 37 insertions(+), 13 deletions(-)

diff --git a/src/SuperSocket.Connection/PipeConnection.cs b/src/SuperSocket.Connection/PipeConnection.cs
index e6dc7823f..10550697c 100644
--- a/src/SuperSocket.Connection/PipeConnection.cs
+++ b/src/SuperSocket.Connection/PipeConnection.cs
@@ -183,9 +183,9 @@ protected async ValueTask<bool> ProcessOutputRead(PipeReader reader)
 
         protected abstract ValueTask<int> SendOverIOAsync(ReadOnlySequence<byte> buffer, CancellationToken cancellationToken);
 
-        protected internal ArraySegment<T> GetArrayByMemory<T>(ReadOnlyMemory<T> memory)
+        protected internal ArraySegment<byte> GetArrayByMemory(ReadOnlyMemory<byte> memory)
         {
-            if (!MemoryMarshal.TryGetArray(memory, out var result))
+            if (!MemoryMarshal.TryGetArray<byte>(memory, out var result))
             {
                 throw new InvalidOperationException("Buffer backed by array was expected");
             }
diff --git a/src/SuperSocket.Connection/TcpPipeConnection.cs b/src/SuperSocket.Connection/TcpPipeConnection.cs
index 5d22aadda..2bb406852 100644
--- a/src/SuperSocket.Connection/TcpPipeConnection.cs
+++ b/src/SuperSocket.Connection/TcpPipeConnection.cs
@@ -31,13 +31,14 @@ protected override void OnClosed()
 
         protected override async ValueTask<int> FillPipeWithDataAsync(Memory<byte> memory, CancellationToken cancellationToken)
         {
-            return await ReceiveAsync(_socket, memory, SocketFlags.None, cancellationToken);
+            return await ReceiveAsync(_socket, memory, SocketFlags.None, cancellationToken)
+                .ConfigureAwait(false);
         }
 
         private async ValueTask<int> ReceiveAsync(Socket socket, Memory<byte> memory, SocketFlags socketFlags, CancellationToken cancellationToken)
         {
             return await socket
-                .ReceiveAsync(GetArrayByMemory((ReadOnlyMemory<byte>)memory), socketFlags, cancellationToken)
+                .ReceiveAsync(GetArrayByMemory(memory), socketFlags, cancellationToken)
                 .ConfigureAwait(false);
         }
 
diff --git a/src/SuperSocket.Connection/UdpPipeConnection.cs b/src/SuperSocket.Connection/UdpPipeConnection.cs
index 56b242643..9bb84385c 100644
--- a/src/SuperSocket.Connection/UdpPipeConnection.cs
+++ b/src/SuperSocket.Connection/UdpPipeConnection.cs
@@ -50,7 +50,9 @@ protected override async ValueTask<int> SendOverIOAsync(ReadOnlySequence<byte> b
 
                 foreach (var piece in buffer)
                 {
-                    total += await _socket.SendToAsync(GetArrayByMemory<byte>(piece), SocketFlags.None, RemoteEndPoint);
+                    total += await _socket
+                        .SendToAsync(GetArrayByMemory(piece), SocketFlags.None, RemoteEndPoint)
+                        .ConfigureAwait(false);
                 }
 
                 return total;
@@ -62,7 +64,10 @@ protected override async ValueTask<int> SendOverIOAsync(ReadOnlySequence<byte> b
             try
             {                
                 MergeBuffer(ref buffer, destBuffer);
-                return await _socket.SendToAsync(new ArraySegment<byte>(destBuffer, 0, (int)buffer.Length), SocketFlags.None, RemoteEndPoint);       
+
+                return await _socket
+                    .SendToAsync(new ArraySegment<byte>(destBuffer, 0, (int)buffer.Length), SocketFlags.None, RemoteEndPoint)
+                    .ConfigureAwait(false);
             }
             finally
             {
@@ -96,28 +101,43 @@ public override async ValueTask SendAsync(ReadOnlyMemory<byte> buffer, Cancellat
         {
             if (_enableSendingPipe)
             {
-                await base.SendAsync(buffer, cancellationToken);
+                await base
+                    .SendAsync(buffer, cancellationToken)
+                    .ConfigureAwait(false);
                 return;
             }
 
-            await SendOverIOAsync(new ReadOnlySequence<byte>(buffer), cancellationToken);
+            await SendOverIOAsync(new ReadOnlySequence<byte>(buffer), cancellationToken)
+                .ConfigureAwait(false);
         }
         
         public override async ValueTask SendAsync<TPackage>(IPackageEncoder<TPackage> packageEncoder, TPackage package, CancellationToken cancellationToken)
         {
             if (_enableSendingPipe)
             {
-                await base.SendAsync(packageEncoder, package, cancellationToken);
+                await base
+                    .SendAsync(packageEncoder, package, cancellationToken)
+                    .ConfigureAwait(false);
+
                 return;
             }
 
             try
             {
-                await SendLock.WaitAsync(cancellationToken);
+                await SendLock
+                    .WaitAsync(cancellationToken)
+                    .ConfigureAwait(false);
+
                 var writer = OutputWriter;
+
                 WritePackageWithEncoder<TPackage>(writer, packageEncoder, package);
-                await writer.FlushAsync(cancellationToken);
-                await ProcessOutputRead(Output.Reader);
+
+                await writer
+                    .FlushAsync(cancellationToken)
+                    .ConfigureAwait(false);
+
+                await ProcessOutputRead(Output.Reader)
+                    .ConfigureAwait(false);
             }
             finally
             {
@@ -129,7 +149,10 @@ public override async ValueTask SendAsync(Action<PipeWriter> write, Cancellation
         {
             if (_enableSendingPipe)
             {
-                await base.SendAsync(write, cancellationToken);
+                await base
+                    .SendAsync(write, cancellationToken)
+                    .ConfigureAwait(false);
+                    
                 return;
             }