private void AsyncEndWrite(IAsyncResult asyncResult)
{
AsyncStateBag asyncState = asyncResult.AsyncState as AsyncStateBag;
PerRequest request = (asyncState == null) ? null : asyncState.PerRequest;
try
{
this.CompleteCheck(request, InternalError.InvalidEndWriteCompleted);
request.SetRequestCompletedSynchronously(asyncResult.CompletedSynchronously);
EqualRefCheck(this.perRequest, request, InternalError.InvalidEndWrite);
ContentStream requestContentStream = request.RequestContentStream;
Util.NullCheck <ContentStream>(requestContentStream, InternalError.InvalidEndWriteStream);
Util.NullCheck <Stream>(requestContentStream.Stream, InternalError.InvalidEndWriteStream);
Util.NullCheck <Stream>(request.RequestStream, InternalError.InvalidEndWriteStream).EndWrite(asyncResult);
if (!asyncResult.CompletedSynchronously)
{
Stream stream = requestContentStream.Stream;
asyncResult = InvokeAsync(new AsyncAction(stream.BeginRead), request.RequestContentBuffer, 0, request.RequestContentBuffer.Length, new AsyncCallback(this.AsyncRequestContentEndRead), asyncState);
request.SetRequestCompletedSynchronously(asyncResult.CompletedSynchronously);
}
}
catch (Exception exception)
{
if (this.HandleFailure(request, exception))
{
throw;
}
}
finally
{
this.HandleCompleted(request);
}
}
private void AsyncRequestContentEndRead(IAsyncResult asyncResult)
{
AsyncStateBag asyncState = asyncResult.AsyncState as AsyncStateBag;
PerRequest request = (asyncState == null) ? null : asyncState.PerRequest;
try
{
this.CompleteCheck(request, InternalError.InvalidEndReadCompleted);
request.SetRequestCompletedSynchronously(asyncResult.CompletedSynchronously);
EqualRefCheck(this.perRequest, request, InternalError.InvalidEndRead);
ContentStream requestContentStream = request.RequestContentStream;
Util.NullCheck <ContentStream>(requestContentStream, InternalError.InvalidEndReadStream);
Util.NullCheck <Stream>(requestContentStream.Stream, InternalError.InvalidEndReadStream);
Stream stream2 = Util.NullCheck <Stream>(request.RequestStream, InternalError.InvalidEndReadStream);
int num = requestContentStream.Stream.EndRead(asyncResult);
if (0 < num)
{
bool flag = request.RequestContentBufferValidLength == -1;
request.RequestContentBufferValidLength = num;
if (!asyncResult.CompletedSynchronously || flag)
{
do
{
asyncResult = InvokeAsync(new AsyncAction(stream2.BeginWrite), request.RequestContentBuffer, 0, request.RequestContentBufferValidLength, new AsyncCallback(this.AsyncEndWrite), asyncState);
request.SetRequestCompletedSynchronously(asyncResult.CompletedSynchronously);
if ((asyncResult.CompletedSynchronously && !request.RequestCompleted) && !this.IsCompletedInternally)
{
Stream stream = requestContentStream.Stream;
asyncResult = InvokeAsync(new AsyncAction(stream.BeginRead), request.RequestContentBuffer, 0, request.RequestContentBuffer.Length, new AsyncCallback(this.AsyncRequestContentEndRead), asyncState);
request.SetRequestCompletedSynchronously(asyncResult.CompletedSynchronously);
}
}while (((asyncResult.CompletedSynchronously && !request.RequestCompleted) && !this.IsCompletedInternally) && (request.RequestContentBufferValidLength > 0));
}
}
else
{
request.RequestContentBufferValidLength = 0;
request.RequestStream = null;
stream2.Close();
ODataRequestMessageWrapper wrapper = Util.NullCheck <ODataRequestMessageWrapper>(request.Request, InternalError.InvalidEndWriteRequest);
asyncResult = InvokeAsync(new Func <ODataRequestMessageWrapper, AsyncCallback, object, IAsyncResult>(WebUtil.BeginGetResponse), wrapper, new AsyncCallback(this.AsyncEndGetResponse), asyncState);
request.SetRequestCompletedSynchronously(asyncResult.CompletedSynchronously);
}
}
catch (Exception exception)
{
if (this.HandleFailure(request, exception))
{
throw;
}
}
finally
{
this.HandleCompleted(request);
}
}
protected override void AsyncEndGetResponse(IAsyncResult asyncResult)
{
BaseAsyncResult.AsyncStateBag asyncState = asyncResult.AsyncState as BaseAsyncResult.AsyncStateBag;
BaseAsyncResult.PerRequest request = (asyncState == null) ? null : asyncState.PerRequest;
DataServiceContext context = (asyncState == null) ? null : asyncState.Context;
try
{
this.CompleteCheck(request, InternalError.InvalidEndGetResponseCompleted);
request.SetRequestCompletedSynchronously(asyncResult.CompletedSynchronously);
BaseAsyncResult.EqualRefCheck(base.perRequest, request, InternalError.InvalidEndGetResponse);
ODataRequestMessageWrapper wrapper = Util.NullCheck <ODataRequestMessageWrapper>(request.Request, InternalError.InvalidEndGetResponseRequest);
HttpWebResponse response = null;
response = WebUtil.EndGetResponse(wrapper, asyncResult, context);
request.HttpWebResponse = Util.NullCheck <HttpWebResponse>(response, InternalError.InvalidEndGetResponseResponse);
if (!this.IsBatch)
{
this.HandleOperationResponse(response);
this.HandleOperationResponseHeaders(response.StatusCode, WebUtil.WrapResponseHeaders(response));
}
Stream responseStream = WebUtil.GetResponseStream(response, context);
request.ResponseStream = responseStream;
if ((responseStream != null) && responseStream.CanRead)
{
if (this.buildBatchBuffer == null)
{
this.buildBatchBuffer = new byte[0x1f40];
}
do
{
asyncResult = BaseAsyncResult.InvokeAsync(new BaseAsyncResult.AsyncAction(responseStream.BeginRead), this.buildBatchBuffer, 0, this.buildBatchBuffer.Length, new AsyncCallback(this.AsyncEndRead), new AsyncReadState(request));
request.SetRequestCompletedSynchronously(asyncResult.CompletedSynchronously);
}while (((asyncResult.CompletedSynchronously && !request.RequestCompleted) && !base.IsCompletedInternally) && responseStream.CanRead);
}
else
{
request.SetComplete();
if (!base.IsCompletedInternally && !request.RequestCompletedSynchronously)
{
this.FinishCurrentChange(request);
}
}
}
catch (Exception exception)
{
if (base.HandleFailure(request, exception))
{
throw;
}
}
finally
{
this.HandleCompleted(request);
}
}
/// <summary>Synchronous web request</summary>
/// <returns>The IODataResponseMessage for the Request.</returns>
internal IODataResponseMessage ExecuteQuery()
{
try
{
if (this.requestContentStream != null && this.requestContentStream.Stream != null)
{
this.Request.SetRequestStream(this.requestContentStream);
}
#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
IODataResponseMessage response = null;
response = this.RequestInfo.GetSyncronousResponse(this.Request, true);
this.SetHttpWebResponse(Util.NullCheck(response, InternalError.InvalidGetResponse));
if (this.AllowDirectNetworkStreamReading)
{
this.GetStreamFromResponseMessage();
}
else
{
this.CopyStreamFromResponseMessage();
}
}
catch (Exception e)
{
this.HandleFailure(e);
throw;
}
finally
{
this.SetCompleted();
this.CompletedRequest();
}
if (null != this.Failure)
{
throw this.Failure;
}
return this.AllowDirectNetworkStreamReading ? this.responseMessage : null;
}
private void AsyncEndRead(IAsyncResult asyncResult)
{
AsyncReadState asyncState = (AsyncReadState)asyncResult.AsyncState;
BaseAsyncResult.PerRequest pereq = asyncState.Pereq;
int count = 0;
try
{
this.CompleteCheck(pereq, InternalError.InvalidEndReadCompleted);
pereq.SetRequestCompletedSynchronously(asyncResult.CompletedSynchronously);
BaseAsyncResult.EqualRefCheck(base.perRequest, pereq, InternalError.InvalidEndRead);
Stream stream = Util.NullCheck <Stream>(pereq.ResponseStream, InternalError.InvalidEndReadStream);
count = stream.EndRead(asyncResult);
if (0 < count)
{
Util.NullCheck <Stream>(this.ResponseStream, InternalError.InvalidEndReadCopy).Write(this.buildBatchBuffer, 0, count);
asyncState.TotalByteCopied += count;
if (!asyncResult.CompletedSynchronously && stream.CanRead)
{
do
{
asyncResult = BaseAsyncResult.InvokeAsync(new BaseAsyncResult.AsyncAction(stream.BeginRead), this.buildBatchBuffer, 0, this.buildBatchBuffer.Length, new AsyncCallback(this.AsyncEndRead), asyncState);
pereq.SetRequestCompletedSynchronously(asyncResult.CompletedSynchronously);
if ((!asyncResult.CompletedSynchronously || pereq.RequestCompleted) || base.IsCompletedInternally)
{
return;
}
}while (stream.CanRead);
}
}
else
{
pereq.SetComplete();
if (!base.IsCompletedInternally && !pereq.RequestCompletedSynchronously)
{
this.FinishCurrentChange(pereq);
}
}
}
catch (Exception exception)
{
if (base.HandleFailure(pereq, exception))
{
throw;
}
}
finally
{
this.HandleCompleted(pereq);
}
}
private void AsyncEndRead(IAsyncResult asyncResult)
{
BaseAsyncResult.AsyncStateBag asyncState = asyncResult.AsyncState as BaseAsyncResult.AsyncStateBag;
BaseAsyncResult.PerRequest request = (asyncState == null) ? null : asyncState.PerRequest;
int count = 0;
try
{
this.CompleteCheck(request, InternalError.InvalidEndReadCompleted);
request.SetRequestCompletedSynchronously(asyncResult.CompletedSynchronously);
base.SetCompletedSynchronously(asyncResult.CompletedSynchronously);
Stream stream = Util.NullCheck <Stream>(request.ResponseStream, InternalError.InvalidEndReadStream);
Stream stream2 = Util.NullCheck <Stream>(this.outputResponseStream, InternalError.InvalidEndReadCopy);
byte[] buffer = Util.NullCheck <byte[]>(this.asyncStreamCopyBuffer, InternalError.InvalidEndReadBuffer);
count = stream.EndRead(asyncResult);
this.usingBuffer = false;
if (0 < count)
{
stream2.Write(buffer, 0, count);
}
if (((0 < count) && (0 < buffer.Length)) && stream.CanRead)
{
if (!asyncResult.CompletedSynchronously)
{
this.ReadResponseStream(asyncState);
}
}
else
{
if (stream2.Position < stream2.Length)
{
((MemoryStream)stream2).SetLength(stream2.Position);
}
request.SetComplete();
base.SetCompleted();
}
}
catch (Exception exception)
{
if (base.HandleFailure(exception))
{
throw;
}
}
finally
{
this.HandleCompleted(request);
}
}
protected void AsyncEndGetRequestStream(IAsyncResult asyncResult)
{
AsyncStateBag asyncState = asyncResult.AsyncState as AsyncStateBag;
PerRequest request = (asyncState == null) ? null : asyncState.PerRequest;
DataServiceContext context = (asyncState == null) ? null : asyncState.Context;
try
{
this.CompleteCheck(request, InternalError.InvalidEndGetRequestCompleted);
request.SetRequestCompletedSynchronously(asyncResult.CompletedSynchronously);
EqualRefCheck(this.perRequest, request, InternalError.InvalidEndGetRequestStream);
Stream stream = Util.NullCheck <Stream>(WebUtil.EndGetRequestStream(Util.NullCheck <ODataRequestMessageWrapper>(request.Request, InternalError.InvalidEndGetRequestStreamRequest), asyncResult, context), InternalError.InvalidEndGetRequestStreamStream);
request.RequestStream = stream;
ContentStream requestContentStream = request.RequestContentStream;
Util.NullCheck <ContentStream>(requestContentStream, InternalError.InvalidEndGetRequestStreamContent);
Util.NullCheck <Stream>(requestContentStream.Stream, InternalError.InvalidEndGetRequestStreamContent);
if (requestContentStream.IsKnownMemoryStream)
{
MemoryStream stream3 = requestContentStream.Stream as MemoryStream;
byte[] buffer = stream3.GetBuffer();
int position = (int)stream3.Position;
int num2 = ((int)stream3.Length) - position;
if ((buffer == null) || (num2 == 0))
{
Error.ThrowInternalError(InternalError.InvalidEndGetRequestStreamContentLength);
}
}
request.RequestContentBufferValidLength = -1;
Stream stream1 = requestContentStream.Stream;
asyncResult = InvokeAsync(new AsyncAction(stream1.BeginRead), request.RequestContentBuffer, 0, request.RequestContentBuffer.Length, new AsyncCallback(this.AsyncRequestContentEndRead), asyncState);
request.SetRequestCompletedSynchronously(asyncResult.CompletedSynchronously);
}
catch (Exception exception)
{
if (this.HandleFailure(request, exception))
{
throw;
}
}
finally
{
this.HandleCompleted(request);
}
}
private static void AsyncEndGetRequestStream(IAsyncResult asyncResult)
{
QueryAsyncResult state = asyncResult.AsyncState as QueryAsyncResult;
try
{
int step = CompleteCheck(state, InternalError.InvalidEndGetRequestCompleted);
state.CompletedSynchronously &= asyncResult.CompletedSynchronously; // BeginGetRequestStream
HttpWebRequest httpWebRequest = Util.NullCheck(state.Request, InternalError.InvalidEndGetRequestStreamRequest);
Stream stream = Util.NullCheck(httpWebRequest.EndGetRequestStream(asyncResult), InternalError.InvalidEndGetRequestStreamStream);
state.requestStream = stream;
MemoryStream memoryStream = Util.NullCheck(state.requestStreamContent, InternalError.InvalidEndGetRequestStreamContent);
byte[] buffer = memoryStream.GetBuffer();
int bufferOffset = checked ((int)memoryStream.Position);
int bufferLength = checked ((int)memoryStream.Length) - bufferOffset;
if ((null == buffer) || (0 == bufferLength))
{
Error.ThrowInternalError(InternalError.InvalidEndGetRequestStreamContentLength);
}
// the following is useful in the debugging Immediate Window
// string x = System.Text.Encoding.UTF8.GetString(buffer, bufferOffset, bufferLength);
asyncResult = stream.BeginWrite(buffer, bufferOffset, bufferLength, QueryAsyncResult.AsyncEndWrite, state);
bool reallyCompletedSynchronously = asyncResult.CompletedSynchronously && (step < state.asyncCompleteStep);
state.CompletedSynchronously &= reallyCompletedSynchronously; // BeginWrite
}
catch (Exception e)
{
if (state.HandleFailure(e))
{
throw;
}
}
finally
{
state.HandleCompleted();
}
}
private static void AsyncEndWrite(IAsyncResult asyncResult)
{
QueryAsyncResult state = asyncResult.AsyncState as QueryAsyncResult;
try
{
int step = CompleteCheck(state, InternalError.InvalidEndWriteCompleted);
state.CompletedSynchronously &= asyncResult.CompletedSynchronously;
HttpWebRequest httpWebRequest = Util.NullCheck(state.Request, InternalError.InvalidEndWriteRequest);
Stream stream = Util.NullCheck(state.requestStream, InternalError.InvalidEndWriteStream);
stream.EndWrite(asyncResult);
state.requestStream = null;
stream.Dispose();
stream = state.requestStreamContent;
if (null != stream)
{
state.requestStreamContent = null;
stream.Dispose();
}
asyncResult = httpWebRequest.BeginGetResponse(QueryAsyncResult.AsyncEndGetResponse, state);
bool reallyCompletedSynchronously = asyncResult.CompletedSynchronously && (step < state.asyncCompleteStep);
state.CompletedSynchronously &= reallyCompletedSynchronously;
}
catch (Exception e)
{
if (state.HandleFailure(e))
{
throw;
}
}
finally
{
state.HandleCompleted();
}
}
private static void AsyncEndGetResponse(IAsyncResult asyncResult)
{
GetReadStreamResult state = asyncResult.AsyncState as GetReadStreamResult;
Debug.Assert(state != null, "Async callback got called for different request.");
try
{
state.CompletedSynchronously &= asyncResult.CompletedSynchronously;
HttpWebRequest request = Util.NullCheck(state.request, InternalError.InvalidEndGetResponseRequest);
HttpWebResponse webresponse = null;
try
{
webresponse = (HttpWebResponse)request.EndGetResponse(asyncResult);
}
catch (WebException e)
{
webresponse = (HttpWebResponse)e.Response;
if (null == webresponse)
{
throw;
}
}
state.SetHttpWebResponse(webresponse);
state.SetCompleted();
}
catch (Exception e)
{
if (state.HandleFailure(e))
{
throw;
}
}
finally
{
state.HandleCompleted();
}
}
protected override void AsyncEndGetResponse(IAsyncResult asyncResult)
{
try
{
base.SetCompletedSynchronously(asyncResult.CompletedSynchronously);
ODataRequestMessageWrapper request = Util.NullCheck <ODataRequestMessageWrapper>(this.requestMessage, InternalError.InvalidEndGetResponseRequest);
HttpWebResponse webResponse = null;
webResponse = WebUtil.EndGetResponse(request, asyncResult, (DataServiceContext)base.Source);
this.SetHttpWebResponse(webResponse);
base.SetCompleted();
}
catch (Exception exception)
{
if (base.HandleFailure(exception))
{
throw;
}
}
finally
{
base.HandleCompleted();
}
}
/// <summary>
/// Async callback registered with the underlying HttpWebRequest object.
/// </summary>
/// <param name="asyncResult">The async result associated with the HttpWebRequest operation.</param>
protected override void AsyncEndGetResponse(IAsyncResult asyncResult)
{
try
{
this.SetCompletedSynchronously(asyncResult.CompletedSynchronously); // BeginGetResponse
ODataRequestMessageWrapper request = Util.NullCheck(this.requestMessage, InternalError.InvalidEndGetResponseRequest);
this.responseMessage = this.requestInfo.EndGetResponse(request, asyncResult);
Debug.Assert(this.responseMessage != null, "Can't set a null response.");
this.SetCompleted();
}
catch (Exception e)
{
if (this.HandleFailure(e))
{
throw;
}
}
finally
{
this.HandleCompleted();
}
}
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;
}
}
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;
}
}
private void AsyncEndRead(IAsyncResult asyncResult)
#endif
{
#if WINRT
IAsyncResult asyncResult = (IAsyncResult)task;
#endif
Debug.Assert(asyncResult != null && asyncResult.IsCompleted, "asyncResult.IsCompleted");
#if WINRT
AsyncStateBag asyncStateBag = asyncState as AsyncStateBag;
#else
AsyncStateBag asyncStateBag = asyncResult.AsyncState as AsyncStateBag;
#endif
PerRequest pereq = asyncStateBag == null ? null : asyncStateBag.PerRequest;
int count = 0;
try
{
this.CompleteCheck(pereq, InternalError.InvalidEndReadCompleted);
pereq.SetRequestCompletedSynchronously(asyncResult.CompletedSynchronously); // BeginRead
this.SetCompletedSynchronously(asyncResult.CompletedSynchronously);
Stream httpResponseStream = Util.NullCheck(pereq.ResponseStream, InternalError.InvalidEndReadStream); // get the http response stream.
Stream outResponseStream = Util.NullCheck(this.outputResponseStream, InternalError.InvalidEndReadCopy);
byte[] buffer = Util.NullCheck(this.asyncStreamCopyBuffer, InternalError.InvalidEndReadBuffer);
#if WINRT
count = ((Task<int>)task).Result;
#else
count = httpResponseStream.EndRead(asyncResult);
#endif
this.usingBuffer = false;
if (0 < count)
{
outResponseStream.Write(buffer, 0, count);
}
if (0 < count && 0 < buffer.Length && httpResponseStream.CanRead)
{
if (!asyncResult.CompletedSynchronously)
{
// if CompletedSynchronously then caller will call and we reduce risk of stack overflow
this.ReadResponseStream(asyncStateBag);
}
}
else
{
// Debug.Assert(this.ContentLength < 0 || outResponseStream.Length == this.ContentLength, "didn't read expected ContentLength");
if (outResponseStream.Position < outResponseStream.Length)
{
// In Silverlight, generally 3 bytes less than advertised by ContentLength are read
((MemoryStream)outResponseStream).SetLength(outResponseStream.Position);
}
pereq.SetComplete();
this.SetCompleted();
}
}
catch (Exception e)
{
if (this.HandleFailure(e))
{
throw;
}
}
finally
{
this.HandleCompleted(pereq);
}
}
private static void AsyncEndRead(IAsyncResult asyncResult)
{
Debug.Assert(asyncResult != null && asyncResult.IsCompleted, "asyncResult.IsCompleted");
QueryResult state = asyncResult.AsyncState as QueryResult;
int count = 0;
try
{
CompleteCheck(state, InternalError.InvalidEndReadCompleted);
state.CompletedSynchronously &= asyncResult.CompletedSynchronously; // BeginRead
Stream stream = Util.NullCheck(state.asyncResponseStream, InternalError.InvalidEndReadStream);
Stream outputResponse = Util.NullCheck(state.responseStream, InternalError.InvalidEndReadCopy);
byte[] buffer = Util.NullCheck(state.asyncStreamCopyBuffer, InternalError.InvalidEndReadBuffer);
count = stream.EndRead(asyncResult);
state.usingBuffer = false;
if (0 < count)
{
#if StreamContainsBuffer
if (state.responseStreamIsCopyBuffer)
{ // we may have asked for, but not received the entire stream
outputResponse.Position = outputResponse.Position + count;
}
else
#endif
{
outputResponse.Write(buffer, 0, count);
}
}
if (0 < count && 0 < buffer.Length && stream.CanRead)
{
if (!asyncResult.CompletedSynchronously)
{
// if CompletedSynchronously then caller will call and we reduce risk of stack overflow
QueryResult.ReadResponseStream(state);
}
}
else
{
#if StreamContainsBuffer
Debug.Assert(!state.responseStreamIsCopyBuffer || (outputResponse.Position == outputResponse.Length), "didn't read expected count");
#endif
// Debug.Assert(state.ContentLength < 0 || outputResponse.Length == state.ContentLength, "didn't read expected ContentLength");
if (outputResponse.Position < outputResponse.Length)
{
// In Silverlight, generally 3 bytes less than advertised by ContentLength are read
((MemoryStream)outputResponse).SetLength(outputResponse.Position);
}
state.SetCompleted();
}
}
catch (Exception e)
{
if (state.HandleFailure(e))
{
throw;
}
}
finally
{
state.HandleCompleted();
}
}
protected override void AsyncEndGetResponse(IAsyncResult asyncResult)
{
Debug.Assert(asyncResult != null && asyncResult.IsCompleted, "asyncResult.IsCompleted");
AsyncStateBag asyncStateBag = asyncResult.AsyncState as AsyncStateBag;
PerRequest pereq = asyncStateBag == null ? null : asyncStateBag.PerRequest;
try
{
if (this.IsAborted)
{
if (pereq != null)
{
pereq.SetComplete();
}
this.SetCompleted();
}
else
{
this.CompleteCheck(pereq, InternalError.InvalidEndGetResponseCompleted);
pereq.SetRequestCompletedSynchronously(asyncResult.CompletedSynchronously);
this.SetCompletedSynchronously(asyncResult.CompletedSynchronously);
ODataRequestMessageWrapper requestMessage = Util.NullCheck(pereq.Request, InternalError.InvalidEndGetResponseRequest);
// the httpWebResponse is kept for batching, discarded by non-batch
IODataResponseMessage response = this.RequestInfo.EndGetResponse(requestMessage, asyncResult);
pereq.ResponseMessage = Util.NullCheck(response, InternalError.InvalidEndGetResponseResponse);
this.SetHttpWebResponse(pereq.ResponseMessage);
Debug.Assert(null == pereq.ResponseStream, "non-null async ResponseStream");
Stream httpResponseStream = null;
if (HttpStatusCode.NoContent != (HttpStatusCode)response.StatusCode)
{
httpResponseStream = response.GetStream();
pereq.ResponseStream = httpResponseStream;
}
if ((null != httpResponseStream) && httpResponseStream.CanRead)
{
if (null == this.outputResponseStream)
{
// this is the stream we copy the reponse to
this.outputResponseStream = Util.NullCheck(this.GetAsyncResponseStreamCopy(), InternalError.InvalidAsyncResponseStreamCopy);
}
if (null == this.asyncStreamCopyBuffer)
{
// this is the buffer we read into and copy out of
this.asyncStreamCopyBuffer = Util.NullCheck(this.GetAsyncResponseStreamCopyBuffer(), InternalError.InvalidAsyncResponseStreamCopyBuffer);
}
// Make async calls to read the response stream
this.ReadResponseStream(asyncStateBag);
}
else
{
pereq.SetComplete();
this.SetCompleted();
}
}
}
catch (Exception e)
{
if (this.HandleFailure(e))
{
throw;
}
}
finally
{
this.HandleCompleted(pereq);
}
}
private static void AsyncEndGetResponse(IAsyncResult asyncResult)
{
Debug.Assert(asyncResult != null && asyncResult.IsCompleted, "asyncResult.IsCompleted");
QueryResult state = asyncResult.AsyncState as QueryResult;
try
{
CompleteCheck(state, InternalError.InvalidEndGetResponseCompleted);
state.CompletedSynchronously &= asyncResult.CompletedSynchronously;
HttpWebRequest httpWebRequest = Util.NullCheck(state.Request, InternalError.InvalidEndGetResponseRequest);
HttpWebResponse response = null;
try
{
response = (HttpWebResponse)httpWebRequest.EndGetResponse(asyncResult);
}
catch (WebException e)
{
response = (HttpWebResponse)e.Response;
if (null == response)
{
throw;
}
}
state.SetHttpWebResponse(Util.NullCheck(response, InternalError.InvalidEndGetResponseResponse));
Debug.Assert(null == state.asyncResponseStream, "non-null asyncResponseStream");
Stream stream = null;
if (HttpStatusCode.NoContent != response.StatusCode)
{
stream = response.GetResponseStream();
state.asyncResponseStream = stream;
}
if ((null != stream) && stream.CanRead)
{
if (null == state.responseStream)
{
state.responseStream = Util.NullCheck(state.GetAsyncResponseStreamCopy(), InternalError.InvalidAsyncResponseStreamCopy);
}
if (null == state.asyncStreamCopyBuffer)
{
state.asyncStreamCopyBuffer = Util.NullCheck(state.GetAsyncResponseStreamCopyBuffer(), InternalError.InvalidAsyncResponseStreamCopyBuffer);
}
QueryResult.ReadResponseStream(state);
}
else
{
state.SetCompleted();
}
}
catch (Exception e)
{
if (state.HandleFailure(e))
{
throw;
}
}
finally
{
state.HandleCompleted();
}
}
/// <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;
}
}
protected override void AsyncEndGetResponse(IAsyncResult asyncResult)
{
BaseAsyncResult.AsyncStateBag asyncState = asyncResult.AsyncState as BaseAsyncResult.AsyncStateBag;
BaseAsyncResult.PerRequest request = (asyncState == null) ? null : asyncState.PerRequest;
DataServiceContext context = (asyncState == null) ? null : asyncState.Context;
try
{
if (base.IsAborted)
{
if (request != null)
{
request.SetComplete();
}
base.SetCompleted();
}
else
{
this.CompleteCheck(request, InternalError.InvalidEndGetResponseCompleted);
request.SetRequestCompletedSynchronously(asyncResult.CompletedSynchronously);
base.SetCompletedSynchronously(asyncResult.CompletedSynchronously);
HttpWebResponse response = WebUtil.EndGetResponse(Util.NullCheck <ODataRequestMessageWrapper>(request.Request, InternalError.InvalidEndGetResponseRequest), asyncResult, context);
request.HttpWebResponse = Util.NullCheck <HttpWebResponse>(response, InternalError.InvalidEndGetResponseResponse);
this.SetHttpWebResponse(request.HttpWebResponse);
Stream responseStream = null;
if (HttpStatusCode.NoContent != response.StatusCode)
{
responseStream = WebUtil.GetResponseStream(response, context);
request.ResponseStream = responseStream;
}
if ((responseStream != null) && responseStream.CanRead)
{
if (this.outputResponseStream == null)
{
this.outputResponseStream = Util.NullCheck <Stream>(this.GetAsyncResponseStreamCopy(), InternalError.InvalidAsyncResponseStreamCopy);
}
if (this.asyncStreamCopyBuffer == null)
{
this.asyncStreamCopyBuffer = Util.NullCheck <byte[]>(this.GetAsyncResponseStreamCopyBuffer(), InternalError.InvalidAsyncResponseStreamCopyBuffer);
}
this.ReadResponseStream(asyncState);
}
else
{
request.SetComplete();
base.SetCompleted();
}
}
}
catch (Exception exception)
{
if (base.HandleFailure(exception))
{
throw;
}
}
finally
{
this.HandleCompleted(request);
}
}
private static void AsyncEndRead(IAsyncResult asyncResult)
{
Debug.Assert(asyncResult != null && asyncResult.IsCompleted, "asyncResult.IsCompleted");
QueryResult state = asyncResult.AsyncState as QueryResult;
int count = 0;
try
{
CompleteCheck(state, InternalError.InvalidEndReadCompleted);
state.CompletedSynchronously &= asyncResult.CompletedSynchronously;
Stream stream = Util.NullCheck(state.asyncResponseStream, InternalError.InvalidEndReadStream);
Stream outputResponse = Util.NullCheck(state.responseStream, InternalError.InvalidEndReadCopy);
byte[] buffer = Util.NullCheck(state.asyncStreamCopyBuffer, InternalError.InvalidEndReadBuffer);
count = stream.EndRead(asyncResult);
state.usingBuffer = false;
if (0 < count)
{
#if StreamContainsBuffer
if (state.responseStreamIsCopyBuffer)
{
outputResponse.Position = outputResponse.Position + count;
}
else
#endif
{
outputResponse.Write(buffer, 0, count);
}
}
if (0 < count && 0 < buffer.Length && stream.CanRead)
{
if (!asyncResult.CompletedSynchronously)
{
QueryResult.ReadResponseStream(state);
}
}
else
{
#if StreamContainsBuffer
Debug.Assert(!state.responseStreamIsCopyBuffer || (outputResponse.Position == outputResponse.Length), "didn't read expected count");
#endif
if (outputResponse.Position < outputResponse.Length)
{
((MemoryStream)outputResponse).SetLength(outputResponse.Position);
}
state.SetCompleted();
}
}
catch (Exception e)
{
if (state.HandleFailure(e))
{
throw;
}
}
finally
{
state.HandleCompleted();
}
}
private static void AsyncEndGetResponse(IAsyncResult asyncResult)
{
Debug.Assert(asyncResult != null && asyncResult.IsCompleted, "asyncResult.IsCompleted");
QueryResult state = asyncResult.AsyncState as QueryResult;
try
{
CompleteCheck(state, InternalError.InvalidEndGetResponseCompleted);
state.CompletedSynchronously &= asyncResult.CompletedSynchronously; // BeginGetResponse
HttpWebRequest httpWebRequest = Util.NullCheck(state.Request, InternalError.InvalidEndGetResponseRequest);
// the httpWebResponse is kept for batching, discarded by non-batch
HttpWebResponse response = null;
try
{
response = (HttpWebResponse)httpWebRequest.EndGetResponse(asyncResult);
}
catch (WebException e)
{
response = (HttpWebResponse)e.Response;
if (null == response)
{
throw;
}
}
state.SetHttpWebResponse(Util.NullCheck(response, InternalError.InvalidEndGetResponseResponse));
Debug.Assert(null == state.asyncResponseStream, "non-null asyncResponseStream");
Stream stream = null;
if (HttpStatusCode.NoContent != response.StatusCode)
{
stream = response.GetResponseStream();
state.asyncResponseStream = stream;
}
if ((null != stream) && stream.CanRead)
{
if (null == state.responseStream)
{ // this is the stream we copy the reponse to
state.responseStream = Util.NullCheck(state.GetAsyncResponseStreamCopy(), InternalError.InvalidAsyncResponseStreamCopy);
}
if (null == state.asyncStreamCopyBuffer)
{ // this is the buffer we read into and copy out of
state.asyncStreamCopyBuffer = Util.NullCheck(state.GetAsyncResponseStreamCopyBuffer(), InternalError.InvalidAsyncResponseStreamCopyBuffer);
}
// Make async calls to read the response stream
QueryResult.ReadResponseStream(state);
}
else
{
state.SetCompleted();
}
}
catch (Exception e)
{
if (state.HandleFailure(e))
{
throw;
}
}
finally
{
state.HandleCompleted();
}
}
