自己写的TCP监听器

最新推荐文章于 2024-07-01 03:09:46 发布
最新推荐文章于 2024-07-01 03:09:46 发布
阅读量635 收藏
点赞数
分类专栏： C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuyajungogo/article/details/87346232
版权

宿主是自己写的winform窗体程序，这个监听器跑在后台线程，用户开启监听后，仍然可以在界面进行其他操作

勾选checkbox，启动监听器，事件如下：

private void ckbStartListen_CheckedChanged(object sender, EventArgs e)
        {
            
            int port = 0;
            if (!int.TryParse(tbServerPort.Text.Trim(), out port) && ckbStartListen.Checked)
            {
                MessageBox.Show("监听端口填写错误");
                tbServerPort.Focus();
                ckbStartListen.Checked = false;

                return;
            }
            //勾选启动监听并且线程不忙时，可以开启监听
            if (ckbStartListen.Checked)
            {
                if (backgroundWorker1.IsBusy)
                {
                    MessageBox.Show("线程正忙，请稍后再试");
                    ckbStartListen.Checked = false;
                    return;
                }

                
                backgroundWorker1.RunWorkerAsync(port);
                label16.Text = "正在监听";
                label16.ForeColor = Color.Green;
                tbServerPort.Enabled = false;
            }
            else
            {
                try
                {
                    if (backgroundWorker1.IsBusy)
                    {
                        //停止
                        backgroundWorker1.CancelAsync();

                        label16.Text = "正在断开连接，请等待几秒";
                        label16.ForeColor = Color.Red;
                        //给自己发一个连接，以通知异步线程停止监听
                        TcpClient client = new TcpClient();

                        string hostName = Dns.GetHostName();

                        client.Connect(IPAddress.Parse("127.0.0.1"), port);

                        if (client.Connected)
                            client.Close();

                       
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }

            }
        }

后台线程backgroundWorker1的各个事件

 private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            //进度报告
            tbReportInfo.Text = string.Join("\r\n", Reports);
            tbSuccessNum.Text = PKSuccess.ToString();
            tbFailNum.Text = PKFail.ToString();
            tbUploadTime.Text = (PKFail + PKSuccess).ToString();
            tbServerPort.Enabled = false;

            if (!string.IsNullOrEmpty(DevState))
                tbDevState.Text = DevState;
            if (!string.IsNullOrEmpty(DoorState))
                tbDoorState.Text = DoorState;

            tbWallShake.Text = KBAlert+"";
            tbDoorShake.Text = KMAlert+"";
            tbOutTime.Text = OutTimeAlert+"";

            //dgvPKinfo.DataSource = null;
            //dgvPKinfo.DataSource = pklist;
            //必须这样绑定才能刷新列表，晕
            dgvPKinfoRef();
            dgvLockInfoRef();
            dgvJCRef();
            //dgvLockInfo.DataSource = lockList;
            //dgvJC.DataSource = cjShowlist;
        }
        private void dgvPKinfoRef()
        {
            BindingList<PKModel> bd = new BindingList<PKModel>();
            dgvPKinfo.DataSource = bd;
            foreach (PKModel P in pklist)
            {
                bd.Add(P);
            }
        }
        private void dgvLockInfoRef()
        {
            BindingList<LockModel> bd = new BindingList<LockModel>();
            dgvLockInfo.DataSource = bd;
            foreach (LockModel P in lockList)
            {
                bd.Add(P);
            }
        }
        private void dgvJCRef()
        {
            BindingList<CJModel_Show> bd = new BindingList<CJModel_Show>();
            dgvJC.DataSource = bd;
            foreach (CJModel_Show P in cjShowlist)
            {
                bd.Add(P);
            }
        }
        /// <summary>
        /// 将异步执行的操作
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            int port = int.Parse(e.Argument.ToString());

            int js = 0;
            //创建服务器监听
            TcpListener server = new TcpListener(IPAddress.Any, port);
            //最大可支持10个挂起的连接
            server.Start(10);
            while (true)
            {
                try
                {
                    
                    //接收连接请求
                    if (backgroundWorker1.CancellationPending)
                    {
                        e.Cancel = true;
                        Common.WriteLog("用户取消了监听");
                        server.Stop();
                        return;
                    }
                    TcpClient client = server.AcceptTcpClient();
                    client.ReceiveTimeout = 10 * 1000;//10秒无数据则停止等待
                    NetworkStream stream = client.GetStream();

                    #region 已连接
                    byte[] buffer = new byte[4096];
                    while (true)
                    {
                        try
                        {
                            if (backgroundWorker1.CancellationPending)
                            {
                                e.Cancel = true;
                                Common.WriteLog("用户取消了监听");
                                stream.Close();
                                client.Client.Shutdown(SocketShutdown.Both);
                                client.Client.Close();
                                client.Close();
                                server.Stop();
                                return;
                            }

                            if (!client.Connected)//客户端断开后退出当前循环
                                break;
                            js++;
                            //从流数据里面获取数据
                            int lenth = stream.Read(buffer, 0, buffer.Length);

                            if (lenth > 0)
                            {
                                #region 接收
                                if (lenth <= 32)
                                {
                                    Common.WriteLog("非法指令：" + BitConverter.ToString(buffer, 0, lenth));
                                    continue;
                                }

                                //处理流数据
                                Common.WriteLog("未解密设备请求：" + BitConverter.ToString(buffer, 0, lenth));

                                string msg;
                                string retheadstr = "";
                                if (true)
                                {
                                    //取出未加密的头部
                                    byte[] rethead = new byte[32];
                                    for (int i = 0; i < 32; i++)
                                    {
                                        rethead[i] = buffer[i];
                                    }

                                    retheadstr = Encoding.UTF8.GetString(rethead);
                                    int len1 = Convert.ToInt32(retheadstr.Substring(0, 6));

                                    //根据长度取出后续报文，不是16的倍数时需要同时取出补充的空格
                                    int bc = 0;
                                    if ((len1 - 32) % 16 != 0)
                                    {
                                        bc = 16 - ((len1 - 32) % 16);
                                    }

                                    byte[] retbody = new byte[len1 - 32 + bc];
                                    for (int i = 0; i < retbody.Length; i++)
                                    {
                                        retbody[i] = buffer[i + 32];
                                    }
                                    //解密
                                    msg = Common.Decrypt(retbody, AseKey).Trim();

                                    if (cbOpenReport.Checked)
                                    {
                                        Common.WriteLog("解密设备请求：" + retheadstr + msg);
                                        Reports.Add(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + "-->设备请求：" + retheadstr + msg);
                                        if (Reports.Count > 10)
                                        {
                                            Reports.RemoveRange(0, Reports.Count - 10);
                                        }
                                    }
                                }
                                else
                                {
                                    msg = Encoding.UTF8.GetString(buffer, 0, lenth);
                                    retheadstr = msg.Substring(0, 32);
                                    msg = msg.Substring(32);

                                    //修改List 试试
                                    if (pklist == null)
                                        pklist = new List<PKModel>();
                                    pklist.Add(new PKModel()
                                    {
                                        Ex_BoxId = js + "",
                                        Ex_BoxPower = "test" + js,
                                        Ex_PartId = "test" + js,
                                        Ex_PartStatus = "开启" + js
                                    });

                                }
                                XmlDocument doc = new XmlDocument();
                                doc.LoadXml(msg);
                                string xml = string.Empty;
                                switch (retheadstr.Substring(6, 4))
                                {
                                    case "2005": xml = PKResult(doc); break;
                                    case "3001": xml = Report3001(doc); break;
                                    case "3002": xml = Report3002(doc); break;
                                    case "4001": xml = Report4001(doc); break;
                                    default: Common.WriteLog("命令不存在:" + msg.Substring(6, 4)); break;
                                }
                                #endregion

                                #region 回复
                                //回复的头部信息用原来的
                                string head = retheadstr.Substring(6);
                                if (cbOpenReport.Checked)
                                {
                                    Common.WriteLog("加密前服务器应答:" + ((head + xml).Length + 6).ToString().PadLeft(6, '0') + head + xml);
                                    Reports.Add(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + "-->服务器应答：" + ((head + xml).Length + 6).ToString().PadLeft(6, '0') + head + xml);
                                    if (Reports.Count > 10)
                                    {
                                        Reports.RemoveRange(0, Reports.Count - 10);
                                    }
                                }

                                //需要加密
                                byte[] newXml = Common.Encrypt(xml, AseKey);

                                byte[] newbyte = new byte[newXml.Length + 32];
                                byte[] headbyte = System.Text.Encoding.Default.GetBytes(head);
                                byte[] len = System.Text.Encoding.Default.GetBytes((newXml.Length + 32).ToString().PadLeft(6, '0'));

                                for (int i = 0; i < newbyte.Length; )
                                {
                                    if (i < 6)
                                    {
                                        //前6位长度
                                        for (int j = 0; j < len.Length; j++)
                                        {
                                            newbyte[i++] = len[j];

                                        }
                                    }
                                    if (i < 32 && i >= 6)
                                    {
                                        //剩下的报文头
                                        for (int j = 0; j < headbyte.Length; j++)
                                        {
                                            newbyte[i++] = headbyte[j];
                                        }
                                    }
                                    if (i >= 32)
                                    {
                                        //报文体
                                        for (int j = 0; j < newXml.Length; j++)
                                        {
                                            newbyte[i++] = newXml[j];
                                        }
                                    }
                                }

                                Common.WriteLog("加密后服务器应答:" + BitConverter.ToString(newbyte));

                                stream.Write(newbyte, 0, newbyte.Length);
                                stream.Flush();
                                #endregion

                                backgroundWorker1.ReportProgress(js);
                            }
                            else
                            {
                                break;
                            } 
                        }
                        catch (SocketException)
                        {

                            try
                            {
                                Common.WriteLog("出现Socket异常，连接已断开");
                                client.Client.Shutdown(SocketShutdown.Both);
                                client.Client.Close();
                                client.Close();
                            }
                            catch { }
                            break;
                        }
                        catch (Exception ex)
                        {
                            Common.WriteLog("处理监听数据异常，异常信息：" + ex.Message + "；详细信息：" + ex.StackTrace);

                            stream.Close();
                            client.Close();
                            server.Stop();
                            break;
                        }

                    }
                    #endregion
                }
                catch(Exception ex)
                {
                    Common.WriteLog("监听器出现异常，异常信息：" + ex.Message + "；详细信息：" + ex.StackTrace);
                    break;
                }
            }
        }
        private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            //完成,此判断是取消的，还是自然完成的
            if (e.Cancelled)
                MessageBox.Show("监听已终止");
            else
                MessageBox.Show("监听意外停止，请打开查看日志查看详情");
            if (e.Error != null)
                MessageBox.Show("监听异常停止，异常信息：" + e.Error.Message);

            tbServerPort.Enabled = true;
            label16.Text = "监听停止";
            label16.ForeColor = Color.Red;
            backgroundWorker1.Dispose();
        }

 

