C# iocp通讯客户端只能发送数据，无法接收服务端发送的数据

最新推荐文章于 2024-07-05 18:38:29 发布
最新推荐文章于 2024-07-05 18:38:29 发布
阅读量2.4k 收藏 2
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xwnxwn/article/details/9625195
版权 

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

namespace IOCP
{
    ///
    /// MyTcpIpClient 提供在Net TCP_IP 协议上基于消息的服务端
    ///
    public class MyTcpIpServer : System.ComponentModel.Component
    {
        private int bufferSize = 2048;
        private string tcpIpServerIP = "";
        private int tcpIpServerPort = 8808;
        private Socket listener = null;
        private ManualResetEvent allDone = new ManualResetEvent(false);
        private ManualResetEvent sendDone = new ManualResetEvent(false);
        private Thread thread = null;

        private void StartListening()
        {
            try
            {
                listener = new Socket(AddressFamily.InterNetwork,
                 SocketType.Stream, ProtocolType.Tcp);

                IPAddress ipAddress;
                if (tcpIpServerIP.Trim() == "")
                {
                    ipAddress = IPAddress.Any;
                }
                else
                {
                    ipAddress = IPAddress.Parse(tcpIpServerIP);
                }
                IPEndPoint localEndPoint = new IPEndPoint(ipAddress, tcpIpServerPort);

                listener.Bind(localEndPoint);
                listener.Listen(100000);
                while (true)
                {
                    allDone.Reset();
                    listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);
                    allDone.WaitOne();
                }
            }
            catch (Exception e)
            {
                OnErrorServerEvent(new ErrorServerEventArgs(e, listener));
            }
        }

        private void ReadCallback(IAsyncResult ar)
        {
            Socket handler = null;
            try
            {
                lock (ar)
                {
                    StateObject state = (StateObject)ar.AsyncState;
                    handler = state.workSocket;

                    int bytesRead = handler.EndReceive(ar);

                    if (bytesRead > 0)
                    {
                        Console.WriteLine(Encoding.UTF8.GetString(state.buffer, 0, bytesRead));


                        byte[] arrb = Encoding.UTF8.GetBytes("ffffffffffffffffffffff");
                        Stream sr = new MemoryStream(arrb);
                        //Send(handler, sr);

                        int ReadPiont = 0;
                        while (ReadPiont < bytesRead)
                        {
                            if (state.Cortrol == 0 && ReadPiont < bytesRead)
                            {
                                long bi1 = state.buffer[ReadPiont];
                                bi1 = (bi1 << 24) & 0xff000000;
                                state.packSize = bi1;
                                ReadPiont++;
                                state.Cortrol = 1;
                            }

                            if (state.Cortrol == 1 && ReadPiont < bytesRead)
                            {
                                long bi1 = state.buffer[ReadPiont];
                                bi1 = (bi1 << 16) & 0x00ff0000;
                                state.packSize = state.packSize + bi1;
                                ReadPiont++;
                                state.Cortrol = 2;
                            }

                            if (state.Cortrol == 2 && ReadPiont < bytesRead)
                            {
                                long bi1 = state.buffer[ReadPiont];
                                bi1 = (bi1 << 8) & 0x0000ff00;
                                state.packSize = state.packSize + bi1;
                                ReadPiont++;
                                state.Cortrol = 3;
                            }

                            if (state.Cortrol == 3 && ReadPiont < bytesRead)
                            {
                                long bi1 = state.buffer[ReadPiont];
                                bi1 = bi1 & 0xff;
                                state.packSize = state.packSize + bi1 - 4;
                                ReadPiont++;
                                state.Cortrol = 4;
                            }

                            if (state.Cortrol == 4 && ReadPiont < bytesRead)
                            {
                                long bi1 = state.buffer[ReadPiont];
                                bi1 = (bi1 << 24) & 0xff000000;
                                state.residualSize = bi1;
                                ReadPiont++;
                                state.Cortrol = 5;
                                state.packSize -= 1;
                            }

                            if (state.Cortrol == 5 && ReadPiont < bytesRead)
                            {
                                long bi1 = state.buffer[ReadPiont];
                                bi1 = (bi1 << 16) & 0x00ff0000;
                                state.residualSize = state.residualSize + bi1;
                                ReadPiont++;
                                state.Cortrol = 6;
                                state.packSize -= 1;
                            }

                            if (state.Cortrol == 6 && ReadPiont < bytesRead)
                            {
                                long bi1 = state.buffer[ReadPiont];
                                bi1 = (bi1 << 8) & 0x0000ff00;
                                state.residualSize = state.residualSize + bi1;
                                ReadPiont++;
                                state.Cortrol = 7;
                                state.packSize -= 1;
                            }
                            if (state.Cortrol == 7 && ReadPiont < bytesRead)
                            {
                                long bi1 = state.buffer[ReadPiont];
                                bi1 = bi1 & 0xff;
                                state.residualSize = state.residualSize + bi1;
                                state.Datastream.SetLength(0);
                                state.Datastream.Position = 0;

                                ReadPiont++;
                                state.Cortrol = 8;
                                state.packSize -= 1;
                            }

                            if (state.Cortrol == 8 && ReadPiont < bytesRead)
                            {
                                int bi1 = bytesRead - ReadPiont;
                                int bi2 = (int)(state.residualSize - state.Datastream.Length);
                                if (bi1 >= bi2)
                                {
                                    state.Datastream.Write(state.buffer, ReadPiont, bi2);
                                    ReadPiont += bi2;
                                    OnInceptServerEvent(new InceptServerEventArgs(state.Datastream, state.workSocket, this));
                                    state.Cortrol = 9;
                                    state.packSize -= bi2;


                                }
                                else
                                {
                                    state.Datastream.Write(state.buffer, ReadPiont, bi1);
                                    ReadPiont += bi1;
                                    state.packSize -= bi1;
                                }
                            }
                            if (state.Cortrol == 9 && ReadPiont < bytesRead)
                            {
                                int bi1 = bytesRead - ReadPiont;
                                if (bi1 != 0)
                                {
                                    state.packSize = state.packSize - bi1;
                                    ReadPiont += bi1;
                                }
                                else
                                {
                                    state.Cortrol = 0;
                                    ReadPiont += (int)state.packSize;
                                }
                            }
                        }
                        if (handler.Connected == true)
                        {
                            handler.BeginReceive(state.buffer, 0, bufferSize, 0,
                             new AsyncCallback(ReadCallback), state);
                        }
                    }
                    else
                    {
                        handler.Shutdown(SocketShutdown.Both);
                        handler.Close();
                        //throw(new Exception("读入的数据小于1bit"));
                    }
                }
            }
            catch (Exception e)
            {
                OnErrorServerEvent(new ErrorServerEventArgs(e, handler));

            }
        }

