Merge pull request #583 from igotinfected/feature/generate-list-of-enums-instead-of-strings

Add `EnumCollection` flag which allows generating list of enums

Author: mganss

README.md

@@ -200,7 +200,10 @@ Options:
       --oxi, --omitXmlIncludeAttribute
                              omit generation of XmlIncludeAttribute for derived
                                types (default is false)
-	  --ns, --namingScheme   use the specified naming scheme for class and
+      --ecl, --enumCollection
+                             generate typed enum collections for xs:list types
+                             instead of string collections (default is false)
+      --ns, --namingScheme   use the specified naming scheme for class and
                                property names (default is Pascal; can be:
                                Direct, Pascal, Legacy)
       --fu, --forceUriScheme=VALUE

XmlSchemaClassGenerator.Console/Program.cs

@@ -1,4 +1,4 @@
-using XmlSchemaClassGenerator;
+using XmlSchemaClassGenerator;
 using XmlSchemaClassGenerator.NamingProviders;
 using System;
 using System.CodeDom;
@@ -69,8 +69,9 @@ static int Main(string[] args)
         var separateNamespaceHierarchy = false;
         var serializeEmptyCollections = false;
         var allowDtdParse = false;
-        var omitXmlIncludeAttribute = false;
-        NamingScheme? namingScheme = null;
+        var omitXmlIncludeAttribute = false;
+        var enumCollection = false;
+        NamingScheme? namingScheme = null;
         var forceUriScheme = "none";
 
 
@@ -170,7 +171,8 @@ A file name may be given by appending a pipe sign (|) followed by a file name (l
             { "uc|unionCommonType", "generate a common type for unions if possible (default is false)", v => unionCommonType = v != null },
             { "ec|serializeEmptyCollections", "serialize empty collections (default is false)", v => serializeEmptyCollections = v != null },
             { "dtd|allowDtdParse", "allows dtd parse (default is false)", v => allowDtdParse = v != null },
-            { "oxi|omitXmlIncludeAttribute", "omit generation of XmlIncludeAttribute for derived types (default is false)", v => omitXmlIncludeAttribute = v != null },
+            { "oxi|omitXmlIncludeAttribute", "omit generation of XmlIncludeAttribute for derived types (default is false)", v => omitXmlIncludeAttribute = v != null },
+            { "ecl|enumCollection", "generate typed enum collections for xs:list types instead of string collections (default is false)", v => enumCollection = v != null },
             { "ns|namingScheme=", @"use the specified naming scheme for class and property names (default is Pascal; can be: Direct, Pascal, Legacy)",
                 v =>
                 {
@@ -272,8 +274,9 @@ A file name may be given by appending a pipe sign (|) followed by a file name (l
             SeparateNamespaceHierarchy = separateNamespaceHierarchy,
             SerializeEmptyCollections = serializeEmptyCollections,
             AllowDtdParse = allowDtdParse,
-            OmitXmlIncludeAttribute = omitXmlIncludeAttribute,
-            ForceUriScheme = forceUriScheme
+            OmitXmlIncludeAttribute = omitXmlIncludeAttribute,
+            EnumCollection = enumCollection,
+            ForceUriScheme = forceUriScheme
         };
 
         if (namingScheme != null)

XmlSchemaClassGenerator.Tests/Compiler.cs

@@ -120,6 +120,7 @@ public static Assembly GenerateFiles(string name, IEnumerable<string> files, Gen
             MapUnionToWidestCommonType = generatorPrototype.MapUnionToWidestCommonType,
             SeparateNamespaceHierarchy = generatorPrototype.SeparateNamespaceHierarchy,
             OmitXmlIncludeAttribute = generatorPrototype.OmitXmlIncludeAttribute,
+            EnumCollection = generatorPrototype.EnumCollection,
         };
 
         gen.CommentLanguages.Clear();

XmlSchemaClassGenerator.Tests/XmlTests.cs

@@ -59,7 +59,8 @@ private static IEnumerable<string> ConvertXml(string name, IEnumerable<string> x
             UseArrayItemAttribute = generatorPrototype.UseArrayItemAttribute,
             EnumAsString = generatorPrototype.EnumAsString,
             AllowDtdParse = generatorPrototype.AllowDtdParse,
-            OmitXmlIncludeAttribute = generatorPrototype.OmitXmlIncludeAttribute
+            OmitXmlIncludeAttribute = generatorPrototype.OmitXmlIncludeAttribute,
+            EnumCollection = generatorPrototype.EnumCollection,
         };
 
         gen.CommentLanguages.Clear();
@@ -186,35 +187,35 @@ public void TestGuid()
 
     [Fact, TestPriority(1)]
     [UseCulture("en-US")]
-    public void TestUnion()
-    {
-        var assembly = Compiler.Generate("Union", UnionPattern, new Generator
-        {
-            NamespacePrefix = "Union",
-            IntegerDataType = typeof(int),
-            MapUnionToWidestCommonType = true
-        });
-
-        Assert.NotNull(assembly);
-
-        SharedTestFunctions.TestSamples(Output, "Union", UnionPattern);
-
-        var snapshotType = assembly.GetType("Union.Snapshot");
-        Assert.NotNull(snapshotType);
-
-        var date = snapshotType.GetProperty("Date");
-        Assert.NotNull(date);
-        Assert.Equal(typeof(DateTime), date.PropertyType);
-
-        var count = snapshotType.GetProperty("Count");
-        Assert.NotNull(count);
-        Assert.Equal(typeof(int), count.PropertyType);
-
-        var num = snapshotType.GetProperty("Num");
-        Assert.NotNull(num);
-        Assert.Equal(typeof(decimal), num.PropertyType);
-    }
-
+    public void TestUnion()
+    {
+        var assembly = Compiler.Generate("Union", UnionPattern, new Generator
+        {
+            NamespacePrefix = "Union",
+            IntegerDataType = typeof(int),
+            MapUnionToWidestCommonType = true
+        });
+
+        Assert.NotNull(assembly);
+
+        SharedTestFunctions.TestSamples(Output, "Union", UnionPattern);
+
+        var snapshotType = assembly.GetType("Union.Snapshot");
+        Assert.NotNull(snapshotType);
+
+        var date = snapshotType.GetProperty("Date");
+        Assert.NotNull(date);
+        Assert.Equal(typeof(DateTime), date.PropertyType);
+
+        var count = snapshotType.GetProperty("Count");
+        Assert.NotNull(count);
+        Assert.Equal(typeof(int), count.PropertyType);
+
+        var num = snapshotType.GetProperty("Num");
+        Assert.NotNull(num);
+        Assert.Equal(typeof(decimal), num.PropertyType);
+    }
+
     [Fact, TestPriority(1)]
     [UseCulture("en-US")]
     public void TestSimpleContentEnum()
@@ -275,13 +276,13 @@ public void TestSimpleContentEnum()
         enumValueProperty.SetValue(instance, null);
         stringValue = valueProperty.GetValue(instance);
         Assert.Null(stringValue);
-    }
-
-    [Fact, TestPriority(1)]
-    [UseCulture("en-US")]
-    public void TestList()
-    {
-        Compiler.Generate("List", ListPattern);
+    }
+
+    [Fact, TestPriority(1)]
+    [UseCulture("en-US")]
+    public void TestList()
+    {
+        Compiler.Generate("List", ListPattern);
         SharedTestFunctions.TestSamples(Output, "List", ListPattern);
     }
 
@@ -517,6 +518,112 @@ public void TestListWithPublicPropertySettersWithoutConstructorsSpecified()
         }
     }
 
