Freigeben über

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

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 überprüfen. Beschreibt außerdem, wie die Validierung durch Zwischenspeichern von Schemas optimiert wird.

Originalproduktversion: 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 XDR-Schema (Microsoft XML-Data Reduced) oder ein XSD-Schema (XML Schema Definition Language) schreiben.

XSD-Schemas sind die bevorzugte Methode zum Angeben von XML-Grammatiken in .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 mithilfe der XmlValidatingReader-Klasse ein XML-Dokument anhand der angegebenen Grammatik überprüfen. Außerdem erfahren Sie, wie Sie die XmlSchemaCollection-Klasse zum Zwischenspeichern von Schemas im Arbeitsspeicher verwenden, um die XML-Validierung 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 Microsoft .NET Framework-Klassenbibliotheksnamespaces:

  • 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 Validierungsprobleme

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", zeigen Sie 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 zugreifen können (die Codebeispiele in diesem Artikel gehen von einem Ordner mit dem Namen C:\MyFolderaus).

  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 hierzu 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 einer Überprüfung mithilfe einer DTD

  1. Erstellen Sie in Visual Studio 2005 oder in Visual Studio .NET ein neues Visual Basic Console Application-Projekt 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 Module1 (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 Hauptunterroutine 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 Überprüfungsleser 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 Hauptunterroutine 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 so, dass sie ungültig wird (z. B. das ProductName Rugby Jersey/ProductName-Element). 11. Führen Sie die Anwendung erneut aus.

Die Anwendung sollte die folgende Fehlermeldung anzeigen:

Das Validation-Ereigniselement "Product" enthält unvollständigen Inhalt. 'ProductName' erwartet. Bei file:///C:/MyFolder/ProductWithDTD.xml(4, 3) ist ein Fehler aufgetreten. 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 das ursprüngliche Product.xml erneut, und verknüpfen Sie es 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 einer Überprüfung mithilfe eines XDR-Schemas

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

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

  2. Legen Sie den ValidationType XDR-Wert so fest, dass der Überprüfungsleser die XDR-Überprüfung wie folgt ausfü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 , damit sie absichtlich ungültig wird.

  5. Erneutes Ausführen der Anwendung

    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 das ursprüngliche Product.xml erneut, und verknüpfen Sie es 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 einer Überprüfung mithilfe eines XSD-Schemas

  1. Ändern Sie Ihre Anwendung so, dass die XmlTextReader ProductWithXSD.xml wie folgt geladen wird:

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

  2. Legen Sie das ValidationType Schema so fest, dass der Überprüfungsleser die XSD-Schemaüberprüfung wie folgt ausfü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 im urn:MyNamespaceDokument. Ändern Sie die XSD-Verknüpfung so, dass das XSD-Schema zum Überprüfen von Inhalten in diesem Namespace wie folgt angegeben wird:

    <?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 Sie ProductWithXSD.xml.

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

    <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 Hauptunterroutine ein XmlSchemaCollection Objekt wie folgt:

    Dim cache As New XmlSchemaCollection()

  2. Mit dem XmlSchemaCollection 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 der Schemacache dem XmlValidatingReader Schemacache hinzugefügt, sodass der Leser die In-Memory-Schemas 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. Überprüfen Sie, ob die Anwendung diese Überprüfungsfehler erkennt.