private void ProcessConnect(object sender, SocketAsyncEventArgs e) { if (e.SocketError == SocketError.Success) { MDebug.Log(LOG_TAG, $"Client({GetName()}) 连接成功"); m_BufferPool = new ArrayPool <byte>(1024 * 512); lock (m_TcpConnectActionLock) { m_TcpConnectData = new TcpConnectData(this, e, ConnectState.Connected); } m_IsSending = false; lock (m_BufferPool) { m_SendEventArgs = new SocketAsyncEventArgs(); m_SendEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(ProcessSend); m_SendingBuffer = m_BufferPool.AllocBuffer(DEFAULT_BUFFER_SIZE); m_WaitSendBuffer = m_BufferPool.AllocBuffer(DEFAULT_BUFFER_SIZE); m_WaitSendBufferSize = 0; m_SendEventArgs.SetBuffer(m_SendingBuffer.GetBuffer(), m_SendingBuffer.GetOffset(), 0); m_ReceiveEventArgs = new SocketAsyncEventArgs(); m_ReceiveEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(ProcessReceive); m_ReceiveBuffer = m_BufferPool.AllocBuffer(DEFAULT_BUFFER_SIZE); m_ReceiveEventArgs.SetBuffer(m_ReceiveBuffer.GetBuffer(), m_ReceiveBuffer.GetOffset(), m_ReceiveBuffer.GetSize()); m_ReceiveState = ReceiveState.ReceivingPackageLength; m_ReceivedPackageCount = 0; m_ReceiveHeaderBuffer = m_BufferPool.AllocBuffer(PACKAGE_HEADER_SIZE); } lock (m_ReceiveLock) { m_ReceivedPackages = new Queue <ArrayPool <byte> .Node>(); m_ReceivedPackages2 = new BetterList <ArrayPool <byte> .Node>(4); m_ReceivedPackages2._SetCount(m_ReceivedPackages2.Capacity); } StartReceive(); } else { MDebug.LogError(LOG_TAG , $"Client({GetName()}) 连接失败: {e.SocketError.ToString()}\n{e.ConnectByNameError.ToString()}"); lock (m_TcpConnectActionLock) { m_TcpConnectData = new TcpConnectData(this, e, ConnectState.ConnectFailed); } m_Client.Close(); m_Client = null; } }
public void Test(RpcValue paramater) { ArrayPool <byte> bufferPool = TcpClient.GetBufferPool(); ArrayPool <byte> .Node buffer; lock (bufferPool) { buffer = bufferPool.AllocBuffer(DEFAULT_BUFFER_SIZE); } int serializePoint = buffer.GetOffset(); paramater.Serialize(buffer.GetBuffer(), ref serializePoint); int dserializePoint = buffer.GetOffset(); paramater.Deserialize(RpcValueArrayPool , RpcValuePool , buffer.GetBuffer() , ref dserializePoint); lock (bufferPool) { bufferPool.ReleaseBuffer(buffer); } MDebug.Assert(serializePoint == dserializePoint , "Rpc" , "serializePoint == dserializePoint"); }
private void OnReceived(byte[] buffer, int offset, int count) { int remainCount = count; int readPosition = offset; while (remainCount > 0) { switch (m_ReceiveState) { case ReceiveState.ReceivingPackageLength: if (ReceiveToPackageBuffer(buffer , ref remainCount , ref readPosition , m_ReceiveHeaderBuffer , PACKAGE_HEADER_SIZE)) { // SIGN:TLength TLength packageLength = BitConverter.ToInt32(m_ReceiveHeaderBuffer.GetBuffer() , m_ReceiveHeaderBuffer.GetOffset()); lock (m_BufferPool) { m_ReceiveBodyBuffer = m_BufferPool.AllocBuffer(packageLength - PACKAGE_HEADER_SIZE); } m_ReceiveState = ReceiveState.ReceivingPackageBody; } break; case ReceiveState.ReceivingPackageBody: if (ReceiveToPackageBuffer(buffer , ref remainCount , ref readPosition , m_ReceiveBodyBuffer , m_ReceiveBodyBuffer.GetSize())) { lock (m_ReceiveLock) { m_ReceivedPackages.Enqueue(m_ReceiveBodyBuffer); } m_ReceiveBodyBuffer = null; m_ReceiveState = ReceiveState.ReceivingPackageLength; } break; } } }
/// <summary> /// 反序列化 /// <see cref="Serialize"/> /// </summary> public void Deserialize(ArrayPool <RpcValue> rpcValueArrayPool , ObjectPool <RpcValue> rpcValuePool , byte[] buffer , ref int offset , bool enableDeserializeValueType = true) { if (enableDeserializeValueType) { ValueType = (ValueType)buffer[offset]; offset++; } switch (ValueType) { case ValueType.Byte: ByteValue = buffer[offset]; offset++; break; case ValueType.Short: ShortValue = BitConverter.ToInt16(buffer, offset); offset += sizeof(short); break; case ValueType.Int: IntValue = BitConverter.ToInt32(buffer, offset); offset += sizeof(int); break; case ValueType.Long: LongValue = BitConverter.ToInt64(buffer, offset); offset += sizeof(long); break; case ValueType.Float: FloatValue = BitConverter.ToSingle(buffer, offset); offset += sizeof(float); break; case ValueType.Double: DoubleValue = BitConverter.ToDouble(buffer, offset); offset += sizeof(double); break; case ValueType.FixedValueTypeArray: { int elementCount = BitConverter.ToInt32(buffer, offset); offset += sizeof(int); ValueType elementValueType = (ValueType)buffer[offset]; offset++; ArrayValue = rpcValueArrayPool.AllocBuffer(elementCount); int endPoint = ArrayValue.GetOffset() + ArrayValue.GetSize(); RpcValue[] elements = ArrayValue.GetBuffer(); for (int iElement = ArrayValue.GetOffset(); iElement < endPoint; iElement++) { RpcValue iterElement = rpcValuePool.Alloc(); elements[iElement] = iterElement; iterElement.ValueType = elementValueType; iterElement.Deserialize(rpcValueArrayPool , rpcValuePool , buffer , ref offset , false); } } break; case ValueType.VariableValueTypeArray: { int elementCount = BitConverter.ToInt32(buffer, offset); offset += sizeof(int); ArrayValue = rpcValueArrayPool.AllocBuffer(elementCount); int endPoint = ArrayValue.GetOffset() + ArrayValue.GetSize(); RpcValue[] elements = ArrayValue.GetBuffer(); for (int iElement = ArrayValue.GetOffset(); iElement < endPoint; iElement++) { RpcValue iterElement = rpcValuePool.Alloc(); elements[iElement] = iterElement; iterElement.Deserialize(rpcValueArrayPool , rpcValuePool , buffer , ref offset); } } break; default: throw new Exception("Not support ValueType: " + ValueType); } }