在ASP.NET Web API中为单个请求更改JsonFormatter

Question

I have an action filter defined as follows, registered globally in my Web API project:

public class ResultCasingFilter : IActionFilter
{
    private static JsonMediaTypeFormatter _pascalCasingFormatter;
    private static JsonMediaTypeFormatter _camelCasingFormatter;

    // Constructor that initializes formatters left out for brevity

    public Task<HttpResponseMessage> ExecuteActionFilterAsync(HttpActionContext actionContext, CancellationToken cancellationToken, Func<Task<HttpResponseMessage>> continuation)
    {
        actionContext.RequestContext.Configuration.Formatters.Clear();
        actionContext.RequestContext.Configuration.Formatters.Add(
            ResponseShouldBePascalCased(actionContext)
            ? _pascalCasingFormatter
            : _camelCasingFormatter);
        return continuation();
    }

    private static bool ResponseShouldBePascalCased(HttpActionContext actionContext)
    {
        return actionContext.ActionDescriptor
            .GetCustomAttributes<PascalCasedResultAttribute>().Any();
    }

    public bool AllowMultiple { get { return false; } }
}

This works quite well, but I seem to be getting interference between requests; if I issue one request at a time to action methods where one has the PascalCasedResultAttribute and one doesn't, everything works as expected - but if I issue two very close to each-other, both sometimes end up with the same casing.

I interpret this behavior as a sign that the changes to actionContext.RequestContext.Configuration.Formatters really changes the configuration for the entire app, and not just for the current request, and sometimes the requests overlap. Basically, I've based my solution on the following sequence of events:

1. Request 1 chooses its serializer
2. Request 1 is serialized using the last chosen serializer
3. Request 2 chooses its serializer
4. Request 2 is serialized using the last chosen serializer

Note that if step two and three change order, the behavior is changed. What I want is rather

1. Request 1 chooses its serializer
2. Request 1 is serialized using serializer 1
3. Request 2 chooses its serializer
4. Request 2 is serialized using serializer 2

where I (or the framework) can switch order of 2 and 3 without changing the behavior.

How do I best accomplish this?

Answer 1

The problem is that you are changing a global variable, which obviously is not consistent on ordering.

What you could do is manually serialize in the action and just return the string as appropriate.

You can either then supply a flag to choose which serializer to use in your request or use cookies to remember the client's choice.

Answer 2

I ended up doing the following instead:

public Task<HttpResponseMessage> ExecuteActionFilterAsync(HttpActionContext actionContext, CancellationToken cancellationToken, Func<Task<HttpResponseMessage>> continuation)
{
    // Let the action method execute, resulting in a serialized response
    var responseMessage = await continuation();

    if (responseMessage.Content is ObjectContent)
    {
        // Get the message content in its unserialized form, and choose formatter
        var content = responseMessage.Content as ObjectContent;
        var formatter = ResponseShouldBePascalCased(actionContext)
                        ? _pascalCasingFormatter
                        : _camelCasingFormatter;

        // Re-serialize content, with the correctly chosen formatter
        responseMessage.Content = new ObjectContent(content.ObjectType, content.Value, 
                                                    formatter);
    }
    // Return the (possibly) re-serialized message
    return responseMessage;
}

The main hurdle for me to jump before I got to this solution was to realize that I could await continuation() to let the action method execute, and then work with the response.

This approach still has the downside that if the client asks for eg XML, it will still get JSON, because I'm choosing the serializer manually without looking at the Accepts header. In my use case I'm totally OK with that, since we're only using JSON anyway, but if it does matter to you, then you need something more complicated in place of the ternary statement I have where the formatter is chosen. (If there is a simple way to do this only for stuff that's been serialized to a given format, I'd be happy to learn about it!)