Add UseArrayItemAttribute option (fixes #313)

Michael Ganss · Michael Ganss · commit 732fcd2ef40c · 2022-03-21T13:04:57.000+01:00
diff --git a/XmlSchemaClassGenerator.Console/Program.cs b/XmlSchemaClassGenerator.Console/Program.cs
@@ -56,6 +56,7 @@ static void Main(string[] args)
             var netCoreSpecificCode = false;
             var nullableReferenceAttributes = false;
             var generateCommandLineArgs = true;
+            var useArrayItemAttribute = true;
 
             var options = new OptionSet {
                 { "h|help", "show this message and exit", v => showHelp = v != null },
@@ -129,6 +130,7 @@ A file name may be given by appending a pipe sign (|) followed by a file name (l
                 { "gc|generatedCodeAttribute", "add version information to GeneratedCodeAttribute (default is true)", v => createGeneratedCodeAttributeVersion = v != null },
                 { "nc|netCore", "generate .NET Core specific code that might not work with .NET Framework (default is false)", v => netCoreSpecificCode = v != null },
                 { "nr|nullableReferenceAttributes", "generate attributes for nullable reference types (default is false)", v => nullableReferenceAttributes = v != null },
+                { "ar|useArrayItemAttribute", "use ArrayItemAttribute for sequences with single elements (default is true)", v => useArrayItemAttribute = v != null },
                 { "ca|commandArgs", "generate a comment with the exact command line arguments that were used to generate the source code (default is true)", v => generateCommandLineArgs = v != null },
             };
 
@@ -207,6 +209,7 @@ A file name may be given by appending a pipe sign (|) followed by a file name (l
                 NetCoreSpecificCode = netCoreSpecificCode,
                 EnableNullableReferenceAttributes = nullableReferenceAttributes,
                 GenerateCommandLineArgumentsComment = generateCommandLineArgs,
+                UseArrayItemAttribute = useArrayItemAttribute,
             };
 
             generator.CommentLanguages.AddRange(commentLanguages);
diff --git a/XmlSchemaClassGenerator.Tests/Compiler.cs b/XmlSchemaClassGenerator.Tests/Compiler.cs
@@ -114,7 +114,8 @@ public static Assembly GenerateFiles(string name, IEnumerable<string> files, Gen
                 CreateGeneratedCodeAttributeVersion = generatorPrototype.CreateGeneratedCodeAttributeVersion,
                 NetCoreSpecificCode = generatorPrototype.NetCoreSpecificCode,
                 EnableNullableReferenceAttributes = generatorPrototype.EnableNullableReferenceAttributes,
-                NamingScheme = generatorPrototype.NamingScheme
+                NamingScheme = generatorPrototype.NamingScheme,
+                UseArrayItemAttribute = generatorPrototype.UseArrayItemAttribute,
             };
 
             gen.CommentLanguages.Clear();
diff --git a/XmlSchemaClassGenerator.Tests/XmlTests.cs b/XmlSchemaClassGenerator.Tests/XmlTests.cs
@@ -64,6 +64,7 @@ private static IEnumerable<string> ConvertXml(string name, IEnumerable<string> x
                 CollectionType = generatorPrototype.CollectionType,
                 CollectionImplementationType = generatorPrototype.CollectionImplementationType,
                 CollectionSettersMode = generatorPrototype.CollectionSettersMode,
+                UseArrayItemAttribute = generatorPrototype.UseArrayItemAttribute,
             };
 
             gen.CommentLanguages.Clear();
@@ -2371,20 +2372,20 @@ void UnknownAttributeHandler(object sender, XmlAttributeEventArgs e)
 
         [Fact, TestPriority(1)]
         [UseCulture("en-US")]
-        public void TestNullableReferenceAttributes() 
+        public void TestNullableReferenceAttributes()
         {
             var files = Glob.ExpandNames(NullableReferenceAttributesPattern).OrderByDescending(f => f);
-            var generator = new Generator 
+            var generator = new Generator
             {
                 EnableNullableReferenceAttributes = true,
                 UseShouldSerializePattern = true,
-                NamespaceProvider = new NamespaceProvider 
+                NamespaceProvider = new NamespaceProvider
                 {
                     GenerateNamespace = key => "Test"
                 }
             };
             var assembly = Compiler.Generate(nameof(TestNullableReferenceAttributes), NullableReferenceAttributesPattern, generator);
-            void assertNullable(string typename, bool nullable) 
+            void assertNullable(string typename, bool nullable)
             {
                 Type c = assembly.GetType(typename);
                 var property = c.GetProperty("Text");
@@ -2528,5 +2529,54 @@ public partial class Elem
 }}
 ", csharp);
         }
+
+        [Fact]
+        public void TestArrayItemAttribute()
+        {
+            // see https://github.com/mganss/XmlSchemaClassGenerator/issues/313
+
+            var xsd =
+@"<?xml version=""1.0"" encoding=""UTF-8""?>
+
+<xs:schema xmlns:xs=""http://www.w3.org/2001/XMLSchema""
+	 xmlns=""test_generation_namespace/common.xsd""
+	 xmlns:ct=""test_generation_namespace/commontypes.xsd""
+	 targetNamespace=""test_generation_namespace/common.xsd""
+	 version=""1.1""
+	 elementFormDefault=""qualified""
+	 attributeFormDefault=""unqualified"">
+	<xs:import namespace=""test_generation_namespace/commontypes.xsd"" schemaLocation=""TheCommonTypes.xsd""/>
+	<xs:complexType name=""T_NameValue"">
+		<xs:sequence>
+			<xs:element name=""Name"" type=""xs:string""/>
+			<xs:element name=""Value"" type=""xs:string"" minOccurs=""0""/>
+		</xs:sequence>
+	</xs:complexType>
+	<xs:complexType name=""T_OptionList"">
+		<xs:sequence>
+			<xs:element name=""Option"" type=""T_NameValue"" minOccurs=""0"" maxOccurs=""unbounded""/>
+		</xs:sequence>
+	</xs:complexType>
+    <xs:complexType name=""T_Application"">
+		<xs:sequence>
+			<xs:element name=""OptionList"" type=""T_OptionList"" minOccurs=""0""/>
+		</xs:sequence>
+	</xs:complexType>
+</xs:schema>";
+            var generator = new Generator
+            {
+                IntegerDataType = typeof(int),
+                GenerateNullables = true,
+                CollectionType = typeof(System.Array),
+                CollectionSettersMode = CollectionSettersMode.Public,
+                UseArrayItemAttribute = false
+            };
+            var contents = ConvertXml(nameof(TestArrayItemAttribute), new[] { xsd }, generator).ToArray();
+            var assembly = Compiler.Compile(nameof(TestArrayItemAttribute), contents);
+            var applicationType = assembly.GetType("Test_Generation_Namespace.T_Application");
+            Assert.NotNull(applicationType);
+            var optionList = applicationType.GetProperty("OptionList");
+            Assert.Equal("Test_Generation_Namespace.T_OptionList", optionList.PropertyType.FullName);
+        }
     }
 }
