编写TCP异步通信组件之AsyncTCPServer

最新推荐文章于 2021-02-16 22:14:18 发布
最新推荐文章于 2021-02-16 22:14:18 发布
阅读量4.9k 收藏 2
点赞数
分类专栏： .NET 文章标签： tcp socket string exception null byte
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/michelsn/article/details/1906511
版权

最近写了两个异步socket组件：
在SocketLibrary里面有两个TCP异步通信组件，分别是:AsyncTCPServer, AsyncTCPClient，同时里面包含测试程序

经过测试，客户端连接达到10000个以上的情况下，通信正常。
如果有什么问题或建议请给我发邮件:michelsn#163.com (请把 # 用 @ 替换掉) 

 

/*
 *
 *      作者：俞伟
 *      时间：2007-11-29
 *      作用：声明AsyncTCPServer类，TCP异步通信服务端
 *      邮件：michelsn@163.com
 *
 * */


using System;
using System.ComponentModel;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
using System.Collections;
using System.Net;
using System.Net.Sockets;
using System.IO;
using System.Threading;

namespace SocketLibrary {
    public partial class AsyncTCPServer : Component {

        #region 构造函数

        public AsyncTCPServer() {
            InitializeComponent();
        }

        public AsyncTCPServer(IContainer container) {
            container.Add(this);

            InitializeComponent();
        }

        #endregion

        #region 私有变量

        private Socket mSocket = null;
        private string keyID = "";
        private bool active = false;
        private ArrayList clientSocketList = new ArrayList();
        private bool IsExit = false;

        #endregion

        #region 变量属性

        /// <summary>
        /// Socket标志
        /// </summary>
        public string KeyID {
            get {
                return keyID;
            }
        }

        /// <summary>
        /// Socket通信状态
        /// </summary>
        public bool Active {
            get {
                return active;
            }
        }

        /// <summary>
        /// 消息的终止判断符
        /// </summary>
        public static string EndChar {
            get {
                return new string((char)0, 1);
            }
        }


        /// <summary>
        /// 客户端管理队列
        /// </summary>
        public ArrayList ClientSocketList {
            get {
                return clientSocketList;
            }
        }

        #endregion

        #region 代理委托

        /// <summary>
        /// Socket异常错误事件
        /// </summary>
        /// <param name="aKeyID">异常错误所有者的标志值</param>
        /// <param name="aErrorMessage">异常错误信息</param>
        public delegate void SocketErrorHandler(string aKeyID, string aErrorMessage);

        /// <summary>
        /// 停止Socket通信之前
        /// </summary>
        /// <param name="aAsyncTCPServer">AsyncTCPServer对象</param>
        public delegate void BeforeStopHandler(AsyncTCPServer aAsyncTCPServer);

        /// <summary>
        /// 停止Socket通信之后
        /// </summary>
        /// <param name="aAsyncTCPServer">AsyncTCPServer</param>
        public delegate void AfterStopHandler(AsyncTCPServer aAsyncTCPServer);

        /// <summary>
        /// 接受新的Socket通信连接请求
        /// </summary>
        /// <param name="aNewSocket">新接受的Socket通信连接对象</param>
        public delegate void AcceptSocketHandler(Socket aNewSocket);

        /// <summary>
        /// 接收二进制数据
        /// </summary>
        /// <param name="aKeyID">接收到数据的Socket标志</param>
        /// <param name="aData">接收到的数据</param>
        /// <param name="aSocket">接收到数据的Socket</param>
        public delegate void BinaryDataAvailableHandler(string aKeyID, byte[] aData, SocketObject aSocketObject);

        /// <summary>
        /// 接收字符串数据
        /// </summary>
        /// <param name="aKeyID">接收到数据的Socket标志</param>
        /// <param name="aData">接收到的数据</param>
        /// <param name="aSocket">接收到数据的Socket</param>
        public delegate void StringDataAvailableHandler(string aKeyID, string aData, SocketObject aSocketObject);

        /// <summary>
        /// 客户端断开连接
        /// </summary>
        /// <param name="aKeyID">客户端对应的Socket标志</param>
        public delegate void CloseClientSocketHandler(string aKeyID);

        #endregion

        #region 事件声明

        public event SocketErrorHandler OnSocketError;
        public event BeforeStopHandler OnBeforeStop;
        public event AfterStopHandler OnAfterStop;
        public event AcceptSocketHandler OnAcceptClientSocket;
        public event BinaryDataAvailableHandler OnBinaryDataAvailable;
        public event StringDataAvailableHandler OnStringDataAvailable;
        public event CloseClientSocketHandler OnCloseClientSocket;

