/// <summary>
/// Create the client
/// </summary>
/// <param name="client">The REST client that wants to create the HTTP client</param>
/// <param name="request">The REST request for which the HTTP client is created</param>
/// <returns>A new HttpClient object</returns>
/// <remarks>
/// The DefaultHttpClientFactory contains some helpful protected methods that helps gathering
/// the data required for a proper configuration of the HttpClient.
/// </remarks>
public virtual IHttpClient CreateClient(IRestClient client, IRestRequest request)
{
var headers = new GenericHttpHeaders();
var httpClient = new DefaultHttpClient(this, headers)
{
BaseAddress = GetBaseAddress(client)
};
if (client.Timeout.HasValue)
{
httpClient.Timeout = client.Timeout.Value;
}
var proxy = GetProxy(client);
if (proxy != null)
{
httpClient.Proxy = new RequestProxyWrapper(proxy);
}
var cookieContainer = GetCookies(client, request);
if (cookieContainer != null)
{
httpClient.CookieContainer = cookieContainer;
}
if (_setCredentials)
{
var credentials = client.Credentials;
if (credentials != null)
{
httpClient.Credentials = credentials;
}
}
return httpClient;
}
public StringContent([NotNull] string value, [NotNull] Encoding encoding)
{
_value = value;
_encoding = encoding;
Headers = new GenericHttpHeaders();
Headers.TryAddWithoutValidation("Content-Type", $"text/plain; charset={encoding.WebName}");
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultHttpResponseMessage"/> class.
/// </summary>
/// <param name="requestMessage">The request message for this response</param>
/// <param name="responseMessage">The response message to wrap</param>
/// <param name="exception">The exception that occurred during the request</param>
public DefaultHttpResponseMessage([NotNull] IHttpRequestMessage requestMessage, [NotNull] HttpWebResponse responseMessage, [CanBeNull] WebException exception = null)
{
ResponseMessage = responseMessage;
_exception = exception;
_requestMessage = requestMessage;
var responseHeaders = new GenericHttpHeaders();
var contentHeaders = new GenericHttpHeaders();
if (responseMessage.SupportsHeaders)
{
foreach (var headerName in responseMessage.Headers.AllKeys)
{
IHttpHeaders headers;
if (headerName.StartsWith("Content-", StringComparison.OrdinalIgnoreCase))
{
headers = contentHeaders;
}
else
{
headers = responseHeaders;
}
headers.TryAddWithoutValidation(headerName, responseMessage.Headers[headerName]);
}
}
_content = new HttpWebResponseContent(contentHeaders, responseMessage);
_responseHttpHeaders = responseHeaders;
}
/// <summary>
/// Create the request message
/// </summary>
/// <param name="client">The REST client that wants to create the HTTP request message</param>
/// <param name="request">The REST request for which the HTTP request message is created</param>
/// <param name="parameters">The request parameters for the REST request except the content header parameters (read-only)</param>
/// <returns>A new HttpRequestMessage object</returns>
/// <remarks>
/// The DefaultHttpClientFactory contains some helpful protected methods that helps gathering
/// the data required for a proper configuration of the HttpClient.
/// </remarks>
public virtual IHttpRequestMessage CreateRequestMessage(IRestClient client, IRestRequest request, IList<Parameter> parameters)
{
var address = GetMessageAddress(client, request);
var method = GetHttpMethod(client, request);
var headers = new GenericHttpHeaders();
AddHttpHeaderParameters(headers, request, parameters);
return new DefaultHttpRequestMessage(method, address, headers, null);
}
/// <summary>
/// Asynchronously send a request
/// </summary>
/// <param name="request">The request do send</param>
/// <param name="cancellationToken">The cancellation token used to signal an abortion</param>
/// <returns>The task to query the response</returns>
public async Task<IHttpResponseMessage> SendAsync(IHttpRequestMessage request, CancellationToken cancellationToken)
{
var uri = new Uri(BaseAddress, request.RequestUri);
var wr = _httpClientFactory.CreateWebRequest(uri);
if (wr.SupportsCookieContainer && CookieContainer != null)
wr.CookieContainer = CookieContainer;
if (Credentials != null)
wr.Credentials = Credentials;
wr.Method = request.Method.ToString();
#if !PCL
wr.Proxy = Proxy ?? System.Net.WebRequest.DefaultWebProxy;
#endif
// Combine all headers into one header collection
var headers = new GenericHttpHeaders();
if (request.Content?.Headers != null)
{
foreach (var header in request.Content.Headers.Where(x => !headers.Contains(x.Key)))
{
headers.TryAddWithoutValidation(header.Key, header.Value);
}
}
if (request.Headers != null)
{
foreach (var header in request.Headers.Where(x => !headers.Contains(x.Key)))
{
headers.TryAddWithoutValidation(header.Key, header.Value);
}
}
if (DefaultRequestHeaders != null)
{
foreach (var header in DefaultRequestHeaders.Where(x => !headers.Contains(x.Key)))
{
headers.TryAddWithoutValidation(header.Key, header.Value);
}
}
bool hasContentLength = false;
foreach (var header in headers)
{
var value = string.Join(",", header.Value);
SetWebRequestHeaderValue(wr, header.Key, value);
if (!hasContentLength && string.Equals(header.Key, "content-length", StringComparison.OrdinalIgnoreCase))
hasContentLength = true;
}
if (request.Content != null)
{
// Add content length if not provided by the user.
if (!hasContentLength)
{
long contentLength;
if (request.Content.TryComputeLength(out contentLength))
{
#if PCL || NETFX_CORE || WINDOWS_STORE
wr.Headers[HttpRequestHeader.ContentLength] = contentLength.ToString();
#else
wr.ContentLength = contentLength;
#endif
}
}
try
{
#if PCL && ASYNC_PCL
var getRequestStreamAsync = Task.Factory.FromAsync<Stream>(wr.BeginGetRequestStream, wr.EndGetRequestStream, null);
var requestStream = await getRequestStreamAsync.HandleCancellation(cancellationToken);
#else
var requestStream = await wr.GetRequestStreamAsync().HandleCancellation(cancellationToken);
#endif
using (requestStream)
{
var temp = new MemoryStream();
await request.Content.CopyToAsync(temp);
var buffer = temp.ToArray();
await requestStream.WriteAsync(buffer, 0, buffer.Length, cancellationToken);
await requestStream.FlushAsync(cancellationToken);
}
}
catch (OperationCanceledException)
{
wr.Abort();
throw;
}
}
try
{
#if PCL && ASYNC_PCL
var getResponseAsync = Task.Factory.FromAsync<WebResponse>(wr.BeginGetResponse, wr.EndGetResponse, null);
var response = await getResponseAsync.HandleCancellation(cancellationToken);
#else
var response = await wr.GetResponseAsync().HandleCancellation(cancellationToken);
#endif
var httpWebResponse = response as HttpWebResponse;
if (httpWebResponse == null)
{
response.Dispose();
throw new ProtocolViolationException("No HTTP request")
{
Data =
{
{ "URI", wr.RequestUri },
},
};
}
return new DefaultHttpResponseMessage(request, httpWebResponse);
}
catch (WebException ex)
{
var httpWebResponse = (HttpWebResponse)ex.Response;
return new DefaultHttpResponseMessage(request, httpWebResponse, ex);
}
catch (OperationCanceledException)
{
wr.Abort();
throw;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ByteArrayContent"/> class.
/// </summary>
/// <param name="data">The underlying binary data</param>
public ByteArrayContent(byte[] data)
{
_data = data;
Headers = new GenericHttpHeaders();
Headers.TryAddWithoutValidation("Content-Type", "application/octet-stream");
}
