Weryfikowanie dokumentu XML przy użyciu DTD, XDR lub XSD w visual basic

Artykuł
07/17/2023

W tym artykule pokazano, jak za pomocą XmlValidatingReader klasy zweryfikować dokument XML względem DTD, schematu XDR lub schematu XSD w programie Visual Basic 2005 lub visual basic .NET. Opisano również sposób optymalizowania walidacji przez buforowanie schematów.

Oryginalna wersja produktu: Visual Basic
Oryginalny numer KB: 315533

Podsumowanie

Dokumenty języka XML (Extensible Markup Language) zawierają elementy i atrybuty oraz zapewniają elastyczny i zaawansowany sposób wymiany danych między aplikacjami i organizacjami. Aby określić dozwoloną strukturę i zawartość dokumentu XML, można napisać definicję typu dokumentu (DTD), schemat XDR (Microsoft XML-Data Reduced) lub język definicji schematu XML (XSD).

Schematy XSD to preferowany sposób określania gramatyki XML w .NET Framework, ale obsługiwane są również DTD i schematy XDR.

W tym artykule dowiesz się, jak zastosować DTD, schemat XDR lub schemat XSD do dokumentu XML w programie Microsoft Visual Basic 2005 lub microsoft Visual Basic .NET. Następnie dowiesz się, jak za pomocą klasy XmlValidatingReader zweryfikować dokument XML względem określonej gramatyki. Dowiesz się również, jak używać klasy XmlSchemaCollection do buforowania schematów w pamięci jako sposobu optymalizacji walidacji XML.

Wymagania

Na poniższej liście przedstawiono zalecany sprzęt, oprogramowanie, infrastrukturę sieciową i dodatki Service Pack, których potrzebujesz: Microsoft Visual Basic 2005 lub Microsoft Visual Basic .NET

W tym artykule opisano następujące przestrzenie nazw biblioteki klas microsoft .NET Framework:

System.Xml
System.Xml.Schema

W tym artykule założono, że znasz następujące tematy:

Składnia programu Visual Basic 2005 lub Visual Basic na platformie .NET
Pojęcia XML, w tym problemy z weryfikacją

Tworzenie dokumentu XML

Uruchom program Microsoft Visual Studio 2005 lub Microsoft Visual Studio .NET. Następnie utwórz nowy plik XML (w menu Plik wskaż polecenie Nowy, a następnie kliknij pozycję Plik).
Wybierz typ pliku XML, a następnie kliknij przycisk Otwórz.

Dodaj następujące dane do dokumentu XML, aby reprezentować produkt w wykazie:

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

Zapisz plik jako Product.xml w folderze, do którego będzie można łatwo uzyskać dostęp później (przykłady kodu w tym artykule zakładają folder o nazwie C:\MyFolder).

Tworzenie identyfikatora DTD i łącze do dokumentu XML

W programie Visual Studio 2005 lub w programie Visual Studio .NET wskaż polecenie Nowy w menu Plik, a następnie kliknij pozycję Plik.
Wybierz typ pliku tekstowego, a następnie kliknij przycisk Otwórz.

Dodaj następujące deklaracje DTD do pliku, aby opisać gramatyki dokumentu XML:

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

Zapisz plik jako Product.dtd w tym samym folderze co dokument XML.
Otwórz ponownieProduct.xml w programie Visual Studio 2005 lub w programie Visual Studio .NET; W tym celu wskaż polecenie Otwórz w menu Plik, a następnie kliknij pozycję Plik. Dodaj instrukcję DOCTYPE (poniżej wiersza ?xml version="1.0" ) w następujący sposób. Spowoduje to połączenie dokumentu XML z plikiem DTD.
```
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE Product SYSTEM "Product.dtd">
```
Zapisz zmodyfikowany dokument XML jako ProductWithDTD.xml.

Przeprowadzanie walidacji przy użyciu DTD

