Eu pesquisei essa questão no Google, mas não entendo claramente o que é um esquema XML e DTD (definição de tipo de documento) e por que o esquema XML é mais poderoso comparado ao DTD.

Qualquer orientação seria muito apreciada.

Na seção Diferenças entre DTDs e Esquema do artigo Convertendo uma DTD em um esquema :

A diferença crítica entre DTDs e XML Schema é que o XML Schema utiliza uma sintaxe baseada em XML, enquanto as DTDs têm uma sintaxe exclusiva mantida em relação às DTDs SGML. Embora as DTDs sejam frequentemente criticadas por causa dessa necessidade de aprender uma nova sintaxe, a própria sintaxe é bastante concisa. O oposto é verdadeiro para o XML Schema, que é detalhado, mas também usa tags e XML, para que os autores de XML achem a sintaxe do XML Schema menos intimidadora.

O objetivo das DTDs era manter um nível de compatibilidade com SGML para aplicativos que podem querer converter DTDs SGML em DTDs XML. No entanto, de acordo com um dos objetivos do XML, "a dispersão na marcação XML é de importância mínima", não há uma preocupação real em manter a sintaxe breve.

[...]

Então, quais são algumas das outras diferenças que podem ser especialmente importantes quando estamos convertendo uma DTD? Vamos dar uma olhada.

Digitando

A diferença mais significativa entre DTDs e XML Schema é a capacidade de criar e usar tipos de dados no Schema em conjunto com as declarações de elemento e atributo. De fato, é uma diferença tão importante que metade da Recomendação do Esquema XML é dedicada à digitação de dados e ao Esquema XML. Abordamos os tipos de dados em detalhes na Parte III deste livro, "XML Schema Datatypes".

[...]

Restrições de Ocorrência

Outra área em que DTDs e Esquema diferem significativamente é com restrições de ocorrência. Se você se lembra dos exemplos anteriores no Capítulo 2, "Estrutura do esquema" (ou seu próprio trabalho com DTDs), existem três símbolos que você pode usar para limitar o número de ocorrências de um elemento: *, + e?.

[...]

Enumerações

Então, digamos que tínhamos um elemento e queríamos definir um atributo de tamanho para a camiseta, o que permitia aos usuários escolher um tamanho: pequeno, médio ou grande. Nosso DTD ficaria assim:

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

[...]

Mas e se quiséssemos sizeser um elemento? Não podemos fazer isso com um DTD. As DTDs não fornecem enumerações no conteúdo de texto de um elemento. No entanto, devido aos tipos de dados com o esquema, quando declaramos a enumeração no exemplo anterior, na verdade criamos uma simpleTypechamada size_valuesque agora podemos usar com um elemento:

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

[...]

As diferenças entre uma definição de esquema XML (XSD) e uma definição de tipo de documento (DTD) incluem:

• Esquemas XML são gravados em XML enquanto DTD são derivados da sintaxe SGML.
• Esquemas XML definem tipos de dados para elementos e atributos, enquanto o DTD não suporta tipos de dados.
• Esquemas XML permitem o suporte a espaços para nome, enquanto o DTD não.
• Os esquemas XML definem o número e a ordem dos elementos filhos, enquanto o DTD não.
• Os esquemas XML podem ser manipulados por você mesmo com o XML DOM, mas não é possível no caso de DTD.
• usando o esquema XML, o usuário não precisa aprender um novo idioma, mas trabalhar com DTD é difícil para um usuário.
• O esquema XML fornece comunicação segura de dados, ou seja, o remetente pode descrever os dados de uma maneira que o destinatário entenda, mas no caso de dados DTD podem ser mal interpretados pelo destinatário.
• Esquemas XML são extensíveis enquanto DTD não é extensível.

UPDATE : 2015.08.26

Nem todos esses pontos são 100% precisos, mas você entende.

Por outro lado:

• DTD permite definir novos valores de ENTITY para uso em seu arquivo XML.
• O DTD permite estendê-lo local para um arquivo XML individual.

Como muitas pessoas mencionaram antes, o XML Schema utiliza uma sintaxe baseada em XML e as DTDs têm uma sintaxe exclusiva. O DTD não suporta tipos de dados, o que importa.

Vamos ver um exemplo muito simples no qual a universidade tem vários alunos e cada aluno tem dois elementos "nome" e "ano". Observe que eu tenho usos "// ->" no meu código apenas para comentários.

Agora vou escrever este exemplo em DTD e em XSD.

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>

