Consider using these JSON converters for JsonPatchDocument in dotnet 5

[sergeyt]

Related issue #16968 is closed as out of scope of dotnet 5 release because of efforts

Code below might be reused to reduce this effort

using System;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using Microsoft.AspNetCore.JsonPatch;
using Microsoft.AspNetCore.JsonPatch.Operations;

namespace JsonExtensions
{
    public class JsonPatchConverterFactory : JsonConverterFactory
    {
        public override bool CanConvert(Type typeToConvert)
        {
            return typeToConvert.IsConstructedGenericType &&
                   typeToConvert.GetGenericTypeDefinition() == typeof(JsonPatchDocument<>) ||
                   typeToConvert == typeof(JsonPatchDocument);
        }

        public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
        {
            if (typeToConvert.IsConstructedGenericType &&
                typeToConvert.GetGenericTypeDefinition() == typeof(JsonPatchDocument<>))
            {
                var converterType =
                    typeof(JsonPatchConverter<>).MakeGenericType(typeToConvert.GetGenericArguments()[0]);
                return (JsonConverter) Activator.CreateInstance(converterType);
            }
            return JsonPatchConverter.Instance;
        }
    }
    
    public class JsonPatchConverter : JsonConverter<JsonPatchDocument>
    {
        public static JsonPatchConverter Instance => Singleton.Value;
        
        private static class Singleton
        {
            public static readonly JsonPatchConverter Value = new JsonPatchConverter();
        }
        
        public override JsonPatchDocument Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            if (typeToConvert != typeof(JsonPatchDocument))
            {
                throw new ArgumentException("Invalid type", nameof(typeToConvert));
            }
            
            if (reader.TokenType == JsonTokenType.Null)
            {
                return null;
            }

            var ops = new List<Operation>();
            ReadOperations(ref reader, ops);
            
            return new JsonPatchDocument(ops, NewtonsoftImpl.SerializerSettings.ContractResolver);
        }

        public override void Write(Utf8JsonWriter writer, JsonPatchDocument value, JsonSerializerOptions options)
        {
            WritePatch(writer, value);
        }

        internal static void ReadOperations<T>(ref Utf8JsonReader reader, List<T> ops)
            where T : Operation
        {
            while (true)
            {
                if (!reader.Read() || reader.TokenType == JsonTokenType.EndArray)
                {
                    break;
                }

                if (reader.TokenType == JsonTokenType.Comment)
                {
                    continue;
                }

                if (reader.TokenType != JsonTokenType.StartObject)
                {
                    throw new JsonException($"Expect {JsonTokenType.StartObject}, but got {reader.TokenType}");
                }

                var op = JsonSerializer.Deserialize<T>(
                    ref reader,
                    DefaultJsonOptions.Instance
                );

                // see Unwrap implementation below
                if (op.value is JsonElement elem)
                {
                    op.value = elem.Unwrap();
                }

                ops.Add(op);
            }
        }

        internal static void WritePatch(Utf8JsonWriter writer, IJsonPatchDocument value)
        {
            if (value == null)
            {
                return;
            }
            
            writer.WriteStartArray();
            foreach (var op in value.GetOperations())
            {
                writer.WriteStartObject();
                writer.WriteProperty("op", op.op);
                if (op.from != null)
                {
                    writer.WriteProperty("from", op.from);    
                }
                writer.WriteProperty("path", op.path);
                if (op.value != null)
                {
                    writer.WriteProperty("value", op.value);    
                }
                writer.WriteEndObject();
            }
            writer.WriteEndArray();
        }
    }

    public class JsonPatchConverter<T> : JsonConverter<JsonPatchDocument<T>> 
        where T : class
    {
        public override JsonPatchDocument<T> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            if (reader.TokenType == JsonTokenType.Null)
            {
                return null;
            }
            
            if (reader.TokenType != JsonTokenType.StartArray)
            {
                throw new JsonException($"Expect '{JsonTokenType.StartArray}', but got '{reader.TokenType}'");
            }
            
            var ops = new List<Operation<T>>();
            JsonPatchConverter.ReadOperations(ref reader, ops);

            return new JsonPatchDocument<T>(ops, NewtonsoftImpl.SerializerSettings.ContractResolver);
        }

        public override void Write(Utf8JsonWriter writer, JsonPatchDocument<T> value, JsonSerializerOptions options)
        {
            JsonPatchConverter.WritePatch(writer, value);
        }
    }
}

JsonElement unwrap implementation:

using System;
using System.Globalization;
using System.Linq;
using System.Text.Json;
using System.Text.RegularExpressions;

namespace JsonExtensions
{
    public static class JsonElementExtensions
    {
        public static object Unwrap(this JsonElement elem)
        {
            return elem.ValueKind switch
            {
                JsonValueKind.String => UnwrapString(elem),
                JsonValueKind.Number => UnwrapNumber(elem),
                JsonValueKind.True => true,
                JsonValueKind.False => false,
                JsonValueKind.Array => elem.EnumerateArray().Select(Unwrap).ToList(),
                JsonValueKind.Object => elem.EnumerateObject().ToDictionary(x => x.Name, x => Unwrap(x.Value)),
                _ => null
            };
        }

        private static object UnwrapNumber(this JsonElement elem)
        {
            return elem.GetDouble().Optimize();
        }

        private static object UnwrapString(this JsonElement elem)
        {
            return elem.ToString().OrDate();
        }
    }

    internal static class StringExtensions
    {
        private static readonly Regex IsoDate = new Regex("\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(.\\d+)?");
        
        public static object OrDate(this string value)
        {
            // TODO consider using DateTimeStyles.AssumeUniversal
            if (IsoDate.IsMatch(value) && DateTime.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.None,
                out var d))
            {
                return d;
            }

            return value;
        }
    }

    internal static class DoubleExtensions
    {
        public static object Optimize(this double value)
        {
            if (value == Math.Ceiling(value))
            {
                if (value >= int.MinValue && value <= int.MaxValue)
                {
                    return (int) value;
                }

                return (long) value;
            }
            return value;
        }
    }
}