bug(ConfigurationBuilder): Empty value in json read wrong use ConfigurationBuilder on NET10

[ArgoZhang]

Description

Json config

"TestSection": {
  "Test-Null": null,
  "Test-Key:": ""
}

Code

builder.AddJsonFile(jsonPath, true, false);

var config = builder.Build();

var children = config.GetSection("TestSection").GetChildren();

foreach (var child in children)
{
    Console.WriteLine($"{child.Key}: {child.Value}");
}

Result

In NET9.0 (Correct)

section TestSection Test-Key value is string.Empty

In NET10 (Incorrent)

section TestSection Test-Key value is NULL

Reproduction Steps

repro project
ConsoleApp1.zip

Expected behavior

In NET9.0

section TestSection Test-Key value is string.Empty

In NET10

section TestSection Test-Key value is string.Empty

Actual behavior

In NET9.0

section TestSection Test-Key value is string.Empty

In NET10

section TestSection Test-Key value is NULL

Regression?

No response

Known Workarounds

No response

Configuration

No response

Other information

No response

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/area-extensions-configuration
See info in area-owners.md if you want to be subscribed.

[tarekgh]

@ArgoZhang

I’m not sure if what you reported is correct, or perhaps the behavior was observed in reverse? I did a quick test using the following code:

string jsonConfig1 = @"
{
    ""TestSection"": {
        ""Test-Null"" : null,
        ""Test-Empty"" : """"
    }
}";

var configuration = new ConfigurationBuilder()
    .AddJsonStream(new MemoryStream(Encoding.UTF8.GetBytes(jsonConfig1)))
    .Build()
    .GetSection("TestSection");

foreach (var child in configuration.GetChildren())
{
    string childKey = child.Key ?? "null";
    string childValue = child.Value ?? "null";
    Console.WriteLine($"`{childKey}`: `{childValue}`");
}

On .NET 9.0, this produces the following output:

`Test-Empty`: ``
`Test-Null`: ``

That means both values are read as empty strings.
On .NET 10, however, the output is:

`Test-Empty`: ``
`Test-Null`: `null`

This indicates that .NET 10 now correctly preserves null values, which is the intended behavior. You can find more details about this change in the documentation: .NET 10 – Configuration null values preserved.

Also, note that when you call Console.WriteLine(...) with a null value, it prints an empty string. I’ll close this issue for now, but please feel free to reply if you have any further questions.

[ArgoZhang]

@tarekgh I strongly request to try the repro-project I provided.

i had double check it. the result is

Hello, World!
`Test-Key`: `null`
`Test-Null`: `null`

If you use AddJsonStream(stream) the result will be the same as yours. in this repro-project use AddJsonFile

[tarekgh]

@ArgoZhang

I can now reproduce the behavior you described when using a JSON file instead of reading from memory. However, the .NET 10 behavior is still an improvement.

.NET 9.0 behavior:

`Test - Key`: `null`
`Test - Null`: ``

Here, the empty string value is read as null, while the null value is read as an empty string.

.NET 10 behavior:

`Test - Key`: `null`
`Test - Null`: `null`

In this case, the null value is correctly read as null. Only the empty string value is still being read as null, which may be the issue we need to investigate and fix.

In conclusion, .NET 10 shows improved behavior compared to .NET 9, though it’s still not perfect when reading empty string values from files. My guess is that the JSON file reader might be converting actual empty strings to null before passing them to the configuration system.

[tarekgh]

I looked into this further and found that the issue is actually in your configuration. There’s a small typo in your JSON — you added a colon at the end of the key ("Test-Key:"). Removing the colon fixes the problem, and .NET 10 then produces the correct values.

Make sure your JSON looks like this:

"TestSection": {
  "Test-Null": null,
  "Test-Key": ""
}

This should produce the following output:

`Test-Key`: ``
`Test-Null`: `null`

[ArgoZhang]

@tarekgh hi. thank you for the quick reply. I apologize for the typo error.

"TestSection": {
    "Test-Null" : null,
    "Test-Empty" : ""
}

NET9.0

`Test-Empty`: ``
`Test-Null`: ``

NET10.0

`Test-Empty`: ``
`Test-Null`: `null`

It seems that the improvements in .NET 10 were correct, and that .NET 9 was flawed. is right?