一枚大帅哥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
tcp 端口监听器
03-14
tcp 端口监听器
TCP-服务器监听
qq_43187004的博客
10-19 4639
package main import ( “fmt” “net” ) func process(conn net.Conn) { //这里我们循环的接收客户端发送的数据 defer conn.Close()//关闭conn for{ //创建一个新的切片 buf := make([]byte,1024) //conn.Read(buf) //1.等待客户端通过conn发送信息 //2.如果客户...
java监听tcp端口
最新发布
weixin_29435467的博客
07-01 94
TCP相关视频讲解：轻松理解并熟悉TCP四次挥手状态转换监听TCP端口的Java应用程序开发 在网络编程中，我们经常需要编写应用程序来监听TCP端口，以便接收来自其他计算机的连接请求。在Java中，我们可以使用Socket类来实现这一功能。本文将介绍如何在Java中监听TCP端口，并提供一个简单的示例代码。 TCP端口监...
多线程 TCP/IP 侦听器
06-18
多线程 TCP/IP 侦听器
TCP监听套接口链表
redwingz的博客
03-05 728
全局结构体变量tcp_hashinfo，成员listening_hash为保存处于监听状态（TCP_LISTEN）的TCP套接口哈希链表。由于监听套接口需要被频繁的读写，内核将其对其到一行高速缓存的长度，以便快速访问。 struct inet_hashinfo tcp_hashinfo; #define INET_LHTABLE_SIZE 32 struct inet_hashinfo...
tcp 端口监听器 使用教程
03-14
tcp 端口监听器 使用教程
基于C#实现的tcp服务端监听程序
07-24
此外，由于此程序是在Windows环境下运行，开发者需要了解如何在Windows系统中管理和调试TCP服务，例如通过命令行工具`netstat`检查端口状态，或者使用任务管理器查看进程状态。 总之，这个项目提供了一个基础的TCP...
tcp.rar_C# 监听端口_C++ TCP 监听_tcp 监听_端口监听
09-14
本资料“tcp.rar”包含了一段C#语言实现的端口监听代码，以及可能涉及到C++实现的TCP监听的相关内容。下面，我们将详细探讨C#和C++中如何实现TCP监听以及端口监听的关键知识点。 首先，让我们从C#开始。C#中的`...
tcp 监听程序
03-28
TCP监听程序，通常被称为网络嗅探器或抓包工具，是一种用于分析网络通信的数据包捕获软件。在本例中，我们关注的是一个使用C#编程语言开发的TCP监听程序，名为TCPSniffer.exe。这个程序允许用户查看TCP/IP协议层的...
TCPView端口查看器
03-30
此外，TCPView还会显示连接的状态，如“监听”、“已建立”或“关闭等待”，这些状态反映了连接的不同阶段和活跃程度。 在安全领域，TCPView扮演着重要的角色。由于它可以实时监控并更新TCP连接信息，因此，如果你...
监听tcp ip
06-13
- `TcpListener`：根据端点创建监听器对象。 2. **启动监听器**： ```csharp tcpServer.Start(); Console.WriteLine("启动监听"); ``` - 使用`Start()`方法启动监听器。 - 输出提示信息“启动监听”。 3. *...
TCP.UDP协议的实时监听
07-10
TCP.UDP协议的实时监听,TCP.UDP协议的实时监听,TCP.UDP协议的实时监听.
tcptrace TCP端口监听工具 TCP跟踪
06-11
好用的TCP端口监听工具，　用於調試WCF, SOAP的工具
我自己做得TCP监听本地端口的程序。。希望大家提出不足。。。
05-15
实现了监听串口设备的数据。心跳包。 主要运用了TCP协议。。希望大家提出不足。可加我QQ：170231513
Tcp通讯，客户端监听,server发消息client接收消息
04-28
Tcp通讯，客户端监听,server发消息client接收消息
简单TCP程序实例_tcp聊天器_tcp_
10-02
本项目提供了一个简单的TCP程序实例，即TCP聊天器，它包括服务端和客户端两部分，允许两个或多个用户通过网络进行实时交流。 **TCP协议基础** TCP是一种面向连接的、可靠的、基于字节流的传输层通信协议。它在数据...
tcpip多端口监听代码_java TCP端口监听
weixin_39959192的博客
12-22 869
import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.PrintWriter;import java.net.InetAddress;import java.net.ServerSocket;import java.net.Socket;/**...
zabbix监控TCP
qq_38419276的博客
10-05 620
TCP端口的十一种连接状态： CLOSED：端口默认是关闭状态。 LISTEN： 服务器程序开始监听一个端口，就是LISTEN状态。 SYN_RCVD：三次握手的第二次握手后的端口状态，是收到了客户端发送的SYN_SENT数据包之后的状态，这个状态很短暂， 正常在服务器上是很少看到的，除非服务器故意不发送最后一次握手数据包， 服务器返回给客户端SYN确认之后就会将在自己的端口置为SYN_RCVD。 SYN_SENT：SYN_SENT状态表示客户端已发送SYN=1的请求连接报文，发送之后客户端就会将自己
PLSQL配置监听器
04-09
PLSQL配置监听器 PLSQL配置监听器是指在Oracle服务器上配置监听器，以便于远程访问数据库。监听器是Oracle Net组件之一，负责监听来自客户端的连接请求，并将其路由到相应的数据库实例。 在配置监听器之前，需要...
配置监听器listenerBMS
06-01
好的，您可以使用以下步骤来配置名为listenerBMS的监听器： 1. 打开命令行窗口或终端...这个SQL语句将创建一个名为listenerBMS的监听器，使用TCP协议和端口号1522。您可以根据需要调整主机名、端口号和监听器名称。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值