C#实现TCP服务端

最新推荐文章于 2024-06-20 10:37:01 发布
最新推荐文章于 2024-06-20 10:37:01 发布
阅读量1.1w 收藏 45
点赞数 7
分类专栏： C#编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/scy518/article/details/113699684
版权

C# TCP服务器 网络编程 异步处理 连接管理
关键词由CSDN通过智能技术生成

C#实现TCP服务端

网上给出的C#实现的基本上都是测试代码，项目使用还是存在一点问题。实在没有办法，自己全新写了一个。不啰嗦，直接上代码。

TCP部分代码下载地址：https://download.csdn.net/download/scy518/15082224

需要整个代码，请私信联系。

测试截图

在这里插入图片描述

服务端代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Threading;
using System.Net;
using DeployAssist.UI.Device;

namespace DeployAssist.Net
{
    public class TcpSocketServer
    {
        private DeviceManageForm m_DeviceManageForm = null;
        private Socket m_ServerSocket = null;
        private IAsyncResult m_IAsyncResult = null;
        private Dictionary<string, TcpSocketConnect> m_ConSocketDic = new Dictionary<string, TcpSocketConnect>();
        private bool m_Running = false;

        public TcpSocketServer(DeviceManageForm dmform)
        {
            m_DeviceManageForm = dmform;
        }

        /// <summary>
        /// 启动服务
        /// </summary>
        /// <param name="port">端口号</param>
        public bool StartServer(string host, int port)
        {
            try
            {
                m_Running = true;

                //创建负责监听的套接字，注意其中的参数；
                m_ServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

                IPEndPoint endPoint = null;
                //创建包含ip和端口号的网络节点对象
                if (host == "")
                {
                    endPoint = new IPEndPoint(IPAddress.Any, port);
                }
                else
                {
                    //将将IP地址字符串转换为IPAddress对象
                    IPAddress ip = IPAddress.Parse(host);
                    endPoint = new IPEndPoint(ip, port);
                }

                //将负责监听的套接字绑定到唯一的ip和端口上
                m_ServerSocket.Bind(endPoint);

                //设置监听队列的长度
                m_ServerSocket.Listen(100);

                //开始接受连接,异步
                m_IAsyncResult = m_ServerSocket.BeginAccept(new AsyncCallback(OnAccept), m_ServerSocket);

                //创建连接超时检测线程
                Thread checkConnectTread = new Thread(CheckConnectThread);
                checkConnectTread.IsBackground = true;
                checkConnectTread.Start();

                return true;
            }
            catch (System.Exception ex)
            {
                m_DeviceManageForm.DoWirteLog(ex.ToString());
                return false;
            }
        }
        /// <summary>
        /// 关闭服务
        /// </summary>
        public void StopServer()
        {
            //设置停止运行
            SetRunning(false);

            if (m_ServerSocket != null)
            {
                m_ServerSocket.Close();
                m_ServerSocket = null;
            }

            lock (m_ConSocketDic)
            {
                foreach (var item in m_ConSocketDic)
                {
                    //关闭每一个连接
                    item.Value.CloseSocket();
                }
                m_ConSocketDic.Clear();
            }
        }

        /// <summary>
        /// 接收状态
        /// </summary>
        public void SetRunning(bool flage)
        {
            lock (this)
            {
                m_Running = flage;
            }

            return;
        }

        /// <summary>
        /// 接收状态
        /// </summary>
        public bool GetRunning()
        {
            bool tmprunning = false;

            lock (this)
            {
                tmprunning = m_Running;
            }

            return tmprunning;
        }

        /// <summary>
        /// 监听客户端请求的方法；
        /// </summary>
        private void OnAccept(IAsyncResult asyResult)
        {
            try
            {
                //一旦监听到一个客户端的请求，就返回一个与该客户端通信的套接字
                Socket tcpserver = (Socket)asyResult.AsyncState;
                Socket tmpsocket = tcpserver.EndAccept(asyResult);

                //将与客户端连接的套接字对象添加到集合中
                string remoteEndpoint = tmpsocket.RemoteEndPoint.ToString();
                TcpSocketConnect connect = new TcpSocketConnect();
                int ret = connect.OpenSocket(this, tmpsocket);
                if (ret == 0)
                {
                    m_ConSocketDic.Add(remoteEndpoint, connect);
                }
                else
                {
                    m_DeviceManageForm.DoWirteLog("Init Connect fail." + remoteEndpoint);
                }

                //等待新的客户端连接
                tcpserver.BeginAccept(new AsyncCallback(OnAccept), tcpserver);
            }
            catch (System.Exception ex)
            {
                if (m_ServerSocket != null)
                {
                    m_DeviceManageForm.DoWirteLog(ex.ToString());
                }
            }
        }

