using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.IO;

using System.Data;

using System.Globalization;

using System.Reflection;

using System.Collections.ObjectModel;

using System.Text.RegularExpressions;

​

using System.Text.Json;

using System.Text.Json.Serialization;

using System.Text.Json.Serialization.Metadata;

using System.Text.Json.Nodes;

using System.Text.Encodings.Web;

​

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

​

// Hack to get Debug.WriteLine() to seem to work.  

// Needed because https://dotnetfiddle.net doesn't seem to have any debug listeners installed. 

using Debug = System.Console;

​

#nullable enable

​

//https://stackoverflow.com/questions/77931730/json-references-during-deserialization-with-custom-referenceresolver-get-lost

​

public class JsonReferenceResolver : ReferenceResolver

{

    private uint _referenceCount;

    private readonly Dictionary<string, object> _referenceIdToObjectMap = new();

    private readonly Dictionary<object, string> _objectToReferenceIdMap = new(ReferenceEqualityComparer.Instance);

​

    public override void AddReference(string referenceId, object value)

    {

        Console.WriteLine("Add Ref: " + referenceId);

        if (!_referenceIdToObjectMap.TryAdd(referenceId, value))

        {

            throw new JsonException();

        }

    }

​

    public override string GetReference(object value, out bool alreadyExists)

    {

        Console.WriteLine("Get Ref: " + value);

​

        if (_objectToReferenceIdMap.TryGetValue(value, out string? referenceId))

        {

            alreadyExists = true;

        }

        else

        {

            _referenceCount++;

            referenceId = _referenceCount.ToString();

            _objectToReferenceIdMap.Add(value, referenceId);

            alreadyExists = false;

        }

​

        return referenceId;

    }

​

    public override object ResolveReference(string referenceId)

    {

        Console.WriteLine("Res Ref: " + referenceId);

        if (!_referenceIdToObjectMap.TryGetValue(referenceId, out object? value))

        {

            throw new JsonException();

        }

​

        return value;

    }

}

​

public class JsonReferenceHandler : ReferenceHandler

{

    public JsonReferenceHandler() => Reset();

    private ReferenceResolver? _rootedResolver;

    public override ReferenceResolver CreateResolver() => _rootedResolver!;

    public void Reset(){

        Debug.WriteLine("{0}.{1} called, stack trace =\n{2}", GetType().Name,System.Reflection.MethodBase.GetCurrentMethod()?.Name, new System.Diagnostics.StackTrace());

        _rootedResolver = new JsonReferenceResolver();

  }

}

​

public class Model

{

    public string Value { get; set; } = "";

}

​

class TestClass

{

    private static ReferenceHandler referenceHandler = new JsonReferenceHandler();

​

    private static readonly JsonSerializerOptions options = new()

    {

        Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,

        WriteIndented = true,

        ReferenceHandler = referenceHandler,

        IncludeFields = true

    };

    public static void Test()

    {

        TestWithoutReset();

        TestWithReset();

    }

    public static void TestWithoutReset()

    {

        var model = new Model { Value = "hello" };

        var array = new [] { model, model, model };

        Assert.That(array.Distinct().Count() == 1);

        var json = JsonSerializer.Serialize(array, options);

        Console.WriteLine(json);

        var deserializedArray = JsonSerializer.Deserialize<Model []>(json, options);

        Assert.That(deserializedArray?.Length == array.Length);

        Assert.That(deserializedArray!.Distinct().Count() == 1);

        Assert.That(array.Distinct().Count() == 1);

​

        Assert.That(Regex.Matches(json, model.Value).Count == 1);

    }       

    public static void TestWithReset()

    {

        var model = new Model { Value = "hello" };

        var array = new [] { model, model, model };

        Assert.That(array.Distinct().Count() == 1);

        ((JsonReferenceHandler?)options.ReferenceHandler)?.Reset();

​

        var json = JsonSerializer.Serialize(array, options);

        Console.WriteLine(json);

        ((JsonReferenceHandler?)options.ReferenceHandler)?.Reset();

        var deserializedArray = JsonSerializer.Deserialize<Model []>(json, options);

        Assert.That(deserializedArray?.Length == array.Length);

        Assert.That(deserializedArray!.Distinct().Count() == 1);

        Assert.That(array.Distinct().Count() == 1);

​

        Assert.That(Regex.Matches(json, model.Value).Count == 1);

    }       

}

​

    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;

            }

        }

    }

​