Remove the Newtonsoft.Json package and migrate to System.Text.Json

Clean.bat

@@ -0,0 +1,8 @@
+FOR /d /r . %%d in (bin,obj) do @if exist "%%d" rd /s/q "%%d"
+FOR /F "tokens=*" %%G IN ('DIR /B /AD /S Packages') DO RMDIR /S /Q "%%G"
+FOR /F "tokens=*" %%G IN ('DIR /B /AD /S .vs') DO RMDIR /S /Q "%%G"
+FOR /F "tokens=*" %%G IN ('DIR /B /AD /S .vscode') DO RMDIR /S /Q "%%G"
+FOR /F "tokens=*" %%G IN ('DIR /B /AD /S TestResults') DO RMDIR /S /Q "%%G"
+FOR /F "tokens=*" %%G IN ('DIR /B /AD /S AppPackages') DO RMDIR /S /Q "%%G"
+DEL /Q /F /S "*.csproj.user"
+DEL /Q /F /S "*.sln.DotSettings.user"

docs/features/dependencyinjection.rst

@@ -132,7 +132,14 @@ Current `implementation <https://github.com/search?q=repo%3AThreeMammals%2FOcelo
                 .AddApplicationPart(assembly)
                 .AddControllersAsServices()
                 .AddAuthorization()
-                .AddNewtonsoftJson();
+                .AddJsonOptions(op =>
+                {
+                    op.JsonSerializerOptions.ReferenceHandler = ReferenceHandler.IgnoreCycles;
+                    op.JsonSerializerOptions.NumberHandling = JsonNumberHandling.AllowReadingFromString;
+                    op.JsonSerializerOptions.WriteIndented = false;
+                    op.JsonSerializerOptions.PropertyNameCaseInsensitive = true;
+                    op.JsonSerializerOptions.Encoder = JavaScriptEncoder.Create(UnicodeRanges.All);
+                });
         }
 
 The method cannot be overridden. It is not virtual, and there is no way to override current behavior by inheritance.
@@ -154,74 +161,6 @@ The next section shows you an example of designing custom Ocelot pipeline by cus
 
 .. _di-custom-builder:
 
-Custom Builder
---------------
-
-**Goal**: Replace ``Newtonsoft.Json`` services with ``System.Text.Json`` services.
-
-Problem
-^^^^^^^
-
-The main `AddOcelot`_ method adds 
-`Newtonsoft JSON <https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.dependencyinjection.newtonsoftjsonmvccorebuilderextensions.addnewtonsoftjson>`_ services 
-by the ``AddNewtonsoftJson`` extension method in default builder (`AddDefaultAspNetServices`_ method). 
-The ``AddNewtonsoftJson`` method calling was introduced in old .NET and Ocelot releases which was necessary when Microsoft did not launch the ``System.Text.Json`` library, 
-but now it affects normal use, so we have an intention to solve the problem.
-
-Modern `JSON services <https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.dependencyinjection.mvccoremvccorebuilderextensions.addjsonoptions>`_ 
-out of `the box <https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.dependencyinjection.mvccoremvccorebuilderextensions>`_
-will help to configure JSON settings by the ``JsonSerializerOptions`` property for JSON formatters during (de)serialization.
-
-Solution
-^^^^^^^^
-
-We have the following methods in `ServiceCollectionExtensions`_ class:
-
-.. code-block:: csharp
-
-    IOcelotBuilder AddOcelotUsingBuilder(this IServiceCollection services, Func<IMvcCoreBuilder, Assembly, IMvcCoreBuilder> customBuilder);
-    IOcelotBuilder AddOcelotUsingBuilder(this IServiceCollection services, IConfiguration configuration, Func<IMvcCoreBuilder, Assembly, IMvcCoreBuilder> customBuilder);
-
-These methods with custom builder allow you to use your any desired JSON library for (de)serialization.
-But we are going to create custom ``MvcCoreBuilder`` with support of JSON services, such as ``System.Text.Json``.
-To do that we need to call ``AddJsonOptions`` extension of the ``MvcCoreMvcCoreBuilderExtensions`` class 
-(NuGet package: `Microsoft.AspNetCore.Mvc.Core <https://www.nuget.org/packages/Microsoft.AspNetCore.Mvc.Core/>`_) in **Startup.cs**:
-
-.. code-block:: csharp
-
-    using Microsoft.Extensions.DependencyInjection;
-    using Ocelot.DependencyInjection;
-    using System.Reflection;
-
-    public class Startup
-    {
-        public void ConfigureServices(IServiceCollection services)
-        {
-            services
-                .AddLogging()
-                .AddMiddlewareAnalysis()
-                .AddWebEncoders()
-                // Add your custom builder
-                .AddOcelotUsingBuilder(MyCustomBuilder);
-        }
-
-        private static IMvcCoreBuilder MyCustomBuilder(IMvcCoreBuilder builder, Assembly assembly)
-        {
-            return builder
-                .AddApplicationPart(assembly)
-                .AddControllersAsServices()
-                .AddAuthorization()
-
-                // Replace AddNewtonsoftJson() by AddJsonOptions()
-                .AddJsonOptions(options =>
-                {
-                    options.JsonSerializerOptions.WriteIndented = true; // use System.Text.Json
-                });
-        }
-    }
-
-The sample code provides settings to render JSON as indented text rather than compressed plain JSON text without spaces.
-This is just one common use case, and you can add additional services to the builder.
 
 ------------------------------------------------------------------
 

