XSD Tools in .NET8 – Part1 – VS2022

A practical guide to XSD tools available in .NET8 environment.

Abstract: A practical guide to XML and XSD tools available in .NET8 environment, focusing on generating and using C# classes to process some XML valid for some given XSD (technology as of September 2024).

1 Doing XML and XSD related work in .NET8

I was recently doing some work related to XML and XSD processing in .NET8 environment and created several proof-of-concept applications to evaluate the tools available. These articles are the result of my prototyping work.

1.1 List of tools used/tested

Here are the tools used/tested:

• Visual Studio 2022
• XSD.EXE (Microsoft license, part of VS2022)
• XmlSchemaClassGenerator (Open Source/Freeware)
• LinqToXsdCore (Open Source/Freeware)
• Liquid XML Objects (Commercial license)

1.2 Articles in this series

For technical reasons, I will organize this text into several articles:

• XSD Tools in .NET8 – Part1 – VS2022
• XSD Tools in .NET8 – Part2 – C# validation
• XSD Tools in .NET8 – Part3 – XsdExe – Simple
• XSD Tools in .NET8 – Part4 – XsdExe - Advanced
• XSD Tools in .NET8 – Part5 – XmlSchemaClassGenerator – Simple
• XSD Tools in .NET8 – Part6 – XmlSchemaClassGenerator – Advanced
• XSD Tools in .NET8 – Part7 – LinqToXsdCore – Simple
• XSD Tools in .NET8 – Part8 – LinqToXsdCore – Advanced
• XSD Tools in .NET8 – Part9 – LiquidXMLObjects – Simple
• XSD Tools in .NET8 – Part10 – LiquidXMLObjects – Advanced

2 Some XML terminology

Here is a refreshment on some XML terminology:

• XML - Extensible Markup Language (XML) is a markup language and file format for storing, transmitting, and reconstructing arbitrary data.
• Well-Formed XML - A well-formed document in XML is a document that "adheres to the syntax rules specified by the XML 1.0 specification in that it must satisfy both physical and logical structures".
• XSD schema file - An XML schema definition (XSD), is a framework document that defines the rules and constraints for XML documents. An XSD formally describes the elements in an XML document and can be used to validate the contents of the XML document to make sure that it adheres to the rules of the XSD.
• DTD - A document type definition (DTD) is a specification file that contains set of markup declarations that define a document type for an SGML-family markup language (GML, SGML, XML, HTML). The DTD specification file can be used to validate documents.
• Valid XML - A "valid" XML document must be well-formed. In addition, it must conform to a document-type definition. There are two different document type definitions that can be used with XML: 1) DTD - The original Document Type Definition; 2) XML Schema - An XML-based alternative to DTD.
• XML validation – This is a process of establishing if an XML is valid according to a specific DTD or XSD file.

So, the way I think about it is. We have all kinds of text files. Then some text files are markup language files. Those that are intended to transfer or hold data and follow specification XML 1.0 are called XML files, or better to say “well-formed XML” files. Those that are not “well-formed XML” files are not really XML-s at all, they are “look-alikes”. They look similar to XML-s, but are not really XML-s in the strict meaning of specification XML 1.0.

Then, among all the XML-s we want to define some family of XML-s with specific structure. We can express those schema rules by either a DTD file or an XSD file. I think of those rules as grammar that an XML file must satisfy. In the process called “XML validation”, we examine if some particular XML satisfies rules given by DTD or XSD. If it does, we say that particular “XML is valid according to some given DTD or XSD”.

3 Visual Studio 2022 tools for XML and XSD

3.1 Basic operations with XML and XSD

VS2022 offers some very useful features to manipulate XML and XSD files:

• Creation of XML and XSD files
• Automatic creation of XSD schema for an XML (best guess algorithm)
• Validation of XML for some XSD schema
• Several XSD design views
• Generating sample (random) XML for some defined XSD schema

3.2 Basic Operations GUI

Here are screenshots to help users find above mention operations in VS2022.

4 More theory about XML and XSD rules

Here is some more theory about XML and XSD rules.

4.1 Optional Xml-Element and Xml-Attribute

Optional: Does not need to be present in the XML.

For XSD Schema elements:
Optional: minOccurs="0" attribute ->In order to set a schema element as optional, you include the minOccurs="0" attribute

The Difference Between Optional and Not Required for Xml-Element and Xml-Attribute

Note the difference:

• Optional: Does not need to be present in the XML.
• Not Required: Does not need to have a value.

You can have any combination:

• Optional + Not Required
• Optional + Required
• Not Optional + Not Required
• Not Optional + Required

For XSD Schema elements:

• Optional: minOccurs="0" attribute ->In order to set a schema element as optional, you include the minOccurs="0" attribute
• Required: nillable="true" attribute ->In order to set a schema element as not required, you include the nillable="true" attribute.

String data types are not required by default, though you can force them to be required.
Other data types, such as Boolean, Integer, Date, Time, etc. are all required by default. In order to make one of these data types not required, you must set the nillable attribute equal to true for the element in the schema.

5 Examples of XML and XSD

With all the above theory about XML and XSD here are some sample XML-s and XSD-s I created for test purposes, by using VS2022 toolset.

5.1 Simple case