+    [Fact]
+    public void TestEnumCollection()
+    {
+        var assembly = Compiler.Generate("ListEnumCollection", ListPattern, new Generator
+        {
+            GenerateNullables = true,
+            IntegerDataType = typeof(int),
+            DataAnnotationMode = DataAnnotationMode.All,
+            GenerateDesignerCategoryAttribute = false,
+            GenerateComplexTypesForCollections = true,
+            EntityFramework = false,
+            GenerateInterfaces = true,
+            NamespacePrefix = "List",
+            GenerateDescriptionAttribute = true,
+            TextValuePropertyName = "Value",
+            EnumCollection = true
+        });
+
+        Assert.NotNull(assembly);
+
+        var myClassType = assembly.GetType("List.MyClass");
+        Assert.NotNull(myClassType);
+
+        var enumType = assembly.GetType("List.EnumType");
+        Assert.NotNull(enumType);
+        Assert.True(enumType.IsEnum);
+
+        // Element property: should be Collection<EnumType>, not Collection<string>
+        var enumElemProp = myClassType.GetProperty("EnumElem");
+        Assert.NotNull(enumElemProp);
+        Assert.True(enumElemProp.PropertyType.IsGenericType);
+        Assert.Equal(enumType, enumElemProp.PropertyType.GetGenericArguments()[0]);
+
+        // Attribute property: should use enum type, not string
+        var enumAttrProp = myClassType.GetProperty("EnumAttr");
+        Assert.NotNull(enumAttrProp);
+        if (enumAttrProp.PropertyType.IsArray)
+        {
+            Assert.Equal(enumType, enumAttrProp.PropertyType.GetElementType());
+        }
+        else if (enumAttrProp.PropertyType.IsGenericType)
+        {
+            Assert.Equal(enumType, enumAttrProp.PropertyType.GetGenericArguments()[0]);
+        }
+        else
+        {
+            Assert.Fail($"Expected array or generic collection, got {enumAttrProp.PropertyType}");
+        }
+
+        // Non-enum list properties should remain string-based
+        var timeListElemProp = myClassType.GetProperty("TimeListElem");
+        Assert.NotNull(timeListElemProp);
+        Assert.True(timeListElemProp.PropertyType.IsGenericType);
+        Assert.Equal(typeof(string), timeListElemProp.PropertyType.GetGenericArguments()[0]);
+    }
+
+    [Theory]
+    [InlineData(typeof(Collection<>), null)]
+    [InlineData(typeof(List<>), null)]
+    [InlineData(typeof(HashSet<>), null)]
+    [InlineData(typeof(Array), null)]
+    public void TestEnumCollectionRespectsCollectionType(Type collectionType, Type collectionImplementationType)
+    {
+        var assembly = Compiler.Generate($"ListEnumCollection_{collectionType.Name}_{collectionImplementationType?.Name}", ListPattern, new Generator
+        {
+            GenerateNullables = true,
+            IntegerDataType = typeof(int),
+            DataAnnotationMode = DataAnnotationMode.All,
+            GenerateDesignerCategoryAttribute = false,
+            GenerateComplexTypesForCollections = true,
+            EntityFramework = false,
+            GenerateInterfaces = true,
+            NamespacePrefix = "List",
+            GenerateDescriptionAttribute = true,
+            TextValuePropertyName = "Value",
+            EnumCollection = true,
+            CollectionType = collectionType,
+            CollectionImplementationType = collectionImplementationType
+        });
+
+        Assert.NotNull(assembly);
+
+        var myClassType = assembly.GetType("List.MyClass");
+        Assert.NotNull(myClassType);
+
+        var enumType = assembly.GetType("List.EnumType");
+        Assert.NotNull(enumType);
+
+        var enumElemProp = myClassType.GetProperty("EnumElem");
+        Assert.NotNull(enumElemProp);
+
+        if (collectionType == typeof(System.Array))
+        {
+            Assert.True(enumElemProp.PropertyType.IsArray);
+            Assert.Equal(enumType, enumElemProp.PropertyType.GetElementType());
+        }
+        else
+        {
+            Assert.True(enumElemProp.PropertyType.IsGenericType);
+            Assert.Equal(enumType, enumElemProp.PropertyType.GetGenericArguments()[0]);
+
+            var expectedCollectionType = collectionType.MakeGenericType(enumType);
+            Assert.Equal(expectedCollectionType, enumElemProp.PropertyType);
+        }
+    }
+
     public static TheoryData<CodeTypeReferenceOptions, NamingScheme, Type> TestSimpleData() {
         var theoryData = new TheoryData<CodeTypeReferenceOptions, NamingScheme, Type>();
         foreach (var referenceMode in new[]

XmlSchemaClassGenerator/Generator.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.CodeDom;
 using System.Collections.Generic;
 using System.IO;
@@ -366,13 +366,19 @@ public bool AllowDtdParse
         set { _configuration.AllowDtdParse = value; }
     }
 
-    public bool OmitXmlIncludeAttribute
-    {
-        get { return _configuration.OmitXmlIncludeAttribute; }
-        set { _configuration.OmitXmlIncludeAttribute = value; }
-    }
-
-    public bool ValidationError { get; private set; }
+    public bool OmitXmlIncludeAttribute
+    {
+        get { return _configuration.OmitXmlIncludeAttribute; }
+        set { _configuration.OmitXmlIncludeAttribute = value; }
+    }
+
+    public bool EnumCollection
+    {
+        get { return _configuration.EnumCollection; }
+        set { _configuration.EnumCollection = value; }
+    }
+
+    public bool ValidationError { get; private set; }
 
     static Generator()
     {

XmlSchemaClassGenerator/GeneratorConfiguration.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.CodeDom;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
@@ -366,8 +366,14 @@ public void WriteLog(string message)
     /// </summary>
     public bool AllowDtdParse { get; set; } = false;
 
-    /// <summary>
-    /// Omit generation of XmlIncludeAttribute for derived types. Default is false.
-    /// </summary>
-    public bool OmitXmlIncludeAttribute { get; set; } = false;
-}
+    /// <summary>
+    /// Omit generation of XmlIncludeAttribute for derived types. Default is false.
+    /// </summary>
+    public bool OmitXmlIncludeAttribute { get; set; } = false;
+
+    /// <summary>
+    /// Generate typed enum collections for xs:list types whose item type is an enumeration,
+    /// instead of falling back to string collections. Default is false.
+    /// </summary>
+    public bool EnumCollection { get; set; }
+}