Fix default handling for optional elements with simple content (fixes #645)

Author: mganss

XmlSchemaClassGenerator.Tests/ElementTextDefaultTests.cs

@@ -0,0 +1,48 @@
+using System.IO;
+using System.Xml.Serialization;
+using Xunit;
+
+namespace XmlSchemaClassGenerator.Tests;
+
+public class ElementTextDefaultTests
+{
+    /// 
+    /// The default of an optional element with simple content applies to the text value of the element,
+    /// so the element must stay null when absent and get the default only when present but empty.
+    /// 
+    [Fact]
+    public void OptionalElementDefaultIsAppliedToTextValue()
+    {
+        var assembly = Compiler.Generate(nameof(OptionalElementDefaultIsAppliedToTextValue), "xsd/ElementTextDefault/*.xsd", new Generator
+        {
+            NamespaceProvider = new NamespaceProvider { GenerateNamespace = _ => "Test" }
+        });
+
+        var geometryType = assembly.GetType("Test.Geometry");
+        Assert.NotNull(geometryType);
+        var serializer = new XmlSerializer(geometryType);
+
+        var geometry = System.Activator.CreateInstance(geometryType);
+        Assert.Null(geometryType.GetProperty("ThicknessReduction").GetValue(geometry));
+
+        const string absent = "";
+        var absentObject = serializer.Deserialize(new StringReader(absent));
+        Assert.Null(geometryType.GetProperty("ThicknessReduction").GetValue(absentObject));
+
+        var writer = new StringWriter();
+        serializer.Serialize(writer, absentObject);
+        Assert.DoesNotContain("thicknessReduction", writer.ToString());
+
+        const string empty = "\"Bottom\" />";
+        var emptyObject = serializer.Deserialize(new StringReader(empty));
+        var reduction = geometryType.GetProperty("ThicknessReduction").GetValue(emptyObject);
+        Assert.NotNull(reduction);
+        Assert.Equal(false, reduction.GetType().GetProperty("Value").GetValue(reduction));
+        Assert.Equal("Bottom", reduction.GetType().GetProperty("Reference").GetValue(reduction).ToString());
+
+        const string explicitValue = "\"Top\">true";
+        var explicitObject = serializer.Deserialize(new StringReader(explicitValue));
+        reduction = geometryType.GetProperty("ThicknessReduction").GetValue(explicitObject);
+        Assert.Equal(true, reduction.GetType().GetProperty("Value").GetValue(reduction));
+    }
+}

XmlSchemaClassGenerator.Tests/xsd/ElementTextDefault/element-text-default.xsd

@@ -0,0 +1,24 @@
+xml version="1.0" encoding="utf-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
+  <xs:simpleType name="ReferenceType">
+    <xs:restriction base="xs:string">
+      <xs:enumeration value="Top"/>
+      <xs:enumeration value="Bottom"/>
+    xs:restriction>
+  xs:simpleType>
+  <xs:element name="geometry">
+    <xs:complexType>
+      <xs:sequence>
+        <xs:element name="thicknessReduction" minOccurs="0" default="false">
+          <xs:complexType>
+            <xs:simpleContent>
+              <xs:extension base="xs:boolean">
+                <xs:attribute name="reference" type="ReferenceType" use="required"/>
+              xs:extension>
+            xs:simpleContent>
+          xs:complexType>
+        xs:element>
+      xs:sequence>
+    xs:complexType>
+  xs:element>
+xs:schema>

XmlSchemaClassGenerator/ModelBuilder.cs

@@ -1186,6 +1186,16 @@ private PropertyModel PropertyFromElement(TypeModel owningTypeModel, XmlSchemaEl
         property.SetFromNode(originalName, isRequired, element);
         property.SetSchemaNameAndNamespace(owningTypeModel, effectiveElement);
 
+        // The default of an optional element with simple content applies to its text value, not to the element:
+        // move it there so the element stays null when absent. Only possible if the anonymous type belongs to this element alone.
+        if (!isRequired && substitute == null && property.DefaultValue != null
+            && typeModel is ClassModel { IsAnonymous: true, IsMixed: false, DerivedTypes.Count: 0, BaseClass: not null and not ClassModel } textClass
+            && !string.IsNullOrEmpty(_configuration.TextValuePropertyName))
+        {
+            textClass.TextValueDefault = property.DefaultValue;
+            property.SetDefaultValue(null);
+        }
+
         if (property.IsArray && !_configuration.GenerateComplexTypesForCollections)
             property.Type.Namespace.Types.Remove(property.Type.Name);
 

XmlSchemaClassGenerator/Models/ClassModel.cs

@@ -18,6 +18,12 @@ public class ClassModel(GeneratorConfiguration configuration) : ReferenceTypeMod
     public bool IsSubstitution { get; set; }
     public TypeModel BaseClass { get; set; }
     public TypeModel TextValueType { get; set; }
+
+    /// 
+    /// Default for the text value of a simple-content class, taken from the default of the
+    /// (only) element that uses this anonymous type.
+    /// 
+    public string TextValueDefault { get; set; }
     public List<ClassModel> DerivedTypes { get; set; } = [];
     public override bool IsSubtype => BaseClass != null;
 
@@ -199,12 +205,15 @@ public override CodeTypeDeclaration Generate()
                 var enableDataBinding = Configuration.EnableDataBinding;
                 var typeReference = BaseClass.GetReferenceFor(Namespace);
 
+                var textDefaultExpression = TextValueDefault != null ? BaseClass.GetDefaultValueFor(TextValueDefault, false) : null;
+
                 CodeMemberField backingFieldMember = null;
-                if (enableDataBinding)
+                if (enableDataBinding || textDefaultExpression != null)
                 {
                     backingFieldMember = new CodeMemberField(typeReference, textName.ToBackingField(Configuration.PrivateMemberPrefix))
                     {
-                        Attributes = MemberAttributes.Private
+                        Attributes = MemberAttributes.Private,
+                        InitExpression = textDefaultExpression
                     };
                     classDeclaration.Members.Add(backingFieldMember);
                 }
@@ -222,6 +231,14 @@ public override CodeTypeDeclaration Generate()
                 var attribute = AttributeDecl<XmlTextAttribute>();
                 var valuePropertyModel = new PropertyModel(Configuration, textName, BaseClass, this);
 
+                if (textDefaultExpression != null)
+                {
+                    valuePropertyModel.SetDefaultValue(TextValueDefault);
+
+                    if (textDefaultExpression is CodePrimitiveExpression or CodeFieldReferenceExpression)
+                        text.CustomAttributes.Add(valuePropertyModel.CreateDefaultValueAttribute(typeReference, textDefaultExpression));
+                }
+
                 if (BaseClass is SimpleModel simpleModel)
                 {
                     docs.AddRange(simpleModel.Restrictions.Select(r => new DocumentationModel { Language = English, Text = r.Description }));

XmlSchemaClassGenerator/Models/PropertyModel.cs

@@ -178,7 +178,9 @@ private void AddDocs(CodeTypeMember member)
     internal bool HasCollectionItemStringLengthAttribute
         => IsEnumerable && PropertyType is SimpleModel simpleType && simpleType.GetCollectionItemStringLengthAttribute() != null;
 
-    private CodeAttributeDeclaration CreateDefaultValueAttribute(CodeTypeReference typeReference, CodeExpression defaultValueExpression)
+    internal void SetDefaultValue(string defaultValue) => DefaultValue = defaultValue;
+
+    internal CodeAttributeDeclaration CreateDefaultValueAttribute(CodeTypeReference typeReference, CodeExpression defaultValueExpression)
     {
         var defaultValueAttribute = AttributeDecl<DefaultValueAttribute>();