基于。NET的模块化网络服务应用程序服务器开发 第一章

  什么是模块化网络服务应用程序？

  模块化网络服务应用程序 是通过 SOCKET 应用程序 提供框架 ，然后 通过一些方法 把你 编译的类（当然这些类必须实现一定的规则）添加到框架 里头去。这就是ASPX 你只要把你编译好的网站放到IIS中就可以提供服务了。 而我们的 SOCKET框架 相当于IIS， 已经提供了 。NET 网络通讯的 一些基本功能，在此功能上你只要写好数据处理方式  就可以完成一个网络服务端程序了。 这就相当于写ASPX 从来不用去理解低层的SOCKET 通讯

 

好的下面 就让我们开始吧

 

  要实现 SOKCET通讯 我们必须要 有SOCKET 服务器端类， 此类必须要有非常好的性能 以及 稳定性 ，并且提供良好的 调用方式 处理方式。

 

                                                第一章        SOCKET服务器类

 

 。NET SOCKET 里面 Begin 函数提供了异步 方法，但是 此方法 还是过于复杂 以及无法达到 最好的性能。

 我们采用。NET 3.5 里面的新提供的 XXXAsync 系列的函数。 此类函数提供 基于IOCP 的SOCKET服务， 传说能带动 5W个连接以上。 当然这个5W个我没有试过。但是使用 ASYNC 我们可以使用 SocketAsyncEventArgs 方便的 处理数据以及 确认数据包对象（此数据包是哪个用户发过来的） 也许有的人会说 哎呀3。5很大啊 我没装3。5啊。 我这里和你说 你写的是服务器 服务器上没3。5装下就好了。而客户端呢最好用。NET 2。0或者C++ 写。 为什么呢 方便大家安装啊

 

好的不废话 我发出代码来

 

 

 

  /// <summary> /// SOCKET 服务器对象 /// </summary> private Socket sock; /// <summary> /// 连接传入所处理的函数代理 /// </summary> private EventHandler<SocketAsyncEventArgs> AcceptAsyCompleted { get; set; } /// <summary> /// 读取客户端数据的函数代理 /// </summary> private EventHandler<SocketAsyncEventArgs> ReceiveCompleted { get; set; } /// <summary> /// 发送数据的函数代理 /// </summary> private EventHandler<SocketAsyncEventArgs> SendCompleted { get; set; } /// <summary> /// 断开客户端处理的函数代理 /// </summary> private EventHandler<SocketAsyncEventArgs> DisconnectCompleted { get; set; }

 

 

SOKCET 对象我就不说了

 

说下 下面4个函数 我已经注释了 我只说下为什么要定义。 这就好比使用 异步SOKCET一样 必须要有回调函数。 而在3。5新加的 异步处理中 事件代理了 回调函数 所以我们必须定义事件 ，也许你会说 我们可以在 设置时间处理的时候定义。 当然也可以，但是这是服务器

所以还是先定义的好。关键还是性能麻！

 

继续贴代码

 

 在类外面实现3个代理

  /// <summary> /// 发送数据的代理 /// </summary> /// <param name="socketAsync"></param> public delegate void ConnectionFilter(SocketAsyncEventArgs socketAsync); /// <summary> /// 数据包输入代理 /// </summary> /// <param name="data">输入包</param> /// <param name="socketAsync"></param> public delegate void BinaryInputHandler(byte[] data, SocketAsyncEventArgs socketAsync); /// <summary> /// 异常错误通常是用户断开的代理 /// </summary> /// <param name="message">消息</param> /// <param name="socketAsync"></param> /// <param name="erorr">错误代码</param> public delegate void MessageInputHandler(string message, SocketAsyncEventArgs socketAsync, int erorr);

 

 

 

3个代理 表示什么 上面写的很清楚 。 为什么要定义呢 因为 通常 数据处理方法 都在SOKCET服务类 的外面 所以需要代理拉 来把 方法引入

 

在类里面定义3个 代理的对象

 

