Werbung einblenden Werbung ausblenden


Home / Tutorials / xml, xsl, xpath Handbuch / XML Schema


XML Schema
Validierung eines XML-Schemas
Vollständige Beschreibung eines XML-Dokumentes
complexType
sequence
maxOccurs
minOccurs
choice
complexType
simpleType
simpleContent mit extension
Mit simpleContent auf eine externe Deklaration verweisen
simpleType mit restriction
complexContent mit extension

XML Schema

Schemas sind der zweite, in Zukunft nach allgemeiner Ansicht dominierende, Ansatz, um XML-Dokumente zu beschreiben. Die Idee dahinter ist die gleiche, wie bei der document type definition. Man sucht eine Methode, die erzwingt, dass alle XML-Dokumente eines bestimmten Typs gleich strukturiert sind. Dies ist zwingend notwendig, wenn dieser Typ von XML-Dokumenten über die gleichen Schnittstellen ausgewertet werden soll. Ein XML-Schema ist im Gegensatz zu einer XML-dtd immer eine externe Datei. Um uns klar zu machen, wie ein XML-Schema definiert wird, schreiben wir am besten eines. Unsere, schon aus dem Kapitel document type definition (DTD) bekannten XML-Datei wollen wir nun ein Schema schreiben. Die XML-Datei, nochmal zur Erinnerung, sieht so aus:

<?xml version="1.0" encoding="ISO-8859-1"?>
<Projekte xmlns="http://127.0.0.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://127.0.0.1
test28.xsd">
<Gruppe>
<Gruppenname stand="abgeschifft">Berliner Verwaltungsreform</Gruppenname>
<Kollegen>
<Mitarbeiter Firma="Price Waterhouse">Werner Lepinski</Mitarbeiter>
<Mitarbeiter>Erika Saufwech</Mitarbeiter>
<Mitarbeiter>Hans Geldfliech</Mitarbeiter>
</Kollegen>
<Ansprechpartner Telefon="030-435555" Ident="A_1">Otto Moltoimportante</Ansprechpartner>
<Adresse>
<Strasse Gegend="teures Pflaster">Kurfürstendamm 5</Strasse>
<Ort>13453 Berlin</Ort>
</Adresse>
<Budget>40000000</Budget>
<Kommentar/>
</Gruppe>
<Gruppe>
<Gruppenname>Hamburger Verwaltungschaos </Gruppenname>
<Kollegen>
<Mitarbeiter Firma="Arthur de Little">Werner Nordflut</Mitarbeiter>
<Mitarbeiter>Marina Meimportauncarajo</Mitarbeiter>
<Mitarbeiter>Peter Wessnich</Mitarbeiter>
</Kollegen>
<Ansprechpartner Ident="A_2">Ludwig Noresponsable</Ansprechpartner>
<Adresse>
<Strasse>An der Waterkant 15</Strasse>
<Ort>45555 Hamburg</Ort>
</Adresse>
<Kostenvoranschlag>30000000</Kostenvoranschlag>
</Gruppe>
</Projekte>

Das dazugehörige XML-Schema sieht dann so aus.

<?xml version="1.0"?>
<xs:schema targetNamespace="http://127.0.0.1" xmlns="http://127.0.0.1" xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
<xs:element name="Projekte">
<xs:complexType>
<xs:sequence minOccurs="0" maxOccurs="unbounded">
<xs:element name="Gruppe">
<xs:complexType>
<xs:sequence minOccurs="0" maxOccurs="4">
<xs:element name="Gruppenname">
<xs:complexType>
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="stand" type="xs:string"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:element>
<xs:element name="Kollegen">
<xs:complexType>
<xs:sequence minOccurs="0" maxOccurs="4">
<xs:element name="Mitarbeiter">
<xs:complexType>
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="Firma" type="xs:string"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="Ansprechpartner">
<xs:complexType>
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="hinweise" type="xs:string" fixed="arbeitet wie ein Pferd"/>
<xs:attribute name="Telefon" type="xs:string"/>
<xs:attribute name="Ident" type="xs:string"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:element>
<xs:element name="Adresse">
<xs:complexType>
<xs:sequence>
<xs:element name="Strasse">
<xs:complexType>
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="Gegend" type="xs:string" use="optional"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:element>
<xs:element name="Ort" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:choice>
<xs:element name="Budget" type="xs:integer"/>
<xs:element name="Kostenvoranschlag" type="xs:integer"/>
</xs:choice>
<xs:element name="Kommentar" type="xs:string" minOccurs="0"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>

