/// <summary>
/// 异步发送
/// </summary>
/// <param name="userToken">AsyncUserToken</param>
/// <param name="buffer">byte[]</param>
/// <param name="offset">int</param>
/// <param name="count">int</param>
/// <returns>bool</returns>
private ResMsg SendAsyncEvent(AsyncUserToken userToken, byte[] buffer, int offset, int count)
{
if (userToken.Socket == null || !userToken.Socket.Connected)
{
userToken.m_sendAsync = false;
return(new ResMsg(false, "连接已关闭"));
}
userToken.SendEventArgs.SetBuffer(buffer, offset, count); //设置发送缓冲区域
bool willRaiseEvent = userToken.Socket.SendAsync(userToken.SendEventArgs); //异步发送
if (!willRaiseEvent)
{
return(ProcessSend(userToken.SendEventArgs));
}
//userToken.m_sendAsync = false;
return(new ResMsg(true, ""));
}
/// <summary>
/// 通过预先分配可重用缓冲区和上下文对象来初始化服务器。
/// 这些对象不需要预先分配或重用，但是这样做是为了说明如何轻松地使用API创建可重用对象来提高服务器性能。
/// </summary>
private void Init()
{
if (_isInited)
{
return;
}
AsyncUserToken userToken;
for (int i = 0; i < _maxConnections; i++) //按照连接数建立读写对象
{
userToken = new AsyncUserToken(_recvBufferSize);
userToken.AsyncServer = this;
//异步回调函数初始化
userToken.RecvEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(IO_Completed);
userToken.SendEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(IO_Completed);
//开辟固定空间
m_asyncUserTokenPool.Push(userToken);
}
_isInited = true;
}
public void AsyncClose()
{
Thread th = new Thread(new ParameterizedThreadStart(state =>
{
AsyncUserToken userToken = state as AsyncUserToken;
if (userToken != null)
{
try
{
userToken.Close();
}
catch (Exception ex)
{
//LogHelper.LogError(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + " 关闭连接发生异常", ex);
}
}
}));
th.IsBackground = true;
th.Start(this);
}
/// <summary>
/// 异步发送回调函数
/// </summary>
/// <param name="asyncEventArgs"></param>
private ResMsg ProcessSend(SocketAsyncEventArgs sendEventArgs)
{
AsyncUserToken userToken = sendEventArgs.UserToken as AsyncUserToken;
userToken.ActiveDateTime = DateTime.Now;
if (sendEventArgs.SocketError == SocketError.Success)
{
//发送成功，检查缓存中是否还有数据没有发送,有就继续发送
byte[] data;
if (userToken.SendBuffer.TryDequeue(out data) && data != null)
{
userToken.m_sendAsync = true;
return(SendAsyncEvent(userToken, data, 0, data.Length));
}
userToken.m_sendAsync = false;
return(new ResMsg(true, ""));
}
else
{
userToken.AsyncClose();
return(new ResMsg(false, "连接已关闭"));
}
}
public ResMsg SendData(AsyncUserToken userToken, byte[] buffer, int offset, int count)
{
if (buffer == null || buffer.Length == 0 || count <= 1)
{
return(new ResMsg(false, "要发送的数据不能为空"));
}
if ((offset + count) > buffer.Length)
{
return(new ResMsg(false, "要发送的数据长度不足"));
}
if (userToken.Socket == null || !userToken.Socket.Connected)
{
return(new ResMsg(false, "连接已断开"));
}
byte[] data = new byte[count];
Buffer.BlockCopy(buffer, 0, data, 0, count);
userToken.SendBuffer.Enqueue(data);
try
{
if (!userToken.m_sendAsync)
{
byte[] sendData;
if (userToken.SendBuffer.TryDequeue(out sendData) && sendData != null)
{
userToken.m_sendAsync = true;
return(SendAsyncEvent(userToken, sendData, 0, sendData.Length));
}
}
return(new ResMsg(true, ""));
}
catch (Exception ex)
{
return(new ResMsg {
Result = false, Message = ex.Message, RefObj = ex
});
}
}
/// <summary>
/// 只要在套接字上完成了接收或发送操作，就会调用此方法
/// </summary>
/// <param name="sender"></param>
/// <param name="e">与完成的接收操作相关联的SocketAsyncEventArg</param>
private void IO_Completed(object sender, SocketAsyncEventArgs e)
{
AsyncUserToken userToken = e.UserToken as AsyncUserToken;
try
{
//确定刚刚完成的操作类型并调用关联的处理程序
if (e.LastOperation == SocketAsyncOperation.Receive)
{
ProcessReceive(e);
}
else if (e.LastOperation == SocketAsyncOperation.Send)
{
ProcessSend(e);
}
else
{
throw new ArgumentException("在套接字上完成的最后一个操作不是接收或发送");
}
}
catch (Exception ex)
{
}
}
public DataPacket(AsyncUserToken userToken, byte[] data)
{
_userToken = userToken;
_data = data;
}
