// 同步方法
public string GetSyncData()
{
    // 模擬耗時操作（如文件讀取、網(wǎng)絡請求）
    Thread.Sleep(2000);
    return "同步數(shù)據(jù)";
}

// 異步方法（改造后）
public async Task<string> GetAsyncData()
{
    // 用Task.Delay替代Thread.Sleep（異步等待，不阻塞線程）
    await Task.Delay(2000);
    return "異步數(shù)據(jù)";
}

// 調(diào)用異步方法
public async Task CallAsyncMethod()
{
    Console.WriteLine("開始調(diào)用異步方法");
    string result = await GetAsyncData(); // 等待異步操作完成，不阻塞當前線程
    Console.WriteLine($"異步方法返回結果：{result}");
}

using System;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace AsyncTcpCommunication
{
    public class AsyncTcpClient : IDisposable
    {
        private TcpClient? _tcpClient;
        private NetworkStream? _networkStream;
        private CancellationTokenSource? _cts; // 用于取消異步接收循環(huán)

        // 連接狀態(tài)
        public bool IsConnected => _tcpClient?.Connected == true && _networkStream != null;

        /// <summary>
        /// 異步連接服務端
        /// </summary>
        public async Task<bool> ConnectAsync(string serverIp, int serverPort)
        {
            try
            {
                _cts = new CancellationTokenSource();
                _tcpClient = new TcpClient();

                // 異步連接：不阻塞當前線程，等待連接完成
                await _tcpClient.ConnectAsync(serverIp, serverPort);
                _networkStream = _tcpClient.GetStream();

                Console.WriteLine("成功連接到服務端");
                // 啟動異步接收循環(huán)（后臺持續(xù)監(jiān)聽數(shù)據(jù)，不阻塞主線程）
                _ = ReceiveDataLoopAsync(_cts.Token);

                return true;
            }
            catch (SocketException ex)
            {
                Console.WriteLine($"連接失敗：{ex.Message}");
                return false;
            }
        }

        /// <summary>
        /// 異步發(fā)送數(shù)據(jù)
        /// </summary>
        public async Task<bool> SendDataAsync(string message)
        {
            if (!IsConnected || string.IsNullOrEmpty(message))
                return false;

            try
            {
                byte[] sendData = Encoding.UTF8.GetBytes(message);
                // 異步寫入網(wǎng)絡流：不阻塞當前線程，等待數(shù)據(jù)發(fā)送完成
                await _networkStream!.WriteAsync(sendData, 0, sendData.Length);
                await _networkStream.FlushAsync(); // 異步刷新緩沖區(qū)

                Console.WriteLine($"成功發(fā)送數(shù)據(jù)：{message}");
                return true;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"發(fā)送數(shù)據(jù)失?。簕ex.Message}");
                return false;
            }
        }

        /// <summary>
        /// 異步接收數(shù)據(jù)循環(huán)（持續(xù)監(jiān)聽服務端數(shù)據(jù)）
        /// </summary>
        private async Task ReceiveDataLoopAsync(CancellationToken cancellationToken)
        {
            if (!IsConnected)
                return;

            byte[] buffer = new byte[1024]; // 接收緩沖區(qū)
            try
            {
                while (!cancellationToken.IsCancellationRequested && IsConnected)
                {
                    // 異步讀取網(wǎng)絡流：無數(shù)據(jù)時掛起，不阻塞線程，有數(shù)據(jù)時恢復執(zhí)行
                    int receivedBytes = await _networkStream!.ReadAsync(buffer, 0, buffer.Length, cancellationToken);

                    if (receivedBytes == 0)
                    {
                        Console.WriteLine("服務端主動關閉連接");
                        break;
                    }

                    // 解析接收到的數(shù)據(jù)
                    string receivedMessage = Encoding.UTF8.GetString(buffer, 0, receivedBytes);
                    Console.WriteLine($"接收到服務端數(shù)據(jù)：{receivedMessage}");
                }
            }
            catch (OperationCanceledException)
            {
                Console.WriteLine("接收循環(huán)已被取消");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"接收數(shù)據(jù)異常：{ex.Message}");
            }
        }

        /// <summary>
        /// 釋放資源
        /// </summary>
        public void Dispose()
        {
            _cts?.Cancel(); // 取消異步接收循環(huán)
            _networkStream?.Dispose();
            _tcpClient?.Dispose();
            Console.WriteLine("已斷開連接并釋放資源");
        }
    }

    // 調(diào)用示例
    class Program
    {
        static async Task Main(string[] args)
        {
            using var tcpClient = new AsyncTcpClient();

            // 異步連接（不阻塞Main線程）
            bool isConnected = await tcpClient.ConnectAsync("127.0.0.1", 8888);
            if (!isConnected)
                return;

            // 循環(huán)異步發(fā)送數(shù)據(jù)
            int sendCount = 0;
            while (tcpClient.IsConnected)
            {
                sendCount++;
                string message = $"異步通信測試 {sendCount} - {DateTime.Now:HH:mm:ss}";
                await tcpClient.SendDataAsync(message);

                // 異步等待3秒，不阻塞線程
                await Task.Delay(3000);
            }
        }
    }
}

try
{
    await tcpClient.ConnectAsync("127.0.0.1", 8888);
}
catch (SocketException ex)
{
    // 針對性處理Socket異常
    Console.WriteLine($"網(wǎng)絡連接異常：{ex.ErrorCode} - {ex.Message}");
}