Neues HowTo, "Neue" Guides

Hallo,

ich hab mal wieder mich hingesetzt und neben den MS ASP.NET AJAX HowTos jetzt auch eine neue Reihe angefangen (allerdings hängen die auch mehr oder weniger mit zusammen ;) ) – Silverlight.

Ich hab auch den XML Guide erweitert mit 4 neuen Seiten. Dabei hab ich gemerkt, dass ich wohl an die Grenzen von Wordpress gestoßen bin, daher ist die Formatierung etwas zerschossen im Firefox, weil ich die eine Seite in drei Teile aufspalten musste. Leider. Und mein Browser ist mehrmals abgestürtzt. Ich muss mal forschen, woran das liegt oder muss mir eine neue Struktur überlegen.

Bis dahin allerdings die 4 Guide-Teile:

Guide: XML (DocumentType Definitions DTDs)
Guide: XML (XML Schema – Teil 1)
Guide: XML (XML Schema – Teil 2)
Guide: XML (XML Schema – Teil 3)

 

Grüße,

Robert

Guide: XML (XML Schema XSD – Teil 2)

4.2.2.3 Definition von Typen

Jedem Element und Attribut werden Typen zugeordnet. In der XSD gibt es einfache („simpleType“) und komplexe(„complexType“) Typen.

Einfache Typen “simpleType”:

Der „simpleType“ definiert einen einfachen Typ, welcher bereits vordefinierte Typen, wie z.B. xsd:string, xsd:int etc. enthält.

Es ist auch möglich, eigene einfache Typen zu schaffen, allerdings müssen diese auf einfachen, schon vordefinierten Typen bestehen und diese einschränken.

Beispiel in XSD:
<?xml version=”1.0” encoding=”UTF-8”?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
…
<xsd:simpleType name=“waehrung“>
   <xsd:restriction base=”xsd:string”>
            <!--Facette -->
   </xsd:restriction>
   </xsd:simpleType>
</xsd:schema>

 

In dem Falle haben wir einen einfachen Typ namens „waehrung“ geschaffen, welcher über xsd:restriction Beschränkungen enthält, allerdings basiert („base“) dieser Typ „waehrung“ auf den vordefinierten Typ „xsd:string“, wobei dann durch so genannte Facetten die Beschränkung erfolgt.

 

Komplexe Typen “complexType”:

Komplexe Datentypen erlauben in XML die Kindelemente eines Elementes zu beschreiben.

Beispiel:
<xsd:element name="Name" type=”name”>
   <xsd:complexType>
      <xsd:sequence>
         <xsd:element name="Vorname" type="xsd:string"/>
         <xsd:element name="Nachname" type="xsd:string"/>
        </xsd:sequence>
   </xsd:complexType>
</xsd:element>

Hiermit weise ich dem Element „Name“ den Typ „Name“ zu. Da es diesen Datentyp noch nicht gibt, muss er erst beschrieben werden, welche Elemente er enthält.

Das hier angegebene Beispiel bedeutet, dass das Element „Name“, 2 Kindelemente hat.

Einfacher Inhalt “simpleContent”:

Der „simpleContent“ definiert einen einfachen Inhalt, was bedeutet, dass er nur Text enthalten darf.

Komplexer Inhalt “complexContent”:

Der „complexContent“ definiert einen komplexen Inhalt, was bedeutet, dass er Text, Attribute und andere Elemente enthalten darf.

 

4.2.2.4 Definition des Inhaltes

 

4.2.2.4.1 Sequenz

Merkmale:

  • Elemente müssen der Reihe nach vorkommen.
  • Falls keine anderen Werte angegeben werden, können Elemente 0 oder mehrfach vorkommen.
Beispiel:
<xsd:element name="Anschrift" type=”anschrift”>
   <xsd:complexType name=”anschrift”>
      <xsd:sequence>
         <xsd:element name="wohnort" type="xsd:string"/>
         <xsd:element name="plz" type="xsd:int"/>
         <xsd:element name="strasse" type="xsd:string"/>
         <xsd:element name="nr" type="xsd:int"/>
         <xsd:element name="name" type="xsd:string"/>
        </xsd:sequence>
   </xsd:complexType>
</xsd:element>

 

4.2.2.4.2 Choice

Merkmale:

  • Aus einer Anzahl von Elementen darf, falls kein anderer Wert über Max/MinOccurs gesetzt, ein Element vorkommen. Ansonsten auch mehrere möglich.
  • Reihenfolge beliebig.
  • Durch das MaxOccurs ist es möglich zu sagen, dass Elemente mehrfach und die Reihenfolge beliebig ist
Beispiel:
<xsd:element name="Tier" type=”tier”>
   <xsd:complexType name=”tier”>
      <xsd:choice>
         <xsd:element name="Affe" type="xsd:string"/>
         <xsd:element name="Tiger" type="xsd:string "/>
         <xsd:element name="Leopard" type="xsd:string"/>
         <xsd:element name="Maus" type="xsd:string "/>
        </xsd:choice>
   </xsd:complexType>
</xsd:element>
4.2.2.4.3 All

Merkmale:

  • Jedes Element darf einmal vorkommen.
  • Reihenfolge spielt keine Rolle.
Beispiel:
<xsd:element name="Einkaufsliste" type=”einkaufsliste”>
   <xsd:complexType name=”einkaufsliste”>
      <xsd:all>
         <xsd:element name="Kaese" type="xsd:string"/>
         <xsd:element name="Milch" type="xsd:string "/>
         <xsd:element name="Butter" type="xsd:string"/>
         <xsd:element name="Wurst" type="xsd:string "/>
        </xsd:all>
   </xsd:complexType>
</xsd:element>

 

4.2.2.4.4 Group

Merkmale:

  • Gruppiert eine Reihe von Elementen oder Anweisungen.
Beispiel:
<xsd:complexType name="BestellungTyp">
  <xsd:sequence>
    <xsd:choice>
      <xsd:group ref="verschiedeneAdr"/>
      <xsd:element name="eineAdresse" type="DeAdresse"/>
    </xsd:choice>
    <xsd:element ref="Kommentar" minOccurs="0"/>
    <xsd:element name="Waren" type="WarenTyp"/>
  </xsd:sequence>
  <xsd:attribute name="bestelldatum" type="xsd:date"/>
</xsd:complexType>

<xsd:group name="verschiedeneAdr">
  <xsd:sequence>
    <xsd:element name="Lieferadresse" type="DeAdresse"/>
    <xsd:element name="Rechnungsadresse" type="DeAdresse"/>
  </xsd:sequence>
</xsd:group>

 

4.2.2.4.5 Any

Merkmale:

  • Erlaubt beliebigen Datentyp
4.2.2.4.6 Extensions

Extension bedeutet auf Deutsch Ableitung. Das Prinzip was dahinter steckt, ist bereits aus der Programmierung bekannt – Stichwort lautet Vererbung.

Ableitungen von Elementtypen sind dann interessant, wenn man manche Elemente spezialisieren möchte. Man spart sich dadurch eine Menge Tipparbeit und man kann einfach andere Kindelemente an das Elternelement dranhängen. Als Beispiel möchte ich hier die Einkaufsliste erweitern.

Beispiel:
<xsd:complexType name=”myEinkaufsliste”>
   <xsd:complexContent>
      <xsd:extension base=”einkaufsliste”>
         <xsd:all>
         <xsd:element name="Fertigesssen" type="xsd:string"/>
           </xsd:all>
      </xsd:extension>
   </xsd:complexContent>
</xsd:complexType>

 

4.2.2.4.7 Restrictions

