ReceiveQueue

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace NetFramework
{
/// <summary>
/// 计算机如何存储大数值的体系结构
/// </summary>
public enum Endian
{
/// <summary>
///  Intel x86，AMD64，DEC VAX
/// </summary>
LITTLE_ENDIAN = 0,
/// <summary>
/// Sun SPARC, Motorola 68000，Java Virtual Machine
/// </summary>
BIG_ENDIAN = 1,
}

public class ReceiveQueue
{
#region zh-CHS 类常量 | en Class Constants
/// <summary>
/// 字节默认的大小
/// </summary>
private const long BUFFER_SIZE = 1024 * 32;
#endregion

#region zh-CHS 私有成员变量 | en Private Member Variables
/// <summary>
/// 字节的头位置
/// </summary>
private long m_Head;
/// <summary>
/// 字节的尾位置
/// </summary>
private long m_Tail;
/// <summary>
/// 字节的数组
/// </summary>
private byte[] m_Buffer = new byte[BUFFER_SIZE];
/// <summary>
///
/// </summary>
private object m_LockBuffer = new object();
#endregion

#region zh-CHS 属性 | en Properties
#region zh-CHS 私有成员变量 | en Private Member Variables
/// <summary>
/// 字节的大小
/// </summary>
private long m_Size;
#endregion
/// <summary>
/// 环绕缓冲区内的数据大小
/// </summary>
public long Length
{
get { return m_Size; }
}

#endregion

#region zh-CHS 方法 | en Method
/// <summary>
/// 给出使用环绕缓冲区内的数据
/// </summary>
/// <param name="byteBuffer">要复制到的数据的数组</param>
/// <param name="iOffset">要复制到数组的长度偏移量</param>
/// <param name="iSize">要复制多少长度的数据</param>
/// <returns>返回实际读取到的字节数</returns>
public long Dequeue(byte[] byteBuffer, long iOffset, long iSize)
{
if (byteBuffer == null)
throw new ArgumentNullException("byteBuffer", "ReceiveQueue.Dequeue(...) - byteBuffer == null error!");

if (iOffset < 0 || iOffset >= byteBuffer.Length)
throw new Exception("ReceiveQueue.Dequeue(...) - iOffset < 0 || iOffset >= byteBuffer.Length error!");

if (iSize < 0 || iSize > byteBuffer.Length) // 如果iLength == 0就返回空,如果iLength == 0就跳过
throw new Exception("ReceiveQueue.Dequeue(...) - iSize < 0 || iSize > byteBuffer.Length error!");

if ((byteBuffer.Length - iOffset) < iSize)
throw new Exception("ReceiveQueue.Dequeue(...) - ( byteBuffer.Length - iOffset ) < iSize error!");

if (iSize == 0)
return 0;

lock (m_LockBuffer)
{
if (iSize > m_Size)
iSize = m_Size;

if (m_Head < m_Tail)
Buffer.BlockCopy(m_Buffer, (int)m_Head, byteBuffer, (int)iOffset, (int)iSize);
else
{
long rightLength = m_Buffer.Length - m_Head;

if (rightLength >= iSize)
Buffer.BlockCopy(m_Buffer, (int)m_Head, byteBuffer, (int)iOffset, (int)iSize);
else
{
Buffer.BlockCopy(m_Buffer, (int)m_Head, byteBuffer, (int)iOffset, (int)rightLength);
Buffer.BlockCopy(m_Buffer, 0, byteBuffer, (int)(iOffset + rightLength), (int)(iSize - rightLength));
}
}

m_Head = (m_Head + iSize) % m_Buffer.Length;
m_Size -= iSize;

if (m_Size == 0)
{
m_Head = 0;
m_Tail = 0;
}
}

return iSize;
}

/// <summary>
/// 压入数据至环绕缓冲区内
/// </summary>
/// <param name="byteBuffer"></param>
/// <param name="iOffset"></param>
/// <param name="iSize"></param>
public void Enqueue(byte[] byteBuffer, long iOffset, long iSize)
{
if (byteBuffer == null)
throw new ArgumentNullException("byteBuffer", "ReceiveQueue.Enqueue(...) - byteBuffer == null error!");

if (iOffset < 0 || iOffset >= byteBuffer.Length)
throw new Exception("ReceiveQueue.Enqueue(...) - iOffset < 0 || iOffset >= byteBuffer.Length error!");

if (iSize < 0 || iSize > byteBuffer.Length) // 如果iLength == 0就返回空,如果iLength == 0就跳过
throw new Exception("ReceiveQueue.Enqueue(...) - iSize < 0 || iSize > byteBuffer.Length error!");

if ((byteBuffer.Length - iOffset) < iSize)
throw new Exception("ReceiveQueue.Enqueue(...) - ( byteBuffer.Length - iOffset ) < iSize error!");

lock (m_LockBuffer)
{
if ((m_Size + iSize) >= m_Buffer.Length)
SetCapacityInLock((m_Size + iSize + 2047) & ~2047); // 总是以2048的倍数来增大字节数, :( 弄得我老半天才明白原理呢!

if (m_Head < m_Tail)
{
long rightLength = m_Buffer.Length - m_Tail;

if (rightLength >= iSize)
Buffer.BlockCopy(byteBuffer, (int)iOffset, m_Buffer, (int)m_Tail, (int)iSize);
else
{
Buffer.BlockCopy(byteBuffer, (int)iOffset, m_Buffer, (int)m_Tail, (int)rightLength);
Buffer.BlockCopy(byteBuffer, (int)(iOffset + rightLength), m_Buffer, 0, (int)(iSize - rightLength));
}
}
else
Buffer.BlockCopy(byteBuffer, (int)iOffset, m_Buffer, (int)m_Tail, (int)iSize);

m_Tail = (m_Tail + iSize) % m_Buffer.Length;
m_Size += iSize;
}
}

/// <summary>
/// 清除数据的信息,不清除数据缓冲,用于下次使用
/// </summary>
public void Clear()
{
lock (m_LockBuffer)
{
m_Head = 0;
m_Tail = 0;
m_Size = 0;
}

}

/// <summary>
///
/// </summary>
private Endian m_Endian = Endian.BIG_ENDIAN;

/// <summary>
/// 包的长度
/// </summary>
public const int PacketLengthSize = 4;

/// <summary>
/// 包的长度
/// </summary>
public const int PacketHeadLengthSize = 4;

/// <summary>
/// 给出数据包的长度
/// </summary>
/// <returns></returns>
public int GetPacketLength()
{
int iReturn = 0;

lock (m_LockBuffer)
{
if (PacketLengthSize > m_Size)
return 0;

if (m_Head + PacketLengthSize < m_Buffer.Length)
{
//  保证要读取的数据在字节数组里
var index = m_Head;

//  读四字节长度
if (m_Endian == Endian.LITTLE_ENDIAN)
return (m_Buffer[index] << 24) | (m_Buffer[index+1] << 16) | (m_Buffer[index+2] << 8) | m_Buffer[index+3];
else
return m_Buffer[index] | (m_Buffer[index + 1] << 8) | (m_Buffer[index + 2] << 16) | (m_Buffer[index + 3] << 24);

//if (m_Endian == Endian.LITTLE_ENDIAN)
//    return (m_Buffer[index] << 8) | (m_Buffer[index + 1]);
//else
//    return m_Buffer[index] | (m_Buffer[index + 1] << 8);
}
}

return iReturn;
}

/// <summary>
/// 给出数据包头部的长度
/// </summary>
/// <returns></returns>
public int GetPacketHeadLength()
{
int iReturn = 0;

lock (m_LockBuffer)
{
if (PacketLengthSize + PacketHeadLengthSize > m_Size)
return 0;

if (m_Head + PacketLengthSize + PacketHeadLengthSize < m_Buffer.Length)
{
//  保证要读取的数据在字节数组里
var index = m_Head + PacketLengthSize;

//  读四字节长度
if (m_Endian == Endian.LITTLE_ENDIAN)
return (m_Buffer[index] << 24) | (m_Buffer[index + 1] << 16) | (m_Buffer[index + 2] << 8) | m_Buffer[index + 3];
else
return m_Buffer[index] | (m_Buffer[index + 1] << 8) | (m_Buffer[index + 2] << 16) | (m_Buffer[index + 3] << 24);

//if (m_Endian == Endian.LITTLE_ENDIAN)
//    return (m_Buffer[index] << 8) | (m_Buffer[index + 1]);
//else
//    return m_Buffer[index] | (m_Buffer[index + 1] << 8);
}
}

return iReturn;
}

#endregion

#region zh-CHS 私有方法 | en Private Method
/// <summary>
/// 扩大缓冲数据的大小(当前都在锁中操作，因此不需要锁定的)
/// </summary>
/// <param name="iCapacity"></param>
private void SetCapacityInLock(long iCapacity)
{
byte[] newBuffer = new byte[iCapacity];

if (m_Size > 0)
{
if (m_Head < m_Tail)
Buffer.BlockCopy(m_Buffer, (int)m_Head, newBuffer, 0, (int)m_Size);
else
{
long rightLength = m_Buffer.Length - m_Head;

Buffer.BlockCopy(m_Buffer, (int)m_Head, newBuffer, 0, (int)rightLength);
Buffer.BlockCopy(m_Buffer, 0, newBuffer, (int)rightLength, (int)m_Tail);
}
}

m_Head = 0;
m_Tail = m_Size;
m_Buffer = newBuffer;
}
#endregion
}
}