diff --git a/XmlSchemaClassGenerator/CodeUtilities.cs b/XmlSchemaClassGenerator/CodeUtilities.cs
@@ -245,7 +245,7 @@ public static string GetUniqueTypeName(this NamespaceModel model, string name)
             var n = name;
             var i = 2;
 
-            while (model.Types.ContainsKey(n) && !(model.Types[n] is SimpleModel))
+            while (model.Types.ContainsKey(n) && model.Types[n] is not SimpleModel)
             {
                 n = name + i;
                 i++;
diff --git a/XmlSchemaClassGenerator/Generator.cs b/XmlSchemaClassGenerator/Generator.cs
@@ -115,7 +115,7 @@ public bool GenerateNullables
             set { _configuration.GenerateNullables = value; }
         }
 
-        public bool EnableNullableReferenceAttributes 
+        public bool EnableNullableReferenceAttributes
         {
             get { return _configuration.EnableNullableReferenceAttributes; }
             set { _configuration.EnableNullableReferenceAttributes = value; }
@@ -294,6 +294,12 @@ public bool NetCoreSpecificCode
             set { _configuration.NetCoreSpecificCode = value; }
         }
 
+        public bool UseArrayItemAttribute
+        {
+            get { return _configuration.UseArrayItemAttribute; }
+            set {  _configuration.UseArrayItemAttribute = value;}
+        }
+
         public bool GenerateCommandLineArgumentsComment
         {
             get { return _configuration.GenerateCommandLineArgumentsComment; }
diff --git a/XmlSchemaClassGenerator/GeneratorConfiguration.cs b/XmlSchemaClassGenerator/GeneratorConfiguration.cs
@@ -320,5 +320,11 @@ public void WriteLog(string message)
         /// A provider to obtain the command line arguments of the tool.
         /// </summary>
         public CommandLineArgumentsProvider CommandLineArgumentsProvider { get; set; }
+
+        /// <summary>
+        /// Enables use of <see cref="System.Xml.Serialization.XmlArrayItemAttribute"/>
+        /// for sequences with single elements. Default is true.
+        /// </summary>
+        public bool UseArrayItemAttribute { get; set; } = true;
     }
 }
