using System;

using System.Collections.Generic;

using System.Text;

using System.Linq;

using System.Xml.Serialization;

using System.Xml;

using System.Xml.Linq;

using System.IO;

using System.Data;

using System.Runtime.Serialization;

using System.Runtime.Serialization.Formatters.Binary;

using System.IO.Compression;

using System.Reflection;

​

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

​

//https://stackoverflow.com/questions/58987203/trying-to-save-a-class-content-into-a-file-and-then-reload-it-c

​

    public static class Constants

    {

        public const string DataContractNamespace = ""; // Or whatever

    }

​

    [DataContract(Name = "Dispatcher", Namespace = Constants.DataContractNamespace)]

    public partial class Dispatcher

    {

        [DataMember]

        private Dictionary<int, Dictionary<int, Dictionary<int, Message>>> m_DataBase;

​

        private Dispatcher()

        {

            m_DataBase = new Dictionary<int, Dictionary<int, Dictionary<int, Message>>>();

        }

        [System.Runtime.Serialization.OnDeserialized]

        void OnDeserializedMethod(System.Runtime.Serialization.StreamingContext context)

        {

            // Ensure m_DataBase is not null after deserialization (DataContractSerializer does not call the constructor).

            if (m_DataBase == null)

                m_DataBase = new Dictionary<int, Dictionary<int, Dictionary<int, Message>>>();

        }

​

        internal const string FileName = @"DispatcherDataBase.xml";

        public static Dispatcher LoadFromFile()

        {

            Dispatcher loadedDataBase;

​

            try

            {

                using (var stream = new FileStream(FileName, FileMode.Open))

                {

                    var serializer = new DataContractSerializer(typeof(Dispatcher));

                    loadedDataBase = serializer.ReadObject(stream) as Dispatcher;

                }

            }

            catch (Exception)

            {

                loadedDataBase = new Dispatcher();

            }

​

            return loadedDataBase;

        }

​

        public void SaveToFile()

        {

            using (var stream = new FileStream(FileName, FileMode.Create))

            using (var writer = XmlWriter.Create(stream, new XmlWriterSettings { Indent = true })) // Optional indentation for readability only.

            {

                var serializer = new DataContractSerializer(this.GetType());

                serializer.WriteObject(writer, this);

            }

        }

    }

​

    // Not shown in question, added as an example

    [DataContract(Name = "Message", Namespace = Constants.DataContractNamespace)]

    public class Message

    {

        [DataMember]

        public string Value { get; set; }

    }

​

    public partial class Dispatcher

    {

        public void Set(int index1, int index2, int index3, Message message)

        {

            if (!m_DataBase.TryGetValue(index1, out var mid))

                m_DataBase[index1] = mid = new Dictionary<int, Dictionary<int, Message>>();

            if (!mid.TryGetValue(index2, out var inner))

                mid[index2] = inner = new Dictionary<int, Message>();

            inner[index3] = message;

        }

        internal static void AssertEquals(Dispatcher dispatcher1, Dispatcher dispatcher2)

        {

            if (dispatcher1.m_DataBase.Count != dispatcher2.m_DataBase.Count)

                Assert.Fail("Level0");

            if (!dispatcher1.m_DataBase.Select(d => new { d.Key, d.Value.Count }).SequenceEqual(dispatcher2.m_DataBase.Select(d => new { d.Key, d.Value.Count })))

                Assert.Fail("Level1");

            if (!dispatcher1.m_DataBase.SelectMany(d => d.Value).Select(d => new { d.Key, d.Value.Count })

                .SequenceEqual(dispatcher2.m_DataBase.SelectMany(d => d.Value).Select(d => new { d.Key, d.Value.Count })))

                Assert.Fail("Level2");

            if (!dispatcher1.m_DataBase.SelectMany(d => d.Value).SelectMany(d => d.Value).Select(d => new { d.Key, d.Value.Value })

                .SequenceEqual(dispatcher2.m_DataBase.SelectMany(d => d.Value).SelectMany(d => d.Value).Select(d => new { d.Key, d.Value.Value })))

                Assert.Fail("Level3");

        }

    }

​

    public class TestClass

    {

        public static void Test()

        {

            var dispatcher = Dispatcher.LoadFromFile();

            dispatcher.Set(1, 2, 3, new Message { Value = "hello" });

            dispatcher.SaveToFile();

            var xml1 = File.ReadAllText(Dispatcher.FileName);

            Console.WriteLine(xml1);

            var dispatcher2 = Dispatcher.LoadFromFile();

​

            dispatcher2.SaveToFile();

            var xml2 = File.ReadAllText(Dispatcher.FileName);

​

            Assert.IsTrue(xml1 == xml2);

            Dispatcher.AssertEquals(dispatcher, dispatcher2);

            File.Delete(Dispatcher.FileName);

        }

    }

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: {0} ({1})", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , GetNetCoreVersion());

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

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

                Console.WriteLine(ex);

                throw;

            }

        }

        public static string GetNetCoreVersion()

        {

            //https://techblog.dorogin.com/how-to-detect-net-core-version-in-runtime-ecd65ad695be

            //

            var assembly = typeof(System.Runtime.GCSettings).GetTypeInfo().Assembly;

            var assemblyPath = assembly.CodeBase.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);

            int netCoreAppIndex = Array.IndexOf(assemblyPath, "Microsoft.NETCore.App");

            if (netCoreAppIndex > 0 && netCoreAppIndex < assemblyPath.Length - 2)

                return assemblyPath[netCoreAppIndex + 1];

            return null;

        }

    }

​