TL;DR
JMESPath is a powerful query language that enables processing of JSON payloads. It can be used in .NET, see JmesPath.Net.
Source code: https://github.com/NikiforovAll/jmespath-demo
Introduction
JSON processing is a common task in the day-to-day work of developers. We are used to working with JSON, but, occasionally, we need something more dynamic and efficient than System.Text.Json and Newtonsoft.Json. JMESPath is a powerful query language that allows you to perform Map/Reduce tasks in a declarative and intuitive manner.
JMESPath is simple to use, the query itself is just a plain string. The benefit of this approach is that you can follow the inversion of control principle and give your users the control of writing JMESPath queries.
💡 For example, the Azure CLI uses the –query parameter to execute a JMESPath query on the results of commands.
public sealed class JmesPath
{
public string Transform(string json, string expression);
}
Demo
Read a random example of JSON string from a file:
var source = new StreamReader("./example.json").ReadToEnd();
The content of the file:
{
"_id": "63ba60670fe420f2fb346866",
"isActive": true,
"balance": "$2,285.51",
"age": 20,
"eyeColor": "blue",
"name": "Eva Sharpe",
"email": "evasharpe@zaggles.com",
"phone": "+1 (950) 479-2130",
"registered": "2023-01-08T08:07:44.1787922+00:00",
"latitude": 46.325291,
"longitude": 5.211461,
"friends": [
{
"id": 0,
"name": "Nielsen Casey",
"age": 19
},
{
"id": 1,
"name": "Carlene Long",
"age": 38
}
]
}
The code below shows the processing of the example payload above. It demonstrates different concepts such as projections, filtering, aggregation, type transformation, etc. I think the syntax is quite intuitive and doesn’t need an explanation.
The processing is quite simple:
var expressions = new (string, string)[]
{
("scalar", "balance"),
("projection", "{email: email, name: name}"),
("functions", "to_string(latitude)"),
("arrays", "friends[*].name"),
("filtering", "friends[?age > `20`].name"),
("aggregation", "{sum: sum(friends[*].age), names: join(',', friends[*].name)}"),
("now. ISO 8601", "now()"),
("now. Universal sortable date/time pattern", "now('u')"),
("now. Long date pattern", "now('D')"),
("format", "date_format(registered, 'd')"),
};
foreach (var (exampleName, expression) in expressions)
{
var result = parser.Transform(source, expression);
}
Extensibility
The cool thing about JMESPath is it provides a way to add custom functions. See more details: https://github.com/jdevillard/JmesPath.Net/issues/81
For example, here is how we can write now() function that accepts .NET string format provider, see the Microsoft docs https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-date-and-time-format-strings.
public class NowFunction : JmesPathFunction
{
private const string DefaultDateFormat = "o";
public NowFunction() : base("now", minCount: 0, variadic: true) { }
public override JToken Execute(params JmesPathFunctionArgument[] args)
{
var format = args is { Length: > 0 } x
? x[0].Token
: DefaultDateFormat;
return new JValue(DateTimeOffset.UtcNow.ToString(format.ToString()));
}
}
Summary
As you can see, JMESPath solves the issues of dynamic JSON processing based on user input quite nicely. It has an extensibility model that opens tons of possibilities.
Top comments (0)