Definição de esquema XML (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>

DTD é anterior ao XML e, portanto, não é o próprio XML válido. Essa é provavelmente a maior razão para a invenção do XSD.

Semelhanças entre XSD e DTD

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

Diferenças entre XSD e DTD

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

Além disso, embora o XSD seja pouco detalhado, sua sintaxe é uma extensão do XML, tornando conveniente o aprendizado rápido.

Uma diferença é que, em uma DTD, o modelo de conteúdo de um elemento é completamente determinado por seu nome, independentemente de onde aparece no documento:

Supondo que você queira ter

• um personelemento
• com um elemento filho chamado name
• um em namesi tem elementos filhos firste last.

Como isso

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

Se um cityelemento no mesmo documento também precisa ter 'nome' um elemento filho do DTD exige que este elemento 'nome' deve ter elementos filhos firste lastbem. Apesar do fato de que city.namenão requer firste lastcomo crianças.

Por outro lado, o XML Schema permite declarar tipos de elementos filhos localmente; você pode declarar os nameelementos filhos para ambos persone cityseparadamente. Dando a eles seus modelos de conteúdo adequados nesses contextos.

A outra grande diferença é o suporte a namespaces. Como as DTDs fazem parte da especificação XML original (e são herdadas do SGML), elas não reconhecem o namespace, porque os namespaces XML foram especificados posteriormente. Você pode usar DTDs em combinação com espaços para nome, mas isso requer algumas contorções, como ser forçado a definir os prefixos na DTD e usar apenas esses prefixos, em vez de poder usar prefixos arbitrários.

Para mim, outras diferenças são principalmente superficiais. O suporte ao tipo de dados pode ser facilmente adicionado às DTDs, e a sintaxe é apenas sintaxe. (Eu, por exemplo, considero a sintaxe do esquema XML horrível e nunca gostaria de manter manualmente um esquema XML, o que eu não diria sobre DTDs ou esquemas RELAX NG; se eu precisar de um esquema XML por algum motivo, geralmente escrevo um RELAX NG one e converta-o com trang.)

Semelhanças :

DTDs e Schemas desempenham as mesmas funções básicas:

• Primeiro, ambos declaram uma lista completa de elementos e atributos.
• Segundo, ambos descrevem como esses elementos são agrupados, aninhados ou usados ​​no XML. Em outras palavras, eles declaram as regras pelas quais você está permitindo que alguém crie um arquivo XML em seu fluxo de trabalho e
• Terceiro, os DTDs e os esquemas fornecem métodos para restringir ou forçar o tipo ou formato de um elemento. Por exemplo, dentro da DTD ou Esquema, você pode forçar um campo de data a ser gravado como 01/05/06 ou 1/5/2006.

Diferenças:

• As DTDs são melhores para aplicativos com uso intenso de texto, enquanto os esquemas têm várias vantagens para fluxos de trabalho com uso intenso de dados.

• Os esquemas são escritos em XML e, portanto, seguem as mesmas regras, enquanto os DTDs são escritos em uma linguagem completamente diferente.

Exemplos:

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>

O DTD pode ter apenas dois tipos de dados, o CDATA e o PCDATA. Porém, em um esquema, você pode usar todo o tipo de dados primitivo usado na linguagem de programação e ter a flexibilidade de definir seus próprios tipos de dados personalizados.

O desenvolvedor que cria um esquema pode criar tipos de dados personalizados com base nos tipos de dados principais e usando diferentes operadores e modificadores.

Quando o XML foi lançado, fomos informados de que resolveria todos os nossos problemas: o XML será fácil de usar, infinitamente extensível, evitará digitação forte e não exigirá nenhuma habilidade de programação. Eu aprendi sobre DTDs e escrevi meu próprio analisador de XML. Mais de 15 anos depois, vejo que a maioria dos XML não é fácil de usar e não é muito extensível (dependendo do uso). Assim que alguns tamancos inteligentes conectaram o XML a um banco de dados, eu sabia que os tipos de dados eram praticamente inevitáveis. E você deve ver o XSLT (arquivo de transformação) que tive que trabalhar no outro dia. Se isso não é programação, não sei o que é! Atualmente, não é incomum ver todos os tipos de problemas relacionados a dados ou interfaces XML em mau estado. Eu amo XML, mas ele se afastou do ponto de partida altruísta original.

A resposta curta? As DTDs foram descontinuadas em favor dos XSDs, porque um XSD permite definir uma estrutura XML com mais precisão.

DTD XML

O objetivo de uma DTD é definir a estrutura de um documento XML. Ele define a estrutura com uma lista de elementos legais:

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

Esquema XML

O esquema XML permite que os autores do esquema especifiquem que os dados da quantidade do elemento devem ser numéricos ou, mais especificamente, um número inteiro. No exemplo a seguir eu usei 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>

A DTD está praticamente obsoleta porque é limitada em sua utilidade como linguagem de esquema, não suporta espaço para nome e não suporta tipo de dados. Além disso, a sintaxe da DTD é bastante complicada, dificultando a compreensão e a manutenção.

DTD indica a sintaxe do elemento XML

Esquemas XML são a alternativa da Microsoft ao DTD para validar XML