/// <summary> /// 连接传入处理 /// </summary> public ConnectionFilter Connetions { get; set; } /// <summary> /// 数据输入处理 /// </summary> public BinaryInputHandler BinaryInput { get; set; } /// <summary> /// 异常错误通常是用户断开处理 /// </summary> public MessageInputHandler MessageInput { get; set; }

 

 

 

 

现在也许你还不明白 SOCKET 异步处理都是基于 SocketAsyncEventArgs 对象的 需要大量的 SocketAsyncEventArgs 对象

所以我们需要事先 定义好 大量的 SocketAsyncEventArgs 对象 这样就不必在需要是创建 而消耗CPU 。所以我们定义 一个 Queue<SocketAsyncEventArgs> 来保存 SocketAsyncEventArgs 对象。 使用的时候只要

 

SocketAsyncEventArgs AcceptAsy = AysncQueue.Dequeue(); 就OK了  这比新创建一个明显速度要快

 

 

 

 

不废话贴代码

 

/// <summary> /// SocketAsyncEventArgs 列队 /// </summary> private Queue<SocketAsyncEventArgs> AysncQueue;

 

 

 

 

 

 

 

 

 你SOCKET 服务器 通讯必须要有把 客户端 连接 收集在一起，不然你如何知道 你程序有多少个SOCKET客户端连接 如何调用指定客户呢？

 

 

我采用 LIST<SOCKET> 来保存

 

 

/// <summary> /// 保存SOCKET 客户连接列表 /// </summary> private List<Socket> clientlist; public List<Socket> Clientlist { get { return clientlist; } }

 

 添加些必要的属性

 

  /// <summary> /// 服务器SOCKET 对象 /// </summary> public Socket Sock { get { return sock; } } /// <summary> /// 是否开启SOCKET Delay算法 /// </summary> public bool NoDelay { get { return sock.NoDelay; } set { sock.NoDelay = value; } } /// <summary> /// SOCKET 的 ReceiveTimeout属性 /// </summary> public int ReceiveTimeout { get { return sock.ReceiveTimeout; } set { sock.ReceiveTimeout = value; } } /// <summary> /// SOCKET 的 SendTimeout /// </summary> public int SendTimeout { get { return sock.SendTimeout; } set { sock.SendTimeout = value; } } /// <summary> /// SOCKET 的 UseOnlyOverlappedIO /// </summary> public bool UseOnlyOverlappedIO { get { return sock.UseOnlyOverlappedIO; } set { sock.UseOnlyOverlappedIO = value; } } /// <summary> /// 接收包大小 /// </summary> public int MaxByteCout { get; set; } /// <summary> /// 最大用户连接 /// </summary> private int ListCout;

 

 

 

下面实现 构造函数 一些 元素的初始化 以及定义

 

 

/// <summary> /// 建立一个新的ZYSERVER /// </summary> /// <param name="host">IP地址</param> /// <param name="port">服务端口</param> /// <param name="listcout">最大用户</param> public ZYServer(string host, int port,int listcout) { if (isDisposed == true) { throw new ObjectDisposedException("ZYServer is Disposed"); } this.AysncQueue = new Queue<SocketAsyncEventArgs>(listcout); this.clientlist = new List<Socket>(listcout); this.ListCout = listcout; for (int i = 0; i < ListCout; i++) { SocketAsyncEventArgs e = new SocketAsyncEventArgs(); AysncQueue.Enqueue(e); } AcceptAsyCompleted = new EventHandler<SocketAsyncEventArgs>(AcceptAsy_Completed); ReceiveCompleted = new EventHandler<SocketAsyncEventArgs>(Receive_Completed); SendCompleted = new EventHandler<SocketAsyncEventArgs>(Send_Completed); DisconnectCompleted = new EventHandler<SocketAsyncEventArgs>(Disconnect_Completed); sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); sock.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1); IPEndPoint myEnd = (String.IsNullOrEmpty(host)) ? (new IPEndPoint(Dns.GetHostEntry(Dns.GetHostName()).AddressList[0], port)) : (new IPEndPoint(IPAddress.Parse(host), port)); sock.Bind(myEnd); sock.Listen(20); SendTimeout = 1000; ReceiveTimeout = 1000; UseOnlyOverlappedIO = true; MaxByteCout = 1024; SetAcceptAsy(); }

 

 

 

 

