// This method is invoked via the AsyncOperation object, // so it is guaranteed to be executed on the correct thread. private void OnAsyncReportProgress(object state) { AsyncOperationProgressEventArgs e = state as AsyncOperationProgressEventArgs; if (this.AsyncOperationProgress != null) { this.AsyncOperationProgress(this, e); } }
internal bool SendProgressData(AsyncData data, AsyncOperationProgressEventArgs args) { // In this case, don't allow cancellation, as the method // is about to raise the completed event. bool ret = !CheckIfOperationIsCancelled(data.UserData); if (ret) { data.Operation.Post(data.Delegate, args); } return(ret); }
private MemoryStream CopyResponseToMemory(AsyncData data, Stream responseStream, long contentLength) { if (responseStream == null) { return(null); } // read the stream into memory. That's the only way to satisfy the "main work // on the other thread requirement MemoryStream memStream = new MemoryStream(); const int size = 4096; var bytes = new byte[size]; int numBytes; double current = 0; long bytesWritten = 0; while ((numBytes = responseStream.Read(bytes, 0, size)) > 0) { memStream.Write(bytes, 0, numBytes); if (data == null || data.Delegate == null) { continue; } bytesWritten += numBytes; if (contentLength > size) { current = bytesWritten * 100d / contentLength; } // see if we are still in the list... // Multiple threads will access the task dictionary, // so it must be locked to serialize access. if (CheckIfOperationIsCancelled(data.UserData)) { throw new ArgumentException("Operation was cancelled"); } var args = new AsyncOperationProgressEventArgs(contentLength, bytesWritten, (int)current, data.UriToUse, data.HttpVerb, data.UserData); data.Operation.Post(data.Delegate, args); } memStream.Seek(0, SeekOrigin.Begin); return(memStream); }
/// <summary>takes our copy of the stream, and puts it into the request stream</summary> protected void CopyRequestData() { if (this.requestCopy != null) { // Since we don't use write buffering on the WebRequest object, // we need to ensure the Content-Length field is correctly set // to the length we want to set. EnsureWebRequest(); this.Request.ContentLength = this.requestCopy.Length; // stream it into the real request stream Stream req = base.GetRequestStream(); try { const int size = 4096; byte[] bytes = new byte[size]; int numBytes; double oneLoop = 100; if (requestCopy.Length > size) { oneLoop = (100 / ((double)this.requestCopy.Length / size)); } // 3 lines of debug code // this.requestCopy.Seek(0, SeekOrigin.Begin); // StreamReader reader = new StreamReader( this.requestCopy ); // string text = reader.ReadToEnd(); this.requestCopy.Seek(0, SeekOrigin.Begin); long bytesWritten = 0; double current = 0; while ((numBytes = this.requestCopy.Read(bytes, 0, size)) > 0) { req.Write(bytes, 0, numBytes); bytesWritten += numBytes; if (this.asyncData != null && this.asyncData.Delegate != null && this.asyncData.DataHandler != null) { AsyncOperationProgressEventArgs args; args = new AsyncOperationProgressEventArgs(this.requestCopy.Length, bytesWritten, (int)current, this.Request.RequestUri, this.Request.Method, this.asyncData.UserData); current += oneLoop; if (!this.asyncData.DataHandler.SendProgressData(asyncData, args)) { break; } } } } finally { req.Close(); } } else { if (this.IsBatch) { this.EnsureWebRequest(); this.ContentStore.SaveToXml(this.GetRequestStream()); this.CopyRequestData(); } } }