        /// <summary>
        /// 检测连接状态线程
        /// </summary>
        private void CheckConnectThread()
        {
            //启动运行
            SetRunning(true);

            while (GetRunning())
            {
                try
                {
                    List<string> conkeylist = new List<string>();
                    lock (m_ConSocketDic)
                    {
                        foreach (var dic in m_ConSocketDic)
                        {
                            //判断连接是否超时
                            TcpSocketConnect connect = ((TcpSocketConnect)(dic.Value));
                            if (connect.CheckTimeOut())
                            {
                                connect.CloseSocket();
                                conkeylist.Add(dic.Key);
                            }
                        }

                        //移除超时会话
                        foreach (string key in conkeylist)
                        {
                            m_ConSocketDic.Remove(key);
                        }      
                    }
                }
                catch (System.Exception ex)
                {
                    m_DeviceManageForm.DoWirteLog(ex.ToString());
                }

                Thread.Sleep(200);
            }
        }

        /// <summary>
        /// 写日志
        /// </summary>
        /// <param name="sokConnectionparn"></param>
        public void DoWirteLog(string log)
        {
            if (m_DeviceManageForm != null)
            {
                m_DeviceManageForm.DoWirteLog(log);
            }
        }

        /// <summary>
        /// 接收数据
        /// </summary>
        /// <param name="sokConnectionparn"></param>
        public void DoReceiveData(string remotePoint, byte[] data, int len)
        {
            if (m_DeviceManageForm != null)
            {
                m_DeviceManageForm.DoReceiveData(remotePoint, data, len);
            }
        }
        /// <summary>
        /// 发送数据给指定的客户端
        /// </summary>
        /// <param name="_endPoint">客户端套接字</param>
        /// <param name="_buf">发送的数组</param>
        /// <returns></returns>
        public int DoSendData(string remotePoint, byte[] data, int len)
        {
            int ret = 0;
            TcpSocketConnect connect = new TcpSocketConnect();
            if (m_ConSocketDic.TryGetValue(remotePoint, out connect))
            {
                ret = connect.Send(data, len);
            }
            else
            {
                ret = -1 ;
            }

            return ret;
        }
    }
}

连接代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Net;
using System.Threading;
using DeployAssist.UI.Device;
using DeployAssist.Util;

namespace DeployAssist.Net
{
    public class TcpSocketConnect
    {
        private TcpSocketServer m_TcpSocketServer = null;
        private Socket     m_TcpSocket = null;
        private Thread     m_Thread = null;
        private Boolean    m_Running = false;
        private string     m_RemoteIP = "";
        private long       m_LastTime = 0;

        public int OpenSocket(TcpSocketServer tcpserver, Socket sk)
        {
            m_TcpSocketServer = tcpserver;
            m_TcpSocket = sk;

            //创建线程接收数据
            m_Thread = new Thread(ReceiveDataThread);
            m_Thread.IsBackground = true;
            m_Thread.Start();

            return 0;
        }

        /// <summary>
        /// 关闭连接
        /// </summary>
        public void CloseSocket()
        {
            //设置停止
            SetRunning(false);
            if (m_TcpSocket != null)
            {
                m_TcpSocket.Shutdown(SocketShutdown.Both);
            }
        }

