重构(tcp): 更新TouchSocket版本并优化连接逻辑

在 `BootstrapBlazor.TouchSocket.csproj` 文件中，将 `TouchSocket` 的版本从 `3.1.11.8` 更新为 `4.0.0-Alpha.10`。
在 `DefaultTcpSocketProvider.cs` 文件中，类的访问修饰符从 `sealed` 改为 `internal`，并添加了对 `System.Diagnostics` 的引用。
修改 `IsConnected` 属性的实现，确保调用基类的 `Online` 属性。
添加新的 `CloseAsync` 方法，重写连接逻辑以包含异常处理，并在连接成功后进行调试断言。
更新 `ReceiveAsync` 方法的数据读取逻辑，使用基类的 `Transport.Input` 进行数据读取，并确保正确处理数据缓冲区。
重写 `SendAsync` 方法，添加对取消令牌的处理，并确保在发送数据时正确管理锁。
重写 `ReceiveLoopAsync` 方法，注释说明新的接收循环逻辑，确保数据通过管道直接读取，而不进行额外的数据读取操作

Author: RRQM

src/extensions/BootstrapBlazor.TouchSocket/BootstrapBlazor.TouchSocket.csproj

@@ -14,7 +14,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="TouchSocket" Version="3.1.11.8" />
+    <PackageReference Include="TouchSocket" Version="4.0.0-Alpha.10" />
   </ItemGroup>
 
   <ItemGroup>

src/extensions/BootstrapBlazor.TouchSocket/Services/DefaultTcpSocketProvider.cs

@@ -3,27 +3,34 @@
 // Website: https://www.blazor.zone or https://argozhang.github.io/
 
 using System.Buffers;
+using System.Diagnostics;
 using System.IO.Pipelines;
 using System.Net;
 using TouchSocket.Core;
 using TouchSocket.Sockets;
 
 namespace BootstrapBlazor.Components;
 
-sealed class DefaultTcpSocketProvider : TcpClientBase, ISocketClientProvider
+internal sealed class DefaultTcpSocketProvider : TcpClientBase, ISocketClientProvider
 {
-    private readonly Pipe _pipe = new();
-
     /// <summary>
     /// <inheritdoc/>
     /// </summary>
-    public bool IsConnected => Online;
+    public bool IsConnected => base.Online;
 
     /// <summary>
     /// <inheritdoc/>
     /// </summary>
     public IPEndPoint LocalEndPoint { get; set; } = new IPEndPoint(IPAddress.Any, 0);
 
+    /// <summary>
+    /// <inheritdoc/>
+    /// </summary>
+    public async ValueTask CloseAsync()
+    {
+        await base.CloseAsync(string.Empty);
+    }
+
     /// <summary>
     /// <inheritdoc/>
     /// </summary>
@@ -32,53 +39,85 @@ public async ValueTask<bool> ConnectAsync(IPEndPoint endPoint, CancellationToken
         await SetupAsync(new TouchSocketConfig()
             .SetBindIPHost(new IPHost(LocalEndPoint.Address, LocalEndPoint.Port))
             .SetRemoteIPHost(new IPHost(endPoint.Address, endPoint.Port)));
-        await TcpConnectAsync(int.MaxValue, token);
-        if (Online)
+
+        try
         {
+            await TcpConnectAsync(int.MaxValue, token);
+            Debug.Assert(MainSocket != null, "MainSocket cannot be null after connection.");
+            Debug.Assert(base.Online, "Online should be true after successful connection.");
             if (MainSocket.LocalEndPoint is IPEndPoint localEndPoint)
             {
                 LocalEndPoint = localEndPoint;
             }
+            return true;
+        }
+        catch (Exception ex)
+        {
+            this.Logger?.Exception(this, ex);
+            return false;
         }
-        return Online;
-    }
-
-    /// <summary>
-    /// <inheritdoc/>
-    /// </summary>
-    public async ValueTask<bool> SendAsync(ReadOnlyMemory<byte> data, CancellationToken token = default)
-    {
-        await ProtectedDefaultSendAsync(data, token);
-        return true;
     }
 
     /// <summary>
     /// <inheritdoc/>
     /// </summary>
     public async ValueTask<int> ReceiveAsync(Memory<byte> buffer, CancellationToken token = default)
     {
-        var result = await _pipe.Reader.ReadAsync(token);
+        token.ThrowIfCancellationRequested();
+        this.ThrowIfTcpClientNotConnected();
+        this.ThrowIfDisposed();
+
+        var result = await base.Transport.Input.ReadAsync(token);
         if (result.IsCompleted)
         {
             return 0;
         }
+        var length = (int)Math.Min(result.Buffer.Length, buffer.Length);
 
-        result.Buffer.CopyTo(buffer.Span);
-        return (int)result.Buffer.Length;
-    }
+        var sequence = result.Buffer.Slice(0, length);
 
-    protected override async ValueTask<bool> OnTcpReceiving(ByteBlock byteBlock)
-    {
-        await _pipe.Writer.WriteAsync(byteBlock.Memory);
-        await _pipe.Writer.FlushAsync();
-        return true;
+        sequence.CopyTo(buffer.Span);
+        base.Transport.Input.AdvanceTo(sequence.End);
+        return length;
     }
 
     /// <summary>
     /// <inheritdoc/>
     /// </summary>
-    public async ValueTask CloseAsync()
+    public async ValueTask<bool> SendAsync(ReadOnlyMemory<byte> data, CancellationToken token = default)
+    {
+        token.ThrowIfCancellationRequested();
+        base.ThrowIfTcpClientNotConnected();
+        base.ThrowIfDisposed();
+        var pipeWriter = base.Transport.Output;
+        var locker = base.Transport.SemaphoreSlimForWriter;
+        await locker.WaitAsync(token);
+        try
+        {
+            pipeWriter.Write(data.Span);
+            var result = await pipeWriter.FlushAsync(token);
+            if (result.IsCanceled || result.IsCompleted)
+            {
+                return false;
+            }
+            return true;
+        }
+        catch (Exception ex)
+        {
+            this.Logger?.Exception(this, ex);
+            return false;
+        }
+        finally
+        {
+            locker.Release();
+        }
+    }
+
+    protected override sealed async Task ReceiveLoopAsync(ITransport transport)
     {
-        await CloseAsync(string.Empty);
+        //重写接收循环方法
+        //此处不做任何数据读取
+        //让数据直接到ReceiveAsync使用管道直接读取数据
+        await Task.Delay(-1, transport.ClosedToken);
     }
 }