Func <HttpClient, CancellationToken, object[], Task <T> > BuildCancellableTaskFuncForMethod <T>(RestMethodInfo restMethod) { return(async(client, ct, paramList) => { if (client.BaseAddress == null) { throw new InvalidOperationException("BaseAddress must be set on the HttpClient instance"); } var factory = BuildRequestFactoryForMethod(restMethod.Name, client.BaseAddress.AbsolutePath, restMethod.CancellationToken != null); var rq = factory(paramList); HttpResponseMessage resp = null; var disposeResponse = true; try { resp = await client.SendAsync(rq, HttpCompletionOption.ResponseHeadersRead, ct).ConfigureAwait(false); if (restMethod.SerializedReturnType == typeof(HttpResponseMessage)) { disposeResponse = false; // caller has to dispose // NB: This double-casting manual-boxing hate crime is the only way to make // this work without a 'class' generic constraint. It could blow up at runtime // and would be A Bad Idea if we hadn't already vetted the return type. return (T)(object)resp; } if (!resp.IsSuccessStatusCode) { disposeResponse = false; throw await ApiException.Create(rq.RequestUri, restMethod.HttpMethod, resp, restMethod.RefitSettings).ConfigureAwait(false); } if (restMethod.SerializedReturnType == typeof(HttpContent)) { disposeResponse = false; // caller has to clean up the content return (T)(object)resp.Content; } if (restMethod.SerializedReturnType == typeof(Stream)) { disposeResponse = false; // caller has to dispose return (T)(object)await resp.Content.ReadAsStreamAsync().ConfigureAwait(false); } using (var stream = await resp.Content.ReadAsStreamAsync().ConfigureAwait(false)) using (var reader = new StreamReader(stream)) { if (restMethod.SerializedReturnType == typeof(string)) { return (T)(object)await reader.ReadToEndAsync().ConfigureAwait(false); } using (var jsonReader = new JsonTextReader(reader)) { return serializer.Deserialize <T>(jsonReader); } } } finally { // Ensure we clean up the request // Especially important if it has open files/streams rq.Dispose(); if (disposeResponse) { resp?.Dispose(); } } }); }
ValidationApiException(ApiException apiException) : base(apiException.RequestMessage, apiException.HttpMethod, apiException.StatusCode, apiException.ReasonPhrase, apiException.Headers, apiException.RefitSettings) { }
Func <HttpClient, CancellationToken, object[], Task <T> > BuildCancellableTaskFuncForMethod <T, TBody>(RestMethodInfo restMethod) { return(async(client, ct, paramList) => { if (client.BaseAddress == null) { throw new InvalidOperationException("BaseAddress must be set on the HttpClient instance"); } var factory = BuildRequestFactoryForMethod(restMethod, client.BaseAddress.AbsolutePath, restMethod.CancellationToken != null); var rq = await factory(paramList).ConfigureAwait(false); HttpResponseMessage resp = null; HttpContent content = null; var disposeResponse = true; try { resp = await client.SendAsync(rq, HttpCompletionOption.ResponseHeadersRead, ct).ConfigureAwait(false); content = resp.Content ?? new StringContent(string.Empty); if (restMethod.SerializedReturnType == typeof(HttpResponseMessage)) { disposeResponse = false; // caller has to dispose // NB: This double-casting manual-boxing hate crime is the only way to make // this work without a 'class' generic constraint. It could blow up at runtime // and would be A Bad Idea if we hadn't already vetted the return type. return (T)(object)resp; } if (!resp.IsSuccessStatusCode) { disposeResponse = false; var exception = await ApiException.Create(rq, restMethod.HttpMethod, resp, restMethod.RefitSettings).ConfigureAwait(false); if (restMethod.IsApiResponse) { return ApiResponse.Create <T>(resp, default(T), exception); } throw exception; } var serializedReturnType = restMethod.IsApiResponse ? restMethod.SerializedGenericArgument : restMethod.SerializedReturnType; if (serializedReturnType == typeof(HttpContent)) { disposeResponse = false; // caller has to clean up the content if (restMethod.IsApiResponse) { return ApiResponse.Create <T>(resp, content); } return (T)(object)content; } if (serializedReturnType == typeof(Stream)) { disposeResponse = false; // caller has to dispose var stream = (object)await content.ReadAsStreamAsync().ConfigureAwait(false); if (restMethod.IsApiResponse) { return ApiResponse.Create <T>(resp, stream); } return (T)stream; } if (serializedReturnType == typeof(string)) { using (var stream = await content.ReadAsStreamAsync().ConfigureAwait(false)) using (var reader = new StreamReader(stream)) { var str = (object)await reader.ReadToEndAsync().ConfigureAwait(false); if (restMethod.IsApiResponse) { return ApiResponse.Create <T>(resp, str); } return (T)str; } } var body = await serializer.DeserializeAsync <TBody>(content); if (restMethod.IsApiResponse) { return ApiResponse.Create <T>(resp, body); } // Unfortunate side-effect of having no 'class' or 'T : TBody' constraints. // However, we know that T must be the same as TBody because IsApiResponse != true so // this code is safe at runtime. return (T)(object)body; } finally { // Ensure we clean up the request // Especially important if it has open files/streams rq.Dispose(); if (disposeResponse) { resp?.Dispose(); content?.Dispose(); } } }); }
internal static T Create <T>(HttpResponseMessage resp, object content, ApiException error = null) { return((T)Activator.CreateInstance(typeof(T), resp, content, error)); }
/// <summary> /// Creates a new instance of a ValidationException from an existing ApiException. /// </summary> /// <param name="exception">An instance of an ApiException to use to build a ValidationException.</param> /// <returns>ValidationApiException</returns> public static ValidationApiException Create(ApiException exception) { return(new ValidationApiException(exception)); }