        private void SendCallback(IAsyncResult ar)
        {
            Socket client = (Socket)ar.AsyncState;
            try
            {
                int bytesSent = client.EndSend(ar);
            }
            catch (Exception e)
            {
                OnErrorServerEvent(new ErrorServerEventArgs(e, client));
            }
            finally
            {
                sendDone.Set();
            }
        }

        private void AcceptCallback(IAsyncResult ar)
        {
            Socket handler = null;
            try
            {
                Socket listener = (Socket)ar.AsyncState;
                handler = listener.EndAccept(ar);
                StateObject state = new StateObject(bufferSize, handler);
                state.workSocket = handler;
                handler.BeginReceive(state.buffer, 0, bufferSize, 0,
                 new AsyncCallback(ReadCallback), state);
            }
            catch (Exception e)
            {
                OnErrorServerEvent(new ErrorServerEventArgs(e, handler));
            }
            finally
            {
                allDone.Set();
            }
        }

        ///
        /// 析构
        ///
        /// 不知道
        protected override void Dispose(bool disposing)
        {
            Abort();
        }

        ///
        /// 引发接收事件
        ///
        /// 数据
        protected virtual void OnInceptServerEvent(InceptServerEventArgs e)
        {
            if (InceptServer != null)
            {
                InceptServer(this, e);
            }
        }
        ///
        /// 引发错误事件
        ///
        /// 数据
        protected virtual void OnErrorServerEvent(ErrorServerEventArgs e)
        {
            if (ErrorServer != null)
            {
                ErrorServer(this, e);
            }
        }

        ///
        /// 开始监听访问
        ///
        public void Listening()
        {
            //StartListening();
            thread = new Thread(new ThreadStart(StartListening));
            thread.Name = "MyTcpIpServer.Listening";
            thread.Start();
        }
        ///
        /// 异常中止服务
        ///
        public void Abort()
        {
            if (thread != null)
            {
                thread.Abort();
                listener.Close();
            }
        }

        ///
        ///构造
        ///
        /// 父控件
        public MyTcpIpServer(System.ComponentModel.IContainer container)
        {
            container.Add(this);
            InitializeComponent();

            //
            // TODO: 在 InitializeComponent 调用后添加任何构造函数代码
            //
        }