        #endregion

        #region 事件代理方法

        /// <summary>
        /// 显示异常错误信息
        /// </summary>
        /// <param name="aKeyID">异常错误所有者的标志值</param>
        /// <param name="aErrorMessage">异常错误信息</param>
        private void DisplayError(string aKeyID, string aErrorMessage) {
            if (OnSocketError != null) {
                OnSocketError(aKeyID, aErrorMessage);
            }
        }

        /// <summary>
        /// 停止Socket通信之前
        /// </summary>
        /// <param name="aAsyncTCPServer">AsyncTCPServer对象</param>
        private void BeforeStop(AsyncTCPServer aAsyncTCPServer) {
            if (OnBeforeStop != null) {
                OnBeforeStop(aAsyncTCPServer);
            }
        }

        <summary>
        /// 停止Socket通信之后
        /// </summary>
        /// <param name="aAsyncTCPServer">AsyncTCPServer</param>
        private void AfterStop(AsyncTCPServer aAsyncTCPServer) {
            if (OnAfterStop != null) {
                OnAfterStop(aAsyncTCPServer);
            }
        }

        /// <summary>
        /// 接受新的Socket通信连接请求
        /// </summary>
        /// <param name="aNewSocket">新接受的Socket通信连接对象</param>
        public void AcceptClientSocket(Socket aNewSocket) {
            if (OnAcceptClientSocket != null) {
                OnAcceptClientSocket(aNewSocket);
            }
        }

        /// <summary>
        /// 接收二进制数据
        /// </summary>
        /// <param name="aKeyID">接收到数据的Socket标志</param>
        /// <param name="aData">接收到的数据</param>
        /// <param name="aSocket">接收到数据的Socket</param>
        public void BinaryDataAvailable(string aKeyID, byte[] aData, SocketObject aSocketObject) {
            if (OnBinaryDataAvailable != null) {
                OnBinaryDataAvailable(aKeyID, aData, aSocketObject);
            }
        }

        /// <summary>
        /// 接收字符串数据
        /// </summary>
        /// <param name="aKeyID">接收到数据的Socket标志</param>
        /// <param name="aData">接收到的数据</param>
        /// <param name="aSocket">接收到数据的Socket</param>
        public void StringDataAvailable(string aKeyID, string aData, SocketObject aSocketObject) {
            if (OnStringDataAvailable != null) {
                OnStringDataAvailable(aKeyID, aData, aSocketObject);
            }
        }

        /// <summary>
        /// 客户端断开连接
        /// </summary>
        /// <param name="aKeyID">客户端对应的Socket标志</param>
        public void CloseClientSocket(string aKeyID) {
            if (OnCloseClientSocket != null) {
                OnCloseClientSocket(aKeyID);
            }
        }

        #endregion

        #region 内部方法

        /// <summary>
        /// 初始化Socket连接
        /// </summary>
        /// <param name="aLocalIPAddress">本机地址</param>
        /// <param name="aLocalPort">本机端口</param>
        /// <returns>返回操作是否成功</returns>
        private bool InitSocket(string aLocalIPAddress, int aLocalPort) {
            bool bActive = false;
            mSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            LingerOption lo = new LingerOption(false, 10);
            mSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, lo);
            try {
                IPAddress ip = Dns.GetHostAddresses(aLocalIPAddress)[0];
                IPEndPoint ipe = new IPEndPoint(ip, aLocalPort);
                keyID = Guid.NewGuid().ToString();
                mSocket.Bind(ipe);
                bActive = true;
            } catch (Exception ex) {
                bActive = false;
                DisplayError(KeyID, ex.Message);
            }
            return bActive;
        }

        /// <summary>
        /// 监听
        /// </summary>
        /// <param name="aLimitAcceptCount">挂起连接队列的最大长度</param>
        /// <returns>返回操作是否成功</returns>
        private bool Listen(int aLimitAcceptCount) {
            bool bActive = false;
            try {
                if (mSocket != null) {
                    mSocket.Listen(aLimitAcceptCount);
                    //调用异步接收Socket连接请求事件
                    mSocket.BeginAccept(new AsyncCallback(AsyncAcceptSocket), mSocket);
                    bActive = true;
                }
            } catch (Exception ex) {
                bActive = false;
                DisplayError(KeyID, ex.Message);
            }
            return bActive;
        }