这里补充下：
            for (int i = 0; i < ListCout; i++)
            {
                SocketAsyncEventArgs e = new SocketAsyncEventArgs();               
                AysncQueue.Enqueue(e);

            }

 

 

一般 一个 SocketAsyncEventArgs对象对应一个用户连接 至少这样设置可以提供性能。所以这里列队到小等于 最大连接数是有必要的。如果万一 数量不够 还可以另创建

 

 

继续贴代码

 

/// <summary> /// 设置一个 SocketAsyncEventArgs 对象用于监听 /// </summary> private void SetAcceptAsy() { if (AysncQueue.Count > 0 && clientlist.Count < ListCout) { SocketAsyncEventArgs AcceptAsy = AysncQueue.Dequeue(); AcceptAsy.Completed += AcceptAsyCompleted; Sock.AcceptAsync(AcceptAsy); } } void AcceptAsy_Completed(object sender, SocketAsyncEventArgs e) { if (!isDisposed) { Socket client = e.AcceptSocket; e.Completed -= AcceptAsy_Completed; e.Completed += ReceiveCompleted; byte[] buff = new byte[MaxByteCout]; e.SetBuffer(buff, 0, buff.Length); client.ReceiveAsync(e); if (!clientlist.Contains(client)) { this.clientlist.Add(client); } else { CloseSocket(e); } if (Connetions != null) { Connetions(e); } SetAcceptAsy(); } else { e.Dispose(); } } void Receive_Completed(object sender, SocketAsyncEventArgs e) { Socket client = sender as Socket; if (e.BytesTransferred == 0) { if (MessageInput != null) { string RemoteAddress = client.RemoteEndPoint.ToString(); MessageInput(RemoteAddress + " Disconnect", e, 1); } e.Completed -= ReceiveCompleted; clientlist.Remove(client); client.Close(); e.Dispose(); if (AysncQueue.Count == 1) { LocalAsyncQueue(); } } else { if (BinaryInput != null) { byte[] data = new byte[e.BytesTransferred]; Array.Copy(e.Buffer, 0, data, 0, data.Length); BinaryInput(data, e); } try { if (client.Connected) client.ReceiveAsync(e); } catch (ObjectDisposedException) { } } } void Disconnect_Completed(object sender, SocketAsyncEventArgs e) { Socket client = sender as Socket; clientlist.Remove(client); e.Completed -= ReceiveCompleted; e.Dispose(); if (AysncQueue.Count == 1) { LocalAsyncQueue(); } } void Send_Completed(object sender, SocketAsyncEventArgs e) { try { if (e.BytesTransferred < e.Buffer.Length) { Socket Socks = sender as Socket; if (Socks != null) { Socks.SendAsync(e); } else { e.Dispose(); } } } catch (ObjectDisposedException) { if (MessageInput != null) { MessageInput.Invoke("无法发送数据,Socket对象已经断开连接", e, 1); } // MessageInput("无法发送数据,Socket对象已经断开连接", e); } finally { e.Dispose(); } }

 

 

 

除了 SetAcceptAsy() 其他4个函数对应

 

 

     /// <summary>
        /// 连接传入所处理的函数代理
        /// </summary>
        private EventHandler<SocketAsyncEventArgs> AcceptAsyCompleted { get; set; } 

        /// <summary>
        /// 读取客户端数据的函数代理
        /// </summary>
        private EventHandler<SocketAsyncEventArgs> ReceiveCompleted { get; set; }
  
        /// <summary>
        /// 发送数据的函数代理
        /// </summary>
        private EventHandler<SocketAsyncEventArgs> SendCompleted { get; set; }   
        /// <summary>
        /// 断开客户端处理的函数代理
        /// </summary>
        private EventHandler<SocketAsyncEventArgs> DisconnectCompleted { get; set; } 

 

 

这4个代理的 函数处理

 

这4个函数里面拥有 SocketAsyncEventArgs 的使用方法 下面我将一步步的去说明

 

 

 

 

 SetAcceptAsy() 方法主要是获取一个 SocketAsyncEventArgs  对象 然后 将此对象 放入SOCKET AcceptAsync 函数让他进行监听

 

 