        ///
        /// 构造
        ///
        public MyTcpIpServer()
        {
            InitializeComponent();

            //
            // TODO: 在 InitializeComponent 调用后添加任何构造函数代码
            //
        }

        #region Component Designer generated code
        ///
        /// 设计器支持所需的方法 - 不要使用代码编辑器修改
        /// 此方法的内容。
        ///
        private void InitializeComponent()
        {

        }
        #endregion

        ///
        /// 要连接的服务器IP地址
        ///
        public string TcpIpServerIP
        {
            get
            {
                return tcpIpServerIP;
            }
            set
            {
                tcpIpServerIP = value;
            }
        }

        ///
        /// 要连接的服务器所使用的端口
        ///
        public int TcpIpServerPort
        {
            get
            {
                return tcpIpServerPort;
            }
            set
            {
                tcpIpServerPort = value;
            }
        }

        ///
        /// 缓冲器大小
        ///
        public int BufferSize
        {
            get
            {
                return bufferSize;
            }
            set
            {
                bufferSize = value;
            }
        }

        ///
        /// 连接的活动状态
        ///
        public bool Activ
        {
            get
            {
                return listener.Connected;
            }
            //set
            //{
            // activ=value;
            //}
        }

        ///
        /// 发送一个流数据
        ///
        public void Send(Socket ClientSocket, Stream Astream)
        {
            try
            {
                if (ClientSocket.Connected == false)
                {
                    throw (new Exception("没有连接客户端不可以发送信息!"));
                }
                Astream.Position = 0;
                byte[] byteData = new byte[bufferSize];
                int bi1 = (int)((Astream.Length + 8) / bufferSize);
                int bi2 = (int)Astream.Length;
                if (((Astream.Length + 8) % bufferSize) > 0)
                {
                    bi1 = bi1 + 1;
                }
                bi1 = bi1 * bufferSize;

                byteData[0] = System.Convert.ToByte(bi1 >> 24);
                byteData[1] = System.Convert.ToByte((bi1 & 0x00ff0000) >> 16);
                byteData[2] = System.Convert.ToByte((bi1 & 0x0000ff00) >> 8);
                byteData[3] = System.Convert.ToByte((bi1 & 0x000000ff));

                byteData[4] = System.Convert.ToByte(bi2 >> 24);
                byteData[5] = System.Convert.ToByte((bi2 & 0x00ff0000) >> 16);
                byteData[6] = System.Convert.ToByte((bi2 & 0x0000ff00) >> 8);
                byteData[7] = System.Convert.ToByte((bi2 & 0x000000ff));

                int n = Astream.Read(byteData, 8, byteData.Length - 8);

                while (n > 0)
                {
                    ClientSocket.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), ClientSocket);
                    sendDone.WaitOne();
                    byteData = new byte[bufferSize];
                    n = Astream.Read(byteData, 0, byteData.Length);
                }
            }
            catch (Exception e)
            {
                OnErrorServerEvent(new ErrorServerEventArgs(e, ClientSocket));
            }
        }

        ///
        /// 接收到数据事件
        ///
        public event InceptServerEvent InceptServer;
        ///
        /// 发生错误事件
        ///
        public event ErrorServerEvent ErrorServer;
    }
    ///
    /// 状态对象
    ///
    public class StateObject
    {
        ///
        /// 构造
        ///
        /// 缓存
        /// 工作的插座
        public StateObject(int bufferSize, Socket WorkSocket)
        {
            buffer = new byte[bufferSize];
            workSocket = WorkSocket;
        }
        ///
        /// 缓存
        ///
        public byte[] buffer = null;
        ///
        /// 工作插座
        ///
        public Socket workSocket = null;
        ///
        /// 数据流
        ///
        public Stream Datastream = new MemoryStream();
        ///
        /// 剩余大小
        ///
        public long residualSize = 0;
        ///
        /// 数据包大小
        ///
        public long packSize = 0;
        ///
        /// 计数器
        ///
        public int Cortrol = 0;
    }

    ///
    /// 接收事件
    ///
    public class InceptServerEventArgs : EventArgs
    {
        private readonly Stream datastream;
        private readonly Socket serverSocket;
        private readonly MyTcpIpServer tcpIpServer;
        ///
        /// 构造
        ///
        /// 数据
        /// 工作插座
        /// 提供服务的TCP/IP对象
        public InceptServerEventArgs(Stream Astream, Socket ServerSocket, MyTcpIpServer TcpIpServer)
        {
            datastream = Astream;
            serverSocket = ServerSocket;
            tcpIpServer = TcpIpServer;
        }
        ///
        /// 数据
        ///
        public Stream Astream
        {
            get { return datastream; }
        }
        ///
        /// 工作插座
        ///
        public Socket ServerSocket
        {
            get { return serverSocket; }
        }
        ///
        /// 提供TCP/IP服务的服务器对象.
        ///
        public MyTcpIpServer TcpIpServer
        {
            get { return tcpIpServer; }
        }
    }
    ///
    /// 接收数据委托
    ///
    public delegate void InceptServerEvent(object sender, InceptServerEventArgs e);
    ///
    /// 错误事件委托
    ///
    public class ErrorServerEventArgs : EventArgs
    {
        private readonly Exception error;
        private readonly Socket serverSocket;
        ///
        /// 构造
        ///
        /// 数据
        /// 问题插座
        public ErrorServerEventArgs(Exception Error, Socket ServerSocket)
        {
            error = Error;
            serverSocket = ServerSocket;
        }
        ///
        /// 数据
        ///
        public Exception Error
        {
            get { return error; }
        }
        ///
        /// 问题插座
        ///
        public Socket ServerSocket
        {
            get { return serverSocket; }
        }
    }
    ///
    ///错误事件委托
    ///
    public delegate void ErrorServerEvent(object sender, ErrorServerEventArgs e);
}



