public override void Flush()
{
WriteSyncResult writeResult = new WriteSyncResult();
this.owner.TryCompleteFlushRequest(writeResult);
writeResult.WaitFor();
}
public override void Write(byte[] buffer, int offset, int count)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (offset >= buffer.Length)
{
throw new ArgumentOutOfRangeException("offset");
}
if (offset + count > buffer.Length)
{
throw new ArgumentOutOfRangeException("count");
}
WriteSyncResult writeResult = new WriteSyncResult();
this.owner.TryCompleteWriteRequest(buffer, offset, count, writeResult);
writeResult.WaitFor();
}
public override void Write(byte[] buffer, int offset, int count)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (offset >= buffer.Length)
{
throw new ArgumentOutOfRangeException("offset");
}
if (offset + count > buffer.Length)
{
throw new ArgumentOutOfRangeException("count");
}
WriteSyncResult writeResult = new WriteSyncResult();
this.owner.TryCompleteWriteRequest(buffer, offset, count, writeResult);
writeResult.WaitFor();
}
public override void Flush()
{
WriteSyncResult writeResult = new WriteSyncResult();
this.owner.TryCompleteFlushRequest(writeResult);
writeResult.WaitFor();
}
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
Debug.WriteLine("BNS ({0}): BeginWrite (buffer, {1}, {2}) [m_outputBuffer_pos = {3}]", NetworkStream.InternalSocket.InternalRemoteEndPoint, offset, count,
m_outputBuffer_pos);
if (buffer == null)
{
throw new ArgumentNullException("buffer is null");
}
int len = buffer.Length;
if (offset < 0 || offset > len)
{
throw new ArgumentOutOfRangeException("offset exceeds the size of buffer");
}
if (count < 0 || offset + count > len)
{
throw new ArgumentOutOfRangeException("offset+size exceeds the size of buffer");
}
CheckObjectDisposedException();
if (!m_stream.CanWrite)
{
throw new NotSupportedException(Locale.GetText("Cannot write to stream"));
}
if (m_nagleTimer == null)
{
return(m_stream.BeginWrite(buffer, offset, count, callback, state));
}
var avail = m_bufferSize - m_outputBuffer_pos;
if (count <= avail)
{
EnsureOutputBuffer();
m_lockFlush.Acquire();
try
{
Buffer.BlockCopy(buffer, offset, m_outputBuffer, m_outputBuffer_pos, count);
m_outputBuffer_pos += count;
if (m_outputBuffer_pos == m_bufferSize)
{
m_nagleTimer.Stop();
m_outputBuffer_pos = 0;
return(m_stream.BeginWrite(m_outputBuffer, 0, m_bufferSize, callback, state));
}
m_nagleTimer.Reset(200);
var wsr = new WriteSyncResult
{
AsyncState = state
};
if (callback != null)
{
callback.BeginInvokeEx(wsr, null, null);
}
return(wsr);
}
finally
{
m_lockFlush.Release();
}
}
if (m_outputBuffer_pos == 0 && count > m_bufferSize)
{
return(m_stream.BeginWrite(buffer, offset, count, callback, state));
}
if (m_inputBuffer_pos != 0)
{
m_lockFlush.Acquire();
try
{
if (m_outputBuffer_pos != 0)
{
m_nagleTimer.Stop();
if (count <= m_bufferSize)
{
var tbuffer = new byte[m_outputBuffer_pos + count];
Buffer.BlockCopy(m_outputBuffer, 0, tbuffer, 0, m_outputBuffer_pos);
Buffer.BlockCopy(buffer, offset, tbuffer, m_outputBuffer_pos, count);
m_outputBuffer_pos = 0;
return(m_stream.BeginWrite(tbuffer, 0, tbuffer.Length, callback, state));
}
var war = new WriteAsyncResult
{
AsyncState = state
};
m_stream.BeginWrite(m_outputBuffer, 0, m_outputBuffer_pos, iar =>
{
var ws = (WriteState)iar.AsyncState;
m_stream.EndWrite(iar);
m_stream.BeginWrite(ws.buffer, ws.offset, ws.count, iar2 =>
{
var ws2 = (WriteState)iar.AsyncState;
m_stream.EndWrite(iar2);
ws2.writeAsyncResult.IsCompleted = true;
((CEvent)ws2.writeAsyncResult.AsyncWaitHandle).Set();
if (ws2.callback != null)
{
try
{
ws2.callback(ws2.writeAsyncResult);
}
catch
{
}
}
}, ws);
}, new WriteState
{
writeAsyncResult = war,
callback = callback,
buffer = buffer,
offset = offset,
count = count,
});
m_outputBuffer_pos = 0;
return(war);
}
}
finally
{
m_lockFlush.Release();
}
}
return(m_stream.BeginWrite(buffer, offset, count, callback, state));
}
