internal void BatchBeginRequest() { PerRequest pereq = null; try { ODataRequestMessageWrapper batchRequestMessage = this.GenerateBatchRequest(); this.Abortable = batchRequestMessage; if (batchRequestMessage != null) { batchRequestMessage.SetContentLengthHeader(); this.perRequest = pereq = new PerRequest(); pereq.Request = batchRequestMessage; pereq.RequestContentStream = batchRequestMessage.CachedRequestStream; AsyncStateBag asyncStateBag = new AsyncStateBag(pereq); this.responseStream = new MemoryStream(); IAsyncResult asyncResult = BaseAsyncResult.InvokeAsync(batchRequestMessage.BeginGetRequestStream, this.AsyncEndGetRequestStream, asyncStateBag); pereq.SetRequestCompletedSynchronously(asyncResult.CompletedSynchronously); } else { Debug.Assert(this.CompletedSynchronously, "completedSynchronously"); Debug.Assert(this.IsCompletedInternally, "completed"); } } catch (Exception e) { this.HandleFailure(pereq, e); throw; // to user on BeginSaveChangeSet, will still invoke Callback } finally { this.HandleCompleted(pereq); // will invoke user callback } Debug.Assert((this.CompletedSynchronously && this.IsCompleted) || !this.CompletedSynchronously, "sync without complete"); }
private void AsyncEndRead(IAsyncResult asyncResult) #endif { #if PORTABLELIB IAsyncResult asyncResult = (IAsyncResult)task; #endif Debug.Assert(asyncResult != null && asyncResult.IsCompleted, "asyncResult.IsCompleted"); #if PORTABLELIB 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 PORTABLELIB 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); } }
internal void BeginCreateNextChange() { Debug.Assert(!this.IsCompletedInternally, "why being called if already completed?"); // create the memory stream required to cache the responses as we read async from the underlying http web response this.inMemoryResponseStream = new MemoryStream(); // SaveCallback can't chain synchronously completed responses, caller will loop the to next change PerRequest pereq = null; IAsyncResult asyncResult = null; do { IODataResponseMessage responseMsg = null; ODataRequestMessageWrapper requestMessage = null; try { if (null != this.perRequest) { this.SetCompleted(); Error.ThrowInternalError(InternalError.InvalidBeginNextChange); } requestMessage = this.CreateNextRequest(); // Keeping the old behavior (V1/V2) where the abortable was set to null, // if CreateNextRequest returned null. if (requestMessage == null) { this.Abortable = null; } if ((null != requestMessage) || (this.entryIndex < this.ChangedEntries.Count)) { if (this.ChangedEntries[this.entryIndex].ContentGeneratedForSave) { Debug.Assert(this.ChangedEntries[this.entryIndex] is LinkDescriptor, "only expected RelatedEnd to presave"); Debug.Assert( this.ChangedEntries[this.entryIndex].State == EntityStates.Added || this.ChangedEntries[this.entryIndex].State == EntityStates.Modified, "only expected added to presave"); continue; } this.Abortable = requestMessage; ContentStream contentStream = this.CreateNonBatchChangeData(this.entryIndex, requestMessage); this.perRequest = pereq = new PerRequest(); pereq.Request = requestMessage; AsyncStateBag asyncStateBag = new AsyncStateBag(pereq); if (null == contentStream || null == contentStream.Stream) { asyncResult = BaseAsyncResult.InvokeAsync(requestMessage.BeginGetResponse, this.AsyncEndGetResponse, asyncStateBag); } else { if (contentStream.IsKnownMemoryStream) { requestMessage.SetContentLengthHeader(); } pereq.RequestContentStream = contentStream; asyncResult = BaseAsyncResult.InvokeAsync(requestMessage.BeginGetRequestStream, this.AsyncEndGetRequestStream, asyncStateBag); } pereq.SetRequestCompletedSynchronously(asyncResult.CompletedSynchronously); this.SetCompletedSynchronously(pereq.RequestCompletedSynchronously); } else { this.SetCompleted(); if (this.CompletedSynchronously) { this.HandleCompleted(pereq); } } } catch (InvalidOperationException e) { e = WebUtil.GetHttpWebResponse(e, ref responseMsg); this.HandleOperationException(e, responseMsg); this.HandleCompleted(pereq); } finally { WebUtil.DisposeMessage(responseMsg); } // If the current request is completed synchronously, we need to call FinishCurrentChange() to process the response payload. // FinishCurrentChange() will not call BeginCreateNextChange() when the request is synchronous. // If the current request is completed asynchronously, an async thread will call FinishCurrentChange() to process the response payload. // FinishCurrentchange() will then call BeginCreateNextChange() from the async thread and we need to exit this loop. // If requestMessage = this.CreateNextRequest() returns null, we would have called this.SetCompleted() above and this.IsCompletedInternally // would be true. This means we are done processing all changed entries and we should not call this.FinishCurrentChange(). if (null != pereq && pereq.RequestCompleted && pereq.RequestCompletedSynchronously && !this.IsCompletedInternally) { Debug.Assert(requestMessage != null, "httpWebRequest != null"); this.FinishCurrentChange(pereq); } // In the condition for the do-while loop we must test for pereq.RequestCompletedSynchronously and not asyncResult.CompletedSynchronously. // pereq.RequestCompletedSynchronously is true only if all async calls completed synchronously. If we don't exit this loop when // pereq.RequestCompletedSynchronously is false, the current thread and an async thread will both re-enter BeginCreateNextChange() // and we will fail. We can only process one request at a given time. } while (((null == pereq) || (pereq.RequestCompleted && pereq.RequestCompletedSynchronously)) && !this.IsCompletedInternally); Debug.Assert((this.CompletedSynchronously && this.IsCompleted) || !this.CompletedSynchronously, "sync without complete"); Debug.Assert(this.entryIndex < this.ChangedEntries.Count || this.ChangedEntries.All(o => o.ContentGeneratedForSave), "didn't generate content for all entities/links"); }
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 response 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); } }