| 
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
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).
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.
|
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="unbounded" gibt
an, dass das Element Gruppe beliebig oft auftauchen darf.
Mit minOccurs als Attribut des Elements kann
man aber festlegen, dass sie auch 0 Mal vorkommen können.
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.
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.
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.
|
