WinForm实现同一台电脑两个程序间的TCP通信

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Windows.Forms;

namespace TCPServer
{
    public partial class Form1 : Form
    {
        // TCP监听套接字（核心对象，负责监听客户端连接）
        private TcpListener tcpListener;
        // 客户端连接套接字（与客户端建立连接后，用于接收消息）
        private TcpClient clientSocket;
        // 监听线程（将监听操作放入后台线程，防止界面卡死）
        private Thread listenThread;
        // 服务端IP和端口（同一台电脑固定用本地回环地址127.0.0.1，端口可自定义，需与客户端一致）
        private readonly string ip = "127.0.0.1";
        private readonly int port = 8888;

        public Form1()
        {
            InitializeComponent();
            // 绑定窗体关闭事件，关闭时释放所有资源，避免内存泄漏
            this.FormClosing += Form1_FormClosing;
        }

        // 「启动监听」按钮点击事件
        private void btnStart_Click(object sender, EventArgs e)
        {
            // 启动后台监听线程，避免阻塞主线程（界面卡死）
            listenThread = new Thread(StartListen);
            listenThread.IsBackground = true; // 设为后台线程，关闭程序时自动退出
            listenThread.Start();
            // 向消息框添加状态提示
            AppendMsg("服务端已启动监听：" + ip + ":" + port);
        }

        // 核心方法：启动TCP监听，等待客户端连接
        private void StartListen()
        {
            try
            {
                // 创建TCP监听对象，绑定IP和端口
                tcpListener = new TcpListener(IPAddress.Parse(ip), port);
                // 启动监听服务
                tcpListener.Start();
                AppendMsg("等待客户端连接...");

                // 死循环监听（阻塞方法，必须放在线程中），持续等待客户端连接
                while (true)
                {
                    // 接受客户端的连接请求，建立连接
                    clientSocket = tcpListener.AcceptTcpClient();
                    AppendMsg("客户端已连接！");

                    // 开启新线程接收该客户端的消息（多线程支持，可扩展多客户端连接）
                    Thread receiveThread = new Thread(ReceiveMsg);
                    receiveThread.IsBackground = true;
                    receiveThread.Start(clientSocket);
                }
            }
            catch (Exception ex)
            {
                // 捕获异常，避免程序崩溃，提示异常信息
                AppendMsg("监听异常：" + ex.Message);
            }
        }

        // 接收客户端发送的消息
        private void ReceiveMsg(object obj)
        {
            // 将传入的参数转为TcpClient对象（与当前连接的客户端绑定）
            TcpClient client = (TcpClient)obj;
            // 获取网络数据流，用于读取客户端发送的数据
            NetworkStream stream = client.GetStream();

            try
            {
                byte[] buffer = new byte[1024]; // 数据缓冲区，用于存储接收的字节数据（1024字节足够日常使用）
                int len; // 实际读取到的字节长度

                // 循环读取客户端消息（stream.Read()是阻塞方法，客户端断开连接时会抛出异常）
                while ((len = stream.Read(buffer, 0, buffer.Length)) > 0)
                {
                    // 将字节数据转为UTF-8编码的字符串（与客户端编码一致，避免乱码）
                    string msg = Encoding.UTF8.GetString(buffer, 0, len);
                    // 显示客户端发送的消息
                    AppendMsg("客户端说：" + msg);
                }
            }
            catch
            {
                // 客户端断开连接时，提示状态
                AppendMsg("客户端断开连接");
            }
        }

        // 「停止监听」按钮点击事件
        private void btnStop_Click(object sender, EventArgs e)
        {
            // 停止监听，释放监听资源
            tcpListener?.Stop();
            // 关闭客户端连接，释放连接资源
            clientSocket?.Close();
            AppendMsg("服务端已停止监听");
        }

        // 窗体关闭事件：释放所有资源
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            // 安全释放资源，避免程序异常
            tcpListener?.Stop();
            clientSocket?.Close();
        }