Man kann auch einen neuen Elementtypen erzeugen, indem man einen bereits vorhandenen Elementtyp beschränkt. Dafür müssen alle Elemente aufgezählt werden und dabei kann man beliebig die Beschränkungen verteilen.

Als Beispiel möchte ich mein Anschriftsschema von oben verwenden.

Beispiel:
<xsd:complexType name=”singelAnschrift”>
   <xsd:restriction base=“anschrift“>
      <xsd:sequence>
         <xsd:element name="wohnort" type="xsd:string"/>
         <xsd:element name="plz" type="xsd:int"/>
         <xsd:element name="strasse" type="xsd:string"/>
         <xsd:element name="nr" type="xsd:int"/>
         <xsd:element name="name" type="xsd:string" minOccurs=”1” maxOccurs=”1”/>
        </xsd:sequence>
   </xsd:restriction>
</xsd:complexType>

Bei dem Beispiel muss immer ein Element “name” vorkommen.

Liste der Einschränkungen, auch Facetten genannten, durch welche man einfache Beschränkungen realisieren kann:

  • length, maxLength, minLength – Länge eines Strings
  • enumeration – Auswahl
  • pattern – Reguläre Ausdrücke
  • minExclusiv, maxExclusiv, minInclusiv, maxInclusiv – Wertebereicheinschränkung
  • totalDigits, fractionDigits – Einschränkung der Dezimalstelle (Gesamtzahl, Nachkommastelle)
  • whiteSpace – Behandlung von Tabs und Leerzeichen
Beispiel:
<xsd:simpleType name=”IQ”>
   <xsd:restriction base=“xsd:decimal“>
      <xsd:minInclusiv value=”80”/>
      <xsd:maxInclusiv value="180"/>
      <xsd:fractionDigits value=”3”/>
   </xsd:restriction>
</xsd:simpleType>

 

4.2.2.4.8 List

In einem XML Element können durch den Typ Liste mehrere “pseudo”-Elemente drin stehen. Die Elemente müssen allerdings alle vom selben Typ sein.

Beispiel:
<xsd:simpleType name="BundeslandListe">
    <xsd:list itemType="Bundesland"/>
</xsd:simpleType>

<xsd:simpleType name="SechsBundesländer">
    <xsd:restriction base="BundeslandListe">
    <xsd:length value="6"/>
    </xsd:restriction>
</xsd:simpleType>

Beispiel:
<sechsLänder>Sachsen       Baden-Württemberg   Rheinland-Pfalz
             Brandenburg   Niedersachsen       Hessen</sechsLänder>

 

4.2.2.4.9 Union

Die Union bietet in der XSD die Möglichkeit einem Element mehrere Typen zu geben, sodass man ähnlich zur Liste, mehrere „pseudo“ Elemente in einem Tag hat.

Syntax: <xsd:union memberTypes=“Typen“ />

Beispiel:
<xsd:simpleType name="Irgendwas">
   <xsd:union memberTypes=“xsd:int xsd:string“/>
</xsd:simpleType>

Beispiel:
<Irgendwas>12 Bla</Irgendwas>
<Irgendwas>12</Irgendwas>
<Irgendwas>12 Bla 12</Irgendwas>
<Irgendwas>Bla Bla</Irgendwas>

 

4.2.2.4.10 AnyAttribute

Erlaubt beliebige Attribute innerhalb von Elementen.

4.2.2.4.11 AttributeGroup

Gruppiert Attribute, sodass ein einfacher Zugriff auf diese möglich ist.

 

Guide: XML (XML Schema XSD – Teil 3)

4.2.2.5 Elemente für Schlüssel

In der XSD gibt ebenso wie in der DTD die Möglichkeit einmalige Schlüssel, ähnlich wie der Index in einer Datenbank, zu definieren.

In XSD gibt es fünf Arten, die hier kurz vorgestellt werden:

  • xsd:key
    • eindeutige Schlüsselwerte
  • xsd:field
    • gibt Gültigkeitsbereich an
  • xsd:unique
    • optional, muss aber eindeutig sein
  • xsd:refkey
    • Referenz auf den Schlüssel
  • xsd:selector
    • gibt Gültikeitsbereich mit XPath an

 

4.2.2.6 Modularisierung

Modularisierung in der XSD erlaubt, dass gewisse Teile immer wieder verwendet werden können und somit diese wesentlich besser nutzen kann. XSD kennt drei Arten, eine andere XSD zu importieren.

 

xsd:include

Typdefinitionen innerhalb eines Namensraumes, die auf mehrere Dateien verteilt sind, lassen sich mittels include zusammenfügen.

Beispiel:
<schema xmlns="http://www.w3.org/2001/XMLSchema"
         xmlns:pcTeile="http://www.example.com/pcTeile"
         targetNamespace="http://www.example.com/pcTeile">
   ...
   <include schemaLocation="http://www.example.com/schemata/harddisk.xsd">
   <include schemaLocation="http://www.example.com/schemata/ram.xsd">
   ...
 </schema>

 

xsd:import

Der import-Tag erlaubt es, Elemente aus anderen Namensräumen zu importieren, mit einem Präfix zu versehen und damit Schema-Bestandteile aus unterschiedlichen Namespaces wiederzuverwenden.
Annahme ist, dass es einen definierten Typ “superTyp” in “pcTeile” gibt.

Beispiel:
<schema xmlns="http://www.w3.org/2001/XMLSchema"
         xmlns:pcTeile="http://www.example.com/pcTeile"
         targetNamespace="http://www.example.com/firma">
   ...
   <import namespace="http://www.example.com/pcTeile"/>
   ...
     <...
       <xsd:attribute name="xyz" type="pcTeile:superTyp"/>
     .../>
   ...
 </schema>

xsd:redefine

Gleiches Beispiel wie gerade. Annahme es gäbe einen complexType “Hersteller” im Schema “harddisk.xsd”".

Beispiel:
<schema xmlns="http://www.w3.org/2001/XMLSchema"
         xmlns:pcTeile="http://www.example.com/pcTeile"
         targetNamespace="http://www.example.com/pcTeile">
   ...
   <redefine schemaLocation="http://www.example.com/schemata/harddisk.xsd">
     <complexType name="Hersteller">
       <complexContent>
         <restriction base="pcTeile:Hersteller">
           <xsd:sequence>
             <xsd:element name="hersteller" type="xsd:string" minOccurs="10" maxOccurs="10"/>
           </xsd:sequence>
         </restriction >
       </complexContent>
     </complexType>
   <redefine/>
   ...
   <include schemaLocation="http://www.example.com/schemata/ram.xsd">
   ...
 </schema>

 

4.2.2.7 Dokumentation

In der XSD gibt es die Möglichkeit zu den einzelnen Elementen oder auch generell zur XSD eine Art Kommentare zu erstellen. Diese werden hier kurz aufgelistet.

  • xsd:annotation
    • sind Anmerkungen
  • xsd:documentation
    • dient der Dokumentation
  • xsd:appinfo
    • gibt Information über Applikation

 

4.2.2.8 Facetten

Beim Thema der Beschränkung ist schon kurz der Begriff der Facetten gefallen. In der XSD gibt mehrere Arten der Beschränkung.

  • xsd:length
    • Gibt die genaue Länge eines Strings an
  • xsd:maxLength
    • Maximale Länges eines Strings
  • xsd:minLength
    • Minimale Länge eines Strings
  • xsd:pattern
    • Reguläre Ausdrücke
  • xsd:maxExclusive
    • Setzt eine obere Schranke für numerische Werte. Werte müssen kleiner sein.
  • xsd:minExclusive
    • Setzt eine untere Schranke für numerische Werte. Werte müssen größer sein.
  • xsd:minInclusive
    • Setzt eine untere Schranke für numerische Werte. Werte müssen größer oder gleich groß sein.
  • xsd:maxInclusive
    • Setzt eine obere Schranke für numerische Werte. Werte müssen kleiner oder gleich groß sein.
  • xsd:enumeration
    • Definiert eine Liste möglicher Werte
  • xsd:whiteSpace
    • Definiert wie white Spaces behandelt werden sollen
  • xsd:totalDigits
    • Gibt die exakte Anzahl der Ziffern an.
  • xsd:fractionDigits
    • Definiert die max. Erlaubten Dezimalstellen

 

