Clique aqui para instalar o Silverlight*
BrasilAlterar|Todos os sites da Microsoft
MSDN
|Developer Centers|Biblioteca|Downloads|Assinaturas MSDN
Pesquisa rápida


XPath sem Traumas

Por Fábio Vazquez

Para ler todas as matérias da MSDN Magazine, assine a revista no endereço www.neoficio.com.br/msdn

Este artigo discute:

Este artigo usa as seguintes tecnologias:

O que é XPath e seus métodos

Como gerar e ler XML

Pesquisar dados com XPath

XML, C#

Download:

Chapéu
XPath

 

Não é à toa que vemos poucos desenvolvedores usando os recursos maravilhosos disponibilizados por tecnologias como XPath (XML Path Language) e XSLT (Extensible Stylesheet Language Transformation): elas podem realmente parecer muito complexas. O objetivo deste artigo é dar uma visão de algumas utilizações práticas da linguagem de consulta XPath. Não detalharei questões intrincadas que envolvem a interpretação da sintaxe das expressões XPath, mas tentarei despertar a atenção do leitor para alguns usos interessantes proporcionados por esta tecnologia. Este artigo assume que o leitor já tenha familiaridade com os conceitos da tecnologia XML.

Faça o simples antes. Deixe o complicado para depois

Como qualquer consumidor convencional, nós, consumidores de tecnologia, precisamos ter a nossa atenção despertada para que criemos o interesse por algum produto tecnológico. Se algo parece muito complexo a primeira vista, pode até estimular o interesse de alguns, mas a maioria não chegará a ter desejo por usar a tecnologia, seja porque ela é demasiadamente complexa ou porque esta pessoa simplesmente não entende o que está a sua frente. XML em geral e as tecnologias acessórias como XPath, XSLT, XSD e outras, são baseadas em princípios altamente consolidados para desenvolvedores, como hierarquias, relacionamentos, caminhos, tipos de dados, gramáticas, entre outros. Por esta razão, não podemos deixar de usá-las porque as achamos complexas ou desnecessárias.

Por serem baseados em texto, os documentos XML são facilmente lidos e interpretados, não somente por diferentes linguagens e plataformas operacionais, mas também pelo ser humano. Por exemplo, o documento mostrado na Listagem 1 é fácil verificar que se trata da representação de alguns pedidos e os seus respectivos itens. Mais precisamente, os pedidos do cliente "TRAIH" do database Northwind, que é distribuído com o Microsoft SQL Server 2000.

Listagem 1 - Documento XML hierárquico gerado a partir de um DataSet.

<?xml version="1.0" standalone="yes"?>
<PedidosItens>
  <Pedidos>
    <OrderID>10574</OrderID>
    <OrderDate>1997-06-19T00:00:00.0000000-03:00</OrderDate>
    <Itens>
      <OrderID>10574</OrderID>
      <ProductID>33</ProductID>
      <UnitPrice>2.5000</UnitPrice>
      <Quantity>14</Quantity>
      <Discount>0</Discount>
    </Itens>
    <Itens>
      <OrderID>10574</OrderID>
      <ProductID>40</ProductID>
      <UnitPrice>18.4000</UnitPrice>
      <Quantity>2</Quantity>
      <Discount>0</Discount>
    </Itens>
    <Itens>
      <OrderID>10574</OrderID>
      <ProductID>62</ProductID>
      <UnitPrice>49.3000</UnitPrice>
      <Quantity>10</Quantity>
      <Discount>0</Discount>
    </Itens>
    <Itens>
      <OrderID>10574</OrderID>
      <ProductID>64</ProductID>
      <UnitPrice>33.2500</UnitPrice>
      <Quantity>6</Quantity>
      <Discount>0</Discount>
    </Itens>
  </Pedidos>
  <Pedidos>
    <OrderID>10577</OrderID>
    <OrderDate>1997-06-23T00:00:00.0000000-03:00</OrderDate>
    <Itens>
      <OrderID>10577</OrderID>
      <ProductID>39</ProductID>
      <UnitPrice>18.0000</UnitPrice>
      <Quantity>10</Quantity>
      <Discount>0</Discount>
    </Itens>
    <Itens>
      <OrderID>10577</OrderID>
      <ProductID>75</ProductID>
      <UnitPrice>7.7500</UnitPrice>
      <Quantity>20</Quantity>
      <Discount>0</Discount>
    </Itens>
    <Itens>
      <OrderID>10577</OrderID>
      <ProductID>77</ProductID>
      <UnitPrice>13.0000</UnitPrice>
      <Quantity>18</Quantity>
      <Discount>0</Discount>
    </Itens>
  </Pedidos>
  <Pedidos>
    <OrderID>10822</OrderID>
    <OrderDate>1998-01-08T00:00:00.0000000-03:00</OrderDate>
    <Itens>
      <OrderID>10822</OrderID>
      <ProductID>62</ProductID>
      <UnitPrice>49.3000</UnitPrice>
      <Quantity>3</Quantity>
      <Discount>0</Discount>
    </Itens>
    <Itens>
      <OrderID>10822</OrderID>
      <ProductID>70</ProductID>
      <UnitPrice>15.0000</UnitPrice>
      <Quantity>6</Quantity>
      <Discount>0</Discount>
    </Itens>
  </Pedidos>
