Serializing query parameters as json

[RavenLiquid]

What I thought wo be a simple thing turns out to be mostly impossible it seems. I'm moving so projects from RestEase to Refit and RestEase seems to have a default behavior that letst you serialize complext objects in query parameters to JSON. Refit does not support this, but more importantly I cannot seems to replicate this via any of the documented ways.

The way I think this should work is the formatter route, but the UrlParameterFormatter does not exactly work as expected and will flatten complex types regardless and give you the separate properties instead of the object.

While trying some other method and inhereting from the query attribute I noticed today that yesterdays release has now made the query attribute sealed so that is out of the windows as well.

Is the only way to make this work rebuilding the entire query string in a DelegatingHandler and replace the Query attribute with a Parameter attribute (which is now also sealed, so no extending this either)?

It would be nice if I could just drop this behavior, but it is used and we are stuck it with.

[ChrisPulman]

Thank you for your feedback, its very useful

[davidvedvick-billee]

@RavenLiquid did you find a way to do this? I'm also working with an API that wants serialized JSON in query parameters.

[glennawatson]

A few updates, and a working approach.

First, QueryAttribute and ParameterAttribute are not sealed in current Refit. The change you saw was not kept, so subclassing is possible again - but you do not need it for this.

To send a complex object as a single JSON-valued query parameter (instead of having Refit flatten it into separate keys), you have two clean options:

1. Serialize to a string yourself and pass it as a string parameter. This is the simplest and most explicit:

public interface IApi
{
    [Get("/search")]
    Task<Result> Search([Query] string filter);
}

// call site
var filter = JsonSerializer.Serialize(new { name = "abc", tags = new[] { 1, 2 } });
await api.Search(filter);

The value is URL-encoded for you, so the JSON travels safely in the query string.

2. Keep a typed parameter but stop Refit from expanding it, using a custom IUrlParameterFormatter plus a marker. The reason your formatter "flattened" the object is that for non-string complex objects Refit walks the properties (BuildQueryMap) before the formatter ever sees the whole object. The way to bypass that walk is to make the value look like a scalar to Refit. The practical lever is [Query(TreatAsString = true)]: when set, Refit calls param.ToString() and treats the result as a single value rather than expanding it.

[Get("/search")]
Task<Result> Search([Query(TreatAsString = true)] FilterDto filter);

public sealed class FilterDto
{
    public string Name { get; set; }
    public int[] Tags { get; set; }
    public override string ToString() => JsonSerializer.Serialize(this);
}

With TreatAsString = true, FilterDto.ToString() (returning JSON) becomes the single query value, URL-encoded.

Option 1 is what most people use and avoids putting serialization in ToString(). There is no need for a DelegatingHandler.