Reduce verbosity and pain for working with JSON in C#

[Nefcanto]

Consider this JSON:

{
  "return": {
    "status": 200,
    "message": "Approved"
  },
  "entries": [
    {
      "messageId": 1466447495,
      "message": "Your verification code: 23298",
      "status": 5,
      "statusText": "Sent",
      "sender": "1000551451",
      "receptor": "918181818181818181",
      "date": 1701615164
    }
  ]
}

Let's check if it has entries property, and the entries property is array and it has at least one element, then get the message property if it exists.

This is the JS code:

if (json.entries && json.entries.map && json.entries.length > 0) {
    const message = json.entries[0]?.message
}

This is the Python code:

_json = json.loads(json_string)
if 'entries' in _json and isinstance(_json['entries'], list) and len(_json['entries']) > 0:
    first_entry = _json['entries'][0]
    if 'message' in first_entry:
        message = first_entry['message']

More verbose, but still bearable.

This is the C# code:

var json = JsonSerializer.Deserialize<dynamic>(jsonString);
if (json is JsonElement jsonElement && jsonElement.TryGetProperty("entries", out JsonElement entries) &&  entries.ValueKind == JsonValueKind.Array && entries.GetArrayLength() > 0)
{
    var firstEntry = entries[0];
    if (firstEntry.TryGetProperty("message", out JsonElement message))
    {
        var message = message.GetString();
    }
}

See the amount of verbosity? More lines of code and less readability.

Please make working with JSON less verbose. Please enhance the DX in working with JSON in C#. It's a pain.
Make it a first-class citizen. Add some keywords.

This is a pseudo-code that could be valuable:

var json = ParseJson(jsongString);
if (json.Has("entries") && json["entries"].IsArray() && json["entries"].Length > 0)
{
    var message = json["entries"][0]?.["message"];
}

[Nefcanto]

I encourage others to add samples from more languages to see how bad C# is in this regard.

I asked ChatGPT and these are some more code examples:

Ruby:

json_object = JSON.parse(json_string)
if json_object.key?('entries') && json_object['entries'].any?
  first_entry = json_object['entries'][0]
  if first_entry.key?('message')
    message = first_entry['message']
    puts message
  end
end

PHP:

$jsonObject = json_decode($jsonString, true);
if (isset($jsonObject['entries']) && count($jsonObject['entries']) > 0) {
    $firstEntry = $jsonObject['entries'][0];
    if (isset($firstEntry['message'])) {
        $message = $firstEntry['message'];
        echo $message;
    }
}

Dart:

var jsonObject = jsonDecode(jsonString);
if (jsonObject.containsKey('entries') && jsonObject['entries'].isNotEmpty) {
var firstEntry = jsonObject['entries'][0];
if (firstEntry.containsKey('message')) {
    var message = firstEntry['message'];
    print(message);
}
}

Kotlin:

val jsonObject = JSONObject(jsonString)
if (jsonObject.has("entries")) {
    val entries = jsonObject.getJSONArray("entries")
    if (entries.length() > 0 && entries.getJSONObject(0).has("message")) {
        val message = entries.getJSONObject(0).getString("message")
        println(message)
    }
}

I don't know if they are valid codes or not. I'm not an expert in those languages. But if they are valid, then C# is truly awful in handling JSON.

[huoyaoyuan]

I can't imagine how you classify the if chains as good. These languages are all terrible at testing nested objects.

[Nefcanto]

@chrisoverzero, are you inviting me to use more verbosity and boilerplate code? Really? Do you expect us to create a static type for any JSON we receive? That's the most boilerplated, verbose answer I've ever seen.

[Nefcanto]

@huoyaoyuan I'm using Python and I'm using C# on a daily basis. I must disagree with you. I always analyze AST (Abstract Syntax Trees) with Python and it's awesome even when it comes to testing nested objects. What is wrong with having multiple nested ifs?

[CyrusNajmabadi]

@chrisoverzero, are you inviting me to use more verbosity and boilerplate code? Really? Do you expect us to create a static type for any JSON we receive? That's the most boilerplated, verbose answer I've ever seen.

I don't see the problem. This is what we do in typescript as well. It allows the shape of the data to be described, ensuring type safety and catching of mistakes.

For example, it's trivial to accidentally write "massage" instead of "message" when having to do everything in a weakly typed fashion.

It's trivial to just write a simple your describing the data, and then use all the static features of c# to with with it.

Play to the strengths of the system. This is what all those other languages would recommend as well.

[CyrusNajmabadi]

What is wrong with having multiple nested ifs?

That's the most boilerplated, verbose answer I've ever seen.

:-)

C# is not Python. It does not aim to be. Your dynamic testing approach makes sense there where everything is dynamic. C# and .net excel in performance and efficiency in static approaches to data processing. Patterns nicely ensure you match a shape while simultaneously extracting the data you need.

If you avoid the strengths of the system and blindly insist on trying to some problems in the weak way that you do so elsewhere, your going to have a bad time.

Finally, we are interested in making these spaces better. But we do so by investing in ways that some the issue holistically. We don't just ape what another language has done as there are often much better ways available to us based on how our entire runtime and type system are designed.

[Unknown6656]