Validierung eines XML-Schemas

Bei der Validierung dieses Schemas versagt der Explorer endgültig. Er stellt das XML-Dokument zwar dar, interpretiert aber die Attribute nicht richtig. Eine Validierung ermöglicht die Seite http://www.w3.org/2001/03/webdata/xsv. Um diese durchzuführen muss man beide Dateien, das Schema wie auch die XML-Datei, deren Gültigkeit gegen dieses Schema geprüft werden soll, auf einen Rechner im Internet uploaden. Die Domain http://127.0.0.1 ist dann natürlich entsprechend zu ändern. Eine weitere Möglickeit ist, von der Seite http://www.xmlspy.com xmlypy herunterzuladen (15 MB !) und das Dokument damit zu validieren. Wer selber Schema schreiben will, wird nicht umhin kommen, sich eine Software lokal zu installieren, die Schemas validiert. Sprechen wir das Schema Stück für Stück durch. Die Deklaration eines Schemas beginnt immer gleich. Dieses Schema zeigt die wesentlichen Elemente eines Schemas:

1) <xs:schema
2) targetNamespace="http://127.0.0.1"
3) xmlns="http://127.0.0.1"
4) xmlns:xs="http://www.w3.org/2001/XMLSchema"
5) elementFormDefault="qualified">


1) Ein Schema muss selber den Kriterien eines wohlgeformten XML-Dokumentes genügen und hat folglich eine Wurzelelement. Dieses Wurzelelement ist bei einem Schema immer schema. Entscheidend ist jetzt
4) Hier wird der namespace festgelegt, in welchem sich die Elemente befinden, die das Schema definieren, also schema, element, extension, complexType etc. etc. Es wird auch festgelegt, dass auf diesen namespace und auf dessen Elemente über das Präfix xs (xs:element, xs:extension etc.) zugegriffen wird. Mehr zu Namensräumen unter document type definition (DTD) .
5) besagt, dass alle Elemente, die die XML-Instanz (also das XML-Dokument, dass aufgrund dieses Schema validiert wird) nutzt, im Schema einem Namensraum zugeordnet werden müssen. Der targetNamespace ist der Namensraum, wo das Schema angewendet wird. In der Regel ist das auch der Default Namespace, also der Namensraum, der angenommen wird, wenn ein Element ohne Präfix gesetzt wird.

Vollständige Beschreibung eines XML-Dokumentes

Ein Schema muss ein XML-Dokument vollständig beschreiben. Es muss beschreiben, in welcher Reihenfolge die Elemente auftauchen, die Art des Inhalts (string, integer, date:time etc.), ob das Element optional oder zwingend vorhanden sein muss, die Verschachtelung der Elemente, die Attribute der Elemente etc. etc. In unserem Beispiel ist Projekte das Wurzelement. Dieses wiederum hat einen Tochterknoten, Gruppe. Die Gruppe wiederum hat die Elemente Gruppennamen (Attribut stand), Kollegen (mit den Elementen Mitarbeiter), Ansprechpartner mit wiederum drei Attributen, Adresse mit den Elementen Strasse und Ort und schlussendlich noch die Elemente Budget, Kostenvoranschlag, Kommentar. Die Elemente Budget und Kostenvoranschlag schliessen sich hierbei gegenseitig aus. Entweder kommt Budget vor oder Kostenvoranschlag, aber nicht beide zusammen. Das Element Kommentar kann vorkommen, muss aber nicht (man betrachte nochmal im Detail die zu validierende XML-Datei). Wir müssen bei unserem XML-Schema auch berücksichtigen, dass es

1. Elemente gibt, die nur Attribute und Text haben
2. Elemente, die Attribute und andere Elemente haben
3. Elemente , die mehrere Elemente haben

Schemas beschreiben also ein XML-Dokument sehr präzise, was wiederum heisst, dass sie nur mit einem gewissen Aufwand erstellt werden können. Die äußere Klammer für unser Schema sieht so aus:


<xs:element name="Projekte">
<xs:complexType>
<xs:sequence minOccurs="0" maxOccurs="unbounded">
........Deklaration der anderen Elemente....
</xs:complexType>
</xs:element>
</xs:schema>

Wir haben also ein Element Projekte (dass selber wiederum ein Element von schema ist, da das Wurzelelement eines Schema immer das Element schema ist).

complexType