</PedidosItens>

O documento da Listagem 1 foi gerado com o código da Listagem 2. Note que o XML foi criado a partir da chamada ao método WriteXml() de um objeto DataSet que mantinha dois DataTables (Pedidos e Itens). Estes DataTables, por sua vez, estavam relacionados entre si através de uma chave-estrangeira, a qual foi adicionada à coleção "Relations" do DataSet. Um detalhe interessante neste exemplo é que o documento XML foi gerado de forma que o relacionamento entre os pedidos e os seus itens fosse determinado hierarquicamente, ou seja, os elementos <Itens> tornaram-se filhos dos elementos <Pedidos>. Embora este não seja o comportamento padrão da serialização dos dados de um DataSet em XML, conseguimos isto atribuindo o valor "true" à propriedade "Nested" da relação:

ds.Relations["PedidosItens"].Nested = true;

Listagem 2 - Método utilizado para gerar o documento XML da Listagem 1.

public string   GerarXml()
{
    string strArqXml  = @"\PedidosItens.Xml";
    string strConexao = @"Data Source=localhost; 
                          Initial Catalog=Northwind; 
                          Integrated Security=SSPI;";

    SqlDataAdapter daPedidos, daItens;
    DataSet ds = new DataSet("PedidosItens");

    using ( SqlConnection conn = new SqlConnection(strConexao) )
    {
        try 
        {
            daPedidos = new SqlDataAdapter
                (
                    @"select OrderID, OrderDate   
                      from Orders 
                      where CustomerID = 'TRAIH'", 
                    conn
                );
            daPedidos.Fill(ds, "Pedidos");

            daItens = new SqlDataAdapter
                (
                    @"select I.* 
                      from Orders O inner join [Order Details] I on O.OrderID = I.OrderID   
                      where O.CustomerID = 'TRAIH'",
                    conn
                );
            daItens.Fill(ds, "Itens");

            // Estabelece um relacionamento de chave-estrangeira entre Pedidos e Itens
            ds.Relations.Add
                (
                    "PedidosItens",
                    ds.Tables["Pedidos"].Columns["OrderId"],
                    ds.Tables["Itens"].Columns["OrderId"]
                );

            // Indica que os elementos filhos serão aninhados no pai. 
            // Isto irá gerar um XML hierárquico...
            ds.Relations["PedidosItens"].Nested = true;

            ds.WriteXml(strArqXml);

            daItens.Dispose();
            daPedidos.Dispose();
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        }

        if (!System.IO.File.Exists(strArqXml))
        {
            strArqXml = "";
        }

        return strArqXml;
    }
}

Expressões XPath

