public static Task<Stream> GetRequestStreamAsync(this HttpWebRequest request) { var tcs = new TaskCompletionSource<Stream>(); try { request.BeginGetRequestStream(iar => { try { var response = request.EndGetRequestStream(iar); tcs.SetResult(response); } catch (Exception exc) { tcs.SetException(exc); } }, null); } catch (Exception exc) { tcs.SetException(exc); } return tcs.Task; }
public static Task<Stream> GetStreamAsync(this HttpWebRequest context, object state) { // this will be our sentry that will know when our async operation is completed var tcs = new TaskCompletionSource<Stream>(); try { context.BeginGetRequestStream((iar) => { try { var result = context.EndGetRequestStream(iar as IAsyncResult); tcs.TrySetResult(result); } catch (OperationCanceledException ex) { // if the inner operation was canceled, this task is cancelled too tcs.TrySetCanceled(); } catch (Exception ex) { // general exception has been set tcs.TrySetException(ex); } }, state); } catch { tcs.TrySetResult(default(Stream)); // propagate exceptions to the outside throw; } return tcs.Task; }
/// <include file='../_Doc/System.xml' path='doc/members/member[@name="M:System.Net.WebRequest.GetRequestStream"]/*' /> /// <param name="request">HTTP web request object on which to get request stream.</param> public static Stream GetRequestStream(this WebRequest request) { #if DOTNET return request.GetRequestStream(); #else return request.EndGetRequestStream(request.BeginGetRequestStream(null, null)); #endif }
public static Stream GetRequestStream(this WebRequest request) { AutoResetEvent autoResetEvent = new AutoResetEvent(false); IAsyncResult asyncResult = request.BeginGetRequestStream(r => autoResetEvent.Set(), null); // Wait until the call is finished autoResetEvent.WaitOne(); return request.EndGetRequestStream(asyncResult); }
public static Task<Stream> GetRequestStreamAsync(this HttpWebRequest request) { var taskComplete = new TaskCompletionSource<Stream>(); request.BeginGetRequestStream(ar => { Stream requestStream = request.EndGetRequestStream(ar); taskComplete.TrySetResult(requestStream); }, request); return taskComplete.Task; }
internal static void WriteBody(this HttpWebRequest request, byte[] data) { #if PORTABLE45 Stream outs = null; //outs = request.GetRequestStreamAsync().Result; //outs.Write(data, 0, (int)data.Length); //outs.Flush(); //outs.Dispose(); ManualResetEvent requestReady = new ManualResetEvent(initialState: false); Exception caught = null; AsyncCallback callback = new AsyncCallback(ar => { //var request = (WebRequest)ar.AsyncState; try { outs = request.EndGetRequestStream(ar); } catch (Exception ex) { caught = ex; } finally { requestReady.Set(); } }); var async = request.BeginGetRequestStream(callback, null); if (!async.IsCompleted) { //async.AsyncWaitHandle.WaitOne(); // Not having thread affinity seems to work better with ManualResetEvent // Using AsyncWaitHandle.WaitOne() gave unpredictable results (in the // unit tests), when EndGetResponse would return null without any error // thrown requestReady.WaitOne(); //async.AsyncWaitHandle.WaitOne(); } if (caught != null) throw caught; outs.Write(data, 0, (int)data.Length); outs.Flush(); outs.Dispose(); #else Stream outs = request.GetRequestStream(); outs.Write(data, 0, (int)data.Length); outs.Flush(); outs.Dispose(); #endif }
public static Stream GetRequestStream(this WebRequest request) { ManualResetEvent evt = new ManualResetEvent(false); Stream requestStream = null; request.BeginGetRequestStream((IAsyncResult ar) => { requestStream = request.EndGetRequestStream(ar); evt.Set(); }, null); evt.WaitOne(); return requestStream; }
public static void GetResponseContent(this HttpWebRequest request, byte[] requestContent, Action<string> result) { request.BeginGetRequestStream((iar) => { using (Stream requestStrm = request.EndGetRequestStream(iar)) { requestStrm.Write(requestContent, 0, requestContent.Length); } GetResponseContent(request, result); }, request); }
internal static void SetContentAsync(this WebRequest request, string content) { request.BeginGetRequestStream (ar => { using (var writer = new System.IO.StreamWriter(request.EndGetRequestStream(ar))) { writer.Write(content); } }, null); }
public static Task<Stream> GetRequestStreamAsync(this HttpWebRequest request) { var taskComplete = new TaskCompletionSource<Stream>(); request.BeginGetRequestStream(asyncResponse => { try { var responseRequest = (HttpWebRequest)asyncResponse.AsyncState; var someResponse = (Stream)responseRequest.EndGetRequestStream(asyncResponse); taskComplete.TrySetResult(someResponse); } catch (WebException webExc) { var failedResponse = (HttpWebResponse)webExc.Response; taskComplete.TrySetResult(null); } }, request); return taskComplete.Task; }
public static Task<Stream> GetRequestStreamAsync(this HttpWebRequest request) { var taskComplete = new TaskCompletionSource<Stream>(); request.AllowReadStreamBuffering = true; request.AllowWriteStreamBuffering = true; request.BeginGetRequestStream(ar => { var requestStream = request.EndGetRequestStream(ar); taskComplete.TrySetResult(requestStream); }, request); return taskComplete.Task; }
public static IAsyncResult ExecutePutAsync(this WebRequest request, byte[] content, Action <WebResponseEventArgs> callback) { Console.WriteLine("POST: {0}", request.RequestUri); ClearLastResponse(); var state = new object[] {request, content, callback}; return request.BeginGetRequestStream( BeginGetRequestStreamCompleted, state); }
/// <summary> /// get the request stream asynchronously /// </summary> /// <param name="request">the request</param> /// <returns>the request stream to write on</returns> public static Task<Stream> GetRequestStreamAsync(this WebRequest request) { var taskComplete = new TaskCompletionSource<Stream>(); request.BeginGetRequestStream(asyncStream => { try { Stream requestStream = (Stream)request.EndGetRequestStream(asyncStream); taskComplete.TrySetResult(requestStream); } catch (Exception e) { taskComplete.TrySetException(e); } }, request); return taskComplete.Task; }
public static Task<Stream> GetRequestStreamAsync(this WebRequest request) { var taskSource = new TaskCompletionSource<Stream>(); request.BeginGetRequestStream(ar => { try { var webRequest = ar.AsyncState as WebRequest; var stream = webRequest.EndGetRequestStream(ar); taskSource.TrySetResult(stream); } catch (Exception ex) { taskSource.TrySetException(ex); } }, request); return taskSource.Task; }
public static Task<Stream> GetRequestStreamAsync(this HttpWebRequest request) { var taskComplete = new TaskCompletionSource<Stream>(); request.BeginGetRequestStream(asyncResult => { try { HttpWebRequest webRequest = (HttpWebRequest)asyncResult.AsyncState; Stream stream = (Stream)webRequest.EndGetRequestStream(asyncResult); taskComplete.TrySetResult(stream); } catch (Exception ex) { taskComplete.SetException(ex); } }, request); return taskComplete.Task; }
/// <summary> /// 异常信息与 request 的 BeginGetRequestStream, EndGetRequestStream 相同。 /// </summary> /// <param name="request"></param> /// <returns></returns> public static async Task<Stream> GetRequestStreamAsync(this HttpWebRequest request) { var task = new TaskCompletionSource<Stream>(); request.BeginGetRequestStream(ac => { try { task.SetResult(request.EndGetRequestStream(ac)); } catch (Exception e) { task.SetException(e); } }, null); return await task.Task; }
public static Stream GetRequestStream(this HttpWebRequest request) { var dataReady = new AutoResetEvent(false); Stream stream = null; var callback = new AsyncCallback(delegate(IAsyncResult asynchronousResult) { stream = (Stream)request.EndGetRequestStream(asynchronousResult); dataReady.Set(); }); request.BeginGetRequestStream(callback, request); if (!dataReady.WaitOne(DefaultRequestTimeout)) { return null; } return stream; }
/// <summary> /// Synchronously gets a request stream for a given request. /// </summary> /// <param name="request">The request to be sent.</param> /// <param name="timeout">An optional timeout.</param> /// <returns>The stream that was received for the request.</returns> /// <exception cref="TimeoutException">If the <paramref name="timeout"/> /// parameter was set, and no stream was received within the specified /// time.</exception> public static Stream GetRequestStream(this HttpWebRequest request, int? timeout) { if (request == null) throw new ArgumentNullException("request"); AutoResetEvent waitHandle = new AutoResetEvent(false); Stream requestStream = null; Exception exception = null; AsyncCallback callback = ar => { //get the response try { requestStream = request.EndGetRequestStream(ar); } catch (Exception e) { exception = e; } finally { //setting the handle unblocks the loop below waitHandle.Set(); } }; //request stream async var asyncResult = request.BeginGetRequestStream(callback, null); if (asyncResult.CompletedSynchronously) return requestStream; bool hasSignal = waitHandle.WaitOne(timeout ?? Timeout.Infinite); if (!hasSignal) { throw new TimeoutException("No response received in time."); } //bubble exception that occurred on worker thread if (exception != null) throw exception; return requestStream; }
public static Task<Stream> GetRequestStreamAsync(this WebRequest request) { var tcs = new TaskCompletionSource<Stream>(); request.BeginGetRequestStream(res => tcs.SetResult(request.EndGetRequestStream(res)), request); return tcs.Task; }
internal static Task<Stream> GetRequestStreamAsync(this HttpWebRequest request) { var tcs = new TaskCompletionSource<Stream>(); request.BeginGetRequestStream(asyncResponse => { try { var asyncState = (HttpWebRequest)asyncResponse.AsyncState; var stream = asyncState.EndGetRequestStream(asyncResponse); tcs.TrySetResult(stream); } catch (WebException ex) { tcs.SetException(ex); } }, request); return tcs.Task; }
public static Task<System.IO.Stream> GetRequestStreamAsync(this System.Net.WebRequest request) { return Task.Factory.FromAsync(request.BeginGetRequestStream(null, null), ia => request.EndGetRequestStream(ia)); }
/// <summary> /// Extends BeginGetRequestStream so that when a state object is not needed, null does not need to be passed. /// <example> /// ftpwebrequest.BeginGetRequestStream(callback); /// </example> /// </summary> public static IAsyncResult BeginGetRequestStream(this FtpWebRequest ftpwebrequest, AsyncCallback callback) { if(ftpwebrequest == null) throw new ArgumentNullException("ftpwebrequest"); return ftpwebrequest.BeginGetRequestStream(callback, null); }
public static Stream GetRequestStream(this HttpWebRequest source) { var ar = source.BeginGetRequestStream(null, null); ar.AsyncWaitHandle.WaitOne(); return source.EndGetRequestStream(ar); }
public static void AddBody(this HttpWebRequest request, object body) { var serializedBody = JsonConvert.SerializeObject(body); request.ContentType = "application/json"; var done = new ManualResetEvent(false); request.BeginGetRequestStream(ar => { var request1 = (HttpWebRequest) ar.AsyncState; using (var postStream = request1.EndGetRequestStream(ar)) { var byteArray = Encoding.UTF8.GetBytes(serializedBody); postStream.Write(byteArray, 0, byteArray.Length); } done.Set(); }, request); done.WaitOne(); }
public static async Task<Stream> GetRequestStreamAsync(this WebRequest request) { return await new Task<Stream>(() => { IAsyncResult result = request.BeginGetRequestStream(ar => { }, null); return request.EndGetRequestStream(result); }); }