客户端代码：





using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Net;
using System.Threading;


namespace ClientSocket
{
    class Program
    {
        //创建一个数据缓冲区
        private static byte[] m_DataBuffer = new byte[2048];
        static void Main(string[] args)
        {
            IPHostEntry ipHost = Dns.Resolve(Dns.GetHostName());
            IPAddress ip = ipHost.AddressList[0];
            Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
          
            try
            {
                client.Connect(new IPEndPoint(ip, 8088));
                Console.WriteLine("连接server成功!");
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return;
            }
            //client接收数据


     //       int receiveLength = 0;
      //      try
      //      {
      //        receiveLength = client.Receive(m_DataBuffer);
      //      }
      //      catch (System.Exception ex)
      //      {
      //        string ss=  ex.Message;
      //      }
     
      //Console.WriteLine("接受server消息"+ Encoding.UTF8.GetString(m_DataBuffer, 0, receiveLength));
            //client发送数据
            int receiveLength = 0;
            for (int i = 0; i < 1000; i++)
            {
             [b]   try
                {
                //*   、、*/ Thread.Sleep(1000);
                     
                    string msg = "Server你好！"+DateTime.Now.ToString();
                    client.Send(Encoding.UTF8.GetBytes(msg));
                    Console.WriteLine("发送的消息为：{0}", msg);


                    try
                    {
                        m_DataBuffer = new byte[2048];
                        receiveLength = client.Receive(m_DataBuffer);
                    }
                    catch (System.Exception ex)
                    {
                        string ss = ex.Message;
                    }


                    Console.WriteLine("接受的消息:" + Encoding.UTF8.GetString(m_DataBuffer, 0, receiveLength));
                }
                catch
                {
                    client.Shutdown(SocketShutdown.Both);
                    client.Close();
                    break;
                }
            }[/b]
            Console.WriteLine("发送完毕！");
            //发送完消息后关闭连接
            client.Shutdown(SocketShutdown.Both);
            client.Close();
            Console.Read();
        }
    }
}

