/// <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); }