This sounds like you're requesting a library change, not a language / syntax change. I.e., you want the System.Text.Json.*-APIs to be less verbose, but you're not requesting some explicit C# syntax changes, am I correct?

Should that be the case, I'd advise you to forward your question/issue to the following repo:
https://github.com/dotnet/runtime

[HaloFour]

A couple of extension methods could probably wrap all of that up into a single call, but either way, this is a library concern, not a language one.

[HaloFour]

Shouldn't be too hard to accomplish the following with extension methods:

var jsonObject = JsonObject.Parse(...);
if (jsonObject.HasArray("entries", out var entries) && entries.Length > 0) {
    var message = entries[0].GetString("message");
}

[KennethHoff]

I think active patterns would solve this quite nicely. I fail to find the proposal though..

Being able to do something like this:

var json = ParseJson(jsongString);
if (json is JsonArray { entries: [{} firstEntry] } && firstEntry.TryGetProperty("message", out JsonElement message))
{
   var message = message.GetString();
}

Where JsonArray is defined something like this SharpLab

[jnm2]

Proposal for active patterns, aka user-defined positional patterns: #4131

[AoshiW]

I think the JsonNode is the solution to your problem.

using System.Text.Json;
using System.Text.Json.Nodes;

var json = JsonSerializer.Deserialize<JsonNode>(jsonString);
if (json["entries"] is JsonArray array && array.Count > 0)
{
    var message = array[0]["message"].GetValue<string>();
}

[jnm2]

Why not var json = JsonNode.Parse(jsonString);?

[AoshiW]

I didn't use it because I forgot that method existed.

[koszeggy]

I doubt that the existing API would introduce such breaking changes but you can use 3rd party solutions if reducing verbosity is really that important (disclaimer: I am the author, so I hope this is not qualified as an unwanted advertisement).

With the library above the solution is this compact (see also online):

var json = JsonValue.Parse(jsonString);
string message = json["entries"][0]["message"].AsString ?? throw new ArgumentException("Invalid content");

You can do this because getting lost in the hierarchy just returns a default JsonValue, which is the equivalent of JS undefined:

Console.WriteLine(json["entrdries"][-42]["msg"]); // undefined

And here you can compare the verbosity of the different libraries (well, this is when there is no validation; otherwise, other libraries are just even more verbose).

[Trarizon]

How about a struct wrapper of JsonElement like

public readonly struct JsonElementWrapper(JsonElement element)
{
    public JsonElementWrapper? this[int index] => element.ValueKind is JsonValueKind.Array ? new(element[index]) : null;
    public JsonElementWrapper? this[ReadOnlySpan<char> propertyName] => element.ValueKind is JsonValueKind.Object ? new(element.GetProperty(propertyName)) : null;
    public int? ArrayLength => element.ValueKind is JsonValueKind.Array ? element.GetArrayLength() : null;
    public string? AsString() => element.ValueKind is JsonValueKind.String ? element.GetString() : null;
}

and you can write

using var doc = JsonDocument.Parse(jsonString);
var root = new JsonElementWrapper(doc.RootElement);

if (root["entries"] is { ArrayLength: > 0 } entries) {
    var message = entries[0]?["message"]?.AsString();
}

[zms9110750]

I think you think it's long because you used the wrong API.

using Newtonsoft.Json.Linq; 

JObject json = JObject.Parse(jsonString); 
 
if (json["entries"] is JArray { Count: > 0 } jar)
{
	Console.WriteLine(jar[0]["message"]);
} 

[huoyaoyuan]

This can be further simplified with list pattern:

if (json["entries"] is JArray and [first, ..])
{
	Console.WriteLine(first["message"]);
} 

[zms9110750]

@huoyaoyuan can't.
Unhandled exception. System.ArgumentException: Accessed JArray values with invalid key value: 0. Int32 array index expected.
I don't know this is API issue or lang issue.

[CyrusNajmabadi]

@huoyaoyuan can't.
Unhandled exception. System.ArgumentException: Accessed JArray values with invalid key value: 0. Int32 array index expected.
I don't know this is API issue or lang issue.

It's an API issue. The lang provides the constructs, it's up the API to integrate with them.

[elgonzo]

@CyrusNajmabadi

The lang provides the constructs, it's up the API to integrate with them.

Then how is an API supposed to integrate with this? Considering that the exception is thrown on an JArray instance which implements IList<JToken> and has an public JToken this[int index] indexer, i don't see what else would be required for the list pattern to work...

[zms9110750]

@elgonzo

JToken this[int index]

no, it's JToken this[object key].
and it have if ( key not is int) throw
so,list pattern give it Index

[dexcompiler]

Seems easy enough to manage this fluently using the JsonDocument API:

public static string? GetMessage(string json) =>
	JsonDocument.Parse(json).RootElement
		.GetProperty("entries")
		.EnumerateArray()
		.FirstOrDefault()
		.GetProperty("message")
		.GetString();

Arugably more readable and easier on the eyes than the JS/Python/other languages above.

[CyrusNajmabadi]

Closing out as this has been answered. There are incredibly simple ways of working with Jason that people have already provided. And this is due to the support the language gives you. If you want particular apis to integrate better with the language support, you should take it up with the API authors. The language already has the tools to make the consumption as nice (or nicer) than the examples you provided from other languages.