Überprüfen eines XML-Dokuments mithilfe von DTD, XDR oder XSD in Visual Basic

  • Artikel
  • 7 Minuten Lesedauer

In diesem Artikel wird gezeigt, wie Sie mithilfe der XmlValidatingReader Klasse ein XML-Dokument anhand einer DTD, eines XDR-Schemas oder eines XSD-Schemas in Visual Basic 2005 oder in Visual Basic .NET validieren. Beschreibt auch, wie die Überprüfung durch Zwischenspeichern von Schemas optimiert wird.

Originalversion des Produkts:   Visual Basic
Ursprüngliche KB-Nummer:   315533

Zusammenfassung

XML-Dokumente (Extensible Markup Language) enthalten Elemente und Attribute und bieten eine flexible und leistungsstarke Möglichkeit zum Austausch von Daten zwischen Anwendungen und Organisationen. Um die zulässige Struktur und den Inhalt eines XML-Dokuments anzugeben, können Sie eine Dokumenttypdefinition (Document Type Definition, DTD), ein Microsoft XML-Data Reduced (XDR)-Schema oder ein XSD-Schema (XML Schema Definition Language) schreiben.

XSD-Schemas sind die bevorzugte Methode zum Angeben von XML-Grammatiken in der .NET Framework, aber AUCH DTDs und XDR-Schemas werden unterstützt.

In diesem Artikel erfahren Sie, wie Sie eine DTD, ein XDR-Schema oder ein XSD-Schema auf ein XML-Dokument in Microsoft Visual Basic 2005 oder in Microsoft Visual Basic .NET anwenden. Anschließend erfahren Sie, wie Sie die XmlValidatingReader-Klasse verwenden, um ein XML-Dokument anhand der angegebenen Grammatik zu überprüfen. Außerdem erfahren Sie, wie Sie die XmlSchemaCollection-Klasse verwenden, um Schemas im Arbeitsspeicher zwischenzuspeichern, um die XML-Überprüfung zu optimieren.

Anforderungen

In der folgenden Liste sind die empfohlenen Hardware-, Software-, Netzwerkinfrastruktur- und Service Packs aufgeführt, die Sie benötigen: Microsoft Visual Basic 2005 oder Microsoft Visual Basic .NET

Dieser Artikel bezieht sich auf die folgenden Namespaces der Microsoft .NET Framework-Klassenbibliothek:

  • System.Xml
  • System.Xml.Schema

In diesem Artikel wird davon ausgegangen, dass Sie mit den folgenden Themen vertraut sind:

  • Visual Basic 2005 oder Visual Basic .NET-Syntax
  • XML-Konzepte, einschließlich Überprüfungsproblemen

Erstellen eines XML-Dokuments

  1. Starten Sie Microsoft Visual Studio 2005 oder Microsoft Visual Studio .NET. Erstellen Sie dann eine neue XML-Datei (zeigen Sie im Menü "Datei" auf "Neu", und klicken Sie dann auf "Datei").

  2. Wählen Sie den XML-Dateityp aus, und klicken Sie dann auf "Öffnen".

  3. Fügen Sie dem XML-Dokument die folgenden Daten hinzu, um ein Produkt in einem Katalog darzustellen:

    <Product ProductID="123">
    <ProductName>Rugby jersey</ProductName>
</Product>

  4. Speichern Sie die Datei als Product.xml in einem Ordner, auf den Sie später problemlos zugreifen können (in den Codebeispielen in diesem Artikel wird von einem Ordner mit dem Namen ausgegangen C:\MyFolder).

  1. Zeigen Sie in Visual Studio 2005 oder in Visual Studio .NET im Menü "Datei" auf "Neu", und klicken Sie dann auf "Datei".

  2. Wählen Sie den Textdateityp aus, und klicken Sie dann auf "Öffnen".

  3. Fügen Sie der Datei die folgenden DTD-Deklarationen hinzu, um die Grammatik des XML-Dokuments zu beschreiben:

    <!ELEMENT Product (ProductName)>
