XmlContentSerializer.cs

using System;
using System.Collections.Concurrent;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Serialization;

namespace Refit
{
    /// <summary>
    /// A <see langword="class"/> implementing <see cref="IHttpContentSerializer"/> which provides Xml content serialization.
    /// </summary>
    public class XmlContentSerializer : IHttpContentSerializer
    {
        readonly XmlContentSerializerSettings settings;
        readonly ConcurrentDictionary<Type, XmlSerializer> serializerCache = new();

        public XmlContentSerializer()
            : this(new XmlContentSerializerSettings()) { }

        public XmlContentSerializer(XmlContentSerializerSettings settings)
        {
            this.settings = settings ?? throw new ArgumentNullException(nameof(settings));
        }

        /// <summary>
        /// Serialize object of type <typeparamref name="T"/> to a <see cref="HttpContent"/> with Xml.
        /// </summary>
        /// <typeparam name="T">Type of the object to serialize from.</typeparam>
        /// <param name="item">Object to serialize.</param>
        /// <returns><see cref="HttpContent"/> that contains the serialized <typeparamref name="T"/> object in Xml.</returns>
        /// <exception cref="ArgumentNullException"></exception>
        public HttpContent ToHttpContent<T>(T item)
        {
            if (item is null)
                throw new ArgumentNullException(nameof(item));

            var xmlSerializer = serializerCache.GetOrAdd(
                item.GetType(),
                t => new XmlSerializer(t, settings.XmlAttributeOverrides)
            );

            using var stream = new MemoryStream();
            using var writer = XmlWriter.Create(
                stream,
                settings.XmlReaderWriterSettings.WriterSettings
            );
            var encoding =
                settings.XmlReaderWriterSettings.WriterSettings?.Encoding ?? Encoding.Unicode;
            xmlSerializer.Serialize(writer, item, settings.XmlNamespaces);
            var str = encoding.GetString(stream.ToArray());
            var content = new StringContent(str, encoding, "application/xml");
            return content;
        }

        /// <summary>
        /// Deserializes an object of type <typeparamref name="T"/> from a <see cref="HttpContent"/> object that contains Xml content.
        /// </summary>
        /// <typeparam name="T">Type of the object to deserialize to.</typeparam>
        /// <param name="content">HttpContent object with Xml content to deserialize.</param>
        /// <param name="cancellationToken">CancellationToken to abort the deserialization.</param>
        /// <returns>The deserialized object of type <typeparamref name="T"/>.</returns>
        public async Task<T?> FromHttpContentAsync<T>(
            HttpContent content,
            CancellationToken cancellationToken = default
        )
        {
            var xmlSerializer = serializerCache.GetOrAdd(
                typeof(T),
                t =>
                    new XmlSerializer(
                        t,
                        settings.XmlAttributeOverrides,
                        Array.Empty<Type>(),
                        null,
                        settings.XmlDefaultNamespace
                    )
            );

            using var input = new StringReader(
                await content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false)
            );

            using var reader = XmlReader.Create(
                input,
                settings.XmlReaderWriterSettings.ReaderSettings
            );
            return (T?)xmlSerializer.Deserialize(reader);
        }

        /// <inheritdoc/>
        public string? GetFieldNameForProperty(PropertyInfo propertyInfo)
        {
            if (propertyInfo is null)
                throw new ArgumentNullException(nameof(propertyInfo));

            return propertyInfo
                    .GetCustomAttributes<XmlElementAttribute>(true)
                    .Select(a => a.ElementName)
                    .FirstOrDefault()
                ?? propertyInfo
                    .GetCustomAttributes<XmlAttributeAttribute>(true)
                    .Select(a => a.AttributeName)
                    .FirstOrDefault();
        }
    }

    public class XmlReaderWriterSettings
    {
        XmlReaderSettings readerSettings;
        XmlWriterSettings writerSettings;

        public XmlReaderWriterSettings()
            : this(new XmlReaderSettings(), new XmlWriterSettings()) { }

        public XmlReaderWriterSettings(XmlReaderSettings readerSettings)
            : this(readerSettings, new XmlWriterSettings()) { }

        public XmlReaderWriterSettings(XmlWriterSettings writerSettings)
            : this(new XmlReaderSettings(), writerSettings) { }

#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
        public XmlReaderWriterSettings(
            XmlReaderSettings readerSettings,
            XmlWriterSettings writerSettings
        )
#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
        {
            ReaderSettings = readerSettings;
            WriterSettings = writerSettings;
        }

        public XmlReaderSettings ReaderSettings
        {
            get
            {
                ApplyOverrideSettings();
                return readerSettings;
            }
            set => readerSettings = value ?? throw new ArgumentNullException(nameof(value));
        }

        public XmlWriterSettings WriterSettings
        {
            get
            {
                ApplyOverrideSettings();
                return writerSettings;
            }
            set => writerSettings = value ?? throw new ArgumentNullException(nameof(value));
        }

        /// <summary>
        /// The writer and reader settings are set by the caller, but certain properties
        /// should remain set to meet the demands of the XmlContentSerializer. Those properties
        /// are always set here.
        /// </summary>
        void ApplyOverrideSettings()
        {
            writerSettings.Async = true;
            readerSettings.Async = true;
        }
    }

    public class XmlContentSerializerSettings
    {
        public XmlContentSerializerSettings()
        {
            XmlDefaultNamespace = null;
            XmlReaderWriterSettings = new XmlReaderWriterSettings();
            XmlNamespaces = new XmlSerializerNamespaces(
                new[] { new XmlQualifiedName(string.Empty, string.Empty), }
            );

            XmlAttributeOverrides = new XmlAttributeOverrides();
        }

        public string? XmlDefaultNamespace { get; set; }

        public XmlReaderWriterSettings XmlReaderWriterSettings { get; set; }

        public XmlSerializerNamespaces XmlNamespaces { get; set; }

        public XmlAttributeOverrides XmlAttributeOverrides { get; set; }
    }
}