        /// <summary>
        /// 主动关闭客户端连接
        /// </summary>
        /// <param name="aSocketObject">客户端对象</param>
        private void CloseClientSocket(SocketObject aSocketObject) {
            try {
                if (aSocketObject.WorkSocket.Connected) {
                    aSocketObject.WorkSocket.Shutdown(SocketShutdown.Both);
                    aSocketObject.WorkSocket.Close();
                    aSocketObject.WorkSocket = null;
                    ClientSocketList.Remove(aSocketObject);
                }
                OnCloseClientSocket(aSocketObject.KeyID);
            } catch (Exception ex) {
                DisplayError(aSocketObject.KeyID, ex.Message);
            }
        }

        /// <summary>
        /// 客户端Socket连接异步接收数据
        /// </summary>
        /// <param name="ar"></param>
        private void AsyncClientSocketReceive(IAsyncResult ar) {
            SocketObject so = (SocketObject)ar.AsyncState;
            try {
                if (so.WorkSocket.Connected) {
                    int iReceiveCount = so.WorkSocket.EndReceive(ar);
                    if (iReceiveCount > 0) {
                        so.sbBuffer.Append(Encoding.UTF8.GetString(so.Buffer, 0, iReceiveCount));
                        string strReceive = so.sbBuffer.ToString();
                        if (strReceive.Substring(strReceive.Length - 1, 1) == EndChar) {
                            //本次接收
                            strReceive = strReceive.Remove(strReceive.Length - 1, 1);
                            //调用外部用户接口方法
                            BinaryDataAvailable(so.KeyID, Encoding.UTF8.GetBytes(strReceive), so);
                            StringDataAvailable(so.KeyID, strReceive, so);
                            //清空数据
                            so.sbBuffer.Remove(0, so.sbBuffer.Length);
                        }
                        if (IsExit == false) {
                            so.WorkSocket.BeginReceive(so.Buffer, 0, so.Buffer.Length, SocketFlags.None, new AsyncCallback(AsyncClientSocketReceive), so);
                        }
                    } else {
                        CloseClientSocket(so);
                    }
                } else {
                    CloseClientSocket(so);
                }
            } catch (Exception ex) {
                //接收数据异常，则关闭该客户端连接
                CloseClientSocket(so);
                DisplayError(so.KeyID, ex.Message);
            }
        }

        /// <summary>
        /// 异步接受Socket连接请求
        /// </summary>
        /// <param name="ar">IAsyncResult接口对象</param>
        private void AsyncAcceptSocket(IAsyncResult ar) {
            Socket sock = (Socket)ar.AsyncState;
            try {
                if (IsExit == false) {
                    Socket handler = sock.EndAccept(ar);
                    AcceptClientSocket(handler);
                    //判断handler是不是被设置为null，如果为null表示连接在执行AcceptSocket过程中用户在OnAcceptSocket中把连接释放掉
                    if (handler != null) {
                        //判断是否保持连接，如果为false，表示连接在执行AcceptSocket过程中用户在OnAcceptSocket中把连接断开掉
                        if (handler.Connected) {
                            SocketObject so = new SocketObject();
                            so.KeyID = Guid.NewGuid().ToString();
                            so.WorkSocket = handler;
                            ClientSocketList.Add(so);
                            if (IsExit == false) {
                                so.WorkSocket.BeginReceive(so.Buffer, 0, so.Buffer.Length, SocketFlags.None, new AsyncCallback(AsyncClientSocketReceive), so);
                            }
                        } else {
                            handler = null;
                        }
                    }
                    if (IsExit == false) {
                        sock.BeginAccept(new AsyncCallback(AsyncAcceptSocket), sock);
                    }
                }
            } catch (Exception ex) {
                //接受连接过程发生异常关闭连接
                Stop();
                DisplayError(KeyID, ex.Message);
            }
        }

        /// <summary>
        /// 通过客户端Socket异步发送消息
        /// </summary>
        /// <param name="ar">IAsyncResult接口对象</param>
        private void AsyncClientSend(IAsyncResult ar) {
            SocketObject so = (SocketObject)ar.AsyncState;
            try {
                int iSendCount = so.WorkSocket.EndSend(ar);
            } catch (Exception ex) {
                DisplayError(so.KeyID, ex.Message);
            }
        }
       
        /// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="aData">要发送的消息</param>
        /// <param name="aSocketObject">接收消息的对象</param>
        private void Send(byte[] aData, SocketObject aSocketObject) {
            try {
                aSocketObject.WorkSocket.BeginSend(aData, 0, aData.Length, SocketFlags.None, new AsyncCallback(AsyncClientSend), aSocketObject);
            } catch (Exception ex) {
                DisplayError(aSocketObject.KeyID, ex.Message);
            }
        }