A XML Path Language, XPath, é parte importante da família de tecnologias XML, já que ela provê a possibilidade de selecionar e filtrar dados contidos em um ou mais documentos XML. Quando trabalhamos com XML em geral, vários são os casos de uso que surgem aos quais podemos aplicar expressões XPath para realizar pesquisas sobre esses documentos. A sintaxe adotada pelo XPath é bastante intuitiva, já que ela baseia-se em caminhos, como os caminhos de um sistema de arquivos. Considere, por exemplo, a expressão XPath a seguir:

/PedidosItens/Pedidos

Se aplicada ao documento da Listagem 1, esta expressão retornará todos os elementos "Pedidos" que são filhos do elemento "PedidosItens". No nosso exemplo, todos os elementos "Pedidos" do documento. Note que a expressão inicia com um caractere de barra (/). Toda expressão que inicia com uma barra indica que a pesquisa deve começar a partir da raiz do documento XML; da mesma forma que o caminho "\Arquivos de Programas", quando aplicado a um sistema de arquivos, indicará que o diretório deve ser pesquisado a partir do diretório raiz da unidade corrente. Vários caracteres de barra podem aparecer em uma expressão XPath. No exemplo acima, além da barra inicial, temos mais uma barra separando "PedidosItens" de "Pedidos". Cada caractere de barra numa expressão XPath representa uma troca de nível hierárquico; mais uma vez, da mesma forma que ocorre com os caminhos em sistemas de arquivos. Com estas informações em mãos, já podemos concluir que "PedidosItens" é o elemento raiz do documento de exemplo e que ele é pai de "Pedidos". Como existirá mais do que um elemento "Pedidos" no documento que satisfaça a condição determinada pela expressão acima, todos esses elementos serão retornados numa espécie de coleção de nodos, formalmente denominada "node-set". Um node-set nada mais é do que um conjunto de nodos (elementos, atributos, instruções de processamento, comentários, textos ou namespaces) agrupados em uma estrutura comum. Esta estrutura poderá, posteriormente, ser processada via programação, como veremos mais adiante neste artigo.

Como um documento XML só pode ter um único elemento raiz, sabemos que somente um elemento "PedidosItens" existirá no documento. Mas quantos elementos "Pedidos" serão retornados? Podemos responder a esta pergunta aplicando a seguinte expressão XPath:

count( /PedidosItens/Pedidos )

A função "count" é uma das funções de agregação da XPath, assim como a função de mesmo nome existente no SELECT-SQL no SQL Server. Ela retornará um valor escalar inteiro com a contagem dos nodos que satisfaçam a consulta XPath passada como parâmetro. No caso do documento de exemplo, como existem três elementos "Pedidos", o inteiro 3 será retornado da expressão.

Além das capacidades de pesquisa direta por determinados nodos e utilização de funções de agregação que trabalham sobre conjuntos de nodos, a XPath também permite a especificação de condições que tornam possível a filtragem dos dados. A expressão abaixo retorna um elemento de pedido específico, baseado numa condição de filtragem:

/PedidosItens/Pedidos[ OrderID ='10577' ]

A expressão entre colchetes, formalmente denominada "predicado", determina uma condição lógica que deve ser atendida para que o nodo que a precede seja selecionado pelo processador XPath. Podemos, por razões didáticas, comparar o predicado de uma expressão XPath com a cláusula WHERE de um comando SELECT-SQL. No exemplo acima, somente serão retornados os elementos "Pedidos" cujo elemento filho, "OrderID", tenha o valor '10577'. Os nodos que aparecem no predicado da expressão estão dentro de um contexto; e este contexto é justamente o nodo que precede o predicado. Na expressão acima, o nodo de contexto do elemento "OrderID" é o elemento "Pedidos".

As expressões XPath apresentadas até agora somente envolvem nodos do tipo elemento. Mas sabemos que um documento XML é composto de muitos outros tipos de nodos, como atributos, comentários, instruções de processamento, etc. Uma observação importante a ser feita neste momento, que servirá não só para predicados, mas para qualquer parte de uma expressão XPath, é a forma como atributos são identificados. Imaginemos por um momento que "OrderID" seja um atributo e não um elemento. A expressão acima poderia ser reescrita da seguinte forma:

