public override int Read(byte[] buffer, int offset, int count)
{
if (!buffer.IsSafeIndex(offset, length: count))
{
throw new System.ArgumentException("Invalid offset/count combination [bufferSize:{0} offset:{1} count:{2}]".CheckedFormat(buffer.SafeLength(), offset, count));
}
int putToOffset = offset;
int totalCountTransferred = 0;
for (; totalCountTransferred < count;)
{
if (currentBuffer == null)
{
currentBufferListIndex++;
if (currentBufferListIndex < bufferList.SafeCount())
{
currentBuffer = bufferList[currentBufferListIndex];
currentBufferReadOffset = currentBuffer.header.Length;
currentBufferRemainingCount = Math.Max(0, currentBuffer.byteCount - currentBufferReadOffset);
}
}
if (currentBuffer == null)
{
break;
}
int iterCopyCount = Math.Min(count - totalCountTransferred, currentBufferRemainingCount);
byte [] copyFromBuffer = currentBuffer.byteArray;
if (iterCopyCount <= 8)
{
for (int idx = 0; idx < iterCopyCount; idx++)
{
buffer[putToOffset++] = copyFromBuffer[currentBufferReadOffset++];
}
}
else
{
System.Buffer.BlockCopy(copyFromBuffer, currentBufferReadOffset, buffer, putToOffset, iterCopyCount);
currentBufferReadOffset += iterCopyCount;
putToOffset += iterCopyCount;
}
currentBufferRemainingCount -= iterCopyCount;
totalCountTransferred += iterCopyCount;
if (currentBufferRemainingCount <= 0)
{
currentBuffer = null;
}
}
return(totalCountTransferred);
}
private static void SendCompleted(SocketAsyncEventArgs e)
{
SocketAsyncEventArgsX ex = (SocketAsyncEventArgsX)e;
Buffers.Buffer buffer = (Buffers.Buffer)ex.BufferX;
AsyncTcpClient tcpclient = (AsyncTcpClient)e.UserToken;
try
{
if (e.SocketError == SocketError.IOPending || e.SocketError == SocketError.Success)
{
System.Threading.Interlocked.Increment(ref tcpclient.mSendQuantity);
tcpclient.mSendBytes += e.BytesTransferred;
if (e.BytesTransferred < e.Count)
{
buffer.Postion = buffer.Postion + e.BytesTransferred;
buffer.SetLength(buffer.Length - e.BytesTransferred);
buffer.AsyncTo(tcpclient.mSendEventArgs, tcpclient.Socket);
}
else
{
IBuffer nextbuf = buffer.Next;
try
{
buffer.Completed?.Invoke(buffer);
}
catch
{
}
buffer.Free();
if (nextbuf != null)
{
tcpclient.CommitBuffer(nextbuf);
}
else
{
tcpclient.SendCompleted();
}
}
}
else
{
Buffers.Buffer.Free(ex.BufferX);
tcpclient.DisConnect();
tcpclient.ProcessError(new SocketException((int)e.SocketError), $"Send error {e.SocketError}");
}
if (tcpclient.SocketProcessHandler != null)
{
tcpclient.SocketProcessHandler.SendCompleted(tcpclient, e);
}
}
catch (Exception e_)
{
tcpclient.ProcessError(e_, "client network send error!");
}
}
public Rectangle2D(Vector3 position, Vector3 scale, float rotation, Color color)
{
vertexArray = new VertexArray();
FillIndexBuffer = new IndexBuffer(FillIndices);
vertexBuffer = new Buffers.Buffer(Vertices, 3);
vertexArray.AddBuffer(vertexBuffer, 0);
Position = Matrix4.CreateTranslation(position);
Scale = Matrix4.CreateScale(scale);
Rotation = Matrix4.CreateRotationZ(rotation);
Color = color;
}
internal void CommitBuffer(IBuffer buffer)
{
try
{
Buffers.Buffer bf = (Buffers.Buffer)buffer;
bf.UserToken = this;
((Buffers.Buffer)buffer).AsyncTo(this.mSendEventArgs, this.Socket);
}
catch (Exception e_)
{
Buffers.Buffer.Free(buffer);
DisConnect();
ProcessError(e_, "session send data error!");
}
}
internal void CommitBuffer(IBuffer buffer)
{
try
{
Buffers.Buffer bf = (Buffers.Buffer)buffer;
bf.UserToken = this;
/// <see cref="AsyncTcpClient.Connect"/> mSendEventArgs.Completed += IO_Completed
((Buffers.Buffer)buffer).AsyncTo(this.mSendEventArgs, this.Socket);
}
catch (Exception e_)
{
Buffers.Buffer.Free(buffer);
DisConnect();
ProcessError(e_, "session send data error!");
}
}
private void BeginReceive()
{
if (IsConnected)
{
Buffers.Buffer buffer = (Buffers.Buffer)ReceiveBufferPool.Pop();
buffer.UserToken = this;
try
{
buffer.AsyncFrom(mReceiveEventArgs, mSocket);
}
catch (Exception e_)
{
buffer.Free();
DisConnect();
ProcessError(e_, "client begin network receive error!");
}
}
}
public void BeginReceive()
{
if (IsConnected && System.Threading.Interlocked.Exchange(ref mReceiveState, 1) == 0)
{
Buffers.Buffer buffer = (Buffers.Buffer)BufferPool.Pop();
buffer.UserToken = this;
try
{
buffer.AsyncFrom(mReceiveEventArgs, mSocket);/// see ref=<see cref="SocketAsyncEventArgs.Completed"/>
}
catch (Exception e_)
{
InitReceiveState();
buffer.Free();
DisConnect();
ProcessError(e_, "client begin network receive error!");
}
}
}
private void OnWriterFlash(IBuffer data)
{
int index = 0;
if (data == null)
{
return;
}
Buffers.Buffer buffer = (Buffers.Buffer)data;
try
{
while (buffer != null)
{
buffer.To(Socket);
System.Threading.Interlocked.Add(ref mSendBytes, buffer.Length);
System.Threading.Interlocked.Increment(ref mSendQuantity);
index++;
var freebuf = buffer;
buffer = (Buffers.Buffer)buffer.Next;
freebuf.Free();
}
}
catch (ObjectDisposedException ode)
{
Buffers.Buffer.Free(buffer);
DisConnect();
throw ode;
}
catch (SocketException se)
{
Buffers.Buffer.Free(buffer);
DisConnect();
throw se;
}
catch (Exception e_)
{
Buffers.Buffer.Free(buffer);
throw e_;
}
}
private void BeginReceive()
{
if (IsConnected)
{
Buffers.Buffer buffer = (Buffers.Buffer)BufferPool.ReceiveDefault.Pop();
if (!buffer.BindIOCompleted)
{
buffer.BindIOEvent(IO_Completed);
}
buffer.UserToken = this;
try
{
buffer.AsyncFrom(mSocket);
}
catch (Exception e_)
{
buffer.Free();
DisConnect();
ProcessError(e_, "client begin network receive error!");
}
}
}
public Message Update(INamedValueSet buildPayloadDataFromNVS = null, string buildPayloadDataFromString = null, BufferHeaderFlags?orInFlags = null)
{
if (buildPayloadDataFromNVS != null)
{
NVS = buildPayloadDataFromNVS;
}
if (buildPayloadDataFromString != null)
{
String = buildPayloadDataFromString;
}
if (orInFlags != null)
{
Buffers.Buffer firstBuffer = bufferList.SafeAccess(0);
if (firstBuffer != null)
{
firstBuffer.Update(orInFlags: orInFlags);
}
}
return(this);
}
public override void Write(byte[] buffer, int offset, int count)
{
if (!buffer.IsSafeIndex(offset, length: count))
{
throw new System.ArgumentException("Invalid offset/count combination [bufferSize:{0} offset:{1} count:{2}]".CheckedFormat(buffer.SafeLength(), offset, count));
}
Buffers.BufferPool useBufferPool = message.bufferSourcePool ?? fallbackDefaultBufferPool;
int getFromOffset = offset;
int totalCountTransferred = 0;
for (; totalCountTransferred < count;)
{
if (currentBuffer == null)
{
QpcTimeStamp tsNow = QpcTimeStamp.Now;
currentBuffer = useBufferPool.Acquire(tsNow);
if (currentBuffer == null)
{
throw new System.OutOfMemoryException("Unable to acquire a buffer from the message bufferPool");
}
bufferList.Add(currentBuffer);
if (message.State == MessageState.Initial)
{
message.SetState(tsNow, MessageState.Data, "BufferListWriteStream.Write");
}
}
int iterCopyCount = Math.Min(count - totalCountTransferred, currentBuffer.AvailableSpace);
byte[] copyToBuffer = currentBuffer.byteArray;
if (iterCopyCount <= 8)
{
int copyToOffset = currentBuffer.byteCount;
for (int idx = 0; idx < iterCopyCount; idx++)
{
copyToBuffer[copyToOffset++] = buffer[getFromOffset++];
}
}
else
{
System.Buffer.BlockCopy(buffer, getFromOffset, copyToBuffer, currentBuffer.byteCount, iterCopyCount);
getFromOffset += iterCopyCount;
}
currentBuffer.byteCount += iterCopyCount;
if (currentBuffer.AvailableSpace <= 0)
{
currentBuffer = null;
}
totalCountTransferred += iterCopyCount;
}
}
