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 = ,
/// <summary>
/// Sun SPARC, Motorola 68000，Java Virtual Machine
/// </summary>
BIG_ENDIAN = ,
}
public class ReceiveQueue
{
#region zh-CHS 类常量 | en Class Constants
/// <summary>
/// 字节默认的大小
/// </summary>
private const long BUFFER_SIZE = * ;
#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 < || iOffset >= byteBuffer.Length)
throw new Exception("ReceiveQueue.Dequeue(...) - iOffset < 0 || iOffset >= byteBuffer.Length error!");
if (iSize < || 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 == )
return ;
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, , byteBuffer, (int)(iOffset + rightLength), (int)(iSize - rightLength));
}
}
m_Head = (m_Head + iSize) % m_Buffer.Length;
m_Size -= iSize;
if (m_Size == )
{
m_Head = ;
m_Tail = ;
}
}
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 < || iOffset >= byteBuffer.Length)
throw new Exception("ReceiveQueue.Enqueue(...) - iOffset < 0 || iOffset >= byteBuffer.Length error!");
if (iSize < || 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 + ) & ~); // 总是以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, , (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 = ;
m_Tail = ;
m_Size = ;
}
}
/// <summary>
///
/// </summary>
private Endian m_Endian = Endian.BIG_ENDIAN;
/// <summary>
/// 包的长度
/// </summary>
public const int PacketLengthSize = ;
/// <summary>
/// 包的长度
/// </summary>
public const int PacketHeadLengthSize = ;
/// <summary>
/// 给出数据包的长度
/// </summary>
/// <returns></returns>
public int GetPacketLength()
{
int iReturn = ;
lock (m_LockBuffer)
{
if (PacketLengthSize > m_Size)
return ;
if (m_Head + PacketLengthSize < m_Buffer.Length)
{
// 保证要读取的数据在字节数组里
var index = m_Head;
// 读四字节长度
if (m_Endian == Endian.LITTLE_ENDIAN)
return (m_Buffer[index] << ) | (m_Buffer[index+] << ) | (m_Buffer[index+] << ) | m_Buffer[index+];
else
return m_Buffer[index] | (m_Buffer[index + ] << ) | (m_Buffer[index + ] << ) | (m_Buffer[index + ] << );
//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 = ;
lock (m_LockBuffer)
{
if (PacketLengthSize + PacketHeadLengthSize > m_Size)
return ;
if (m_Head + PacketLengthSize + PacketHeadLengthSize < m_Buffer.Length)
{
// 保证要读取的数据在字节数组里
var index = m_Head + PacketLengthSize;
// 读四字节长度
if (m_Endian == Endian.LITTLE_ENDIAN)
return (m_Buffer[index] << ) | (m_Buffer[index + ] << ) | (m_Buffer[index + ] << ) | m_Buffer[index + ];
else
return m_Buffer[index] | (m_Buffer[index + ] << ) | (m_Buffer[index + ] << ) | (m_Buffer[index + ] << );
//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 > )
{
if (m_Head < m_Tail)
Buffer.BlockCopy(m_Buffer, (int)m_Head, newBuffer, , (int)m_Size);
else
{
long rightLength = m_Buffer.Length - m_Head;
Buffer.BlockCopy(m_Buffer, (int)m_Head, newBuffer, , (int)rightLength);
Buffer.BlockCopy(m_Buffer, , newBuffer, (int)rightLength, (int)m_Tail);
}
}
m_Head = ;
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, , e.BytesReceived);
nMsgLen = e.BytesReceived;
}
if (nMsgLen <= )
{
break;
}
if (package_len > && head_len > )
{
e.ReceiveBufferQueue.Enqueue(data, , e.BytesReceived);
if (e.ReceiveBufferQueue.Length == package_len + )
{
lock (this)
{
package_len = ;
head_len = ;
byte[] temp = new byte[e.ReceiveBufferQueue.Length];
int len = (int)e.ReceiveBufferQueue.Dequeue(temp, , e.ReceiveBufferQueue.Length);
ExecGateBuffers(GateIdx, Gate, temp, len);
M2Share.MainOutMessage(string.Format("=========={0}", len));
break;
}
}
}
if (package_len > && head_len == )
{
Array.Reverse(data);
e.ReceiveBufferQueue.Enqueue(data, , e.BytesReceived);
head_len = e.ReceiveBufferQueue.GetPacketHeadLength();
M2Share.MainOutMessage(string.Format("head_len : {0}", head_len));
}
if (package_len == )
{
Array.Reverse(data);
e.ReceiveBufferQueue.Enqueue(data, , e.BytesReceived);
package_len = e.ReceiveBufferQueue.GetPacketLength();
M2Share.MainOutMessage(string.Format("package_len : {0}", package_len));
}
break;
}