4.2.3 Datentypen

Komplexe Datentypen haben wir ja schon kennen gelernt, aber die Frage, welche Datentypen direkt von der XSD unterstützt werden, ist noch nicht ganz geklärt.

XML Schema stellt einige einfache Datentypen bereit, welche auch schon aus anderen Programmiersprachen bekannt sind.

Hier ein kleine Auswahl über die wichtigsten Datentypen:

  • string – „Test“
  • decimal – 23.3
  • boolean – true/false
  • data – Jahr/Monat/Tag (2006-12-05)
  • time – Stunde/Minute/Sekunde/Hundertstel (21:03:43.03)
  • datetime – Jahr/Monat/Tag Stunde/Minute/Sekunde (2006-02-23T23:23:23) „T“=Trennzeichen
  • float – -23.6
  • anyURI – eine URI (http://www.heise.de)
  • gYearMonth – Jahr/Monat (2005-12)
  • gMonthDay – Monat/Tag (12-05)
  • gYear – Jahr (2005)
  • gMonth – Monat (12)
  • gDay – Tag (12)
  • hexBinary – Hexadezimaler Wert (12EA)
  • language – Sprachbezeichnung (de-DE)
  • QName – Qualifizierter Name innerhalb eines Namensraumes
  • ID – Identifikationsattribut innerhalb eines XML
  • IDREF – Referenz auf ID
  • Integer – 12
  • positivInteger – 12
  • negativInteger – -12
  • long – -9223372036854775808 bis 9223372036854775808
  • int – -2147483648 bis 2147483647 32-Bit Integer
  • byte – -127 bis 128 8-Bit Integer

 

Beispiel:
<?xml version="1.0" encoding="ISO-8859-1"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2000/10/XMLSchema" elementFormDefault="qualified">
   <xsd:element name="p" type="xsd:string"/>
</xsd:schema>

 

4.2.4 Namensräume in der XSD

Namensräume, welche in dem XML Dokument angeben werden, finden sich auch in der XSD wieder.

Der vollständige Namespace wird im Attribut „targetNamespace“ festgehalten.

Beispiel:
<schema targetNamespace="http://www.example.com/BEST"/>
…
</schema>

 

4.3 Andere Schemaarten

 

Die DTD und die XSD sind direkt vom W3C, allerdings gibt es noch zwei andere bekannte Schemasprachen, welche auch auf XML aufbauen.

  • Relax NG
  • WSDL

Guide: XML (XML Schema XSD – Teil 1)

4.2 XML Schema

 

Das XML – Schema ist eine Empfehlung vom W3C, welche dem Prinzip der XML-DTD ähnelt – es definiert die XML Baumstruktur. Im Gegensatz zur herkömmlichen XML-DTD ist die XSD komplexer und bietet mehr Datentypen zur Auswahl. Zudem ist die XSD komplett im XML Format beschrieben.

Anmerkungen zu diesem Abschnitt: Es gibt immer mehrere Wege ein Element zu beschreiben. Scheinbar herrscht unter den XSD Liebhabern noch keine Einigkeit zu bestehen, welche Form man nun genau wählt. Vom Prinzip her unterscheiden sich die Formen aber nur in kleinen Teilen.

 

4.2.1 Einbindung

Eingebunden wird das Schemat im Rootelement des XMLs.

Beispiel:
<?xml version=”1.0” standalone=”no”?>
<ROOT xmlns:xsi="http://www.w3.org/2000/10/XMLSchema-instance" xsi:noNamespaceSchemaLocation="SCHEMADATEINAME.xsd"
 >
</ROOT>

Direkt hinter dem Rootelement wird ein XML Namespace mit dem Präfix xsi gebildet, welche direkt vom W3C kommt. Dannach erfolgt die Einbindung unserer XSD.

4.2.2 Schemaelemente

Hier ein kurzer Überblick, was im Schema enthalten sein kann.

4.2.2.1 Wurzelelemente

Das Wurzelelement in der XSD ist entweder das <xsd:schema>, das <xs:schema> oder nur <schema> – je nach eingebundenen Namespace.

Beispiel in XSD:
<?xml version=”1.0” encoding=”UTF-8”?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
.
.
.
</xsd:schema>

Da die XSD auch nur ein XML Dokument ist, wird in der ersten Zeile die XML Version sowie die Kodierung festgelegt.

Dannach erfolgt ein Tag „schema“ mit einem Präfix, welcher standardmäßig entweder xs oder xsd ist.

Dies wird durch den Namensraum, welcher auch wieder vom W3C kommt, festgelegt.

Das xs oder xsd kann auch weggelassen werden, wenn ich anstatt „xmlns:xsd=…“ direkt „xmlns=…“ schreibe. Hierbei spricht man, wie schon einmal erwähnt, vom sogenannten default Namespace.

Da meistens mit dem XSD Präfix gearbeitet wird, werde ich es in den folgenden Teilen ebenfalls verwenden.

 

4.2.2.2 Deklarationselemente

 

Elemente:

Ähnlich leicht wie in der DTD können in der XSD Elemente erstellt werden.

Beispiel in XSD (Datei: element.xsd):
<?xml version=”1.0” encoding=”UTF-8”?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name=“Bauunternehmen“ />
</xsd:schema>

Beispiel in XML:
<?xml version=”1.0” encoding=”UTF-8”?>
<Bauunternehmen xmlns:xsi="http://www.w3.org/2000/10/XMLSchema-instance" xsi:noNamespaceSchemaLocation="element.xsd“>
.
.
.
</Bauunternehmen>

Attribute:

Ähnlich leicht wie in der DTD können in der XSD Elemente erstellt werden.

Da es nicht unbedingt ratsam ist, direkt im Root Element Attribute festzulegen, ist in diesem Beispiel „Bauunternehmen“ ein Element irgendwo in dem XML Dokument.

Beispiel in XSD (Datei: attribut.xsd):
<?xml version=”1.0” encoding=”UTF-8”?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <xsd:element name=“Rootelement“ type=“wurzel“ />
   <xsd:element name=“Bauunternehmen“>
   <xsd:complexType>
      <xsd:complexContent>
         <xsd:extension base=”xsd:string”>
               <xsd:attribute name=“Regionalcode“ type=“xsd:string“ />
         </xsd:extension>
      </xsd:complexContent>
   </xsd:complexType>
   </xsd:element>
</xsd:schema>

Beispiel in XML:
<?xml version=”1.0” encoding=”UTF-8”?>
<Rootelement xmlns:xsi="http://www.w3.org/2000/10/XMLSchema-instance" xsi:noNamespaceSchemaLocation="element.xsd“>
   <Bauunternehmen Regionalcode=“asA3555“>…</Bauunternehmen>
</Rootelement>

Attribute haben, anders als Elemente, nur einfache Typen. Nur komplexe Elemente können Attribute enthalten.

Attribute werden, wenn nichts anderes angegeben ist, nur optional verlangt.

Liste der Zustände eines Attributs:

  • use
    • optional
      • Attribut muss nicht vorhanden sein
    • required
      • Attribut muss vorhanden sein
    • prohibited
      • Attribut ist verboten
  • fixed
      • definiert festen Wert
  • “…”
      • Enthält beliebigen Standardwert (Default)
      • Wenn nichts anderes angegeben, wird dieses genommen

Achtung: Fixed und Default dürfen nicht beide definiert werden

Syntax

<xsd:attribute name=“name“ type=“type“ use=“use“ default=“default“/fixed=“fixed“ />

Beispiel:
<xsd:attribute name=”gender” use=“required“ default=“m“ type=“xsd:string“ />

Guide: XML (DocumentType Definitions DTDs)

[Aufbauend auf den vorherigen Guide]

4. Documenttype Definitions

Die Documenttype Definitionen beschreiben die Struktur von XML- und SGML Dokumenten. Es bestimmt die Struktur von Dokumenten. In einer DTD werden Attribute, Elemente usw. definiert.

Da die DTD ist ein Bestandteil der XML Spezifikation, was allerdings später von vielen kritisiert wurde, da der DTD Syntax kein XML Syntax ist. Für XML Dokumente wurde ein eigene Spezifikation, das XML Schema (oder in kurz: XSD) geschaffen.

Diese XSD verfolgt dasselbe Ziel wie die DTD, ist jedoch etwas komplexer und ist komplett im XML Syntax verfasst.

Da die DTD jedoch trotzdem noch eine Rolle spielt, wird sie hier trotzdem noch behandelt.
 

4.1 „Documenttyp-Definition“ (DTD) und Instanzen

Die wenigsten die HTML Dokumente verfassen, werden sich mit der DTD beschäftigt haben, da die DTD für HTML fest in den Händen des W3Cs liegt, allerdings gibt es nun mit XML die Möglichkeit eigene Elemente zu schaffen, welche z.B. aber nur bestimmte Attribute bekommen dürfen.

Einige Beispiele entstammen der XHTML DTD vom W3C, welche sich hier einsehbar ist:

http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd
 

4.1.1 Elementtypen

Die wichtigsten Komponenten einer DTD sind die Element-Deklarationen.

Die Elementtypen weisen einem Element und sein möglicher Inhalt definiert.

Folgende Elementtypen gibt es in einer DTD:

  • Empty – kein Inhalt
  • Any – für beliebigen Inhalt
  • , – Reihenfolge
  • | – Alternative
  • Runde Klammern zum Gruppieren
  • Stern für keinmal oder mehrmals
  • Plus für einmal oder mehrmals
  • Fragezeichen für einmal oder keinmal
  • Wird weder Stern, Plus oder Fragezeichen verwendet, muss das Element min. einmal vorkommen
  • Texte, welche den Elementen angehören, werden als PCDATA (Parsed Character Data) deklariert.

Syntax: <!ELEMENT elementname elementtyp>

Beispiel:
<!ELEMENT img EMPTY>
<!ELEMENT table
     (caption?, (col*|colgroup*), thead?, tfoot?, (tbody+|tr+))>

4.1.2 Entities

Wie bereits schon vorhin kurz erwähnt, dienen Entities der Wiederverwendbarkeit. Dabei wird eine bestimmte Zeichenkette festgelegt, welche beim Aufrufen dieser durch eine vorher festgelegte andere Zeichenkette oder ein anderes Dokument ersetzt wird.

4.1.2.1 Interne Entities

Ein internes Entity besteht nur aus dem Namen und der Zeichenkette, welche später eingesetzt werden soll.

Syntax: <!ENTITY namezeichenkette“>

Aufgerufen wird dieses Entity mit einem & und dem namen sowie einem Semikolon.

Syntax: &name;

Beispiel: 

<!ENTITY dtag „Deutsche Telekom AG“>

Anwenden würden wir dieses Entity mit „&dtag;“

Die Zeichenkette kann im Prinzip alles enthalten: Normale Texte, neue Entitys oder XML.

Beispiel: 

<!ENTITY dtag „Deutsche Telekom AG“> 

<!ENTITY tt_link „<a href=’training.telekom.de’>Telekom Training</a>” > 

<!ENTITY division „&dtag; - Telekom Training“>

4.1.2.2 Externe Entities

Externe Entities verweisen auf den Inhalt von den angegebenen Dateien. Nach dem Namen wird noch notiert, ob dieses Entity öffentlich („PUBLIC“), d.h. es wird nicht nur auf der Website sondern im ganzen Intranet oder ist vom W3C standardisiert oder es ist nur systemweit („SYSTEM“). Allerdings spielen diese beiden Sachen keine große Rolle.

Syntax: <!ENTITY name SYSTEM/PUBLIC „datei“>

Beispiel: 

<!ENTITY kapitel1 SYSTEM „kapitel1.xml“>

Bei Externen Entities kann man zusätzlich angeben, wenn es um ein nicht analysiertes Entity handelt, d.h. der Inhalt besteht aus beliebigen Daten. In diesem Fall muss eine Notation angegeben werden:

Beispiel: 

<!ENTITY BMP_Bildchen SYSTEM „bild.bmp“ NDATA bmp>

4.1.3 Parameter-Entities

Normale Entities werden verwendet, wenn man auf der Website bestimmte Abkürzungen nutzen will. Da sich auch in einer DTD häufig Deklarationen doppeln, wird hier mit sog. Parameter-Entities gearbeitet. Dadurch lassen sich auch externe Daten in die DTD einbinden.

Syntax: <!ENTITY % namezeichenkette“>

Beispiel: 

<!ENTITY % headlines „H1|H2|H3|H4|H5|H6|H7“>

4.1.4 Attribute

Elemente können bestimmte Attribute enthalten. Welches Element, welches Attribut enthält wird in der DTD festgehalten.

4.1.4.1 Attributtypen

  • CDATA – steht für beliebigen Inhalt
    • PCDATA und CDATA sind vom Prinzip her gleich
    • In ihnen werden beliebige Texte gespeichert
    • Unterschied liegt daran, dass PCDATA vom Parser durchsucht wird und kann zum Beispiel Entities oder XML Daten parsen („Parsed Character Data“).
    • In CDATA werden keine Markupzeichen, wie z.B. spitze Klammern erkannt.
Beispiel in der DTD: 

<!ATTLIST IrgendEinElement 

Sprache CDATA 

> 

Beispiel in der XML Datei: 

<IrgendEinElement Sprache=“deutsch123“>Dies hier ist ein Text.</IrgendEinElement>
 
  • ID
    • steht für einen eindeutigen Bezeichner
    • darf aus Buchstaben und Zahlen und Kombinationen dessen bestehen
Beispiel in DTD: 

<!ATTLIST IrgendEinElement 

Sprache_id ID 

>Beispiel in der XML Datei: 

<IrgendEinElement Sprache_id=“123“>Dies hier ist ein Text.</IrgendEinElement>
  • IDREF
    • steht für eine Referenz auf einen Bezeichner
    • dient dazu, dass eine ID nicht zweimal vergeben wird, wenn ein Element die augenscheinliche selbe ID vergeben will
Beispiel in DTD: 

<!ATTLIST Produkt 

Hersteller_id IDREF 

>Beispiel in der XML Datei: 

<Produkt Herstellter_id=“123“>Hammer</Produkt>
 
  • NMTOKEN
    • ähnelt dem CDATA, hat allerdings ein paar Einschränkungen
    • steht für Name Token
Beispiel in DTD: 

<!ATTLIST IrgendEinElement 

Sprache NMTOKEN 

>Beispiel in der XML Datei: 

< IrgendEinElement Sprache=“de DE“>Testtext</ IrgendEinElement >
 
  • Aufzählungen
    • Nur angegebene Werte dürfen im Attribut vorkommen
Beispiel in der DTD: 

<!ATTLIST IrgendEinElement 

Sprache (deutsch|englisch|spanisch) 

>Beispiel in der XML Datei: 

<IrgendEinElement Sprache=“deutsch“>Dies hier ist ein Text.</IrgendEinElement> 

<IrgendEinElement Sprache=“englisch“>Nice work!</IrgendEinElement>

4.1.4.2 Attributvorgaben

Mittels Vorgaben kann man Attribute vorbelegen oder sagen, ob das Attribut zwingend vorhanden sein muss oder nicht.

  • #REQUIRED – Attribut muss angegeben werden
  • #IMPLIED – Attribut kann angegeben werden
  • #FIXED „…“ – Attribut hat immer einen Standardwert
  • „…“ – Attribut hat bei Nichtzuweisung diesen Standardwert

4.1.4.3 Attributlisten

In den Listen erfolgt die Zuordnung.

Syntax: <!ATTLIST elementname

Name typ Vorgabewert

Beispiel: 

<!ATTLIST wohnort 

plz   CDATA #REQUIRED 

strasse    CDATA #REQUIRED 

hausnr   CDATA #IMPLIED 

land   CDATA #FIXED „germany“ 

>

4.1.5. Einbindung der DTD in XML

4.1.5.1 Externe Verweise

Beispiel: 

<?xml version=”1.0” standalone=”yes”?> 

<!DOCTYPE lala SYSTEM “lala.dtd”> 

<lala>Dumdidum</lala>

4.1.5.2 Interne Verweise

Beispiel: 

<?xml version=”1.0” standalone=”yes”?> 

<!DOCTYPE lala [ <!ELEMENT (#PCDATA) >] > 

<lala>Dumdidum</lala>

Der Name muss dem des Wurzelelementes entsprechen!

Silverlight Streaming auf Live.com & XML Dokumentation

Zuerst zum Alten: Ich habe den zweiten Teil meiner XML Dokumentation online gestellt. Darin wird das “Basiswissen” behandelt. Ich hoffe, ich werde mich irgendwann dazu aufraffen und auch die restlichen 55 Seiten hier posten ;)

Nun zu Silverlight: Microsoft hat seit kurzem sein Hosting Service für Silverlight Anwendungen online gestellt: silverlight.live.com

Der Dienst ist kostenlos und man kann bis zu 4 GB hochladen – gedacht soll es wohl für Videos sein, welche max. 10min lang sein dürfen. Ein Blick schadet aber nicht.
Eine gute Anleitung hab ich auf diesem Blog gefunden.

Guide: XML (Basiswissen)

XML – Thema: Basiswissen

Was bedeutet Basiswissen bei XML? Gute Frage. Daher ist meine Schulung sowieso nur in 2 große Hauptteile gegliedert (Einführung und Basiswissen). Mag etwas sinnlos sein, aber egal.

Heute geht es darum: Was ist eigentlich XML? Wie definiert man es und was gibt es für Fachtermini zu dem Thema?

Da dieser Teil “Basiswissen” enorm groß ist – vor uns liegen noch Themen wie XML DTDs, XSD, XPath & XSLT. Vielleicht – aber die Chancen sind äußerst gering. Mach ich einen 3 großen Teil: XML in .NET. Ist ein sehr spannendes Thema, welches sich auch lohnen würde aufzuschreiben. Lassen wir uns überraschen.

II Basiswissen

1. Interpretation von XML
1.1 Clientseitige Interpretation
Beim Clientseitigen XML Interpretieren, bekommt der Client das XML Dokument direkt vom Server geschickt. Nun hat der Client verschiedene Möglichkeiten das Dokument zu formatieren um es in die gewünschte vorm zu bringen, z.B. HTML.

Allerdings ist es heute, im Jahre 2006, noch nicht ganz unproblematisch, ein XML Dokument durch den Browser parsen zu lassen um am Ende die gewünschte Website zu sehen.

Später werden noch einige Beispiele dazu folgen.

1.2 Serverseitige Interpretation
Durch „Content Negotiaten“ spricht sich der Server mit dem Client ab, ob dieser XML akzeptiert oder nicht. Wenn dies der Fall ist, wird das XML Dokument Clientseitig durch den Browser geparst. Falls der Client dies aber nicht unterstützt, liefert der Server in den meisten Fällen ein HTML Dokument direkt an den Client, da dies alle Browser beherrschen.

Diese Variante ist in der heutigen Zeit, wohl die am meisten verwendete, da man noch nicht genau sagen kann, wie ein Browser XML parst.

Beispiele dazu werden ebenso später folgen.

2. Grundlegendes für das Verständnis
2.1 XML Deklaration

Beispiel:

<?xml version="1.0" encoding= "EUC-JP" standalone = "yes"?>

Hinter dem ?xml werden so genannte Pseudo-Attribute erwartet. Die XML Spezifikation enthält momentan 3 solcher Pseudo-Attribute:

- Version:
    – Sollte immer Angegeben sein.
    – Enthält XML-Spezifikationsversion
    – 1.0 oder 1.1 sind momentan sinnvolle Werte
- Encoding:
    – Bestimmt Kodierung des XML
    – UTF 8 ist Standard
    - Auch muss das Attribut vom Parser angenommen werden.
- Standalone:
    – Selten verwendet
    – Yes oder No sind die einzig gültigen Werte
    – Yes wird verwendet, wenn Parser externe DTD (oder XSD) ignoriert werden soll

2.2 Fachtermini
Da in den folgenden Kapiteln immer wieder bestimmte „Fachwörter“ auftauchen, hier mal eine kurze Erklärung.

Wohlgeformtheit: Ein XML Dokument, welche alle Regeln der Spezifikation einhält ist wohlgeformt („well formed“).

Gültigkeit: Für den Datenaustausch über XML ist es wichtig, Regeln für das Erstellen von XML Dokumenten zu erstellen. Regeln stehen entweder in der DTD oder in einer XSD. Wenn das XML Dokument diese Regeln einhält, ist es gültig („valid“).

2.2.1 Parser
Parser sind Programme oder Programmteile, welche das XML Dokument auslesen, interpretieren. Kontrolliert der Parser auch die Gültigkeit, nennt man ihn „validierender Parser“.

Momentan gibt es 2 große „Parserarten“.

Die erste Parserart hat sich zum quasi Standard durchgesetzt. Genannt wird diese Art „SAX“, was voll ausgesprochen Simple API for XML heisst.
SAX ließt XML Dokument über sequentiellen Datenstrom und ruft im Standard definierte Ereignisse vorgegebene Rückruffunktionen auf. Dadurch ist SAX zustandslos und erlaubt keinen freien Zugriff auf alle Inhalte. Das ist insbesondere für große XML Dateien praktisch.

Die zweite Art nennt sich DOM, was auch schon aus z.B. Javascript bekannt sein dürfte. DOM ist ein W3C Standard, welcher voll ausgesprochen Document Object Model heisst. DOM liesst zuerst das komplette XML Dokument ein und bildet den Strukturbaum intern ab. Vorteil davon ist, dass ich auf jedes Element Einfluss nehmen kann und dadurch freien Zugriff auf alle Teile meines XMLs habe und jederzeit verändern kann.

Beide Parserarten haben freie Schnittstellen, sodass bereits für beide Arten in fast allen gängigen Programmiersprachen Zugriffsmöglichkeiten bestehen.

2.2.2 Delimitierung
In einigen Quellen ist von Delimitierung die Rede, was eigentlich recht schnell erklärt ist. Die Delimitierung ist die Abgrenzung zwischen den Tags und den Inhalten dessen, sprich die „<“ und „>“ Klammer.

2.2.3 Tags und Elemente
Tags repräsentieren meistens Elemente, allerdings muss man bei der Wahl eines Tags bestimmte Regeln einhalten.

Der Tag muss mit Buchstaben (a-z, A-Z) oder mit Unterstrich (_) anfangen. Zahlen sind nicht erlaubt.
Nach der Regel darf nach dem ersten Zeichen wieder Buchstaben (a-z, A-Z), Unterstrich (_), Zahlen (0-9) oder bestimmte Interpunktionen (.,,;) verwenden.
Nicht erlaubt sind Leerzeichen.
Wie bereits erwähnt, sind Elemente und Tags casesensitive.

Jedes Element beginnt mit <tagName> und endet mit </tagName> .

Beispiel aus XHTML:

<p>Das ist toll.</p>

Ausnahmen werden als Empty-Element-Tag bezeichnet und sehen so aus:

Beispiel aus XHTML:

<img src=“bild.jpg“ alt=“Bild“ />

Reservierte Zeichen:

In XML sind 4 Zeichen reserviert. Diese vier Zeichen sind:
„<“, „>“, das Apostroph und die Anführungszeichen. Für diese Zeichen gibt es, ähnlich wie in HTML die Umlaute, vordefinierte Entities:

< = <
> = >
Apostroph = &apos;
Anführungszeichen = ”

2.2.4 Tags und Elemente
Wie in fast jeder Sprache, gibt es auch in XML die Möglichkeit Kommentare zu setzen:

<!– Das ist ein gar lustiger Kommentar. –>

2.2.5 Attribute

XML – Attribute werden direkt in den Elementtag geschrieben, welche Metainformationen beinhalten.

Attributwerte werden in „“ geschrieben.

Nun muss man allerdings drauf achte, wann man ein Attribute einem Tag zuordnet oder ob man direkt ein neues Element unterm dem Element zuordnet.

Um zu verdeutlichen was ich meine, hier kurze Beispiele:

Beispiel mit Informationen in den Attributen:

<person id=“01231233328654“ lastlogin=“05.04.06“>
     <vorname>Ben</vorname>
     <nachname>James</nachname>
     <wohnort>New York</wohnort>
</person>

Beispiel mit Informationen als neue Elemente:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<person>
    <lastlogin>05.04.06</lastlogin>
    <id>01231233328654</id>
    <vorname>Ben</vorname>
    <nachname>James</nachname>
    <wohnort>New York</wohnort>
</person>

Es gibt dazu keine allgemeingültige Regel, wann man was einsetzt, da es ganz vom Verwendungszweck abhängt. Man sollte allerdings den Sinn des XMLs auch ohne die Attribute verstehen, da dies nur extra Informationen darstellen sollen.Im kommenden Kapitel werden uns die Attribute auch in der DTD und in der XSD begegnen.

2.2.6 URI & URL
In XML reden wir meistens von der URI („Uniform Ressource Identifier“) gesprochen, hingegen ist den meisten nur die URL („Uniform Ressource Locator“).

Die URL ist eine Teilmenge von der URI, allerdings kann man beide nicht einfach auseinanderhalten.

„http://www.test.de“ könnte eine URL oder URI sein.

Unterschied besteht in dem Sinn. Die URL bezieht sich mehr auf den Speicherort des Dokumentes („… Locator“) und ist in der Regel eine Internetadresse.

Die URI identifiziert die Ressource und ist eine allgemeine Architektur zur Lokalisierung von Dokumenten. Die URI ist nicht auf Ressourcen im Internet beschränkt.

Wenn wir heute in XML von der URI sprechen, ist es meistens die URL.

3. Namensräume

Insbesondere in größeren Projekten, wird es früher oder später Namensdopplungen geben, wo sie den Sinn entstellen. Als Beispiel haben verwenden wir in einer XML Datei folgendes:

Beispiel:

<!--Adresse 1 -->
<adresse>
    <strasse>Blabla</strasse>
    <hausnummer>42</hausnummer>
    <plz>15023</plz>
    <ort>Hinterblubdorf</ort>
</adresse> 
<!--Adresse 2 -->
<rechner>
    <domain>bla.de</domain>
    <name>namensblabla</name>
    <adresse>127.0.0.1</adresse>
</rechner>

Wie sie hier sehen, wir das Element “adresse” 2 mal gebraucht und beides mal in einem anderen Zusammenhang. Will man unterschiedlich gemeinte Elemente in einem Dokument benutzen, was ja bei großen Projekten durchaus vorstellbar ist, braucht man Namensräume.In der XML sind Namensräume an URIs gebunden. Um einen Namespace zu definieren wird „xmlns“, der Präfix und die zugehörige URI angegeben. Der Präfix „xml“ ist reserviert und kann daher nicht neu definiert werden.

Beispiel:

<x xmlns:test='http://test.org/schema'>
    <!-- Das "test"-Präfix wird für das Element "x" und Inhalt an http://test.org/schema gebunden. -->
</x> 

Der QName ist eine Zusammensetzung aus dem Präfix und dem lokalen Namen. 

„Default Namespaces“ können verwendet werden, wenn ein Namensraum häufiger als andere verwendet wird. Allerdings kommen damit einige Parser und Browser nicht vollständig zurecht.

Beispiel:

<x xmlns:test='http://test.org/schema'>
    <test:y>Dies hier ist mit Namespacepräfix.</test:y>
</x>
<default xmlns='http://test.org/schema'>
    <test>Hier wird der default Namespace verwendet, welcher festgelegt wurde.</test>
</default>

Damit unser oberes Beispiel funktionieren kann, müssen wir nun ein paar kleine Veränderungen durchführen. 

Beispiel:

<!--Adresse 1 -->
<adresse xmlns:adresse=“http://www.test.de/schema“>
    <adresse:strasse>Blabla</adresse:strasse>
    <adresse:hausnummer>42</adresse:hausnummer>
    <adresse:plz>15023</adresse:plz>
    <adresse:ort>Hinterblubdorf</adresse:ort>
</adresse>
<!--Adresse 2 -->
<rechner xmlns:rechner=“http://www.test.de/schema“>
    <rechner:domain>bla.de</rechner:domain>
    <rechner:name>namensblabla</rechner:name>
    <rechner:adresse>127.0.0.1</rechner:adresse>
</rechner>
 

Der Präfix ist im Prinzip nichts anderes als eine Erweiterung der URI.

Statt rechner=“http://www.test.de/schema“ könnte man auch „http://www.test.de/schema/rechner“ sagen.

[Fortsetzung: XML (DocumentType Definitions DTDs)]

Aus der Schublade…

Ich habe (mal wieder) eine neue Artikelserie angefangen – diesmal ists aber garnicht so neu. Es geht ganz allgemein um das Thema XML, DTD, XSD und am Ende XSLT. Da heute so gut wie alles mit XML gemacht wird, ist es eigentlich auch nicht verkehrt. OpenXML, XAML & die Web.config sind nur Beispiele von XML Anwendungfällen.
Das Dokument umfasst insgesamt 60 Seiten, allerdings sind manche nicht mehr aktuell oder überarbeitungswürdig. Von daher habe ich heute erstmal den ersten Teil online gestellt:

Guide – XML Einführung

Erstellt wurde es vor ca. einem Jahr von mir wegen meiner Ausbildung. Ich hoffe ich kann mal das gesamte Werk online stellen.

Grüße

Guide: XML (Einführung)

XML – Thema: Einführung

XML – Schulung: Warum?
Warum schreib ich in einem Blog eigentlich eine Schulung für XML? Ist das nicht sinnlos oder gar Zeitverschwendung? Definitiv ja. Hab ich langeweile? Auch… jedenfalls teilweise. Da ich momentan (wie schon viele vor mir) ein Bibliothekprogramm in C# schreibe und auch XML als Datenspeicher verwenden will. Jetzt verflucht mich, aber irgendwie hat es mir XML angetan. Zudem hatte ich die Aufgabe im Rahmen meiner Ausbildung sowieso eine XML Schulung zu verfassen. Da die Dokumentation hier rum liegt, hab ich mir gedacht, pass ich sie doch mal in den Blog rein. Leider hab ich manche “Zitate” etwas unsauber gemacht, daher werd ich wohl jetzt alles nochmal schreiben. Aber ich hab ja Zeit. Falls ihr doch noch Sachen findet, die ich von anderen Seiten “geklaut” habe, dann seid mir bitte nicht gar zu sehr böse. Danke. Von woher ich die Quellen habe, werde ich entweder direkt im Text oder im Anschluss machen.

Quellen

Bücher
- Marco Skulschus, Marcus Wiederstein:
XSLT und XPath für HTML, Text und XML.
- Henning Behme, Stefan Minter:
XML in der Praxis, Professionelles Web-Publishing mit der Extensible Markup Language
- Horst-Dieter Radke:
PC Spicker XML

Internet:
www.wikipedia.de
http://www.obqo.de/w3c-trans/xpath-de-20020226
http://www.edition-w3c.de/

… weitere Quellen könnten noch folgen.

I Einführung

1. Was ist XML?

XML ist das Akronym für “Extensible Markup Language”. Zu deutsch bedeutet das ungefähr “erweitere Auszeichnungssprache”.

XML ist heute ein Standard für die Erstellung von maschinen- und menschenlesbaren Dokumenten. Dies alles wird in Form einer Baumstruktur dargestellt. Der Standard selbst wird vom W3C definiert und ständig erweitert.

XML ist eine Teilmenge von SGML, welches beides Metasprachen sind.

Beispiel:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<addressbuch>
     <addresse>
          <vorname>Ben</vorname>
          <nachname>James</nachname>
          <wohnort>New York</wohnort>
     </addresse >
     <addresse>
          <vorname>Hans</vorname>
          <nachname>Herrman</nachname>
          <wohnort>Dortmund</wohnort>
     </addresse>
</addressbuch >
2. Sinn von XML

In der heutigen Zeit nimmt die Vernetzung unserer Welt immer mehr zu. Daten werden gesammelt, zusammengefasst und angerufen. Würde jedes Unternehmen eigene Standards einführen, was teilweise so ist, würde dieser Datenaustausch wesentlich gehemmt.Durch den relativ einfachen Aufbau von XML, können Daten in dieser Form überall gelesen, verarbeitet und selbst die unterschiedlichsten Systeme können diese verarbeiten.3. Das Web und XML

3.1 Ersetzt XML HTML
Auf die Frage, ob HTML durch XML ersetzt wird, kann man ganz klar mit einem „nein“ beantworten. HTML hat allerdings Grenzen was der Vorrat an Elementtypen und zudem drohte der „Standard“ durch verschiedene Konzerne (Microsoft oder Netscape) auseinander zu brechen. Genau an dieser Stelle tritt nun XML in den Vordergrund. Durch XML kann man beliebige Daten speichern, welche dann z.B. wieder durch (X)HTML dargestellt werden. Näheres dazu wird zu einem späteren Zeitpunkt erklärt. Der große Vorteil von XML ist, dass ich durch Stylesheets im Prinzip unendlich viele Web Dokumente generieren lassen kann.Heute gibt es kaum noch Anwendungen die ohne XML arbeiten. Ähnlich wie HTML lassen sich auch XML-Daten „on the fly“ aus Datenbankbeständen erzeugen. Allerdings eignet sich XML besser für die Speicherung von Daten. Insbesondere in objektorientierten Systemen kann man durch den hierarchischen Aufbau wesentlich einfacher objektorientierte Datenbanksysteme abbilden.Der Traum von vielen die XML propagieren ist, dass mit XML ein einheitliches (universelles) Datenformat zu schaffen, was sowohl von Menschen als auch von Maschinen gelesen und verstanden werden kann.

3.2 Unterschie zwischen XML und HTML
XML ist im Gegensatz zu HTML casesensitiv. Dies bedeutet, dass in XML , <auto> oder <AUTO> gar <aUtO> 3 völlig verschiedene Elemente sind.
In HTML spielt es keine große Rolle ob man nun und dies dann mit schließt.
Zudem hat, wie bereits weiter oben erwähnt, HTML einen begrenzten Satz an Elementen.

Der letzte relativ große Unterschied, vom Sinn eines XMLs mal abzusehen, ist, dass Attribute in XML in Anführungszeichen gesetzt werden müssen. In HTML ist dies nicht unbedingt nötig.

4. Zusammenhänge zwischen SGML, XML, HTML, CSS, XSL…

Es gibt zwei Arten von Sprachen, die Auszeichnungssprachen, welche die Daten speichern und die Formatierungssprachen, welche die Formatierung dieser Übernehmen.
Hier sei noch mal der Unterschied zwischen XML und HTML zu beachten: HTML ist eine pure Auszeichnungssprache. XML ist eine Metasprache, was bedeutet dass es, genau wie SGML, eine Spezifikation ist, welche beliebig viele Auszeichnungssprachen, wie z.B. XHTML, schaffen kann.

Da wir insbesondere später mit DTDs und XSDs (was genau das ist, wird später erklärt) sowie einigen anderen Teilen arbeiten, muss man sich bei dem Arbeiten mit XML folgende 3 großen Teile vorstellen:

Der erste Teil ist die Gültigkeitsprüfung, welche die Regeln des XML Dokumentes enthält.
Der zweite Teil sind die Daten, welche in unserm XML Dokument zu finden sind.
Der dritte Teil befasst sich mit der Formatierung dessen.

             DTD              XSD         Gültigkeit

                     XML                       Daten

             CSS               XSL          Formatierung

5. Geschichtliches über XML

Das Web drohte vor nicht allzu langer Zeit auseinander zu brechen, was zur Folge hatte, dass die SGML Anhänger und das W3C schnell eine Lösung kommen mussten.

HTML oder gar XML ist im Vergleich zum Browser noch relativ jung. Der erste graphische Browser kam 1990 zum Einsatz.
3 Jahre lang hat sich eine Arbeitsgruppe mit dem Problem der Erweiterbarkeit von HTML beschäftigt.
Der erste Vorschlag zur „Extensible Markup Language“ kam 1996 im Rahmen einer SGML Veranstaltung. Auf der World Wide Web Conference 1997 war XML eines der Hauptthemen.
Das komplizierte SGML musste vereinfacht werden und heraus gekommen ist XML, als Teilmenge von SGML.
1998 wurde XML 1.0 zum Standard definiert. Nur ein Jahr später, wurde auch XHTML 1.0 zum Standard.

5.1 SGML
SGML steht für „Standard Generalized Markup Language“, was seit 1986 ein ISO Standard ist.
SGML ermöglicht die Definierung unterschiedlicher Auszeichnungssprachen, wie z.B. HTML. SGML ist der Nachfolger von GML, der „Generalized Markup Language“.

Ziel der SGML war es, betriebssystemübergreifend Dokumente auszutauschen.

5.2 Unterschied zwischen XML und SGML
Da XML ein Ableger von SGML ist, ist XML natürlich zu SGML kompatibel. Es gibt allerdings einige Unterschiede.

SGML arbeitet mit dem ASCII Code, sodass nur ein begrenzter Zeichensatz verfügbar ist. XML arbeitet mit dem UNICODE, welcher ein wesentlich größeren Zeichensatz hat.
Zudem sind in XML so genannte Empty-Tag-Elemente erlaubt, allerdings müssen diese durch ein „/“ beendet werden. Beispiel ist das img Tag aus HTML/XHTML:
HTML (was SGML repräsentiert)

<img src=”lala.jpg” mce_src=”lala.jpg”>

XHTML (was XML repräsentiert)

<img src=”lala.jpg” mce_src=”lala.jpg” />

Desweiteren ist XML Casesensitiv, d.h. Groß- und Kleinschreibung wird beachtet.
entspricht nicht oder gar . Aus XML Sicht sind das 3 verschiedene Elemente. In SGML spielt die Groß- und Kleinschreibung keine Rolle.

Ein letzter Punkt ist, dass der Doctype in SGML zwingend ist, hingegen bei der XML nur optional. Was das genau ist, erfahrt ihr auf den folgenden Seiten.

6. Die 10 Aussagen der Syntaxbeschreibung
Die Entwickler von XML haben 10 Aussagen entworfen um den Sinn von XML zu festigen:

XML soll sich im Internet auf einfache Weise nutzen lassen.
XML soll ein breites Spektrum von Anwendungen unterstützen.
XML soll zu SGML kompatibel sein.
Es soll einfach sein, Programme zu schreiben, die XML – Dokumente verarbeiten.
Die Anzahl optionaler Merkmale in XML soll minimal sein, idealer weise Null.
XML – Dokumente sollten für Menschen lesbar und angemessen verständlich sein.
Der XML – Entwurf sollte zügig abgefasst werden.
Der Entwurf von XML soll formal und präzise sein.
XML – Dokumente sollen leicht zu erstellen sein.
Knappheit von XML – Markup ist von minimaler Bedeutung.

7. 3 Gebote
In Anlehnung an die 10 Aussagen, sollte man bei der Generierung von XML Dokumenten 3 Gebote einhalten:

Du sollst Deine Elemente immer schließen.
Du sollst Attributwerte immer in doppelten Anführungszeichen setzen.
Schachtel Deine Elemente immer hierarchisch.

8. Auszeichnung
Da XML zu den Auszeichnungssprachen gehört, müssen wir natürlich diese Begrifflichkeit kurz erklären.
Eine Auszeichnung dient der Strukturierung eines Textes oder auch Dokumentes.

Auszeichnungen kann man in 3 große Teile aufspalten.

8.1 Physische Auszeichnung
Diese Auszeichnung bezieht sich auf die Layoutformatierung eines Textes.

Beispiel:
Wie ein Text dargestellt werden soll: kursiv, fett, unterstrichen?

8.2 Logische Auszeichnung
Diese Auszeichnung formatiert den Text auf logische Art und Weise.

Beispiel:
Der Text ist ein Zitat oder eine Überschrift.

8.3 Semantische Auszeichnung
Diese Auszeichnung wird am meisten in XML verwendet und gewinnt daher an Einfluss.

Die semantische Auszeichnung kann man sich wie eine Datenbank vorstellen und definiert nur die Struktur des Textes. Wie dieser formatiert und dargestellt wird, hat hier keine Bedeutung.

[Fortsetzung: XML Basiswissen]

Artikel

Amazon Web Service:
HowTo: Produktsuche mit den Amazon Web Services

eBay API:
HowTo: eBay API (Grundvoraussetzungen)
HowTo: eBay API (Suchen mit eBay…)
HowTo: eBay API (Aktuelle Suchbegriffe…)

Google Maps API:
HowTo: Google Maps API (Grundvoraussetzungen)

HTML / Javascript:
HowTo: Webanwendung debuggen (Javascript & HTML debuggen mit den entsprechenden Tools)
HowTo: Mauseingaben & Javascript (Wie bastelt man ein Paint mit Javascript?)
HowTo: Xml mit Javascript Parsen (Zugriff auf Nodes & Attribute)
HowTo: Objektorientierte Programmierung / OOP in Javascript (Eine einfache Klasse erstellen)
HowTo: Javascript Event “onscroll” nutzen
HowTo: Javascript Mouse Over – Mousepositionen für Details

Microsoft ASP.NET:
HowTo: Microsoft ASP.NET AJAX (Grundlagen)
HowTo: Microsoft ASP.NET AJAX (Praktischer Anfang)
HowTo: Microsoft ASP.NET AJAX (Clientseitiger Aufruf von Webmethoden)
HowTo: Microsoft ASP.NET AJAX (PageMethods – Webmethoden aufrufen ohne ASMX Datein)
HowTo: Json-Services erstellen (…oder wie erstell ich dynamisch Javascript?…oder Web 2.0 ohne AJAX?)
HowTo: Dynamische vCards als Link zum Importieren anbieten
HowTo: Microsoft AJAX Client API nutzen

Microsoft .NET:
HowTo: Datein per FTP über mit .NET runterladen und speichern
HowTo: Interfaces/Schnittstellen verstehen – mal auf simple Art und Weise
HowTo: XML erstellen mit XmlAttributes
HowTo: PDF’s erstellen unter .NET mit NFop

Microsoft Silverlight:
HowTo: Microsoft Silverlight 1.0 (Grundlagen)
HowTo: Microsoft Silverlight 1.0 (Praktischer Anfang)
HowTo: Microsoft Silverlight 1.0 (Spiegeleffekte erzeugen)
HowTo: Microsoft Silverlight 1.0 (dynamische Spiegeleffekte)
HowTo: Microsoft Silverlight 1.0 (Bilder “kippen” samt Spiegeleffekt)
HowTo: Microsoft Silverlight 1.0 (Webanwendungen mit dynamischen SilverlightHosts verschönern)
HowTo: Erstellen eines Silverlight 1.0 Videoplayers mal auf einfache Weise
HowTo: Silverlight mit dem “object” Tag als embedded HTML anbieten

Microsoft Patterns&Practices Software Factories:
HowTo: Microsoft Patterns&Practices Software Factories verstehen
HowTo: Microsoft Patterns&Practices – Web Service Factory / Service Factory (Teil 1: Grundlagen & ASMX Variante)
HowTo: Microsoft Patterns&Practices – Web Service Factory / Service Factory (Teil 2: WCF Variante)
HowTo: Microsoft Patterns&Parctices – Web Service Factory / Service Factory (Teil 3: Praktisches “Hello World”)

Microsoft Office SharePoint 2007:
HowTo: Automatisierte Backups mit dem Microsoft Office SharePoint 2007

Microsoft Visual Studio:
HowTo: Visual Studio 2005 für .NET 3.0 (WPF, WCF, WF) rüsten

AJAX:
HowTo: AJAX
HowTo: AJAX und ASP.NET Webservices (und die Sache mit dem GET)

Windows Live ID:
HowTo: Windows Live ID Web Authenticaton (Grundlage & Installation)

Microsoft Virtual Earth:
HowTo: Microsoft Virtual Earth (Praktischer Einstieg)

XML:
Guide: XML (Einführung)
Guide: XML (Basiswissen)
Guide: XML (DocumentType Definitions DTDs)
Guide: XML (XML Schema – Teil 1)
Guide: XML (XML Schema – Teil 2)
Guide: XML (XML Schema – Teil 3)

.NET & Datenbankverbindungen:
HowTo: Datenbankverbindungen – .NET & MS SQL 2005
HowTo: Datenbankverbindungen – .NET & MySQL

Oracle:
HowTo: Oracle 10g und die Oracle Developer Tools unter Vista