C# HttpWebRequest.BeginGetResponse方法代码示例

 private void GetRequest(string word)
 {
     Uri reqUri = GetRequestUri(word);
     request = (HttpWebRequest)WebRequest.Create(reqUri);
     AsyncCallback callback = new AsyncCallback(ProcessRequest);
     request.BeginGetResponse(callback, null);
 }

 public void Download(String URL)
 {
     URL = HttpUtility.UrlEncode(URL);
     string req_src = api_req_url + URL;
     wr = (HttpWebRequest)HttpWebRequest.Create(new Uri(req_src, UriKind.Absolute));
     wr.BeginGetResponse(new AsyncCallback(req_callback), wr);
 }

        public Task<WebResponse> GetResponseAsync(HttpWebRequest request, int timeoutMs)
        {
            if (timeoutMs > 0)
            {
                return GetResponseAsync(request, TimeSpan.FromMilliseconds(timeoutMs));
            }

            var tcs = new TaskCompletionSource<WebResponse>();

            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;
        }

        /// <summary>
        /// Encapsulates GetResponse so tests don't invoke the request
        /// </summary>
        /// <param name="req">Request to Twitter</param>
        /// <returns>Response to Twitter</returns>
        public static HttpWebResponse AsyncGetResponse(HttpWebRequest req)
        {
            Exception asyncException = null;

            var resetEvent = new ManualResetEvent(/*initialStateSignaled:*/ false);
            HttpWebResponse res = null;

            req.BeginGetResponse(
                new AsyncCallback(
                    ar =>
                    {
                        try
                        {
                            res = req.EndGetResponse(ar) as HttpWebResponse;
                        }
                        catch (Exception ex)
                        {
                            asyncException = ex;
                        }
                        finally
                        {
                            resetEvent.Set();
                        }
                    }), null);

            resetEvent.WaitOne();

            if (asyncException != null)
            {
                throw asyncException;
            }

            return res;
        }

    public void BeginGetHeight(XYPoint point, int UTMZone)
    {
      string url = String.Format("http://kmswww3.kms.dk/FindMinHoejde/Default.aspx?display=show&csIn=utm{2}_euref89&csOut=utm32_euref89&x={0}&y={1}&c=dk", point.X, point.Y, UTMZone);

      request = (HttpWebRequest)WebRequest.Create(url);
      result= (IAsyncResult) request.BeginGetResponse(new AsyncCallback(RespCallback),null);
    }

 private HttpWebResponse GetResponseAsynch(HttpWebRequest request)
 {
     return AsynchHelper.WaitForAsynchResponse(
         c => request.BeginGetResponse(c, null),
         (r, s) => (HttpWebResponse)request.EndGetResponse(r)
     );
 }

        public void FetchSearchResults(HttpWebRequest queryRequest)
        {
            this.WebResultCollection.Clear();

            IsLoading = true;

            queryRequest.BeginGetResponse(new AsyncCallback(ReadCallback), queryRequest);
        }

        private void button_Click(object sender, RoutedEventArgs e)
        {
            if (list.Items.Count != 0)
                list.Items.Clear();

            http = (HttpWebRequest)WebRequest.Create("http://192.168.2.39/TOSWEB/webservice/service.php");
            http.BeginGetResponse(new AsyncCallback(ReadWebRequestCallBack), http);
        }

        protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
        {
            DownloadStatusText.Text = "Downloading image from " + imageUrl;
            webRequest = (HttpWebRequest)HttpWebRequest.CreateHttp(imageUrl);
            webRequest.BeginGetResponse(new AsyncCallback(ResponseCallback), webRequest);

            base.OnNavigatedTo(e);
        }

        public static IEnumerator<object> IssueRequest(HttpWebRequest request)
        {
            var fResponse = new Future<HttpWebResponse>();
            ThreadPool.QueueUserWorkItem(
                (__) => {
                    try {
                        request.BeginGetResponse(
                            (ar) => {
                                try {
                                    var _ = (HttpWebResponse)request.EndGetResponse(ar);
                                    fResponse.SetResult(_, null);
                                } catch (Exception ex) {
                                    fResponse.SetResult(null, ex);
                                }
                            }, null
                        );
                    } catch (Exception ex_) {
                        fResponse.SetResult(null, ex_);
                    }
                }
            );

            yield return fResponse;
            if (fResponse.Failed)
                throw new RequestFailedException(fResponse.Error);

            using (var response = fResponse.Result) {
                var fResponseStream = Future.RunInThread(
                    () => response.GetResponseStream()
                );
                yield return fResponseStream;

                Encoding encoding = AsyncTextReader.DefaultEncoding;
                if (!string.IsNullOrEmpty(response.CharacterSet))
                    encoding = Encoding.GetEncoding(response.CharacterSet);

                string responseText;
                using (var stream = fResponseStream.Result)
                using (var adapter = new AsyncTextReader(new StreamDataAdapter(stream, false), encoding)) {
                    var fText = adapter.ReadToEnd();

                    yield return fText;

                    responseText = fText.Result;
                }

                var cookies = new Cookie[response.Cookies.Count];
                response.Cookies.CopyTo(cookies, 0);

                yield return new Result(new Response {
                    Body = responseText,
                    ContentType = response.ContentType,
                    StatusCode = response.StatusCode,
                    StatusDescription = response.StatusDescription,
                    Cookies = cookies
                });
            }
        }

        public void SendCommandAsync(JsonAsyncCallback jCallback)
        {
            jb = jCallback;
            //String qryString = uri + name + "?" + (secret != Guid.Empty ? ("secret=" + secret.ToString() + "&") : "") + paramString;
            String qryString = uri + name + "?" + paramString;

            request = (HttpWebRequest)HttpWebRequest.Create(qryString);
            IAsyncResult result = (IAsyncResult)request.BeginGetResponse(RespCallback, null);
        }

 static void SendMinecraftNetBeat() {
     HeartbeatData data = new HeartbeatData( MinecraftNetUri );
     if( !RaiseHeartbeatSendingEvent( data, MinecraftNetUri, true ) ) {
         return;
     }
     minecraftNetRequest = CreateRequest( data.CreateUri() );
     var state = new HeartbeatRequestState( minecraftNetRequest, data );
     minecraftNetRequest.BeginGetResponse( ResponseCallback, state );
 }

 public void GetData()
 {
     using (var File = IsolatedStorageFile.GetUserStoreForApplication())
     {
         request = (HttpWebRequest)HttpWebRequest.Create("http://www.search4rss.com/search.php?lang=en&q=" + txt_Search.Text);
         Dispatcher.BeginInvoke(() => RssList.Visibility=Visibility.Collapsed);
         Dispatcher.BeginInvoke(() => Loading_for_Search.Visibility=Visibility.Visible);
         request.BeginGetResponse(new AsyncCallback(ReadWebRequestCallback), request);
     }
 }

        public void DownloadDataAsync(HttpWebRequest request, byte[] d,  int millisecondsTimeout,
           RequestCompletedEventHandler completedCallback)
        {
            RequestState state = new RequestState(request, d, millisecondsTimeout, completedCallback, null);

            IAsyncResult result = request.BeginGetResponse(GetResponse, state);

#if !NETFX_CORE
            ThreadPool.RegisterWaitForSingleObject(result.AsyncWaitHandle, TimeoutCallback, state, millisecondsTimeout, true);
#endif
        }

 /// <summary>Attempts to get data from a web request.</summary>
 /// <param name="request">The HTTP web request.</param>
 /// <param name="method">The OneAll supported HTTP method to use.</param>
 /// <param name="creds">The <see cref="Credential"/> used to authenticate the call, or null for calls not requiring authentication.</param>
 /// <param name="callBack">The call-back to invoke after the request is complete.</param>
 /// <param name="state">The initial state object provided.</param>
 private static void GetAsync(HttpWebRequest request, OneAllMethod method, Credential creds, BinaryReceivedHandler callBack, object state)
 {
     request.SetHTTPMethod(method);
     request.SetBasicAuth(creds);
     request.BeginGetResponse(OnRequestCompleted, new BinaryWebClientState()
     {
         Request = request,
         Callback = callBack,
         State = state
     });
 }