private async Task<string> FetchGzipCompressedHttpContent(Uri uri)
{
var handler = new CompressedHttpClientHandler();
var client = new HttpClient(handler);
var result = await client.GetStringAsync(uri);
return result;
}
public async Task GetStringAsync()
{
var handler = new CompressedHttpClientHandler();
var client = new HttpClient(handler);
var result = await client.GetStringAsync(NuGetString);
Assert.IsNotNull(result);
}
private async Task <string> FetchGzipCompressedHttpContent(Uri uri)
{
var handler = new CompressedHttpClientHandler();
var client = new HttpClient(handler);
var result = await client.GetStringAsync(uri);
return(result);
}
public async Task SendAsyncWithHeaders()
{
var handler = new CompressedHttpClientHandler();
var client = new HttpClient(handler);
var message = new HttpRequestMessage(HttpMethod.Get, new Uri(NuGetString, UriKind.RelativeOrAbsolute));
var result = await client.SendAsync(message);
Assert.IsNotNull(result);
Assert.IsNotNull(result.Content);
Assert.IsNotNull(result.Content.Headers);
}
/// <summary>
/// Read zipped html page and return its content as string.
/// </summary>
/// <param name="pageAdress">The address of the zipped page.</param>
/// <returns>Content of the page as a string.</returns>
public static async Task<string> readCompressedHtmlPageAsync(string pageAdress)
{
CompressedHttpClientHandler handler = new CompressedHttpClientHandler();
HttpClient client = new HttpClient(handler);
HttpResponseMessage response = await client.GetAsync(pageAdress);
response.EnsureSuccessStatusCode();
string content = await response.Content.ReadAsStringAsync();
return content;
}
public async Task <string> GetArticles(string url)
{
try
{
AdvancedREI.Net.Http.Compression.CompressedHttpClientHandler handler = new CompressedHttpClientHandler();
System.Net.Http.HttpClient hc = new System.Net.Http.HttpClient(handler);
hc.DefaultRequestHeaders.Add("Cache-Control", "no-cache");
hc.DefaultRequestHeaders.ConnectionClose = true;
//hc.DefaultRequestHeaders.CacheControl.NoCache = true;
return(await hc.GetStringAsync(new Uri(url)));
}
catch (Exception)
{
return("");
}
}
/// <summary>
/// Executes an asynchronous request to the given resource and deserializes the response to an object of T.
/// </summary>
/// <typeparam name="T">The type to deserialize to.</typeparam>
/// <param name="restRequest">The RestRequest to execute.</param>
/// <returns>An object of T.</returns>
public async Task <T> ExecuteAsync <T>(RestRequest restRequest) where T : class
{
T result = null;
var url = restRequest.GetFormattedResource(BaseUrl);
if (string.IsNullOrWhiteSpace(restRequest.DateFormat) && !string.IsNullOrWhiteSpace(DateFormat))
{
restRequest.DateFormat = DateFormat;
}
var handler = new CompressedHttpClientHandler {
AllowAutoRedirect = true
};
_client = new HttpClient(handler);
if (!string.IsNullOrWhiteSpace(UserAgent))
{
_client.DefaultRequestHeaders.Add("user-agent", UserAgent);
}
var message = new HttpRequestMessage(restRequest.Method, new Uri(restRequest.Resource, UriKind.RelativeOrAbsolute));
foreach (var header in Headers)
{
message.Headers.Add(header.Key, header.Value);
}
if (restRequest.Method == HttpMethod.Post || restRequest.Method == HttpMethod.Put)
{
var contentString = new StringContent(restRequest.GetRequestBody(), Encoding.UTF8, restRequest.GetContentType());
message.Content = contentString;
}
HttpResponseMessage response = null;
response = await _client.SendAsync(message);
response.EnsureSuccessStatusCode();
var responseContent = await response.Content.ReadAsStringAsync();
//TODO: Handle Error
if (response.Content.Headers.ContentType.MediaType == "application/xml")
{
// RWM: IDEA - The DataContractSerializer doesn't like attributes, but will handle everything else.
// So instead of trying to mess with a double-conversion to JSON and then to the Object, we'll just turn the attributes
// into elements, and sort the elements into alphabetical order so the DataContracterializer doesn't crap itself.
// On post, use a C# attribute to specify if a property is an XML attribute, DataContractSerialize to XML, then
// query the object for [XmlAttribute] attributes and move them from elements to attributes using code similar to below.
// If the POST request requires the attributes in a certain order, oh well. Shouldn't have used PHP :P.
XElement root = XElement.Parse(responseContent);
XElement newRoot = (XElement)Transform(restRequest.IgnoreRootElement ? root.Descendants().First() : root, restRequest);
using (var memoryStream = new MemoryStream(Encoding.Unicode.GetBytes(newRoot.ToString())))
{
var settings = new XmlReaderSettings {
IgnoreWhitespace = true
};
using (var reader = XmlReader.Create(memoryStream, settings))
{
try
{
var serializer = new DataContractSerializer(typeof(T));
result = serializer.ReadObject(reader) as T;
}
catch (SerializationException ex)
{
throw new PortableRestException(string.Format("The serializer failed on node '{0}'", reader.Name), reader.Name, ex);
}
}
}
}
else
{
result = JsonConvert.DeserializeObject <T>(responseContent);
}
return(result);
}