Wir haben es mit einem complexType zu tun, das heisst mit einem Element, dass ausser Zeichenketten noch andere Elemente oder Attribute enthält. Es stellen sich folgende Fragen:

1. Müssen die Elemente, die wir innerhalb dieses Blocks definieren in genau der Reihenfolge auftauchen, wie wir sie definieren oder kann die Reihenfolge eine andere sein.
2. Muss jedes Element auftauchen, oder dürfen manche Elemente fehlen.
Weiter könnte man noch festlegen, ob in dem XML-Dokument Elemente vorkommen dürfen, die wir nicht definieren.

sequence

Mit sequence geben wir an, dass die Elemente genau in der vorgeschriebenen Reihenfolge auftauchen müssen. Innerhalb von sequence definieren wir auch, wie oft das Element Gruppe auftauchen darf. Mit minOccurs und maxOccurs geben wir an, wie oft ein Element auftauchen darf. Wir vergegenwärtigen uns nochmal kurz die Alternativen.

<xs:element name="Projekte">
<xs:complexType>
<xs:all>
........Deklaration der anderen Elemente....
</xs:complexType>
</xs:element>
</xs:schema>

Geben wir anstatt sequence all an, legen wir fest, dass die Elemente in einer beliegen Reihenfolge auftauchen können. Allerdings können und müssen sie dann nur einmal auftauchen.

maxOccurs

maxOccurs="unbounded" gibt an, dass das Element Gruppe beliebig oft auftauchen darf.

minOccurs

Mit minOccurs als Attribut des Elements kann man aber festlegen, dass sie auch 0 Mal vorkommen können.

choice

Als Alternative zu sequence hätte sich noch choice angeboten, wir kommen darauf später zurück. choice macht allerdings nur dann Sinn, wenn das Element mindestens zwei Elemente hat, weil eine Auswahl getroffen wird (entweder das eine Element, oder das andere, oder ein drittes.) Bei choice darf aber nur ein Element auftauchen.
Auch bei choice ist es möglich anzugeben, wie oft ein Element auftauchen soll. Hierbei können die Attribute maxOccurs und minOccurs sowohl als Attribut von choice als auch als Attribut der Elemente auftauchen. Ein Schema kann zum Beispiel so aussehen:

<?xml version="1.0"?>
<xs:schema targetNamespace="http://127.0.0.1" xmlns="http://127.0.0.1" xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
<xs:element name="Name">
<xs:complexType>
<xs:choice maxOccurs="2" minOccurs="1">
<xs:element name="Nachname"/>
<xs:element name="Vorname"/>
<xs:element name="Telefon"/>
<xs:element name="Adresse"/>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>

Das heisst, dass eines der genannten Elemente (eines !) vorkommen kann und dieses muss dann mindestens einmal und darf höchstens 2 mal vorkommen. Validiert gegen dieses Schema, ist dann folgende XML-Datei gültig:

<?xml version="1.0" encoding="ISO-8859-1"?>
<Name xmlns="http://127.0.0.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://127.0.0.1
c:/sambar/docs/banane.xsd">
<Nachname>Ehmann</Nachname>
<Nachname>Maier</Nachname>
</Name>

Eine Feinsteuerung kann man durchführen, wenn man die Attribute minOccurs und maxOccurs als Attribute der einzelnen Elemente deklariert.

<?xml version="1.0"?>
<xs:schema targetNamespace="http://127.0.0.1" xmlns="http://127.0.0.1" xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
<xs:element name="Name">
<xs:complexType>
<xs:choice>
<xs:element name="Nachname" maxOccurs="2" minOccurs="1"/>
<xs:element name="Vorname" maxOccurs="5" minOccurs="2"/>
<xs:element name="Telefon" maxOccurs="2" minOccurs="1"/>
<xs:element name="Adresse" maxOccurs="10" minOccurs="5"/>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>

Das heisst, irgendeines (eines !) der Elemente muss vorkommen und das Element das vorkommt, muss zwischen minOccurs und maxOccurs liegen. Gegen dieses Schema validiert, ist dieses XML-Dokument gültig:

<?xml version="1.0" encoding="ISO-8859-1"?>
<Name xmlns="http://127.0.0.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://127.0.0.1
c:/sambar/docs/banane.xsd">
<Vorname>Andres</Vorname>
<Vorname>Maria</Vorname>
<Vorname>David</Vorname>
</Name>

Kehren wir zurück zu unserem komplexeren Schema. Innerhalb unseres Wurzelelementes, darf das Element Gruppe beliebig oft auftauchen.

