Create individual classes for all root elements that derive from the same type (see #273)

Author: Michael Ganss

XmlSchemaClassGenerator/ModelBuilder.cs

@@ -137,7 +137,7 @@ private void CreateSubstitutes()
 
         private void AddXmlRootAttributeToAmbiguousTypes()
         {
-            var ambiguousTypes = Types.Values.Where(t=>t.RootElementName == null && !(t is InterfaceModel)).GroupBy(t => t.Name);
+            var ambiguousTypes = Types.Values.Where(t => t.RootElementName == null && !t.IsAbstractRoot && !(t is InterfaceModel)).GroupBy(t => t.Name);
             foreach (var ambiguousTypeGroup in ambiguousTypes)
             {
                 var types = ambiguousTypeGroup.ToList();
@@ -253,7 +253,7 @@ private void CreateElements(IEnumerable<XmlSchemaElement> elements)
                 var type = CreateTypeModel(typeSource, rootElement.ElementSchemaType, qualifiedName);
                 ClassModel derivedClassModel = null;
 
-                if (type.RootElementName != null)
+                if (type.RootElementName != null || type.IsAbstractRoot)
                 {
                     if (type is ClassModel classModel)
                     {
@@ -283,6 +283,49 @@ private void CreateElements(IEnumerable<XmlSchemaElement> elements)
                         ((ClassModel)derivedClassModel.BaseClass).DerivedTypes.Add(derivedClassModel);
 
                         derivedClassModel.RootElementName = rootElement.QualifiedName;
+
+                        if (!type.IsAbstractRoot)
+                        {
+                            // Also create an empty derived class for the original root element
+
+                            var originalClassModel = new ClassModel(_configuration)
+                            {
+                                Name = _configuration.NamingProvider.RootClassNameFromQualifiedName(type.RootElementName),
+                                Namespace = classModel.Namespace
+                            };
+
+                            originalClassModel.Documentation.AddRange(classModel.Documentation);
+                            classModel.Documentation.Clear();
+
+                            if (originalClassModel.Namespace != null)
+                            {
+                                originalClassModel.Name = originalClassModel.Namespace.GetUniqueTypeName(originalClassModel.Name);
+                                originalClassModel.Namespace.Types[originalClassModel.Name] = originalClassModel;
+                            }
+
+                            if (classModel.XmlSchemaName != null && !classModel.XmlSchemaName.IsEmpty)
+                            {
+                                key = BuildKey(classModel.RootElement, classModel.XmlSchemaName);
+                                Types[key] = originalClassModel;
+                            }
+
+                            originalClassModel.BaseClass = classModel;
+                            ((ClassModel)originalClassModel.BaseClass).DerivedTypes.Add(originalClassModel);
+
+                            originalClassModel.RootElementName = type.RootElementName;
+
+                            if (classModel.RootElement.SubstitutionGroup != null
+                                && SubstitutionGroups.TryGetValue(classModel.RootElement.SubstitutionGroup, out var substitutes))
+                            {
+                                foreach (var substitute in substitutes.Where(s => s.Element == classModel.RootElement))
+                                {
+                                    substitute.Type = originalClassModel;
+                                }
+                            }
+
+                            classModel.RootElementName = null;
+                            classModel.IsAbstractRoot = true;
+                        }
                     }
                     else
                     {
@@ -297,6 +340,7 @@ private void CreateElements(IEnumerable<XmlSchemaElement> elements)
                         classModel.Documentation.AddRange(GetDocumentation(rootElement));
                     }
 
+                    type.RootElement = rootElement;
                     type.RootElementName = rootElement.QualifiedName;
                 }
 

XmlSchemaClassGenerator/TypeModel.cs

@@ -111,7 +111,9 @@ public abstract class TypeModel
         protected static readonly CodeDomProvider CSharpProvider = CodeDomProvider.CreateProvider("CSharp");
 
         public NamespaceModel Namespace { get; set; }
+        public XmlSchemaElement RootElement { get; set; }
         public XmlQualifiedName RootElementName { get; set; }
+        public bool IsAbstractRoot { get; set; }
         public string Name { get; set; }
         public XmlQualifiedName XmlSchemaName { get; set; }
         public XmlSchemaType XmlSchemaType { get; set; }