        #endregion

        #region 开放的接口方法

        /// <summary>
        /// 启动Socket通信
        /// </summary>
        /// <param name="aLocalIPAddress">本机地址</param>
        /// <param name="aLocalPort">本机端口</param>
        /// <param name="aLimitAcceptCount">挂起连接队列的最大长度</param>
        /// <returns>返回操作是否成功</returns>
        public bool Start(string aLocalIPAddress, int aLocalPort, int aLimitAcceptCount) {
            bool bActive = InitSocket(aLocalIPAddress, aLocalPort);
            if (bActive) {
                bActive = Listen(aLimitAcceptCount);
            }
            active = bActive;
            return active;
        }

        /// <summary>
        /// 停止Socket通信
        /// </summary>
        /// <returns>返回操作是否成功</returns>
        public bool Stop() {
            bool bActive = false;
            if (mSocket != null) {
                //之前
                BeforeStop(this);
                try {
                    IsExit = true;
                    Thread.Sleep(10);
                    if (mSocket.Connected) {
                        mSocket.Shutdown(SocketShutdown.Both);
                    }
                    mSocket.Close();
                    mSocket = null;
                    bActive = true;

                } catch (Exception ex) {
                    bActive = false;
                    DisplayError(KeyID, ex.Message);
                }
                active = !bActive;
                //之后
                if (bActive) {
                    AfterStop(this);
                }
            }
            return bActive;
        }

        /// <summary>
        /// 发送消息(异步发送)
        /// </summary>
        /// <param name="aMessage">要发送的消息</param>
        public void Send(string aMessage, SocketObject aSocketObject) {
            string strMessage = aMessage;
            //判断要发送的消息是不是以消息终止判断符号结尾，如果没有则自动加上
            if (strMessage.Substring(strMessage.Length - 1, 1) != EndChar) {
                strMessage = strMessage + EndChar;
            }
            Send(Encoding.UTF8.GetBytes(strMessage), aSocketObject);
        }

        /// <summary>
        /// 发送消息(异步发送)
        /// </summary>
        /// <param name="aMessage">要发送的消息</param>
        public void Send(byte[] aMessage, int aMessageLength, SocketObject aSocketObject) {
            StringBuilder SendBuffer = new StringBuilder();
            SendBuffer.Append(Encoding.UTF8.GetString(aMessage, 0, aMessageLength));
            string strSend = SendBuffer.ToString();
            Send(strSend, aSocketObject);
        }

        /// <summary>
        /// 广播消息
        /// </summary>
        /// <param name="aMessage">要广播的消息</param>
        public void BroadcastMessage(string aMessage) {
            string strMessage = aMessage;
            //判断要发送的消息是不是以消息终止判断符号结尾，如果没有则自动加上
            if (strMessage.Substring(strMessage.Length - 1, 1) != EndChar) {
                strMessage = strMessage + EndChar;
            }
            for (int i = 0; i < ClientSocketList.Count; i++) {
                SocketObject so = (SocketObject)ClientSocketList[i];
                try {
                    Send(Encoding.UTF8.GetBytes(strMessage), so);
                } catch (Exception ex) {
                    DisplayError(so.KeyID, ex.Message);
                }
            }
        }

        #endregion
    }
}

