/// <summary>
/// 获取当前的数据
/// </summary>
/// <returns></returns>
public SendBuffer Dequeue()
{
SendBuffer sendGram = SendBuffer.NullBuffer;
SpinLockEx.ReliableEnter(ref m_LockFlushAndPending);
try
{
if (m_PendingBuffer.Count > 0)
{
sendGram = m_PendingBuffer.Dequeue(); // 再给出数据
}
else if (m_FlushBuffer.IsNull == false)
{
sendGram = m_FlushBuffer; // 再给出数据
m_FlushBuffer = SendBuffer.NullBuffer;
}
// 移去已发送的数据的大小
m_WaitSendSize -= sendGram.Length;
}
catch (Exception e) { Logs.FatalError("SendQueue->Dequeue: Occurred error when dequeuing the data {0} ", e.Message); }
finally
{
m_LockFlushAndPending.Exit();
}
return(sendGram);
}
/// <summary>
/// 添加多个监听端口的数据传过来
/// </summary>
/// <param name="listener"></param>
public void AddListener(Listener listener)
{
if (listener == null)
{
throw new ArgumentNullException("listener", "MessagePump.AddListener(...) - listener == null error!");
}
if (listener.World != null && listener.World != World)
{
throw new ArgumentException("MessagePump.AddListener(...) - listener.World != null && listener.World != this.World error!", "listener.World");
}
// 检查是否有相同的监听器
Listener[] listenerArray = m_Listeners;
for (int iIndex = 0; iIndex < listenerArray.Length; iIndex++)
{
Listener itemListener = listenerArray[iIndex];
if (itemListener == listener)
{
return;
}
}
SpinLockEx.ReliableEnter(ref m_OnlyLockAddListener);
try
{
// 创建新的Listener数组,添加数据,交换数组数据,不需要锁定,没有引用时自动会回收数据
Listener[] tempListener = new Listener[m_Listeners.Length + 1];
for (int iIndex = 0; iIndex < m_Listeners.Length; ++iIndex)
{
tempListener[iIndex] = m_Listeners[iIndex];
}
tempListener[m_Listeners.Length] = listener;
listener.World = m_World;
m_Listeners = tempListener;
}
finally
{
m_OnlyLockAddListener.Exit();
}
}
/// <summary>
/// 添加多个连接端口的数据传过来
/// </summary>
public void AddConnecter(Connecter connecter)
{
if (connecter == null)
{
throw new ArgumentNullException("connecter", "MessagePump.AddConnecter(...) - connecter == null error!");
}
if (connecter.World != null && connecter.World != World)
{
throw new ArgumentException("connecter.World", "MessagePump.AddConnecter(...) - connecter.World != null && connecter.World != this.World error!");
}
// 检查是否有相同的连接器
Connecter[] connecterArray = m_Connecters;
for (int iIndex = 0; iIndex < connecterArray.Length; iIndex++)
{
Connecter itemConnecter = connecterArray[iIndex];
if (itemConnecter == connecter)
{
return;
}
}
SpinLockEx.ReliableEnter(ref m_OnlyLockAddConnecter);
{
// 创建新的Listener数组,添加数据,交换数组数据,不需要锁定,没有引用时自动会回收数据
Connecter[] tempConnecter = new Connecter[m_Connecters.Length + 1];
for (int iIndex = 0; iIndex < m_Connecters.Length; ++iIndex)
{
tempConnecter[iIndex] = m_Connecters[iIndex];
}
tempConnecter[m_Connecters.Length] = connecter;
connecter.World = m_World;
m_Connecters = tempConnecter;
}
m_OnlyLockAddConnecter.Exit();
}
/// <summary>
/// 清除数据
/// </summary>
public void Clear()
{
SpinLockEx.ReliableEnter(ref m_LockFlushAndPending);
try
{
while (m_PendingBuffer.Count > 0)
{
m_PendingBuffer.Dequeue().Release();
}
if (m_FlushBuffer.IsNull == false)
{
m_FlushBuffer.Release();
m_FlushBuffer = SendBuffer.NullBuffer;
}
// 清空
m_WaitSendSize = 0;
}
finally
{
m_LockFlushAndPending.Exit();
}
}
// 可能是windows操作系统的最大可发送的字节数
//private const int PENDING_MAX_BUFFER = 96 * 1024;
#endregion
/// <summary>
/// 如果数据满了,且缓冲区内的数据是空的则返回需要发送的数据
/// 调用Enqueue(...)后调用Dequeue(...),不能直接调用Dequeue(...)
/// </summary>
/// <param name="byteBuffer"></param>
/// <param name="iOffset"></param>
/// <param name="iLength"></param>
/// <returns></returns>
public void Enqueue(byte[] byteBuffer, long iOffset, long iLength)
{
if (byteBuffer == null)
{
throw new ArgumentNullException("byteBuffer", "SendQueue.Enqueue(...) - byteBuffer == null error!");
}
if (iOffset < 0 || iOffset >= byteBuffer.Length)
{
throw new Exception("SendQueue.Enqueue(...) - iOffset < 0 || iOffset >= byteBuffer.Length error!");
}
if (iLength < 0 || iLength > byteBuffer.Length) // 如果iLength == 0就返回空,如果iLength == 0就跳过
{
throw new Exception("SendQueue.Enqueue(...) - iLength < 0 || iLength > byteBuffer.Length error!");
}
if ((byteBuffer.Length - iOffset) < iLength)
{
throw new Exception("SendQueue.Enqueue(...) - ( byteBuffer.Length - iOffset ) < iLength error!");
}
SpinLockEx.ReliableEnter(ref m_LockFlushAndPending);
try
{
do
{
if (m_FlushBuffer.IsNull == true)
{
// nothing yet buffered
m_FlushBuffer = SendBuffer.Instance();
if (m_FlushBuffer.IsNull == true)
{
throw new Exception("SendQueue.Enqueue(...) - m_FlushBuffer.IsNull == true error!");
}
}
// 当前已经写入的字节
long iBytesWritten = m_FlushBuffer.Write(byteBuffer, iOffset, iLength);
iOffset += iBytesWritten;
iLength -= iBytesWritten;
// 写入需要发送的数据的大小
m_WaitSendSize += iBytesWritten;
// 如果数据没有满,且数据写入完毕则退出,返回空,不添加到集合内
if (m_FlushBuffer.IsFull == true)
{
// 如果满了添加到集合内的尾处
m_PendingBuffer.Enqueue(m_FlushBuffer);
m_FlushBuffer = SendBuffer.NullBuffer; // 置空再次请求缓存
}
} while (iLength > 0);
}
catch (Exception e)
{
Logs.Error("SendQueue->Enqueue: Occurred error when enqueuing the data {0} ", e);
}
finally
{
m_LockFlushAndPending.Exit();
}
}
