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;
		}
Example #5
0
        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;
        }
Example #7
0
        /// <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
        }
Example #8
0
        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);
        }
Example #9
0
 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);
 }
Example #10
0
 public static K<WebResponse> GetResponseAsync(this WebRequest request)
 {
     return respond => request.BeginGetResponse(result =>
         {
             var response = request.EndGetResponse(result);
             respond(response);
         }, null);
 }
Example #11
0
 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;
 }
Example #13
0
        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;
            }
        }
Example #15
0
 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;
        }
Example #19
0
    /// <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);
 }
Example #27
0
 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);
        }