/// <summary> /// Creates a HttpResponse object from the incoming HttpResponseMessage and parses it's content for the specified type. /// </summary> /// <typeparam name="T">The type of the parsed content.</typeparam> /// <param name="serializer">The IHttpContentSerializer to be used.</param> /// <param name="responseMessage">The recieved HttpResponseMessage to be parsed.</param> /// <param name="cancellationToken">A CancellationToken that can be used to cancel this operation.</param> /// <returns>The HttpResponse instance.</returns> public virtual async Task <HttpResponse <T> > CreateResponseAsync <T>(IHttpContentSerializer serializer, HttpResponseMessage responseMessage, CancellationToken cancellationToken = default) { return(new HttpResponse <T> ( responseMessage.StatusCode, await serializer.DeserializeResponseContentAsync <T>(responseMessage.Content, cancellationToken) )); }
/// <summary> /// Creates a new <see cref="RefitSettings"/> instance with the specified parameters /// </summary> /// <param name="contentSerializer">The <see cref="IHttpContentSerializer"/> instance to use</param> /// <param name="urlParameterFormatter">The <see cref="IUrlParameterFormatter"/> instance to use (defaults to <see cref="DefaultUrlParameterFormatter"/>)</param> /// <param name="formUrlEncodedParameterFormatter">The <see cref="IFormUrlEncodedParameterFormatter"/> instance to use (defaults to <see cref="DefaultFormUrlEncodedParameterFormatter"/>)</param> public RefitSettings( IHttpContentSerializer contentSerializer, IUrlParameterFormatter?urlParameterFormatter = null, IFormUrlEncodedParameterFormatter?formUrlEncodedParameterFormatter = null) { ContentSerializer = contentSerializer ?? throw new ArgumentNullException(nameof(contentSerializer), "The content serializer can't be null"); UrlParameterFormatter = urlParameterFormatter ?? new DefaultUrlParameterFormatter(); FormUrlEncodedParameterFormatter = formUrlEncodedParameterFormatter ?? new DefaultFormUrlEncodedParameterFormatter(); ExceptionFactory = new DefaultApiExceptionFactory(this).CreateAsync; }
/// <summary> /// Creates a new HttpRequestMessage instance for the outgoint request. /// </summary> /// <param name="serializer">The seralizer to be used for the requests content.</param> /// <param name="request">The requests parameteres.</param> /// <param name="cancellationToken">A CancellationToken that can be used to cancel this operation.</param> /// <returns>The HttpRequest instance to be sent.</returns> public virtual async Task <HttpRequestMessage> CreateHttpRequestMessageAsync(IHttpContentSerializer serializer, HttpRequestBase request, CancellationToken cancellationToken = default) { var requestMessage = new HttpRequestMessage(request.Method, await CreateRequestUriAsync(BaseUri, request.RequestUri, request.QueryParameters)); if (request is HttpRequestWithContent requestWithContent && requestWithContent.Content != null) { requestMessage.Content = await serializer.SerializeRequestContentAsync(requestWithContent.Content, cancellationToken); } if (UseGzip) { requestMessage.Headers.AcceptEncoding.Add(new StringWithQualityHeaderValue(GzipEncoding)); requestMessage.Headers.AcceptEncoding.Add(new StringWithQualityHeaderValue(DeflateEncoding)); } foreach (var header in await serializer.CreateAcceptCharsetHeaderValuesAsync()) { requestMessage.Headers.AcceptCharset.Add(header); } foreach (var header in await serializer.CreateAcceptHeaderValuesAsync()) { requestMessage.Headers.Accept.Add(header); } if (request.Headers != null) { foreach (var header in request.Headers) { var headerValue = header.Value.StringValue; if (!string.IsNullOrEmpty(headerValue)) { requestMessage.Headers.Add(header.Key, headerValue); } } } return(requestMessage); }
public HttpSerializer(IServiceProvider provider, ClientConfiguration config) { _provider = provider; _config = config; Serializer = (IHttpContentSerializer)_provider.GetService(_config.Serializer); Deserializers = new Dictionary <string, IHttpContentSerializer>(); foreach (var serType in _config.Deserializers) { var ser = (IHttpContentSerializer)_provider.GetService(serType); foreach (var contentType in ser.ContentTypes ?? Enumerable.Empty <string>()) { if (Deserializers.ContainsKey(contentType)) { Deserializers[contentType] = ser; } else { Deserializers.Add(contentType, ser); } } } }
public CybtansContentSerializer(IHttpContentSerializer defaultSerializer) : this(BinarySerializer.DefaultEncoding, defaultSerializer) { }
public CybtansContentSerializer(Encoding encoding, IHttpContentSerializer defaultSerializer) { _encoding = encoding; _mediaType = $"{BinarySerializer.MEDIA_TYPE}; charset={_encoding.WebName}"; _defaultSerializer = defaultSerializer; }
/// <summary> /// Creates a HttpResponse object from the incoming HttpResponseMessage without parsing it's content. /// </summary> /// <param name="serializer">The IHttpContentSerializer to be used.</param> /// <param name="responseMessage">The recieved HttpResponseMessage to be parsed.</param> /// <param name="cancellationToken">A CancellationToken that can be used to cancel this operation.</param> /// <returns>The HttpResponse instance.</returns> public virtual Task <HttpResponse> CreateResponseAsync(IHttpContentSerializer serializer, HttpResponseMessage responseMessage, CancellationToken cancellationToken = default) { return(Task.FromResult(new HttpResponse(responseMessage.StatusCode))); }
/// <summary> /// Serializes the specified <paramref name="content"/> into a new /// <see cref="HttpContent"/> instance. /// /// This method passes the type of the generic type parameter <typeparamref name="T"/> /// as the content type to the serializer. /// </summary> /// <typeparam name="T"> /// The target type of the object which is supposed to be serialized. /// </typeparam> /// <param name="serializer">The serializer.</param> /// <param name="content"> /// The object to be serialized into a new <see cref="HttpContent"/> instance. /// This can be <see langword="null"/>. /// </param> /// <param name="encoding"> /// An optional encoding to be used by the serializer if it serializes the <paramref name="content"/> /// to an <see cref="HttpContent"/> which requires one. /// If <see langword="null"/>, a default encoding is used. /// </param> /// <returns> /// A new <see cref="HttpContent"/> instance which holds the serialized <paramref name="content"/> /// or <see langword="null"/>. /// </returns> /// <exception cref="ArgumentNullException"> /// * <paramref name="serializer"/> /// </exception> /// <exception cref="HttpContentSerializationException"> /// Serializing the <paramref name="content"/> failed. /// </exception> public static HttpContent?Serialize <T>(this IHttpContentSerializer serializer, T content, Encoding?encoding) { _ = serializer ?? throw new ArgumentNullException(nameof(serializer)); return(serializer.Serialize(content, typeof(T), encoding)); }