异步Socket

最新推荐文章于 2024-11-27 17:10:00 发布
最新推荐文章于 2024-11-27 17:10:00 发布
阅读量1.8k 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： .Net 文章标签： buffer byte socket null object sockets
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LeoMaya/article/details/1728518
using System;
using System.Collections.Generic;
using System.Text;
using System.Net.Sockets;
using System.Threading;
using System.Net;

namespace AsyncSocket
{
    public enum SocketState
    {
        ssConnected,
        ssDisconnected,
        ssUnknown
    }

    public interface ISocket
    {
        int SocketID { get;set;}
        int Connect(string host, int port, object tag);
        int Disconnect(int socketID);
        int SendMessage(int socketID, byte[] buffer);
    }

    public abstract class TSocket : ISocket
    {
        public abstract int SocketID { get;set;}

        public virtual int Connect(string host, int port, object tag) { return -1; }

        public virtual int Disconnect(int socketID) { return -1; }

        public virtual int SendMessage(int socketID, byte[] buffer) { return -1; }
    }

    public class SocketVendor : TSocket
    {
        public event ConnectionEventHandler OnSocketConnected;
        public event ConnectionEventHandler OnSocketDisconneted;
        public event SocketReceivedEventHandler OnSocketReceived;

        protected ManualResetEvent stopEvent;
        protected AutoResetEvent dataReady;

        protected Queue<byte[]> transmitQ;
        protected Queue<byte[]> receivedQ;

        protected ReaderWriterLock transmitLock;

        protected Socket socket;

        protected SocketState socketState = SocketState.ssUnknown;
        public SocketState State { get { return socketState; } }

        public bool Connected { get { return socket == null ? false : socket.Connected; } }

        private static int currentSessionID;
        protected int socketID;
        public override int SocketID
        {
            get { return socketID; }
            set { socketID = value; }
        }

        protected int timeout;
        public int Timeout { get { return timeout; } }

        public SocketVendor(int timeout)
        {
            this.timeout = timeout;

            stopEvent = new ManualResetEvent(false);
            dataReady = new AutoResetEvent(false);

            transmitQ = new Queue<byte[]>();
            receivedQ = new Queue<byte[]>();

            transmitLock = new ReaderWriterLock();

            currentSessionID++;
            socketID = currentSessionID;
        }

        public override int Connect(string host, int port, object tag)
        {
            if (Connected) return -1;

            stopEvent.Reset();

            IPHostEntry hostEntry = Dns.GetHostEntry(host);
            if (hostEntry != null)
            {
                IPEndPoint remoteEP = new IPEndPoint(hostEntry.AddressList[0], port);

                socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                try
                {
                    socket.Connect(remoteEP);
                    socketState = SocketState.ssConnected;
                    if (OnSocketConnected != null)
                    {
                        ConnectionEventArgs e = new ConnectionEventArgs(SocketID, Connected, State);
                        OnSocketConnected(this, e);
                    }
                }
                catch (Exception exx)
                {
                    socketState = SocketState.ssDisconnected;
                    System.Diagnostics.Trace.WriteLine("============Exception Occured while doing the Socket Connection============ " + exx.Message);
                    if (OnSocketConnected != null)
                    {
                        ConnectionEventArgs e = new ConnectionEventArgs(SocketID, Connected, State);
                        OnSocketConnected(this, e);
                    }

                    return -1;
                }

                ThreadPool.QueueUserWorkItem(new WaitCallback(ReceiveEntryPoint));
                ThreadPool.QueueUserWorkItem(new WaitCallback(SendEntryPoint));

                return SocketID;
            }
            else
            {
                return -1;
            }
        }

        public override int Disconnect(int socketID)
        {
            if (Connected)
            {
                socketState = SocketState.ssDisconnected;
                stopEvent.Set();
                if (socket != null)
                {
                    socket.Disconnect(false);
                }

                if (OnSocketDisconneted != null)
                {
                    ConnectionEventArgs e = new ConnectionEventArgs(socketID, Connected, State);
                    OnSocketDisconneted(this, e);
                }

                return socketID;
            }
            else
            {
                return -1;
            }
        }

        public override int SendMessage(int socketID, byte[] buffer)
        {
            transmitLock.AcquireWriterLock(-1);
            try
            {
                transmitQ.Enqueue(buffer);
            }
            catch (Exception e)
            {
                System.Diagnostics.Trace.WriteLine("============Exception Occured while doing the Socekt Send Message============ " + e.Message);
                return -1;
            }
            finally
            {
                transmitLock.ReleaseWriterLock();
            }

            dataReady.Set();
            return socketID;
        }

