|
public GetRequestStreamAsync ( ) : System.Threading.Tasks.Task |
||
| return | System.Threading.Tasks.Task |
|
/// <summary>
/// 发送指定的 form data 数据。
/// </summary>
/// <param name="request">WebRequest 扩展实例</param>
/// <param name="data">提交数据时所需要的数据。可使用 <code>new { name = "xxx" }</code> 匿名对象的形式提供。</param>
/// <param name="encoding">对于提交的数据的编码格式。null表示使用默认的 UTF-8 编码格式。</param>
/// <returns>当前 <see cref="WebRequest"/> 实例。</returns>
/// <exception cref="System.ArgumentNullException">data</exception>
public static async Task <WebResponse> PushDataAsync(this WebRequest request, object data, Encoding encoding = null)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
var form_data = string.Empty;
if (data.GetType() != typeof(string))
{
var properties = new Dictionary <string, string>();
foreach (var propInfo in data.GetType().GetRuntimeProperties())
{
properties.Add(propInfo.Name, propInfo.GetValue(data).ToString());
}
form_data = properties.Select(kvp => $"{kvp.Key}={kvp.Value}").Aggregate((prev, next) => $"{prev}&{next}");
}
else
{
form_data = data.ToString();
}
var buffer = form_data.ToBytes(encoding);
using (var stream = await request.GetRequestStreamAsync())
{
stream.Write(buffer, 0, buffer.Length);
}
return(await request.GetResponseAsync());
}
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/"));
}
/// <summary>
/// Creates a <see cref="T:Task"/> that represents sending all of the data to the <see cref="T:WebRequest"/>.
/// </summary>
/// <param name="webRequest">The <see cref="T:WebRequest"/> instance.</param>
/// <param name="data">A data object to be sent alone with the <see cref="T:WebRequest"/>.</param>
/// <returns>A <see cref="T:Task"/> objected returned after sending data to a <see cref="T:WebRequest"/>.</returns>
public static Task PostDataAsync(this WebRequest webRequest, object data)
{
Contract.Requires(webRequest != null);
Contract.Requires(data != null);
byte[] buffer;
var sb = new StringBuilder();
foreach (PropertyInfo pi in data.GetType().GetProperties())
{
sb.Append((sb.Length == 0 ? String.Empty : "&") + pi.Name + "=" + Uri.UnescapeDataString(pi.GetValue(data, null).ToString()));
}
buffer = Encoding.ASCII.GetBytes(sb.ToString());
webRequest.ContentLength = buffer.Length;
webRequest.Method = WebRequestMethods.Http.Post;
webRequest.ContentType = "application/x-www-form-urlencoded";
return(webRequest.GetRequestStreamAsync().ContinueWith(stream =>
{
return stream.Result.WriteAsync(buffer, 0, buffer.Length);
}).Unwrap());
}
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[]> 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)
fStream.Close ();
if (reqStream != null)
reqStream.Close ();
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 ();
}
}
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;
}
}
