在C#中实现异步通信的方法步骤

// 同步方法
public string GetSyncData()
{
    // 模拟耗时操作（如文件读取、网络请求）
    Thread.Sleep(2000);
    return "同步数据";
}

// 异步方法（改造后）
public async Task<string> GetAsyncData()
{
    // 用Task.Delay替代Thread.Sleep（异步等待，不阻塞线程）
    await Task.Delay(2000);
    return "异步数据";
}

// 调用异步方法
public async Task CallAsyncMethod()
{
    Console.WriteLine("开始调用异步方法");
    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; // 用于取消异步接收循环

        // 连接状态
        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("成功连接到服务端");
                // 启动异步接收循环（后台持续监听数据，不阻塞主线程）
                _ = ReceiveDataLoopAsync(_cts.Token);

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

        /// <summary>
        /// 异步发送数据
        /// </summary>
        public async Task<bool> SendDataAsync(string message)
        {
            if (!IsConnected || string.IsNullOrEmpty(message))
                return false;

            try
            {
                byte[] sendData = Encoding.UTF8.GetBytes(message);
                // 异步写入网络流：不阻塞当前线程，等待数据发送完成
                await _networkStream!.WriteAsync(sendData, 0, sendData.Length);
                await _networkStream.FlushAsync(); // 异步刷新缓冲区

                Console.WriteLine($"成功发送数据：{message}");
                return true;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"发送数据失败：{ex.Message}");
                return false;
            }
        }

        /// <summary>
        /// 异步接收数据循环（持续监听服务端数据）
        /// </summary>
        private async Task ReceiveDataLoopAsync(CancellationToken cancellationToken)
        {
            if (!IsConnected)
                return;

            byte[] buffer = new byte[1024]; // 接收缓冲区
            try
            {
                while (!cancellationToken.IsCancellationRequested && IsConnected)
                {
                    // 异步读取网络流：无数据时挂起，不阻塞线程，有数据时恢复执行
                    int receivedBytes = await _networkStream!.ReadAsync(buffer, 0, buffer.Length, cancellationToken);

                    if (receivedBytes == 0)
                    {
                        Console.WriteLine("服务端主动关闭连接");
                        break;
                    }

                    // 解析接收到的数据
                    string receivedMessage = Encoding.UTF8.GetString(buffer, 0, receivedBytes);
                    Console.WriteLine($"接收到服务端数据：{receivedMessage}");
                }
            }
            catch (OperationCanceledException)
            {
                Console.WriteLine("接收循环已被取消");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"接收数据异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 释放资源
        /// </summary>
        public void Dispose()
        {
            _cts?.Cancel(); // 取消异步接收循环
            _networkStream?.Dispose();
            _tcpClient?.Dispose();
            Console.WriteLine("已断开连接并释放资源");
        }
    }

    // 调用示例
    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;

            // 循环异步发送数据
            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($"网络连接异常：{ex.ErrorCode} - {ex.Message}");
}