/// <summary>
/// Sets the request stream.
/// </summary>
/// <param name="requestStreamContent">The content stream to copy into the request stream.</param>
internal void SetRequestStream(ContentStream requestStreamContent)
{
if (requestStreamContent.IsKnownMemoryStream)
{
this.SetContentLengthHeader();
}
#if DEBUG
this.ValidateHeaders();
#endif
using (Stream requestStream = this.requestMessage.GetStream())
{
if (requestStreamContent.IsKnownMemoryStream)
{
MemoryStream bufferableStream = (MemoryStream)requestStreamContent.Stream;
Debug.Assert(bufferableStream.Position == 0, "Cached/buffered stream position should be 0");
byte[] buffer = bufferableStream.GetBuffer();
int bufferOffset = checked ((int)bufferableStream.Position);
int bufferLength = checked ((int)bufferableStream.Length) - bufferOffset;
// the following is useful in the debugging Immediate Window
// string x = System.Text.Encoding.UTF8.GetString(buffer, bufferOffset, bufferLength);
requestStream.Write(buffer, bufferOffset, bufferLength);
}
else
{
byte[] buffer = new byte[WebUtil.DefaultBufferSizeForStreamCopy];
WebUtil.CopyStream(requestStreamContent.Stream, requestStream, ref buffer);
}
}
}
/// <summary>
/// Copies the stream of response message and set it to local outputResponseStream.
/// </summary>
private void CopyStreamFromResponseMessage()
{
if (HttpStatusCode.NoContent != this.StatusCode)
{
using (Stream stream = this.responseMessage.GetStream())
{
if (null != stream)
{
Stream copy = this.GetAsyncResponseStreamCopy();
this.outputResponseStream = copy;
Byte[] buffer = this.GetAsyncResponseStreamCopyBuffer();
long copied = WebUtil.CopyStream(stream, copy, ref buffer);
if (this.responseStreamOwner)
{
if (0 == copied)
{
this.outputResponseStream = null;
}
else if (copy.Position < copy.Length)
{
// In Silverlight, generally 3 bytes less than advertised by ContentLength are read
((MemoryStream)copy).SetLength(copy.Position);
}
}
this.PutAsyncResponseStreamCopyBuffer(buffer);
}
}
}
}
/// <summary>
/// Fires the WritingRequest event
/// </summary >
/// <param name="isBatchPart">Boolean flag indicating if this request is part of a batch request.</param>
/// <param name="requestInfo">Request information to help fire events on the context.</param>
internal void FireWritingRequest(bool isBatchPart, RequestInfo requestInfo)
{
byte[] streamCopyBuffer = null;
var readableStream = new MemoryStream();
var requestStream = this.GetStream();
try
{
WebUtil.CopyStream(requestStream, readableStream, ref streamCopyBuffer);
readableStream.Position = 0;
}
finally
{
requestStream.Dispose();
}
this.cachedRequestStream = WebUtil.FireWritingRequest(this.HeaderCollection, readableStream, isBatchPart, requestInfo, this, true);
}
/// <summary>
/// Fires the ReadingResponse event
/// </summary>
/// <param name="isBatchPart">Boolean flag indicating if this request is part of a batch request..</param>
internal void FireReadingResponse(bool isBatchPart)
{
var readableStream = new MemoryStream();
var requestStream = this.GetStream();
try
{
WebUtil.CopyStream(requestStream, readableStream, ref this.streamCopyBuffer);
readableStream.Position = 0;
}
finally
{
requestStream.Dispose();
}
ReadingWritingHttpMessageEventArgs args = new ReadingWritingHttpMessageEventArgs(this.HeaderCollection, readableStream, isBatchPart);
var rewrittenArgs = this.requestInfo.FireReadingResponseEvent(args);
this.cachedResponseStream = rewrittenArgs.Content;
ApplyHeadersToResponse(rewrittenArgs.HeaderCollection, this);
}
private void HandleOperationResponseData(HttpWebResponse response)
{
using (Stream stream = WebUtil.GetResponseStream(response, (DataServiceContext)base.Source))
{
if (stream != null)
{
using (MemoryStream stream2 = new MemoryStream())
{
if (WebUtil.CopyStream(stream, stream2, ref this.buildBatchBuffer) != 0L)
{
stream2.Position = 0L;
this.HandleOperationResponseData(response, stream2);
}
else
{
this.HandleOperationResponseData(response, null);
}
}
}
}
}
private Exception ProcessCurrentOperationResponse(ODataBatchReader batchReader)
{
MemoryStream stream2;
Version version;
IODataResponseMessage message = batchReader.CreateOperationResponseMessage();
Stream input = message.GetStream();
if (input == null)
{
System.Data.Services.Client.Error.ThrowBatchExpectedResponse(InternalError.NullResponseStream);
}
try
{
stream2 = new MemoryStream();
WebUtil.CopyStream(input, stream2, ref this.streamCopyBuffer);
stream2.Position = 0L;
}
finally
{
input.Dispose();
}
this.currentOperationResponse = new CurrentOperationResponse((HttpStatusCode)message.StatusCode, message.Headers, stream2);
return(BaseSaveResult.HandleResponse(base.RequestInfo, this.currentOperationResponse.StatusCode, this.currentOperationResponse.GetHeader("DataServiceVersion"), () => this.currentOperationResponse.ContentStream, false, out version));
}
internal void Execute()
{
try
{
#if false
if ((null != requestContent) && (0 < requestContent.Length))
{
using (System.IO.Stream stream = Util.NullCheck(this.Request.GetRequestStream(), InternalError.InvalidGetRequestStream))
{
byte[] buffer = requestContent.GetBuffer();
int bufferOffset = checked ((int)requestContent.Position);
int bufferLength = checked ((int)requestContent.Length) - bufferOffset;
stream.Write(buffer, bufferOffset, bufferLength);
}
}
#endif
HttpWebResponse response = null;
try
{
response = (HttpWebResponse)this.Request.GetResponse();
}
catch (WebException ex)
{
response = (HttpWebResponse)ex.Response;
if (null == response)
{
throw;
}
}
this.SetHttpWebResponse(Util.NullCheck(response, InternalError.InvalidGetResponse));
if (HttpStatusCode.NoContent != this.StatusCode)
{
using (Stream stream = this.httpWebResponse.GetResponseStream())
{
if (null != stream)
{
Stream copy = this.GetAsyncResponseStreamCopy();
this.responseStream = copy;
Byte[] buffer = this.GetAsyncResponseStreamCopyBuffer();
long copied = WebUtil.CopyStream(stream, copy, ref buffer);
if (this.responseStreamOwner)
{
if (0 == copied)
{
this.responseStream = null;
}
else if (copy.Position < copy.Length)
{
((MemoryStream)copy).SetLength(copy.Position);
}
}
this.PutAsyncResponseStreamCopyBuffer(buffer);
}
}
}
}
catch (Exception e)
{
this.HandleFailure(e);
throw;
}
finally
{
this.SetCompleted();
this.CompletedRequest();
}
if (null != this.Failure)
{
throw this.Failure;
}
}
/// <summary>Synchronous web request</summary>
internal void Execute()
{
try
{
#if false
if ((null != requestContent) && (0 < requestContent.Length))
{
using (System.IO.Stream stream = Util.NullCheck(this.Request.GetRequestStream(), InternalError.InvalidGetRequestStream))
{
byte[] buffer = requestContent.GetBuffer();
int bufferOffset = checked ((int)requestContent.Position);
int bufferLength = checked ((int)requestContent.Length) - bufferOffset;
// the following is useful in the debugging Immediate Window
// string x = System.Text.Encoding.UTF8.GetString(buffer, bufferOffset, bufferLength);
stream.Write(buffer, bufferOffset, bufferLength);
}
}
#endif
HttpWebResponse response = null;
try
{
response = (HttpWebResponse)this.Request.GetResponse();
}
catch (WebException ex)
{
response = (HttpWebResponse)ex.Response;
if (null == response)
{
throw;
}
}
this.SetHttpWebResponse(Util.NullCheck(response, InternalError.InvalidGetResponse));
if (HttpStatusCode.NoContent != this.StatusCode)
{
using (Stream stream = this.httpWebResponse.GetResponseStream())
{
if (null != stream)
{
Stream copy = this.GetAsyncResponseStreamCopy();
this.responseStream = copy;
Byte[] buffer = this.GetAsyncResponseStreamCopyBuffer();
long copied = WebUtil.CopyStream(stream, copy, ref buffer);
if (this.responseStreamOwner)
{
if (0 == copied)
{
this.responseStream = null;
}
else if (copy.Position < copy.Length)
{ // In Silverlight, generally 3 bytes less than advertised by ContentLength are read
((MemoryStream)copy).SetLength(copy.Position);
}
}
this.PutAsyncResponseStreamCopyBuffer(buffer);
}
}
}
}
catch (Exception e)
{
this.HandleFailure(e);
throw;
}
finally
{
this.SetCompleted();
this.CompletedRequest();
}
if (null != this.Failure)
{
throw this.Failure;
}
}
internal void ExecuteQuery(DataServiceContext context)
{
try
{
if ((this.requestContentStream != null) && (this.requestContentStream.Stream != null))
{
if (this.requestContentStream.IsKnownMemoryStream)
{
this.Request.SetContentLengthHeader();
}
using (Stream stream = WebUtil.GetRequestStream(this.Request, context))
{
int num;
byte[] buffer = new byte[0x10000];
do
{
num = this.requestContentStream.Stream.Read(buffer, 0, buffer.Length);
if (num > 0)
{
stream.Write(buffer, 0, num);
}
}while (num > 0);
}
}
HttpWebResponse response = null;
response = WebUtil.GetResponse(this.Request, context, true);
this.SetHttpWebResponse(Util.NullCheck <HttpWebResponse>(response, InternalError.InvalidGetResponse));
if (HttpStatusCode.NoContent != this.StatusCode)
{
using (Stream stream2 = WebUtil.GetResponseStream(this.httpWebResponse, context))
{
if (stream2 != null)
{
Stream asyncResponseStreamCopy = this.GetAsyncResponseStreamCopy();
this.outputResponseStream = asyncResponseStreamCopy;
byte[] asyncResponseStreamCopyBuffer = this.GetAsyncResponseStreamCopyBuffer();
long num2 = WebUtil.CopyStream(stream2, asyncResponseStreamCopy, ref asyncResponseStreamCopyBuffer);
if (this.responseStreamOwner)
{
if (0L == num2)
{
this.outputResponseStream = null;
}
else if (asyncResponseStreamCopy.Position < asyncResponseStreamCopy.Length)
{
((MemoryStream)asyncResponseStreamCopy).SetLength(asyncResponseStreamCopy.Position);
}
}
this.PutAsyncResponseStreamCopyBuffer(asyncResponseStreamCopyBuffer);
}
}
}
}
catch (Exception exception)
{
base.HandleFailure(exception);
throw;
}
finally
{
base.SetCompleted();
this.CompletedRequest();
}
if (base.Failure != null)
{
throw base.Failure;
}
}
