How to bind Json Query string in asp.net core web api

I came along this question because I have a similar problem. In my scenario it was more convinient to implement ModelBinderAttribute:

public class FromUriJsonAttribute : ModelBinderAttribute
{
    public FromUriJsonAttribute()
    {
        BinderType = typeof(JsonBinder);
    }

    public FromUriJsonAttribute(string paramName)
        : this()
    {
        Name = paramName;
    }
}

As in @MindingData answer the binder is needed:

public class JsonBinder : IModelBinder
{
    public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
    {
        try
        {
            var name = bindingContext.ModelName;
            var json = actionContext.Request.GetQueryNameValuePairs().FirstOrDefault(x => x.Key == name).Value;
            var targetType = bindingContext.ModelType;
            var model = Newtonsoft.Json.JsonConvert.DeserializeObject(json, targetType);
            bindingContext.Model = model;
            return true;
        }
        catch
        {
        }
        return false;
    }
}

And the usage:

[Route("{id}/items")]
public Item GetItem(string id, [FromUriJson] Filter filter)
{
    //logic
}  

or:

[Route("{id}/items")]
public Item GetItem(string id, [FromUriJson("queryStringKey")] Filter filter)
{
    //logic
} 

It can be useful if you want to have Json formatted query string parameter only in some endpoints and/or don't want to mess with default IServiceCollection configuration by inserting a new IModelBinderProvider implementation.

Unfortunately there is no way to bind JSON in a GET query like you have there. What you are looking for is to use a custom model binder to tell ASP.net Core how you want to bind.

First, you want to build your model for your JSON object.

public class MyCustomModel
{
    public string DeviceName { get; set; }
}

Next you need to build your model binder. A simple example is given below but you would obviously want other checks around if it can be converted, Try/Catch blocks etc. Essentially a model binder tells ASP.net Core how a model should be bound. You might also run into TypeConverters which are given a type, how can I change this to another type during model binding. For now let's just use modelbinders.

public class MyViewModelBinder : IModelBinder
{
    public Task BindModelAsync(ModelBindingContext bindingContext)
    {
        var jsonString = bindingContext.ActionContext.HttpContext.Request.Query["query"];
        MyCustomModel result = JsonConvert.DeserializeObject<MyCustomModel>(jsonString);

        bindingContext.Result = ModelBindingResult.Success(result);
        return Task.CompletedTask;
    }
}

So all we are doing is taking the query string and deserializing it to our model.

Next we build a provider. A provider is what tells ASP.net core which modelbinder to use. In our case it's simple, if the model type is our custom type, then use our custom binder.

public class MyViewModelBinderProvider : IModelBinderProvider
{
    public IModelBinder GetBinder(ModelBinderProviderContext context)
    {
        if (context.Metadata.ModelType == typeof(MyCustomModel))
            return new MyViewModelBinder();

        return null;
    }
}

And the final piece of the puzzle. In our startup.cs, we find where we add MVC services and we insert our model binder to the front of the list. This is important. If we just add our modelbinder to the list, another model binder might think it should be used instead (First in first served), so we might not ever make it to ours. So be sure to insert it at the start.

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc(config => config.ModelBinderProviders.Insert(0, new MyViewModelBinderProvider()));
}

Now we just create an action where we read the data, no attributes required.

[HttpGet]
public void Get(MyCustomModel model)
{

}

Further reading :

• http://dotnetcoretutorials.com/2016/12/28/custom-model-binders-asp-net-core/
• https://learn.microsoft.com/en-us/aspnet/core/mvc/advanced/custom-model-binding