System.Text.Json should allow any JSON type to be able to deserialzie to string type.

[John0King]

user case

json from a API

//json-a

{
    "Id":"Abc123"
}

//json-b
{
    "Id": 123
}

the mode class

public class Foo
{
     public string Id { get;set;}
}

current System.Text.Json doesn't allow this deserialzation, and it throw on "jsonb" ,
to deserialze this , the model should change the type from string to "JsonNode/JsonElement" . but the "JsonNode/JsonElement" is for dynamic complex type, and for this json model , the best type for the property is string, which means the number version json is wrong (may be because the api is using a dynamic type language like javascript)

suggestion

JsonSeriazlieOptions.StringHanding = JsonStringHanding.AllowAnyType;

public enum JsonStringHanding
{
    Strict,
    AllowNumbersAndBollean,
    AllowAnyType
}

refence

• System.Text.Json ：The JSON value could not be converted to System.String #56760
• The JSON value could not be converted to System.String #37354

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/area-system-text-json, @gregsdennis
See info in area-owners.md if you want to be subscribed.

[eiriktsarpalis]

Per #56760 and #37354 this is something that STJ doesn't permit by design. The suggested workaround is to author a string converter that handles the desired types: (number, boolean or perhaps even object and array).

[elgonzo]

For special cases like these use a JsonConverter. Something like this example converter, which reads any kind of json value as a string, except the json null which will be translated to a null value:

class ReadAsStringConverter : JsonConverter<string>
{
    public override string? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        => JsonElement.ParseValue(ref reader).ToString();

    public override void Write(Utf8JsonWriter writer, string value, JsonSerializerOptions options)
        => _defaultConverter.Write(writer, value, options);

    private static readonly JsonConverter<string> _defaultConverter = (JsonConverter<string>) JsonSerializerOptions.Default.GetConverter(typeof(string));
}

(Side note: Using the default converter like demonstrated here currently doesn't work with collection converters, until issue #50205 is resolved.)

[eiriktsarpalis]

Or if you prefer to avoid the intermediate JsonElement allocation you can do a pattern match directly on the reader:

class ReadAsStringConverter : JsonConverter<string>
{
    public override string? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        return reader.TokenType switch
        {
            JsonTokenType.Null => null,
            JsonTokenType.String => reader.GetString(),
            JsonTokenType.False => "false",
            JsonTokenType.True => "true",
            JsonTokenType.Number => 
                reader.TryGetDouble(out double number)
                ? number.ToString()
                : JsonElement.ParseValue(ref reader).ToString(),

            _ => throw new JsonException(),
        };
    }

    public override void Write(Utf8JsonWriter writer, string value, JsonSerializerOptions options)
    {
        if (value is null)
        {
            writer.WriteNullValue();
        }
        else
        {
            writer.WriteStringValue(value);
        }
    }
}

[elgonzo]

reader.TryGetDouble(out double number)
   ? number.ToString()
   : JsonElement.ParseValue(ref reader).ToString(),

That's giving inaccurate/incorrect results because of converting the json number into an inherent imprecise binary floating point type. As a result, large integers with very large absolute values (including such that would be otherwise readable as long/ulong) and some particular real numbers would not be correctly converted to strings. Neither would be trailing fractional zeros preserved (as would be possible when the deserialization target were a decimal).

The conversion can be made in a way to preserve the the original json number accurately (i guess):

    ...
    JsonTokenType.Number =>
        Encoding.UTF8.GetString(reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan),
    ...