        /// <summary>
        /// 检测是否超时，超时返回true 否则返回false
        /// </summary>
        /// <param name="buf"></param>
        public bool CheckTimeOut(int timeout = 60)
        {
            int tmptimeout = 60;
            if (timeout > 0)
            {
                tmptimeout = timeout;
            }

            long now = UtilTool.GetCurrentTimeStamp();
            lock (this)
            {
                if (now - m_LastTime > tmptimeout)
                {
                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="buf"></param>
        public int Send(byte[] buf, int len = 0)
        {
            if (buf == null)
            {
                return -1;
            }

            int ret = 0;
            lock (m_TcpSocket)
            {
                if (m_TcpSocket != null)
                {
                    ret = m_TcpSocket.Send(buf, len, SocketFlags.None);
                }
                else
                {
                    ret = -2;
                }
            }

            return ret;
        }

        /// <summary>
        /// 获取连接的ip
        /// </summary>
        /// <returns></returns>
        public string GetRemoteIP()
        {
            lock (m_TcpSocket)
            {
                if (m_TcpSocket != null && m_RemoteIP == "")
                {
                    IPEndPoint clientipe = (IPEndPoint)m_TcpSocket.RemoteEndPoint;
                    m_RemoteIP = clientipe.ToString();
                }
            }

            return m_RemoteIP;
        }

        /// <summary>
        /// 接收状态
        /// </summary>
        public void SetRunning(bool flage)
        {
            lock (this)
            {
                m_Running = flage;
            }

            return;
        }

        /// <summary>
        /// 接收状态
        /// </summary>
        public bool GetRunning()
        {
            bool tmprunning = false;

            lock (this)
            {
                tmprunning = m_Running;
            }

            return tmprunning;
        }

        /// <summary>
        /// 接收数据线程
        /// </summary>
        private void ReceiveDataThread()
        {
            //设置接收状态
            SetRunning(true);

            m_LastTime = UtilTool.GetCurrentTimeStamp();

            //定义一个2M的缓存区
            byte[] arrRec = new byte[1024 * 1024 * 2];

            while (GetRunning())
            {
                try
                {
                    if (m_TcpSocket == null)
                    {
                        break;
                    }

                    //接收数据，并返回数据的长度
                    int length = m_TcpSocket.Receive(arrRec);
                    if (length > 0)
                    {
                        if (m_TcpSocketServer != null)
                        {
                            m_TcpSocketServer.DoReceiveData(GetRemoteIP(), arrRec, length);
                        }

                        m_LastTime = UtilTool.GetCurrentTimeStamp();
                    }
                }
                catch (System.Exception ex)
                {
                    m_TcpSocketServer.DoWirteLog(ex.ToString());
                }

                Thread.Sleep(100);
            }
        }
    }
}


                    m_TcpSocketServer.DoReceiveData(GetRemoteIP(), arrRec, length);
                    }

