Wie zu verwenden ETag in Web-API über die Aktion filter zusammen mit HttpResponseMessage

Meine Anforderung war der cache mein web-api-JSON-Antworten... Und all die Lösungen nicht leicht, "link", wo die Daten generiert werden - sprich in der Steuerung...

Also meine Lösung war die Erstellung einer wrapper "CacheableJsonResult" generiert eine Antwort, und fügte dann den ETag in die Kopfzeile. Dies ermöglicht eine etag übergeben werden, wenn die controller-Methode generiert, und will wieder den Inhalt...

public class CacheableJsonResult<T> : JsonResult<T>
{
    private readonly string _eTag;
    private const int MaxAge = 10;  //10 seconds between requests so it doesn't even check the eTag!

    public CacheableJsonResult(T content, JsonSerializerSettings serializerSettings, Encoding encoding, HttpRequestMessage request, string eTag)
        :base(content, serializerSettings, encoding, request)
    {
        _eTag = eTag;
    }

    public override Task<HttpResponseMessage> ExecuteAsync(System.Threading.CancellationToken cancellationToken)
    {
        Task<HttpResponseMessage> response = base.ExecuteAsync(cancellationToken);

        return response.ContinueWith<HttpResponseMessage>((prior) =>
        {
            HttpResponseMessage message = prior.Result;

            message.Headers.ETag = new EntityTagHeaderValue(String.Format("\"{0}\"", _eTag));
            message.Headers.CacheControl = new CacheControlHeaderValue
            {
                Public = true,
                MaxAge = TimeSpan.FromSeconds(MaxAge)
            };

            return message;
        }, cancellationToken);
    }
}

Und dann im controller - Rendite-dieses Objekt:

[HttpGet]
[Route("results/{runId}")]
public async Task<IHttpActionResult> GetRunResults(int runId)
{               
    //Is the current cache key in our cache?
    //Yes - return 304
    //No - get data - and update CacheKeys
    string tag = GetETag(Request);
    string cacheTag = GetCacheTag("GetRunResults");  //you need to implement this map - or use Redis if multiple web servers

    if (tag == cacheTag )
            return new StatusCodeResult(HttpStatusCode.NotModified, Request);

    //Build data, and update Cache...
    string newTag = "123";    //however you define this - I have a DB auto-inc ID on my messages

    //Call our new CacheableJsonResult - and assign the new cache tag
    return new CacheableJsonResult<WebsiteRunResults>(results, GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings, System.Text.UTF8Encoding.Default, Request, newTag);

    }
}

private static string GetETag(HttpRequestMessage request)
{
    IEnumerable<string> values = null;
    if (request.Headers.TryGetValues("If-None-Match", out values))
        return new EntityTagHeaderValue(values.FirstOrDefault()).Tag;

    return null;
}

Müssen Sie definieren, wie Granulat, um Ihre tags, für meine Daten ist user-spezifisch, so dass ich auch die UserId in der CacheKey (etag)

Fand ich CacheCow sehr aufgebläht, was es bedeutet, wenn der einzige Grund ist, um den Betrag an Daten übertragen, möchten Sie vielleicht so etwas wie dieses:

public class EntityTagContentHashAttribute : ActionFilterAttribute
{
    private IEnumerable<string> _receivedEntityTags;

    private readonly HttpMethod[] _supportedRequestMethods = {
        HttpMethod.Get,
        HttpMethod.Head
    };

    public override void OnActionExecuting(HttpActionContext context) {
        if (!_supportedRequestMethods.Contains(context.Request.Method))
            throw new HttpResponseException(context.Request.CreateErrorResponse(HttpStatusCode.PreconditionFailed,
                "This request method is not supported in combination with ETag."));

        var conditions = context.Request.Headers.IfNoneMatch;

        if (conditions != null) {
            _receivedEntityTags = conditions.Select(t => t.Tag.Trim('"'));
        }
    }

    public override void OnActionExecuted(HttpActionExecutedContext context)
    {
        var objectContent = context.Response.Content as ObjectContent;

        if (objectContent == null) return;

        var computedEntityTag = ComputeHash(objectContent.Value);

        if (_receivedEntityTags.Contains(computedEntityTag))
        {
            context.Response.StatusCode = HttpStatusCode.NotModified;
            context.Response.Content = null;
        }

        context.Response.Headers.ETag = new EntityTagHeaderValue("\"" + computedEntityTag + "\"", true);
    }

    private static string ComputeHash(object instance) {
        var cryptoServiceProvider = new MD5CryptoServiceProvider();
        var serializer = new DataContractSerializer(instance.GetType());

        using (var memoryStream = new MemoryStream())
        {
            serializer.WriteObject(memoryStream, instance);
            cryptoServiceProvider.ComputeHash(memoryStream.ToArray());

            return String.Join("", cryptoServiceProvider.Hash.Select(c => c.ToString("x2")));
        }
    }
}

Nicht einrichten zu müssen nichts, einstellen und vergessen. So wie ich es mag. 🙂

Scheint ein schöner Weg, es zu tun:

public class CacheControlAttribute : System.Web.Http.Filters.ActionFilterAttribute
{
    public int MaxAge { get; set; }

    public CacheControlAttribute()
    {
        MaxAge = 3600;
    }

    public override void OnActionExecuted(HttpActionExecutedContext context)
    {
        if (context.Response != null)
        {
            context.Response.Headers.CacheControl = new CacheControlHeaderValue
            {
                Public = true,
                MaxAge = TimeSpan.FromSeconds(MaxAge)
            };
            context.Response.Headers.ETag = new EntityTagHeaderValue(string.Concat("\"", context.Response.Content.ReadAsStringAsync().Result.GetHashCode(), "\""),true);
        }
        base.OnActionExecuted(context);
    }
}