wip: 重构实现方法（未完成）

Author: ArgoZhang

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

@@ -0,0 +1,181 @@
+// Copyright (c) Argo Zhang (argo@163.com). All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+// Website: https://www.blazor.zone or https://argozhang.github.io/
+
+using Microsoft.Extensions.Logging;
+using System.Buffers;
+using System.Net;
+using TouchSocket.Core;
+using TouchSocket.Sockets;
+
+namespace BootstrapBlazor.Components;
+
+sealed class DefaultTcpSocketClient(IPEndPoint endPoint) : ITcpSocketClient
+{
+    private TcpClient? _client;
+    private IDataPackageHandler? _dataPackageHandler;
+    private CancellationTokenSource? _receiveCancellationTokenSource;
+    private IPEndPoint? _remoteEndPoint;
+
+    public bool IsConnected => _client?.Online ?? false;
+
+    public IPEndPoint LocalEndPoint { get; set; } = endPoint;
+
+    [NotNull]
+    public ILogger<DefaultTcpSocketClient>? Logger { get; set; }
+
+    public int ReceiveBufferSize { get; set; } = 1024 * 10;
+
+    public Func<ReadOnlyMemory<byte>, ValueTask>? ReceivedCallBack { get; set; }
+
+    public void SetDataHandler(IDataPackageHandler handler)
+    {
+        _dataPackageHandler = handler;
+    }
+
+    public async ValueTask<bool> ConnectAsync(IPEndPoint endPoint, CancellationToken token = default)
+    {
+        var ret = false;
+        try
+        {
+            // 释放资源
+            Close();
+
+            // 创建新的 TouchSocket TcpClient 实例
+            _client ??= new TcpClient();
+            await _client.SetupAsync(new TouchSocketConfig().SetBindIPHost(new IPHost(LocalEndPoint.Address, LocalEndPoint.Port)));
+
+            await _client.ConnectAsync(new IPHost(endPoint.Address, endPoint.Port), );
+
+            // 开始接收数据
+            //_ = Task.Run(ReceiveAsync, token);
+
+            //LocalEndPoint = (IPEndPoint)_client.Client.LocalEndPoint!;
+            _remoteEndPoint = endPoint;
+            ret = true;
+        }
+        catch (OperationCanceledException ex)
+        {
+            Logger.LogWarning(ex, "TCP Socket connect operation was canceled from {LocalEndPoint} to {RemoteEndPoint}", LocalEndPoint, endPoint);
+        }
+        catch (Exception ex)
+        {
+            Logger.LogError(ex, "TCP Socket connection failed from {LocalEndPoint} to {RemoteEndPoint}", LocalEndPoint, endPoint);
+        }
+        return ret;
+    }
+
+    public async ValueTask<bool> SendAsync(ReadOnlyMemory<byte> data, CancellationToken token = default)
+    {
+        if (_client is not { Online: true })
+        {
+            throw new InvalidOperationException($"TCP Socket is not connected {LocalEndPoint}");
+        }
+
+        var ret = false;
+        try
+        {
+            if (_dataPackageHandler != null)
+            {
+                data = await _dataPackageHandler.SendAsync(data);
+            }
+            //var stream = _client.GetStream();
+            //await stream.WriteAsync(data, token);
+            ret = true;
+        }
+        catch (OperationCanceledException ex)
+        {
+            Logger.LogWarning(ex, "TCP Socket send operation was canceled from {LocalEndPoint} to {RemoteEndPoint}", LocalEndPoint, _remoteEndPoint);
+        }
+        catch (Exception ex)
+        {
+            Logger.LogError(ex, "TCP Socket send failed from {LocalEndPoint} to {RemoteEndPoint}", LocalEndPoint, _remoteEndPoint);
+        }
+        return ret;
+    }
+
+    private async ValueTask ReceiveAsync()
+    {
+        _receiveCancellationTokenSource ??= new();
+        while (_receiveCancellationTokenSource is { IsCancellationRequested: false })
+        {
+            if (_client is not { Online: true })
+            {
+                throw new InvalidOperationException($"TCP Socket is not connected {LocalEndPoint}");
+            }
+
+            try
+            {
+                using var block = MemoryPool<byte>.Shared.Rent(ReceiveBufferSize);
+                var buffer = block.Memory;
+                //var stream = _client.GetStream();
+                //var len = await stream.ReadAsync(buffer, _receiveCancellationTokenSource.Token);
+                //if (len == 0)
+                //{
+                //    // 远端主机关闭链路
+                //    Logger.LogInformation("TCP Socket {LocalEndPoint} received 0 data closed by {RemoteEndPoint}", LocalEndPoint, _remoteEndPoint);
+                //    break;
+                //}
+                //else
+                //{
+                //    buffer = buffer[..len];
+
+                //    if (ReceivedCallBack != null)
+                //    {
+                //        await ReceivedCallBack(buffer);
+                //    }
+
+                //    if (_dataPackageHandler != null)
+                //    {
+                //        await _dataPackageHandler.ReceiveAsync(buffer);
+                //    }
+                //}
+            }
+            catch (OperationCanceledException ex)
+            {
+                Logger.LogWarning(ex, "TCP Socket receive operation was canceled from {LocalEndPoint} to {RemoteEndPoint}", LocalEndPoint, _remoteEndPoint);
+            }
+            catch (Exception ex)
+            {
+                Logger.LogError(ex, "TCP Socket receive failed from {LocalEndPoint} to {RemoteEndPoint}", LocalEndPoint, _remoteEndPoint);
+            }
+        }
+    }
+
+    public void Close()
+    {
+        Dispose(true);
+    }
+
+    private void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            _remoteEndPoint = null;
+
+            // 取消接收数据的任务
+            if (_receiveCancellationTokenSource is not null)
+            {
+                _receiveCancellationTokenSource.Cancel();
+                _receiveCancellationTokenSource.Dispose();
+                _receiveCancellationTokenSource = null;
+            }
+
+            // 释放 TcpClient 资源
+            if (_client != null)
+            {
+                _client.CloseAsync();
+                _client = null;
+            }
+        }
+    }
+
+    /// <summary>
+    /// <inheritdoc/>
+    /// </summary>
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+}

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

@@ -5,26 +5,33 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using System.Collections.Concurrent;
+using System.Net;
+using System.Runtime.Versioning;
 
 namespace BootstrapBlazor.Components;
 
-class DefaultTcpSocketFactory : ITcpSocketFactory
+[UnsupportedOSPlatform("browser")]
+sealed class DefaultTcpSocketFactory(IServiceProvider provider) : ITcpSocketFactory
 {
     private readonly ConcurrentDictionary<string, ITcpSocketClient> _pool = new();
 
-    public ITcpSocketClient GetOrCreate(string host, int port = 0)
+    public ITcpSocketClient GetOrCreate(string name, Func<string, IPEndPoint> valueFactory)
     {
-        return _pool.GetOrAdd($"{host}:{port}", key =>
+        return _pool.GetOrAdd(name, key =>
         {
-            var client = new TouchSocketTcpClient();
+            var endPoint = valueFactory(key);
+            var client = new DefaultTcpSocketClient(endPoint)
+            {
+                Logger = provider.GetService<ILogger<DefaultTcpSocketClient>>()
+            };
             return client;
         });
     }
 
-    public ITcpSocketClient? Remove(string host, int port)
+    public ITcpSocketClient? Remove(string name)
     {
         ITcpSocketClient? client = null;
-        if (_pool.TryRemove($"{host}:{port}", out var c))
+        if (_pool.TryRemove(name, out var c))
         {
             client = c;
         }