/// <summary>
/// Makes a restful call using supplied information.
/// </summary>
/// <typeparam name="TResult">Return type to convert response to (if you provide VoidResultType then null will be returned - basically a void call).</typeparam>
/// <param name="uri">Uri to make the request against.</param>
/// <param name="httpVerb">HTTP verb to use.</param>
/// <param name="body">Optional body object to send (use null if not needed).</param>
/// <param name="cookieJar">Optional cookie to use (use null if not needed).</param>
/// <param name="headerJar">Optional headers to use (use null if not needed).</param>
/// <param name="saveResponseHeadersAction">Optional action to use to save response headers (use null if not needed).</param>
/// <param name="contentType">Content type to use for request.</param>
/// <param name="acceptType">Content type to use for response.</param>
/// <param name="timeout">Timeout to use.</param>
/// <param name="serializer">Serializer to use.</param>
/// <returns>Converted response to the specified type.</returns>
public static TResult Call <TResult>(
Uri uri,
HttpVerb httpVerb,
object body,
CookieJar cookieJar,
HeaderJar headerJar,
Action <KeyValuePair <string, string>[]> saveResponseHeadersAction,
ContentType contentType,
ContentType acceptType,
TimeSpan timeout,
IStringSerializeAndDeserialize serializer)
where TResult : class
{
var httpVerbAsString = httpVerb.ToString().ToUpperInvariant();
return(Call <TResult>(
uri,
httpVerbAsString,
body,
cookieJar,
headerJar,
saveResponseHeadersAction,
contentType,
acceptType,
timeout,
serializer));
}
/// <summary>
/// Makes a restful call using supplied information.
/// </summary>
/// <typeparam name="TResult">Return type to convert response to (if you provide VoidResultType then null will be returned - basically a void call).</typeparam>
/// <param name="uri">Uri to make the request against.</param>
/// <param name="httpVerb">HTTP verb to use.</param>
/// <param name="body">Optional body object to send (use null if not needed).</param>
/// <param name="cookieJar">Optional cookie to use (use null if not needed).</param>
/// <param name="headerJar">Optional headers to use (use null if not needed).</param>
/// <param name="saveResponseHeadersAction">Optional action to use to save response headers (use null if not needed).</param>
/// <param name="contentType">Content type to use for request.</param>
/// <param name="acceptType">Content type to use for response.</param>
/// <param name="timeout">Timeout to use.</param>
/// <param name="serializer">Serializer to use.</param>
/// <returns>Converted response to the specified type.</returns>
/// <exception cref="ArgumentException">
/// Must have return of string when accepting text type.
/// or
/// ContentType: " + contentType + " not supported at this time. - contentType
/// or
/// AcceptType: " + contentType + " not supported at this time. - acceptType
/// or
/// AcceptType: " + acceptType + " not supported at this time. - acceptType.
/// </exception>
public static TResult Call <TResult>(
Uri uri,
string httpVerb,
object body,
CookieJar cookieJar,
HeaderJar headerJar,
Action <KeyValuePair <string, string>[]> saveResponseHeadersAction,
ContentType contentType,
ContentType acceptType,
TimeSpan timeout,
IStringSerializeAndDeserialize serializer)
where TResult : class
{
new { uri }.AsArg().Must().NotBeNull();
new { httpVerb }.AsArg().Must().NotBeNullNorWhiteSpace();
new { serializer }.AsArg().Must().NotBeNull();
if (acceptType == ContentType.TextPlain && typeof(TResult) != typeof(string))
{
throw new ArgumentException("Must have return of string when accepting text type.");
}
if (contentType != ContentType.ApplicationJson)
{
throw new ArgumentException("ContentType: " + contentType + " not supported at this time.", nameof(contentType));
}
if (acceptType != ContentType.ApplicationJson && acceptType != ContentType.TextPlain)
{
throw new ArgumentException("AcceptType: " + contentType + " not supported at this time.", nameof(acceptType));
}
if (timeout == default(TimeSpan))
{
timeout = TimeSpan.FromSeconds(100);
}
var cookieContainer = new CookieContainer();
foreach (var cookie in cookieJar.Cookies)
{
cookieContainer.Add(cookie);
}
// ReSharper disable once AccessToStaticMemberViaDerivedType - want to call this method...
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(uri);
request.CookieContainer = cookieContainer;
request.ContentType = contentType.ToStringValue();
request.Accept = acceptType.ToStringValue();
request.Method = httpVerb;
request.Timeout = (int)timeout.TotalMilliseconds;
LoadRequestHeaders(request, headerJar);
string bodyAsString = null;
if (contentType == ContentType.ApplicationJson && body != null)
{
bodyAsString = serializer.SerializeToString(body);
}
if (httpVerb != HttpVerb.Get.ToString().ToUpperInvariant() && !string.IsNullOrWhiteSpace(bodyAsString))
{
request.ContentLength = bodyAsString.Length;
using (var requestStream = request.GetRequestStream())
{
using (var requestWriter = new StreamWriter(requestStream, Encoding.ASCII))
{
requestWriter.Write(bodyAsString);
requestWriter.Close();
}
}
}
string contents = null;
WebHeaderCollection responseHeadersRaw;
using (var resp = request.GetResponse())
{
responseHeadersRaw = resp.Headers;
var responseStream = resp.GetResponseStream();
if (responseStream != null)
{
using (var reader = new StreamReader(responseStream))
{
contents = reader.ReadToEnd();
}
}
}
TResult ret = default(TResult);
if (typeof(TResult) == typeof(VoidResultType))
{
return(ret); // this will just be null and should only be used when you don't want a return
}
else if (acceptType == ContentType.ApplicationJson)
{
ret = serializer.Deserialize <TResult>(contents);
}
else if (acceptType == ContentType.TextPlain)
{
ret = contents as TResult;
}
else
{
throw new ArgumentException("AcceptType: " + acceptType + " not supported at this time.", nameof(acceptType));
}
var responseHeaders = responseHeadersRaw == null
? new KeyValuePair <string, string> [0]
: responseHeadersRaw.ToKeyValuePairArray();
saveResponseHeadersAction?.Invoke(responseHeaders);
return(ret);
}