<xs:schema targetNamespace="http://127.0.0.1" xmlns="http://127.0.0.1" xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
<xs:element name="Projekte">
<xs:complexType>
<xs:sequence minOccurs="0" maxOccurs="unbounded">
<xs:element name="Gruppe">
<xs:complexType>
<xs:sequence minOccurs="0" maxOccurs="4">
...der Inhalt des Elementes Gruppe.....
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>

Wie wir sehen ist Gruppe, das entspricht auch dem Aufbau der XML-Datei, in dem Element Projekte enthalten.

complexType

Auch das Element Gruppe wiederum ist vom Typ complexType, das heisst, es enthält mehr, als nur Text. Wieder zeigen wir mit sequence an, dass die Elemente in genau der Reihenfolge auftauchen, die wir definieren, wobei allerdings auch Elemente fehlen dürfen, was bei der XML-Datei ja auch tatasächlich der Fall ist. Einen Kommentar gibt es nur in der ersten Gruppe, in der zweiten Gruppe nicht. Fehlen die Attribute minOccurs und maxOccurs, so wird angenommen, dass das Element genau einmal auftauchen muss. Ist maxOccurs definiert aber minOccurs nicht, so muss es mindestens einmal auftauchen und höchsten so oft, wie in maxOccurs angegeben. Fehlt maxOccurs, so muss es genau so oft auftauchen, wie in minOccurs definiert Innerhalb von Gruppe haben wir das Element Gruppenname.

<xs:element name="Gruppenname">
<xs:complexType>
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="stand" type="xs:string"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:element>

Auch hier haben wir wieder complexType.

simpleType

Vom Typ simpleType kann nur ein Element sein, welches keine anderen Elemente hat. simpleType kann auch nicht sequence oder choice einschliessen, schon aus diesem Grund, kann man in simpleType keine Elemente einbauen. (sequence ist immer ein Kind von complexType). Also kann simpleType nur etwas von diesem Typ

<Gruppenname>Youngsters</Gruppenname>

oder diesem

<Gruppenname Aufenthaltsort="Disco">Youngsters</Gruppenname>

sein. Letztere Version haben wir in unserem Beispiel. Die Frage, die sich nun stellt, warum ist das so kompliziert, warum brauchen wir jetzt noch simpleContent und extension. Die Antwort hierauf ist einfach, wir brauchen es nicht. Man hätte ein Element mit Inhalt und Attributen auch so deklarieren können.

<xs:element name="Gruppenname">
<xs:complexType mixed="true">
<xs:attribute name="stand"/>
</xs:complexType>
</xs:element>

Dies wäre das gleiche. complexType erlaubt andere Elemente und Attribute, aber keinen Textinhalt. Mit complexType ist also so etwas möglich:

<Gruppenname>
<ort>Berlin</ort>
</Gruppenname>

aber so etwas nicht:

<Gruppenname>Wir sind in Berlin</Gruppenname>

Letzteres ist aber das, was wir haben wollen. Wir müssen also complexType durch das Attribut mixed mit dem Wert true erweitern. Es stellt sich nun die Frage, wozu man simpleContent (bzw.complexContent) wirklich braucht. Beide braucht man nur im Zusammenhang mit restriction (wenn der Inhalt eingeschränkt werden soll) oder mit extension ( wenn der Inhalt erweitert werden soll). Für restriction sind auch Anwendungen ohne simpleContent oder complexContent denkbar. Es sind aber keine Anwendungen von simpleContent oder complexContent ohne restriction oder extension denkbar.

simpleContent mit extension

Ziel: Erweitern eines Elementes vom Typ complexType mit einem Attribut.
Dies ist der Fall, der sich, wie oben beschrieben auch anders lösen lässt. Nehmen wir an, wir wollen für dieses XML-Dokument ein Schema schreiben:


<?xml version="1.0" encoding="ISO-8859-1"?>
<Adressen xmlns="http://127.0.0.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://127.0.0.1
c:/sambar/docs/kirsche.xsd">
<Name Wohnort="Berlin">Andrés Ehmann</Name>
</Adressen>

Das dazugehörige Schema sieht dann so aus.

<?xml version="1.0"?>
<xs:schema targetNamespace="http://127.0.0.1" xmlns="http://127.0.0.1" xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
<xs:element name="Adressen">
<xs:complexType>
<xs:sequence>
<xs:element name="Name">
<xs:complexType>
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="Wohnort"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>

