tried to fix the issue cannot receive on unity3d

kerryjiang · Aug 31, 2024 · f2e549d · f2e549d
1 parent 32311c5
commit f2e549d
Show file tree

Hide file tree

Showing 3 changed files with 37 additions and 13 deletions.
diff --git 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
@@ -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
@@ -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;
             }