Request.Async.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;
using System.Threading;

namespace CoreTweet
{
    partial class Request
    {
        /// <summary>
        /// Sends a GET request.
        /// </summary>
        /// <returns>The response.</returns>
        /// <param name="url">URL.</param>
        /// <param name="prm">Parameters.</param>
        /// <param name="authorizationHeader">String of OAuth header.</param>
        /// <param name="userAgent">User-Agent header.</param>
        /// <param name="proxy">Proxy information for the request.</param>
        /// <param name="cancellationToken">Cancellation token.</param>
        internal static Task<HttpWebResponse> HttpGetAsync(string url, IEnumerable<KeyValuePair<string, object>> prm, string authorizationHeader, string userAgent
#if !PCL
            , IWebProxy proxy
#endif
            , CancellationToken cancellationToken)
        {
            var task = new TaskCompletionSource<HttpWebResponse>();
            if (cancellationToken.IsCancellationRequested)
            {
                task.TrySetCanceled();
                return task.Task;
            }

            try
            {
                if (prm == null) prm = new Dictionary<string, object>();
                var req = (HttpWebRequest)WebRequest.Create(url + '?' + CreateQueryString(prm));

                var reg = cancellationToken.Register(() =>
                {
                    req.Abort();
                    task.TrySetCanceled();
                });

                req.UserAgent = userAgent;
#if !PCL
                req.Proxy = proxy;
#endif
                req.Headers.Add(HttpRequestHeader.Authorization, authorizationHeader);
                req.BeginGetResponse(ar =>
                {
                    reg.Dispose();
                    try
                    {
                        task.TrySetResult((HttpWebResponse)req.EndGetResponse(ar));
                    }
                    catch (Exception ex)
                    {
                        task.TrySetException(ex);
                    }
                }, null);
            }
            catch (Exception ex)
            {
                task.TrySetException(ex);
            }

            return task.Task;
        }

        /// <summary>
        /// Sends a POST request.
        /// </summary>
        /// <returns>The response.</returns>
        /// <param name="url">URL.</param>
        /// <param name="prm">Parameters.</param>
        /// <param name="authorizationHeader">String of OAuth header.</param>
        /// <param name="userAgent">User-Agent header.</param>
        /// <param name="proxy">Proxy information for the request.</param>
        /// <param name="cancellationToken">Cancellation token.</param>
        internal static Task<HttpWebResponse> HttpPostAsync(string url, IEnumerable<KeyValuePair<string, object>> prm, string authorizationHeader, string userAgent
#if !PCL
            , IWebProxy proxy
#endif
            , CancellationToken cancellationToken)
        {
            var task = new TaskCompletionSource<HttpWebResponse>();
            if (cancellationToken.IsCancellationRequested)
            {
                task.TrySetCanceled();
                return task.Task;
            }

            try
            {
                if (prm == null) prm = new Dictionary<string, object>();
                var data = Encoding.UTF8.GetBytes(CreateQueryString(prm));
                var req = (HttpWebRequest)WebRequest.Create(url);

                var reg = cancellationToken.Register(() =>
                {
                    req.Abort();
                    task.TrySetCanceled();
                });

                req.ServicePoint.Expect100Continue = false;
                req.Method = "POST";
                req.UserAgent = userAgent;
#if !PCL
                req.Proxy = proxy;
#endif
                req.ContentType = "application/x-www-form-urlencoded";
                req.ContentLength = data.Length;
                req.Headers.Add(HttpRequestHeader.Authorization, authorizationHeader);

                req.BeginGetRequestStream(reqStrAr =>
                {
                    try
                    {
                        using (var stream = req.EndGetRequestStream(reqStrAr))
                            stream.Write(data, 0, data.Length);

                        req.BeginGetResponse(resAr =>
                        {
                            reg.Dispose();
                            try
                            {
                                task.TrySetResult((HttpWebResponse)req.EndGetResponse(resAr));
                            }
                            catch (Exception ex)
                            {
                                task.TrySetException(ex);
                            }
                        }, null);
                    }
                    catch (Exception ex)
                    {
                        task.TrySetException(ex);
                    }
                }, null);
            }
            catch (Exception ex)
            {
                task.TrySetException(ex);
            }

            return task.Task;
        }

        /// <summary>
        /// Sends a POST request with multipart/form-data.
        /// </summary>
        /// <returns>The response.</returns>
        /// <param name="url">URL.</param>
        /// <param name="prm">Parameters.</param>
        /// <param name="authorizationHeader">String of OAuth header.</param>
        /// <param name="userAgent">User-Agent header.</param>
        /// <param name="proxy">Proxy information for the request.</param>
        /// <param name="cancellationToken">Cancellation token.</param>
        internal static Task<HttpWebResponse> HttpPostWithMultipartFormDataAsync(string url, IEnumerable<KeyValuePair<string, object>> prm, string authorizationHeader, string userAgent
#if !PCL
            , IWebProxy proxy
#endif
            , CancellationToken cancellationToken)
        {
            var task = new TaskCompletionSource<HttpWebResponse>();
            if (cancellationToken.IsCancellationRequested)
            {
                task.TrySetCanceled();
                return task.Task;
            }

            try
            {
                var boundary = Guid.NewGuid().ToString();
                var req = (HttpWebRequest)WebRequest.Create(url);

                var reg = cancellationToken.Register(() =>
                {
                    req.Abort();
                    task.TrySetCanceled();
                });

                req.ServicePoint.Expect100Continue = false;
                req.Method = "POST";
                req.UserAgent = userAgent;
#if !PCL
                req.Proxy = proxy;
#endif
                req.ContentType = "multipart/form-data;boundary=" + boundary;
                req.Headers.Add(HttpRequestHeader.Authorization, authorizationHeader);

                req.BeginGetRequestStream(reqStrAr =>
                {
                    try
                    {
                        using (var stream = req.EndGetRequestStream(reqStrAr))
                            WriteMultipartFormData(stream, boundary, prm);

                        req.BeginGetResponse(resAr =>
                        {
                            reg.Dispose();
                            try
                            {
                                task.TrySetResult((HttpWebResponse)req.EndGetResponse(resAr));
                            }
                            catch (Exception ex)
                            {
                                task.TrySetException(ex);
                            }
                        }, null);
                    }
                    catch (Exception ex)
                    {
                        task.TrySetException(ex);
                    }
                }, null);
            }
            catch (Exception ex)
            {
                task.TrySetException(ex);
            }

            return task.Task;
        }
    }
}