A Microsoft vem lançando cada vez mais tecnologias, como o MVC, família Linq (Linq to SQL, Linq to XML, Linq to Entity…), Silverlight, Dynamic data, entre muitas outras do framework 3.0 e 3.5. Uma que com certeza é muito bem vinda é a Linq to XML.

O que é o Linq to XML?

O Linq to XML é uma nova forma de manipular XML que simplifica muito o desenvolvimento, seja web ou desktop. Com o VB 9.0 é possível, por exemplo, criar código XML diretamente no código (XML Literals), utilizando XElement e XDocument. O Visual Studio, com o VB9 identifica um código XML no meio do código e faz automaticamente a endentação, conforme imagem abaixo:

Imagem 01: Criando um XML diretamente no código.

Note, pela imagem 01, que apesar de não estar declarado o tipo da variável, ela não é um objeto, mas sim um XDocument (System.Xml.Linq.XDocument). Observe também que a forma com que o XML é apresentado no Visual Studio é totalmente estruturada. Não foi preciso adicionar aspas para determinar uma string. O XML está sendo escrito diretamente no código, e o Visual Studio entende que é um XML.

Bacana… Mas e se eu quiser adicionar código no meio do XML?

O Linq to XML permite adicionar código no meio do XML, utilizando o “embeded expression“. No ASP convencional era normal colocar tags “<%= (seu código) %>”. A Microsoft está utilizando esta já conhecida forma de sintaxe em basicamente quase todos novos lançamentos, como MVC, Linq, entre outros incluindo o Linq to XML.

Para representar uma função qualquer de um dado sistema, vamos criar uma função que soma duas entradas, retornando a soma como resultado.

  
Function somar(ByVal iValor01 As Integer, ByVal iValor02 As Integer) As Integer
        Return iValor01 + iValor02
    End Function

Agora vamos chamá-la no meio do XML:

   

' Exemplo de como chamar uma função no meio do XML
  Dim sSoma = <?xml version="1.0" encoding="utf-8"?>
                <exemplo>
                    <%= somar(21, 7) %>
                </exemplo>

Neste caso, o resultado da função será atribuído ao nó do XML. Note que o processo é extremamente simples e possibilita criar XML complexos com pouco esforço.

Criando um XML dinamicamente a partir de uma fonte de dados

Para criar um XML a partir de uma fonte de dados, vou utilizar um exemplo em ASP.NET. Representando a fonte de dados, vou solicitar todas as variáveis do servidor utilizando o comando “Request.ServerVariables”. Observe que poderia ser qualquer tipo de informação, inclusive uma lista genérica, collection, banco de dados, ou outra fonte de dados qualquer.

Na listagem a seguir está sendo criado um XDocument, com as variáveis do servidor. A idéia é que através da coleção “Request.ServerVariables” sejam selecionadas informações e montando um XML.

' Criando um XML a partir de uma fonte de dados
 Dim sXML = <?xml version="1.0" encoding="utf-8"?>
                <Server>
                  <%= From s In System.Web.HttpContext.Current.Request.ServerVariables _
                      Select <Variable>
                                <Chave><%= s.ToString %></Chave>
                                <Valor><%= Request.ServerVariables(s.ToString) %></Valor>
                                 </Variable> %>
                </Server>
 

Filtrando informações

Digamos que você queira filtrar a informação que fará parte do XML. O Processo também é bem simples, bastando adicionar uma cláusula “Where” depois de “From”. No exemplo a seguir estou filtrando todas as variáveis que não tenham o valor vazio (Request.ServerVariables(s.ToString) <> “”).

Criando um XML a partir de uma fonte de dados com filtro

Dim sXML = <?xml version="1.0" encoding="utf-8"?>
                   <Server>
                       <%= From s In System.Web.HttpContext.Current.Request.ServerVariables _
                           Where Request.ServerVariables(s.ToString) <> "" _
                           Select <Variable>
                                      <Chave><%= s.ToString %></Chave>
                                      <Valor><%= Request.ServerVariables(s.ToString) %></Valor>
                                  </Variable> %>
                   </Server>

Importante!

É importante notar que como qualquer outra manipulação com XML, o processo é “Case Sensitive“, ou seja, sensível à caixa alta e baixa! Para o pessoal de C# nenhuma novidade, mas para o pessoal de VB, muito cuidado!

