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.IO.MemoryMappedFiles;

using System.Runtime.Serialization;

using System.Runtime.Versioning;

​

using System.Xml;

using System.Xml.Serialization;

using System.Xml.Linq;

​

using Debug = System.Console;

​

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

​

//https://stackoverflow.com/questions/79005457/system-runtime-serialization-serializationexception-the-data-at-the-root-level

​

#nullable enable

​

    public static partial class DataContractSerializerExtensions

    {

        public static IEnumerable<T?> ReadObjectFragments<T>(Stream stream, DataContractSerializer? serializer = null, bool closeInput = true)

        {

            var settings = new XmlReaderSettings

            {

                ConformanceLevel = ConformanceLevel.Fragment,

                CloseInput = closeInput,

            };

            serializer ??= new DataContractSerializer(typeof(T));

            using (var outerReader = XmlReader.Create(stream, settings))

            {

                while (outerReader.Read())

                {   // Skip whitespace

                    if (outerReader.NodeType == XmlNodeType.Element)

                        using (var innerReader = outerReader.ReadSubtree())

                        {

                            yield return (T?)serializer.ReadObject(innerReader);

                        }

                }

            }

        }

    }

​

    class TestClass

    {

        public static void Test()

        {

            // Fix for Unix taken from this answer https://stackoverflow.com/a/77149446

            // by https://stackoverflow.com/users/1576055/user1576055

            // To https://stackoverflow.com/questions/66308340/how-to-use-net-memory-mapped-file-in-linux-without-persisted-file

            using (var mmf = MemoryMappedFile.CreateFromFile("/dev/shm/test", System.IO.FileMode.OpenOrCreate, null, 10240, MemoryMappedFileAccess.ReadWrite))

            //using (MemoryMappedFile.CreateNew("TempName", 10240, MemoryMappedFileAccess.ReadWrite))

            {

                WriteToMemoryMappedFile(mmf);

​

                var infoObj = ReadFromMemoryMappedFile(mmf);

​

                Console.WriteLine(infoObj?.Name);

                Assert.That(infoObj?.Name == "TestApp");

            }

        }   

        private static void WriteToMemoryMappedFile(MemoryMappedFile mmf)

        {

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

​

            var infoObj = new SampleClass { Name = "TestApp" };

​

            using (var stream = mmf.CreateViewStream(0, 0, MemoryMappedFileAccess.Write))

            {

                Debug.WriteLine(stream.Length); // Prints 10240

                serializer.WriteObject(stream, infoObj);

                stream.Flush();

            }

        }

​

        private static SampleClass? ReadFromMemoryMappedFile(MemoryMappedFile mmf)

        {

            using (var stream = mmf.CreateViewStream(0, 0, MemoryMappedFileAccess.Read))

            {

                return DataContractSerializerExtensions.ReadObjectFragments<SampleClass>(stream).FirstOrDefault();

            }

        }

    }

​

    [DataContract]

    public class SampleClass

    {

        [DataMember]

        public string? Name { get; set; }

    }

​

    public static partial class DataContractSerializerHelper

    {

        public static string ToContractXml<T>(this T obj, DataContractSerializer? serializer = null, XmlWriterSettings? settings = null)

        {

            serializer = serializer ?? new DataContractSerializer(obj == null ? typeof(T) : obj.GetType());

            using (var textWriter = new StringWriter())

            {

                settings = settings ?? new XmlWriterSettings { Indent = true };

                using (var xmlWriter = XmlWriter.Create(textWriter, settings))

                {

                    serializer.WriteObject(xmlWriter, obj);

                }

                return textWriter.ToString();

            }

        }

​

        public static T? FromContractXml<T>(string xml, DataContractSerializer? serializer = null)

        {

            using (var textReader = new StringReader(xml ?? ""))

            using (var xmlReader = XmlReader.Create(textReader))

            {

                return (T?)(serializer ?? new DataContractSerializer(typeof(T))).ReadObject(xmlReader);

            }

        }

    }

​

    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();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

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

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​