/// <summary>
/// Executes an HTTP method on the given Url
/// </summary>
/// <typeparam name="InType">Type of data to be sent in the request</typeparam>
/// <typeparam name="OutType">Output type to be parsed from the response</typeparam>
/// <param name="method">Method to execute</param>
/// <param name="service">Service to call</param>
/// <param name="serializationMode">Body serialization type</param>
/// <param name="input">Data to send with the request</param>
/// <param name="uriFormat">Format of the Uri parameters</param>
/// <param name="values">Values used to create Uri parameters</param>
/// <returns>Http results class object that contains either the result data or error</returns>
public static HttpResults <OutType> ExecuteHttpMethod <InType, OutType>(HttpMethod method, string service, SerializationModesEnum serializationMode, InType input, string uriFormat, params object[] values)
{
HttpResults <OutType> result = null;
try
{
// Get client reference
HttpClient client = GetClient(service);
XmlObjectSerializer serializer = null;
HttpContent content = null;
// Get appropriate serializer
switch (serializationMode)
{
case SerializationModesEnum.Json:
var settings = new DataContractJsonSerializerSettings
{
DateTimeFormat = new DateTimeFormat(DATE_TIME_FMT)
};
serializer = new DataContractJsonSerializer(typeof(InType), settings);
break;
case SerializationModesEnum.Xml:
default:
serializer = new DataContractSerializer(typeof(InType));
break;
}
// Build body content
string contentString = null;
using (MemoryStream ms = new MemoryStream())
{
serializer.WriteObject(ms, input);
contentString = UTF8Encoding.UTF8.GetString(ms.ToArray());
}
content = new StringContent(contentString, Encoding.UTF8, GetContentMediaTypeName(serializationMode));
// Execute call
string uri = "";
if (!string.IsNullOrEmpty(uriFormat))
{
uri = string.Format(uriFormat, values);
}
using (HttpRequestMessage request = new HttpRequestMessage(method, uri))
{
AddHeaders(request, serializationMode);
request.Content = content;
using (HttpResponseMessage response = client.SendAsync(request).Result)
{
result = ParseResponse <OutType>(response);
}
}
}
catch (Exception ex)
{
System.Reflection.MethodBase mb = System.Reflection.MethodBase.GetCurrentMethod();
System.Diagnostics.Debug.WriteLine(ex.Message, string.Format("{0}.{1}.{2}", mb.DeclaringType.Namespace, mb.DeclaringType.Name, mb.Name));
}
return(result);
}
/// <summary>
/// Executes a DELETE on the given Url without header inputs or outputs
/// </summary>
/// <param name="service">Service to call</param>
/// <param name="serializationMode">Body serialization type</param>
/// <param name="uriFormat">Format of the Uri parameters</param>
/// <param name="values">Values used to create Uri parameters</param>
/// <returns>Http result code - hopefully 200 (OK)</returns>
public static HttpResults <object> Delete(string service, SerializationModesEnum serializationMode, string uriFormat, params object[] values)
{
HttpClient client = GetClient(service);
HttpResults <object> result = null;
try
{
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Delete, string.Format(uriFormat, values));
AddHeaders(request, serializationMode);
using (HttpResponseMessage response = client.SendAsync(request).Result)
{
result = new HttpResults <object>(response.StatusCode, null);
if (!response.IsSuccessStatusCode)
{
result.Error = response.StatusCode.ToString();
}
}
}
catch (Exception ex)
{
System.Reflection.MethodBase mb = System.Reflection.MethodBase.GetCurrentMethod();
System.Diagnostics.Debug.WriteLine(ex.Message, string.Format("{0}.{1}.{2}", mb.DeclaringType.Namespace, mb.DeclaringType.Name, mb.Name));
}
return(result);
}
/// <summary>
/// Parses an Http response message
/// </summary>
/// <typeparam name="OutType">Datatype of the response contents</typeparam>
/// <param name="response">Response message object</param>
/// <returns></returns>
private static HttpResults <OutType> ParseResponse <OutType>(HttpResponseMessage response)
{
HttpResults <OutType> result = null;
try
{
Stream stream = response.Content.ReadAsStreamAsync().Result;
XmlObjectSerializer serializer = null;
#if DEBUG
// For debugging purposes
byte[] data = new byte[stream.Length];
stream.Read(data, 0, data.Length);
stream.Seek(0, SeekOrigin.Begin);
string contents = UTF8Encoding.UTF8.GetString(data, 0, data.Length);
Console.WriteLine(contents);
#endif
SerializationModesEnum serializationMode = GetContentMediaType(response);
if (response.IsSuccessStatusCode)
{
switch (serializationMode)
{
case SerializationModesEnum.Json:
var settings = new DataContractJsonSerializerSettings
{
DateTimeFormat = new DateTimeFormat(DATE_TIME_FMT)
};
serializer = new DataContractJsonSerializer(typeof(OutType), settings);
//serializer = new DataContractJsonSerializer(typeof(OutType));
break;
case SerializationModesEnum.Xml:
serializer = new DataContractSerializer(typeof(OutType));
break;
default:
result = new HttpResults <OutType>(response.StatusCode, default(OutType))
{
Error = "Unknown media content type"
};
break;
}
if (serializer != null)
{
result = new HttpResults <OutType>(response.StatusCode, (OutType)serializer.ReadObject(stream));
}
}
else
{
switch (serializationMode)
{
case SerializationModesEnum.Json:
serializer = new DataContractJsonSerializer(typeof(string));
break;
case SerializationModesEnum.Xml:
serializer = new DataContractSerializer(typeof(string));
break;
default:
result = new HttpResults <OutType>(response.StatusCode, default(OutType))
{
Error = response.StatusCode.ToString()
};
break;
}
if (serializer != null)
{
result = new HttpResults <OutType>(response.StatusCode, (string)serializer.ReadObject(stream));
}
}
#if DEBUG
result.RawData = contents;
#endif
}
catch (Exception ex)
{
System.Reflection.MethodBase mb = System.Reflection.MethodBase.GetCurrentMethod();
System.Diagnostics.Debug.WriteLine(ex.Message, string.Format("{0}.{1}.{2}", mb.DeclaringType.Namespace, mb.DeclaringType.Name, mb.Name));
}
return(result);
}
