public static WebResponse GetResponseNoEx(this WebRequest req) { WebResponse result = null; ManualResetEvent responseReady = new ManualResetEvent(false); AsyncCallback callback = new AsyncCallback(ar => { //var request = (WebRequest)ar.AsyncState; result = req.EndGetResponseNoEx(ar); responseReady.Set(); }); var async = req.BeginGetResponse(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 responseReady.WaitOne(); //async.AsyncWaitHandle.WaitOne(); } return result; }
public static Task<HttpWebResponse> GetResponseAsync(this HttpWebRequest request) { var tcs = new TaskCompletionSource<HttpWebResponse>(); try { request.BeginGetResponse(iar => { try { var response = (HttpWebResponse)request.EndGetResponse(iar); tcs.SetResult(response); } catch (Exception exc) { tcs.SetException(exc); } }, null); } catch (Exception exc) { tcs.SetException(exc); } return tcs.Task; }
public static HttpResponse ToHttpCall(this WebRequest request) { var reset = new ManualResetEvent(false); IAsyncResult result = null; var thread = new Thread(() => { result = request.BeginGetResponse(r => { }, null); reset.Set(); }); thread.Start(); thread.Join(); reset.WaitOne(); try { var response = request.EndGetResponse(result).As<HttpWebResponse>(); return new HttpResponse(response); } catch (WebException e) { if (e.Response == null) { throw; } var errorResponse = new HttpResponse(e.Response.As<HttpWebResponse>()); return errorResponse; } }
public static Task<WebResponse> GetResponseAsync(this HttpWebRequest request) { var taskComplete = new TaskCompletionSource<WebResponse>(); request.AllowReadStreamBuffering = true; request.AllowWriteStreamBuffering = true; request.BeginGetResponse(asyncResponse => { try { var responseRequest = (HttpWebRequest)asyncResponse.AsyncState; var someResponse = responseRequest.EndGetResponse(asyncResponse); taskComplete.TrySetResult(someResponse); } catch (WebException webExc) { var failedResponse = webExc.Response; taskComplete.TrySetResult(failedResponse); } }, request); return taskComplete.Task; }
public static void DownloadStringAsync(this WebRequest request, Encoding encoding, Action<string> callback) { if (request == null) throw new ArgumentNullException("request"); if (encoding == null) throw new ArgumentNullException("encoding"); if (callback == null) throw new ArgumentNullException("callback"); request.BeginGetResponse((IAsyncResult result) => { try { var response = request.EndGetResponse(result); using (var reader = new StreamReader(response.GetResponseStream(), encoding)) { callback(reader.ReadToEnd()); } } catch (WebException e) { // Don't perform a callback, as this error is mostly due to // there being no internet connection available. System.Diagnostics.Debug.WriteLine(e.Message); } }, request); }
public static Task<HttpWebResponse> GetResponseStreamAsync(this HttpWebRequest context, object state) { // this will be our sentry that will know when our async operation is completed var tcs = new TaskCompletionSource<HttpWebResponse>(); try { context.BeginGetResponse((iar) => { try { var result = context.EndGetResponse(iar as IAsyncResult); tcs.TrySetResult(result as HttpWebResponse); } 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(HttpWebResponse)); // propagate exceptions to the outside throw; } return tcs.Task; }
/// <include file='../_Doc/System.xml' path='doc/members/member[@name="M:System.Net.WebRequest.GetResponse"]/*' /> /// <param name="request">HTTP web request object on which to get response.</param> public static WebResponse GetResponse(this WebRequest request) { #if DOTNET return request.GetResponse(); #else return request.EndGetResponse(request.BeginGetResponse(null, null)); #endif }
public static WebResponse GetResponse(this HttpWebRequest request) { var autoResetEvent = new AutoResetEvent(false); IAsyncResult asyncResult = request.BeginGetResponse(r => autoResetEvent.Set(), null); autoResetEvent.WaitOne(); return request.EndGetResponse(asyncResult); }
public static WebResponse GetResponse(this WebRequest request) { AutoResetEvent autoResetEvent = new AutoResetEvent(false); IAsyncResult asyncResult = request.BeginGetResponse(r => autoResetEvent.Set(), null); // Wait until the call is finished autoResetEvent.WaitOne(); return request.EndGetResponse(asyncResult); }
public static K<WebResponse> GetResponseAsync(this WebRequest request) { return respond => request.BeginGetResponse(result => { var response = request.EndGetResponse(result); respond(response); }, null); }
public static void GetResponseContent(this HttpWebRequest request, Action<string> result) { request.BeginGetResponse((iar) => { WebResponse response = request.EndGetResponse(iar); using (var sr = new StreamReader(response.GetResponseStream())) { result(sr.ReadToEnd()); } }, request); }
public static WebResponse GetResponse(this WebRequest request) { ManualResetEvent evt = new ManualResetEvent(false); WebResponse response = null; request.BeginGetResponse((IAsyncResult ar) => { response = request.EndGetResponse(ar); evt.Set(); }, null); evt.WaitOne(); return response as WebResponse; }
public static IAsyncResult ExecuteGetAsync(this WebRequest request, Action<WebResponseEventArgs> callback) { Console.WriteLine("GET: {0}", request.RequestUri); ClearLastResponse(); return request.BeginGetResponse( result => RaiseWebResponse(request, result, callback), null); }
public static HttpResponse ToHttpCall(this WebRequest request) { var result = request.BeginGetResponse(r => { }, null); try { var response = request.EndGetResponse(result).As<HttpWebResponse>(); return new HttpResponse(response); } catch (WebException e) { var errorResponse = new HttpResponse(e.Response.As<HttpWebResponse>()); Debug.WriteLine(errorResponse.ToString()); return errorResponse; } }
public static Task<HttpWebResponse> GetResponseAsync(this HttpWebRequest request) { var taskComplete = new TaskCompletionSource<HttpWebResponse>(); request.BeginGetResponse(asyncResponse => { try { HttpWebRequest responseRequest = (HttpWebRequest)asyncResponse.AsyncState; HttpWebResponse someResponse = (HttpWebResponse)responseRequest.EndGetResponse(asyncResponse); taskComplete.TrySetResult(someResponse); } catch(WebException webExc) { HttpWebResponse failedResponse = (HttpWebResponse)webExc.Response; taskComplete.TrySetResult(failedResponse); } }, request); return taskComplete.Task; }
/// <summary> /// A blocking operation that does not continue until a response has been /// received for a given <see cref="HttpWebRequest"/>, or the request /// timed out. /// </summary> /// <param name="request">The request to be sent.</param> /// <param name="timeout">An optional timeout.</param> /// <returns>The response that was received for the request.</returns> /// <exception cref="TimeoutException">If the <paramref name="timeout"/> /// parameter was set, and no response was received within the specified /// time.</exception> /// <see href="http://www.hardcodet.net/2010/02/blocking-httpwebrequest-getresponse-for-silverlight"/> public static HttpWebResponse GetSyncResponse(this HttpWebRequest request, int? timeout) { if (request == null) throw new ArgumentNullException("request"); //TODO: check if this method is usable when called from the UI thread in Silverlight //if not, see how we could throw an exception when this is the case (otherwise it just hangs) var waitHandle = new AutoResetEvent(false); HttpWebResponse response = null; Exception exception = null; AsyncCallback callback = ar => { try { //get the response response = (HttpWebResponse)request.EndGetResponse(ar); } catch (Exception e) { exception = e; } finally { //setting the handle unblocks the loop below waitHandle.Set(); } }; //request response async var asyncResult = request.BeginGetResponse(callback, null); if (asyncResult.CompletedSynchronously) return response; bool hasSignal = waitHandle.WaitOne(timeout ?? System.Threading.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 response; }
/// <summary> /// 异常信息与 request 的 BeginGetResponse, EndGetResponse 相同。 /// </summary> /// <param name="request"></param> /// <returns></returns> public static async Task<WebResponse> GetResponseAsync(this HttpWebRequest request) { var task = new TaskCompletionSource<WebResponse>(); request.BeginGetResponse(ac => { try { task.SetResult(request.EndGetResponse(ac)); } catch (Exception e) { task.SetException(e); } }, null); return await task.Task; }
public static HttpWebResponse GetResponse(this HttpWebRequest request) { var dataReady = new AutoResetEvent(false); HttpWebResponse response = null; var callback = new AsyncCallback(delegate(IAsyncResult asynchronousResult) { response = (HttpWebResponse)request.EndGetResponse(asynchronousResult); dataReady.Set(); }); request.BeginGetResponse(callback, request); if (dataReady.WaitOne(DefaultRequestTimeout)) { return response; } return null; }
/// <summary> /// A blocking operation that does not continue until a response has been /// received for a given <see cref="HttpWebRequest"/>, or the request /// timed out. /// </summary> /// <param name="request">The request to be sent.</param> /// <param name="timeout">An optional timeout.</param> /// <returns>The response that was received for the request.</returns> /// <exception cref="TimeoutException">If the <paramref name="timeout"/> /// parameter was set, and no response was received within the specified /// time.</exception> /// <remarks>You must not invoke this method on the UI thread, or the call will /// time out. This is because the <see cref="HttpWebRequest.EndGetResponse"/> /// method accesses the UI thread as well, which will starve the worker thread.</remarks> public static HttpWebResponse GetResponse(this HttpWebRequest request, int? timeout) { if (request == null) throw new ArgumentNullException("request"); AutoResetEvent waitHandle = new AutoResetEvent(false); HttpWebResponse response = null; Exception exception = null; AsyncCallback callback = ar => { try { //get the response response = (HttpWebResponse)request.EndGetResponse(ar); } catch(Exception e) { exception = e; } finally { //setting the handle unblocks the loop below waitHandle.Set(); } }; //request response async var asyncResult = request.BeginGetResponse(callback, null); if (asyncResult.CompletedSynchronously) return response; 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 response; }
public static Task<WebResponse> GetResponseAsync(this WebRequest request) { var completerionSource = new TaskCompletionSource<WebResponse>(); request.BeginGetResponse(asyncResponse => { try { var r = (WebRequest)asyncResponse.AsyncState; var response = r.EndGetResponse(asyncResponse); completerionSource.TrySetResult(response); } catch (WebException ex) { completerionSource.TrySetException(ex); } }, request); return completerionSource.Task; }
public static Task<WebResponse> GetResponseAsync(this WebRequest request) { var taskSource = new TaskCompletionSource<WebResponse>(); request.BeginGetResponse(ar => { try { var webRequest = ar.AsyncState as WebRequest; var response = webRequest.EndGetResponse(ar); taskSource.TrySetResult(response); } catch (WebException wex) { taskSource.TrySetResult(wex.Response); } catch (Exception ex) { taskSource.TrySetException(ex); } }, request); return taskSource.Task; }
public static HttpWebResponse GetResponse(this HttpWebRequest request) { if (IsUiThread()) return null; HttpWebResponse response = null; var mre = new ManualResetEvent(false); Exception ex = null; ThreadPool.QueueUserWorkItem(obj => request.BeginGetResponse(ar => { try { request = (HttpWebRequest)ar.AsyncState != null ? (HttpWebRequest)ar.AsyncState : request; response = (HttpWebResponse)request.EndGetResponse(ar); } catch (Exception e) { ex = e; } finally { mre.Set(); } }, null )); mre.WaitOne(5000); if (ex != null) // throw an error if we encountered one throw ex; // return whatever we got return response; }
public static Task<HttpWebResponse> GetResponseAsync(this HttpWebRequest request) { var taskComplete = new TaskCompletionSource<HttpWebResponse>(); request.BeginGetResponse(asyncResult => { try { HttpWebRequest webRequest = (HttpWebRequest)asyncResult.AsyncState; HttpWebResponse webResponse = (HttpWebResponse)webRequest.EndGetResponse(asyncResult); taskComplete.TrySetResult(webResponse); } catch (WebException ex) { HttpWebResponse webResponse = (HttpWebResponse)ex.Response; taskComplete.TrySetResult(webResponse); } catch (Exception ex) { taskComplete.SetException(ex); } }, request); return taskComplete.Task; }
public static async Task<HttpWebResponse> GetResponseAsync(this HttpWebRequest request) { var tcs = new TaskCompletionSource<HttpWebResponse>(); request.BeginGetResponse(ar => { try { var response = (HttpWebResponse)request.EndGetResponse(ar); tcs.SetResult(response); } catch (WebException ex) { HttpWebResponse response = (HttpWebResponse)ex.Response; tcs.SetException(new WebRequestorFailure(response.StatusCode, response.Headers)); } catch (Exception ex) { tcs.SetException(ex); } }, null); return await tcs.Task; }
/// <summary> /// Returns a response to an Internet request as an asynchronous operation. /// </summary> /// <remarks> /// This operation will not block. The returned <see cref="Task{TResult}"/> object will /// complete after a response to an Internet request is available. /// </remarks> /// <param name="request">The request.</param> /// <param name="cancellationToken">The <see cref="CancellationToken"/> that will be assigned to the new <see cref="Task"/>.</param> /// <returns>A <see cref="Task"/> object which represents the asynchronous operation.</returns> /// <exception cref="ArgumentNullException">If <paramref name="request"/> is <see langword="null"/>.</exception> /// <exception cref="WebException"> /// If <see cref="WebRequest.Abort"/> was previously called. /// <para>-or-</para> /// <para>If the timeout period for the request expired.</para> /// <para>-or-</para> /// <para>If an error occurred while processing the request.</para> /// </exception> public static Task<WebResponse> GetResponseAsync(this WebRequest request, CancellationToken cancellationToken) { if (request == null) throw new ArgumentNullException("request"); bool timeout = false; TaskCompletionSource<WebResponse> completionSource = new TaskCompletionSource<WebResponse>(); RegisteredWaitHandle timerRegisteredWaitHandle = null; RegisteredWaitHandle cancellationRegisteredWaitHandle = null; AsyncCallback completedCallback = result => { try { if (cancellationRegisteredWaitHandle != null) cancellationRegisteredWaitHandle.Unregister(null); if (timerRegisteredWaitHandle != null) timerRegisteredWaitHandle.Unregister(null); completionSource.TrySetResult(request.EndGetResponse(result)); } catch (WebException ex) { if (timeout) completionSource.TrySetException(new WebException("No response was received during the time-out period for a request.", WebExceptionStatus.Timeout)); else if (cancellationToken.IsCancellationRequested) completionSource.TrySetCanceled(); else completionSource.TrySetException(ex); } catch (Exception ex) { completionSource.TrySetException(ex); } }; IAsyncResult asyncResult = request.BeginGetResponse(completedCallback, null); if (!asyncResult.IsCompleted) { if (request.Timeout != Timeout.Infinite) { WaitOrTimerCallback timedOutCallback = (object state, bool timedOut) => { if (timedOut) { timeout = true; request.Abort(); } }; timerRegisteredWaitHandle = ThreadPool.RegisterWaitForSingleObject(asyncResult.AsyncWaitHandle, timedOutCallback, null, request.Timeout, true); } if (cancellationToken.CanBeCanceled) { WaitOrTimerCallback cancelledCallback = (object state, bool timedOut) => { if (cancellationToken.IsCancellationRequested) request.Abort(); }; cancellationRegisteredWaitHandle = ThreadPool.RegisterWaitForSingleObject(cancellationToken.WaitHandle, cancelledCallback, null, Timeout.Infinite, true); } } return completionSource.Task; }
/// <summary> /// Begins an asynchronous request to an Internet resource, using GZIP when supported by the server. /// </summary> /// <param name="request">Request to act on.</param> /// <param name="callback">The AsyncCallback delegate.</param> /// <param name="state">The state object for this request.</param> /// <returns>An IAsyncResult that references the asynchronous request for a response.</returns> /// <remarks> /// Functionally equivalent to BeginGetResponse (with GZIP). /// </remarks> public static IAsyncResult BeginGetCompressedResponse(this HttpWebRequest request, AsyncCallback callback, object state) { AddAcceptEncodingHeader(request); return request.BeginGetResponse(callback, state); }
internal static Task<HttpWebResponse> GetResponseAsync(this HttpWebRequest request) { var tcs = new TaskCompletionSource<HttpWebResponse>(); request.BeginGetResponse(asyncResponse => { try { var asyncState = (HttpWebRequest)asyncResponse.AsyncState; var response = (HttpWebResponse)asyncState.EndGetResponse(asyncResponse); tcs.TrySetResult(response); } catch (WebException ex) { var failedResponse = (HttpWebResponse)ex.Response; tcs.TrySetResult(failedResponse); } }, request); return tcs.Task; }
/// <summary> /// Returns a response to an Internet request as an asynchronous operation. /// </summary> /// <remarks> /// <para>This operation will not block. The returned <see cref="Task{TResult}"/> object will /// complete after a response to an Internet request is available.</para> /// </remarks> /// <param name="request">The request.</param> /// <param name="throwOnError"><see langword="true"/> to throw a <see cref="WebException"/> if the <see cref="HttpWebResponse.StatusCode"/> of the response is greater than 400; otherwise, <see langword="false"/> to return the <see cref="WebResponse"/> in the result for these cases.</param> /// <param name="cancellationToken">The <see cref="CancellationToken"/> that will be assigned to the new <see cref="Task"/>.</param> /// <returns>A <see cref="Task"/> object which represents the asynchronous operation.</returns> /// <exception cref="ArgumentNullException"> /// <para>If <paramref name="request"/> is <see langword="null"/>.</para> /// </exception> /// <exception cref="WebException"> /// <para>If <see cref="WebRequest.Abort"/> was previously called.</para> /// <para>-or-</para> /// <para>If the timeout period for the request expired.</para> /// <para>-or-</para> /// <para>If an error occurred while processing the request.</para> /// </exception> public static Task<WebResponse> GetResponseAsync(this WebRequest request, bool throwOnError, CancellationToken cancellationToken) { if (request == null) throw new ArgumentNullException("request"); #if PORTABLE bool timeout = false; CancellationTokenRegistration cancellationTokenRegistration; if (cancellationToken.CanBeCanceled) { Action cancellationAction = request.Abort; cancellationTokenRegistration = cancellationToken.Register(cancellationAction); } else { cancellationTokenRegistration = default(CancellationTokenRegistration); } CancellationTokenSource noRequestTimeoutTokenSource = new CancellationTokenSource(); WebExceptionStatus timeoutStatus; if (!Enum.TryParse("Timeout", out timeoutStatus)) timeoutStatus = WebExceptionStatus.UnknownError; int requestTimeout; #if NET45PLUS try { // hack to work around PCL limitation in .NET 4.5 dynamic dynamicRequest = request; requestTimeout = dynamicRequest.Timeout; } catch (RuntimeBinderException) { requestTimeout = Timeout.Infinite; } #else // hack to work around PCL limitation in .NET 4.0 var propertyInfo = request.GetType().GetProperty("Timeout", typeof(int)); if (propertyInfo != null) { requestTimeout = (int)propertyInfo.GetValue(request, null); } else { requestTimeout = Timeout.Infinite; } #endif if (requestTimeout >= 0) { Task timeoutTask = DelayedTask.Delay(TimeSpan.FromMilliseconds(requestTimeout), noRequestTimeoutTokenSource.Token).Select( _ => { timeout = true; request.Abort(); }); } TaskCompletionSource<WebResponse> completionSource = new TaskCompletionSource<WebResponse>(); AsyncCallback completedCallback = result => { try { noRequestTimeoutTokenSource.Cancel(); noRequestTimeoutTokenSource.Dispose(); cancellationTokenRegistration.Dispose(); completionSource.TrySetResult(request.EndGetResponse(result)); } catch (WebException ex) { if (timeout) completionSource.TrySetException(new WebException("No response was received during the time-out period for a request.", timeoutStatus)); else if (cancellationToken.IsCancellationRequested) completionSource.TrySetCanceled(); else if (ex.Response != null && !throwOnError) completionSource.TrySetResult(ex.Response); else completionSource.TrySetException(ex); } catch (Exception ex) { completionSource.TrySetException(ex); } }; IAsyncResult asyncResult = request.BeginGetResponse(completedCallback, null); return completionSource.Task; #else bool timeout = false; TaskCompletionSource<WebResponse> completionSource = new TaskCompletionSource<WebResponse>(); RegisteredWaitHandle timerRegisteredWaitHandle = null; RegisteredWaitHandle cancellationRegisteredWaitHandle = null; AsyncCallback completedCallback = result => { try { if (cancellationRegisteredWaitHandle != null) cancellationRegisteredWaitHandle.Unregister(null); if (timerRegisteredWaitHandle != null) timerRegisteredWaitHandle.Unregister(null); completionSource.TrySetResult(request.EndGetResponse(result)); } catch (WebException ex) { if (timeout) completionSource.TrySetException(new WebException("No response was received during the time-out period for a request.", WebExceptionStatus.Timeout)); else if (cancellationToken.IsCancellationRequested) completionSource.TrySetCanceled(); else if (ex.Response != null && !throwOnError) completionSource.TrySetResult(ex.Response); else completionSource.TrySetException(ex); } catch (Exception ex) { completionSource.TrySetException(ex); } }; IAsyncResult asyncResult = request.BeginGetResponse(completedCallback, null); if (!asyncResult.IsCompleted) { if (request.Timeout != Timeout.Infinite) { WaitOrTimerCallback timedOutCallback = (object state, bool timedOut) => { if (timedOut) { timeout = true; request.Abort(); } }; timerRegisteredWaitHandle = ThreadPool.RegisterWaitForSingleObject(asyncResult.AsyncWaitHandle, timedOutCallback, null, request.Timeout, true); } if (cancellationToken.CanBeCanceled) { WaitOrTimerCallback cancelledCallback = (object state, bool timedOut) => { if (cancellationToken.IsCancellationRequested) request.Abort(); }; cancellationRegisteredWaitHandle = ThreadPool.RegisterWaitForSingleObject(cancellationToken.WaitHandle, cancelledCallback, null, Timeout.Infinite, true); } } return completionSource.Task; #endif }
public static WebResponse GetResponse(this HttpWebRequest request) { var result = request.BeginGetResponse(null, null); return request.EndGetResponse(result); }
/// <summary> /// Extends BeginGetResponse so that when a state object is not needed, null does not need to be passed. /// <example> /// ftpwebrequest.BeginGetResponse(callback); /// </example> /// </summary> public static IAsyncResult BeginGetResponse(this FtpWebRequest ftpwebrequest, AsyncCallback callback) { if(ftpwebrequest == null) throw new ArgumentNullException("ftpwebrequest"); return ftpwebrequest.BeginGetResponse(callback, null); }