src/Ocelot.Provider.Consul/ConsulFileConfigurationRepository.cs

@@ -1,13 +1,14 @@
 using Microsoft.Extensions.Options;
-using Newtonsoft.Json;
 using Ocelot.Cache;
 using Ocelot.Configuration;
 using Ocelot.Configuration.File;
 using Ocelot.Configuration.Repository;
+using Ocelot.Infrastructure;
 using Ocelot.Logging;
 using Ocelot.Provider.Consul.Interfaces;
 using Ocelot.Responses;
 using System.Text;
+using System.Text.Json;
 
 namespace Ocelot.Provider.Consul;
 
@@ -53,14 +54,14 @@ public async Task<Response<FileConfiguration>> Get()
 
         var bytes = queryResult.Response.Value;
         var json = Encoding.UTF8.GetString(bytes);
-        var consulConfig = JsonConvert.DeserializeObject<FileConfiguration>(json);
+        var consulConfig = JsonSerializer.Deserialize<FileConfiguration>(json, JsonSerializerOptionsExtensions.Web);
 
         return new OkResponse<FileConfiguration>(consulConfig);
     }
 
     public async Task<Response> Set(FileConfiguration ocelotConfiguration)
     {
-        var json = JsonConvert.SerializeObject(ocelotConfiguration, Formatting.Indented);
+        var json = JsonSerializer.Serialize(ocelotConfiguration, JsonSerializerOptionsExtensions.WebWriteIndented);
         var bytes = Encoding.UTF8.GetBytes(json);
         var kvPair = new KVPair(_configurationKey)
         {

src/Ocelot/Configuration/Repository/DiskFileConfigurationRepository.cs

@@ -1,9 +1,10 @@
 using Microsoft.AspNetCore.Hosting;
-using Newtonsoft.Json;
 using Ocelot.Configuration.ChangeTracking;
 using Ocelot.Configuration.File;
 using Ocelot.DependencyInjection;
+using Ocelot.Infrastructure;
 using Ocelot.Responses;
+using System.Text.Json;
 using FileSys = System.IO.File;
 
 namespace Ocelot.Configuration.Repository
@@ -49,14 +50,14 @@ public Task<Response<FileConfiguration>> Get()
                 jsonConfiguration = FileSys.ReadAllText(_environmentFile.FullName);
             }
 
-            var fileConfiguration = JsonConvert.DeserializeObject<FileConfiguration>(jsonConfiguration);
+            var fileConfiguration = JsonSerializer.Deserialize<FileConfiguration>(jsonConfiguration, JsonSerializerOptionsExtensions.Web);
 
             return Task.FromResult<Response<FileConfiguration>>(new OkResponse<FileConfiguration>(fileConfiguration));
         }
 
         public Task<Response> Set(FileConfiguration fileConfiguration)
         {
-            var jsonConfiguration = JsonConvert.SerializeObject(fileConfiguration, Formatting.Indented);
+            var jsonConfiguration = JsonSerializer.Serialize(fileConfiguration, JsonSerializerOptionsExtensions.WebWriteIndented);
 
             lock (_lock)
             {

src/Ocelot/Configuration/Repository/FileConfigurationPoller.cs

@@ -1,8 +1,9 @@
 using Microsoft.Extensions.Hosting;
-using Newtonsoft.Json;
 using Ocelot.Configuration.Creator;
 using Ocelot.Configuration.File;
+using Ocelot.Infrastructure;
 using Ocelot.Logging;
+using System.Text.Json;
 
 namespace Ocelot.Configuration.Repository
 {
@@ -68,7 +69,7 @@ private async Task Poll()
 
             if (fileConfig.IsError)
             {
-                _logger.LogWarning(() =>$"error geting file config, errors are {string.Join(',', fileConfig.Errors.Select(x => x.Message))}");
+                _logger.LogWarning(() => $"error geting file config, errors are {string.Join(',', fileConfig.Errors.Select(x => x.Message))}");
                 return;
             }
 
@@ -95,7 +96,7 @@ private async Task Poll()
         /// <returns>hash of the config.</returns>
         private static string ToJson(FileConfiguration config)
         {
-            var currentHash = JsonConvert.SerializeObject(config);
+            var currentHash = JsonSerializer.Serialize(config, JsonSerializerOptionsExtensions.Web);
             return currentHash;
         }
 

src/Ocelot/DependencyInjection/ConfigurationBuilderExtensions.cs

@@ -1,9 +1,10 @@
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.Configuration.Memory;
-using Newtonsoft.Json;
+using Microsoft.Extensions.Configuration.Memory;
 using Ocelot.Configuration.File;
-
+using Ocelot.Infrastructure;
+using System.Text.Json;
+
 namespace Ocelot.DependencyInjection
 {
     /// <summary>
@@ -98,8 +99,8 @@ public static IConfigurationBuilder AddOcelot(this IConfigurationBuilder builder
         private static IConfigurationBuilder ApplyMergeOcelotJsonOption(IConfigurationBuilder builder, MergeOcelotJson mergeTo, string json,
             string primaryConfigFile, bool? optional, bool? reloadOnChange)
         {
-            return mergeTo == MergeOcelotJson.ToMemory ? 
-                builder.AddJsonStream(new MemoryStream(Encoding.UTF8.GetBytes(json))) : 
+            return mergeTo == MergeOcelotJson.ToMemory ?
+                builder.AddJsonStream(new MemoryStream(Encoding.UTF8.GetBytes(json))) :
                 AddOcelotJsonFile(builder, json, primaryConfigFile, optional, reloadOnChange);
         }
 
@@ -132,7 +133,7 @@ private static string GetMergedOcelotJson(string folder, IWebHostEnvironment env
                 }
 
                 var lines = File.ReadAllText(file.FullName);
-                var config = JsonConvert.DeserializeObject<FileConfiguration>(lines);
+                var config = JsonSerializer.Deserialize<FileConfiguration>(lines, JsonSerializerOptionsExtensions.Web);
                 if (file.Name.Equals(globalFileInfo.Name, StringComparison.OrdinalIgnoreCase) &&
                     file.FullName.Equals(globalFileInfo.FullName, StringComparison.OrdinalIgnoreCase))
                 {
@@ -143,7 +144,7 @@ private static string GetMergedOcelotJson(string folder, IWebHostEnvironment env
                 fileConfiguration.Routes.AddRange(config.Routes);
             }
 
-            return JsonConvert.SerializeObject(fileConfiguration, Formatting.Indented);
+            return JsonSerializer.Serialize(fileConfiguration, JsonSerializerOptionsExtensions.WebWriteIndented);
         }
 
         /// <summary>
@@ -160,7 +161,7 @@ private static string GetMergedOcelotJson(string folder, IWebHostEnvironment env
         public static IConfigurationBuilder AddOcelot(this IConfigurationBuilder builder, FileConfiguration fileConfiguration,
             string primaryConfigFile = null, bool? optional = null, bool? reloadOnChange = null) // optional injections
         {
-            var json = JsonConvert.SerializeObject(fileConfiguration, Formatting.Indented);
+            var json = JsonSerializer.Serialize(fileConfiguration, JsonSerializerOptionsExtensions.WebWriteIndented);
             return AddOcelotJsonFile(builder, json, primaryConfigFile, optional, reloadOnChange);
         }
 

src/Ocelot/DependencyInjection/OcelotBuilder.cs

@@ -4,7 +4,6 @@
 using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Options;
 using Ocelot.Authorization;
-using Ocelot.Cache;
 using Ocelot.Claims;
 using Ocelot.Configuration;
 using Ocelot.Configuration.ChangeTracking;
@@ -27,7 +26,6 @@
 using Ocelot.Multiplexer;
 using Ocelot.PathManipulation;
 using Ocelot.QueryStrings;
-using Ocelot.RateLimiting;
 using Ocelot.Request.Creator;
 using Ocelot.Request.Mapper;
 using Ocelot.Requester;
@@ -39,6 +37,9 @@
 using Ocelot.ServiceDiscovery.Providers;
 using Ocelot.WebSockets;
 using System.Reflection;
+using System.Text.Encodings.Web;
+using System.Text.Json.Serialization;
+using System.Text.Unicode;
 
 namespace Ocelot.DependencyInjection
 {
@@ -111,7 +112,7 @@ public OcelotBuilder(IServiceCollection services, IConfiguration configurationRo
             Services.TryAddSingleton<IHttpHandlerOptionsCreator, HttpHandlerOptionsCreator>();
             Services.TryAddSingleton<IDownstreamAddressesCreator, DownstreamAddressesCreator>();
             Services.TryAddSingleton<IDelegatingHandlerHandlerFactory, DelegatingHandlerHandlerFactory>();
-            
+
             Services.TryAddSingleton<IOcelotConfigurationChangeTokenSource, OcelotConfigurationChangeTokenSource>();
             Services.TryAddSingleton<IOptionsMonitor<IInternalConfiguration>, OcelotConfigurationMonitor>();
 
@@ -157,7 +158,6 @@ public OcelotBuilder(IServiceCollection services, IConfiguration configurationRo
         /// <summary>
         /// Adds default ASP.NET services which are the minimal part of the gateway core.
         /// <para>
-        /// Finally the builder adds Newtonsoft.Json services via the <see cref="NewtonsoftJsonMvcCoreBuilderExtensions.AddNewtonsoftJson(IMvcCoreBuilder)"/> extension-method.<br/>
         /// To remove these services, use custom builder in the <see cref="ServiceCollectionExtensions.AddOcelotUsingBuilder(IServiceCollection, Func{IMvcCoreBuilder, Assembly, IMvcCoreBuilder})"/> extension-method.
         /// </para>
         /// </summary>
@@ -171,8 +171,7 @@ public OcelotBuilder(IServiceCollection services, IConfiguration configurationRo
         /// Warning! The following <see cref="IMvcCoreBuilder"/> extensions being called:<br/>
         /// - <see cref="MvcCoreMvcCoreBuilderExtensions.AddApplicationPart(IMvcCoreBuilder, Assembly)"/><br/>
         /// - <see cref="MvcCoreMvcCoreBuilderExtensions.AddControllersAsServices(IMvcCoreBuilder)"/><br/>
-        /// - <see cref="MvcCoreMvcCoreBuilderExtensions.AddAuthorization(IMvcCoreBuilder)"/><br/>
-        /// - <see cref="NewtonsoftJsonMvcCoreBuilderExtensions.AddNewtonsoftJson(IMvcCoreBuilder)"/>, removable.
+        /// - <see cref="MvcCoreMvcCoreBuilderExtensions.AddAuthorization(IMvcCoreBuilder)"/>
         /// </para>
         /// </remarks>
         /// <param name="builder">The default builder being returned by <see cref="MvcCoreServiceCollectionExtensions.AddMvcCore(IServiceCollection)"/> extension-method.</param>
@@ -189,7 +188,14 @@ protected IMvcCoreBuilder AddDefaultAspNetServices(IMvcCoreBuilder builder, Asse
                 .AddApplicationPart(assembly)
                 .AddControllersAsServices()
                 .AddAuthorization()
-                .AddNewtonsoftJson();
+                .AddJsonOptions(op =>
+                {
+                    op.JsonSerializerOptions.ReferenceHandler = ReferenceHandler.IgnoreCycles;
+                    op.JsonSerializerOptions.NumberHandling = JsonNumberHandling.AllowReadingFromString;
+                    op.JsonSerializerOptions.WriteIndented = false;
+                    op.JsonSerializerOptions.PropertyNameCaseInsensitive = true;
+                    op.JsonSerializerOptions.Encoder = JavaScriptEncoder.Create(UnicodeRanges.All);
+                });
         }
 
         public IOcelotBuilder AddSingletonDefinedAggregator<T>()

src/Ocelot/Infrastructure/JsonSerializerOptionsExtensions.cs

@@ -0,0 +1,29 @@
+using System.Text.Encodings.Web;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Text.Unicode;
+
+namespace Ocelot.Infrastructure
+{
+    public static class JsonSerializerOptionsExtensions
+    {
+        public static readonly JsonSerializerOptions Web = new()
+        {
+            PropertyNameCaseInsensitive = true,
+            NumberHandling = JsonNumberHandling.AllowReadingFromString,
+            ReferenceHandler = ReferenceHandler.IgnoreCycles,
+            WriteIndented = false,
+            Encoder = JavaScriptEncoder.Create(UnicodeRanges.All),
+
+        };
+
+        public static readonly JsonSerializerOptions WebWriteIndented = new()
+        {
+            PropertyNameCaseInsensitive = true,
+            NumberHandling = JsonNumberHandling.AllowReadingFromString,
+            ReferenceHandler = ReferenceHandler.IgnoreCycles,
+            WriteIndented = true,
+            Encoder = JavaScriptEncoder.Create(UnicodeRanges.All)
+        };
+    }
+}

src/Ocelot/Metadata/DownstreamRouteExtensions.cs

@@ -1,6 +1,6 @@
 using Ocelot.Configuration;
+using Ocelot.Infrastructure;
 using System.Globalization;
-using System.Reflection;
 using System.Text.Json;
 
 namespace Ocelot.Metadata;
@@ -74,7 +74,7 @@ public static T GetMetadata<T>(this DownstreamRoute downstreamRoute, string key,
         }
 
         return (T)ConvertTo(typeof(T), metadataValue, downstreamRoute.MetadataOptions,
-            jsonSerializerOptions ?? new JsonSerializerOptions(JsonSerializerDefaults.Web));
+            jsonSerializerOptions ?? JsonSerializerOptionsExtensions.Web);
     }
 
     /// <summary>