C# HttpWebResponse.GetResponseStream方法代码示例

        public string Create(string url)
        {
            try
            {
                // setup web request to tinyurl
                request = (HttpWebRequest)WebRequest.Create(string.Format(TINYURL_ADDRESS_TEMPLATE, url));
                request.Timeout = REQUEST_TIMEOUT;
                request.UserAgent = USER_AGENT;

                // get response
                response = (HttpWebResponse)request.GetResponse();

                // prase response stream to string
                Stream stream = response.GetResponseStream();
                StreamReader reader = new StreamReader(stream, Encoding.GetEncoding(ENCODING_NAME));

                // convert the buffer into string and store in content
                StringBuilder sb = new StringBuilder();
                while (reader.Peek() >= 0)
                {
                    sb.Append(reader.ReadLine());
                }
                return sb.ToString();
            }
            catch (Exception)
            {
                return null;
            }
        }

 private static string GetResponseBody(HttpWebResponse response)
 {
     string responseBody = string.Empty;
     if (response.ContentEncoding.ToLower().Contains("gzip"))
     {
         using (GZipStream stream = new GZipStream(response.GetResponseStream(), CompressionMode.Decompress))
         {
             using (StreamReader reader = new StreamReader(stream))
             {
                 responseBody = reader.ReadToEnd();
             }
         }
     }
     else if (response.ContentEncoding.ToLower().Contains("deflate"))
     {
         using (DeflateStream stream = new DeflateStream(response.GetResponseStream(), CompressionMode.Decompress))
         {
             using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
             {
                 responseBody = reader.ReadToEnd();
             }
         }
     }
     else
     {
         using (Stream stream = response.GetResponseStream())
         {
             using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
             {
                 responseBody = reader.ReadToEnd();
             }
         }
     }
     return responseBody;
 }

        /// <summary>
        /// Relays an HttpWebResponse as verbatim as possible.
        /// </summary>
        /// <param name="responseToRelay">The HTTP response to relay.</param>
        public HttpWebResponseResult(HttpWebResponse responseToRelay)
        {
            if (responseToRelay == null) {
                throw new ArgumentNullException("response");
            }

            _response = responseToRelay;

            Stream contentStream;
            if (responseToRelay.ContentEncoding.Contains("gzip")) {
                contentStream = new GZipStream(responseToRelay.GetResponseStream(), CompressionMode.Decompress);
            } else if (responseToRelay.ContentEncoding.Contains("deflate")) {
                contentStream = new DeflateStream(responseToRelay.GetResponseStream(), CompressionMode.Decompress);
            } else {
                contentStream = responseToRelay.GetResponseStream();
            }

            if (string.IsNullOrEmpty(responseToRelay.CharacterSet)) {
                // File result
                _innerResult = new FileStreamResult(contentStream, responseToRelay.ContentType);
            } else {
                // Text result
                var contentResult = new ContentResult();
                contentResult = new ContentResult();
                contentResult.Content = new StreamReader(contentStream).ReadToEnd();
                _innerResult = contentResult;
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpWebRequestCallbackState"/> class.
        /// </summary>
        /// <param name="response">The response.</param>
        /// <param name="state">The state.</param>
        public HttpWebRequestCallbackState(HttpWebResponse response, object state)
        {
            StatusCode = response.StatusCode;
            Headers = response.Headers;
            ContentType = response.ContentType.Split(new[] { ';' })[0];
            ContentLength = response.ContentLength;

            var contentEncoding = response.Headers[HttpResponseHeader.ContentEncoding] ?? string.Empty;
            if (contentEncoding.Contains("gzip"))
            {
                ResponseStream = new GZipStream(response.GetResponseStream(), CompressionMode.Decompress);
            }
            else if (contentEncoding.Contains("deflate"))
            {
                ResponseStream = new DeflateStream(response.GetResponseStream(), CompressionMode.Decompress);
            }
            else
            {
                ResponseStream = response.GetResponseStream();
            }

            Log.Debug(m => m("HttpWebRequestCallbackState Ctor statusCode:{0}, contentLength:{1}, contentType:{2}", StatusCode, ContentLength, ContentType));

            State = state;
        }

 public static string GetHttpWebResponseData(HttpWebResponse response)
 {
     string data = string.Empty;
     if (response != null)
     {
         StreamReader incomingStreamReader = new StreamReader(response.GetResponseStream());
         data = incomingStreamReader.ReadToEnd();
         incomingStreamReader.Close();
         response.GetResponseStream().Close();
     }
     return data;
 }

    public override async Task<string> ReadResponseStream(HttpWebResponse response) {

      string result = "";
      Stream stream = (string.Equals(response.Headers[HttpRequestHeader.ContentEncoding], "gzip", StringComparison.OrdinalIgnoreCase)) 
                        ? await Task.Run(() => (response.GetResponseStream().Decompress()) ) 
                        : response.GetResponseStream();
      
      using (var reader = new StreamReader(stream)) {
        result = await reader.ReadToEndAsync();
      }

      return result;
    }

    public override async Task<string> ReadResponseStream(HttpWebResponse response) {
      string result;

      using (var gzipStream =
        (string.Equals(response.Headers["Content-Encoding"], "gzip", StringComparison.CurrentCultureIgnoreCase))
          ? new GZipStream(response.GetResponseStream(), CompressionMode.Decompress)
          : response.GetResponseStream()) {

        using (var sr = new StreamReader(gzipStream)) {
          result = await sr.ReadToEndAsync();
        }
      }

      return result;
    }

 public virtual string GetContent(HttpWebResponse webResp, Encoding encoding)
 {
     string content = null;
       var countTry = 3;
       var repeat = true;
       while (repeat && countTry > 0)
     try
     {
       var responseStream = webResp.GetResponseStream();
       responseStream.ReadTimeout = 8000;
       using (var sr = new StreamReader(responseStream, encoding))
       {
     content = sr.ReadToEnd();
     repeat = false;
       }
     }
     catch (WebException exWeb)
     {
       countTry--;
       File.AppendAllText("log.txt", exWeb.Message + Environment.NewLine);
       File.AppendAllText("log.txt", "++" + Environment.NewLine);
       File.AppendAllText("log.txt", exWeb.Status.ToString() + Environment.NewLine);
       File.AppendAllText("log.txt", "++" + Environment.NewLine);
       File.AppendAllText("log.txt", "GetContent" + Environment.NewLine);
       File.AppendAllText("log.txt", "------" + Environment.NewLine);
       var webReq = GetHttpWebReq(url);
       webResp = GetHttpWebResp(webReq);
     }
       return content;
 }

        private PageInfo ExtractFromResponse(HttpWebResponse response)
        {
            var info = new PageInfo();

            using (var responseStream = response.GetResponseStream())
            {
                var htmlDocument = new HtmlDocument();
                htmlDocument.Load(responseStream);
                htmlDocument.OptionFixNestedTags = true;

                var quote = htmlDocument.DocumentNode
                                        .SelectSingleNode("//body")
                                        .SelectNodes("//p").Where(a => a.Attributes.Any(x => x.Name == "class" && x.Value == "qt"))
                                        .SingleOrDefault();

                var title = htmlDocument.DocumentNode
                                        .SelectSingleNode("//title");

                //Quote might not be found, bash.org doesn't have a 404 page
                if (quote == null || title == null)
                {
                    return null;
                }

                //Strip out any HTML that isn't defined in the WhiteList
                SanitizeHtml(quote);

                info.Quote = quote.InnerHtml;
                info.PageURL = response.ResponseUri.AbsoluteUri;
                info.QuoteNumber = title.InnerHtml;
            }

            return info;
        }

 public HttpResponse(HttpWebRequest con)
 {
     this.con = con;
     this.rsp = (HttpWebResponse)con.GetResponse();
     this.stream = rsp.GetResponseStream();
     this.reader = new StreamReader(stream, Encoding.UTF8);
 }

        public void Handle(HttpWebResponse proxyResponse, HttpResponse contextResponse)
        {
            //add cookie
            //foreach (var cookieName in proxyResponse.Cookies)
            //{
            //    var proxyCookie = proxyResponse.Cookies[cookieName.ToString()];

            //    if(proxyCookie.Name.StartsWith("Proxy_"))
            //        contextResponse.SetCookie(new HttpCookie(proxyCookie.Name, proxyCookie.Value));
            //}
            //contextResponse.SetCookie(new HttpCookie("proxyHost", proxyResponse.ResponseUri.Host));

            //add Content-Type
            contextResponse.ContentType = proxyResponse.ContentType;
            //contextResponse
            //add Content-Length
            //Content-Encoding
            //contextResponse.Headers["Content-Encoding"] = proxyResponse.ContentEncoding;

            //copy stream
            using (Stream responseStream = proxyResponse.GetResponseStream())
            {
                Stream rwStream = RewriteStream(responseStream,proxyResponse.ResponseUri, proxyResponse.ContentType);
                //contextResponse.Headers["Content-Length"] = rwStream.Length.ToString();
                rwStream.CopyToStream(contextResponse.OutputStream);
                rwStream.Close();
            }
        }

 public virtual string ReadResponse(HttpWebResponse response)
 {
     using (StreamReader reader = new StreamReader(response.GetResponseStream()))
     {
         return reader.ReadToEnd();
     }
 }

        public static WebResponse ExtractResponse( HttpWebResponse response, string filename )
        {
            WebResponse webResponse = null;
            Stream streamResponse = response.GetResponseStream();

            #if !SILVERLIGHT
            if ( response.ContentEncoding.ToLower().Contains( "deflate" ) )
                streamResponse = new DeflateStream( streamResponse, CompressionMode.Decompress );
            else if ( response.ContentEncoding.ToLower().Contains( "gzip" ) )
                streamResponse = new GZipStream( streamResponse, CompressionMode.Decompress );
            #endif

            StreamReader streamRead = null;
            try
            {
                webResponse = new WebResponse();
                webResponse.ResponseBytes = NetworkUtils.StreamToByteArray( streamResponse );
                webResponse.ResponseString = NetworkUtils.ByteArrayToStr( webResponse.ResponseBytes );

                if ( !string.IsNullOrEmpty( filename ) )
                    MXDevice.File.Save(filename, webResponse.ResponseBytes);
            }
            finally
            {
                // Close the stream object
                if ( streamResponse != null )
                    streamResponse.Close();

                if ( streamRead != null )
                    streamRead.Close();
            }

            return webResponse;
        }

        public static bool DownloadFile(Uri url, string destFileName, HttpWebResponse response, CancellationToken? token = null, Action<int> indicateProgress = null)
        {
            using (new ProfileSection("Download file", typeof(WebRequestHelper)))
              {
            ProfileSection.Argument("url", url);
            ProfileSection.Argument("destFileName", destFileName);
            ProfileSection.Argument("response", response);
            ProfileSection.Argument("token", token);
            ProfileSection.Argument("indicateProgress", indicateProgress);

            using (var responseStream = response.GetResponseStream())
            {
              try
              {
            Assert.ArgumentNotNull(responseStream, "responseStream");
            responseStream.ReadTimeout = Settings.CoreWebDownloadTimeoutMinutes.Value * Minute;
            DownloadFile(destFileName, responseStream, token, indicateProgress);

            ProfileSection.Result("Done");
            return true;
              }
              catch (OperationCanceledException)
              {
            FileSystem.FileSystem.Local.File.Delete(destFileName);

            ProfileSection.Result("Canceled");
            return false;
              }
              catch (Exception ex)
              {
            throw new InvalidOperationException("Downloading failed with exception", ex);
              }
            }
              }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="MadMimi.Result"/> class.
 /// </summary>
 /// <param name='response'>
 /// An HttpWebResponse which contains the result.
 /// </param>
 public Result(HttpWebResponse response)
 {
     statusCode = response.StatusCode;
     using (StreamReader reader = new StreamReader (response.GetResponseStream ())) {
         body = reader.ReadToEnd ();
     }
 }