W programie Visual Studio 2005 lub w programie Visual Studio .NET utwórz nowy projekt aplikacji konsolowej Visual Basic o nazwie ValidateXmlUsingVB.
Program Visual Studio 2005 lub Visual Studio .NET wyświetla nowy plik o nazwie Module1.vb. Na początku tego pliku dodaj dwie instrukcje Imports w następujący sposób:
```
Imports System.Xml ' For XmlTextReader and XmlValidatingReader
Imports System.Xml.Schema ' For XmlSchemaCollection (used later)
```

W module Module1 (przed rozpoczęciem podprogramu Main) zadeklaruj zmienną logiczną o nazwie isValid w następujący sposób:

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

W podprogramie Main utwórz obiekt XmlTextReader, aby odczytać dokument XML z pliku tekstowego. Następnie utwórz XmlValidatingReader obiekt w celu zweryfikowania tych danych XML:
```
Dim r As New XmlTextReader("C:\MyFolder\ProductWithDTD.xml")
Dim v As New XmlValidatingReader(r)
```
Obiekt XmlValidatingReader ma właściwość ValidationType, która wskazuje typ wymaganej weryfikacji (DTD, XDR lub Schema). Ustaw tę właściwość na wartość DTD w następujący sposób:
```
v.ValidationType = ValidationType.DTD
```
Jeśli wystąpią błędy walidacji, czytnik weryfikacji generuje zdarzenie weryfikacji. Dodaj następujący kod, aby zarejestrować procedurę obsługi zdarzeń weryfikacji (w kroku 8 tej sekcji zaimplementujesz podprogram MyValidationEventHandler):
```
AddHandler v.ValidationEventHandler, AddressOf MyValidationEventHandler
```
Dodaj następujący kod, aby odczytać i zweryfikować dokument XML. Jeśli wystąpią błędy walidacji, w celu obsługi błędu zostanie wywołana funkcja MyValidationEventHandler. Ta podprogram zostanie ustawiona isValid na wartość False (zobacz krok 8 tej sekcji). Możesz sprawdzić stan isValid po walidacji, aby sprawdzić, czy dokument jest prawidłowy, czy nieprawidłowy.
```
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
```

Po podprogramie Main napisz podprogram MyValidationEventHandler w następujący sposób:

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

Skompiluj i uruchom aplikację.

Aplikacja powinna zgłosić, że dokument XML jest prawidłowy. 10. W programie Visual Studio 2005 lub w programie Visual Studio .NET zmodyfikuj ProductWithDTD.xml, aby była nieprawidłowa (na przykład usuń element ProductName Rugby jersey/ ProductName ). 11. Uruchom ponownie aplikację.

Aplikacja powinna wyświetlić następujący komunikat o błędzie:

Element zdarzenia weryfikacji "Product" ma niekompletną zawartość. Oczekiwano "ProductName". Wystąpił błąd w file:///C:/MyFolder/ProductWithDTD.xml(4, 3). Dokument jest nieprawidłowy

Tworzenie schematu XDR i łącze do dokumentu XML

W programie Visual Studio 2005 lub w programie Visual Studio .NET wskaż polecenie Nowy w menu Plik, a następnie kliknij pozycję Plik.
Wybierz typ pliku tekstowego, a następnie kliknij przycisk Otwórz.

Dodaj następujące definicje schematu XDR do pliku, aby opisać gramatyki dokumentu XML:

<?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>

Zapisz plik jako plik Product.xdr w tym samym folderze co dokument XML.

Otwórz ponownie oryginalny Product.xml, a następnie połącz go ze schematem XDR w następujący sposób:

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

Zapisz zmodyfikowany dokument XML jako ProductWithXDR.xml.

Walidacja przy użyciu schematu XDR

Zmodyfikuj aplikację tak, aby obiekt XmlTextReader ładuje ProductWithXDR.xml, w następujący sposób:
```
Dim r As New XmlTextReader("C:\MyFolder\ProductWithXDR.xml")
```
ValidationType Ustaw wartość XDR tak, aby czytnik sprawdzania poprawności przeprowadzał walidację XDR w następujący sposób:
```
v.ValidationType = ValidationType.XDR
```
Skompiluj i uruchom aplikację.