        public int SendMessage(int socketID, string msg)
        {
            byte[] buffer = Encoding.Default.GetBytes(msg);
            return SendMessage(socketID, buffer);
        }

        private void ReceiveEntryPoint(object state)
        {
            try
            {
                while (true)
                {
                    WaitHandle[] handles = new WaitHandle[1];
                    handles[0] = stopEvent;

                    if (socket != null && Connected)
                    {
                        try
                        {
                            SocketStateObject sso = new SocketStateObject(socket);
                            IAsyncResult iar = socket.BeginReceive(sso.Buffer, 0, SocketStateObject.BUFFER_SIZE, 0, new AsyncCallback(AsyncReceiveCallback), sso);

                            //if StopEvent Signaled, break
                            if (WaitHandle.WaitAny(handles) == 0) break;
                        }
                        catch { }
                    }
                }
            }
            catch (Exception e)
            {
                System.Diagnostics.Trace.WriteLine("============Exception Occured while doing the Receive Message from Socket============ " + e.Message);
            }
        }

        private void AsyncReceiveCallback(IAsyncResult iar)
        {
            SocketStateObject sso = (SocketStateObject)iar.AsyncState;
            Socket s = sso.WorkSocket;

            try
            {
                if (s == null || !s.Connected) return;
                int read = s.EndReceive(iar);
                if (read > 0)
                {
                    try
                    {
                        if (OnSocketReceived != null)
                        {
                            SocketReceivedEventArgs e = new SocketReceivedEventArgs(socketID, s.Connected, State, sso.Buffer);
                            OnSocketReceived(this, e);
                        }
                    }
                    catch (Exception exx)
                    {
                        System.Diagnostics.Trace.WriteLine("============Exception Occured while Receive Callback Asynchronous============ " + exx.Message);
                    }

                    s.BeginReceive(sso.Buffer, 0, SocketStateObject.BUFFER_SIZE, 0, new AsyncCallback(AsyncReceiveCallback), sso);
                }
                //else
                //{
                //    if (OnSocketDisconneted != null)
                //    {
                //        socketState = SocketState.ssDisconnected;
                //        ConnectionEventArgs e = new ConnectionEventArgs(socketID, s.Connected, State);
                //        OnSocketDisconneted(this, e);
                //    }
                //}
            }
            catch (Exception exx)
            {
                System.Diagnostics.Trace.WriteLine("============Exception Occured while Receive Callback Asynchronous============ " + exx.Message);
                if (OnSocketDisconneted != null)
                {
                    socketState = SocketState.ssDisconnected;
                    ConnectionEventArgs e = new ConnectionEventArgs(socketID, s.Connected, State);
                    OnSocketDisconneted(this, e);
                }
            }
        }

