.NET 6 XmlSerializer no longer emits line breaks #64885

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Xml.Serialization;

namespace XmlSerializerNet6
{
    class Program
    {
        static void Main(string[] args)
        {
            List<TranslationItem> items = new();
            items.Add(new(name: "$this", property: "Text", source: "MyName"));

            List<TranslationCategory> categories = new();

            TranslationCategory category = new(name: "MyForm", sourceLanguage: "en", targetLanguage: "");
            category.Body = new() { TranslationItems = items };
            categories.Add(category);

            TranslationFile file = new()
            {
                 GitExVersion = "33.33.33",
                 SourceLanguage = "en",
                 TargetLanguage = "ru",
                 TranslationCategories = categories
            };

            Serialize(file, "test.xlf");
        }

        public static void Serialize(TranslationFile translation, string path)
        {
            using TextWriter tw = new StreamWriter(path, false);
            XmlSerializer serializer = new(typeof(TranslationFile));
            serializer.Serialize(tw, translation);
        }
    }

    /// <summary>Provides a translation for a specific language.</summary>
    [XmlRoot("xliff")]
    public class TranslationFile
    {
        public TranslationFile()
        {
            Version = "1.0";
            TranslationCategories = new List<TranslationCategory>();
        }

        [XmlAttribute("version")]
        public string Version { get; set; }

        [XmlAttribute("GitExVersion")]
        public string? GitExVersion { get; set; }

        [XmlIgnore]
        public string? SourceLanguage { get; set; }

        [XmlIgnore]
        public string? TargetLanguage { get; set; }

        [XmlElement(ElementName = "file")]
        public List<TranslationCategory> TranslationCategories { get; set; }

    }

    [DebuggerDisplay("{" + nameof(Name) + "}")]
    public class TranslationCategory : IComparable<TranslationCategory>
    {
        public TranslationCategory()
        {
        }

        public TranslationCategory(string name, string? sourceLanguage, string? targetLanguage = null)
        {
            Name = name;
            SourceLanguage = sourceLanguage;
            TargetLanguage = targetLanguage;
        }

        [XmlAttribute("datatype")]
        public string DataType { get; set; } = "plaintext";

        [XmlAttribute("original")]
        public string? Name { get; set; }

        [XmlAttribute("source-language")]
        public string? SourceLanguage { get; set; }

        [XmlAttribute("target-language")]
        public string? TargetLanguage { get; set; }

        [XmlElement(ElementName = "body")]
        public TranslationBody Body { get; set; } = new();

        public int CompareTo(TranslationCategory other) => StringComparer.InvariantCulture.Compare(Name, other.Name);
    }

    public class TranslationBody
    {
        public TranslationBody()
        {
            TranslationItems = new List<TranslationItem>();
        }

        [XmlElement(ElementName = "trans-unit")]
        public List<TranslationItem> TranslationItems { get; set; }
    }

    [DebuggerDisplay("{Name}.{Property}={Value}")]
    public class TranslationItem : IComparable<TranslationItem>, ICloneable
    {
        public TranslationItem()
        {
        }

        public TranslationItem(string name, string property, string source)
        {
            Name = name;
            Property = property;
            Source = source;
        }

        public TranslationItem(string? name, string? property, string? source, string? value)
        {
            Name = name;
            Property = property;
            Source = source;
            Value = value;
        }

        [XmlIgnore]
        public string? Name { get; set; }

        [XmlIgnore]
        public string? Property { get; set; }

        [XmlAttribute("id")]
        public string Id
        {
            get => Name + "." + Property;
            set
            {
                var values = value.Split(new char[] { '.' }, 2);
                Name = values[0];
                Property = values.Length > 1 ? values[1] : "";
            }
        }

        [XmlElement("source")]
        public string? Source { get; set; }

        [XmlElement("target")]
        public string? Value { get; set; }

        public int CompareTo(TranslationItem other)
        {
            int val = string.Compare(Name, other.Name, StringComparison.Ordinal);
            if (val == 0)
            {
                val = string.Compare(Property, other.Property, StringComparison.Ordinal);
            }

            return val;
        }

        object ICloneable.Clone()
        {
            return Clone();
        }

        public TranslationItem Clone()
        {
            return new TranslationItem(Name, Property, Source, Value);
        }
    }
}