海蓝树
关注
c#写的iocp服务端和客户端代码
07-09
用c#语言写的iocp网络服务，和客户端，有注释，程序可直接运行
C# IOCP高性能 SOCKET并发完成端口例子（有C#客户端）完整实例源码
06-21
运用SocketAsyncEventArgs实现广域网客户端和服务端互发消息，用于学习IOCP开发
c# IOCP.ClientEx2.ReadWrite 加断点遭遇System.AccessViolationException 问题
weixin_30299539的博客
11-29 58
起因: 如果在Debug模式下，在IOCP.ClientEx2.ReadWrite.cs while (0 > (nPackSize = _ipcp.Pack(arg_n64PackId, arg_n64RemotePackId, _saeaSend.Buffer, 0, _saeaSend.Buffer.Length, arg_objsWrite, out eoPack)) &...
C#物联网平台服务器框架源码。 这套带码是通过C#编写集成IOCP高性能高并发优势服务器
最新发布
yTxroTQk的博客
07-05 1334
3、系统目前支持modbus 、modbus rtu协议,可定制开发集成Modbus TCp、西门子PLC S7协议、OPC协议、三菱PLC协议以及集成MQTT服务（以上协议在框架中没有集成，可以定制集成）。WEB API功能有服务器日志查询、WEB API接口认证用户管理、远端设备注册管理、服务器轮询读取任务启停、服务器参数设置、查询历史数据记录、下发指令到终端设备。5、与传统协议方法不同，比如Modbus设备，需要PC端主动去连接设备，而这套框架只需要监听端口，服务器就能自动去轮询终端所有设备。
Client IOCP.zip
12-25
C# iocp IO模型C# iocp IO模型C# iocp IO模型C# iocp IO模型C# iocp IO模型C# iocp IO模型C# iocp IO模型C# iocp IO模型C# iocp IO模型
C# 基于UDP、socket的IOCP
11-07
基于C#的UDP，IOCP的封装库，附带零碎内存管理模块，针对解决UDP没有异步接口和处理高并发的情况，类库接口开放，允许回调Socket处理数据后的一系列自定义接口，而且是自动回调，可能还会有很多地方不完善，欢迎提出
C# IOCP通讯封装透传的，需要自己做分包处理
12-02
在“透传”通信模式下，数据会被原封不动地从客户端传输到服务端，反之亦然。为了实现透传，我们需要确保在接收到数据时，正确地处理数据包的边界，这通常涉及到分包和重组包的过程。由于TCP是流式协议，它不保证...
基于SocketAsyncEventArgs(IOCP)的高性能TCP服务器实现（二）——服务端信息接收窗体实现（C#）
09-26
2. `SocketAsyncEventArgs`集合：每个客户端连接对应一个实例，用于异步接收和发送数据。 3. 事件处理器：当数据接收到时，事件处理器会被调用，处理接收到的数据，并更新Windows窗体界面。 4. 窗体事件：例如，可能...
C#收发二进制数据比如图片，声音、文件、视频等基于流的tcp协议socket服务端和客户端
09-02
C#开发的Socket通信源码。包含客户端和服务端。基于windows系统的IOCP模型开发，吞吐性能高，稳定性强。也非常容易和第三方系统进行对接。基于SharpSocket开发。使用TCP协议，可以自动重连。
高效率IOCP的UDP通信服务端
04-13
4. **处理完成的I/O请求**: 通过`GetQueuedCompletionStatus`或`GetQueuedCompletionStatusEx`函数从IOCP中取出完成的I/O请求，然后进行相应的业务处理，如解析接收到的数据、发送回应等。 5. **线程池管理**: 根据...
C#高性能大容量SOCKET并发完成端口例子IOCPDemo_NET_V4
12-09
C#高性能大容量SOCKET并发完成端口例子IOCPDemo_NET_V4
C# 使用Socket发送和接收TCP数据
12-22
C# 使用Socket发送和接收TCP数据，包含客户端和服务器端，发送Send，监听Listen ，C#运行环境VS2010
IOCP Tcp服务器入门源码
03-29
iocp模型的入门源码，包括一个基于iocp的TCP服务端，和一个客户端。适合新手，高手绕过。更多关于iocp的介绍请见 http://blog.csdn.net/cloud95/article/details/7406128
C#高性能Socket服务器的实现(IOCP)
en&ha
01-08 4741
无论什么平台，编写支持高并发性的网络服务器，瓶颈往往出在I/O上，目前最高效的是采用Asynchronous I/O模型，Linux平台提供了epoll，Windows平台提供了I/O Completion Port(IO完成端口，即IOCP)。 在实际应用中，证明C#编写基于.Net IOCP的高性能服务器可以支持10000个以上的TCP长连接。但在具体实现过程中需要注意几个问题： 1.Soc...
iocp(完成端口)采用WSARecv WSASend处理数据，WSASend群发(广播)消息
woshiyuanlei的专栏
04-28 3498
最近在耍iocp，也在网上看了不少例子，但却基本没看到使用WSASend群发的例子 最多只是使用WSASend将数据回传，而这个功能相对比较简单，只要学会使用WSARecv 回传则比较容易实现，而广播则较难。     一开始我采用的是send将数据群发(广播)，这样不需要使用重叠I/O，也较容易的实现了功能， 但没成功使用WSASend群发消息，心里总有点不舒服，于是慢慢琢磨，最后终于实现
C# IOCP完成端口模型（简单实用高效）
Andrewniu的博客
05-07 4814
1、在C#中，不用去面对完成端口的操作系统内核对象，Microsoft已经为我们提供了SocketAsyncEventArgs类，它封装了IOCP的使用。请参考：http://msdn.microsoft.com/zh-cn/library/system.net.sockets.socketasynceventargs.aspx?cs-save-lang=1&amp;cs-lang=cpp#cod...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值