Replace Newtonsoft.Json with a cross-platform Json helper (STJ on net6.0+)

sunnamed434 · claude · sunnamed434 · commit 114cf15bdf76 · 2026-06-20T10:40:35.000+03:00
Add BitMono.Shared.Json: Serialize/Deserialize/LoadFile/SaveFile behind one API
that uses the in-box System.Text.Json on net6.0+ and Newtonsoft.Json on
net462/netstandard (a single self-contained DLL, no transitive deps). It tolerates
// comments and trailing commas and binds case-insensitively, matching the prior
Newtonsoft behavior on the config files. Plugins on any supported runtime
(net462 ... net10) now get JSON without referencing a serializer themselves.

- Replace SettingsLoader with the general Json helper; drop its dead
  LoadWithVariables/Save.
- net6.0+ no longer pulls Newtonsoft; it is referenced only on the legacy TFMs.
- ProtectionSetting: [JsonIgnore] via a conditional global-using alias; drop
  [JsonRequired] (net6.0 in-box STJ lacks it, a nameless entry just no-ops).

Co-Authored-By: Claude Opus 4.8 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/src/BitMono.CLI/GlobalUsings.cs b/src/BitMono.CLI/GlobalUsings.cs
@@ -7,7 +7,6 @@
 global using BitMono.Obfuscation.Files;
 global using BitMono.Obfuscation.Starter;
 global using BitMono.Shared;
-global using BitMono.Shared.Configuration;
 global using BitMono.Shared.DependencyInjection;
 global using BitMono.Shared.Logging;
 global using BitMono.Shared.Models;