Aplikacja powinna zgłosić, że dokument XML jest prawidłowy.
ZmodyfikujProductWithXDR.xml, aby celowo była nieprawidłowa.
Uruchom ponownie aplikację.

Aplikacja powinna zgłosić błąd weryfikacji.

Tworzenie schematu XSD i łącze do dokumentu XML

W programie Visual Studio .NET wskaż pozycję Nowy w menu Plik, a następnie kliknij pozycję Plik.
Wybierz typ pliku tekstowego, a następnie kliknij przycisk Otwórz.

Dodaj następującą definicję schematu XSD do pliku, aby opisać gramatyki dokumentu XML:

<?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>

Zapisz plik jako Plik Product.xsd w tym samym folderze co dokument XML.

Otwórz ponownie oryginalny Product.xml, a następnie połącz go ze schematem XSD w następujący sposób:

<?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>

Zapisz zmodyfikowany dokument XML jako ProductWithXSD.xml.

Walidacja przy użyciu schematu XSD

Zmodyfikuj XmlTextReader aplikację tak, aby ładowanie ProductWithXSD.xml, w następujący sposób:
```
Dim r As New XmlTextReader("C:\MyFolder\ProductWithXSD.xml")
```
Ustaw wartość schematu ValidationType tak, aby czytnik weryfikacji przeprowadzał walidację schematu XSD w następujący sposób:
```
v.ValidationType = ValidationType.Schema
```
Skompiluj i uruchom aplikację, aby zweryfikować dokument XML przy użyciu schematu XSD.

Aplikacja powinna zgłosić, że dokument XML jest prawidłowy.

Używanie przestrzeni nazw w schemacie XSD

W programie Visual Studio 2005 lub w programie Visual Studio .NET otwórz ProductWithXSD.xml. Zadeklaruj domyślną przestrzeń urn:MyNamespacenazw , w dokumencie. Zmodyfikuj połączenie XSD, aby określić schemat XSD w celu zweryfikowania zawartości w tej przestrzeni nazw w następujący sposób:
```
<?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>
```
Zapisz ProductWithXSD.xml.
Otwórz plik Product.xsd, kliknij kartę XML, a następnie zmodyfikuj tag start xsd:schema w następujący sposób, aby schemat miał zastosowanie do przestrzeni urn:MyNamespacenazw :
```
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
 targetNamespace="urn:MyNamespace"
 elementFormDefault="qualified">
```
Zapisz plik Product.xsd.
Uruchom aplikację, aby zweryfikować dokument XML przy użyciu schematu XSD.

Przestrzenie nazw pamięci podręcznej

W programie Visual Studio 2005 lub w programie Visual Studio .NET otwórz Module1.vb. Na początku podprogramu Main utwórz XmlSchemaCollection obiekt w następujący sposób:
```
Dim cache As New XmlSchemaCollection()
```
Obiekt XmlSchemaCollection umożliwia buforowanie schematów w pamięci w celu zwiększenia wydajności. Każdy schemat jest skojarzony z inną przestrzenią nazw. Dodaj następujący kod do pamięci podręcznej Product.xsd:
```
cache.Add("urn:MyNamespace", "C:\MyFolder\Product.xsd")
```
Po kodzie, który tworzy XmlValidatingReader obiekt, dodaj następującą instrukcję. Spowoduje to dodanie pamięci podręcznej schematu XmlValidatingReader do elementu , aby czytelnik mógł używać schematów w pamięci.
```
v.Schemas.Add(cache)
```

Weryfikacji

Skompiluj i uruchom aplikację.
Sprawdź, czy dokument XML jest nadal weryfikowany względem schematu XSD.
Wprowadź pewne zmiany w ProductWithXSD.xml , aby celowo uczynić go nieprawidłowym.
Sprawdź, czy aplikacja wykrywa te błędy weryfikacji.