C# WebRequest.GetResponse方法代码示例

        private void Listen(object sender, DoWorkEventArgs e)
        {
            string url = @"http://" + _ipAddr.ToString() + "/PSIA/Metadata/stream?AreaControlEvents=true";
            credentialCache.Add(new System.Uri(url), "Basic", _credentials);

            _req = WebRequest.Create(url);
            _req.Credentials = credentialCache;
            _req.PreAuthenticate = true;

            HttpWebResponse response = (HttpWebResponse)_req.GetResponse();
            Stream responseStream = response.GetResponseStream();
            XmlTextReader reader = new XmlTextReader(responseStream);

            while (true)
            {
                reader.MoveToContent();
                string contents = reader.ReadOuterXml();

                if (OnEventRaised != null)
                {
                    BackgroundWorker worker = new BackgroundWorker();
                    worker.DoWork += new DoWorkEventHandler(worker_DoWork);
                    worker.RunWorkerAsync(contents);
                }

                reader.ResetState();
            }
        }

        public static ResponseInfo GetResponseAndDuration(WebRequest request)
        {
            try
            {
                var st = new Stopwatch();
                st.Start();

                using (var response = request.GetResponse())
                {
                    st.Stop();

                    var time = st.ElapsedMilliseconds;
                    var body = GetResponseBody(response);

                    var status = ((HttpWebResponse) response).StatusCode;
                    if (status != HttpStatusCode.OK)
                    {
                        throw new Exception("Bad respnose. Status: " + status);
                    }

                    var responseInfo = new ResponseInfo(time, GetQTimeFrom(body), body);

                    return responseInfo;
                }
            }
            catch (WebException ex)
            {
                Console.WriteLine("Error: " +ex.Message);
                throw;
            }
        }

        public static string GetResponse(WebRequest request)
        {
            Func<WebResponse, string> getResponseContent = wr =>
            {
                if (wr == null)
                    return string.Empty;

                using (var reader = new StreamReader(wr.GetResponseStream(), Encoding.UTF8))
                {
                    return reader.ReadToEnd();
                }
            };

            try
            {
                using (var response = (HttpWebResponse)request.GetResponse())
                {
                    return getResponseContent(response);
                }
            }
            catch (WebException ex)
            {
                return getResponseContent(ex.Response);
            }
        }

        private static string ExecuteWebRequest(WebRequest webRequest)
        {
            try
            {
                using (var response = webRequest.GetResponse())
                {
                    return ReadStream(response.GetResponseStream());
                }
            }
            catch (WebException webException)
            {
                return ReadStream(webException.Response.GetResponseStream());
            }
            /*
                if (webException.Response != null)
                {
                    var statusCode = ((HttpWebResponse)webException.Response).StatusCode;

                    var pinError = new PinError();

                    pinError = Mapper<PinError>.MapFromJson(ReadStream(webException.Response.GetResponseStream()));

                    throw new PinException(statusCode, pinError, webException.Message);
                }

                throw;
            }
             * */
        }

        public void AuthenticatePingTest()
        {
            var xml = new XElement("root",
                          new XElement("auth", "token"),
                          new XElement("version", 1),
                          new XElement("update", "1900-01-01"),
                          new XElement("add", "1900-01-02"),
                          new XElement("clean", "1900-01-03"),
                          new XElement("songs", "1234"),
                          new XElement("albums", "123"),
                          new XElement("artists", "12"),
                          new XElement("tags", "10"),
                          new XElement("videos", "1"));
            var stream = new System.IO.MemoryStream();
            xml.Save(stream);
            stream.Position = 0;
            var mockResponse = Substitute.For<WebResponse>();
            mockResponse.GetResponseStream().Returns(stream);
            _mockRequest = Substitute.For<WebRequest>();
            _mockRequest.GetResponse().Returns(mockResponse);
            var password = "password";
            var user = "test";
            var server = "authenticate://test";

            var res = new Authenticate(server, user, password);
            _uri = null;
            res.Ping();
            Assert.That(_uri, Is.Not.Null);
            Assert.That(_uri, Is.EqualTo(string.Format("{0}/server/xml.server.php?action=ping&auth={1}", server, "token")));
        }

        public static string SendHttpPost(WebRequest request, YahooMessengerAuthentication authentication, string content)
        {
            request.Method = "POST";
            byte[] byteArray = Encoding.UTF8.GetBytes(content);
            request.ContentLength = byteArray.Length;
            var dataStream = request.GetRequestStream();
            // Write the data to the request stream.
            dataStream.Write(byteArray, 0, byteArray.Length);
            // Close the Stream object.
            dataStream.Close();
            using(var response = (HttpWebResponse) request.GetResponse())
            {
                if (response == null) throw new NullReferenceException();

                var respCode = response.StatusCode;

                if (respCode != HttpStatusCode.OK)
                    throw new HttpException(HttpException.HTTP_OK_NOT_RECEIVED, respCode.ToString());

                dataStream = response.GetResponseStream();
                if (dataStream == null) throw new NullReferenceException();
                var reader = new StreamReader(dataStream);

                var responseFromServer = new StringBuilder("");
                responseFromServer.Append(reader.ReadToEnd());
                reader.Close();
                dataStream.Close();
                response.Close();

                return responseFromServer.ToString();
            }
        }

 // Returns the status code received as response from DataManagementSystem.
 // Returns 0, if no status code can be extracted.
 private static int handleResponse(WebRequest request)
 {
     try
     {
         using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
         {
             return ((int)response.StatusCode);
         }
     }
     catch (WebException except)
     {
         if (except.Status == WebExceptionStatus.ProtocolError)
         {
             var exceptResponse = except.Response as HttpWebResponse;
             if (exceptResponse != null)
             {
                 return ((int)exceptResponse.StatusCode);
             }
             else
             {
                 return 0;
             }
         }
         else
         {
             return 0;
         }
     }
 }

        private static string ExecuteWebRequest(WebRequest webRequest)
        {
            try
            {
                using (var response = webRequest.GetResponse())
                {
                    return ReadStream(response.GetResponseStream());
                }
            }
            catch (WebException webException)
            {
                if (webException.Response != null)
                {
                    var statusCode = ((HttpWebResponse)webException.Response).StatusCode;

                    var wePayError = new WePayError();

                    wePayError = WepayMapping<WePayError>.MapFromJson(ReadStream(webException.Response.GetResponseStream()));

                    throw new WePayException(statusCode, wePayError, wePayError.ErrorDescription);
                }
                else
                {
                    throw webException;
                }
            }
        }

        //private string token;
        public string GetResponse(WebRequest request,string token)
        {
            string result = "";

            try
            {
                if (token != String.Empty) request.Headers.Add("Authorization", "Bearer " + token);
                request.Method = "GET";
                request.ContentType = "application/json; charset=utf-8";
                WebResponse resp = request.GetResponse();

                using (System.IO.Stream stream = resp.GetResponseStream())
                {
                    using (StreamReader sr = new StreamReader(stream))
                    {
                        result = sr.ReadToEnd();
                    }
                }
            }
            catch (Exception e)
            {
                return e.Message;
            }

            return result;
        }

        /// <summary>
        /// Given a web request - reads the response and returns it all
        /// as a string.
        /// </summary>
        /// <param name="request">A .NET WebRequest object.</param>
        /// <returns>The response as a string.</returns>
        public string ReadResponseAsString(WebRequest request)
        {
            try
            {
                request.Timeout = 30000;
                using (WebResponse response = request.GetResponse())
                using (StreamReader reader = new StreamReader(response.GetResponseStream()))
                {
                    return reader.ReadToEnd();
                }
            }
            catch (WebException x)
            {
                // This error still has content in the body and was not really
                // a connection failure, but is a failure in what we sent to the
                // service.
                if (x.Status == WebExceptionStatus.ProtocolError)
                {
                    using (StreamReader reader = new StreamReader(x.Response.GetResponseStream()))
                    {
                        string error = reader.ReadToEnd();
                        return error;
                    }
                }

                throw;
            }
        }

 private void strtBtn_Click(object sender, EventArgs e)
 {
     requestPicStreet = WebRequest.Create("http://maps.googleapis.com/maps/api/streetview?location=" + address + "&heading=" + heading.ToString() + "&zoom=12&size=453x267&sensor=false");
     repsonsePicStreet = requestPicStreet.GetResponse();
     mapStreet = Image.FromStream(repsonsePicStreet.GetResponseStream());
     pictureBox2.Image = mapStreet;
 }

 private void staticBtn_Click(object sender, EventArgs e)
 {
     requestPicStatic = WebRequest.Create("http://maps.googleapis.com/maps/api/staticmap?center=" + address + "&zoom=" + zoom + "&size=353x267&sensor=false");
     repsonsePicStatic = requestPicStatic.GetResponse();
     mapStatic = Image.FromStream(repsonsePicStatic.GetResponseStream());
     pictureBox1.Image = mapStatic;
 }

 public static void GetResponse(WebRequest request, Action<Stream> action)
 {
     using (WebResponse response = request.GetResponse())
     {
         action(response.GetResponseStream());
     }
 }

 private static string FetchResponseString(WebRequest request)
 {
     using (var response = request.GetResponse())
         using (var stream = response.GetResponseStream())
             using (var reader = new StreamReader(stream, Encoding.UTF8))
                 return reader.ReadToEnd();
 }

        private static string ExecuteWebRequest(WebRequest webRequest)
        {
            try
            {
                using (var response = webRequest.GetResponse())
                {
                    return ReadStream(response.GetResponseStream());
                }
            }
            catch (WebException webException)
            {
                if (webException.Response != null)
                {
                    var statusCode = ((HttpWebResponse)webException.Response).StatusCode;

                    var romitError = new RomitError();

                    if (webRequest.RequestUri.ToString().Contains("oauth"))
                        romitError = Mapper<RomitError>.MapFromJson(ReadStream(webException.Response.GetResponseStream()));
                    else
                        romitError = Mapper<RomitError>.MapFromJson(ReadStream(webException.Response.GetResponseStream()), "error");

                    throw new RomitException(statusCode, romitError, romitError.Message);
                }

                throw;
            }
        }