18

Consider the code...

using System;
using System.Text.Json;

public class Program
{
    public static void Main()
    {
        int id = 9;
        string str = "{\"id\": " + id + "}";
        var u = JsonSerializer.Deserialize<User>(str);
        Console.WriteLine($"User ID: {u.Id}, Correct: {id == u.Id}");  // always 0/init/default value
    }
}


public class User {
    public int Id { get; set; }
}

Why isn't the data being deserialized properly into the User object? I also verified the behavior via DotNetFiddle in case it was an issue local to my system. No exception is thrown.

My actual implementation is read from an [ApiController]'s [HttpPost] action after I return Created("user", newUser). It is called in my MVC/Razor project via _httpClient.PostAsync. I verified the values are correct when Created is returned to the PostAsync call, but no matter what, the value parsed from the response body contains only default values (the actual ID is a Guid).

I initially thought it might have been an UTF8 related issue, as that is the encoding for the StringContent I post to the ApiController. UTF8 deserialization is referenced here, but I had trouble getting from the IO.Stream of the HttpContent to a ReadOnlySpan or Utf8JsonReader.

I found this project while searching, which makes me think it should work as I expected.

Improve this question
1
  • 1
    It is always a good idea to serialize a sample first to see a sample. I did it and found out that it was looking for Id instead of id it couldn't find it so it takes the default value 0 Commented Feb 8, 2020 at 3:00

4 Answers 4

Reset to default
53

Your problem is that System.Text.Json is case-sensitive by default, so "id": 9 (all lowercase) is not mapped to the Id property. From the docs:

Case-insensitive property matching

By default, deserialization looks for case-sensitive property name matches between JSON and the target object properties. To change that behavior, set JsonSerializerOptions.PropertyNameCaseInsensitive to true:

Note: The web default is case-insensitive.

var options = new JsonSerializerOptions
{
   PropertyNameCaseInsensitive = true,
};
var weatherForecast = JsonSerializer.Deserialize<WeatherForecast>(jsonString, options);

So you need to do that also:

var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
var u = JsonSerializer.Deserialize<User>(str, options);

Note that Microsoft recommends to cache and reuse options for performance reasons.

Demo fiddle #1 here.

(If the difference is entirely due to camel casing and not more general differences in case, you can instead configure the serializer to use camel case as shown in this answer by t.j..)

You can configure the option on startup in ASP.NET Core 3.0 as shown in How to set json serializer settings in asp.net core 3?:

services.AddControllers().AddJsonOptions(options =>
{
    options.JsonSerializerOptions.PropertyNameCaseInsensitive = true;
});

Alternatively you could apply [JsonPropertyName("id")] to your model:

public class User {
    [JsonPropertyName("id")]
    public int Id { get; set; }
}

Demo fiddle #2 here.

Update for .NET 9: In .NET 9 and later you can deserialize using the global default options JsonSerializerOptions.Web which sets both PropertyNameCaseInsensitive and CamelCase by default:

var u = JsonSerializer.Deserialize<User>(str, JsonSerializerOptions.Web);

Demo fiddle #3 here.

Improve this answer
Sign up to request clarification or add additional context in comments.

8 Comments

correct, plus extra useful info regarding config... marking as solution
If you expect all properties in the JSON to be camel-cased instead, an alternative to using PropertyNameCaseInsensitive is to set the PropertyNamingPolicy to CamelCase explicitly and leave the comparison as the default/case-sensitive.
Using JsonNamingPolicy.CamelCase is generally more performant (with case sensitive comparison) compared to opting for case insensitive comparison. Otherwise, setting both, like asp.net core does, works as well.
in startup this should be like this or will give error options.JsonSerializerOptions.PropertyNameCaseInsensitive = true;
I've lost 3 hours trying to understand why it doesn't work, and it was all for case sensitivity . Thanks man
|
3

Thanks to mr5 who suggested it was a casing issue via chat.

Changing the string to use TitleCase ("Id") solves the issue.

I was in the process of submitting a ticket, and one of the possibly related issues comments lead me to another issue, which lead to the documentation, which has a solution

var options = new JsonSerializerOptions();
options.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;

Using the options, solves the problem...

string str = "{\"id\": " + id + "}";
var options = new JsonSerializerOptions();
options.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
var u = JsonSerializer.Deserialize<User>(str, options);

Leaving this all up in case it helps someone else.

Improve this answer

1 Comment

The doc pages might be helpful as well. Specifically learn.microsoft.com/en-us/dotnet/standard/serialization/… Regarding the discussion from the chat (quoted here: "weird that it isnt an issue elsewhere ([FromBody] handles it just fine"), that's because of the default options are configured differently within aspnet: github.com/dotnet/aspnetcore/blob/…
1

You can also read this microsoft documentation JSON Serialization, for the configuration you can use the following:

JsonSerializerOptions _jsonOptions = new(JsonSerializerDefaults.Web);
var serialized = JsonSerializer.Serialize(data, _jsonOptions);
var deserialized = JsonSerializer.Deserialize<TEntity>(serialized , _jsonOptions);

JsonSerializerDefaults.Web it is a predefined enum setting like "camelCase value", "case-insensitive property names", etc, check this JsonSerializerDefaults.? , if you want to customize you would check the documentation again here

Improve this answer

Comments

-1

In ConfigureServices at Startup.cs

services.AddControllers()
        .AddJsonOptions(o => {
            o.JsonSerializerOptions.PropertyNamingPolicy=JsonNamingPolicy.CamelCase;
            o.PropertyNameCasInsensitive=true
        });
Improve this answer

1 Comment

PropertyNameCasInsensitive has a typo and isn't found directly in o but rather in JsonSerializerOptions so it should be o.JsonSerializerOptions.PropertyNameCaseInsensitive

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.