Please note that this example XML/XSD has an Optional Xml-Element. Read the comments inside for more details.

<?xml version="1.0" encoding="utf-8"?>
<!--SmallCompany.xsd++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-->
<xs:schema attributeFormDefault="unqualified" 
           elementFormDefault="qualified" 
           targetNamespace="https://markpelf.com/SmallCompany.xsd" 
           xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="SmallCompany">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="CompanyName" type="xs:string" />
                <xs:element maxOccurs="unbounded" name="Employee">
                    <xs:complexType>
                        <xs:sequence>
                            <!--Name_String_NO is String NotOptional-->
                            <xs:element name="Name_String_NO" type="xs:string" />
                            <!--City_String_O is String Optional-->
                            <xs:element minOccurs="0" name="City_String_O" type="xs:string" />
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
                <xs:element maxOccurs="unbounded" name="InfoData">
                    <xs:complexType>
                        <xs:sequence>
                            <!--Id_Int_NO is Int NotOptional-->
                            <xs:element name="Id_Int_NO" type="xs:int" />
                            <!--Quantity_Int_O is Int Optional-->
                            <xs:element minOccurs="0" name="Quantity_Int_O" type="xs:int" />
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
</xs:schema>

<?xml version="1.0" encoding="utf-8"?>
<!--SmallCompany.xsd++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-->
<xs:schema attributeFormDefault="unqualified" 
           elementFormDefault="qualified" 
           targetNamespace="https://markpelf.com/SmallCompany.xsd" 
           xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="SmallCompany">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="CompanyName" type="xs:string" />
                <xs:element maxOccurs="unbounded" name="Employee">
                    <xs:complexType>
                        <xs:sequence>
                            <!--Name_String_NO is String NotOptional-->
                            <xs:element name="Name_String_NO" type="xs:string" />
                            <!--City_String_O is String Optional-->
                            <xs:element minOccurs="0" name="City_String_O" type="xs:string" />
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
                <xs:element maxOccurs="unbounded" name="InfoData">
                    <xs:complexType>
                        <xs:sequence>
                            <!--Id_Int_NO is Int NotOptional-->
                            <xs:element name="Id_Int_NO" type="xs:int" />
                            <!--Quantity_Int_O is Int Optional-->
                            <xs:element minOccurs="0" name="Quantity_Int_O" type="xs:int" />
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
</xs:schema>

5.2 Advanced case

Please note that this example XML/XSD has an Optional and Not-Required Xml-Element. Read the comments inside for more details.

<?xml version="1.0" encoding="utf-8"?>
<!--SmallCompanyAAA.xml+++++++++++++++++++++++++++++++++++++++++++++++-->
<SmallCompany xmlns="https://markpelf.com/SmallCompany.xsd">
    <CompanyName>SmallCompanyAAA</CompanyName>
    <Employee>
        <Name_String_NO>Mark</Name_String_NO>
        <City_String_O>Belgrade</City_String_O>
    </Employee>
    <Employee>
        <Name_String_NO>John</Name_String_NO>
    </Employee>
    <InfoData>
        <Id_Int_NO>11</Id_Int_NO>
        <Quantity_Int_O>123</Quantity_Int_O>
    </InfoData>
    <InfoData>
        <Id_Int_NO>22</Id_Int_NO>
    </InfoData>
</SmallCompany>

<?xml version="1.0" encoding="utf-8"?>
<!--SmallCompany.xsd++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-->
<xs:schema attributeFormDefault="unqualified" 
           elementFormDefault="qualified" 
           targetNamespace="https://markpelf.com/SmallCompany.xsd" 
           xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="SmallCompany">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="CompanyName" type="xs:string" />
                <xs:element maxOccurs="unbounded" name="Employee">
                    <xs:complexType>
                        <xs:sequence>
                            <!--Name_String_NO is String NotOptional-->
                            <xs:element name="Name_String_NO" type="xs:string" />
                            <!--City_String_O is String Optional-->
                            <xs:element minOccurs="0" name="City_String_O" type="xs:string" />
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
                <xs:element maxOccurs="unbounded" name="InfoData">
                    <xs:complexType>
                        <xs:sequence>
                            <!--Id_Int_NO is Int NotOptional-->
                            <xs:element name="Id_Int_NO" type="xs:int" />
                            <!--Quantity_Int_O is Int Optional-->
                            <xs:element minOccurs="0" name="Quantity_Int_O" type="xs:int" />
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
</xs:schema>

6 References

[1] Well-formed document
https://en.wikipedia.org/wiki/Well-formed_document

[2] XML Schema
https://www.w3schools.com/xml/xml_schema.asp

[3] XML Schema Tutorial
https://www.w3schools.com/xml/schema_intro.asp

[4] XML Namespaces
https://www.w3schools.com/xml/xml_namespaces.asp

[5] The Difference Between Optional and Not Required
https://www.infopathdev.com/blogs/greg/archive/2004/09/16/The-Difference-Between-Optional-and-Not-Required.aspx

[6] nillable and minOccurs XSD element attributes
https://stackoverflow.com/questions/1903062/nillable-and-minoccurs-xsd-element-attributes

[99] https://github.com/MarkPelf/XsdToolsInNet8