Serialize/deserialize a ReferenceLoop of ISerializable objects with Newtonsoft.JSON (Json.NET)

Your serialization requirements seem to include:

• Convenient support for serialization of complex polymorphic type hierarchies in a "massive legacy codebase".

• Convenient support for round-tripping of cyclic object graphs.

• Ability to inject custom serialization logic for certain types without disturbing automatic serialization of remaining types.

• No tight coupling of your legacy code base to any particular serializer.

• Good performance without excessive throwing and catching of exceptions.

Your current strategy to meet these requirements seems to depend on technologies that are either obsoleted or in legacy support, and do not provide the necessary APIs:

• All BinaryFormatter related technologies including [Serializable] and ISerializable have been obsoleted and will be removed entirely.

• Json.NET seems no longer to be under active development.

• Json.NET's JsonSerializerInternalWriter does not offer public API access to CheckForCircularReference() or its _serializeStack.

• SerializationInfo does not does not offer public API access to GetValueNoThrow() or its IFormatterConverter _converter.

  (Json.NET sets SerializationInfo_converter to an instance of its private type FormatterConverter so you would need access to _converter if you wanted to manually loop through the serialization entries and deserialize each one manually without making direct calls to Json.NET from within your streaming constructor.)

• The replacement for Json.NET, System.Text.Json, has its own limitations; for instance its custom converters do not work with its built-in handling of cycles, and API access is not present to make them work together easily.

Given that you seem to be at an impasse here, I would recommend solving your specific problem with minimal code: simply catch and ignore the exception inside your streaming constructors. To make it a bit simpler, introduce the following extension method:

public static class SerializationInfoExtensions { public static object? GetValueNoThrow(this SerializationInfo info, string name, Type type) { ArgumentNullException.ThrowIfNull(info); ArgumentNullException.ThrowIfNull(name); ArgumentNullException.ThrowIfNull(type); try { return info.GetValue(name, type); } catch (SerializationException) { return null; } } } 

Then use it in your streaming constructors:

[Serializable] internal sealed class User : ISerializable { private User(SerializationInfo info, StreamingContext context) { Name = (string)info.GetValue(nameof(Name), typeof(string)); Group = (UserGroup)info.GetValueNoThrow(nameof(Group), typeof(UserGroup)); } // Remainder omitted [Serializable] internal sealed class UserGroup : ISerializable { private UserGroup(SerializationInfo info, StreamingContext context) { Name = (string)info.GetValue(nameof(Name), typeof(string)); DefaultUser = (User)info.GetValueNoThrow(nameof(DefaultUser), typeof(User)); } // Remainder omitted 

Now, as you correctly note in your question, throwing and catching exceptions is not performant, so profile your application. If performance is good enough, move on.

Demo fiddle #1 here.

But if performance is not good enough, you could use the dark arts of reflection to call the internal method SerializationInfo.GetValueNoThrow() like so:

public static class SerializationInfoExtensions { static Lazy<Func<SerializationInfo, string, Type, object?>?> GetValueNoThrowFunc = new( () => { var method = typeof(SerializationInfo).GetMethod("GetValueNoThrow", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public, new [] { typeof(string), typeof(Type)}); if (method == null) return null; return (Func<SerializationInfo, string, Type, object?>)Delegate.CreateDelegate(typeof(Func<SerializationInfo, string, Type, object?>), null, method); } ); public static object? GetValueNoThrow(this SerializationInfo info, string name, Type type) { ArgumentNullException.ThrowIfNull(info); ArgumentNullException.ThrowIfNull(name); ArgumentNullException.ThrowIfNull(type); var func = GetValueNoThrowFunc.Value; if (func != null) return func(info, name, type); // Fallback in case GetValueNoThrow() is removed by MSFT. try { return info.GetValue(name, type); } catch (SerializationException) { return null; } } } 

By caching a delegate created from the MethodInfo for GetValueNoThrow(), repeated calls should be nearly as fast as direct method calls.

Then rerun your profiles. If performance is better, use this as a stopgap while you re-evaluate your serialization architecture. Sure, this approach is fragile, but it's very unlikely that MSFT will modify SerializationInfo and remove the internal method you are calling. (Rather, it's more likely that they will remove the type entirely.)

Demo fiddle #2 here.