C# WebRequest.GetResponseAsync方法代码示例

        private async Task<JObject> _ReadResponseAsync(WebRequest request, string inputAddress)
        {
            HttpWebResponse response;
            try
            {
                response = (HttpWebResponse)(await request.GetResponseAsync().ConfigureAwait(false));
            }
            catch (WebException we)
            {
                response = (HttpWebResponse)we.Response;
            }

            JObject responseJson;
            using (var responseStream = new StreamReader(response.GetResponseStream()))
            {
                var responseStr = await responseStream.ReadToEndAsync().ConfigureAwait(false);
                responseJson = JObject.Parse(responseStr); // I'm fine throwing a parse error here.
            }

            if (response.StatusCode == HttpStatusCode.OK) // Could probably relax this to "non-failing" codes.
            {
                return responseJson;
            }
            else
            {
                throw new Exception(string.Format("Failed call: {0} failed to OCR - code {1} - details\n{2}", 
                    inputAddress, response.StatusCode, responseJson.ToString(Newtonsoft.Json.Formatting.Indented)));
            }
        }

		private static async Task<WebResponse> GetWebResponse(WebRequest request)
		{
			WebResponse response = null;
			try
			{
				response = await request.GetResponseAsync().ConfigureAwait(false);
			}
			catch(WebException ex)
			{
				// "WebException status: {0}", ex.Status);

				// Even if the request "failed" we need to continue reading the response from the router
				response = ex.Response as HttpWebResponse;

				if(response == null)
					throw;

				var stream = response.GetResponseStream();
				var bytesToRead = (int)response.ContentLength;
				var buffer = stream.ReadBytes(bytesToRead);
				response.Dispose();
				throw new RestApiException(Encoding.UTF8.GetString(buffer, 0, buffer.Length - 2), ex);
			}
			return response;
		}

        private async Task Transact(WebRequest wreq, Action<object> receive)
        {

            // read response
            object rdata = null;
            using (var wres = await wreq.GetResponseAsync())
            using (var sres = wres.GetResponseStream())
            {
                var ms = new MemoryStream();
                await sres.CopyToAsync(ms);

                ms.Position = 0;
                using (var sreader = new StreamReader(ms))
                {
                    var sdata = sreader.ReadToEnd();

                    if (null != Parse)
                    {
                        rdata = Parse(sdata);
                    }
                    else
                    {
                        rdata = sdata;
                    }
                }
            }

            Dispatcher.Invoke(() => receive(rdata));
        }

 public  async Task<string> InfoAnswerAsync(WebRequest request)
 {
     using (var response = await request.GetResponseAsync())
     {
         using (var stream = response.GetResponseStream())
             if (stream != null)
                 using (var reader = new StreamReader(stream))
                 {
                     return await reader.ReadToEndAsync();
                 }
     }
     return "";
 }

 protected async Task<Tuple<HttpStatusCode, string, Stream>> GetResponseTask(WebRequest request, CancellationToken cancellationToken)
 {
     var response = await request.GetResponseAsync(cancellationToken);
     var location = response.Headers[LocationHeader];
     var statusCode = (response as HttpWebResponse).Maybe(_ => _.StatusCode);
     if (_helper.IsGZipped((HttpWebResponse)response))
     {
         var entityCompressed = _helper.ExtractCompressedEntity(response);
         return new Tuple<HttpStatusCode, string, Stream>(statusCode, location, entityCompressed);
     }
     var entityNormal = response.GetResponseStream();
     return new Tuple<HttpStatusCode, string, Stream>(statusCode, location, entityNormal);
 }

        public async Task<string> GetRequestAsync(string url)
        {
            request = WebRequest.Create(url);
            request.Method = "GET";
            WebResponse response = await request.GetResponseAsync();
            // Get the stream containing all content returned by the requested server.
            Stream dataStream = response.GetResponseStream();

            // Open the stream using a StreamReader for easy access.
            StreamReader reader = new StreamReader(dataStream);

            // Read the content fully up to the end.
            return reader.ReadToEnd();
        }

		private ServiceResponse SendRequestAsyncAwait(WebRequest request)
		{
			Func<Task<ServiceResponse>> getResponse = async () =>
			{
				var response = await request.GetResponseAsync();
				var reader = new StreamReader(response.GetResponseStream());
				var message = reader.ReadToEnd();
				return new ServiceResponse() { IsSuccess = true, Message = message };
			};

			return _retryPolicy.ExecuteAction<ServiceResponse>(() =>
			{
				try
				{
					return getResponse().Result;
				}
				catch (AggregateException ae)
				{
					throw MappedAggregateException(ae);
				}

			});
		}

        private async Task SendRequestAsync(WebRequest request)
        {
            using (Stream requestStream = await request.GetRequestStreamAsync().ConfigureAwait(false))
            {
                await requestStream.WriteAsync(this.Content, 0, this.Content.Length).ConfigureAwait(false);
            }

            using (WebResponse response = await request.GetResponseAsync().ConfigureAwait(false))
            {
            }
        }

 public async Task<WebResponse> GetWebResponseAsync(WebRequest webRequest)
 {
     return await webRequest.GetResponseAsync();
 }

		private static async Task<string> ExecuteWebRequestAsync(WebRequest request)
		{
			ExceptionDispatchInfo capturedException;

			try
			{
				using (var response = await request.GetResponseAsync())
				{
					return await ReadStreamAsync(response.GetResponseStream());
				}
			}
			catch (WebException ex)
			{
				if (ex.Response == null)
				{
					throw;
				}
				capturedException = ExceptionDispatchInfo.Capture(ex);
			}

			var wex = (WebException)capturedException.SourceException;
			var statusCode = ((HttpWebResponse)wex.Response).StatusCode;

			using (var stream = wex.Response.GetResponseStream())
			{
				var result = await ReadStreamAsync(stream);
				var stripeError = request.RequestUri.ToString().Contains("oauth")
					                  ? Mapper<StripeError>.MapFromJson(result)
					                  : Mapper<StripeError>.MapFromJson(result, "error");

				throw new StripeException(statusCode, stripeError, stripeError.Message);
			}
		}

        private static async Task<string> ExecuteWebRequestAsync(WebRequest webRequest)
        {
            try
            {
                using (var response = await webRequest.GetResponseAsync())
                {
                    return await ReadStreamAsync(response.GetResponseStream());
                }
            }
            catch (WebException webException)
            {
                if (webException.Response != null)
                {
                    var statusCode = ((HttpWebResponse)webException.Response).StatusCode;

                    var stripeError = new StripeError();

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

                    throw new StripeException(statusCode, stripeError, stripeError.Message);
                }

                throw;
            }
        }

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

 private static async Task DownloadAndSavePhoto(string targetFileName, WebRequest request, byte[] buffer)
 {
     using (var target = new FileStream(targetFileName, FileMode.Create, FileAccess.Write))
     {
         using (WebResponse response = await request.GetResponseAsync())
         {
             using (Stream stream = response.GetResponseStream())
             {
                 int read;
                 while ((read = await stream.ReadAsync(buffer, 0, buffer.Length)) > 0)
                 {
                     await target.WriteAsync(buffer, 0, read);
                 }
             }
         }
     }
 }

		private async Task<RavenJToken> ReadJsonInternalAsync(WebRequest responseTask)
		{
			WebResponse response;
			try
			{
                response = await responseTask.GetResponseAsync().ConfigureAwait(false);
				sp.Stop();
			}
			catch (WebException e)
			{
				sp.Stop();
				var result = HandleErrors(e);
				if (result == null)
					throw;
				return result;
			}

			ResponseHeaders = new NameValueCollection(response.Headers);
			ResponseStatusCode = ((HttpWebResponse)response).StatusCode;

			HandleReplicationStatusChanges(ResponseHeaders, primaryUrl, operationUrl);

			using (response)
			using (var responseStream = response.GetResponseStreamWithHttpDecompression())
			{
                var data = await RavenJToken.TryLoadAsync(responseStream).ConfigureAwait(false);

				if (Method == "GET" && ShouldCacheRequest)
				{
					factory.CacheResponse(Url, data, ResponseHeaders);
				}

				factory.InvokeLogRequest(owner, () => new RequestResultArgs
				{
					DurationMilliseconds = CalculateDuration(),
					Method = webRequest.Method,
					HttpResult = (int) ResponseStatusCode,
					Status = RequestStatus.SentToServer,
					Result = (data ?? "").ToString(),
					Url = webRequest.RequestUri.PathAndQuery,
					PostedData = postedData
				});

				return data;
			}
		}

        private static async Task<WebResponse> GetWebResponse(WebRequest request)
        {
            WebResponse response;
            try
            {
                response = await request.GetResponseAsync().ConfigureAwait(false);
            }
            catch (WebException ex)
            {
                NatDiscoverer.TraceSource.TraceEvent(TraceEventType.Verbose, 0, "WebException status: {0}", ex.Status);

                // Even if the request "failed" we need to continue reading the response from the router
                response = ex.Response as HttpWebResponse;

                if (response == null)
                    throw;
            }
            return response;
        }