/PedidosItens/Pedidos[ @OrderID ='10577' ]

Note que um atributo deve ser precedido por um caractere "@". Isso é suficiente para que o processador XPath saiba que estamos fazendo referência para um atributo e não para um elemento.

Muitas possibilidades. Muitas expressões

Uma breve reflexão neste momento nos permite concluir que uma expressão XPath pode retornar diversos tipos de dados. Nos exemplos anteriores, vimos expressões que retornam conjuntos de nodos (node-set), escalar numérico e um único nodo. Realmente, as expressões XPath têm esta peculiaridade. Outros tipos também podem ser retornados, como strings e booleanos. O importante aqui é que isso não seja visto como uma complexidade a mais da tecnologia, mas sim como um indicador da flexibilidade oferecida por ela. Antes de prosseguirmos com exemplos mais interessantes de expressões XPath, vamos dar uma olhada em um trecho de programa C# que ilustra a utilização das expressões mostradas acima.

Vamos começar implementando um método que carrega o documento XML de exemplo e aplica a primeira expressão XPath mostrada:

/PedidosItens/Pedidos

Lembre-se que essa expressão retorna um conjunto de nodos, os chamados node-sets. A Listagem 3 mostra como este método poderia ser implementado.

Listagem 3 - Método que executa uma consulta XPath que retorna um note-set (conjunto de nodos).

public void XPathExemplo1()
{
    string strArqXML = GerarXML();

    if (strArqXML.Length > 0)
    {

        XmlDocument doc = new XmlDocument();
        doc.Load(strArqXML);

        // Pesquisa os elementos "Pedidos" do documento
        XmlNodeList nodeList = doc.SelectNodes("/PedidosItens/Pedidos");
        foreach (XmlNode node in nodeList)
        {
             MessageBox.Show(node.OuterXml);
        }
    }
}

O código da Listagem 3 é bastante simples: inicialmente, um objeto da classe XmlDocument é criado e através do seu método Load(), carregamos o documento XML, passando como parâmetro o caminho onde o arquivo está localizado. Vale lembrar que, embora estejamos passando um caminho para o sistema de arquivos local, o método Load() também pode receber uma URL apontando para um recurso remoto disponível na Internet. Mais adiante neste artigo veremos como podemos acessar esse tipo de recurso.

