SystemNetHttpClient.cs

#if !NET35
using System;
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using System.Runtime.InteropServices;

namespace Twilio.Http
{
    /// <summary>
    /// Sample client to make HTTP requests
    /// </summary>
    public class SystemNetHttpClient : HttpClient
    {
#if NET451
        private string PlatVersion = ".NET Framework 4.5.1+";
#else
        private string PlatVersion = RuntimeInformation.FrameworkDescription;
#endif

        private readonly System.Net.Http.HttpClient _httpClient;

        /// <summary>
        /// Create new HttpClient
        /// </summary>
        /// <param name="httpClient">HTTP client to use</param>
        public SystemNetHttpClient(System.Net.Http.HttpClient httpClient = null)
        {
            _httpClient = httpClient ?? new System.Net.Http.HttpClient(new HttpClientHandler() { AllowAutoRedirect = false });
        }

        /// <summary>
        /// Make a synchronous request
        /// </summary>
        /// <param name="request">Twilio request</param>
        /// <returns>Twilio response</returns>
        public override Response MakeRequest(Request request)
        {
            try
            {
                var task = MakeRequestAsync(request);
                task.Wait();
                return task.Result;
            }
            catch (AggregateException ae)
            {
                // Combine nested AggregateExceptions
                ae = ae.Flatten();
                throw ae.InnerExceptions[0];
            }
        }

        /// <summary>
        /// Make an asynchronous request
        /// </summary>
        /// <param name="request">Twilio response</param>
        /// <returns>Task that resolves to the response</returns>
        public override async Task<Response> MakeRequestAsync(Request request)
        {
            var httpRequest = BuildHttpRequest(request);
            if (!Equals(request.Method, HttpMethod.Get))
            {
                if (request.Files.Count > 0)
                {
                    var boundary = "---------" + Guid.NewGuid().ToString().ToLower();
                    var multiPartContent = new MultipartFormDataContent(boundary);
                    multiPartContent.Headers.ContentType = new MediaTypeHeaderValue("multipart/form-data")
                    {
                        Parameters = { new NameValueHeaderValue("boundary", boundary) }
                    };

                    foreach (var postParam in request.PostParams)
                    {
                        multiPartContent.Add(new StringContent(postParam.Value), postParam.Key);
                    }

                    foreach (var file in request.Files)
                    {
                        multiPartContent.Add(new StreamContent(file.Value.Stream), file.Key, file.Value.FileName);
                    }

                    httpRequest.Content = multiPartContent;
                }
                else
                {
                    httpRequest.Content = new FormUrlEncodedContent(request.PostParams);
                }
            }

            this.LastRequest = request;
            this.LastResponse = null;

            var httpResponse = await _httpClient.SendAsync(httpRequest).ConfigureAwait(false);
            var reader = new StreamReader(await httpResponse.Content.ReadAsStreamAsync().ConfigureAwait(false));

            // Create and return a new Response. Keep a reference to the last
            // response for debugging, but don't return it as it may be shared
            // among threads.
            var response = new Response(httpResponse.StatusCode, await reader.ReadToEndAsync().ConfigureAwait(false), httpResponse.Headers);
            this.LastResponse = response;
            return response;
        }

        private HttpRequestMessage BuildHttpRequest(Request request)
        {
            var httpRequest = new HttpRequestMessage(
                new System.Net.Http.HttpMethod(request.Method.ToString()),
                request.ConstructUrl()
            );

            var authBytes = Authentication(request.Username, request.Password);
            httpRequest.Headers.Authorization = new AuthenticationHeaderValue("Basic", authBytes);

            httpRequest.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            httpRequest.Headers.AcceptEncoding.Add(new StringWithQualityHeaderValue("utf-8"));

            int lastSpaceIndex = PlatVersion.LastIndexOf(" ");
            System.Text.StringBuilder PlatVersionSb= new System.Text.StringBuilder(PlatVersion);
            PlatVersionSb[lastSpaceIndex] = '/';

            string helperLibVersion = AssemblyInfomation.AssemblyInformationalVersion;

            string osName = "Unknown";
#if !NETSTANDARD1_4
            osName = Environment.OSVersion.Platform.ToString();
#else       
            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                osName = "Windows";
            }
            else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
            {
                osName = "MacOS";
            }
            else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
            {
                osName = "Linux";
            }
#endif

            string osArch;
#if !NET451
            osArch = RuntimeInformation.OSArchitecture.ToString();
#else
            osArch = Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE") ?? "Unknown"; 
#endif
            var libraryVersion = String.Format("twilio-csharp/{0} ({1} {2}) {3}", helperLibVersion, osName, osArch, PlatVersionSb);

            if (request.UserAgentExtensions != null)
            {
                foreach (var extension in request.UserAgentExtensions)
                {
                    libraryVersion += " " + extension;
                }
            }

            httpRequest.Headers.TryAddWithoutValidation("User-Agent", libraryVersion);

            foreach (var header in request.HeaderParams)
            {
                httpRequest.Headers.TryAddWithoutValidation(header.Key, header.Value);
            }

            return httpRequest;
        }
    }
}
#endif