Ich habe diese Frage gegoogelt, verstehe aber nicht genau, was ein XML-Schema und eine DTD (Dokumenttypdefinition) ist und warum das XML-Schema im Vergleich zur DTD leistungsfähiger ist.

Jede Anleitung wäre sehr dankbar.

Aus dem Abschnitt Unterschiede zwischen DTDs und Schema des Artikels Konvertieren einer DTD in ein Schema :

Der entscheidende Unterschied zwischen DTDs und XML-Schema besteht darin, dass das XML-Schema eine XML-basierte Syntax verwendet, während DTDs eine eindeutige Syntax aufweisen, die von SGML-DTDs übernommen wird. Obwohl DTDs häufig kritisiert werden, weil sie eine neue Syntax lernen müssen, ist die Syntax selbst ziemlich knapp. Das Gegenteil gilt für XML-Schemas, die ausführlich sind, aber auch Tags und XML verwenden, damit Autoren von XML die Syntax von XML-Schema weniger einschüchternd finden sollten.

Das Ziel von DTDs war es, ein Maß an Kompatibilität mit SGML für Anwendungen beizubehalten, die SGML-DTDs möglicherweise in XML-DTDs konvertieren möchten. In Übereinstimmung mit einem der Ziele von XML "ist die Knappheit beim XML-Markup von minimaler Bedeutung" besteht jedoch kein wirkliches Problem darin, die Syntax kurz zu halten.

[...]

Was sind also einige der anderen Unterschiede, die besonders wichtig sein könnten, wenn wir eine DTD konvertieren? Lass uns mal sehen.

Tippen

Der wichtigste Unterschied zwischen DTDs und XML-Schema besteht in der Möglichkeit, Datentypen in Schema in Verbindung mit Element- und Attributdeklarationen zu erstellen und zu verwenden. Tatsächlich ist es ein so wichtiger Unterschied, dass die Hälfte der XML-Schemaempfehlung der Datentypisierung und dem XML-Schema gewidmet ist. Wir behandeln Datentypen ausführlich in Teil III dieses Buches "XML-Schemadatentypen".

[...]

Vorkommensbeschränkungen

Ein weiterer Bereich, in dem sich DTDs und Schema erheblich unterscheiden, sind Vorkommensbeschränkungen. Wenn Sie sich an unsere vorherigen Beispiele in Kapitel 2, "Schemastruktur" (oder Ihre eigene Arbeit mit DTDs) erinnern, gibt es drei Symbole, mit denen Sie die Anzahl der Vorkommen eines Elements begrenzen können: *, + und ?.

[...]

Aufzählungen

Nehmen wir also an, wir hatten ein Element und wollten ein Größenattribut für das Shirt definieren können, mit dem Benutzer eine Größe auswählen können: klein, mittel oder groß. Unsere DTD würde so aussehen:

<!ELEMENT item (shirt)>
<!ELEMENT shirt (#PCDATA)>
<!ATTLIST shirt
    size_value (small | medium | large)>

[...]

Aber was wäre, wenn wir sizeein Element sein wollten ? Mit einer DTD können wir das nicht machen. DTDs sehen keine Aufzählungen im Textinhalt eines Elements vor. Aufgrund von Datentypen mit Schema haben wir beim Deklarieren der Aufzählung im vorherigen Beispiel tatsächlich einen simpleTypeAufruf erstellt, size_valuesden wir jetzt mit einem Element verwenden können:

<xs:element name="size" type="size_value">

[...]

Zu den Unterschieden zwischen einer XML-Schemadefinition (XSD) und einer Dokumenttypdefinition (DTD) gehören:

• XML-Schemas werden in XML geschrieben, während DTD von der SGML-Syntax abgeleitet werden.
• XML-Schemas definieren Datentypen für Elemente und Attribute, während DTD keine Datentypen unterstützt.
• XML-Schemas unterstützen Namespaces, DTD nicht.
• XML-Schemas definieren die Anzahl und Reihenfolge der untergeordneten Elemente, die DTD jedoch nicht.
• XML-Schemas können mit XML DOM selbst bearbeitet werden, bei DTD ist dies jedoch nicht möglich.
• Benutzer eines XML-Schemas müssen keine neue Sprache lernen, aber die Arbeit mit DTD ist für einen Benutzer schwierig.
• Das XML-Schema bietet eine sichere Datenkommunikation, dh der Absender kann die Daten so beschreiben, dass der Empfänger sie versteht. Im Falle von DTD können die Daten jedoch vom Empfänger missverstanden werden.
• XML-Schemas sind erweiterbar, während DTD nicht erweiterbar ist.

UPDATE : 26.08.2015

Nicht alle diese Aufzählungspunkte sind 100% genau, aber Sie verstehen das Wesentliche.

Andererseits:

• Mit DTD können Sie neue ENTITY- Werte zur Verwendung in Ihrer XML-Datei definieren.
• Mit DTD können Sie es lokal auf eine einzelne XML-Datei erweitern.

Wie bereits erwähnt, verwenden XML-Schemata eine XML-basierte Syntax und DTDs eine eindeutige Syntax. DTD unterstützt keine Datentypen, was wichtig ist.

Sehen wir uns ein sehr einfaches Beispiel an, in dem die Universität mehrere Studenten hat und jeder Student zwei Elemente hat: "Name" und "Jahr". Bitte beachten Sie, dass ich in meinem Code "// ->" nur für Kommentare verwendet habe.

Jetzt werde ich dieses Beispiel sowohl in DTD als auch in XSD schreiben.

DTD

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE university[              // --> university as root element 
<!ELEMENT university (student*)>   // --> university has  * = Multiple students
<!ELEMENT student (name,year)>     // --> Student has elements name and year
<!ELEMENT name (#PCDATA)>          // --> name as Parsed character data
<!ELEMENT year (#PCDATA)>          // --> year as Parsed character data
]>

<university>
    <student>
        <name>
            John Niel             //---> I can also use an Integer,not good
        </name>
        <year>
            2000                 //---> I can also use a string,not good
        </year>
    </student>
</university>

XML-Schemadefinition (XSD)

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

<xsd:complexType name ="uniType">                    //--> complex datatype uniType
 <xsd:sequence>
  <xsd:element ref="student" maxOccurs="unbounded"/> //--> has unbounded no.of students
 </xsd:sequence>
</xsd:complexType>

<xsd:complexType name="stuType">                     //--> complex datatype stuType
 <xsd:sequence>
  <xsd:element ref="name"/>                          //--> has element name
  <xsd:element ref="year"/>                          //--> has element year
 </xsd:sequence>
</xsd:complexType>

<xsd:element name="university" type="uniType"/>       //--> university of type UniType 
<xsd:element name="student" type="stuType"/>          //--> student of type stuType
<xsd:element name="name" type="xsd:string"/>          //--> name of datatype string
<xsd:element name="year" type="xsd:integer"/>         //--> year of datatype integer
</xsd:schema>



<?xml version="1.0" encoding="UTF-8"?>
<university>
    <student>
        <name>
            John Niel          
        </name>
        <year>
            2000                      //--> only an Integer value is allowed
        </year>
    </student>
</university>

Die DTD ist älter als XML und daher selbst kein gültiges XML. Dies ist wahrscheinlich der Hauptgrund für die Erfindung von XSD.

Ähnlichkeiten zwischen XSD und DTD

both specify elements, attributes, nesting, ordering, #occurences

Unterschiede zwischen XSD und DTD

XSD also has data types, (typed) pointers, namespaces, keys and more.... unlike DTD 

Obwohl XSD wenig ausführlich ist, ist seine Syntax eine Erweiterung von XML, was es bequem macht, schnell zu lernen.

Ein Unterschied besteht darin, dass in einer DTD das Inhaltsmodell eines Elements vollständig durch seinen Namen bestimmt wird, unabhängig davon, wo es im Dokument angezeigt wird:

Angenommen, Sie möchten haben

• ein personElement
• mit einem untergeordneten Element namens name
• ein nameselbst hat untergeordnete Elemente firstund last.

So was

   <person>
       <name>
            <first></first>
            <last></last>
       </name>
   </person>

Wenn ein cityElement im selben Dokument muss auch ein ‚Namen‘ untergeordneten Element haben erfordert die DTD , dass dieses ‚Namen‘ Element untergeordnete Elemente haben muss firstund lastwie gut. Trotz der Tatsache, dass city.namenicht erforderlich firstund lastals Kinder.

Im Gegensatz dazu können Sie mit XML-Schema untergeordnete Elementtypen lokal deklarieren. Sie können die nameuntergeordneten Elemente für beide personund cityseparat deklarieren . Auf diese Weise erhalten sie ihre richtigen Inhaltsmodelle in diesen Kontexten.

Der andere große Unterschied ist die Unterstützung von Namespaces. Da DTDs Teil der ursprünglichen XML-Spezifikation sind (und von SGML geerbt wurden), sind sie überhaupt nicht namespace-fähig, da später XML-Namespaces angegeben wurden. Sie können DTDs in Kombination mit Namespaces verwenden, es sind jedoch einige Verzerrungen erforderlich, z. B. die Notwendigkeit, die Präfixe in der DTD zu definieren und nur diese Präfixe zu verwenden, anstatt beliebige Präfixe verwenden zu können.

Andere Unterschiede sind für mich meist oberflächlich. Die Unterstützung von Datentypen kann problemlos zu DTDs hinzugefügt werden, und die Syntax ist nur Syntax. (Zum einen finde ich die Syntax des XML-Schemas schrecklich und möchte niemals ein XML-Schema von Hand pflegen, was ich nicht über DTDs oder RELAX NG-Schemas sagen würde. Wenn ich aus irgendeinem Grund ein XML-Schema benötige, schreibe ich normalerweise ein RELAX NG eins und konvertiere es mit trang.)

Ähnlichkeiten :

DTDs und Schemas erfüllen beide die gleichen Grundfunktionen:

• Zunächst deklarieren beide eine Wäscheliste mit Elementen und Attributen.
• Zweitens beschreiben beide, wie diese Elemente in XML gruppiert, verschachtelt oder verwendet werden. Mit anderen Worten, sie deklarieren die Regeln, nach denen Sie jemandem erlauben, eine XML-Datei in Ihrem Workflow zu erstellen, und
• Drittens bieten sowohl DTDs als auch Schemata Methoden zum Einschränken oder Erzwingen des Typs oder Formats eines Elements. Innerhalb der DTD oder des Schemas können Sie beispielsweise erzwingen, dass ein Datumsfeld als 01/05/06 oder 1/5/2006 geschrieben wird.

Unterschiede:

• DTDs eignen sich besser für textintensive Anwendungen, während Schemata für datenintensive Workflows mehrere Vorteile bieten.

• Schemata sind in XML geschrieben und folgen daher denselben Regeln, während DTDs in einer völlig anderen Sprache geschrieben sind.

Beispiele:

DTD:

<?xml version="1.0" encoding="UTF-8"?>
    <!ELEMENT employees (Efirstname, Elastname, Etitle, Ephone, Eemail)>
         <!ELEMENT Efirstname (#PCDATA)>
         <!ELEMENT Elastname (#PCDATA)>
         <!ELEMENT Etitle (#PCDATA)>
         <!ELEMENT Ephone (#PCDATA)>
         <!ELEMENT Eemail (#PCDATA)>

XSD:

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:od="urn:schemas-microsoft-com:officedata">
<xsd:element name="dataroot">
     <xsd:complexType>
          <xsd:sequence>
               <xsd:element ref="employees" minOccurs="0" maxOccurs="unbounded"/>
          </xsd:sequence>
          <xsd:attribute name="generated" type="xsd:dateTime"/>
      </xsd:complexType>
</xsd:element>
<xsd:element name="employees">
      <xsd:annotation>
           <xsd:appinfo>
               <od:index index-name="PrimaryKey" index-key="Employeeid " primary="yes"
                unique="yes" clustered="no"/>
          <od:index index-name="Employeeid" index-key="Employeeid " primary="no" unique="no"
           clustered="no"/>
     </xsd:appinfo>
</xsd:annotation>
     <xsd:complexType>
          <xsd:sequence>
               <xsd:element name="Elastname" minOccurs="0" od:jetType="text"
                od:sqlSType="nvarchar">
                    <xsd:simpleType>
                         <xsd:restriction base="xsd:string">
                              <xsd:maxLength value="50"/>
                         </xsd:restriction>
                    </xsd:simpleType>
               </xsd:element>
               <xsd:element name="Etitle" minOccurs="0" od:jetType="text" od:sqlSType="nvarchar">
                    <xsd:simpleType>
                         <xsd:restriction base="xsd:string">
                              <xsd:maxLength value="50"/>
                         </xsd:restriction>
                    </xsd:simpleType>
               </xsd:element>
               <xsd:element name="Ephone" minOccurs="0" od:jetType="text"
                od:sqlSType="nvarchar">
                    <xsd:simpleType>
                         <xsd:restriction base="xsd:string">
                              <xsd:maxLength value="50"/>
                         </xsd:restriction>
                    </xsd:simpleType>
               </xsd:element>
               <xsd:element name="Eemail" minOccurs="0" od:jetType="text"
               od:sqlSType="nvarchar">
                    <xsd:simpleType>
                         <xsd:restriction base="xsd:string">
                              <xsd:maxLength value="50"/>
                         </xsd:restriction>
                    </xsd:simpleType>
               </xsd:element>
               <xsd:element name="Ephoto" minOccurs="0" od:jetType="text"
                od:sqlSType="nvarchar">
                    <xsd:simpleType>
                         <xsd:restriction base="xsd:string">
                              <xsd:maxLength value="50"/>
                         </xsd:restriction>
                    </xsd:simpleType>
               </xsd:element>
          </xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>

DTD kann nur zwei Arten von Daten haben, die CDATA und die PCDATA. In einem Schema können Sie jedoch alle primitiven Datentypen verwenden, die Sie in der Programmiersprache verwenden, und Sie haben die Flexibilität, Ihre eigenen benutzerdefinierten Datentypen zu definieren.

Der Entwickler, der ein Schema erstellt, kann benutzerdefinierte Datentypen basierend auf den Kerndatentypen und unter Verwendung verschiedener Operatoren und Modifikatoren erstellen.

Als XML zum ersten Mal herauskam, wurde uns gesagt, dass es alle unsere Probleme lösen würde: XML ist benutzerfreundlich, unendlich erweiterbar, vermeidet starkes Tippen und erfordert keine Programmierkenntnisse. Ich habe etwas über DTDs gelernt und meinen eigenen XML-Parser geschrieben. Über 15 Jahre später sehe ich, dass die meisten XML-Dateien nicht benutzerfreundlich und nicht sehr erweiterbar sind (abhängig von ihrer Verwendung). Sobald einige clevere Clogs XML mit einer Datenbank verbunden hatten, wusste ich, dass Datentypen so gut wie unvermeidlich waren. Und Sie sollten die XSLT (Transformationsdatei) sehen, an der ich neulich arbeiten musste. Wenn das nicht programmiert ist, weiß ich nicht was ist! Heutzutage ist es nicht ungewöhnlich, dass alle Arten von Problemen im Zusammenhang mit XML-Daten oder Schnittstellen fehlerhaft sind. Ich liebe XML, aber es hat sich weit von seinem ursprünglichen altruistischen Ausgangspunkt entfernt.

Die kurze Antwort? DTDs wurden zugunsten von XSDs abgelehnt, da Sie mit einer XSD eine XML-Struktur genauer definieren können.

XML-DTD

Der Zweck einer DTD besteht darin, die Struktur eines XML-Dokuments zu definieren. Es definiert die Struktur mit einer Liste von rechtlichen Elementen:

<!ATTLIST contact type CDATA #IMPLIED>
<!ELEMENT address1 ( #PCDATA)>
<!ELEMENT city ( #PCDATA)>
<!ELEMENT state ( #PCDATA)>
<!ELEMENT zip ( #PCDATA)>

XML-Schema

Mit dem XML-Schema können Schemaautoren angeben, dass die Daten der Elementmenge numerisch oder insbesondere eine Ganzzahl sein müssen. Im folgenden Beispiel habe ich verwendet string:

<xs:element name="note">
<xs:complexType>
  <xs:sequence>
    <xs:element name="address1" type="xs:string"/>
    <xs:element name="city" type="xs:string"/>
    <xs:element name="state" type="xs:string"/>
    <xs:element name="zip" type="xs:string"/>
  </xs:sequence>
</xs:complexType>

DTD ist ziemlich veraltet, da es in seiner Nützlichkeit als Schemasprache eingeschränkt ist, keinen Namespace unterstützt und keinen Datentyp unterstützt. Darüber hinaus ist die Syntax der DTD recht kompliziert, was das Verständnis und die Wartung erschwert.

DTD gibt die Syntax des XML-Elements an

XML-Schemas sind die Alternative von Microsoft zur DTD zur Validierung von XML