A classe XmlDocument implementa o modelo DOM (Document Object Model) da recomendação do W3C (http://www.w3.org). Muitos desenvolvedores já estão acostumados com este modelo por já terem trabalhado com a biblioteca COM MSXML, cujo modelo DOM era implementado pelas classes MSXML.XMLDOM ou MSXML2.DOMDocument. Uma das características do modelo DOM é a de manter todo o conteúdo do documento XML em memória, o que, muitas vezes, pode trazer problemas de performance para as aplicações. A Microsoft, pensando nesta possível restrição da classe XmlDocument, criou outras classes que implementam outros modelos de processamento de documentos XML, tais como a XmlTextReader e XPathDocument. Uma análise mais aprofundada dos prós e contras de cada um dos modelos e classes disponíveis está além do escopo deste artigo. Por ora, considere a implementação com XmlDocument para o efeito da discussão sobre XPath que estamos desenvolvendo.

Seguindo com o exemplo, logo após a carga do arquivo através do método Load(), usamos o método SelectNodes() para realizar uma pesquisa no documento. Este método recebe uma expressão XPath e retorna um objeto da classe XmlNodeList. A expressão XPath utilizada no exemplo deverá retornar os três elementos "Pedidos" existentes no documento da Listagem 1. Como o objeto XmlNodeList representa um node-set, ou seja, uma coleção de nodos, podemos percorrê-lo através de uma estrutura de repetição. Cada elemento da coleção representa um nodo genérico através de um objeto da classe XmlNode. Dentro do loop, apresentamos o conteúdo de cada elemento "Pedidos" em uma caixa de mensagem por meio da propriedade "OuterXml" do objeto XmlNode. A Figura 1 ilustra a forma como uma expressão XPath aplicada ao método SelectNodes() da classe XmlDocument gera o seu resultado.


Figura 1 - Forma como funciona uma pesquisa XPath aplicada ao método SelectNodes().

A classe XmlDocument conta ainda com outro método para processamento de consultas XPath. O membro SelectSingleNode(), a exemplo de SelectNodes(), também recebe uma string XPath como argumento. A diferença entre os dois métodos é que SelectSingleNode() deve ser usado para consultas que retornem somente um único nodo e não um conjunto de nodos. Além disso, o método SelectSingleNode() retorna um objeto do tipo XmlNode diretamente, e não um objeto XmlNodeList, como acontece com SelectNodes().

Como vimos anteriormente, nem todas as expressões XPath resultam em um nodo ou conjunto de nodos. Quando valores escalares são retornados, não podemos utilizar os membros SelectNodes() e SelectSingleNodes(). Nestes casos, temos que recorrer a uma classe especial do namespace System.Xml.XPath denominada XPathNavigator. Esta classe implementa uma interface de navegação sobre os dados presentes em um documento de acordo com o modelo de dados da recomendação XPath. A Listagem 4 demonstra como a expressão abaixo pode ser avaliada com a ajuda de um objeto da classe XPathNavigator.

Listagem 4 - Para retornar valores escalares de expressões XPath, podemos usar a classe XPathNavigator.

count( /PedidosItens/Pedidos )

public void XPathExemplo2()
{
    string strArqXml = GerarXml();

    if (strArqXml.Length > 0)
    {
        XmlDocument doc = new XmlDocument();
        doc.Load(strArqXml);

        // Conta a quantidade de elementos "Pedidos" no documento.
        // Para funções que retornam escalares, temos que usar XPathNavigator
        XPathNavigator nav = doc.CreateNavigator();
        double cont = (double) nav.Evaluate("count( /PedidosItens/Pedidos )");
        MessageBox.Show(cont.ToString());
    }
}

É importante observar que o método Evaluate() retorna um objeto representando um número, booleano, string ou node-set. Os tipos respectivos são: System.Double, System.Boolean, System.String ou System.Xml.XPath.XPathNodeIterator. Sendo assim, fica a cargo do desenvolvedor realizar o casting para tipo apropriado. Neste exemplo, o retorno foi convertido para um double, já que é esperado que a expressão retorne um valor numérico para a contagem de nodos.

Através destes exemplos, fica claro que devemos estar atentos não só a forma como montamos consultas XPath, mas também em relação ao retorno gerado por cada consulta. Dependendo da situação, será necessário recorrermos a diferentes classes e métodos do .NET Framework.

Usando XPath na prática: KBALERTZ

Um recurso indispensável para os desenvolvedores Microsoft é a base de conhecimento disponizada em http://support.microsoft.com. Um serviço interessante e gratuito foi criado pelo site http://www.kzalertz.com, que envia notificações para os assinantes do seu serviço toda vez que a base de conhecimento da Microsoft sofre alteração. Mais interessante ainda é que, além da pró-atividade do serviço, o assinante pode selecionar as tecnologias sobre as quais ele quer ser notificado. O site disponibiliza uma lista das diferentes tecnologias através do endereço http://www.kbalertz.com/webmaster/TechnologyList.aspx. Cada uma delas recebe um identificador (ID). A tabela a seguir apresenta algumas tecnologias e os seus respectivos identificadores:

213

Visual C# .NET

214

Visual C++

215

Visual C++ .NET

278

Visual C++ 6.0

216

Visual FoxPro

O identificador 1 tem significado especial, que é "Todos os Produtos Microsoft". Muito bem, mas o que isso tudo tem a ver com a nossa discussão sobre XPath e XML? O que nos interessa aqui é que o site KBALERTZ disponibiliza as suas notificações através de uma página web, cuja URL é: http://www.kbalertz.com/websvc/latestkbs.aspx. Esta página recebe dois parâmetros (strings de consulta): o parâmetro "t" representa o identificador da tecnologia cujas notificações desejamos consultar. O outro parâmetro opcional - "c"- indica a quantidade de artigos a serem retornados da consulta. Esta URL (http://www.kbalertz.com/websvc/latestkbs.aspx?t=213&c=2) retornaria os últimos 2 artigos relacionados a linguagem C#. A parte relevante do documento XML retornado por essa URL na data em que este artigo foi escrito, é mostrada na Listagem 5 (note que se você for realizar a mesma consulta, poderá obter resultados diferentes do apresentado aqui):

Listagem 5 - Exemplo de documento XML retornado pelo serviço KBALERTZ. O schema foi omitido para dar mais clareza ao exemplo.

<NewDataSet>
  <!-- Schema omitido para o exemplo -->
  <Table>
    <Id>188887</Id>
    <Number>830348</Number>
    <Title>
      Buffer overrun in JPEG processing (GDI+) could allow code execution in 
      Visual Basic, Visual C#, Visual C++, Visual J# .NET, and the .NET Framework
    </Title>
    <DateEntered>2004-09-28T01:21:35.6770000-04:00</DateEntered>
    <Url>http://www.kbAlertz.com/redir.aspx?kbNumber=830348</Url>
  </Table>
  <Table>
    <Id>188849</Id>
    <Number>833987</Number>
    <Title>
      MS04-028: Buffer overrun in JPEG processing (GDI+) could allow code execution
    </Title>
    <DateEntered>2004-09-24T01:05:21.3730000-04:00</DateEntered>
    <Url>http://www.kbAlertz.com/redir.aspx?kbNumber=833987</Url>
  </Table>
</NewDataSet>

O leitor mais perspicaz conseguirá identificar que o documento da Listagem 5 foi gerado a partir de um DataSet do ADO.NET. Certamente, poderíamos utilizar um objeto da classe DataSet para carregar o documento diretamente, mas esta não é a abordagem que queremos apresentar neste artigo, já que serviços como este disponíveis na Internet são potencialmente heterogêneos e podem disponibilizar resultados incompatíveis com estruturas nativas do .NET.

Diversas consultas XPath interessantes poderiam ser feitas em um documento como esse, especialmente se os critérios de seleção determinados pelos parâmetros "t" e "c" fossem muito abrangentes. Uma requisição feita para uma URL pode gerar um retorno bastante expressivo, embora o serviço atualmente pareça limitar a consulta em 25 ocorrências. Vamos imaginar algumas dessas consultas XPath:

Localizando todos os artigos cujo título contenha a string "ADO"

/NewDataSet/Table[ contains(Title, 'ADO') ]

A função "contains" retorna um valor booleano indicando se a string passada como primeiro argumento contém a substring passada no segundo argumento. Neste caso, a string contida no valor do elemento "Title" será pesquisada quanto à existência da substring 'ADO'. Para todos os casos onde esta condição seja satisfeita, os nodos "Table" correspondentes serão retornados da expressão XPath. A Listagem 6 mostra a implementação de um método completo que recupera artigos do site KBZLERTZ e realiza a pesquisa XPath acima.

Listagem 6 - Executando consultas XPath sobre documentos XML remotos (exemplo da KBALERTZ).

public void XPathExemploKbAlertz()
{
    XmlDocument doc = new XmlDocument();
	
    // Busca os artigos mais recentes de todas as tecnologias
    doc.Load("http://www.kbalertz.com/websvc/latestkbs.aspx?t=1");
	
    // Pesquisa somente os artigos que contenham a palavra 'ADO' no título
    XmlNodeList nodeList = doc.SelectNodes("/NewDataSet/Table[ contains(Title, 'ADO') ]");
    foreach(XmlNode node in nodeList) 
    {
        MessageBox.Show(node.SelectSingleNode("Title").InnerText);
    }
}

Localizando um artigo específico através do número de artigo na base de conhecimento:

//Table[ Number = 'Q812425' ]

Neste exemplo, o elemento "NewDataSet" foi omitido e, em seu lugar, foi acrescentada uma barra normal. Toda vez que duas barras consecutivas aparecerem numa expressão XPath, significará que todos os nodos descendentes do nodo que precede as duas barras deverão ser pesquisados. Isto significa que o nodo que aparece após os caracteres "//" poderá ser filho direto, neto, bisneto ou ter qualquer outra relação de descendência com o nodo que precede os caracteres "//". No nosso exemplo, como não há elemento antecedendo os caracteres "//", assume-se que a pesquisa iniciará na raiz do documento XML. Seria possível, então, pesquisar todos os elementos "Title" do documento da Listagem 5 usando a seguinte expressão XPath:

//Title

É simples assim mesmo! A expressão acima tentará localizar qualquer elemento "Title" existente em qualquer nivel hieráquico do documento, não importando o nome do seu pai ou de nenhum outro ancestral.

É muito importante ressaltar que esta pesquisa em profundidade não tem o seu uso aconselhado em documentos muito grandes, já que ela não ajuda o processador XPath a percorrer o caminho mais otimizado dentro da estrutura do documento. O processador, no exemplo acima, terá que percorrer simplesmente todos os elementos do documento a fim de verificar quais deles denominam-se "Title". Para documentos mais simples, entretanto, esta é, obviamente, uma alternativa que, embora não muito elegante, é de rápida implemenetação. Use esta técnica sempre com bastante critério para que ela não venha a comprometer a performance das suas consultas XPath.

Com estas informações em mãos, você poderá de forma muito simples, disponibilizar os artigos do site KBALERTZ em seu próprio site ou XML Web Service. Apresentar o conteúdo dos artigos torna-se uma questão de recuperar os nodos corretos do documento XML retornado e renderizá-los na interface de usuário. A opção por fazer isto através de um parser (objeto XmlDocument, por exemplo) ou de documentos de transformação XSLT fica totalmente ao seu cirtério. O importante é saber que, de uma forma ou de outra, a tecnologia XPath desempenhará um papel fundamental na implementação da solução.

Um mundo de possibilidades

Existem outros candidados naturais a utilização de XPath atualmente. Algo que está muito em voga são os Blogs, cujo conteúdo é gerado e transmitido em documentos XML com um vocabulário especial denominado RSS (Real Simple Sindication). Documentos OPML (Outline Processor Markup Language), que são catálogos de Blogs, também são representados em formato XML e são muito úteis para o compartilhamento de listas de Blogs entre assinantes. Os casos de uso para XPath são, na realidade, muito variados hoje em dia.

Conclusão

A tecnologia XML vem gradativamente assumindo um papel cada vez mais importante na indústria de tecnologia. O fato de conseguirmos trocar informações entre sistemas heterogêneos através de uma tecnologia simples e de fácil implementação habilita uma série de negócios e cria interoperabilidade. Precisamos, de alguma forma, conseguir acessar esses dados e manipulá-los de maneira rápida e inteligente. A tecnologia XPath é, sem dúvida, a forma mais direta de realizarmos esses trabalhos. O W3C está, atualmente, trabalhando na segunda versão da linguagem XPath (XPath 2.0). Concomitantemente, o consórcio pretente lançar a recomendação definitiva para a tecnologia XQuery, uma nova linguagem que dispobilizará ainda mais benefícios para a consulta e manipulação de documentos XML e que já terá uma implementação na nova versão do banco de dados da Microsoft, o SQL Server 2005. Fique atento à evolução destas tecnologias e faça-as trabalhar cada vez mais para você.

Fabio Vazquez (fabio@serviplan.com.br) é Microsoft Most Valuable Professional (MVP) e sócio da Serviplan Serviços de Planejamento. É palestrante freqüente em eventos da Microsoft pelo Brasil, colunista da MSDN Brasil e autor de diversos artigos e dos livros "Visual FoxPro 8 para Desenvolvedores" e "Desenvolvendo Soluções XML com Visual FoxPro".


 

©2015 Microsoft Corporation. Todos os direitos reservados. Entre em contato |Nota Legal |Marcas comerciais |Política de Privacidade
Microsoft