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 System.Collections.Concurrent;

​

using Microsoft.AspNetCore.Mvc.Formatters;

using Microsoft.Extensions.Logging;

​

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

​

//https://stackoverflow.com/questions/73127531/how-to-add-a-new-node-to-an-existing-xml-using-c-sharp

​

    public class CachedXmlSerializerOutputFormatter : XmlSerializerOutputFormatter

    {

        // Cache and reuse the serializers returned by base.CreateSerializer(t).  When null is returned for a non-serializable type,

        // a null serializer will be cached and returned.

        static readonly ConcurrentDictionary<Type, XmlSerializer> Serializers = new ConcurrentDictionary<Type, XmlSerializer>();

​

        public CachedXmlSerializerOutputFormatter() : base() { }

        public CachedXmlSerializerOutputFormatter(ILoggerFactory loggerFactory) : base(loggerFactory) { }

        public CachedXmlSerializerOutputFormatter(XmlWriterSettings writerSettings) : base(writerSettings) { }

        public CachedXmlSerializerOutputFormatter(XmlWriterSettings writerSettings, ILoggerFactory loggerFactory) : base(writerSettings, loggerFactory) { }

​

        protected override XmlSerializer CreateSerializer(Type type) { return Serializers.GetOrAdd(type, (t) => base.CreateSerializer(t)); }

    }

​

    public class TestClass

    {

        static int NumberOfFailures = 0;

        private static Assembly MyResolveEventHandler(object sender, ResolveEventArgs args)

        {

            Console.WriteLine("Failed trying to resolve {0}", args.Name);

            NumberOfFailures++;

            return null;

        }

​

        public static void Test()

        {

            //Console.WriteLine(typeof(XmlSerializer).GetProperty("Mode", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static).GetValue(null));

​

            AppDomain currentDomain = AppDomain.CurrentDomain;

            currentDomain.AssemblyResolve += new ResolveEventHandler(MyResolveEventHandler);

​

            var formatter = new CachedXmlSerializerOutputFormatter();

​

            var dto = new

            {

                Name = "name",

                Value = "value",

            };

​

            int startNumberOfFailures = NumberOfFailures;

            for (int i = 0; i < 12; i++)

            {

                try

                {

                    //Console.WriteLine(formatter.CanWriteResult()

                    var v = formatter.GetType().GetMethod("CanWriteType", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).Invoke(formatter, new [] { dto.GetType() });

                }

                catch (Exception ex)

                {

                    if (i == 0)

                        Console.WriteLine("Caught {0}", ex);

                }

            }

​

            int endNumberOfFailures = NumberOfFailures;

​

            Console.WriteLine("Total number of resolve failures when calling XmlSerializerOutputFormatter.CanWriteType({0}): {1}", dto.GetType().Name, endNumberOfFailures - startNumberOfFailures);

        }

    }

​

    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;

            }

        }

    }

​

#if false

    public static class XmlSerializerFactory

    {

        static readonly ConcurrentDictionary<Type, XmlSerializer> Serializers = new ConcurrentDictionary<Type, XmlSerializer>();

        static readonly ConcurrentDictionary<ValueTuple<Type, string>, XmlSerializer> SerializersWithNamespace =  new ConcurrentDictionary<ValueTuple<Type, string>, XmlSerializer>();

        public static XmlSerializer Create(Type type) { return Serializers.GetOrAdd(type, (t) => new XmlSerializer(t)); }

        public static XmlSerializer Create(Type type, string defaultNamespace) { return SerializersWithNamespace.GetOrAdd(ValueTuple.Create(type, defaultNamespace), (t) => new XmlSerializer(t.Item1, t.Item2)); }

    }

#endif

​