<!ATTLIST Product ProductID CDATA #REQUIRED>
<!ELEMENT ProductName (#PCDATA)>

  4. Speichern Sie die Datei als "Product.dtd " im selben Ordner wie Ihr XML-Dokument.

  5. Öffnen Sie Product.xml in Visual Studio 2005 oder in Visual Studio .NET erneut. Zeigen Sie dazu im Menü "Datei" auf "Öffnen", und klicken Sie dann auf "Datei". Fügen Sie eine DOCTYPE-Anweisung (unter der ?xml version="1.0" Zeile) wie folgt hinzu. Dadurch wird das XML-Dokument mit der DTD-Datei verknüpft.

    <?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE Product SYSTEM "Product.dtd">

  6. Speichern Sie das geänderte XML-Dokument als ProductWithDTD.xml.

Durchführen der Überprüfung mithilfe einer DTD

  1. Erstellen Sie in Visual Studio 2005 oder in Visual Studio .NET ein neues Visual Basic Konsolenanwendungsprojekt namens ValidateXmlUsingVB.

  2. Visual Studio 2005 oder Visual Studio .NET zeigt eine neue Datei mit dem Namen "Module1.vb" an. Fügen Sie am Anfang dieser Datei zwei Imports-Anweisungen wie folgt hinzu:

    Imports System.Xml ' For XmlTextReader and XmlValidatingReader
Imports System.Xml.Schema ' For XmlSchemaCollection (used later)

  3. Deklarieren Sie in Modul1 (vor dem Start der Main-Unterroutine) eine boolesche Variable namens "isValid" wie folgt:

    'If a validation error occurs,
' you will set this flag to False 
' in the validation event handler. 
Private isValid As Boolean = True

  4. Erstellen Sie in der Main-Unterroutine ein XmlTextReader-Objekt, um ein XML-Dokument aus einer Textdatei zu lesen. Erstellen Sie dann ein XmlValidatingReader Objekt, um diese XML-Daten zu überprüfen:

    Dim r As New XmlTextReader("C:\MyFolder\ProductWithDTD.xml")
Dim v As New XmlValidatingReader(r)

  5. Das XmlValidatingReader-Objekt verfügt über eine ValidationType-Eigenschaft, die den Typ der erforderlichen Überprüfung angibt (DTD, XDR oder Schema). Legen Sie diese Eigenschaft wie folgt auf DTD fest:

    v.ValidationType = ValidationType.DTD

  6. Wenn Überprüfungsfehler auftreten, generiert der Validierungsleser ein Überprüfungsereignis. Fügen Sie den folgenden Code hinzu, um einen Überprüfungsereignishandler zu registrieren (Sie implementieren die MyValidationEventHandler-Unterroutine in Schritt 8 dieses Abschnitts):

    AddHandler v.ValidationEventHandler, AddressOf MyValidationEventHandler

  7. Fügen Sie den folgenden Code hinzu, um das XML-Dokument zu lesen und zu überprüfen. Wenn Überprüfungsfehler auftreten, wird MyValidationEventHandler aufgerufen, um den Fehler zu behandeln. Diese Unterroutine wird auf "False" festgelegt isValid (siehe Schritt 8 dieses Abschnitts). Sie können den Status von "isValid" nach der Überprüfung überprüfen, um festzustellen, ob das Dokument gültig oder ungültig ist.

    While v.Read()' Could add code here to process the content.
End While
v.Close()' Check whether the document is valid or invalid.
If isValid Then
    Console.WriteLine("Document is valid")
Else
    Console.WriteLine("Document is invalid")
End If

  8. Schreiben Sie nach der Main-Unterroutine die MyValidationEventHandler-Unterroutine wie folgt:

    Public Sub MyValidationEventHandler(ByVal sender As Object, _
 ByVal args As ValidationEventArgs)
     isValid = False
     Console.WriteLine("Validation event" & vbCrLf & args.Message)
End Sub

  9. Erstellen Sie die Anwendung, und führen Sie sie aus.

Die Anwendung sollte melden, dass das XML-Dokument gültig ist. 10. Ändern Sie in Visual Studio 2005 oder in Visual Studio .NET ProductWithDTD.xml, um sie ungültig zu machen (z. B. löschen Sie das ProductName Rugby jersey/ProductName-Element). 11. Führen Sie die Anwendung erneut aus.

Die Anwendung sollte die folgende Fehlermeldung anzeigen:

Das Gültigkeitsprüfungsereigniselement 'Product' enthält unvollständigen Inhalt. 'ProductName' erwartet. Fehler bei file:///C:/MyFolder/ProductWithDTD.xml(4, 3). Dokument ist ungültig

  1. Zeigen Sie in Visual Studio 2005 oder in Visual Studio .NET im Menü "Datei" auf "Neu", und klicken Sie dann auf "Datei".

  2. Wählen Sie den Textdateityp aus, und klicken Sie dann auf "Öffnen".

  3. Fügen Sie der Datei die folgenden XDR-Schemadefinitionen hinzu, um die Grammatik des XML-Dokuments zu beschreiben:

    <?xml version="1.0"?>
<Schema name="ProductSchema" 
 xmlns="urn:schemas-microsoft-com:xml-data"
 xmlns:dt="urn:schemas-microsoft-com:datatypes">

    <AttributeType name="ProductID" dt:type="int"/>
    <ElementType name="ProductName" dt:type="string"/>

    <ElementType name="Product" content="eltOnly">
        <attribute type="ProductID" required="yes"/>
        <element type="ProductName"/>
    </ElementType>
</Schema>

  4. Speichern Sie die Datei als "Product.xdr " im selben Ordner wie ihr XML-Dokument.

  5. Öffnen Sie den ursprünglichen Product.xml erneut, und verknüpfen Sie ihn dann wie folgt mit dem XDR-Schema:

    <?xml version="1.0" encoding="utf-8" ?>
<Product ProductID="123" xmlns="x-schema:Product.xdr"> 
    <ProductName>Rugby jersey</ProductName>
</Product>

  6. Speichern Sie das geänderte XML-Dokument als ProductWithXDR.xml.

Durchführen der Überprüfung mithilfe eines XDR-Schemas

  1. Ändern Sie Ihre Anwendung so, dass xmlTextReader ProductWithXDR.xml wie folgt lädt:

    Dim r As New XmlTextReader("C:\MyFolder\ProductWithXDR.xml")

  2. Legen Sie die ValidationType XDR-Eigenschaft so fest, dass der Überprüfungsleser die XDR-Überprüfung wie folgt durchführt:

    v.ValidationType = ValidationType.XDR

  3. Erstellen Sie die Anwendung, und führen Sie sie aus.

    Die Anwendung sollte melden, dass das XML-Dokument gültig ist.

  4. Ändern Sie ProductWithXDR.xml , um sie absichtlich ungültig zu machen.

  5. Führen Sie die Anwendung erneut aus.

    Die Anwendung sollte einen Überprüfungsfehler melden.

  1. Zeigen Sie in Visual Studio .NET im Menü "Datei" auf "Neu", und klicken Sie dann auf "Datei".

  2. Wählen Sie den Textdateityp aus, und klicken Sie dann auf "Öffnen".

  3. Fügen Sie der Datei die folgende XSD-Schemadefinition hinzu, um die Grammatik des XML-Dokuments zu beschreiben:

    <?xml version="1.0"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <xsd:element name="Product">
    <xsd:complexType>
        <xsd:sequence>
            <xsd:element name="ProductName" type="xsd:string"/>
        </xsd:sequence>
        <xsd:attribute name="ProductID" use="required" type="xsd:int"/>
    </xsd:complexType>
    </xsd:element>
</xsd:schema>

  4. Speichern Sie die Datei als "Product.xsd" im selben Ordner wie Ihr XML-Dokument.

  5. Öffnen Sie die ursprüngliche Product.xml erneut, und verknüpfen Sie sie dann wie folgt mit dem XSD-Schema:

    <?xml version="1.0" encoding="utf-8" ?>
<Product ProductID="123" 
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:noNamespaceSchemaLocation="Product.xsd">
    <ProductName>Rugby jersey</ProductName>
</Product>

  6. Speichern Sie das geänderte XML-Dokument als ProductWithXSD.xml.

Durchführen der Überprüfung mithilfe eines XSD-Schemas

  1. Ändern Sie Ihre Anwendung so, dass die XmlTextReader Ladevorgänge wie folgtProductWithXSD.xml:

    Dim r As New XmlTextReader("C:\MyFolder\ProductWithXSD.xml")

  2. Legen Sie den ValidationType Wert auf "Schema" fest, sodass der Validierungsleser die XSD-Schemaüberprüfung wie folgt durchführt:

    v.ValidationType = ValidationType.Schema

  3. Erstellen Sie die Anwendung, und führen Sie sie aus, um das XML-Dokument mithilfe des XSD-Schemas zu überprüfen.

    Die Anwendung sollte melden, dass das XML-Dokument gültig ist.

Verwenden von Namespaces im XSD-Schema

  1. Öffnen Sie in Visual Studio 2005 oder in Visual Studio .NET ProductWithXSD.xml. Deklarieren Sie einen Standardnamespace urn:MyNamespaceim Dokument. Ändern Sie die XSD-Verknüpfung, um das XSD-Schema zum Überprüfen von Inhalten in diesem Namespace wie folgt anzugeben:

    <?xml version="1.0" encoding="utf-8"?>
<Product ProductID="123" 
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns="urn:MyNamespace"
 xsi:schemaLocation="urn:MyNamespace Product.xsd">
    <ProductName>Rugby jersey</ProductName>
</Product>

  2. Speichern sieProductWithXSD.xml.

  3. Öffnen Sie "Product.xsd", klicken Sie auf die XML-Registerkarte, und ändern Sie dann das Starttag "xsd:schema " wie folgt, sodass das Schema auf den Namespace urn:MyNamespaceangewendet wird:

    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
 targetNamespace="urn:MyNamespace"
 elementFormDefault="qualified">

  4. Speichern Sie "Product.xsd".

  5. Führen Sie die Anwendung aus, um das XML-Dokument mithilfe des XSD-Schemas zu überprüfen.

Cachenamespaces

  1. Öffnen Sie in Visual Studio 2005 oder in Visual Studio .NET Module1.vb. Erstellen Sie am Anfang der Main-Unterroutine ein XmlSchemaCollection Objekt wie folgt:

    Dim cache As New XmlSchemaCollection()

  2. Mit XmlSchemaCollection dem Objekt können Sie Schemas im Arbeitsspeicher zwischenspeichern, um die Leistung zu verbessern. Jedes Schema ist einem anderen Namespace zugeordnet. Fügen Sie den folgenden Code zum Zwischenspeichern von "Product.xsd" hinzu:

    cache.Add("urn:MyNamespace", "C:\MyFolder\Product.xsd")

  3. Fügen Sie nach dem Code, der das XmlValidatingReader Objekt erstellt, die folgende Anweisung hinzu. Dadurch wird dem Schemacache der XmlValidatingReader Cache hinzugefügt, sodass der Leser die Speicherschemas verwenden kann.

    v.Schemas.Add(cache)

Überprüfung

  1. Erstellen Sie die Anwendung, und führen Sie sie aus.
  2. Stellen Sie sicher, dass das XML-Dokument weiterhin anhand des XSD-Schemas überprüft wird.
  3. Nehmen Sie einige Änderungen an der ProductWithXSD.xml vor, um sie absichtlich ungültig zu machen.
  4. Stellen Sie sicher, dass die Anwendung diese Überprüfungsfehler erkennt.