当然在监听前必须要设置 监听处理的事件

 

AcceptAsy.Completed += AcceptAsyCompleted;

 

我才此函数中加入了 SocketAsyncEventArgs  对象列队数量检测和连接数检测 这是必要了为了避免错误

 

 

 

AcceptAsy_Completed 函数是 SetAcceptAsy()  为对象设置的事件处理

 

 

 因为我的SOCKET 服务器类 实现了 接口IDisposable  所以在方法的一开头 就检测 此 类是否被Disposed 掉 如果我的SOCKET 服务器类 调用了Disposed() 后 再次调用此事件时不做处理 并且将此 环境的 SocketAsyncEventArgs  对象 Disposed掉

 

 

 

 

               Socket client = e.AcceptSocket; //获取 当前客户端的SOCKET 对象

                e.Completed -= AcceptAsy_Completed;
                e.Completed += ReceiveCompleted;  //把 SocketAsyncEventArgs  对象 的事件处理更改为读取数据包

 

                byte[] buff = new byte[MaxByteCout];
                e.SetBuffer(buff, 0, buff.Length);         //设置接收数据包          
                client.ReceiveAsync(e);              //将e 放入SOCKET 的 ReceiveAsync 方法
                               
               
                if (!clientlist.Contains(client))  //将此SOCKET 放入用户SOCKET列表
                {
                    this.clientlist.Add(client);
                }
                else
                {
                    CloseSocket(e);
                }

 

 

                if (Connetions != null)  //如果 Connetions 代理不等于空 将E传递给 Connetions 代理 这样 你就能获得连接信息了
                {
                    Connetions(e);
                }

 

                SetAcceptAsy(); //重新将一个SocketAsyncEventArgs  对象 用于监听

 

 

 

 

 

 

 

 在 Receive_Completed 函数中

 

我们第一步检测的就是e.BytesTransferred 获取的数据包长度 如果 有长度那么说明 你接受到了数据包 如果没有为0 那么说明用户已经断开连接了

 

 

if (e.BytesTransferred == 0) //检查获取的数据包长度 判断是否断开连接 { if (MessageInput != null) //如果断开 将调用断开代理 { string RemoteAddress = client.RemoteEndPoint.ToString(); MessageInput(RemoteAddress + " Disconnect", e, 1); } e.Completed -= ReceiveCompleted; // 一些善后工作 clientlist.Remove(client); client.Close(); e.Dispose(); if (AysncQueue.Count == 1) //如果 SocketAsyncEventArgs 列队数量==1 的时候 将重新创建 SocketAsyncEventArgs 列队 列队 { LocalAsyncQueue(); } } 

 

 

 LocalAsyncQueue(); 函数是用来重新创建 一个 SocketAsyncEventArgs 列队

 

 

 

 

