Как включить веб-API.Net для приема сообщений g-ziped

Ответ 1

У меня было такое же требование, что и данные POST gzipped для .NET-api-контроллера. Я придумал это решение:

public class GZipToJsonHandler : DelegatingHandler
{
    protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
                                                           CancellationToken cancellationToken)
    {
        // Handle only if content type is 'application/gzip'
        if (request.Content.Headers.ContentType == null ||
            request.Content.Headers.ContentType.MediaType != "application/gzip")
        {
            return base.SendAsync(request, cancellationToken);
        }

        // Read in the input stream, then decompress in to the outputstream.
        // Doing this asynronously, but not really required at this point
        // since we end up waiting on it right after this.
        Stream outputStream = new MemoryStream();
        Task task = request.Content.ReadAsStreamAsync().ContinueWith(t =>
            {
                Stream inputStream = t.Result;
                var gzipStream = new GZipStream(inputStream, CompressionMode.Decompress);

                gzipStream.CopyTo(outputStream);
                gzipStream.Dispose();

                outputStream.Seek(0, SeekOrigin.Begin);
            });

        // Wait for inputstream and decompression to complete. Would be nice
        // to not block here and work async when ready instead, but I couldn't 
        // figure out how to do it in context of a DelegatingHandler.
        task.Wait();

        // This next section is the key...

        // Save the original content
        HttpContent origContent = request.Content;

        // Replace request content with the newly decompressed stream
        request.Content = new StreamContent(outputStream);

        // Copy all headers from original content in to new one
        foreach (var header in origContent.Headers)
        {
            request.Content.Headers.Add(header.Key, header.Value);
        }

        // Replace the original content-type with content type
        // of decompressed data. In our case, we can assume application/json. A
        // more generic and reuseable handler would need some other 
        // way to differentiate the decompressed content type.
        request.Content.Headers.Remove("Content-Type");
        request.Content.Headers.Add("Content-Type", "application/json");

        return base.SendAsync(request, cancellationToken);
    }
}

Используя этот подход, существующий контроллер, который обычно работает с содержимым JSON и автоматической привязкой к модели, продолжает работать без каких-либо изменений.

Я не знаю, почему был принят другой ответ. Он предоставляет решение для обработки ответов (что является общим), но не запросов (что является необычным). Заголовок Accept-Encoding используется для указания допустимых кодировок ответов и не связан с кодировками запросов.

Ответ 2

Я считаю, что правильным ответом является Kaliatech, и я бы оставил это в качестве комментария и проголосовал за него, у меня было достаточно очков репутации, так как я думаю, что он в основном правильный.

Однако моя ситуация требовала взглянуть на тип типа кодировки, а не на тип содержимого. Используя этот подход, вызывающая система все еще может указать, что тип содержимого - это json/xml/etc в типе контента, но укажите, что данные кодируются с использованием gzip или потенциально другого механизма кодирования/сжатия. Это помешало мне изменить тип содержимого после декодирования ввода и разрешить любую информацию типа содержимого в исходном состоянии.

Вот код. Опять же, 99% из этого - ответ Kaliatech, включая комментарии, поэтому, пожалуйста, проголосуйте за его сообщение, если это полезно.