Salvando em um arquivo .XML

Depois de criado o XDocument, é possível salvá-lo em um arquivo .XML. Para fazer isso, basta chamar o método “Save()”, passando o caminho completo como parâmetro, como no exemplo a seguir.

' Para salvar o XML em um arquivo
sXML.Save(Server.MapPath(".") & "/MeuXML.xml")

Se você abrir o arquivo XML salvo, o conteúdo será por exemplo como a seguir:

<?xml version="1.0" encoding="utf-8"?>
<Server>
  <Variable>
    <Chave>HTTP_ACCEPT_LANGUAGE</Chave>
    <Valor>pt-br</Valor>
  </Variable>
  <Variable>
    <Chave>HTTP_HOST</Chave>
    <Valor>localhost:53928</Valor>
  </Variable>
  <Variable>
    <Chave>HTTP_USER_AGENT</Chave>
    <Valor>Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.0; SLCC1; .NET CLR 2.0.50727; Media Center PC 5.0; .NET CLR 3.0.04506; .NET CLR 3.5.21022)</Valor>
  </Variable>
  <Variable>
    <Chave>HTTP_UA_CPU</Chave>
    <Valor>x86</Valor>
  </Variable>
</Server>

Carregando a partir de um arquivo XML

Carregar um arquivo “.XML” em uma variável Xdocument também é bem simples, basta utilizar o comando “Load()”, e passar o caminho completo, como por exemplo:

‘ Carregar um Xdocument a partir de um documento

Dim novoXML As XDocument = XDocument.Load(Server.MapPath(“.”) & “/MeuXML.xml”)

Uma funcionalidade excelente no Visual Studio 2008 é que se você tiver o esquema do XML, um intelisense é habilitado. O esquema do XML deve ser um arquivo “.xsd”, por exemplo:

 <?xml version="1.0" standalone="yes" ?> 
- <xs:schema id="NewDataSet" xmlns="" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
- <xs:element name="NewDataSet" msdata:IsDataSet="true" msdata:MainDataTable="Server" msdata:UseCurrentLocale="true">
- <xs:complexType>
- <xs:choice minOccurs="0" maxOccurs="unbounded">
- <xs:element name="Server">
- <xs:complexType>
- <xs:sequence>
  <xs:element name="Chave" type="xs:string" minOccurs="0" /> 
  <xs:element name="Valor" type="xs:string" minOccurs="0" /> 
  </xs:sequence>
  </xs:complexType>
  </xs:element>
  </xs:choice>
  </xs:complexType>
  </xs:element>
  </xs:schema>

Imagem 02: Intellisense é ativo no Visual Studio quando o XML carregado possui um esquema XSD.

Exibindo as informações do XDocument

Se você atribuir o XDocument a um GridView, por exemplo, você terá o seguinte resultado:

' Exibindo as variáveis
GVNomes.DataSource = sXML.Descendants("Variable")
GVNomes.DataBind() 

Imagem 03: Exibindo em um Grid View.

Se quiser trabalhar um pouco mais com as informações, além dos filtros apresentados anteriormente, um modo fácil é criar um loop de XElement pela variável XDocument. Para cada XElement pode-se trabalhar com a informação da forma que desejar.

Finalizando

Quanto mais tecnologias são lançadas, mais opções o desenvolvedor tem. É preciso sempre fazer uma análise crítica da tecnologia a ser empregada para um determinado cenário, levando em conta capacidade da equipe, investimento, servidor, manutenção, tempo de entrega, entre outros.

O Linq to XML com certeza é uma poderosa ferramenta, que abstrai grande parte do trabalho na manipulação deste tipo de arquivo.

Um bom casamento é utilizar o Linq to XML com o Silverlight, para desenvolver aplicações cada vez mais ricas. Outro bom casamento na utilização para criar Web Service personalizado adotando, por exemplo, o REST. Outro bom casamento é utilizá-lo para criação de recursos com AJAX.

É possível também criar Interfaces dinâmicas utilizando o WPF, por exemplo, escrevendo o arquivo XAML. O XML Literals inclusive possibilita a criação de templates para geração de códigos.

Se você quiser conhecer um pouco mais sobre a sintaxe do link, recomendo a leitura do artigo do meu colega José Carlos Macoratti :

https://imasters.com.br/artigo/7637/dotnet/net_linq_com_linqpad/]

Forte Abraço!