Mit simpleContent auf eine externe Deklaration verweisen

Mit simpleContent können wir auch auf externe Deklarationen verweisen. Das obige Beispiel hätte man auch so schreiben können:

<?xml version="1.0"?>
<xs:schema targetNamespace="http://127.0.0.1" xmlns="http://127.0.0.1" xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">

<xs:complexType name="the_same">
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="Wohnort"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>

<xs:element name="Adressen">
<xs:complexType>
<xs:sequence>

<xs:element name="Name">
<xs:complexType>
<xs:simpleContent>
<xs:extension base="the_same"/>
</xs:simpleContent>
</xs:complexType>
</xs:element>

</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>

simpleType mit restriction

Ziel: Eingrenzung des Wertebereiches eines Attributes
Angenommen man hat sowas

<?xml version="1.0" encoding="ISO-8859-1"?>
<Adressen xmlns="http://127.0.0.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://127.0.0.1
c:/sambar/docs/kirsche.xsd">
<Name Wohnort="Berlin">Andrés Ehmann</Name>
</Adressen>

und als Wert von Wohnort darf nur Hamburg, Berlin oder Freiburg auftauschen. Das dazugehörige Schema sieht dann so aus:

<?xml version="1.0"?>
<xs:schema targetNamespace="http://127.0.0.1" xmlns="http://127.0.0.1" xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">

<xs:element name="Adressen">
<xs:complexType>
<xs:sequence maxOccurs="unbounded">

<xs:element name="Name">
<xs:complexType>
<xs:complexContent>
<xs:extension base="xs:string">
<xs:attribute name="Wohnort">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="Berlin"/>
<xs:enumeration value="Hamburg"/>
<xs:enumeration value="Freiburg"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>

</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>

Das oben gezeigte Schema ist mit dieser XML-Datei kompatibel

<?xml version="1.0" encoding="ISO-8859-1"?>
<Adressen xmlns="http://127.0.0.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://127.0.0.1
c:/sambar/docs/kirsche.xsd">
<Name Wohnort="Berlin">Andrés Ehmann</Name>
<Name Wohnort="Freiburg">Werner Lützelschwab</Name>
<Name Wohnort="Hamburg">Andrea Holthusen</Name>
</Adressen>

nicht aber mit diesem

<?xml version="1.0" encoding="ISO-8859-1"?>
<Adressen xmlns="http://127.0.0.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://127.0.0.1
c:/sambar/docs/kirsche.xsd">
<Name Wohnort="Berlin">Andrés Ehmann</Name>
<Name Wohnort="Freiburg">Werner Lützelschwab</Name>
<Name Wohnort="Hamburg">Andrea Holthusen</Name>
<Name Wohnort="Bremen">Hans Leverkühn</Name>
</Adressen>

da Bremen ausgeschlossen wurde.

complexContent mit extension

Ziel: Eine externe Deklaration in ein Element einbinden
Gesetzt den Fall, man definiert mehrere Elemente und Teile der Elementdefinition sind mit den Definitionen anderer Elemente identisch. In diesem Fall ist es einfacher, die immer gleichen Teile extern zu definieren und sich dann bei immer wieder darauf zu berufen.


<?xml version="1.0"?>
<xs:schema targetNamespace="http://127.0.0.1" xmlns="http://127.0.0.1" xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">

<xs:complexType name="zusatz">
<xs:sequence>
<xs:element name="Familienname"/>
<xs:element name="Telefon"/>
</xs:sequence>
</xs:complexType>

<xs:element name="Adressen">
<xs:complexType>
<xs:complexContent>
<xs:extension base="zusatz">
<xs:sequence>
<xs:element name="Strasse"/>
<xs:element name="Ort"/>
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:element>

</xs:schema>

Validiert gegen dieses Schema, wäre diese XML-Datei gültig:

<?xml version="1.0" encoding="ISO-8859-1"?>
<Adressen xmlns="http://127.0.0.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://127.0.0.1
c:/sambar/docs/kirsche.xsd">
<Familienname>Ehmann</Familienname>
<Telefon>030-47301386</Telefon>
<Strasse>Hallandstrasse 2</Strasse>
<Ort>13189 Berlin</Ort>
</Adressen>

Weiterführende Informationen zu schema findet man unter http://www.w3schools.com/schema/el_restriction.asp oder im Help Menue des MSXML-Parsers.

vorhergehendes Kapitel