WebAPI Gzip bei der Rückgabe von HttpResponseMessage

Ich habe einen WebAPI-Controller, der eine zurückgibt HttpResponseMessage und ich möchte die gzip-Komprimierung hinzufügen. Dies ist der Servercode:

using System.Net.Http;
using System.Web.Http;
using System.Web;
using System.IO.Compression;

[Route("SomeRoute")]
public HttpResponseMessage Post([FromBody] string value)
{
    HttpContext context = HttpContext.Current;

    context.Response.Filter = new GZipStream(context.Response.Filter, CompressionMode.Compress);

    HttpContext.Current.Response.AppendHeader("Content-encoding", "gzip");
    HttpContext.Current.Response.Cache.VaryByHeaders["Accept-encoding"] = true;

    return new SomeClass().SomeRequest(value);
}

Und dies ist der Client-Code für den Ajax-Aufruf mit jquery:

$.ajax({
    url: "/SomeRoute",
    type: "POST",
    cache: "false",
    data: SomeData,
    beforeSend: function (jqXHR) { jqXHR.setRequestHeader('Accept-Encoding', 'gzip'); },
    success: function(msg) { ... }

Wenn ich dies ausführe, kehrt der Server-Code ohne Fehler zurück, aber der Client-Fehler:

(failed)
net::ERR_CONTENT_DECODING_FAILED

Wenn ich mit Fiddler schaue, sehe ich Folgendes:

Was muss ich ändern, damit der Webdienst gezippte Inhalte zurückgibt, die der Client normal verarbeitet? Ich weiß, dass ich dies auch mit einem HttpModule oder durch eine Einstellung auf IIS tun könnte, aber keine der Optionen passt zum Szenario des Hostings:

Bitte beachten Sie, dass ich nicht nach einer IIS-Einstellung suche, da ich darauf keinen Zugriff habe (Hosting).

Fügen Sie diese NuGet-Pakete hinzu:

Microsoft.AspNet.WebApi.Extensions.Compression.Server System.Net.Http.Extensions.Compression.Client

Dann und fügen Sie eine Codezeile hinzu App_Start\WebApiConfig.cs:

GlobalConfiguration.Configuration.MessageHandlers.Insert(0, new ServerCompressionHandler(new GZipCompressor(), new DeflateCompressor()));

Das wird den Trick tun!

Einzelheiten unter:

• NuGet-Paketseite
• GitHub

Ich hoffe, das hilft.

**Aktualisiert nach Kommentar von @JCisar

Update für ASP.Net Core

Nuget-Paket ist

Microsoft.AspNetCore.ResponseCompression

Wenn Sie Zugriff auf die IIS-Konfiguration haben

Sie können den Header nicht einfach anwenden und hoffen, dass er gezippt wird – die Antwort wird nicht gezippt.

Sie müssen den hinzugefügten Header entfernen und sicherstellen, dass die dynamische Komprimierung und die statische Inhaltskomprimierung auf Ihrem IIS-Server aktiviert sind.

Einer der Kommentatoren hat hier bei stakoverflow einen guten Ressourcenlink erwähnt, der zeigt, wie das geht:

Aktivieren Sie IIS7 gzip

Beachten Sie, dass das Festlegen des Werts in web.config nur funktioniert, wenn die dynamische Komprimierung bereits installiert ist (was nicht in einer Standardinstallation von IIS enthalten ist).

Informationen dazu finden Sie in der MSDN-Dokumentation: http://www.iis.net/configreference/system.webserver/httpcompression

Einfache Komprimierung

Unten finden Sie ein einfaches Beispiel für Ihre eigene Komprimierung. Dieses Beispiel verwendet das Web Api MVC 4-Projekt aus Visual Studio-Projektvorlagen. Damit die Komprimierung für HttpResponseMessages funktioniert, müssen Sie einen benutzerdefinierten MessageHandler implementieren. Siehe unten ein funktionierendes Beispiel.

Siehe die Codeimplementierung unten.

Bitte beachten Sie, dass ich versucht habe, die Methode so zu halten wie in Ihrem Beispiel.

using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web;
using System.Web.Http;

namespace MvcApplication1.Controllers
{
    public class ValuesController : ApiController
    {
        public class Person
        {
            public string name { get; set; }
        }
        // GET api/values
        public IEnumerable<string> Get()
        {
            HttpContext.Current.Response.Cache.VaryByHeaders["accept-encoding"] = true;

            return new [] { "value1", "value2" };
        }

        // GET api/values/5
        public HttpResponseMessage Get(int id)
        {
            HttpContext.Current.Response.Cache.VaryByHeaders["accept-encoding"] = true;

            var TheHTTPResponse = new HttpResponseMessage(System.Net.HttpStatusCode.OK); 
            TheHTTPResponse.Content = new StringContent("{\"asdasdasdsadsad\": 123123123 }", Encoding.UTF8, "text/json"); 

            return TheHTTPResponse;
        }

        public class EncodingDelegateHandler : DelegatingHandler
        {
            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                return base.SendAsync(request, cancellationToken).ContinueWith<HttpResponseMessage>((responseToCompleteTask) =>
                {
                    HttpResponseMessage response = responseToCompleteTask.Result;

                    if (response.RequestMessage.Headers.AcceptEncoding != null &&
                        response.RequestMessage.Headers.AcceptEncoding.Count > 0)
                    {
                        string encodingType = response.RequestMessage.Headers.AcceptEncoding.First().Value;

                        response.Content = new CompressedContent(response.Content, encodingType);
                    }

                    return response;
                },
                TaskContinuationOptions.OnlyOnRanToCompletion);
            }
        }

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

            public CompressedContent(HttpContent content, string encodingType)
            {
                if (content == null)
                {
                    throw new ArgumentNullException("content");
                }

                if (encodingType == null)
                {
                    throw new ArgumentNullException("encodingType");
                }

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

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

                // copy the headers from the original content
                foreach (KeyValuePair<string, IEnumerable<string>> header in originalContent.Headers)
                {
                    this.Headers.TryAddWithoutValidation(header.Key, header.Value);
                }

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

            protected override bool TryComputeLength(out long length)
            {
                length = -1;

                return false;
            }

            protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
            {
                Stream compressedStream = null;

                if (encodingType == "gzip")
                {
                    compressedStream = new GZipStream(stream, CompressionMode.Compress, leaveOpen: true);
                }
                else if (encodingType == "deflate")
                {
                    compressedStream = new DeflateStream(stream, CompressionMode.Compress, leaveOpen: true);
                }

                return originalContent.CopyToAsync(compressedStream).ContinueWith(tsk =>
                {
                    if (compressedStream != null)
                    {
                        compressedStream.Dispose();
                    }
                });
            }
        }
    }
}

Fügen Sie auch den neuen Nachrichtenhandler zur Konfiguration Ihrer App hinzu.

using System.Web.Http;
using MvcApplication1.Controllers;

namespace MvcApplication1
{
    public static class WebApiConfig
    {
        public static void Register(HttpConfiguration config)
        {
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            config.MessageHandlers.Add(new ValuesController.EncodingDelegateHandler());

            config.EnableSystemDiagnosticsTracing();
        }
    }
}

Der Custom Handler wurde zusammengestellt von – Kiran Challa (http://blogs.msdn.com/b/kiranchalla/archive/2012/09/04/handling-compression-accept-encoding-sample.aspx)

Es gibt bessere Beispiele, die auch das Deflationieren eingehender Streams implementieren. Beispiele dafür finden Sie unten:

• http://www.codeproject.com/Articles/557232/Implementing-a-Custom-DelegatingHandler-in-ASP-NET
• http://ronaldrosiernet.azurewebsites.net/blog/2013/07/16/implement_compression_in_aspnet_web_api

Außerdem habe ich auf Github ein wirklich nettes Projekt gefunden, das all dies unterstützt.

• https://github.com/azzlack/Microsoft.AspNet.WebApi.MessageHandlers.Compression

Beachten Sie, dass Simon, während ich selbst zu dieser Antwort gekommen bin, diesen Ansatz vor 2 Tagen nach dem Datum dieser Antwort in Ihren Kommentaren vorgeschlagen hat.

Eine Lösung ohne Bearbeiten einer beliebigen IIS-Einstellung oder Installieren einer beliebigen Nuget Paket ist, a hinzuzufügen MessageHandler zu Ihrer WEB-API.

Dadurch werden Anfragen mit dem „AcceptEncoding“-Header abgefangen und mithilfe von Build in komprimiert System.IO.Komprimierung Bibliotheken.

public class CompressHandler : DelegatingHandler
{
    private static CompressHandler _handler;
    private CompressHandler(){}
    public static CompressHandler GetSingleton()
    {
        if (_handler == null)
            _handler = new CompressHandler();
        return _handler;
    }
    protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
        return base.SendAsync(request, cancellationToken).ContinueWith<HttpResponseMessage>((responseToCompleteTask) =>
        {
            HttpResponseMessage response = responseToCompleteTask.Result;
            var acceptedEncoding =GetAcceptedEncoding(response);
            if(acceptedEncoding!=null)
                response.Content = new CompressedContent(response.Content, acceptedEncoding);

            return response;
        },
        TaskContinuationOptions.OnlyOnRanToCompletion);
    }
    private string GetAcceptedEncoding(HttpResponseMessage response)
    {
        string encodingType=null;
        if (response.RequestMessage.Headers.AcceptEncoding != null && response.RequestMessage.Headers.AcceptEncoding.Any())
        {
            encodingType = response.RequestMessage.Headers.AcceptEncoding.First().Value;
        }
        return encodingType;
    }


}

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

    public CompressedContent(HttpContent content, string encodingType)
    {
        if (content == null)
        {
            throw new ArgumentNullException("content");
        }

        if (encodingType == null)
        {
            throw new ArgumentNullException("encodingType");
        }

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

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

        // copy the headers from the original content
        foreach (KeyValuePair<string, IEnumerable<string>> header in originalContent.Headers)
        {
            this.Headers.TryAddWithoutValidation(header.Key, header.Value);
        }

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

    protected override bool TryComputeLength(out long length)
    {
        length = -1;

        return false;
    }

    protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
    {
        Stream compressedStream = null;

        if (encodingType == "gzip")
        {
            compressedStream = new GZipStream(stream, CompressionMode.Compress, leaveOpen: true);
        }
        else if (encodingType == "deflate")
        {
            compressedStream = new DeflateStream(stream, CompressionMode.Compress, leaveOpen: true);
        }

        return originalContent.CopyToAsync(compressedStream).ContinueWith(tsk =>
        {
            if (compressedStream != null)
            {
                compressedStream.Dispose();
            }
        });
    }
}

Und fügen Sie diesen Handler Ihrer Global.asax.cs hinzu

GlobalConfiguration.Configuration.MessageHandlers.Insert(0, CompressHandler.GetSingleton());

Ein großes Lob an Ben Foster.
ASP.NET-Web-API-Komprimierung

Nur ein Nachtrag zur Aktivierung der Komprimierung in IIS über die applicationHost.config Datei.

Verwenden Sie den IIS-Konfigurationsmanager um die Änderungen vorzunehmen bzw notepad.exe um die Datei zu bearbeiten. Ich benutzte Notepad++ und obwohl die Datei gespeichert wurde, wurde sie tatsächlich nicht gespeichert.

Hat etwas mit 32/64-Bit-Umgebungen, Konfigurationen und den Programmen zu tun, die sie bearbeiten. Meinen Nachmittag ruiniert!!