        // 跨线程安全更新界面消息（子线程不能直接操作窗体控件，需通过Invoke实现）
        private void AppendMsg(string msg)
        {
            // 判断是否需要跨线程调用
            if (txtMsg.InvokeRequired)
            {
                // 跨线程调用，更新消息框内容
                txtMsg.Invoke(new Action(() =>
                {
                    txtMsg.AppendText(DateTime.Now.ToString("HH:mm:ss ") + msg + Environment.NewLine);
                }));
            }
            else
            {
                // 主线程直接更新
                txtMsg.AppendText(DateTime.Now.ToString("HH:mm:ss ") + msg + Environment.NewLine);
            }
        }
    }
}

using System;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Windows.Forms;

namespace TCPClient
{
    public partial class Form1 : Form
    {
        // TCP客户端套接字（核心对象，用于连接服务端并发送消息）
        private TcpClient clientSocket;
        // 服务端IP和端口（必须与服务端完全一致，否则无法连接）
        private readonly string serverIp = "127.0.0.1";
        private readonly int serverPort = 8888;

        public Form1()
        {
            InitializeComponent();
            // 绑定窗体关闭事件，释放资源
            this.FormClosing += Form1_FormClosing;
        }

        // 「连接服务端」按钮点击事件
        private void btnConnect_Click(object sender, EventArgs e)
        {
            try
            {
                // 创建TCP客户端对象
                clientSocket = new TcpClient();
                // 连接服务端（IP和端口必须与服务端一致）
                clientSocket.Connect(serverIp, serverPort);
                AppendMsg("成功连接到服务端！");

                // 开启线程接收服务端消息（本案例服务端暂只接收消息，可扩展双向通信）
                Thread receiveThread = new Thread(ReceiveMsg);
                receiveThread.IsBackground = true;
                receiveThread.Start();
            }
            catch (Exception ex)
            {
                // 连接失败时提示异常信息（常见原因：服务端未启动、端口不一致）
                AppendMsg("连接失败：" + ex.Message);
            }
        }

        // 接收服务端发送的消息（可扩展双向通信，目前预留）
        private void ReceiveMsg()
        {
            try
            {
                // 获取与服务端通信的网络数据流
                NetworkStream stream = clientSocket.GetStream();
                byte[] buffer = new byte[1024]; // 数据缓冲区
                int len; // 实际读取的字节长度

                // 循环读取服务端消息
                while ((len = stream.Read(buffer, 0, buffer.Length)) > 0)
                {
                    string msg = Encoding.UTF8.GetString(buffer, 0, len);
                    AppendMsg("服务端说：" + msg);
                }
            }
            catch
            {
                // 与服务端断开连接时提示
                AppendMsg("与服务端断开连接");
            }
        }

        // 「发送消息」按钮点击事件
        private void btnSend_Click(object sender, EventArgs e)
        {
            // 先判断是否已连接服务端，未连接则提示
            if (clientSocket == null || !clientSocket.Connected)
            {
                MessageBox.Show("请先连接服务端！");
                return;
            }

            try
            {
                // 获取输入框中的消息，去除前后空格
                string sendMsg = txtSend.Text.Trim();
                if (string.IsNullOrEmpty(sendMsg)) return; // 空消息不发送

                // 将字符串转为UTF-8编码的字节流（与服务端编码一致）
                byte[] buffer = Encoding.UTF8.GetBytes(sendMsg);
                // 获取网络数据流，发送消息到服务端
                NetworkStream stream = clientSocket.GetStream();
                stream.Write(buffer, 0, buffer.Length);

                // 显示自己发送的消息
                AppendMsg("你说：" + sendMsg);
                txtSend.Clear(); // 发送后清空输入框
            }
            catch (Exception ex)
            {
                // 发送失败时提示异常信息
                AppendMsg("发送失败：" + ex.Message);
            }
        }

        // 窗体关闭事件：释放客户端资源
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            clientSocket?.Close();
        }

        // 跨线程安全更新界面消息（与服务端逻辑一致）
        private void AppendMsg(string msg)
        {
            if (txtMsg.InvokeRequired)
            {
                txtMsg.Invoke(new Action(() =>
                {
                    txtMsg.AppendText(DateTime.Now.ToString("HH:mm:ss ") + msg + Environment.NewLine);
                }));
            }
            else
            {
                txtMsg.AppendText(DateTime.Now.ToString("HH:mm:ss ") + msg + Environment.NewLine);
            }
        }
    }
}