C#使用TCP/IP长连接获取数据、心跳检测

时间：2025-03-01 06:57:42

逻辑处理

  1. 创建一个Socket对象并连接到服务器，可以使用()方法。
  2. 使用()方法发送数据到服务器。
  3. 使用()方法接收服务器返回的数据。
  4. 实现心跳检测，可以定时向服务器发送一个心跳包，如果服务器没有响应，则说明连接已断开。
  5. 如果连接断开，可以尝试重新连接，可以使用()方法关闭当前连接，然后再重新创建一个新的Socket对象。

注意事项：

  • 长连接需要保证数据传输的可靠性，可以考虑使用TCP协议。
  • 心跳检测的频率需要根据具体情况进行调整，过于频繁可能会增加网络负担，过于稀疏可能会延迟发现连接异常。
  • 在使用Socket的过程中，需要考虑异常处理和资源释放问题，避免出现内存泄漏等问题。

代码示例1：

using System;
using ;

class Program
{
    static void Main(string[] args)
    {
        string serverIp = "127.0.0.1";
        int serverPort = 12345;

        // 创建 Socket 对象并连接到服务器
        Socket socket = new Socket(, , );
        (serverIp, serverPort);

        // 发送数据并接收服务器返回的数据
        byte[] sendData = .("Hello, world!");
        (sendData);

        byte[] recvData = new byte[1024];
        int recvSize = (recvData);
        string recvMsg = .(recvData, 0, recvSize);
        ("[Server]: {0}", recvMsg);

        // 定时发送心跳包并检测连接状态
        while (true)
        {
            try
            {
                // 发送心跳包
                byte[] heartbeatData = .("heartbeat");
                (heartbeatData);

                // 接收服务器返回的心跳包响应
                byte[] heartbeatResp = new byte[1024];
                int respSize = (heartbeatResp);
                if (respSize == 0)
                {
                    throw new Exception("Connection failed: no response received.");
                }

                string respMsg = .(heartbeatResp, 0, respSize);
                ("[Server]: {0}", respMsg);

                // 等待一段时间后再次发送心跳包
                (5000);
            }
            catch (Exception ex)
            {
                ();

                // 连接断开，关闭当前连接并尝试重新连接
                ();
                socket = new Socket(, , );
                (serverIp, serverPort);
            }
        }
    }
}

代码示例2：

using System;
using ;
using ;
using ;

class Program
{
    static void Main(string[] args)
    {
        string serverIp = "127.0.0.1";
        int serverPort = 12345;
        string logFile = @"C:\";

        // 创建 Socket 对象并连接到服务器
        Log("Connecting to server...");
        Socket socket = new Socket(, , );
        try
        {
            (serverIp, serverPort);
            Log("Connected to server.");
        }
        catch (Exception ex)
        {
            Log("Connection failed: " + );
            return;
        }

        // 发送数据并接收服务器返回的数据
        byte[] sendData = Encoding.("Hello, world!");
        try
        {
            Log("Sending data to server...");
            (sendData);

            byte[] recvData = new byte[1024];
            int recvSize = (recvData);
            string recvMsg = Encoding.(recvData, 0, recvSize);
            Log("[Server]: " + recvMsg);
        }
        catch (Exception ex)
        {
            Log("Error sending or receiving data: " + );
            ();
            return;
        }

        // 定时发送心跳包并检测连接状态
        while (true)
        {
            try
            {
                // 发送心跳包
                byte[] heartbeatData = Encoding.("heartbeat");
                (heartbeatData);
                Log("Sent heartbeat.");

                // 接收服务器返回的心跳包响应
                byte[] heartbeatResp = new byte[1024];
                int respSize = (heartbeatResp);
                if (respSize == 0)
                {
                    throw new Exception("Connection failed: no response received.");
                }

                string respMsg = Encoding.(heartbeatResp, 0, respSize);
                Log("[Server]: " + respMsg);

                // 等待一段时间后再次发送心跳包
                (5000);
            }
            catch (Exception ex)
            {
                Log("Error sending or receiving heartbeat: " + );

                // 连接断开，关闭当前连接并尝试重新连接
                ();
                Log("Disconnected from server. Trying to reconnect...");
                try
                {
                    socket = new Socket(, , );
                    (serverIp, serverPort);
                    Log("Connected to server.");
                }
                catch (Exception ex2)
                {
                    Log("Reconnection failed: " + );
                }
            }
        }
    }

    static void Log(string message)
    {
        string timestamp = ("yyyy-MM-dd HH:mm:ss");
        string logMessage = "[" + timestamp + "] " + message;
        (logMessage);

        using (StreamWriter writer = (@"C:\"))
        {
            (logMessage);
        }
    }
}

单客户端连接多服务器代码示例


using System;
using ;
using ;
using ;
using ;
using ;

class Client {
    // 声明变量
    private static List<TcpClient> clients = new List<TcpClient>(); // 多个服务端
    private static bool run = true; // 运行状态
    private static bool connected = false; // 连接状态
    private static StreamWriter logFile; // 日志文件

    static void Main(string[] args) {
        // 创建日志文件
        logFile = new StreamWriter("", true);
         = true;

        // 连接多个服务端
        Connect("192.168.0.1", 5000);
        Connect("192.168.0.2", 5000);

        // 执行心跳检测和断线重连
        while (run) {
            if (!connected) {
                // 断线重连
                Reconnect();
            } else {
                // 执行心跳检测
                foreach (TcpClient client in clients) {
                    if () {
                        NetworkStream stream = ();
                        byte[] message = ("PING");
                        (message, 0, );
                    }
                }
                (10000); // 等待10秒
            }
        }

        // 关闭日志文件
        ();
    }

    static void Connect(string ip, int port) {
        try {
            TcpClient client = new TcpClient(ip, port);
            (client);
            connected = true;
            ("Connected to " + ip + ":" + port);
            // 启动接收线程
            Thread receiveThread = new Thread(new ParameterizedThreadStart(Receive));
            (client);
        } catch (Exception e) {
            ("Error connecting to " + ip + ":" + port + " - " + );
        }
    }

    static void Reconnect() {
        ("Trying to reconnect...");
        foreach (TcpClient client in clients) {
            try {
                if (!) {
                    (((IPEndPoint)).(), ((IPEndPoint)).Port);
                    connected = true;
                    ("Reconnected to " + ((IPEndPoint)).() + ":" + ((IPEndPoint)).Port);
                    // 启动接收线程
                    Thread receiveThread = new Thread(new ParameterizedThreadStart(Receive));
                    (client);
                }
            } catch (Exception e) {
                ("Error reconnecting to " + ((IPEndPoint)).() + ":" + ((IPEndPoint)).Port + " - " + );
            }
        }
        (5000); // 等待5秒
    }

    static void Receive(object clientObject) {
        TcpClient client = (TcpClient)clientObject;
        NetworkStream stream = ();
        byte[] message = new byte[1024];
        int bytesRead;
        while (run) {
            try {
                bytesRead = (message, 0, );
                if (bytesRead > 0) {
                    string data = (message, 0, bytesRead);
                    ("Received data: " + data);
                }
            } catch (Exception e) {
                connected = false;
                ("Error receiving data from " + ((IPEndPoint)).() + ":" + ((IPEndPoint)).Port + " - " + );
                break;
            }
        }
    }
}

相关文章