                    m_LastTime = UtilTool.GetCurrentTimeStamp();
                }
            }
            catch (System.Exception ex)
            {
                m_TcpSocketServer.DoWirteLog(ex.ToString());
            }

            Thread.Sleep(100);
        }
    }
}

}
匠心码农
关注
专栏目录
基于C#的Tcp服务端通信
FlyToCloud的博客
03-11 3269
本篇主要是分享基于.Net的tcp服务端通信方案。其中基于unity的tcp客户端通信会在这里分享。另外关于tcp粘包断包的处理将放在这里分享。 整体设计 如图所示一共采用了三层封装来处理整个服务端的逻辑。 首先最上层的TcpServerMgr可以被业务层直接创建，并且通过事件系统将服务器收到的来自客户端的网络消息分发到各个业务系统中去。 其次TcpServer负责了整个tcp网络通信的创建，监听建立连接，关闭，心跳超时等等处理。对于正常接收到的消息通过一个回调函数传递给TcpServerMgr
c#脚本-TCP服务端事件接收数据
最新发布
667
10-07 462
【代码】c#脚本实现TCP服务端事件接收数据。
[ C# ] C#中TCP服务端的实现
wxf5522的博客
01-06 2226
C#中如何建立TCP服务端并监听客户端的请求与回复
【C#】制作TCP服务器
2301_79762281的博客
06-20 2090
在配置TCP服务器时，需要确认网络环境、开放相应的端口、确认服务运行状态等。可以使用telnet或nc等工具测试TCP连接是否正常。TCP服务器是一种基于TCP协议的服务器程序，它在网络通信中起着重要的角色。通过使用TCP协议，服务器可以保证数据的可靠性和顺序性，确保数据的正确传输。TCP服务器广泛应用于各种网络应用程序中，如网络游戏、网站服务器、文件传输、邮件服务器等。​。
c# 网路通讯TCP 服务端与客户端 简单编写，并能够实现快速断线重连的封装类（适合新手小白参考学习）
m0_54169323的博客
02-27 2235
本文适用于c#新手学习网络编程及断线重连提供思路及方法，简单的封装类。
使用C#语言实现基于Socket的TCP/IP的服务端的编写
weixin_44289416的博客
08-19 3937
C#实现基于Socket的基本的网络通信。实现最基本的和客户端互相发送。适合没有了解的初学者。代码有详细注释。
C# 实现 TCP服务端+客户端 带心跳机制.zip
12-31
本项目“C#实现TCP服务端+客户端带心跳机制”旨在教你如何构建一个具备心跳检查功能的TCP服务器和客户端系统，确保连接的稳定性和数据的可靠性。 TCP服务端和客户端是任何基于TCP的应用程序的两个基本组成部分。...
C#TCP服务端+客户端（心跳机制）.zip
10-16
自带客户与服务端心跳包验证。 客户端掉线，服务器自动响应。 所有均为事件与封装完全分享。代码高度简洁。 服务端断线与重启，客户端自动重新连接。 客户端消息异常，快速响应事件。 客户端与服务端，调用DOME完全...
C#实现TCP服务端与客户端通信示例及心跳检测
- 通过解析提供的C#TCP服务端和客户端完整示例代码，可以具体了解如何实现上述概念。代码中可能包含创建Socket，绑定IP和端口，监听连接，接收和发送数据，以及实现心跳机制的逻辑。 10. 排查和调试网络通信问题 ...
基于C#实现的tcp服务端监听程序
07-24
总之，这个项目提供了一个基础的TCP服务端实现，帮助开发者理解网络编程的基本概念，并能动手实践，进一步提升C#编程和网络通信技能。对于想要深入学习网络编程的C#开发者来说，这是一个非常有价值的起点。
c# tcpServer
09-24
利用C#编写的套接字服务端，可以根据实际情况设置自动回复，和手动回复。自动回复内容为受到的内容！
TCP服务器的C#实现
qq_27474555的博客
06-19 2652
TCP服务器的C#实现。
BytesIO | C# 超简洁的TCP服务端开发（完整源码+视频教程）
猿长大人
05-31 3881
本章将继续利用BytesIO开发TCP的服务端，简洁明了依然是主旋律，我们要在三十行代码内除了实现一个TCP服务端以外，使其支持聊天室（消息转发）、连接数限制、心跳超时检测等功能。 现在，一起跟着视频敲一敲吧！【女朋友都能学会】C# TCP服务端Visual Studio已经帮我们完成了大部分工作，真正需要我们手敲的代码不超过30行......
C# TCP/IP 服务端 和 客户端
绀目澄清
10-08 6742
Serve using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Net.Sockets; using System.Net; class TcpIpServerEx { public End...
C# 异步 TCP 服务器完整实现
aijianxie8808的博客
04-14 1082
TCP异步Socket模型 C#的TCP异步Socket模型是通过Begin-End模式实现的。例如提供 BeginConnect、BeginAccept、BeginSend 和 BeginReceive等。 IAsyncResult BeginAccept(AsyncCallback callback, object state); AsyncCallback 回调在函数...
C# TCP服务端客户端简单异步通讯实例（源码）
weiwei_y的博客
10-10 2634
Tcp/ip通讯 socket SocketAsyncEventArgs 高并发tcp通讯 C# 源码
C# TCP多线程服务器示例
weixin_34075268的博客
03-02 514
前言 之前一直很少接触多线程这块。这次项目中刚好用到了网络编程TCP这块，做一个服务端，需要使用到多线程，所以记录下过程。希望可以帮到自己的同时能给别人带来一点点收获～ 关于TCP的介绍就不多讲，神马经典的三次握手、四次握手，可以参考下面几篇博客学习了解： TCP三次握手扫盲 效果预览 客户端是一个门禁设备，主要是向服务端发送实时数据（200ms）。服务...
C# Tcplistener，Tcp服务端，Tcp心跳包服务器简易封装
qq_44695769的博客
12-19 1684
我最近有个需求要写Tcp服务端，我发现Tcp服务端的回调函数比较麻烦，简化Tcp的服务，我打算自己封装一个简单的Tcp服务端。我最近有个Tcp服务端的项目，发现TcpListener 服务端官方写起来很麻烦。而且没有回调函数。现在做个简单的服务端封装。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

匠心码农

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值