using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Collections.Concurrent;

using System.IO;

using System.Diagnostics.CodeAnalysis;

​

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;    

​

using MessagePack;

​

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

​

//nugets required:

//  https://github.com/microsoft/Microsoft.IO.RecyclableMemoryStream

//  https://www.nuget.org/packages/MessagePack

//https://stackoverflow.com/questions/79450718/c-sharp-asp-net-memorycache-grows-excessively-23gb-instead-of-200mb-on-one-ser

​

#nullable enable

​

using Microsoft.IO;

​

public static partial class SerializationExtensions

{

    // You might want to inject this via dependency injection

    public static RecyclableMemoryStreamManager Manager { get; } = new RecyclableMemoryStreamManager( 

        new RecyclableMemoryStreamManager.Options

        {

            // Set any appropriate options here.

        });

}

​

public interface ICloneWorker

{

    [return: NotNullIfNotNull(nameof(value))]

    T? Clone<T>(T? value);

}

​

public class MessagePackCloneWorker : ICloneWorker

{

    readonly MessagePackSerializerOptions? options = default;

    public MessagePackCloneWorker(MessagePackSerializerOptions? options = default) => this.options = options;

​

    [return: NotNullIfNotNull(nameof(value))]

    public T? Clone<T>(T? value)

    {

        if (value is null)

            return value;

        using Stream stream = SerializationExtensions.Manager.GetStream();

        MessagePackSerializer.Serialize(stream, value, options);

        stream.Position = 0;

        return MessagePackSerializer.Deserialize<T>(stream, options)!;

    }

}

​

public class NewtonsoftCloneWorker : ICloneWorker

{

    static JsonSerializerSettings DefaultNewtonsoftCloneSettings { get; } = new()

    {

        Formatting = Formatting.None,

        NullValueHandling = NullValueHandling.Ignore,

        DefaultValueHandling = DefaultValueHandling.Ignore,

        DateParseHandling = DateParseHandling.None,

    };

    readonly JsonSerializerSettings settings;

    public NewtonsoftCloneWorker(JsonSerializerSettings? settings = default) => this.settings = settings ?? DefaultNewtonsoftCloneSettings;

​

    [return: NotNullIfNotNull(nameof(value))]

    public T? Clone<T>(T? value)

    {

        if (value is null)

            return value;

        var serializer = JsonSerializer.CreateDefault(settings);

        return JToken.FromObject(value, serializer).ToObject<T>(serializer)!;

    }

}

​

[MessagePackObject]

public class Model

{

    [Key(0)]

    public List<string> Strings { get; set; } = new();

    [Key(1)]

    public Dictionary<string, string> Dictionary { get; set; } = new();

}

​

​

    class TestClass

    {

        static MessagePackSerializerOptions? MessagePackOptions = default;

​

        static MessagePackCloneWorker worker = new(MessagePackOptions);

        public static T? DestroyReference<T>(T data) => worker.Clone(data);

        public static void Test()

        {

            foreach (var model in GetModels())

            {

                TestWithMessagePack(model);

                TestWithNewtonsoft(model);

            }

        }   

        public static IEnumerable<Model> GetModels() =>

            new Model []

                {

                    new()

                    {

                        Strings = { "a", "b", "c", "d" },

                        Dictionary = 

                        {

                            ["a"] = "a",

                            ["b"] = "b",

                            ["c"] = "c",

                            ["d"] = "d",

                            ["e"] = "e",

                        }

                    },

                };

        static void TestWithNewtonsoft(Model model)

        {

            Test(model, new NewtonsoftCloneWorker());

        }

​

        static void TestWithMessagePack(Model model)

        {

            Test(model, new MessagePackCloneWorker());

        }

        static void Test(Model model, ICloneWorker worker)

        {

            var newModel = worker.Clone(model);

            Assert.That(model.Strings.SequenceEqual(newModel.Strings));

            Assert.That(model.Dictionary.SequenceEqual(newModel.Dictionary));

            Console.WriteLine("Testing {0}, result: {1}", worker, JsonConvert.SerializeObject(newModel));

        }

    }

​

    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("{0} version: {1}", typeof(JsonSerializer).Namespace, typeof(JsonSerializer).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failed with unhandled exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​