public void HttpGetStreamInvoke(string url, IEnumerable <Header> headers,
HttpInvocationCompletionOption httpInvocationCompletionOption, TimeSpan timeOut,
HttpResponseHandler httpResponseHandler, CancellationToken cancellationToken)
{
Task.Run(async() =>
{
await HttpStreamInvokeAsync(url, HttpMethod.Get, headers, null,
httpInvocationCompletionOption, null, timeOut, httpResponseHandler, cancellationToken);
}, cancellationToken);
}
public void HttpPostStreamInvoke(string url, IEnumerable <Header> headers,
IEnumerable <Header> contentHeaders, HttpInvocationCompletionOption httpCompletetionOption,
string postParameters, TimeSpan timeOut, CancellationToken cancellationToken)
{
Task.Run(async() =>
{
await HttpStreamInvokeAsync(url, HttpMethod.Post, headers, contentHeaders,
httpCompletetionOption, postParameters, timeOut, null, cancellationToken);
}, cancellationToken);
}
private async Task HttpStreamInvokeAsync(string url, HttpMethod httpMethod, IEnumerable <Header> headers,
IEnumerable <Header> contentHeaders, HttpInvocationCompletionOption httpInvocationCompletetionOption,
string postParameters, TimeSpan timeOut, HttpResponseHandler httpResponseHandler,
CancellationToken cancellationToken)
{
postParameters = postParameters ?? String.Empty;
byte[] bufferPostParameters = Encoding.UTF8.GetBytes(postParameters);
using (StreamContent streamContent = new StreamContent(new MemoryStream(bufferPostParameters)))
{
if (httpMethod == HttpMethod.Post)
{
contentHeaders.ToList().ForEach(h => { streamContent.Headers.Add(h.Key, h.Value); });
}
using (HttpClient httpClient = new HttpClient())
{
httpClient.Timeout = timeOut;
headers.ToList().ForEach(h => { httpClient.DefaultRequestHeaders.Add(h.Key, h.Value); });
httpClient.BaseAddress = new Uri(url);
var request = new HttpRequestMessage(httpMethod, url);
if (httpMethod == HttpMethod.Post)
{
request.Content = streamContent;
}
if (cancellationToken.IsCancellationRequested)
{
return;
}
await httpClient.SendAsync(request, (HttpCompletionOption)httpInvocationCompletetionOption)
.ContinueWith(async responseTask =>
{
using (HttpResponseMessage response = responseTask.Result)
{
await response.Content.ReadAsStreamAsync().ContinueWith(streamTask =>
{
using (StreamReader streamReader = new StreamReader(streamTask.Result))
{
List <Header> responseHeaders = new List <Header>();
responseHeaders.AddRange(
response.Headers.Select(c => { return(Header.CreateHeader(c.Key, c.Value)); }));
List <Header> responseContentHeaders = new List <Header>();
responseContentHeaders.AddRange(
response.Content.Headers.Select(c => { return(Header.CreateHeader(c.Key, c.Value)); }));
try
{
while (!streamReader.EndOfStream && !cancellationToken.IsCancellationRequested)
{
if (httpResponseHandler != null)
{
string json = streamReader.ReadLine();
httpResponseHandler(this,
new HttpInvokerResponseArgs(new HttpInvokerResponse(response.StatusCode,
response.ReasonPhrase, headers, contentHeaders, json, false)));
}
}
}
catch (Exception ex)
{
Exception e = ex;
}
finally
{
if (!cancellationToken.IsCancellationRequested)
{
httpResponseHandler?.Invoke(this,
new HttpInvokerResponseArgs(new HttpInvokerResponse(response.StatusCode,
response.ReasonPhrase, headers, contentHeaders, String.Empty, true)));
}
}
}
});
}
});
}
}
}