while (true)
{
if (e.ReceiveBuffer != null)
{
data = new byte[e.BytesReceived];
Array.Copy(e.ReceiveBuffer, e.Offset, data, 0, e.BytesReceived);
nMsgLen = e.BytesReceived;
}
if (nMsgLen <= 0)
{
break;
}

if (package_len > 0 && head_len > 0)
{
e.ReceiveBufferQueue.Enqueue(data, 0, e.BytesReceived);
if (e.ReceiveBufferQueue.Length == package_len + 8)
{
lock (this)
{
package_len = 0;
head_len = 0;
byte[] temp = new byte[e.ReceiveBufferQueue.Length];
int len = (int)e.ReceiveBufferQueue.Dequeue(temp, 0, e.ReceiveBufferQueue.Length);
ExecGateBuffers(GateIdx, Gate, temp, len);
M2Share.MainOutMessage(string.Format("=========={0}", len));
break;
}
}
}

if (package_len > 0 && head_len == 0)
{
Array.Reverse(data);
e.ReceiveBufferQueue.Enqueue(data, 0, e.BytesReceived);
head_len = e.ReceiveBufferQueue.GetPacketHeadLength();
M2Share.MainOutMessage(string.Format("head_len : {0}", head_len));
}

if (package_len == 0)
{
Array.Reverse(data);
e.ReceiveBufferQueue.Enqueue(data, 0, e.BytesReceived);
package_len = e.ReceiveBufferQueue.GetPacketLength();
M2Share.MainOutMessage(string.Format("package_len : {0}", package_len));
}
break;
}