C# WebRequest.GetRequestStreamAsync方法代码示例

        public void SetUp()
        {
            var uri = OAuthRequestHandler.OAuthRequestUri;
            var factory = new TestWebRequestFactory();
            factory.RegisterResultForUri(uri.AbsoluteUri, "null");
            _request = factory.Create(uri);

            _stream = new MemoryStream();
            _request.EndGetRequestStream(Arg.Any<IAsyncResult>()).Returns(c => _stream);
            _request.GetRequestStreamAsync().Returns(async c => (Stream)_stream);

            _handler = new OAuthRequestHandler(new ApiConfiguration("<<clientid>>", "<<clientsecret>>", "http://desktop/"));

        }

		async Task<byte[]> UploadValuesTaskAsyncCore (WebRequest request, NameValueCollection data,
		                                              CancellationToken token)
		{
			token.ThrowIfCancellationRequested ();
			string cType = Headers ["Content-Type"];
			if (cType != null && String.Compare (cType, urlEncodedCType, true) != 0)
				throw new WebException ("Content-Type header cannot be changed from its default " +
							"value for this request.");

			WebResponse response = null;

			Headers ["Content-Type"] = urlEncodedCType;
			try {
				MemoryStream tmpStream = new MemoryStream ();
				foreach (string key in data) {
					byte [] bytes = Encoding.UTF8.GetBytes (key);
					UrlEncodeAndWrite (tmpStream, bytes);
					tmpStream.WriteByte ((byte) '=');
					bytes = Encoding.UTF8.GetBytes (data [key]);
					UrlEncodeAndWrite (tmpStream, bytes);
					tmpStream.WriteByte ((byte) '&');
				}

				token.ThrowIfCancellationRequested ();
				
				int length = (int) tmpStream.Length;
				if (length > 0)
					tmpStream.SetLength (--length); // remove trailing '&'
				
				byte [] buf = tmpStream.GetBuffer ();
				request.ContentLength = length;
				using (Stream rqStream = await request.GetRequestStreamAsync ()) {
					await rqStream.WriteAsync (buf, 0, length, token);
				}
				tmpStream.Close ();

				response = await GetWebResponseTaskAsync (request, token);
				return await ReadAllTaskAsync (request, response, token);
			} finally {
				if (response != null)
					response.Close ();
			}
		}

		async Task<byte[]> UploadDataTaskAsyncCore (WebRequest request, byte[] data, CancellationToken token)
		{
			token.ThrowIfCancellationRequested ();

			int contentLength = data.Length;
			request.ContentLength = contentLength;
			using (Stream stream = await request.GetRequestStreamAsync ()) {
				token.ThrowIfCancellationRequested ();
				await stream.WriteAsync (data, 0, contentLength, token);
				token.ThrowIfCancellationRequested ();
			}

			WebResponse response = null;

			try {
				response = await GetWebResponseTaskAsync (request, token);
				return await ReadAllTaskAsync (request, response, token);
			} finally {
				if (response != null)
					response.Close ();
			}
		}

		async Task<byte[]> UploadFileTaskAsyncCore (WebRequest request, string method,
		                                            string fileName, CancellationToken token)
		{
			token.ThrowIfCancellationRequested ();

			string fileCType = Headers ["Content-Type"];
			if (fileCType != null) {
				string lower = fileCType.ToLower ();
				if (lower.StartsWith ("multipart/"))
					throw new WebException ("Content-Type cannot be set to a multipart" +
								" type for this request.");
			} else {
				fileCType = "application/octet-stream";
			}

			bool needs_boundary = (method != "PUT"); // only verified case so far
			string boundary = null;
			if (needs_boundary) {
				boundary = "------------" + DateTime.Now.Ticks.ToString ("x");
				Headers ["Content-Type"] = String.Format ("multipart/form-data; boundary={0}", boundary);
			}
			Stream reqStream = null;
			Stream fStream = null;
			WebResponse response = null;

			fileName = Path.GetFullPath (fileName);

			try {
				fStream = File.OpenRead (fileName);
				token.ThrowIfCancellationRequested ();
				reqStream = await request.GetRequestStreamAsync ();
				token.ThrowIfCancellationRequested ();
				byte [] bytes_boundary = null;
				if (needs_boundary) {
					bytes_boundary = Encoding.ASCII.GetBytes (boundary);
					using (MemoryStream ms = new MemoryStream ()) {
						ms.WriteByte ((byte) '-');
						ms.WriteByte ((byte) '-');
						ms.Write (bytes_boundary, 0, bytes_boundary.Length);
						ms.WriteByte ((byte) '\r');
						ms.WriteByte ((byte) '\n');
						string partHeaders = String.Format (
							"Content-Disposition: form-data; " +
							"name=\"file\"; filename=\"{0}\"\r\n" +
							"Content-Type: {1}\r\n\r\n",
							Path.GetFileName (fileName), fileCType);
						byte [] partHeadersBytes = Encoding.UTF8.GetBytes (partHeaders);
						ms.Write (partHeadersBytes, 0, partHeadersBytes.Length);
						await ms.CopyToAsync (reqStream, (int)ms.Position, token);
					}
				}
				int nread;
				long bytes_sent = 0;
				long file_size = -1;
				long step = 16384; // every 16kB
				if (fStream.CanSeek) {
					file_size = fStream.Length;
					step = file_size / 100;
				}
				var upload_args = new UploadProgressChangedEventArgs (0, 0, bytes_sent, file_size, 0, null);
				OnUploadProgressChanged (upload_args);
				byte [] buffer = new byte [4096];
				long sum = 0;
				token.ThrowIfCancellationRequested ();
				while ((nread = await fStream.ReadAsync (buffer, 0, 4096, token)) > 0) {
					token.ThrowIfCancellationRequested ();
					await reqStream.WriteAsync (buffer, 0, nread, token);
					bytes_sent += nread;
					sum += nread;
					if (sum >= step || nread < 4096) {
						int percent = 0;
						if (file_size > 0)
							percent = (int) (bytes_sent * 100 / file_size);
						upload_args = new UploadProgressChangedEventArgs (0, 0, bytes_sent, file_size, percent, null);
						OnUploadProgressChanged (upload_args);
						sum = 0;
					}
				}

				if (needs_boundary) {
					using (MemoryStream ms = new MemoryStream ()) {
						ms.WriteByte ((byte) '\r');
						ms.WriteByte ((byte) '\n');
						ms.WriteByte ((byte) '-');
						ms.WriteByte ((byte) '-');
						ms.Write (bytes_boundary, 0, bytes_boundary.Length);
						ms.WriteByte ((byte) '-');
						ms.WriteByte ((byte) '-');
						ms.WriteByte ((byte) '\r');
						ms.WriteByte ((byte) '\n');
						await ms.CopyToAsync (reqStream, (int)ms.Position, token);
					}
				}
				reqStream.Close ();
				reqStream = null;

				response = await GetWebResponseTaskAsync (request, token);
				return await ReadAllTaskAsync (request, response, token);
			} finally {
				if (fStream != null)
//.........这里部分代码省略.........

        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))
            {
            }
        }

		async Task<byte[]> UploadValuesTaskAsyncCore (WebRequest request, NameValueCollection data,
		                                              CancellationToken token)
		{
			token.ThrowIfCancellationRequested ();

			WebResponse response = null;
			try {
				MemoryStream tmpStream = new MemoryStream ();
				foreach (string key in data) {
					byte [] bytes = Encoding.UTF8.GetBytes (key);
					UrlEncodeAndWrite (tmpStream, bytes);
					tmpStream.WriteByte ((byte) '=');
					bytes = Encoding.UTF8.GetBytes (data [key]);
					UrlEncodeAndWrite (tmpStream, bytes);
					tmpStream.WriteByte ((byte) '&');
				}

				token.ThrowIfCancellationRequested ();
				
				int length = (int) tmpStream.Length;
				if (length > 0)
					tmpStream.SetLength (--length); // remove trailing '&'
				
				byte [] buf = tmpStream.GetBuffer ();
				request.ContentLength = length;
				using (Stream rqStream = await request.GetRequestStreamAsync ().ConfigureAwait (false)) {
					await rqStream.WriteAsync (buf, 0, length, token).ConfigureAwait (false);
				}
				tmpStream.Close ();

				response = await GetWebResponseTaskAsync (request, token).ConfigureAwait (false);
				return await ReadAllTaskAsync (request, response, token).ConfigureAwait (false);
			} finally {
				if (response != null)
					response.Close ();
			}
		}

 /// <summary>
 /// 	Sets the body stream of the HTTP request.
 /// </summary>
 /// <param name="request">Request that is being executed.</param>
 /// <param name="body">Body that is to be set with the HTTP request.</param>
 static async Task SetBodyStream(WebRequest request, byte[] body)
 {
     try
     {
         var stream = await request.GetRequestStreamAsync();
         stream.WriteTimeout = 30 * 1000;
         stream.Write(body, 0, body.Length);
         stream.Flush();
         stream.Close();
         stream.Dispose();
     }
     catch (Exception ex)
     {
         Debug.WriteLine("[AsyncRequest][SetBodyStream] Error streaming Body of the request: {0}", ex.Message);
     }
 }

		private async Task<ServiceResponse> SendDataAsyncAwait(WebRequest request, byte[] data)
		{
			try
			{
				var stream = await request.GetRequestStreamAsync();
				stream.Write(data, 0, data.Length);
			}
			catch (AggregateException ae)
			{
				throw MappedAggregateException(ae);
			}

			return SendRequestAsyncAwait(request);
		}

        private async Task<HttpWebResponseWrapper> 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))
            {
                HttpWebResponseWrapper wrapper = null;
                
                var httpResponse = response as HttpWebResponse;
                if (httpResponse != null)
                {
                    // Return content only for 206 for performance reasons
                    // Currently we do not need it in other cases
                    if (httpResponse.StatusCode == HttpStatusCode.PartialContent)
                    {
                        wrapper = new HttpWebResponseWrapper
                        {
                            StatusCode = (int)httpResponse.StatusCode,
                        };

                        if (httpResponse.Headers != null)
                        {
                            wrapper.RetryAfterHeader = httpResponse.Headers["Retry-After"];
                        }

                        using (StreamReader content = new StreamReader(httpResponse.GetResponseStream()))
                        {
                            wrapper.Content = content.ReadToEnd();
                        }
                    }
                }

                return wrapper;
            }
        }