diff --git a/XmlSchemaClassGenerator/TypeModel.cs b/XmlSchemaClassGenerator/TypeModel.cs
@@ -328,7 +328,7 @@ public override CodeTypeDeclaration Generate()
             if (IsAbstract)
                 classDeclaration.TypeAttributes |= System.Reflection.TypeAttributes.Abstract;
 
-            if (Configuration.EnableDataBinding && !(BaseClass is ClassModel))
+            if (Configuration.EnableDataBinding && BaseClass is not ClassModel)
             {
                 var propertyChangedEvent = new CodeMemberEvent()
                 {
@@ -432,7 +432,7 @@ public override CodeTypeDeclaration Generate()
                 classDeclaration.BaseTypes.Add(CodeUtilities.CreateTypeReference(typeof(INotifyPropertyChanged), Configuration));
             }
 
-            if (Configuration.EntityFramework && !(BaseClass is ClassModel))
+            if (Configuration.EntityFramework && BaseClass is not ClassModel)
             {
                 // generate key
                 var keyProperty = Properties.FirstOrDefault(p => p.Name.ToLowerInvariant() == "id")
@@ -729,7 +729,8 @@ public bool IsArray
         {
             get
             {
-                return !IsCollection && !IsAttribute && !IsList && TypeClassModel != null
+                return Configuration.UseArrayItemAttribute
+                && !IsCollection && !IsAttribute && !IsList && TypeClassModel != null
                 && TypeClassModel.BaseClass == null
                 && TypeClassModel.Properties.Count == 1
                 && !TypeClassModel.Properties[0].IsAttribute && !TypeClassModel.Properties[0].IsAny
@@ -752,9 +753,9 @@ private bool IsNullableValueType
             }
         }
 
-        private bool IsNullableReferenceType 
+        private bool IsNullableReferenceType
         {
-            get 
+            get
             {
                 return DefaultValue == null
                     && IsNullable && (IsCollection || IsArray || IsList || PropertyType is ClassModel || PropertyType is SimpleModel model && !model.ValueType.IsValueType);
@@ -1124,7 +1125,7 @@ public void AddMembersTo(CodeTypeDeclaration typeDeclaration, bool withDataBindi
                 typeDeclaration.Members.Add(specifiedProperty);
             }
 
-            if (isNullableReferenceType && Configuration.EnableNullableReferenceAttributes) 
+            if (isNullableReferenceType && Configuration.EnableNullableReferenceAttributes)
             {
                 member.CustomAttributes.Add(new CodeAttributeDeclaration("System.Diagnostics.CodeAnalysis.AllowNullAttribute"));
                 member.CustomAttributes.Add(new CodeAttributeDeclaration("System.Diagnostics.CodeAnalysis.MaybeNullAttribute"));

Original file line number	Diff line number	Diff line change
`@@ -245,7 +245,7 @@ public static string GetUniqueTypeName(this NamespaceModel model, string name)`
`245`	`245`	`var n = name;`
`246`	`246`	`var i = 2;`
`247`	`247`
`248`		`- while (model.Types.ContainsKey(n) && !(model.Types[n] is SimpleModel))`
	`248`	`+ while (model.Types.ContainsKey(n) && model.Types[n] is not SimpleModel)`
`249`	`249`	`{`
`250`	`250`	`n = name + i;`
`251`	`251`	`i++;`
Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,7 @@ public bool GenerateNullables`
`115`	`115`	`set { _configuration.GenerateNullables = value; }`
`116`	`116`	`}`
`117`	`117`
`118`		`- public bool EnableNullableReferenceAttributes`
	`118`	`+ public bool EnableNullableReferenceAttributes`
`119`	`119`	`{`
`120`	`120`	`get { return _configuration.EnableNullableReferenceAttributes; }`
`121`	`121`	`set { _configuration.EnableNullableReferenceAttributes = value; }`
`@@ -294,6 +294,12 @@ public bool NetCoreSpecificCode`
`294`	`294`	`set { _configuration.NetCoreSpecificCode = value; }`
`295`	`295`	`}`
`296`	`296`
	`297`	`+ public bool UseArrayItemAttribute`
	`298`	`+ {`
	`299`	`+ get { return _configuration.UseArrayItemAttribute; }`
	`300`	`+ set { _configuration.UseArrayItemAttribute = value;}`
	`301`	`+ }`
	`302`	`+`
`297`	`303`	`public bool GenerateCommandLineArgumentsComment`
`298`	`304`	`{`
`299`	`305`	`get { return _configuration.GenerateCommandLineArgumentsComment; }`
Original file line number	Diff line number	Diff line change
`@@ -320,5 +320,11 @@ public void WriteLog(string message)`
`320`	`320`	`/// A provider to obtain the command line arguments of the tool.`
`321`	`321`	`/// </summary>`
`322`	`322`	`public CommandLineArgumentsProvider CommandLineArgumentsProvider { get; set; }`
	`323`	`+`
	`324`	`+ /// <summary>`
	`325`	`+ /// Enables use of <see cref="System.Xml.Serialization.XmlArrayItemAttribute"/>`
	`326`	`+ /// for sequences with single elements. Default is true.`
	`327`	`+ /// </summary>`
	`328`	`+ public bool UseArrayItemAttribute { get; set; } = true;`
`323`	`329`	`}`
`324`	`330`	`}`
Original file line number	Diff line number	Diff line change
`@@ -328,7 +328,7 @@ public override CodeTypeDeclaration Generate()`
`328`	`328`	`if (IsAbstract)`
`329`	`329`	`classDeclaration.TypeAttributes \|= System.Reflection.TypeAttributes.Abstract;`
`330`	`330`
`331`		`- if (Configuration.EnableDataBinding && !(BaseClass is ClassModel))`
	`331`	`+ if (Configuration.EnableDataBinding && BaseClass is not ClassModel)`
`332`	`332`	`{`
`333`	`333`	`var propertyChangedEvent = new CodeMemberEvent()`
`334`	`334`	`{`
`@@ -432,7 +432,7 @@ public override CodeTypeDeclaration Generate()`
`432`	`432`	`classDeclaration.BaseTypes.Add(CodeUtilities.CreateTypeReference(typeof(INotifyPropertyChanged), Configuration));`
`433`	`433`	`}`
`434`	`434`
`435`		`- if (Configuration.EntityFramework && !(BaseClass is ClassModel))`
	`435`	`+ if (Configuration.EntityFramework && BaseClass is not ClassModel)`
`436`	`436`	`{`
`437`	`437`	`// generate key`
`438`	`438`	`var keyProperty = Properties.FirstOrDefault(p => p.Name.ToLowerInvariant() == "id")`
`@@ -729,7 +729,8 @@ public bool IsArray`
`729`	`729`	`{`
`730`	`730`	`get`
`731`	`731`	`{`
`732`		`- return !IsCollection && !IsAttribute && !IsList && TypeClassModel != null`
	`732`	`+ return Configuration.UseArrayItemAttribute`
	`733`	`+ && !IsCollection && !IsAttribute && !IsList && TypeClassModel != null`
`733`	`734`	`&& TypeClassModel.BaseClass == null`
`734`	`735`	`&& TypeClassModel.Properties.Count == 1`
`735`	`736`	`&& !TypeClassModel.Properties[0].IsAttribute && !TypeClassModel.Properties[0].IsAny`
`@@ -752,9 +753,9 @@ private bool IsNullableValueType`
`752`	`753`	`}`
`753`	`754`	`}`
`754`	`755`
`755`		`- private bool IsNullableReferenceType`
	`756`	`+ private bool IsNullableReferenceType`
`756`	`757`	`{`
`757`		`- get`
	`758`	`+ get`
`758`	`759`	`{`
`759`	`760`	`return DefaultValue == null`
`760`	`761`	`&& IsNullable && (IsCollection \|\| IsArray \|\| IsList \|\| PropertyType is ClassModel \|\| PropertyType is SimpleModel model && !model.ValueType.IsValueType);`
`@@ -1124,7 +1125,7 @@ public void AddMembersTo(CodeTypeDeclaration typeDeclaration, bool withDataBindi`
`1124`	`1125`	`typeDeclaration.Members.Add(specifiedProperty);`
`1125`	`1126`	`}`
`1126`	`1127`
`1127`		`- if (isNullableReferenceType && Configuration.EnableNullableReferenceAttributes)`
	`1128`	`+ if (isNullableReferenceType && Configuration.EnableNullableReferenceAttributes)`
`1128`	`1129`	`{`
`1129`	`1130`	`member.CustomAttributes.Add(new CodeAttributeDeclaration("System.Diagnostics.CodeAnalysis.AllowNullAttribute"));`
`1130`	`1131`	`member.CustomAttributes.Add(new CodeAttributeDeclaration("System.Diagnostics.CodeAnalysis.MaybeNullAttribute"));`