How to serialize an Xml file with a CDATA section using XmlSerializer?

I need to generate an Xml file in this format:

<root>
   <![CDATA[
   <info>
      <number>12</number>
      <files>1</files>
   </info> 
   ]]>
   <info2>
      <prop1> prop1 </prop1>
   </info2>
</root>

One of the tags must contain a CDATA section, while the others are in the standard format.

I was able to generate it using XmlSerializer but without the CDATA section, but I can't think of a way to serialize it with this CDATA section

Solution

You can use the [XmlText] attribute to indicate that a property should be serialized as text rather than markup, for instance:

[XmlRoot("root")]
public class Root
{
    [XmlText]
    public string Value { get; set; }

    [XmlElement("info2")]
    public Info2 Info2 { get; set; }    
}

However, if you populate Root.Value with the contents of the CData shown in your question, the resulting XML, while well-formed, will have its characters escaped individually rather than as CData:

<root>&lt;info&gt;
   &lt;number&gt;12&lt;/number&gt;
   &lt;files&gt;1&lt;/files&gt;
&lt;/info&gt; <Info2><prop1> prop1 </prop1></Info2></root>

Demo fiddle #1 here.

This form of XML escaping is semantically equivalent to CData escaping, but if for some reason you require CData escaping, you can make use of the following functionality noted in the remarks for XmlTextAttribute.

The XmlTextAttribute can also be applied to a field that returns an XmlNode or an array of XmlNode objects.

The trick is to introduce a surrogate XmlNode [] property that returns the required text content encapsulated in an XmlCDataSection object contained in the XmlNode array. If we further assume that the content is the result of serializing some other property named e.g. Info, your data model could look something like the following:

[XmlRoot("root")]
public class Root
{
    [XmlIgnore]
    public Info Info { get; set; }
    
    //https://learn.microsoft.com/en-us/dotnet/api/system.xml.serialization.xmltextattribute?view=net-8.0
    //The XmlTextAttribute can also be applied to a field that returns an XmlNode or an array of XmlNode objects.
    [XmlText]
    public XmlNode [] XmlValue 
    {
        get => new XmlNode [] { new XmlDocument().CreateCDataSection(Info.GetXml(indent : true, omitStandardNamespaces : true, omitXmlDeclaration : true)) };
        set
        {
            var xml = string.Concat(value?.Cast<XmlCharacterData>().Select(c => c.Value)).Trim();
            if (!string.IsNullOrEmpty(xml))
                Info = xml.LoadFromXml<Info>();
        }
    }
    
    [XmlElement("info2")]
    public Info2 Info2 { get; set; }    
}

[XmlRoot("info")]
public class Info
{
    [XmlElement("number")] public int Number { get; set; }
    [XmlElement("files")] public int Files { get; set; }
}

public class Info2
{
    [XmlElement("prop1")]
    public string Prop1 { get; set; }
}

It uses the following extension methods:

public static partial class XmlSerializationHelper
{
    public static T? LoadFromXml<T>(this string xmlString, XmlSerializer? serializer = null)
    {
        using (var reader = new StringReader(xmlString))
            return (T?)(serializer ?? new(typeof(T))).Deserialize(reader);
    }

    public static string GetXml<T>(this T? obj, XmlSerializer? serializer = null, bool indent = true, bool omitStandardNamespaces = false, bool omitXmlDeclaration = false)
    {
        XmlSerializerNamespaces? ns = null;
        if (omitStandardNamespaces)
        {
            ns = new ();
            ns.Add("", ""); // Disable the xmlns:xsi and xmlns:xsd lines.
        }           
        using var textWriter = new StringWriter();
        var settings = new XmlWriterSettings() { Indent = indent, OmitXmlDeclaration = omitXmlDeclaration };
        using (var xmlWriter = XmlWriter.Create(textWriter, settings))
            (serializer ?? new(obj?.GetType() ?? typeof(T))).Serialize(xmlWriter, obj, ns);
        return textWriter.ToString();
    }
}

This version of Root, when serialized with XmlSerializer, generates the following XML:

<root><![CDATA[<info>
  <number>1</number>
  <files>1</files>
</info>]]><info2><prop1> prop1 </prop1></info2></root>

Demo fiddle #2 here.

Notes:

Your <root> element contains mixed content. As explained in the documentation for XmlWriterSettings.Indent

The elements are indented as long as the element does not contain mixed content. Once the WriteString or WriteWhitespace method is called to write out a mixed element content, the XmlWriter stops indenting. The indenting resumes once the mixed content element is closed.

Thus it does not seem possible to get the precise indenting shown in your question with the .NET XmlWriter. Since such whitespace is not significant this should not matter for any receiving system, but if it does you may need to adopt a different XML framework or write your own XmlWriter subclass.

Post-processing with a regex might be another option.
For some reason, if I declare the XmlValue property to return a single XmlNode, e.g.
```
 [XmlText]
 public XmlNode XmlValue { get => new XmlDocument().CreateCDataSection(Value); set => Value = value?.Value; }
```
Then, in .NET 8, the XmlSerializer constructor will fail and throw an exception despite being documented to work:

System.InvalidOperationException: Cannot serialize member 'XmlValue' of type System.Xml.XmlNode. XmlAttribute/XmlText cannot be used to encode complex types.

This is why I used an array property instead.

Failing fiddle here.
The [XmlText] solution seems much simpler than implementing IXmlSerializable as suggested in Problems serializing a class to XML and including a CDATA section.