C# WebRequest.Abort方法代码示例

 private void BeginRequest(WebRequest request, AsyncCallback callback, object state)
 {
     var result = request.BeginGetResponse(callback, state);
     ClientEngine.MainLoop.QueueTimeout(RequestTimeout, delegate
     {
         if (!result.IsCompleted)
             request.Abort();
         return false;
     });
 }

 private static void AbortRequest(WebRequest request)
 {
     try
     {
         if (request != null)
         {
             request.Abort();
         }
     }
     catch (Exception exception)
     {
         if (((exception is OutOfMemoryException) || (exception is StackOverflowException)) || (exception is ThreadAbortException))
         {
             throw;
         }
     }
 }

 private void EndStreaming(WebRequest request)
 {
     _isStreaming = false;
     
     var stream = new MemoryStream(_endStreamBytes);
     var args = new WebQueryResponseEventArgs(stream);
     OnQueryResponse(args);
     request.Abort();
 }

        public Response(WebRequest request)
        {
            int retries = 0;
            const int maxRetries = 3;
            WebException lastEx = null;

            do
            {
                try
                {
                    if (this.response != null)
                    {
                        try
                        {
                            this.response.Close();
                        }
                        catch { }
                    }

                    request.Timeout = 30000;
                    this.response = request.GetResponse();
                    lastEx = null;
                }
                catch (WebException ex)
                {
                    Debug.WriteLine("Response(request) failed with " + ex.Message);
                    long contentLength = request.ContentLength;

                    try
                    {
                        this.response.Close();
                    }
                    catch { }

                    try
                    {
                        request.Abort();
                    }
                    catch { }

                    lastEx = ex;
                    retries += 1;

                    int? statusCode;
                    HttpWebResponse response = ex.Response as HttpWebResponse;
                    if (response == null)
                    {
                        statusCode = null;
                        if (AWSAuthConnection.verbose)
                            Console.WriteLine("WebException ({0}) but couldn't determine status code", ex.Message);
                    }
                    else
                    {
                        statusCode = (int)response.StatusCode;
                        if (AWSAuthConnection.verbose)
                            Console.WriteLine("WebException ({0}) with status code {1}", ex.Message, statusCode);
                    }

                    if (contentLength == -1 && (statusCode == null || (statusCode >= 500 && statusCode < 600)))
                    {
                        if (AWSAuthConnection.verbose)
                            Console.Error.WriteLine("Rebuilding request automatically");

                        // we can rebuild the request here and retry it (sadly there's no request.Reset())
                        WebRequest newRequest = WebRequest.Create(request.RequestUri);
                        foreach (string key in request.Headers.AllKeys)
                            if (key != "Host" && key != "Connection") // can't set either of these directly
                                newRequest.Headers.Add(key, request.Headers[key]);
                        newRequest.Method = request.Method;
                        if (newRequest is HttpWebRequest)
                        {
                            HttpWebRequest httpReq = newRequest as HttpWebRequest;
                            httpReq.AllowWriteStreamBuffering = false;
                        }
                        request = newRequest;

                        System.Threading.Thread.Sleep(250 * (int)Math.Pow(2, retries - 1));
                    }
                    else
                    {
                        request = null;
                        throw;
                    }
                }
            } while (retries < maxRetries && lastEx != null);

            if (lastEx != null)
            {
                Debug.WriteLine("lastEx not null");

                string msg = lastEx.Response != null ? Utils.slurpInputStream(lastEx.Response.GetResponseStream()) : lastEx.Message;
                try
                {
                    lastEx.Response.Close();
                }
                catch
                {
                    // ignore
                }
                throw new WebException(msg, lastEx, lastEx.Status, lastEx.Response);
//.........这里部分代码省略.........

 static IEnumerable<Task> _getResponseAsync(TaskCompletionSource<WebResponse> tcs, WebRequest request, TimeSpan timeout)
 {
     using (var cancellation_token = new Concurrency.TimeoutToken(timeout))
     using (var registration_token = cancellation_token.Token.Register(() => { request.Abort(); }))
     {
         using (var task_get_response = request.GetResponseAsync())
         {
             yield return task_get_response;
             tcs.SetFromTask(task_get_response);
             yield break;
         }
     }
 }

        public void Start()
        {
            if (StreamState == StreamState.Stop && !_isNew)
            {
                return;
            }

            this.Raise(StreamStarted);
            SetStreamState(StreamState.Resume);

            _currentWebRequest = _generateWebRequest();
            _currentStreamReader = CreateStreamReaderFromWebRequest(_currentWebRequest);

            int numberOfRepeatedFailures = 0;

            while (StreamState != StreamState.Stop)
            {
                if (StreamState == StreamState.Pause)
                {
                    using (EventWaitHandle tmpEvent = new ManualResetEvent(false))
                    {
                        tmpEvent.WaitOne(TimeSpan.FromSeconds(STREAM_RESUME_DELAY));
                    }

                    continue;
                }

                try
                {
                    var jsonResponse = GetJsonResponseFromReader();
                    
                    var isJsonResponseValid = jsonResponse != null;
                    if (!isJsonResponseValid)
                    {
                        if (TryHandleInvalidResponse(numberOfRepeatedFailures))
                        {
                            ++numberOfRepeatedFailures;
                            continue;
                        }

                        break;
                    }

                    numberOfRepeatedFailures = 0;

                    if (jsonResponse == string.Empty)
                    {
                        continue;
                    }

                    if (StreamState == StreamState.Resume && !_processObject(jsonResponse))
                    {
                        SetStreamState(StreamState.Stop);
                        break;
                    }
                }
                catch (Exception ex)
                {
                    if (!ShouldContinueAfterHandlingException(ex))
                    {
                        SetStreamState(StreamState.Stop);
                        break;
                    }
                }
            }

            if (_currentWebRequest != null)
            {
                _currentWebRequest.Abort();
            }

            if (_currentStreamReader != null)
            {
                _currentStreamReader.Dispose();
            }
        }

        private StreamReader CreateStreamReaderFromWebRequest(WebRequest webRequest)
        {
            if (webRequest == null)
            {
                SetStreamState(StreamState.Stop);
                return null;
            }

            StreamReader reader = null;

            try
            {
                var twitterQuery = _twitterQueryFactory.Create(webRequest.RequestUri.AbsoluteUri);
                var queryBeforeExecuteEventArgs = new QueryBeforeExecuteEventArgs(twitterQuery);
                _tweetinviEvents.RaiseBeforeQueryExecute(queryBeforeExecuteEventArgs);

                if (queryBeforeExecuteEventArgs.Cancel)
                {
                    SetStreamState(StreamState.Stop);
                    return null;
                }

                // TODO : LINVI - THIS CODE HAS CHANGED AND NEEDS TO BE CHECKED WITH ASP.NET
                var responseStream = _webHelper.GetResponseStreamAsync(webRequest).Result;
                if (responseStream != null)
                {
                    reader = new StreamReader(responseStream, Encoding.GetEncoding("utf-8"));
                }
            }
            catch (WebException wex)
            {
                HandleWebException(wex);
            }
            catch (Exception ex)
            {
                if (ex is ArgumentException)
                {
                    if (ex.Message == "Stream was not readable.")
                    {
                        webRequest.Abort();
                    }
                }

                _lastException = ex;
                SetStreamState(StreamState.Stop);
            }

            return reader;
        }

 private bool CheckCancel(BackgroundWorker worker, DoWorkEventArgs e, WebRequest request)
 {
     if (worker.CancellationPending)
     {
         request.Abort();
         e.Cancel = true;
         return true;
     }
     return false;
 }

        /// <summary>
        /// Init a Stream
        /// </summary>
        /// <param name="webRequest">WebRequest to connect to streaming API</param>
        /// <returns>The stream connected to Twitter Streaming API</returns>
        private static StreamReader init_webRequest(WebRequest webRequest)
        {
            StreamReader reader = null;
            HttpWebResponse webResponse = (HttpWebResponse)webRequest.GetResponse();

            try
            {
                reader = new StreamReader(webResponse.GetResponseStream(), System.Text.Encoding.GetEncoding("utf-8"));
            }
            catch (ArgumentException ex)
            {
                if (ex.Message == "Stream was not readable.")
                {
                    webRequest.Abort();
                    // Modified by Linvi
                }
                else
                    throw ex;
            }

            return reader;
        }