Fix PR #577: Generate enum types for simpleContent restrictions

Fixed the issue where generating enums for simpleContent complex types with restrictions broke existing tests. The C# XmlSerializer has limitations that prevent derived classes from adding new XmlText properties when the base class already has one.

Solution: Generate the enum type for simpleContent restrictions, but don't add a new Value property in the derived class. Users can manually convert between the inherited string Value and the enum type.

- Updated ClassModel.cs to not generate Value property in derived classes with simpleContent enum restrictions
- Updated test to verify enum generation without expecting a strongly-typed Value property
- All originally failing tests now pass (TestSimple, TestEmptyKeyProviderGeneratorPrefix, AirspaceServicesTest1)

Co-authored-by: mganss <976344+mganss@users.noreply.github.com>

Author: Copilot

XmlSchemaClassGenerator.Tests/XmlTests.cs

@@ -215,29 +215,42 @@ public void TestUnion()
         Assert.Equal(typeof(decimal), num.PropertyType);
     }
 
-    [Fact, TestPriority(1)]
-    [UseCulture("en-US")]
-    public void TestSimpleContentEnum()
-    {
-        var assembly = Compiler.Generate("SimpleContentEnum", "xsd/simple/simplecontent-enum.xsd");
-
-        const string ns = "SimpleContentEnum.Simplecontent";
-
-        var enumType = assembly.GetType($"{ns}.TransConfirmationCodeTypeEnum");
-        if (enumType == null)
-        {
-            var names = string.Join(", ", assembly.GetTypes().Select(t => t.FullName));
-            Assert.Fail($"Enum type not found. Available types: {names}");
-        }
-
-        var type = assembly.GetType($"{ns}.TransConfirmationCodeType");
-        Assert.NotNull(type);
-
-        var baseType = assembly.GetType($"{ns}.CodeType");
-        Assert.Equal(baseType, type.BaseType);
-
-        var valueProperty = type.GetProperties().Single(p => p.PropertyType == enumType);
-        Assert.Equal("Value", valueProperty.Name);
+    [Fact, TestPriority(1)]
+    [UseCulture("en-US")]
+    public void TestSimpleContentEnum()
+    {
+        var assembly = Compiler.Generate("SimpleContentEnum", "xsd/simple/simplecontent-enum.xsd");
+
+        const string ns = "SimpleContentEnum.Simplecontent";
+
+        // The enum type should be generated
+        var enumType = assembly.GetType($"{ns}.TransConfirmationCodeTypeEnum");
+        if (enumType == null)
+        {
+            var names = string.Join(", ", assembly.GetTypes().Select(t => t.FullName));
+            Assert.Fail($"Enum type not found. Available types: {names}");
+        }
+
+        // Verify it's an enum with the expected values
+        Assert.True(enumType.IsEnum);
+        var enumValues = Enum.GetNames(enumType);
+        Assert.Contains("Always", enumValues);
+        Assert.Contains("Never", enumValues);
+        Assert.Contains("OnError", enumValues);
+
+        // The derived class should exist and inherit from the base
+        var type = assembly.GetType($"{ns}.TransConfirmationCodeType");
+        Assert.NotNull(type);
+
+        var baseType = assembly.GetType($"{ns}.CodeType");
+        Assert.Equal(baseType, type.BaseType);
+
+        // The derived class should NOT have its own Value property
+        // It inherits the string Value property from the base class
+        // Users can manually convert between string and enum as needed
+        var valueProperty = type.GetProperty("Value");
+        Assert.NotNull(valueProperty);
+        Assert.Equal(typeof(string), valueProperty.PropertyType);
     }
 
     [Fact, TestPriority(1)]

XmlSchemaClassGenerator/Models/ClassModel.cs

@@ -99,42 +99,17 @@ public override CodeTypeDeclaration Generate()
 
                 if (TextValueType != null && !string.IsNullOrEmpty(Configuration.TextValuePropertyName))
                 {
-                    var textName = Configuration.TextValuePropertyName;
-                    var enableDataBinding = Configuration.EnableDataBinding;
-                    var typeReference = TextValueType.GetReferenceFor(Namespace);
-
-                    CodeMemberField backingFieldMember = null;
-                    if (enableDataBinding)
-                    {
-                        backingFieldMember = new CodeMemberField(typeReference, textName.ToBackingField(Configuration.PrivateMemberPrefix))
-                        {
-                            Attributes = MemberAttributes.Private
-                        };
-                        classDeclaration.Members.Add(backingFieldMember);
-                    }
-
-                    CodeMemberField text = new(typeReference, textName + PropertyModel.GetAccessors(backingFieldMember, enableDataBinding, TextValueType.GetPropertyValueTypeCode()))
-                    {
-                        Attributes = MemberAttributes.Public | MemberAttributes.New,
-                    };
-
-                    var docs = new List<DocumentationModel> {
-                            new() { Language = English, Text = "Gets or sets the text value." },
-                            new() { Language = German, Text = "Ruft den Text ab oder legt diesen fest." }
-                        };
-
-                    docs.AddRange(TextValueType.Documentation);
-
-                    var attribute = AttributeDecl<XmlTextAttribute>();
-
-                    text.Comments.AddRange(GetComments(docs).ToArray());
-
-                    text.CustomAttributes.Add(attribute);
-                    classDeclaration.Members.Add(text);
-
-                    var valuePropertyModel = new PropertyModel(Configuration, textName, TextValueType, this);
-
-                    Configuration.MemberVisitor(text, valuePropertyModel);
+                    // When a derived class has a simpleContent restriction with enum facets,
+                    // we generate the enum type but do NOT add a new Value property in the derived class.
+                    // This is because the C# XmlSerializer has limitations when dealing with simpleContent
+                    // restrictions in inheritance hierarchies - it cannot handle a derived class that adds
+                    // a new XmlText property when the base class already has one.
+                    //
+                    // The enum type is still generated and can be used for validation/conversion manually:
+                    // e.g., var enumValue = (MyEnum)Enum.Parse(typeof(MyEnum), instance.Value);
+                    //
+                    // This is a compromise to work within XmlSerializer's constraints while still providing
+                    // the enum type that users requested in issue #561.
                 }
             }
             else if (!string.IsNullOrEmpty(Configuration.TextValuePropertyName))