C# HttpWebRequest.Abort方法代码示例

        // Simple WebRequest
        public string ExecuteWebRequest(HttpWebRequest webRequest)
        {
            try
            {
                var webRequestResult = GetWebRequestResultFromHttpClient(webRequest);

                if (!webRequestResult.IsSuccessStatusCode)
                {
                    throw _exceptionHandler.TryLogFailedWebRequestResult(webRequestResult);
                }

                var stream = webRequestResult.ResultStream;

                if (stream != null)
                {
                    // Getting the result
                    var responseReader = new StreamReader(stream);
                    return responseReader.ReadLine();
                }

                // Closing the connection
                webRequest.Abort();
            }
            catch (AggregateException aex)
            {
                var webException = aex.InnerException as WebException;
                var httpRequestMessageException = aex.InnerException as HttpRequestException;

                if (httpRequestMessageException != null)
                {
                    webException = httpRequestMessageException.InnerException as WebException;
                }

                if (webException != null)
                {
                    if (webRequest != null)
                    {
                        webRequest.Abort();

                        throw _exceptionHandler.TryLogWebException(webException, webRequest.RequestUri.AbsoluteUri);
                    }

                    throw webException;
                }

                throw;
            }
            catch (TimeoutException)
            {
                var twitterTimeoutException = _twitterTimeoutExceptionFactory.Create(new ConstructorNamedParameter("url", webRequest.RequestUri.AbsoluteUri));
                if (_exceptionHandler.LogExceptions)
                {
                    _exceptionHandler.AddTwitterException(twitterTimeoutException);
                }

                throw (Exception)twitterTimeoutException;
            }

            return null;
        }

        public static void CheckUpdate()
        {
            kIRCVersionChecker.Init();
            Updater = (HttpWebRequest)HttpWebRequest.Create(update_checkerurl);
            Updater_Response = (HttpWebResponse)Updater.GetResponse();

            if (Updater_Response.StatusCode == HttpStatusCode.OK)
            {
                Rocket.Unturned.Logging.Logger.Log("kIRC: Contacting updater...");
                Stream reads = Updater_Response.GetResponseStream();
                byte[] buff = new byte[10];
                reads.Read(buff, 0, 10);
                string ver = Encoding.UTF8.GetString(buff);
                ver = ver.ToLower().Trim(new[] { ' ', '\r', '\n', '\t' }).TrimEnd(new[] { '\0' });

                if (ver == VERSION.ToLower().Trim())
                {
                    Rocket.Unturned.Logging.Logger.Log("kIRC: This plugin is using the latest version!");
                }
                else
                {
                    Rocket.Unturned.Logging.Logger.LogWarning("kIRC Warning: Plugin version mismatch!");
                    Rocket.Unturned.Logging.Logger.LogWarning("Current version: "+VERSION+", Latest version on repository is " + ver + ".");
                }
            }
            else
            {
                Rocket.Unturned.Logging.Logger.LogError("kIRC Error: Failed to contact updater.");
            }
            Updater.Abort();
            Updater = null;
            Updater_Response = null;
            lastchecked = DateTime.Now;
        }

        void HeartBeatHandler() {
            while( true ) {
                try {
                    request = (HttpWebRequest)WebRequest.Create( URL );
                    request.Method = "POST";
                    request.Timeout = 15000; // 15s timeout
                    request.ContentType = "application/x-www-form-urlencoded";
                    request.CachePolicy = new System.Net.Cache.RequestCachePolicy( System.Net.Cache.RequestCacheLevel.NoCacheNoStore );
                    byte[] formData = Encoding.ASCII.GetBytes( staticData + "&users=" + world.GetPlayerCount() );
                    request.ContentLength = formData.Length;

                    using( Stream requestStream = request.GetRequestStream() ) {
                        requestStream.Write( formData, 0, formData.Length );
                        requestStream.Flush();
                    }

                    if( !hasReportedServerURL ) {
                        using( WebResponse response = request.GetResponse() ) {
                            using( StreamReader responseReader = new StreamReader( response.GetResponseStream() ) ) {
                                world.config.ServerURL = responseReader.ReadToEnd().Trim();
                            }
                        }
                        request.Abort();
                        hash = world.config.ServerURL.Substring( world.config.ServerURL.LastIndexOf( '=' ) + 1 );
                        world.FireURLChange( world.config.ServerURL );
                        hasReportedServerURL = true;
                    }

                } catch( Exception ex ) {
                    world.log.Log( "HeartBeat: {0}", LogType.Error, ex.Message );
                }

                try {
                    request = (HttpWebRequest)WebRequest.Create( fListURL );
                    request.Method = "POST";
                    request.Timeout = 15000; // 15s timeout
                    request.ContentType = "application/x-www-form-urlencoded";
                    request.CachePolicy = new System.Net.Cache.RequestCachePolicy( System.Net.Cache.RequestCacheLevel.NoCacheNoStore );
                    string requestString = staticData +
                                            "&users=" + world.GetPlayerCount() +
                                            "&hash=" + hash +
                                            "&motd=" + Server.UrlEncode( world.config.GetString( "MOTD" ) ) +
                                            "&server=fcraft" +
                                            "&players=" + world.GetPlayerListString();
                    byte[] formData = Encoding.ASCII.GetBytes( requestString );
                    request.ContentLength = formData.Length;

                    using( Stream requestStream = request.GetRequestStream() ) {
                        requestStream.Write( formData, 0, formData.Length );
                        requestStream.Flush();
                    }
                    request.Abort();
                } catch( Exception ex ) {
                    world.log.Log( "HeartBeat: Error reporting to fList: {0}", LogType.Error, ex.Message );
                }

                Thread.Sleep( Config.HeartBeatDelay );
            }
        }

        /// <summary>
        /// Reads the information received from the Twitter real-time data stream.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <param name="response">The response.</param>
        private void ReadResponseStream(HttpWebRequest request, HttpWebResponse response)
        {
            byte[] buffer = new byte[65536];
            using (Stream stream = response.GetResponseStream())
            {
                while (this.InternalConnectionStatus == ConnectionStatus.Connected)
                {
                    int read = stream.Read(buffer, 0, buffer.Length);

                    this._dateReceivedInLastSecond += read;

                    UTF8Encoding encoding = new UTF8Encoding();
                    string data = encoding.GetString(buffer, 0, read);
                    ParseResponseChunk(data);
                }

                // need to call request.Abort or the the thread will block at the end of
                // the using block.
                request.Abort();
            }
        }

        public void Abort_BeginGetResponseThenAbort_EndGetResponseThrowsWebException(Uri remoteServer)
        {
            _savedHttpWebRequest = HttpWebRequest.CreateHttp(remoteServer);

            _savedHttpWebRequest.BeginGetResponse(new AsyncCallback(ResponseCallback), null);

            _savedHttpWebRequest.Abort();
            WebException wex = _savedResponseException as WebException;
            Assert.Equal(WebExceptionStatus.RequestCanceled, wex.Status);
        }

 public static void AbortRequest(HttpWebRequest request)
 {
     request.Abort();
 }

        void CleanupOnError(HttpWebRequest request, HttpWebResponse response)
        {
            if (response != null)
            {
                response.Close();
            }

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

            this.Cleanup();
            this.RemoveIdentityMapping(true);
        }

 private void writeRequestBodyFromStream(HttpWebRequest con, Stream data, long streamLength)
 {
     // post data
     Stream s = null;
     try
     {
         con.ContentLength = streamLength;
         con.SendChunked = false;
         byte[] buffer = new byte[64 * 1024];
         s = con.GetRequestStream();
         for (long i = 0; i < streamLength; )
         {
             if (i + buffer.Length > streamLength)
             {
                 int bytesToRead = (int)(streamLength - i);
                 int count = data.Read(buffer, 0, bytesToRead);
                 if (count == 0)
                 {
                     con.Abort();
                     throw new EsuException("Premature EOF reading stream at offset " + i);
                 }
                 s.Write(buffer, 0, count);
                 i += count;
             }
             else
             {
                 int count = data.Read(buffer, 0, buffer.Length);
                 if (count == 0)
                 {
                     con.Abort();
                     throw new EsuException("Premature EOF reading stream at offset " + i);
                 }
                 s.Write(buffer, 0, count);
                 i += count;
             }
         }
         s.Close();
     }
     catch (IOException e)
     {
         s.Close();
         throw new EsuException("Error posting data", e);
     }
 }

        /// <summary>
        /// HTTP/HTTPS的GET方法获取HttpWebResponse
        /// </summary>
        /// <param name="Url">要GET数据的网址</param>
        /// <param name="headers">HTTP协议中消息报头所带的headers信息</param>
        /// <returns>HttpWebResponse</returns>
        protected void GetResponse(String Url, ref HttpWebResponse Response, ref HttpWebRequest rqst, String[] headers, int level = 0)
        {
            //如果使用代理https变为http
            //if (Url.ToLower().Contains("https://") && proxy.Address != null)
            //    Url = "http" + Url.Substring(5);
            Uri uri = new Uri(Url);
            //设置HTTPS方式
            if (Url.ToLower().Contains("https://"))
                ServicePointManager.ServerCertificateValidationCallback = CheckValidationResult;
            //构造HTTP头

            rqst = (HttpWebRequest)WebRequest.Create(uri);
            rqst.KeepAlive = true;
            rqst.AllowAutoRedirect = false;
            rqst.ServicePoint.Expect100Continue = false;
            rqst.MaximumAutomaticRedirections = 3;
            rqst.UserAgent = UserAgent;
            if (reffer != null)
            {
                try
                {
                    rqst.Referer = reffer.AbsoluteUri;
                }
                catch { }
            }
            foreach (String s in headers)
            {
                rqst.Headers.Add(s);
            }
            rqst.Timeout = timeOut;
            rqst.CookieContainer = Cookies;
            if (proxy.Address != null)
            {
                rqst.ProtocolVersion = HttpVersion.Version10;
                //启用代理
                rqst.UseDefaultCredentials = true;
                rqst.Proxy = proxy;
            }
            //记录当前访问页以便下次访问设置Reffer
            reffer = uri;
            //访问URL
            Response = (HttpWebResponse)rqst.GetResponse();
            //更新COOKIE
            foreach (Cookie ck in Response.Cookies)
            {
                Cookies.Add(ck);
            }
            //防止无限循环跳转
            if (level < 10)
            {
                //自动重定向网页

                if (Response.Headers["Location"] != null)
                {
                    Response.Close();
                    rqst.Abort();
                    String location = Response.Headers["Location"];
                    if (!location.Contains("://"))
                        location = uri.Scheme + "://" + uri.Authority + location;
                    GetResponse(location, ref Response, ref rqst, ++level);
                }
                else if (Response.ResponseUri != uri)
                {
                    Response.Close();
                    rqst.Abort();
                    GetResponse(Response.ResponseUri.AbsoluteUri, ref Response, ref rqst, ++level);
                }
            }
        }

        private HttpWebResponse GetResponseWithTimeout(HttpWebRequest req)
        {
            AutoResetEvent ev=new AutoResetEvent(false);
            IAsyncResult result =req.BeginGetResponse(GetResponseCallback, ev);

            if (!ev.WaitOne(ResponseTimeout))
            {
                req.Abort();
                return null;
            }
            /*
            if (!HttpClientParams.WaitOneEmpty)
            {
                if (!ev.WaitOne(ResponseTimeout))
                {
                    req.Abort();
                    return null;
                }
            }
            else
                if (!ev.WaitOne())
                {
                    req.Abort();
                    return null;
                }
             */

            /*if (!m_Ajax) */Referer = req.RequestUri.ToString();
            return (HttpWebResponse)req.EndGetResponse(result);
        }

        private HttpWebResponse GetResponseWithTimeout(HttpWebRequest req)
        {
            bool m_Ajax = Ajax; Ajax = false;
            AutoResetEvent ev=new AutoResetEvent(false);
            IAsyncResult Japan =req.BeginGetResponse(GetResponseCallback, ev);

            if(!ev.WaitOne(Timeout))
            {
                req.Abort();
                return null;
            }
            if (!m_Ajax) Referer = req.RequestUri.ToString();
            return (HttpWebResponse)req.EndGetResponse(Japan);
        }

        private static void get(HttpWebRequest request, YebobHandler handler, ErrorHandler onError)
        {
            request.AllowReadStreamBuffering = true;
            var ob = Observable.FromAsyncPattern<WebResponse>(request.BeginGetResponse, request.EndGetResponse);

            if(onError == null){
                onError = new ErrorHandler(defaultErrorHandler);
            }

            Log.d("Yebob send " + DateTime.Now);
            Observable.Timeout(ob.Invoke(), DateTimeOffset.Now.AddSeconds(10))
                .ObserveOnDispatcher() //include if UI accessed from subscribe
                .Subscribe(response =>
                {
                    Log.d("Yebob recv " + DateTime.Now);
                    using (var responseStream = response.GetResponseStream())
                    {
                        using (var sr = new StreamReader(responseStream, Encoding.UTF8))
                        {
                            String result = sr.ReadToEnd();
                            handleResponse(result, handler, onError);
                        }
                    }
                }, ex =>
                {
                    Log.e("Yebob error " + ex.Message);
                    onError(ERROR.HTTP_HAS_EXCEPTION, "Yebob error " + ex.Message);
                    request.Abort();
                });
        }

        public static async Task<string> DownloadWebsiteAsStringAsync(HttpWebRequest req)
        {
            string response = string.Empty;

            using (HttpWebResponse resp = (HttpWebResponse)(await req.GetResponseAsyncExt().ConfigureAwait(false)))
            {
                if (resp == null)
                {
                    if (req != null)
                    {
                        req.Abort();
                    }
                }
                else
                {
                    if (resp.StatusCode == HttpStatusCode.OK)
                    {
                        using (StreamReader sr = new StreamReader(resp.GetResponseStream()))
                        {
                            try
                            {
                                response = await sr.ReadToEndAsync().ConfigureAwait(false);
                            }
                            catch (IOException)
                            {
                                response = string.Empty;
                            }
                        }
                    }
                    else
                    {
                        string errorMessage = string.Format("Getting website {0} failed with code: {1}, desc: {2}", req.RequestUri.AbsoluteUri, resp.StatusCode.ToString(), resp.StatusDescription);

                        await Utils.LogMessageAsync(errorMessage).ConfigureAwait(false);
                    }
                }
            }

            return response;
        }

        public static string DownloadWebsiteAsString(HttpWebRequest req)
        {
            string response = string.Empty;

            using (HttpWebResponse resp = (HttpWebResponse)req.GetResponseExt())
            {
                if (resp == null)
                {
                    if (req != null)
                    {
                        req.Abort();
                    }
                }
                else
                {
                    if (resp.StatusCode == HttpStatusCode.OK)
                    {
                        using (StreamReader sr = new StreamReader(resp.GetResponseStream()))
                        {
                            try
                            {
                                response = sr.ReadToEnd();
                            }
                            catch (IOException)
                            {
                                response = string.Empty;
                            }
                        }
                    }
                    else
                    {
                        string errorMessage = string.Format("Getting website {0} failed with code {1}", req.RequestUri.AbsoluteUri, resp.StatusCode.ToString());

                        Utils.LogMessage(errorMessage);
                    }
                }
            }

            return response;
        }

        public void Abort_CreateRequestThenAbort_Success(Uri remoteServer)
        {
            _savedHttpWebRequest = HttpWebRequest.CreateHttp(remoteServer);

            _savedHttpWebRequest.Abort();
        }