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");
}
internal void Release(ArrayPool <RpcValue> rpcValueArrayPool
, ObjectPool <RpcValue> rpcValuePool)
{
switch (ValueType)
{
case ValueType.Byte:
case ValueType.Short:
case ValueType.Int:
case ValueType.Long:
case ValueType.Float:
case ValueType.Double:
MDebug.Assert(ArrayValue == null
, "Rpc"
, "ArrayValue == null");
break;
case ValueType.FixedValueTypeArray:
case ValueType.VariableValueTypeArray:
int startPoint = ArrayValue.GetOffset();
int endPoint = startPoint + ArrayValue.GetSize();
RpcValue[] elements = ArrayValue.GetBuffer();
for (int iElement = startPoint; iElement < endPoint; iElement++)
{
RpcValue iterElement = elements[iElement];
iterElement.Release(rpcValueArrayPool, rpcValuePool);
rpcValuePool.Release(iterElement);
elements[iElement] = null;
}
rpcValueArrayPool.ReleaseBuffer(ArrayValue);
ArrayValue = null;
break;
default:
throw new Exception("Not support ValueType: " + ValueType);
}
}
public override void OnUpdate(float deltaTime)
{
lock (m_TcpConnectActionLock)
{
if (m_TcpConnectData != null)
{
try
{
switch (m_TcpConnectData.ConnectState)
{
case ConnectState.Connected:
OnConnected?.Invoke(m_TcpConnectData);
break;
case ConnectState.ConnectFailed:
OnConnectFailed?.Invoke(m_TcpConnectData);
break;
case ConnectState.Disconnected:
OnDisconnected?.Invoke(m_TcpConnectData);
break;
default:
MDebug.Assert(false, LOG_TAG, "Not handle ConnectState: " + m_TcpConnectData.ConnectState);
break;
}
}
catch (Exception e)
{
MDebug.LogError(LOG_TAG
, $"Inove connect:{m_TcpConnectData.ConnectState} Exception:\n{e.ToString()}");
}
m_TcpConnectData = null;
}
}
if (!IsConnected() ||
m_ReceivedPackages2 == null)
{
return;
}
int packageCount;
lock (m_ReceiveLock)
{
packageCount = m_ReceivedPackages.Count;
if (m_ReceivedPackages2.Capacity < packageCount)
{
m_ReceivedPackages2.Capacity = m_ReceivedPackages2.Capacity * 2;
m_ReceivedPackages2._SetCount(m_ReceivedPackages2.Capacity);
}
for (int iPackage = 0; iPackage < packageCount; iPackage++)
{
m_ReceivedPackages2[iPackage] = m_ReceivedPackages.Dequeue();
}
#if GF_DEBUG
MDebug.Assert(m_ReceivedPackages.Count == 0, LOG_TAG, "m_ReceivedPackages.Count == 0");
#endif
}
if (packageCount > 0)
{
if (OnReceivedPackage != null)
{
for (int iPackage = 0; iPackage < packageCount; iPackage++)
{
ArrayPool <byte> .Node iterPackage = m_ReceivedPackages2[iPackage];
try
{
OnReceivedPackage.Invoke(iterPackage);
}
catch (Exception e)
{
MDebug.LogError(LOG_TAG
, $"Invoke OnReceivedPackage length: {iterPackage.GetSize()}. Exception:\n{e.ToString()}");
}
}
}
lock (m_BufferPool)
{
for (int iPackage = 0; iPackage < packageCount; iPackage++)
{
m_BufferPool.ReleaseBuffer(m_ReceivedPackages2[iPackage]);
m_ReceivedPackages2[iPackage] = null;
}
}
}
}
