C#实现的异步套接字，封装了server与client

最近半年以来都在从事suse10下的C++开发，开发工具也从豪门visual studio10降到了代码查看工具source insight。不过不得不说source insight阅读代码的效率绝对超过visual studio，虽然visual studio也能设置哪些功能，但真心没source insight顺手。不过悲剧的就是写代码的支持比文本好不了多少，调试的话，只能上传到suse10服务器上去然后慢慢的gdb调试了，最头大的就是那个makefile的编写，实在让人累。还是怀念windows下那种豪华的日子。

废话不多说了，我写这篇文章不是为了诉苦的，只是为了继续写网络这边的。以前写过windows下的C++的网络编程的一些日子，虽然也被喷过不少，不过今天我还是要来写网络编程，只是语言更换为豪华的C#。之所以说C#豪华，相信同时使用C#与C++的人能体会到。

frame work实在是太强大了，基本我就关注一点点东西就行了，很多类似工具的东西都是可以直接拿过来使用，而且最为关键的是我们在天朝，不用花钱用企业版，小小鄙视下自己，不过我还是会继续支持山寨盗版，谁让我是屌丝呢。

今天文章中写的是异步，纯粹的异步，当然很多人看来很简单了，而且里面很多东西值得商榷，不过说真的，我真心感谢C#的线程池，不然我还要自己去写个threadpool。而且我没办法保证我写的没问题。

直接上代码了，不讲思路了，没时间，最近太忙，已经几天没睡好了。



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

