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

  • Artikel

In diesem Artikel wird gezeigt, wie Sie die XmlValidatingReader -Klasse verwenden, um ein XML-Dokument anhand einer DTD, eines XDR-Schemas oder eines XSD-Schemas in Visual Basic 2005 oder in Visual Basic .NET zu überprüfen. Beschreibt auch, wie Die Validierung durch Zwischenspeichern von Schemas optimiert wird.

Ursprüngliche Produktversion: 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 Austauschen von Daten zwischen Anwendungen und Organisationen. Um die zulässige Struktur und den Inhalt eines XML-Dokuments anzugeben, können Sie eine Dokumenttypdefinition (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 im .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 Validierungsproblemen

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 namens C:\MyFolderausgegangen).

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

  2. Wählen Sie den Typ Textdatei 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 visual Studio .NET erneut. Zeigen Sie dazu im Menü Datei auf Öffnen, und klicken Sie dann auf Datei. Fügen Sie eine DOCTYPE-Anweisung (unterhalb 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 visual Studio .NET ein neues Visual Basic-Konsolenanwendungsprojekt mit dem Namen ValidateXmlUsingVB.

  2. Visual Studio 2005 oder Visual Studio .NET zeigt eine neue Datei namens Module1.vb an. Fügen Sie am Anfang dieser Datei wie folgt zwei Imports-Anweisungen 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 Hauptunterroutine) wie folgt eine boolesche Variable namens isValid:

    '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 Unterroutine Main 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 Validierungsfehler auftreten, generiert der überprüfende Leser ein Validierungsereignis. Fügen Sie den folgenden Code hinzu, um einen Validierungsereignishandler 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 Validierungsfehler auftreten, wird MyValidationEventHandler aufgerufen, um den Fehler zu behandeln. Diese Unterroutine wird auf False festgelegt isValid (siehe Schritt 8 dieses Abschnitts). Sie können die 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 Unterroutine MyValidationEventHandler 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 Validierungsereigniselement "Product" weist unvollständigen Inhalt auf. "ProductName" wurde erwartet. Fehler bei file:///C:/MyFolder/ProductWithDTD.xml(4, 3). Dokument ist ungültig

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

  2. Wählen Sie den Typ Textdatei 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.xmlerneut, und verknüpfen Sie sie 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 Validierung mithilfe eines XDR-Schemas

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

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

  2. Legen Sie auf ValidationType XDR fest, damit der überprüfende Reader 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 , um sie absichtlich ungültig zu machen.

  5. Führen Sie die Anwendung erneut aus.

    Die Anwendung sollte einen Validierungsfehler melden.

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

  2. Wählen Sie den Typ Textdatei 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 den ursprünglichen Product.xmlerneut, und verknüpfen Sie ihn 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 XmlTextReaderProductWithXSD.xmlwie folgt lädt:

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

  2. Legen Sie auf ValidationType Schema fest, damit der überprüfende Reader die XSD-Schemavalidierung 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 visual Studio .NET ProductWithXSD.xml. Deklarieren Sie im Dokument einen Standardnamespace urn:MyNamespace. Ändern Sie die XSD-Verknüpfung wie folgt, um das XSD-Schema zum Überprüfen des Inhalts in diesem Namespace 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 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 visual Studio .NET Module1.vb. Erstellen Sie am Anfang der Main-Unterroutine wie folgt ein XmlSchemaCollection -Objekt:

    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 hinzu, um Product.xsd zwischenzuspeichern:

    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 hinzugefügt XmlValidatingReader , 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. Vergewissern Sie sich, dass das XML-Dokument noch anhand des XSD-Schemas überprüft wird.
  3. Nehmen Sie einige Änderungen am ProductWithXSD.xml vor, um sie absichtlich ungültig zu machen.
  4. Vergewissern Sie sich, dass die Anwendung diese Validierungsfehler erkennt.