/// <summary>
/// Sends the asynchronous.
/// </summary>
/// <typeparam name="TRequest">The type of the request.</typeparam>
/// <typeparam name="TResponse">The type of the response.</typeparam>
/// <param name="method">The method.</param>
/// <param name="requestBody">The request body.</param>
/// <param name="request">The request.</param>
/// <param name="setHeadersCallback">The set headers callback.</param>
/// <returns>The response object.</returns>
/// <exception cref="System.ArgumentNullException">request</exception>
private async Task <TResponse> SendAsync <TRequest, TResponse>(string method, TRequest requestBody, WebRequest request, Action <WebRequest> setHeadersCallback = null)
{
try
{
if (request == null)
{
throw new ArgumentNullException("request");
}
request.Method = method;
if (null == setHeadersCallback)
{
this.SetCommonHeaders(request);
}
else
{
setHeadersCallback(request);
}
if (requestBody is Stream)
{
request.ContentType = "application/octet-stream";
}
var asyncState = new WebRequestAsyncState()
{
RequestBytes = this.SerializeRequestBody(requestBody),
WebRequest = (HttpWebRequest)request,
};
var continueRequestAsyncState = await Task.Factory.FromAsync <Stream>(
asyncState.WebRequest.BeginGetRequestStream,
asyncState.WebRequest.EndGetRequestStream,
asyncState,
TaskCreationOptions.None).ContinueWith <WebRequestAsyncState>(
task =>
{
var requestAsyncState = (WebRequestAsyncState)task.AsyncState;
if (requestBody != null)
{
using (var requestStream = task.Result)
{
if (requestBody is Stream)
{
(requestBody as Stream).CopyTo(requestStream);
}
else
{
requestStream.Write(requestAsyncState.RequestBytes, 0, requestAsyncState.RequestBytes.Length);
}
}
}
return(requestAsyncState);
});
var continueWebRequest = continueRequestAsyncState.WebRequest;
var response = await Task.Factory.FromAsync <WebResponse>(
continueWebRequest.BeginGetResponse,
continueWebRequest.EndGetResponse,
continueRequestAsyncState);
return(this.ProcessAsyncResponse <TResponse>(response as HttpWebResponse));
}
catch (Exception e)
{
this.HandleException(e);
return(default(TResponse));
}
}
/// <summary>
/// Sends the asynchronous.
/// </summary>
/// <typeparam name="TRequest">The type of the request.</typeparam>
/// <typeparam name="TResponse">The type of the response.</typeparam>
/// <param name="method">The method.</param>
/// <param name="requestBody">The request body.</param>
/// <param name="request">The request.</param>
/// <param name="setHeadersCallback">The set headers callback.</param>
/// <returns>The response object.</returns>
/// <exception cref="System.ArgumentNullException">request</exception>
private async Task <TResponse> SendAsync <TRequest, TResponse>(string method, TRequest requestBody, WebRequest request, Action <WebRequest> setHeadersCallback = null)
{
try
{
if (request == null)
{
throw new ArgumentNullException("request");
}
request.Method = method;
if (null == setHeadersCallback)
{
this.SetCommonHeaders(request);
}
else
{
setHeadersCallback(request);
}
if (requestBody is Stream)
{
request.ContentType = "application/octet-stream";
}
var asyncState = new WebRequestAsyncState()
{
RequestBytes = this.SerializeRequestBody(requestBody),
WebRequest = (HttpWebRequest)request,
};
var continueRequestAsyncState = await Task.Factory.FromAsync <Stream>(
asyncState.WebRequest.BeginGetRequestStream,
asyncState.WebRequest.EndGetRequestStream,
asyncState,
TaskCreationOptions.None).ContinueWith <WebRequestAsyncState>(
task =>
{
var requestAsyncState = (WebRequestAsyncState)task.AsyncState;
if (requestBody != null)
{
using (var requestStream = task.Result)
{
if (requestBody is Stream)
{
(requestBody as Stream).CopyTo(requestStream);
}
else
{
requestStream.Write(requestAsyncState.RequestBytes, 0, requestAsyncState.RequestBytes.Length);
}
}
}
return(requestAsyncState);
}).ConfigureAwait(false);
var continueWebRequest = continueRequestAsyncState.WebRequest;
var getResponseAsync = Task.Factory.FromAsync <WebResponse>(
continueWebRequest.BeginGetResponse,
continueWebRequest.EndGetResponse,
continueRequestAsyncState);
await Task.WhenAny(getResponseAsync, Task.Delay(DefaultTimeout)).ConfigureAwait(false);
//Abort request if timeout has expired
if (!getResponseAsync.IsCompleted)
{
request.Abort();
}
return(this.ProcessAsyncResponse <TResponse>(getResponseAsync.Result as HttpWebResponse));
}
catch (AggregateException ae)
{
ae.Handle(e =>
{
this.HandleException(e);
return(true);
});
return(default(TResponse));
}
catch (Exception e)
{
this.HandleException(e);
return(default(TResponse));
}
}
/// <summary>
/// Sends the asynchronous.
/// </summary>
/// <typeparam name="TRequest">The type of the request.</typeparam>
/// <typeparam name="TResponse">The type of the response.</typeparam>
/// <param name="method">The method.</param>
/// <param name="requestBody">The request body.</param>
/// <param name="request">The request.</param>
/// <param name="setHeadersCallback">The set headers callback.</param>
/// <returns>The response object.</returns>
/// <exception cref="System.ArgumentNullException">request</exception>
protected async Task <TResponse> SendAsync <TRequest, TResponse>(string method, TRequest requestBody, WebRequest request, Action <WebRequest> setHeadersCallback = null)
{
try
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
request.Method = method;
request.Headers.Add("Ocp-Apim-Subscription-Key", this.SubscriptionKey);
if (null == setHeadersCallback)
{
if (string.IsNullOrWhiteSpace(request.ContentType))
{
this.SetCommonHeaders(request);
}
}
else
{
setHeadersCallback(request);
}
if (requestBody is Stream)
{
request.ContentType = $"image/jpeg";
}
var asyncState = new WebRequestAsyncState()
{
RequestBytes = this.SerializeRequestBody(requestBody, request.ContentType),
WebRequest = (HttpWebRequest)request,
};
var continueRequestAsyncState = await Task.Factory.FromAsync <Stream>(
asyncState.WebRequest.BeginGetRequestStream,
asyncState.WebRequest.EndGetRequestStream,
asyncState,
TaskCreationOptions.None).ContinueWith <WebRequestAsyncState>(
task =>
{
var requestAsyncState = (WebRequestAsyncState)task.AsyncState;
if (requestBody != null)
{
using (var requestStream = task.Result)
{
if (requestBody is Stream)
{
(requestBody as Stream).CopyTo(requestStream);
}
else
{
requestStream.Write(requestAsyncState.RequestBytes, 0, requestAsyncState.RequestBytes.Length);
}
}
}
return(requestAsyncState);
});
var continueWebRequest = continueRequestAsyncState.WebRequest;
var getResponse = Task.Factory.FromAsync <WebResponse>(
continueWebRequest.BeginGetResponse,
continueWebRequest.EndGetResponse,
continueRequestAsyncState);
await Task.WhenAny(getResponse, Task.Delay(this.DefaultTimeout));
//Abort request if timeout has expired
if (!getResponse.IsCompleted)
{
request.Abort();
}
return(this.ProcessAsyncResponse <TResponse>(getResponse.Result as HttpWebResponse));
}
catch (AggregateException ae)
{
ae.Handle(e =>
{
this.HandleException(e);
return(true);
});
return(default(TResponse));
}
catch (Exception e)
{
this.HandleException(e);
return(default(TResponse));
}
}