public class CompressedRequestHandler : DelegatingHandler
{
    protected override System.Threading.Tasks.Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)
    {
        if (IsRequetCompressed(request))
        {
            request.Content = DecompressRequestContent(request);
        }

        return base.SendAsync(request, cancellationToken);
    }

    private bool IsRequetCompressed(HttpRequestMessage request)
    {
        if (request.Content.Headers.ContentEncoding != null &&
            request.Content.Headers.ContentEncoding.Contains("gzip"))
        {
            return true;
        }

        return false;
    }

    private HttpContent DecompressRequestContent(HttpRequestMessage request)
    {
        // Read in the input stream, then decompress in to the outputstream.
        // Doing this asynronously, but not really required at this point
        // since we end up waiting on it right after this.
        Stream outputStream = new MemoryStream();
        Task task = request.Content.ReadAsStreamAsync().ContinueWith(t =>
            {
                Stream inputStream = t.Result;
                var gzipStream = new GZipStream(inputStream, CompressionMode.Decompress);

                gzipStream.CopyTo(outputStream);
                gzipStream.Dispose();

                outputStream.Seek(0, SeekOrigin.Begin);
            });

        // Wait for inputstream and decompression to complete. Would be nice
        // to not block here and work async when ready instead, but I couldn't 
        // figure out how to do it in context of a DelegatingHandler.
        task.Wait();

        // Save the original content
        HttpContent origContent = request.Content;

        // Replace request content with the newly decompressed stream
        HttpContent newContent = new StreamContent(outputStream);

        // Copy all headers from original content in to new one
        foreach (var header in origContent.Headers)
        {
            newContent.Headers.Add(header.Key, header.Value);
        }

        return newContent;
    }

Затем я зарегистрировал этот обработчик по всему миру, что может быть рискованным предложением, если вы уязвимы для DoS-атак, но наш сервис заблокирован, поэтому он работает для нас

GlobalConfiguration.Configuration.MessageHandlers.Add(new CompressedRequestHandler());

Ответ 3

Хотя веб-API не поддерживает заголовок Accept-Encoding из коробки, но у Kiran есть потрясающее сообщение в блоге о том, как это сделать - http://blogs.msdn.com/b/kiranchalla/archive/2012/09/04/handling-compression-accept-encoding-sample.aspx - используя пользовательский MessageHandler

Если вы реализуете его решение, все, что вам нужно сделать, это выдать запрос с заголовком Accept-Encoding: gzip или Accept-Encoding: deflate, и ответ веб-API будет сжат в обработчике сообщений для вас.

Ответ 4

попробуйте это

    public class DeCompressedContent : HttpContent
{
    private HttpContent originalContent;
    private string encodingType;

    /// <summary>
    /// 
    /// </summary>
    /// <param name="content"></param>
    /// <param name="encodingType"></param>
    public DeCompressedContent(HttpContent content, string encodingType)
    {

        if (content == null) throw new ArgumentNullException("content");
        if (string.IsNullOrWhiteSpace(encodingType)) throw new ArgumentNullException("encodingType");

        this.originalContent = content;
        this.encodingType = encodingType.ToLowerInvariant();

        if (!this.encodingType.Equals("gzip", StringComparison.CurrentCultureIgnoreCase) && !this.encodingType.Equals("deflate", StringComparison.CurrentCultureIgnoreCase))
        {
            throw new InvalidOperationException(string.Format("Encoding {0} is not supported. Only supports gzip or deflate encoding", this.encodingType));
        }

        foreach (KeyValuePair<string, IEnumerable<string>> header in originalContent.Headers)
        {
            this.Headers.TryAddWithoutValidation(header.Key, header.Value);
        }

        this.Headers.ContentEncoding.Add(this.encodingType);
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="stream"></param>
    /// <param name="context"></param>
    /// <returns></returns>
    protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
    {
        var output = new MemoryStream();

        return this.originalContent
            .CopyToAsync(output).ContinueWith(task =>
            {
                // go to start
                output.Seek(0, SeekOrigin.Begin);

                if (this.encodingType.Equals("gzip", StringComparison.CurrentCultureIgnoreCase))
                {
                    using (var dec = new GZipStream(output, CompressionMode.Decompress))
                    {
                        dec.CopyTo(stream);
                    }
                }
                else
                {
                    using (var def = new DeflateStream(output, CompressionMode.Decompress))
                    {
                        def.CopyTo(stream);
                    }
                }

                if (output != null)
                    output.Dispose();
            });


    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="length"></param>
    /// <returns></returns>
    protected override bool TryComputeLength(out long length)
    {
        length = -1;

        return (false);
    }
}