diff --git a/src/BitMono.CLI/Modules/OptionsObfuscationNeedsFactory.cs b/src/BitMono.CLI/Modules/OptionsObfuscationNeedsFactory.cs
@@ -29,19 +29,19 @@ public OptionsObfuscationNeedsFactory(string[] args)
         {
             if (options.ObfuscationFile != null && File.Exists(options.ObfuscationFile))
             {
-                obfuscationSettings = SettingsLoader.Load<ObfuscationSettings>(options.ObfuscationFile);
+                obfuscationSettings = Json.LoadFile<ObfuscationSettings>(options.ObfuscationFile);
             }
             else if (File.Exists(KnownConfigNames.Obfuscation))
             {
-                obfuscationSettings = SettingsLoader.Load<ObfuscationSettings>(KnownConfigNames.Obfuscation);
+                obfuscationSettings = Json.LoadFile<ObfuscationSettings>(KnownConfigNames.Obfuscation);
             }
             else
             {
                 // Fallback to application base directory
                 var baseObfuscationFile = Path.Combine(AppContext.BaseDirectory, KnownConfigNames.Obfuscation);
                 if (File.Exists(baseObfuscationFile))
                 {
-                    obfuscationSettings = SettingsLoader.Load<ObfuscationSettings>(baseObfuscationFile);
+                    obfuscationSettings = Json.LoadFile<ObfuscationSettings>(baseObfuscationFile);
                 }
             }
 
diff --git a/src/BitMono.CLI/Modules/ReadlineObfuscationNeedsFactory.cs b/src/BitMono.CLI/Modules/ReadlineObfuscationNeedsFactory.cs
@@ -36,12 +36,12 @@ public ObfuscationNeeds Create(CancellationToken cancellationToken)
         {
             if (File.Exists(obfuscationFile ?? KnownConfigNames.Obfuscation))
             {
-                obfuscationSettings = SettingsLoader.Load<ObfuscationSettings>(obfuscationFile ?? KnownConfigNames.Obfuscation);
+                obfuscationSettings = Json.LoadFile<ObfuscationSettings>(obfuscationFile ?? KnownConfigNames.Obfuscation);
             }
 
             if (File.Exists(KnownConfigNames.Protections))
             {
-                var loadedSettings = SettingsLoader.Load<ProtectionSettings>(KnownConfigNames.Protections);
+                var loadedSettings = Json.LoadFile<ProtectionSettings>(KnownConfigNames.Protections);
                 protectionSettings = loadedSettings?.Protections;
             }
 
diff --git a/src/BitMono.Core/GlobalUsings.cs b/src/BitMono.Core/GlobalUsings.cs
@@ -27,7 +27,6 @@
 global using Echo.DataFlow.Analysis;
 global using Echo.Platforms.AsmResolver;
 global using JetBrains.Annotations;
-global using Newtonsoft.Json;
 global using BitMono.Shared.Extensions;
 global using System;
 global using System.Collections.Generic;
diff --git a/src/BitMono.GlobalTool/GlobalUsings.cs b/src/BitMono.GlobalTool/GlobalUsings.cs
@@ -8,7 +8,6 @@
 global using BitMono.Obfuscation.Files;
 global using BitMono.Obfuscation.Starter;
 global using BitMono.Shared;
-global using BitMono.Shared.Configuration;
 global using BitMono.Shared.DependencyInjection;
 global using BitMono.Shared.Logging;
 global using BitMono.Shared.Models;
diff --git a/src/BitMono.Host/GlobalUsings.cs b/src/BitMono.Host/GlobalUsings.cs
@@ -9,7 +9,6 @@
 global using BitMono.Core.Services;
 global using BitMono.Host.Ioc;
 global using BitMono.Shared;
-global using BitMono.Shared.Configuration;
 global using BitMono.Shared.DependencyInjection;
 global using BitMono.Shared.Logging;
 global using BitMono.Shared.Models;
diff --git a/src/BitMono.Host/Modules/BitMonoModule.cs b/src/BitMono.Host/Modules/BitMonoModule.cs
@@ -5,7 +5,6 @@
 using BitMono.Core.Renaming;
 using BitMono.Core.Services;
 using BitMono.Host.Ioc;
-using BitMono.Shared.Configuration;
 using BitMono.Shared.DependencyInjection;
 using BitMono.Shared.Logging;
 using BitMono.Shared.Models;
@@ -63,16 +62,16 @@ public void Load(Container container)
         var logger = new Logger(loggerConfiguration);
         container.Register<ILogger>(logger).AsSingleton();
 
-        var criticalsSettings = SettingsLoader.Load<CriticalsSettings>(
+        var criticalsSettings = Json.LoadFile<CriticalsSettings>(
             _criticalsFile ?? KnownConfigNames.Criticals);
         container.Register(criticalsSettings).AsSingleton();
 
         var obfuscationSettings = _obfuscationSettings ??
-            SettingsLoader.Load<ObfuscationSettings>(_obfuscationFile ?? KnownConfigNames.Obfuscation);
+            Json.LoadFile<ObfuscationSettings>(_obfuscationFile ?? KnownConfigNames.Obfuscation);
         container.Register(obfuscationSettings).AsSingleton();
 
         var protectionSettings = _protectionSettings ??
-            SettingsLoader.Load<ProtectionSettings>(_protectionsFile ?? KnownConfigNames.Protections);
+            Json.LoadFile<ProtectionSettings>(_protectionsFile ?? KnownConfigNames.Protections);
         container.Register(protectionSettings).AsSingleton();
 
         container.Register<IEngineContextAccessor, EngineContextAccessor>().AsSingleton();
diff --git a/src/BitMono.Shared/BitMono.Shared.csproj b/src/BitMono.Shared/BitMono.Shared.csproj
@@ -9,10 +9,15 @@
   <!-- Common Packages for all frameworks -->
   <ItemGroup>
     <PackageReference Include="NullGuard.Fody" Version="3.1.1" PrivateAssets="All" />
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageReference Include="morelinq" Version="4.4.0" />
   </ItemGroup>
 
+  <!-- JSON: System.Text.Json is in-box on net6.0+, so we add nothing there. The legacy TFMs keep
+       Newtonsoft.Json (a single self-contained DLL, no transitive deps) via the Json helper's #if. -->
+  <ItemGroup Condition=" '$(TargetFramework)' == 'net462' or '$(TargetFramework)' == 'netstandard2.0' or '$(TargetFramework)' == 'netstandard2.1' ">
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+  </ItemGroup>
+
   <!-- Packages specific to older frameworks that need polyfills -->
   <ItemGroup Condition=" '$(TargetFramework)' == 'net462' ">
     <PackageReference Include="System.Collections.Immutable" Version="1.7.1" />
diff --git a/src/BitMono.Shared/Configuration/SettingsLoader.cs b/src/BitMono.Shared/Configuration/SettingsLoader.cs
diff --git a/src/BitMono.Shared/GlobalUsings.cs b/src/BitMono.Shared/GlobalUsings.cs
@@ -3,6 +3,10 @@
 global using System.IO;
 global using System.Linq;
 global using System.Threading;
-global using Newtonsoft.Json;
+#if NET6_0_OR_GREATER
+global using JsonIgnoreAttribute = System.Text.Json.Serialization.JsonIgnoreAttribute;
+#else
+global using JsonIgnoreAttribute = Newtonsoft.Json.JsonIgnoreAttribute;
+#endif
 global using NullGuard;
 global using BitMono.Shared.Extensions;
diff --git a/src/BitMono.Shared/Json.cs b/src/BitMono.Shared/Json.cs
@@ -0,0 +1,66 @@
+#if NET6_0_OR_GREATER
+using System.Text.Json;
+#else
+using Newtonsoft.Json;
+#endif
+
+namespace BitMono.Shared;
+
+/// <summary>
+/// Cross-platform JSON helper. Uses the in-box System.Text.Json on net6.0+ and Newtonsoft.Json on
+/// .NET Framework / netstandard, behind one API — so anything targeting a BitMono-supported runtime
+/// (net462 … net10), including plugins, can read and write JSON without referencing a serializer of
+/// its own. Tolerates // comments and trailing commas, and binds property names case-insensitively.
+/// </summary>
+public static class Json
+{
+#if NET6_0_OR_GREATER
+    private static readonly JsonSerializerOptions Indented = new()
+    {
+        ReadCommentHandling = JsonCommentHandling.Skip,
+        AllowTrailingCommas = true,
+        PropertyNameCaseInsensitive = true,
+        WriteIndented = true,
+    };
+    private static readonly JsonSerializerOptions Compact = new(Indented) { WriteIndented = false };
+#endif
+
+    /// <summary>Serializes a value to JSON text.</summary>
+    public static string Serialize<T>(T value, bool indented = true)
+    {
+#if NET6_0_OR_GREATER
+        return JsonSerializer.Serialize(value, indented ? Indented : Compact);
+#else
+        return JsonConvert.SerializeObject(value, indented ? Formatting.Indented : Formatting.None);
+#endif
+    }
+
+    /// <summary>Deserializes JSON text to <typeparamref name="T"/> (<c>null</c> if the text is "null").</summary>
+    public static T? Deserialize<T>(string json)
+    {
+#if NET6_0_OR_GREATER
+        return JsonSerializer.Deserialize<T>(json, Indented);
+#else
+        return JsonConvert.DeserializeObject<T>(json);
+#endif
+    }
+
+    /// <summary>Reads a JSON file into <typeparamref name="T"/>, or a new instance if the file doesn't exist.</summary>
+    public static T LoadFile<T>(string path) where T : new()
+    {
+        if (!File.Exists(path))
+            return new T();
+
+        return Deserialize<T>(File.ReadAllText(path)) ?? new T();
+    }
+
+    /// <summary>Writes a value to a JSON file, creating the directory if needed.</summary>
+    public static void SaveFile<T>(T value, string path, bool indented = true)
+    {
+        var dir = Path.GetDirectoryName(path);
+        if (!string.IsNullOrEmpty(dir) && !Directory.Exists(dir))
+            Directory.CreateDirectory(dir);
+
+        File.WriteAllText(path, Serialize(value, indented));
+    }
+}
diff --git a/src/BitMono.Shared/Models/ProtectionSetting.cs b/src/BitMono.Shared/Models/ProtectionSetting.cs
@@ -2,7 +2,9 @@
 
 public class ProtectionSetting
 {
-    [JsonRequired] public string Name { get; set; }
+    // ponytail: dropped [JsonRequired] — STJ v6 (net6.0 in-box) has no such attribute, and a nameless
+    // entry just fails to match a protection (no crash). Restore via a conditional alias if you want the throw.
+    public string Name { get; set; }
     public bool Enabled { get; set; }
     [JsonIgnore] public bool Disabled => !Enabled;
 

Original file line number	Diff line number	Diff line change
`@@ -29,19 +29,19 @@ public OptionsObfuscationNeedsFactory(string[] args)`
`29`	`29`	`{`
`30`	`30`	`if (options.ObfuscationFile != null && File.Exists(options.ObfuscationFile))`
`31`	`31`	`{`
`32`		`- obfuscationSettings = SettingsLoader.Load<ObfuscationSettings>(options.ObfuscationFile);`
	`32`	`+ obfuscationSettings = Json.LoadFile<ObfuscationSettings>(options.ObfuscationFile);`
`33`	`33`	`}`
`34`	`34`	`else if (File.Exists(KnownConfigNames.Obfuscation))`
`35`	`35`	`{`
`36`		`- obfuscationSettings = SettingsLoader.Load<ObfuscationSettings>(KnownConfigNames.Obfuscation);`
	`36`	`+ obfuscationSettings = Json.LoadFile<ObfuscationSettings>(KnownConfigNames.Obfuscation);`
`37`	`37`	`}`
`38`	`38`	`else`
`39`	`39`	`{`
`40`	`40`	`// Fallback to application base directory`
`41`	`41`	`var baseObfuscationFile = Path.Combine(AppContext.BaseDirectory, KnownConfigNames.Obfuscation);`
`42`	`42`	`if (File.Exists(baseObfuscationFile))`
`43`	`43`	`{`
`44`		`- obfuscationSettings = SettingsLoader.Load<ObfuscationSettings>(baseObfuscationFile);`
	`44`	`+ obfuscationSettings = Json.LoadFile<ObfuscationSettings>(baseObfuscationFile);`
`45`	`45`	`}`
`46`	`46`	`}`
`47`	`47`
Original file line number	Diff line number	Diff line change
`@@ -36,12 +36,12 @@ public ObfuscationNeeds Create(CancellationToken cancellationToken)`
`36`	`36`	`{`
`37`	`37`	`if (File.Exists(obfuscationFile ?? KnownConfigNames.Obfuscation))`
`38`	`38`	`{`
`39`		`- obfuscationSettings = SettingsLoader.Load<ObfuscationSettings>(obfuscationFile ?? KnownConfigNames.Obfuscation);`
	`39`	`+ obfuscationSettings = Json.LoadFile<ObfuscationSettings>(obfuscationFile ?? KnownConfigNames.Obfuscation);`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`if (File.Exists(KnownConfigNames.Protections))`
`43`	`43`	`{`
`44`		`- var loadedSettings = SettingsLoader.Load<ProtectionSettings>(KnownConfigNames.Protections);`
	`44`	`+ var loadedSettings = Json.LoadFile<ProtectionSettings>(KnownConfigNames.Protections);`
`45`	`45`	`protectionSettings = loadedSettings?.Protections;`
`46`	`46`	`}`
`47`	`47`