else { if (BinaryInput != null) //如果数据包获取代理不为空 将数据包传入代理 { byte[] data = new byte[e.BytesTransferred]; Array.Copy(e.Buffer, 0, data, 0, data.Length); //复制数据包 BinaryInput(data, e); } try { if (client.Connected) client.ReceiveAsync(e); //重新监听数据包 } catch (ObjectDisposedException) { } }

 

 

 

 

 

 

 

           

 

 好的下面是最后3个函数 一个断开一个发送 以及重组 SocketAsyncEventArgs 列队

 

  

 

  //断开SOCKET 对象 public void CloseSocket(SocketAsyncEventArgs e) { if (e.AcceptSocket != null) { if (AysncQueue.Count > 0) //检测SocketAsyncEventArgs列队 并完成 异步断开 { SocketAsyncEventArgs me = this.AysncQueue.Dequeue(); me.Completed += DisconnectCompleted; e.AcceptSocket.DisconnectAsync(me); } else { LocalAsyncQueue(); SocketAsyncEventArgs me = this.AysncQueue.Dequeue(); me.Completed += DisconnectCompleted; e.AcceptSocket.DisconnectAsync(me); } if (MessageInput != null) { string RemoteAddress = e.AcceptSocket.RemoteEndPoint.ToString(); //将断开信息传入 MessageInput代理 MessageInput(RemoteAddress + " Disconnect", e, 1); } } } void Disconnect_Completed(object sender, SocketAsyncEventArgs e) { Socket client = sender as Socket; clientlist.Remove(client); e.Completed -= ReceiveCompleted; e.Dispose(); if (AysncQueue.Count == 1) { LocalAsyncQueue(); } } //发送数据包 public void SendData(Socket sock, byte[] data) { if (sock.Connected) { SocketAsyncEventArgs e = new SocketAsyncEventArgs(); //创建一个 SocketAsyncEventArgs 对象用于发送 数据包 e.Completed += new EventHandler<SocketAsyncEventArgs>(SendCompleted); e.SetBuffer(data, 0, data.Length); sock.SendAsync(e); } else { throw new ObjectDisposedException("Not Send Data Socket Disconnect"); } } void Send_Completed(object sender, SocketAsyncEventArgs e) { try { if (e.BytesTransferred < e.Buffer.Length) //如果 发送的数据包数量小于 数据包长度将重新发送 { Socket Socks = sender as Socket; if (Socks != null) { Socks.SendAsync(e); } else { e.Dispose(); } } } catch (ObjectDisposedException) { if (MessageInput != null) { MessageInput.Invoke("无法发送数据,Socket对象已经断开连接", e, 1); } // MessageInput("无法发送数据,Socket对象已经断开连接", e); } finally { e.Dispose(); } } //重组 SocketAsyncEventArgs 列队 void LocalAsyncQueue() { for (int i = 0; i < ListCout; i++) { SocketAsyncEventArgs e = new SocketAsyncEventArgs(); AysncQueue.Enqueue(e); } }

 

 

 

 

 

Socket 服务器类 就可以使用了

 

以下是完整代码：

 

using System; using System.Collections.Generic; using System.Collections; using System.Text; using System.Net; using System.Net.Sockets; namespace ZY { /// <summary> /// 发送数据的代理 /// </summary> /// <param name="socketAsync"></param> public delegate void ConnectionFilter(SocketAsyncEventArgs socketAsync); /// <summary> /// 数据包输入代理 /// </summary> /// <param name="data">输入包</param> /// <param name="socketAsync"></param> public delegate void BinaryInputHandler(byte[] data, SocketAsyncEventArgs socketAsync); /// <summary> /// 异常错误通常是用户断开的代理 /// </summary> /// <param name="message">消息</param> /// <param name="socketAsync"></param> /// <param name="erorr">错误代码</param> public delegate void MessageInputHandler(string message, SocketAsyncEventArgs socketAsync, int erorr); public class ZYServer : IDisposable { /// <summary> /// 用来确定是否以释放 /// </summary> private bool isDisposed; /// <summary> /// SOCKET 服务器对象 /// </summary> private Socket sock; /// <summary> /// 连接传入所处理的函数代理 /// </summary> private EventHandler<SocketAsyncEventArgs> AcceptAsyCompleted { get; set; } /// <summary> /// 读取客户端数据的函数代理 /// </summary> private EventHandler<SocketAsyncEventArgs> ReceiveCompleted { get; set; } /// <summary> /// 发送数据的函数代理 /// </summary> private EventHandler<SocketAsyncEventArgs> SendCompleted { get; set; } /// <summary> /// 断开客户端处理的函数代理 /// </summary> private EventHandler<SocketAsyncEventArgs> DisconnectCompleted { get; set; } /// <summary> /// 连接传入处理 /// </summary> public ConnectionFilter Connetions { get; set; } /// <summary> /// 数据输入处理 /// </summary> public BinaryInputHandler BinaryInput { get; set; } /// <summary> /// 异常错误通常是用户断开处理 /// </summary> public MessageInputHandler MessageInput { get; set; } /// <summary> /// SocketAsyncEventArgs 列队 /// </summary> private Queue<SocketAsyncEventArgs> AysncQueue; /// <summary> /// 保存SOCKET 客户连接列表 /// </summary> private List<Socket> clientlist; /// <summary> /// 返回客户SOCKET 列表 /// </summary> public List<Socket> Clientlist { get { return clientlist; } } ~ZYServer() { this.Dispose(false); } public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } protected virtual void Dispose(bool disposing) { if (!isDisposed) { isDisposed = true; for (int i = 0; i < ListCout; i++) { if (AysncQueue.Count > 0) { SocketAsyncEventArgs e = AysncQueue.Dequeue(); e.Dispose(); } else { break; } } foreach (Socket socks in clientlist) { if (socks != null) { try { socks.Disconnect(false); } catch (SocketException) { } catch (ObjectDisposedException) { } } } if (sock != null) sock.Close(); if (disposing) { clientlist.Clear(); AysncQueue.Clear(); } } } /// <summary> /// 服务器SOCKET 对象 /// </summary> public Socket Sock { get { return sock; } } /// <summary> /// 是否开启SOCKET Delay算法 /// </summary> public bool NoDelay { get { return sock.NoDelay; } set { sock.NoDelay = value; } } /// <summary> /// SOCKET 的 ReceiveTimeout属性 /// </summary> public int ReceiveTimeout { get { return sock.ReceiveTimeout; } set { sock.ReceiveTimeout = value; } } /// <summary> /// SOCKET 的 SendTimeout /// </summary> public int SendTimeout { get { return sock.SendTimeout; } set { sock.SendTimeout = value; } } /// <summary> /// SOCKET 的 UseOnlyOverlappedIO /// </summary> public bool UseOnlyOverlappedIO { get { return sock.UseOnlyOverlappedIO; } set { sock.UseOnlyOverlappedIO = value; } } /// <summary> /// 接收包大小 /// </summary> public int MaxByteCout { get; set; } /// <summary> /// 最大用户连接 /// </summary> private int ListCout; /// <summary> /// 建立一个新的ZYSERVER /// </summary> /// <param name="host">IP地址</param> /// <param name="port">服务端口</param> /// <param name="listcout">最大用户</param> public ZYServer(string host, int port,int listcout) { if (isDisposed == true) { throw new ObjectDisposedException("ZYServer is Disposed"); } this.AysncQueue = new Queue<SocketAsyncEventArgs>(listcout); this.clientlist = new List<Socket>(listcout); this.ListCout = listcout; for (int i = 0; i < ListCout; i++) { SocketAsyncEventArgs e = new SocketAsyncEventArgs(); AysncQueue.Enqueue(e); } AcceptAsyCompleted = new EventHandler<SocketAsyncEventArgs>(AcceptAsy_Completed); ReceiveCompleted = new EventHandler<SocketAsyncEventArgs>(Receive_Completed); SendCompleted = new EventHandler<SocketAsyncEventArgs>(Send_Completed); DisconnectCompleted = new EventHandler<SocketAsyncEventArgs>(Disconnect_Completed); sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); sock.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1); IPEndPoint myEnd = (String.IsNullOrEmpty(host)) ? (new IPEndPoint(Dns.GetHostEntry(Dns.GetHostName()).AddressList[0], port)) : (new IPEndPoint(IPAddress.Parse(host), port)); sock.Bind(myEnd); sock.Listen(20); SendTimeout = 1000; ReceiveTimeout = 1000; UseOnlyOverlappedIO = true; MaxByteCout = 1024; SetAcceptAsy(); } /// <summary> /// 设置一个 SocketAsyncEventArgs 对象用于监听 /// </summary> private void SetAcceptAsy() { if (AysncQueue.Count > 0 && clientlist.Count < ListCout) { SocketAsyncEventArgs AcceptAsy = AysncQueue.Dequeue(); AcceptAsy.Completed += AcceptAsyCompleted; Sock.AcceptAsync(AcceptAsy); } } void AcceptAsy_Completed(object sender, SocketAsyncEventArgs e) { if (!isDisposed) { Socket client = e.AcceptSocket; e.Completed -= AcceptAsy_Completed; e.Completed += ReceiveCompleted; byte[] buff = new byte[MaxByteCout]; e.SetBuffer(buff, 0, buff.Length); client.ReceiveAsync(e); if (!clientlist.Contains(client)) { this.clientlist.Add(client); } else { CloseSocket(e); } if (Connetions != null) { Connetions(e); } SetAcceptAsy(); } else { e.Dispose(); } } void Receive_Completed(object sender, SocketAsyncEventArgs e) { Socket client = sender as Socket; if (e.BytesTransferred == 0) //检查获取的数据包长度 判断是否断开连接 { if (MessageInput != null) //如果断开 将调用断开代理 { string RemoteAddress = client.RemoteEndPoint.ToString(); MessageInput(RemoteAddress + " Disconnect", e, 1); } e.Completed -= ReceiveCompleted; // 一些善后工作 clientlist.Remove(client); client.Close(); e.Dispose(); if (AysncQueue.Count == 1) //如果 SocketAsyncEventArgs 列队数量==1 的时候 将重新创建 SocketAsyncEventArgs 列队 列队 { LocalAsyncQueue(); } } else { if (BinaryInput != null) //如果数据包获取代理不为空 将数据包传入代理 { byte[] data = new byte[e.BytesTransferred]; Array.Copy(e.Buffer, 0, data, 0, data.Length); //复制数据包 BinaryInput(data, e); } try { if (client.Connected) client.ReceiveAsync(e); //重新监听数据包 } catch (ObjectDisposedException) { } } } /// <summary> /// 断开一个用户SocketAsyncEventArgs对象 /// </summary> /// <param name="e"></param> public void CloseSocket(SocketAsyncEventArgs e) { if (e.AcceptSocket != null) { if (AysncQueue.Count > 0) //检测SocketAsyncEventArgs列队 并完成 异步断开 { SocketAsyncEventArgs me = this.AysncQueue.Dequeue(); me.Completed += DisconnectCompleted; e.AcceptSocket.DisconnectAsync(me); } else { LocalAsyncQueue(); SocketAsyncEventArgs me = this.AysncQueue.Dequeue(); me.Completed += DisconnectCompleted; e.AcceptSocket.DisconnectAsync(me); } if (MessageInput != null) { string RemoteAddress = e.AcceptSocket.RemoteEndPoint.ToString(); //将断开信息传入 MessageInput代理 MessageInput(RemoteAddress + " Disconnect", e, 1); } } } void Disconnect_Completed(object sender, SocketAsyncEventArgs e) { Socket client = sender as Socket; clientlist.Remove(client); e.Completed -= ReceiveCompleted; e.Dispose(); if (AysncQueue.Count == 1) { LocalAsyncQueue(); } } /// <summary> /// 发送数据包 /// </summary> /// <param name="sock">目标Socket</param> /// <param name="data">数据</param> public void SendData(Socket sock, byte[] data) { if (sock.Connected) { SocketAsyncEventArgs e = new SocketAsyncEventArgs(); //创建一个 SocketAsyncEventArgs 对象用于发送 数据包 e.Completed += new EventHandler<SocketAsyncEventArgs>(SendCompleted); e.SetBuffer(data, 0, data.Length); sock.SendAsync(e); } else { throw new ObjectDisposedException("Not Send Data Socket Disconnect"); } } void Send_Completed(object sender, SocketAsyncEventArgs e) { try { if (e.BytesTransferred < e.Buffer.Length) //如果 发送的数据包数量小于 数据包长度将重新发送 { Socket Socks = sender as Socket; if (Socks != null) { Socks.SendAsync(e); } else { e.Dispose(); } } } catch (ObjectDisposedException) { if (MessageInput != null) { MessageInput.Invoke("无法发送数据,Socket对象已经断开连接", e, 1); } // MessageInput("无法发送数据,Socket对象已经断开连接", e); } finally { e.Dispose(); } } /// <summary> /// 重组 SocketAsyncEventArgs 列队 /// </summary> void LocalAsyncQueue() { for (int i = 0; i < ListCout; i++) { SocketAsyncEventArgs e = new SocketAsyncEventArgs(); AysncQueue.Enqueue(e); } } } }

 

 

 

 

 

我们将在下一章中 讲如何使用此 类进行网络开发