namespace PPT.Comm
{
/// <summary>
/// 接收数据流
/// </summary>
/// <param name="m_pSocket">异步套接字</param>
/// <param name="m_pDatagram">接收到的数据流</param>
public delegate void AsyncDataAcceptedEventHandler(AsyncSocket m_pSocket,byte[] m_pDatagram);

/// <summary>
/// 发送完毕
/// </summary>
/// <param name="m_pSocket">异步套接字</param>
/// <param name="m_pIsSuccess">发送结果</param>
public delegate void AsyncDataSendedEventHandler(AsyncSocket m_pSocket,bool m_pIsSuccess);

/// <summary>
/// 接收连接委托
/// </summary>
/// <param name="m_pSocket">异步套接字</param>
public delegate void AsyncSocketAcceptEventHandler(AsyncSocket m_pSocket);

/// <summary>
/// 关闭连接委托
/// </summary>
/// <param name="m_pSocket">异步套接字</param>
public delegate void AsyncSocketClosedEventHandler(AsyncSocket m_pSocket);

/// <summary>
/// State object for receiving data from remote device.
/// </summary>
class StateObject
{
// Client socket.
public Socket workSocket = null;
// Size of receive buffer.
public const int BufferSize = 1024 * 256;
// Receive buffer.
public byte[] buffer = new byte[BufferSize];
// Received data string.
public StringBuilder sb = new StringBuilder();
}

/// <summary>
/// 异步SOCKET
/// </summary>
public class AsyncSocket
{
#region 私有字段 成员

private Socket m_socket = null; //socket
string m_id = ""; //socket唯一标识，GUID

private readonly bool m_isSerevr; //服务器标志位
private int m_iBackBag;
private string m_ipAddress;
private int m_port;

private AsyncDataAcceptedEventHandler m_onAsyncDataAcceptedEvent = null; //接收数据流
private AsyncDataSendedEventHandler m_onAsyncDataSendedEvent = null; //发送结束
private AsyncSocketAcceptEventHandler m_onAsyncSocketAcceptEvent = null; //接收连接
private AsyncSocketClosedEventHandler m_onAsyncSocketClosedEvent = null; //关闭连接

#endregion

#region 公共属性 成员

/// <summary>
/// 获取SOCKET标志位
/// </summary>
public string ID
{
get
{
return m_id;
}
}

/// <summary>
/// 设置或获取机器标志位
/// </summary>
public string MachineKey
{
set;
get;
}

/// <summary>
/// 获取、设置连接对象
/// </summary>
public Socket LinkObject
{
get
{
return m_socket;
}
set
{
m_socket = value;
}
}

/// <summary>
/// 设置或获取线程退出标识
/// </summary>
public bool IsExit { set; get; }

#endregion

#region 公共事件 成员

/// <summary>
/// 连接关闭事件
/// </summary>
public event AsyncSocketClosedEventHandler AsyncSocketClosedEvent
{
add
{
m_onAsyncSocketClosedEvent += value;
}
remove
{
m_onAsyncSocketClosedEvent -= value;
}
}

/// <summary>
/// 连接接收事件
/// </summary>
public event AsyncSocketAcceptEventHandler AsyncSocketAcceptEvent
{
add
{
m_onAsyncSocketAcceptEvent += value;
}
remove
{
m_onAsyncSocketAcceptEvent -= value;
}
}

/// <summary>
/// 数据接收完成事件
/// </summary>
public event AsyncDataAcceptedEventHandler AsyncDataAcceptedEvent
{
add
{
this.m_onAsyncDataAcceptedEvent += value;
}
remove
{
this.m_onAsyncDataAcceptedEvent -= value;
}
}

/// <summary>
/// 数据发送完成事件
/// </summary>
public event AsyncDataSendedEventHandler AsyncDataSendedEvent
{
add
{
m_onAsyncDataSendedEvent += value;
}
remove
{
m_onAsyncDataSendedEvent -= value;
}
}

#endregion

#region 构造函数 成员

/// <summary>
/// 构造函数
/// </summary>
/// <param name="m_pHostAddrss">主机地址，可为机器名或者IP</param>
/// <param name="m_pHostPort">主机端口</param>
/// <param name="m_pIsAsServer">是否作为服务器，默认为false</param>
/// <param name="m_pICount">支持多少个客户端</param>
public AsyncSocket(string m_pHostAddrss,int m_pHostPort,bool m_pIsAsServer = false,int m_pIBackBag = 10)
{
m_isSerevr = m_pIsAsServer;
m_iBackBag = m_pIBackBag;
m_ipAddress = m_pHostAddrss;
m_port = m_pHostPort;
m_id = Guid.NewGuid().ToString();
}

/// <summary>
/// 构造函数，用于服务器构造与客户端的异步socket
/// </summary>
/// <param name="LinkObject">客户端socket</param>
private AsyncSocket(Socket linkObject)
{
m_socket = linkObject;
m_id = Guid.NewGuid().ToString();
}

#endregion

#region 公共方法

/// <summary>
/// 打开通道
/// </summary>
public void AsyncOpen()
{
if (m_isSerevr)
{
IPAddress ip = Dns.GetHostAddresses(m_ipAddress)[0];
IPEndPoint ipe = new IPEndPoint(ip,m_port);
m_socket = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
m_socket.Bind(ipe);
m_socket.Listen(m_iBackBag);
m_socket.BeginAccept(new AsyncCallback(AcceptCallBack),null);//异步
}
else
{
IPAddress ip = Dns.GetHostAddresses(m_ipAddress)[0];
IPEndPoint ipe = new IPEndPoint(ip,m_port);
m_socket = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
m_socket.Connect(ipe);
}
}

/// <summary>
/// 发送二进制数据
/// </summary>
/// <param name="SendData"></param>
public void AsyncSend(byte[] SendData)
{
m_socket.BeginSend(SendData,0,SendData.Length,0,new AsyncCallback(SendCallBack),m_socket);
}

/// <summary>
/// 关闭通道
/// </summary>
public void AsyncClose()
{
if (!m_isSerevr)
{
m_socket.Shutdown(SocketShutdown.Both);//关闭接收发送流
m_socket.BeginDisconnect(false,CloseCallBack,m_socket);//开始尝试断开
}
else
{
m_socket.Shutdown(SocketShutdown.Both);//关闭接收发送流
Thread.Sleep(200);//等待现有任务处理完成
m_socket.Dispose();//释放所有本地资源
}
}

/// <summary>
/// 开始接受数据，连接建立之后，调用此方法
/// </summary>
public void BeginAcceptData()
{
//开始接收数据
StateObject state = new StateObject();
state.workSocket = m_socket;
m_socket.BeginReceive(state.buffer,0,StateObject.BufferSize,0,new AsyncCallback(ReceiveCallback),state);
}

#endregion

#region 私有方法 成员

#endregion

#region 回调函数 成员

/// <summary>
/// 接受客户端连接处理
/// </summary>
/// <param name="ar"></param>
private void AcceptCallBack(IAsyncResult ar)
{
Socket handler = m_socket.EndAccept(ar);
AsyncSocket NewSocket = new AsyncSocket(handler);

//激发事件，异步触发
if (m_onAsyncSocketAcceptEvent != null)
foreach (AsyncSocketAcceptEventHandler item in m_onAsyncSocketAcceptEvent.GetInvocationList())
item.BeginInvoke(NewSocket,null,null);

//继续投递监听请求
m_socket.BeginAccept(new AsyncCallback(AcceptCallBack),null);
}

/// <summary>
/// 接受字节流处理
/// </summary>
/// <param name="ar"></param>
private void ReceiveCallback(IAsyncResult ar)
{
try
{
StateObject state = ar.AsyncState as StateObject;
//读取数据
int bytesRead = m_socket.EndReceive(ar);
if (bytesRead > 0)
{
byte[] _Readbyte = new byte[bytesRead];
Array.Copy(state.buffer,0,_Readbyte,0,bytesRead);
//接收完成，激发事件
if (m_onAsyncDataAcceptedEvent != null)
foreach (AsyncDataAcceptedEventHandler item in m_onAsyncDataAcceptedEvent.GetInvocationList())
item.BeginInvoke(this,_Readbyte,null,null);

state = new StateObject();//继续投递接收委托
state.workSocket = m_socket;
m_socket.BeginReceive(state.buffer,0,StateObject.BufferSize,0,new AsyncCallback(ReceiveCallback),state);
}
}
catch (SocketException)
{
if (m_onAsyncSocketClosedEvent != null)
foreach (AsyncSocketClosedEventHandler item in m_onAsyncSocketClosedEvent.GetInvocationList())
item.BeginInvoke(this,null,null);
}
}

/// <summary>
/// 发送结束处理
/// </summary>
/// <param name="ar"></param>
private void SendCallBack(IAsyncResult ar)
{
try
{
m_socket.EndSend(ar);
if (m_onAsyncDataSendedEvent != null)
foreach (AsyncDataSendedEventHandler item in m_onAsyncDataSendedEvent.GetInvocationList())
item.BeginInvoke(this,true,null,null);
}
catch (SocketException)
{
if (m_onAsyncDataSendedEvent != null)
foreach (AsyncDataSendedEventHandler item in m_onAsyncDataSendedEvent.GetInvocationList())
item.BeginInvoke(this,false,null,null);

if (m_onAsyncSocketClosedEvent != null)
foreach (AsyncSocketClosedEventHandler item in m_onAsyncSocketClosedEvent.GetInvocationList())
item.BeginInvoke(this,null,null);
}
}

/// <summary>
/// 关闭后处理
/// </summary>
/// <param name="ar"></param>
private void CloseCallBack(IAsyncResult ar)
{
try
{
m_socket.EndDisconnect(ar);
m_socket.Dispose();
if (m_onAsyncDataSendedEvent != null)
foreach (AsyncSocketClosedEventHandler item in m_onAsyncSocketClosedEvent.GetInvocationList())
item.BeginInvoke(this,null,null);
}
catch (SocketException)
{
if (m_onAsyncSocketClosedEvent != null)
foreach (AsyncSocketClosedEventHandler item in m_onAsyncSocketClosedEvent.GetInvocationList())
item.BeginInvoke(this,null,null);
}
}

#endregion
}
}



代码注释还是蛮详细的，相信你看了也没什么不懂的地方。唯一让我不爽的是我异步事件不得不

foreach (AsyncSocketAcceptEventHandler item in m_onAsyncSocketAcceptEvent.GetInvocationList())
item.BeginInvoke(NewSocket,null,null);

这样的写法，很蛋疼。也试验了

Action asyncAction = () => m_onAsyncSocketAcceptEvent ();

asyncAction.BeginInvoke(

null

,

null

);

但郁闷的发现其实action虽然异步了，但那些事件还是顺序触发的，根本不是并发触发。无奈还是写那个蛋疼的foreach语句。顺便提到一句那个foreach中类型写全了，别用var，因为var会自动推断为Delegate。当然你自己再转换下也行，如果你喜欢的话。

我把代码贴出来的目的是找bug，还望各位大神多多指出其中问题。各种都可以，包括性能方面的。（我现在最怀疑的就是这里面到处异步，用线程池的资源会不会出现性能问题，毕竟线程有时候就是坑爹的）