private static void ProcessResponse(IRestRequest request, HttpResponse httpResponse,
RestRequestAsyncHandle asyncHandle, Action <IRestResponse, RestRequestAsyncHandle> callback)
{
RestResponse restResponse = ConvertToRestResponse(request, httpResponse);
callback(restResponse, asyncHandle);
}
/// <summary>
/// Executes the request asynchronously, authenticating if needed
/// </summary>
/// <param name="request">Request to be executed</param>
/// <param name="token">The cancellation token</param>
public virtual Task <IRestResponse> ExecuteTaskAsync(IRestRequest request, CancellationToken token)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
TaskCompletionSource <IRestResponse> taskCompletionSource = new TaskCompletionSource <IRestResponse>();
try
{
RestRequestAsyncHandle async = this.ExecuteAsync(
request,
(response, _) =>
{
if (token.IsCancellationRequested)
{
taskCompletionSource.TrySetCanceled();
}
// Don't run TrySetException, since we should set Error
// properties and swallow exceptions to be consistent
// with sync methods
else
{
taskCompletionSource.TrySetResult(response);
}
});
#if !WINDOWS_PHONE
CancellationTokenRegistration registration =
#endif
token.Register(() =>
{
async.Abort();
taskCompletionSource.TrySetCanceled();
});
#if !WINDOWS_PHONE
taskCompletionSource.Task.ContinueWith(t => registration.Dispose(), token);
#endif
}
catch (Exception ex)
{
taskCompletionSource.TrySetException(ex);
}
return(taskCompletionSource.Task);
}
private RestRequestAsyncHandle ExecuteAsync(IRestRequest request,
Action <IRestResponse, RestRequestAsyncHandle> callback, string httpMethod,
Func <IHttp, Action <HttpResponse>, string, HttpWebRequest> getWebRequest)
{
IHttp http = this.HttpFactory.Create();
this.AuthenticateIfNeeded(this, request);
this.ConfigureHttp(request, http);
RestRequestAsyncHandle asyncHandle = new RestRequestAsyncHandle();
Action <HttpResponse> responseCb = r => ProcessResponse(request, r, asyncHandle, callback);
if (this.UseSynchronizationContext && SynchronizationContext.Current != null)
{
SynchronizationContext ctx = SynchronizationContext.Current;
Action <HttpResponse> cb = responseCb;
responseCb = resp => ctx.Post(s => cb(resp), null);
}
asyncHandle.WebRequest = getWebRequest(http, responseCb, httpMethod);
return(asyncHandle);
}
private void DeserializeResponse <T>(IRestRequest request, Action <IRestResponse <T>,
RestRequestAsyncHandle> callback, IRestResponse response, RestRequestAsyncHandle asyncHandle)
{
IRestResponse <T> restResponse;
try
{
restResponse = this.Deserialize <T>(request, response);
}
catch (Exception ex)
{
restResponse = new RestResponse <T>
{
Request = request,
ResponseStatus = ResponseStatus.Error,
ErrorMessage = ex.Message,
ErrorException = ex
};
}
callback(restResponse, asyncHandle);
}
