|
private BeginWrite ( |
||
| request | ||
| buffer | byte | |
| offset | int | |
| size | int | |
| cb | AsyncCallback | |
| state | object | |
| Результат | IAsyncResult | |
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int size, AsyncCallback cb, object state)
{
if (request.Aborted)
{
throw new WebException("The request was canceled.", null, WebExceptionStatus.RequestCanceled);
}
if (isRead)
{
throw new NotSupportedException("this stream does not allow writing");
}
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
int num = buffer.Length;
if (offset < 0 || num < offset)
{
throw new ArgumentOutOfRangeException("offset");
}
if (size < 0 || num - offset < size)
{
throw new ArgumentOutOfRangeException("size");
}
if (sendChunked)
{
lock (locker)
{
pendingWrites++;
pending.Reset();
}
}
WebAsyncResult webAsyncResult = new WebAsyncResult(cb, state);
if (!sendChunked)
{
CheckWriteOverflow(request.ContentLength, totalWritten, size);
}
if (allowBuffering && !sendChunked)
{
if (writeBuffer == null)
{
writeBuffer = new MemoryStream();
}
writeBuffer.Write(buffer, offset, size);
totalWritten += size;
if (request.ContentLength > 0 && totalWritten == request.ContentLength)
{
try
{
webAsyncResult.AsyncWriteAll = true;
webAsyncResult.InnerAsyncResult = WriteRequestAsync(WriteRequestAsyncCB, webAsyncResult);
if (webAsyncResult.InnerAsyncResult != null)
{
return(webAsyncResult);
}
if (!webAsyncResult.IsCompleted)
{
webAsyncResult.SetCompleted(synch: true, 0);
}
webAsyncResult.DoCallback();
return(webAsyncResult);
}
catch (Exception e)
{
webAsyncResult.SetCompleted(synch: true, e);
webAsyncResult.DoCallback();
return(webAsyncResult);
}
}
webAsyncResult.SetCompleted(synch: true, 0);
webAsyncResult.DoCallback();
return(webAsyncResult);
}
AsyncCallback cb2 = null;
if (cb != null)
{
cb2 = WriteCallbackWrapper;
}
if (sendChunked)
{
WriteRequest();
string s = $"{size:X}\r\n";
byte[] bytes = Encoding.ASCII.GetBytes(s);
int num2 = 2 + size + bytes.Length;
byte[] array = new byte[num2];
Buffer.BlockCopy(bytes, 0, array, 0, bytes.Length);
Buffer.BlockCopy(buffer, offset, array, bytes.Length, size);
Buffer.BlockCopy(crlf, 0, array, bytes.Length + size, crlf.Length);
buffer = array;
offset = 0;
size = num2;
}
webAsyncResult.InnerAsyncResult = cnc.BeginWrite(request, buffer, offset, size, cb2, webAsyncResult);
totalWritten += size;
return(webAsyncResult);
}
public override IAsyncResult BeginWrite(byte [] buffer, int offset, int size,
AsyncCallback cb, object state)
{
if (request.Aborted)
{
throw new WebException("The request was canceled.", null, WebExceptionStatus.RequestCanceled);
}
if (isRead)
{
throw new NotSupportedException("this stream does not allow writing");
}
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
int length = buffer.Length;
if (offset < 0 || length < offset)
{
throw new ArgumentOutOfRangeException("offset");
}
if (size < 0 || (length - offset) < size)
{
throw new ArgumentOutOfRangeException("size");
}
if (sendChunked)
{
lock (locker) {
pendingWrites++;
pending.Reset();
}
}
WebAsyncResult result = new WebAsyncResult(cb, state);
AsyncCallback callback = new AsyncCallback(WriteRequestAsyncCB);
if (sendChunked)
{
requestWritten = true;
string cSize = String.Format("{0:X}\r\n", size);
byte[] head = Encoding.ASCII.GetBytes(cSize);
int chunkSize = 2 + size + head.Length;
byte[] newBuffer = new byte [chunkSize];
Buffer.BlockCopy(head, 0, newBuffer, 0, head.Length);
Buffer.BlockCopy(buffer, offset, newBuffer, head.Length, size);
Buffer.BlockCopy(crlf, 0, newBuffer, head.Length + size, crlf.Length);
buffer = newBuffer;
offset = 0;
size = chunkSize;
}
else
{
CheckWriteOverflow(request.ContentLength, totalWritten, size);
if (allowBuffering)
{
if (writeBuffer == null)
{
writeBuffer = new MemoryStream();
}
writeBuffer.Write(buffer, offset, size);
totalWritten += size;
if (request.ContentLength <= 0 || totalWritten < request.ContentLength)
{
result.SetCompleted(true, 0);
result.DoCallback();
return(result);
}
result.AsyncWriteAll = true;
requestWritten = true;
buffer = writeBuffer.GetBuffer();
offset = 0;
size = (int)totalWritten;
}
}
try {
result.InnerAsyncResult = cnc.BeginWrite(request, buffer, offset, size, callback, result);
if (result.InnerAsyncResult == null)
{
if (!result.IsCompleted)
{
result.SetCompleted(true, 0);
}
result.DoCallback();
}
} catch (Exception) {
if (!IgnoreIOErrors)
{
throw;
}
result.SetCompleted(true, 0);
result.DoCallback();
}
totalWritten += size;
return(result);
}
public override IAsyncResult BeginWrite(byte [] buffer, int offset, int size,
AsyncCallback cb, object state)
{
if (isRead)
{
throw new NotSupportedException("this stream does not allow writing");
}
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
int length = buffer.Length;
if (size < 0 || offset < 0 || length < offset || length - offset < size)
{
throw new ArgumentOutOfRangeException();
}
if (sendChunked)
{
lock (locker) {
pendingWrites++;
pending.Reset();
}
}
WebAsyncResult result = new WebAsyncResult(cb, state);
if (allowBuffering)
{
if (max_buffer_size >= 0)
{
long avail = max_buffer_size - writeBuffer.Length;
if (size > avail)
{
if (requestWritten)
{
throw new ProtocolViolationException(
"The number of bytes to be written is greater than " +
"the specified ContentLength.");
}
}
}
writeBuffer.Write(buffer, offset, size);
if (!sendChunked)
{
result.SetCompleted(true, 0);
result.DoCallback();
return(result);
}
}
AsyncCallback callback = null;
if (cb != null)
{
callback = new AsyncCallback(WriteCallbackWrapper);
}
if (sendChunked)
{
WriteRequest();
string cSize = String.Format("{0:X}\r\n", size);
byte [] head = Encoding.ASCII.GetBytes(cSize);
int chunkSize = 2 + size + head.Length;
byte [] newBuffer = new byte [chunkSize];
Buffer.BlockCopy(head, 0, newBuffer, 0, head.Length);
Buffer.BlockCopy(buffer, offset, newBuffer, head.Length, size);
Buffer.BlockCopy(crlf, 0, newBuffer, head.Length + size, crlf.Length);
buffer = newBuffer;
offset = 0;
size = chunkSize;
}
result.InnerAsyncResult = cnc.BeginWrite(buffer, offset, size, callback, result);
return(result);
}