        private void SendEntryPoint(object state)
        {
            try
            {
                Queue<byte[]> workQ = new Queue<byte[]>();

                while (true)
                {
                    WaitHandle[] handles = new WaitHandle[2];
                    handles[0] = stopEvent;
                    handles[1] = dataReady;

                    //if StopEvent Signaled, break
                    if (WaitHandle.WaitAny(handles) == 0) break;
                    else if (socket != null && Connected)
                    {
                        transmitLock.AcquireWriterLock(-1);
                        try
                        {
                            workQ.Clear();
                            foreach (byte[] bytes in transmitQ) workQ.Enqueue(bytes);
                            transmitQ.Clear();
                        }
                        catch { }
                        finally
                        {
                            transmitLock.ReleaseWriterLock();
                        }

                        foreach (byte[] bytes in workQ)
                        {
                            SocketStateObject sso = new SocketStateObject(socket);
                            socket.BeginSend(bytes, 0, bytes.Length, SocketFlags.None, new AsyncCallback(AsyncSendCallback), sso);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                System.Diagnostics.Trace.WriteLine("============Exception Occured while doing the Send Message============ " + e.Message);
            }
        }

        private void AsyncSendCallback(IAsyncResult iar)
        {
            SocketStateObject sso = (SocketStateObject)iar.AsyncState;
            Socket s = sso.WorkSocket;

            try
            {
                if (s == null || !s.Connected) return;
                s.EndSend(iar);
            }
            catch (Exception e)
            {
                System.Diagnostics.Trace.WriteLine("============Exception Occured while Handling Send Callback Asynchronous============ " + e.Message);
            }
        }
    }

    public class SocketStateObject
    {
        protected Socket workSocket;
        protected StringBuilder items;
        protected byte[] buffer;
        protected bool completed;

        public const int BUFFER_SIZE = 1024;

        public SocketStateObject(Socket socket)
        {
            workSocket = socket;
            buffer = new byte[BUFFER_SIZE];
            completed = false;
        }
        /// <summary>
        /// Gets the current Socket
        /// </summary>
        public Socket WorkSocket { get { return workSocket; } }
        /// <summary>
        /// Gets or Sets the return message
        /// </summary>
        public StringBuilder Items { get { return items; } set { items = value; } }
        /// <summary>
        /// Gets or Sets the return buffer
        /// </summary>
        public byte[] Buffer { get { return buffer; } set { buffer = value; } }
        /// <summary>
        /// Gets or Sets the flag to indicate whether the current socket has completed or not
        /// </summary>
        public bool Completed { get { return completed; } set { completed = value; } }
    }

    public class ConnectionEventArgs : EventArgs
    {
        protected int socketID;
        public int SocketID { get { return socketID; } }

        protected bool connected;
        public bool Connected { get { return connected; } }

        protected SocketState socketState;
        public SocketState State { get { return socketState; } }

        public ConnectionEventArgs(int socketID, bool connected, SocketState socketState)
        {
            this.socketID = socketID;
            this.connected = connected;
            this.socketState = socketState;
        }
    }

    public class SocketReceivedEventArgs : ConnectionEventArgs
    {
        protected byte[] buffer;
        public byte[] Buffer { get { return buffer; } }

        public SocketReceivedEventArgs(int socketID, bool connected, SocketState socketState, byte[] buffer)
            : base(socketID, connected, socketState)
        {
            this.buffer = buffer;
        }
    }

    public delegate void ConnectionEventHandler(object sender, ConnectionEventArgs e);
    public delegate void SocketReceivedEventHandler(object sender,SocketReceivedEventArgs e);
}
 
C#使用SocketAsyncEventArgs实现Socket客户端通信
q1143910315的博客
05-12 3360
用System.Net.Sockets.Socket类实现tcp通信并不简单，需要大量代码去实现，但其接近底层而可以发挥更高的效率，本文的目标是实现高性能的套接字客户端，否则没有使用Socket的必要，而应该使用更为简单易用的System.Net.Sockets.TcpClient 首先是参考资料，第一当然是微软的文档（https://docs.microsoft.com/zh-cn/dotnet/api/system.net.sockets.socket?view=netcore-3.1），其次是其他人
touchSocket
ccvah的博客
03-07 660
TOUCHSOCKET
【亲测免费】 TouchSocket 使用教程
gitblog_00263的博客
08-10 1580
TouchSocket 使用教程 项目介绍 TouchSocket 是一个整合性的、超轻量级的网络通信框架，支持多种通信协议，包括 TCP、UDP、SSL、HTTP、WebSocket、RPC、JSON-RPC、Web API、XML-RPC 等。它能够一键式解决 TCP 黏分包问题和 UDP 大数据包分片组合问题，使用协议模板可快速实现「固定包头」、「固定长度」、「区间字符」等一系列的数据报文解...
超轻量级、支持插件的 .NET 网络通信框架
DotNet技术匠
09-09 1742
给大家推荐一个轻量级的、支持插件的综合网络通信库：TouchSocket。TouchSocket 的基础通信功能包括 TCP、UDP、SSL、RPC 和 HTTP。其中，HTTP 服务器支持 WebSocket、静态网页、XML-RPC、WebAPI 和 JSON-RPC 等扩展插件。此外，TouchSocket 还支持自定义协议的 TouchRPC，具备 SSL 加密、异步调用、权限管理、错误状态返回、服务回调和分布式调用等功能。在空载函数执行时，10 万次调用仅需 3.8 秒；在不返回状态时
用于表示socket的结构体
heal the world
09-26 950
文章转载自：http://hi.baidu.com/linux_kernel/blog/item/5c8510dfb2348613622798e5.html 用户使用socket系统调用编写应用程序时，通过一个数字来表示一个socket，所有的操作都在该数字上进行，这个数字称为
解决QTcpSocket state总是连接状态，即使把网线拔了
exlink2012的专栏
09-15 1631
解决QTcpSocket state总是连接状态，即使把网线拔了
C#中一个高性能异步socket封装库的实现思路分享
01-20
我搜集了大量资料，完成了对异步socket的封装。此库已用稳定高效的运行几个月。 纵观网上的资料，我还没有遇到一个满意的封装库。许多文章把数据收发和协议处理杂糅在一块，代码非常难懂，也无法扩展。 在
C#实现异步Socket通信 -客户端
07-12
本教程将深入讲解如何使用C#实现异步Socket通信的客户端部分。 首先，我们要理解Socket的基本概念。Socket是网络通信中的一个端点，它允许应用程序通过网络发送和接收数据。在C#中，我们可以使用`System.Net....
TCP_UDP.rar_TCP_UDP_TCP异步_socket 异步_udp socket_异步 socket
09-22
本压缩包文件"TCP_UDP.rar"聚焦于TCP与UDP的异步Socket编程，这在构建高性能、高并发的网络应用时尤为重要。 TCP是一种面向连接的协议，它提供了可靠的、全双工的数据传输服务。TCP通过建立连接来确保数据的顺序...
TCPS.rar_Socket异步服务_TCP CSharp _socket_socket异步通信_异步socket
09-22
3. **异步Socket通信**：在处理大量并发连接时，异步Socket通信比同步通信更有效。异步Socket允许服务器在等待数据到达的同时执行其他任务，提高了程序的效率和响应性。C#中的`BeginAccept`, `BeginReceive`, `...
Qt文档阅读笔记-QSslSocket中与错误相关的信号
IT1995的博客
08-30 5008
目录 基本概念 代码与实例 基本概念 放代码前先来看这个信号： [signal] void QAbstractSocket::stateChanged(QAbstractSocket::SocketState socketState) 当socket状态改变后就会触发这个信息，其中socketState参数为当前socket的状态。 这里要注意的是QAbstract...
socket详解
weixin_43754520的博客
09-09 438
socket细节实现
Qt网络编程：QAbstractSocket
热门推荐
友善啊，朋友的博客
06-19 1万+
一、描述 QAbstractSocket 类提供所有Socket类型通用的基本功能。 QAbstractSocket 是 QTcpSocket 和 QUdpSocket 的基类，包含这两个类的所有通用功能。 如果您需要一个Socket，可以： 子类化 QTcpSocket 或QUdpSocket。 创建一个原生Socket，实例化QAbstractSocket，并调用setSocketDescriptor()来包装原生Socket。 TCP（传输控制协议）是一种可靠的、面向流的、面向连接的传输协.
Tomcat7中一次请求处理的前世今生（二）Socket连接转换成内部请求对象
预流
08-28 288
先抛开之前所看到的Tomcat源码不谈，Tomcat作为一个用Java实现的Web服务器，如果让你来实现，那么从何入手？ 这里首先需要厘清的是Web服务器的概念，谷歌了一下，发现这条解释还算靠谱点，【在网络环境下可以向发出请求的浏览器提供文档的程序】。这里面重点有两条，1.网络环境下，2.能够给出响应。用Java写过网络通信程序的都知道，这里必然会用到Socket编程。我们自己要实现的服务器...
简单的TCPSocket客户端使用案例（已入OPCommon）
最新发布
weixin_40029679的博客
11-27 437
做一个实体操作工具类（包含）然后简单的使用方法就是。
本地进程间通信（二）--套接字socket
银冰冷月--学习笔记Blog
12-23 9971
一、什么是Socket？　 套接字除了可以实现网络间不同主机间的通信外，还可以实现同一主机的不同进程间的通信，且建立的通信是双向的通信。本文主要介绍本地进程间socket通信。 我们知道两个进程如果需要进行通讯最基本的一个前提能能够唯一的标示一个进程，在本地进程通讯中我们可以使用PID来唯一标示一个进程，但PID只在本地唯一，网络中的两个进程PID冲突几率很大，这时候我们需要另辟它径了，我们知道IP层的ip地址可以唯一标示主机，而TCP层协议和端口号可以唯一标示主机的一个进程，这样我们可以利用ip地址＋
C#异步SOCKET通信源码实现
- 利用.NET Framework 4.5之后提供的`SocketAsyncEventArgs`类，该类提供了一种面向对象的方式来处理异步SOCKET操作，简化了事件处理和数据包的管理。 ### 知识点六：独立类的设计与使用 在软件开发中，独立类是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值