using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Reflection;

​

using System.Text.Json;

using System.Text.Json.Serialization;

using System.Text.Json.Serialization.Metadata;

using System.Text.Json.Nodes;

​

using NUnit.Framework; // Throws NUnit.Framework.AssertionException

​

//https://stackoverflow.com/questions/78196337/i-need-to-modify-the-value-of-string-type-if-the-property-name-is-xyz-in-jsonc

​

#nullable enable

​

    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.Name, 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);

    }

​

#nullable disable

​

    public record Model(string Foo, string xyz, Nested Nested);

    public record Nested

    {

        public string Bar {get; set; }

        public string xyz {get;set; } 

    }

​

    public record Model<T>(string Foo, T xyz, Nested Nested);

    public record Nested<T>

    {

        public string Bar {get; set;}

        public T xyz {get;set; } 

    }

​

#nullable enable

    class TestClass

    {

        public static void Test()

        {

            TestNonGeneric();

            Console.WriteLine();

            TestGeneric();

        }

        static void TestNonGeneric()

        {

            var input = new Model("foo", "xyz", new() { Bar = "bar", xyz = "xyz" });

            var json = JsonSerializer.Serialize(input);

            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,             

            };

            var model = JsonSerializer.Deserialize<Model>(json, _options);

            var json2 = JsonSerializer.Serialize(model, _options);

            Console.WriteLine("Input JSON:          {0}", json);

            Console.WriteLine("Re-serialized Model: {0}", json2);

            Assert.AreEqual(model?.xyz, "Modified: xyz");

            Assert.AreEqual(model?.Nested.xyz, "Modified: xyz");

            Assert.AreEqual(model?.Foo, "foo");

            Assert.AreEqual("""{"Foo":"foo","xyz":"Modified: xyz","Nested":{"Bar":"bar","xyz":"Modified: xyz"}}""", json2);

        }   

        static void TestGeneric()

        {

            var input = new Model<string>("foo", "xyz", new() { Bar = "bar", xyz = "xyz" });

            var json = JsonSerializer.Serialize(input);

            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,             

            };

​

            var model = JsonSerializer.Deserialize<Model<string>>(json, _options);

            var json2 = JsonSerializer.Serialize(model, _options);

            Console.WriteLine("Input JSON:            {0}", json);

            Console.WriteLine("Re-serialized {0}: {1}", model?.GetType().Name, json2);

            Assert.AreEqual(model?.xyz, "Modified: xyz");

            Assert.AreEqual(model?.Nested.xyz, "Modified: xyz");

            Assert.AreEqual(model?.Foo, "foo");

            Assert.AreEqual("""{"Foo":"foo","xyz":"Modified: xyz","Nested":{"Bar":"bar","xyz":"Modified: xyz"}}""", json2);

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: {0} ({1}), {2}", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , Environment.Version, Environment.OSVersion);

            Console.WriteLine("System.Text.Json version: " + typeof(JsonSerializer).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failed with unhandled exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​