SZ大伟
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
QT socket tcp异步通信
08-16
基于QThread和QTcpScoket进行异步通行封装。
C#网络编程系列文章(三)之TcpListener实现异步TCP服务器
热门推荐
超纯的小白兔
03-14 2万+
原创性声明 本文作者：小竹zz 本文地址http://blog.csdn.net/zhujunxxxxx/article/details/44258719 转载请注明出处 本文介绍 TcpListener 类提供一些简单方法，用于在阻止同步模式下侦听和接受传入连接请求。 可使用 TcpClient 或 Socket 来连接 TcpListener。 可使用 IPEndPoint、本地 IP
C# 高性能 TCP 服务的多种实现方式
aijianxie8808的博客
02-05 530
哎~~ 想想大部分园友应该对"高性能" 字样更感兴趣，为了吸引眼球所以标题中一定要突出，其实我更喜欢的标题是《猴赛雷，C# 编写 TCP 服务的花样姿势！》。 本篇文章的主旨是使用.NET/C# 实现 TCP 高性能服务的不同方式，包括但不限于如下内容： APM 方式，即 Asynchronous Programming Model TAP 方式，即 Task-based ...
C# 异步 TCP 服务器完整实现
newbie的博客
08-25 6529
本文转载连接： https://www.cnblogs.com/gaochundong/archive/2013/04/14/csharp_async_tcp_server.html     TCP异步Socket模型 C#的TCP异步Socket模型是通过Begin-End模式实现的。例如提供 BeginConnect、BeginAccept、BeginSend 和 BeginRecei...
AsyncTcpSocket使用
Dahlin哥's 博客
02-11 1730
AsyncTcpSocket是一个非常好的异步tcp封装类，比较原始的封装，缺少丢包和粘包处理，我在这个实例中把它加上了，我用.net core 3.1 重新编译了AsyncTcpSocket类库，完全可以使用，并用.net core 3.1下的winform搭了一个服务端和客户端，用作Demo，在这里分享一下。
python asyncio tcp server_结合Asyncio Tcp服务器和Tornado Web
weixin_35975197的博客
02-09 472
我有一个asycnio tcp服务器，它连接到5个tcp客户端。在import asyncioclass EchoServerClientProtocol(asyncio.Protocol):def connection_made(self, transport):peername = transport.get_extra_info('peername')print('Connection fr...
TCP异步通信.rar
03-28
自带客户与服务端心跳包验证。 客户端掉线，服务器自动响应。 所有均为事件与封装完全分享。代码高度简洁。 服务端断线与重启，客户端自动重新连接。 客户端消息异常，快速响应事件。 客户端与服务端，调用DOME完全...
CAsyncSocket TCP异步通信程序-VS2010版
08-11
我用VS2010和CAsyncSocket 制作的TCP异步通信对话框程序，并且说明文件中含有制作视频的网址，对初学者有很好的参考价值。
C#实现服务器和客户端之间的TCP异步通信的完整示例源码
02-01
C#实现服务器和客户端之间的TCP异步通信的完整示例源码，消息进行了Des加密和解密。基于.net6.0框架，使用vs2022及以上版本打开。
TCP异步通信试验
07-24
MFC试验例程，Socket异步通信，服务端与客户端选择，交互平台文本字串实时传送。
AsyncTcp 点对点实时通讯，包含服务器、客服端
07-30
C#的TCP异步Socket模型是通过Begin-End模式实现的。例如提供 BeginConnect、BeginAccept、BeginSend 和 BeginReceive等。 IAsyncResult BeginAccept(AsyncCallback callback, object state); AsyncCallback 回调在函数执行完毕后执行。state 对象被用于在执行函数和回调函数间传输信息。
AsyncTcp 正常 2019-7-25.rar
07-29
C# TCP异步通信程序 DLL源码 可以直接调用
使用async关键字进行TCP server的连接
SAP 资深技术专家 Jerry Wang 的技术分享
02-19 607
只是我的学习笔记，记录下来： Orchestra TCPServer.init(“127.0.0.1”,“8081”,‘Orchestra’); // 服务器初始化，监听端口8081 server.on('dataForStatemachine', (data) =&gt; { log.info('Orchestra sends to statemachine group : ' + JSON...
asyncsocket java_Java AsyncServerSocket类代码示例
weixin_36298146的博客
02-16 148
import com.koushikdutta.async.AsyncServerSocket; //导入依赖的package包/类public void testMaxAgePrivate() throws Exception {AsyncHttpClient client = new AsyncHttpClient(AsyncServer.getDefault());ResponseCache...
Socket粘包问题
qq_36356379的博客
06-26 887
前言：最近做安卓端项目需要用到socket和PC端互发指令，但是期间遇到了这么一个现象，就是有时候PC端消息指令发的过快，导致安卓端接收了多条粘在一起的指令，这就是粘包现象。 解析：socket在发送数据的时候会对数据进行粘包和分包处理，这导致我们需要额外处理，虽然看上去没有必要(麻烦、懒得处理)，但是这是socket做的优化。 什么是粘包？ 就是在极短时间内发送了几次很少的数据量，正常是接收端应...
用CocoaAsyncSocket实现TCP(附带demo)
aluoshiyi的博客
01-24 1572
用CocoaAsyncSocket实现TCP(附带demo)
项目总结之TCP/IP Server异步监听及事件扩展
wyx1455249921的博客
11-22 912
项目总结之TCP/IP（一）TCP Server功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 TCP/IP(tran...
c#tcp通信服务器端AsyncTcpServer
最新发布
09-09
你可以使用C#中的异步编程模型来创建一个通信服务器端。下面是一个示例代码，演示了如何使用AsyncTcpServer类来实现： ```csharp using System; using System.Net; using System.Net.Sockets; using System.Text; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值