I need to modify the value of string type if the property name is "xyz" in JsonConverter<string> using System.Text.Json

Question

I don't want to decorate my properties with this converter like

[JsonConverter(typeof(CustomJsonConverter))]
public string xyz {get;set;}

I need to use it like this

JsonSerializerOptions _options = new()
{
    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
    PropertyNameCaseInsensitive = true,
    Converters = { new CustomJsonConverter() }
};

var result = JsonSerializer.DeserializeAsync<T>(stream, _options);

public class CustomJsonConverter : JsonConverter<string>
{
    public override string Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
         if (reader.TokenType == JsonTokenType.PropertyName)
         {
             var propertyName = reader.GetString();

             if (propertyName == "xyz")
             {
                  reader.Read(); // Move to the property value
                  string originalValue = reader.GetString();

                  // Modify the string value (e.g., add a prefix)
                 string modifiedValue = "Modified: " + originalValue;

                 return modifiedValue;
            }
        }

        return reader.GetString();
    }

    public override void Write(Utf8JsonWriter writer, string value, JsonSerializerOptions options)
    {
        // Write the value as a string
        writer.WriteStringValue(value);
    }
}

reader.TokenType is always equals to JsonTokenType.String so it never goes in that if statement

if (reader.TokenType == JsonTokenType.PropertyName)

Answer 1

As of .NET 8 or .NET 9 Preview 2 there is no way get the parent property name or any other part of the serialization path inside JsonConverter<T>.Read() because it is not known by Utf8JsonReader. For confirmation, see this answer to How do I get the property path from Utf8JsonReader?. And as you have seen, by the time Read() is called the reader has been advanced past the property name.

Instead, in .NET 7 and later you can use a typeInfo modifier to programmatically apply the converter to any .NET property named xyz. To do this, first create the following modifier and converter:

public static partial class JsonExtensions
{
    public static Action<JsonTypeInfo> AddPropertyConverter(JsonConverter converter, string propertyName) => typeInfo =>
    {
        // Use StringComparison.OrdinalIgnoreCase if you want to apply the comparer to properties named Xyz and XYZ also.
        foreach (var property in typeInfo.Properties.Where(p => converter.CanConvert(p.PropertyType)
                                                           && String.Equals(p.GetMemberName(), propertyName, StringComparison.Ordinal)))
        {
            // If you only want to apply the converter only when there is not one already, use ??=
            // property.CustomConverter ??= CustomJsonConverter.Instance;
            property.CustomConverter = CustomJsonConverter.Instance;
        }
    };

    public static string? GetMemberName(this JsonPropertyInfo property) => (property.AttributeProvider as MemberInfo)?.Name;
}

public class CustomJsonConverter : JsonConverter<string?>
{
    public static CustomJsonConverter Instance { get; } = new(); // Cache a single instance for performance

    public override bool HandleNull => false; // Change to true if you want to modify null string values.

    public override string? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>
        "Modified: " + reader.GetString();

    public override void Write(Utf8JsonWriter writer, string? value, JsonSerializerOptions options) => 
        // Write the value as a string
        writer.WriteStringValue(value);
}

Then in .NET 8 and later apply the modifier to your desired IJsonTypeInfoResolver using WithAddedModifier():

string propertyName = "xyz";

JsonSerializerOptions _options = new()
{
    // Configure either a DefaultJsonTypeInfoResolver or some JsonSerializerContext and add the required modifier:
    TypeInfoResolver = new DefaultJsonTypeInfoResolver()
        .WithAddedModifier(JsonExtensions.AddPropertyConverter(CustomJsonConverter.Instance, propertyName)),
    // Add other options as required
    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
    PropertyNameCaseInsensitive = true,             
};

Or in .NET 7 create and configure a DefaultJsonTypeInfoResolver directly as follows:

string propertyName = "xyz";

JsonSerializerOptions _options = new()
{
    TypeInfoResolver = new DefaultJsonTypeInfoResolver()
    {
        Modifiers = {JsonExtensions.AddPropertyConverter(CustomJsonConverter.Instance, propertyName)}
    },
    // Add other options as required
    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
    PropertyNameCaseInsensitive = true,             
};

Now all properties named xyz of type string will have their value remapped by your converter during deserialization as required, without needing to add attributes to, or otherwise modify, your serialization classes.

Notes:

• If you want properties with a null value to be remapped, you must override HandleNull and return true.

• If you want to remap properties with a specified JSON name instead of a specified .NET name, check JsonPropertyInfo.Name instead of GetMemberName():

   foreach (var property in typeInfo.Properties.Where(p => converter.CanConvert(p.PropertyType)
                                                      && String.Equals(p.Name, propertyName, StringComparison.Ordinal)))
  

Demo fiddles for .NET 8 here and .NET 7 here.