System.Text.Json and deserializing that fails when null is received for non-nullable property

[MartyIX]

Hi Team,

I have this snippet

using System.Diagnostics;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace Example;

public class Program
{
    public static void Main(string[] args)
    {
        string json = "{\"name\": null}";
        
        // I would love this to throw an exception because Name should not be null.
        SomeClass sc = JsonSerializer.Deserialize<SomeClass>(json)!; 
        Debug.Assert(sc.Name != null);
    }
}

public class SomeClass
{
    // [Required] // this didn't help to enforce that this property can't be null.
    // [NotNull] // this didn't help to enforce that this property can't be null.
    [JsonPropertyName("name")]
    public string Name { get; }

    [JsonConstructor]
    public SomeClass(string name)
    {
        this.Name = name;
    }
}

and I'm looking for a way to forbid SomeClass.Name to be null (and throw an exception) when deserializing JSON as I use https://docs.microsoft.com/en-us/dotnet/csharp/nullable-references in my program. Currently, I need to check all the values by hand that they are not null.

cc @dotnet/area-system-text-json

[bjornen77]

Maybe adding the null check in the ctor is ok for you?

[JsonConstructor]
public SomeClass(string name)
{
    ArgumentNullException.ThrowIfNull(name);
    this.Name = name;
}

Or you can use the IJsonOnDeserialized interface:

public class SomeClass : IJsonOnDeserialized
{
    [JsonInclude]
    [JsonPropertyName("name")]
    public string Name { get; private set; } = null!;

    void IJsonOnDeserialized.OnDeserialized()
    {
        if (Name is null)
        {
            throw new InvalidOperationException("Name property cannot be 'null'");
        }
    }
}

But I agree, having the [Required] attribute would have been the greatest option. Hopefully the [Required] attribute will be added in a future release.

[MartyIX]

I have first tried your first option and then we have found IJsonOnDeserialized. So yes, these are options but really it's a lot of repetitive code if one wants to do it correctly. [Required] is less verbose but ultimately it's just that because one has to carefully annotate everything - so it's bug prone.

I tend to think that it would be great if it were handled by STJ automatically with some option (RespectNullableReferenceTypes?). It seems it would be a great feature because one can then rely on input being syntactically correct.

Maybe I'm missing something though.

[bjornen77]

As far as I know, no other options exists today.

[MartyIX]

With some more thinking, not everybody is using NRT so it probably makes sense how it was implemented.

As far as I know, no other options exists today.

Yeah, it would be great to know if others would find this useful too.

[bjornen77]

This is now possible in .NET 7:
https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/required-properties

Update: The required properties above does not solve the problem. However, there are some limited support for non-nullable reference type enforcement in .NET 9:
https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/nullable-annotations

[MartyIX]

Thanks!

[Steve-OH]

This doesn't seem to work. The required modifier or the [JsonRequired] attribute both cause the deserializer to throw if the property is absent, but neither cause the deserializer to throw if the property is present with a value of null (C# 11, .NET 7.0).

public class AClass
{
    [JsonPropertyName("email")]
    public required string Email { get; set; }
}

...

// this test passes

[Test]
public void ApiContractMissingEmailShouldThrow()
{
    const string JSON = """{ "foo": "bar" }""";
    Assert.Throws<JsonException>(() =>
    {
        JsonSerializer.Deserialize<AClass>(JSON);
    });
}

// this test fails

[Test]
public void ApiContractNullEmailShouldThrow()
{
    const string JSON = """{ "email": null }""";
    Assert.Throws<JsonException>(() =>
    {
        JsonSerializer.Deserialize<AClass>(JSON);
    });
}

[ashikns]

+1, this only works if the value is missing. If it's null no error is thrown. Would love to see a default implementation for this as part of sdk or at least official documentation on how to implement this.

[bjornen77]

Starting in .NET 9, JsonSerializer has (limited) support for non-nullable reference type enforcement in both serialization and deserialization.
https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/nullable-annotations