Extract enumeration values from xsd schema file in .net

Question

How programmatically extract enumeration constraint values of an element from xsd schema file using .net?

for example I'd like to extract 'Audi', 'Golf' and 'BMW' from the following xsd:

<xs:element name="car"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="Audi"/> <xs:enumeration value="Golf"/> <xs:enumeration value="BMW"/> </xs:restriction> </xs:simpleType> </xs:element>

Answer 1

There is an XmlSchema class, but it looks pretty... "fun" to work with.

Would xml querying be enough?

XmlDocument doc = new XmlDocument();
doc.Load("Foo.xsd");            
XmlNamespaceManager mgr = new XmlNamespaceManager(doc.NameTable);
mgr.AddNamespace("xx", "http://www.w3.org/2001/XMLSchema");
foreach (XmlElement el in doc.SelectNodes("//xx:element[@name='car'][1]/xx:simpleType/xx:restriction/xx:enumeration", mgr))
{
    Console.WriteLine(el.GetAttribute("value"));
}

Answer 2

You could also iterate through all the items in the schema.

The following code is a very useful for extracting data from XSD schemas. Basically it makes a call the the function callback for ever object in the SOM. You would need to provide an implementation for the callback that checked the type was an enumeration and processed it accordingly.

     #region CallForEveryElement
 public delegate void SchemaObjectFunction(XmlSchemaObject xso);

 public static void CallForEveryElement(XmlSchema schema, SchemaObjectFunction function)
 {
  CallForEveryElementInternal(schema, function);
 }

 private static void CallForEveryElementInternal(XmlSchemaObject schemaObject, SchemaObjectFunction function)
 {
  if (schemaObject == null)
   return;

  function(schemaObject);

  if (schemaObject is XmlSchema)
  {
   CallForEveryElementInternal((schemaObject as XmlSchema).Includes, function);
   CallForEveryElementInternal((schemaObject as XmlSchema).Items, function);
  }
  if (schemaObject is XmlSchemaGroupBase)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaGroupBase).Items, function);
  }
  if (schemaObject is XmlSchemaAttribute)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaAttribute).SchemaType, function);
  }
  if (schemaObject is XmlSchemaAttributeGroup)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaAttributeGroup).AnyAttribute, function);
   CallForEveryElementInternal((schemaObject as XmlSchemaAttributeGroup).Attributes, function);
  }
  if (schemaObject is XmlSchemaContentModel)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaContentModel).Content, function);
  }
  if (schemaObject is XmlSchemaComplexContentExtension)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaComplexContentExtension).AnyAttribute, function);
   CallForEveryElementInternal((schemaObject as XmlSchemaComplexContentExtension).Attributes, function);
   CallForEveryElementInternal((schemaObject as XmlSchemaComplexContentExtension).Particle, function);
  }
  if (schemaObject is XmlSchemaComplexContentRestriction)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaComplexContentRestriction).AnyAttribute, function);
   CallForEveryElementInternal((schemaObject as XmlSchemaComplexContentRestriction).Attributes, function);
   CallForEveryElementInternal((schemaObject as XmlSchemaComplexContentRestriction).Particle, function);
  }
  if (schemaObject is XmlSchemaComplexType)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaComplexType).AnyAttribute, function);
   CallForEveryElementInternal((schemaObject as XmlSchemaComplexType).Attributes, function);
   CallForEveryElementInternal((schemaObject as XmlSchemaComplexType).AttributeWildcard, function);
   CallForEveryElementInternal((schemaObject as XmlSchemaComplexType).ContentModel, function);
   CallForEveryElementInternal((schemaObject as XmlSchemaComplexType).ContentTypeParticle, function);
   CallForEveryElementInternal((schemaObject as XmlSchemaComplexType).Particle, function);
  }
  if (schemaObject is XmlSchemaElement)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaElement).Constraints, function);
   CallForEveryElementInternal((schemaObject as XmlSchemaElement).ElementSchemaType, function);
   CallForEveryElementInternal((schemaObject as XmlSchemaElement).SchemaType, function);
  }
  if (schemaObject is XmlSchemaGroup)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaGroup).Particle, function);
  }
  if (schemaObject is XmlSchemaGroupBase)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaGroupBase).Items, function);
  }
  if (schemaObject is XmlSchemaGroupRef)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaGroupRef).Particle, function);
  }
  if (schemaObject is XmlSchemaImport)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaImport).Annotation, function);
  }
  if (schemaObject is XmlSchemaInclude)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaInclude).Annotation, function);
  }
  if (schemaObject is XmlSchemaRedefine)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaRedefine).Items, function);
  }
  if (schemaObject is XmlSchemaSimpleContentExtension)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaSimpleContentExtension).AnyAttribute, function);
   CallForEveryElementInternal((schemaObject as XmlSchemaSimpleContentExtension).Attributes, function);
  }
  if (schemaObject is XmlSchemaSimpleContentRestriction)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaSimpleContentRestriction).AnyAttribute, function);
   CallForEveryElementInternal((schemaObject as XmlSchemaSimpleContentRestriction).Attributes, function);
   CallForEveryElementInternal((schemaObject as XmlSchemaSimpleContentRestriction).BaseType, function);
   CallForEveryElementInternal((schemaObject as XmlSchemaSimpleContentRestriction).Facets, function);
  }
  if (schemaObject is XmlSchemaSimpleType)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaSimpleType).Content, function);
  }
  if (schemaObject is XmlSchemaSimpleTypeList)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaSimpleTypeList).BaseItemType, function);
   CallForEveryElementInternal((schemaObject as XmlSchemaSimpleTypeList).ItemType, function);
  }
  if (schemaObject is XmlSchemaSimpleTypeRestriction)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaSimpleTypeRestriction).BaseType, function);
   CallForEveryElementInternal((schemaObject as XmlSchemaSimpleTypeRestriction).Facets, function);
  }
  if (schemaObject is XmlSchemaSimpleTypeUnion)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaSimpleTypeUnion).BaseTypes, function);
  }
  if (schemaObject is XmlSchemaType)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaType).BaseXmlSchemaType, function);
  }
  if (schemaObject is XmlSchemaAnnotated)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaAnnotated).Annotation, function);
  }
  if (schemaObject is XmlSchemaAnnotation)
  {
   CallForEveryElementInternal((schemaObject as XmlSchemaAnnotation).Items, function);
  }
 }

 private static void CallForEveryElementInternal(XmlSchemaObjectCollection schemaObjectCol, SchemaObjectFunction function)
 {
  foreach (XmlSchemaObject xso in schemaObjectCol)
  {
   CallForEveryElementInternal(xso, function);
  }
 }

 #endregion