LINQ: Introdu��o � linguagem LINQ

Por que eu devo ler este artigo:O Microsoft .NET Framework incluiu a partir da vers�o 3.5 a linguagem de consulta integrada LINQ. Esta linguagem ser� demonstrada neste artigo visando o seu imediato emprego pelo programador. Uma vez que seus elementos s�o novos, ser�o demonstrados os princ�pios b�sicos para que o seu uso seja poss�vel quase que imediatamente j� simplificando as tarefas de consulta e fornecendo base para o aprofundamento posterior.

As consultas de dados usando LINQ s�o uma maneira mais f�cil de seleç�o de dados, quer estes estejam na mem�ria em coleç�es de objetos, em um banco de dados ou em um arquivo XML. Sendo integrada com o ambiente do framework, � poss�vel escrever as express�es de consulta dentro do pr�prio c�digo em C#.

Guia do artigo:

Arquitetura
Operadores
Ordenaç�o
LINQ to Objects
Consultando Bancos de Dados
LINQ to Entity
LINQ to XML
Criando o projeto
Configurando o formul�rio
Demonstrando LINQ to Objects
LINQ to Entity - Demonstrando Consulta a Banco de Dados
Configurando o formul�rio para consulta com Banco de Dados
Cliente=p.Orders.Customers.CompanyName
Consultando dados de um documento XML

As aplicaç�es modernas, principalmente usando o framework .net, necessitam de agilidade na consulta a dados. Voc� pode usar LINQ para recuperar os registros de um pedido de venda e demonstr�-los em um DataGrid, pode fazer comparaç�es entre os dados carregados na mem�ria verificando a exist�ncia de um determinado conjunto de valores ou, como tamb�m � muito comum, necessitar ler os dados de um arquivo XML no disco ou ainda, criar um arquivo para armazenar prefer�ncias do usu�rio para o seu programa. Todas estas tarefas s�o executadas mais intuitivamente com a linguagem LINQ.

Muito tem sido publicado sobre a linguagem LINQ. Entretanto, por ser uma novidade no campo das consultas, pode ser um pouco enigm�tica para quem quer começar a us�-la em seus projetos. Para voc� poder empreg�-la de maneira pr�tica e imediata, este artigo ir� passar os principais elementos, mostrando as tr�s principais divis�es que s�o: LINQ to Objects, LINQ to Entities e LINQ to XML. A primeira vers�o � usada para consultar coleç�es de dados na mem�ria. LINQ to Entity tem sido constantemente desenvolvido para ser a opç�o em uma consulta de dados armazenados em bancos de dados e finalmente, se estiver lidando com arquivo XML, voc� vai considerar LINQ to XML bem f�cil de compreender com os passos que ser�o mostrados. Para melhor entendimento ser� dado um exemplo para cada um destes tipos ap�s uma introduç�o te�rica.

A partir da vers�o 2.0 do framework foram introduzidas as coleç�es gen�ricas nos programas desenvolvidos para a plataforma .Net. Com isto, tornou-se mais �gil realizar pesquisas de dados na mem�ria uma vez que fora criada uma ferramenta para manipular listas din�micas de objetos mais facilmente. Muitos m�todos foram acrescentados e com seu constante uso, o pr�ximo passo foi surgir uma forma de simplificar ainda mais a manipulaç�o destas coleç�es de dados deixando o c�digo mais limpo e simples de entender.

� onde surge a partir da vers�o 3.5 do framework .NET a linguagem de consulta de dados integrada, que em ingl�s � Language Integrated Query, ou, LINQ para os mais �ntimos. O primeiro ponto a ser compreendido � o objetivo principal desta linguagem, que � simplesmente facilitar a manipulaç�o dos dados que estiverem em uma coleç�o. Estes podem ter sua origem em uma lista de objetos implementada atrav�s das listas din�micas ou qualquer outra classe derivada, podem ser oriundas de registros em uma tabela armazenada em um banco de dados SQL Server ou qualquer outro que seja suportado ou, ainda, serem n�s de um arquivo XML.

Qualquer que seja a origem dos dados, a manipulaç�o destes torna-se mais f�cil com o uso de LINQ. Esta linguagem est� integrada dentro do framework para que voc� possa usar diretamente junto com o seu c�digo.

Logo, para quem utiliza a linguagem C# � poss�vel inicializar diretamente uma vari�vel com os resultados de uma consulta. Para começar a entender voc� precisa estar familiarizado com as novidades introduzidas na linguagem C# 3.0, destacando:

Tipos e m�todos an�nimos;
Vari�veis tipadas conforme a express�o, ou, declaraç�o da vari�vel sem definir o tipo, utilizando a palavra reservada var. O tipo ser� dado pela express�o que estar� iniciando o valor para a vari�vel;

Inicializadores diretos para objetos e coleç�es. Em vez de usar a seguinte sintaxe:

  
Point Ponto = new Point();
  Ponto.X = 0;
  Ponto.Y = 0;

Voc� pode usar o seguinte c�digo:

  Point P = new Point 
  {
    X = 0,
    Y = 0
  };

A mesma coisa pode ser feita com as listas an�nimas:


List<Point> ListaDePontos = new List<Point> 
  {
    new Point { X = 0, Y = 0 },
    new Point { X = 2, Y = 1 },
    new Point { X = 4, Y = 3 }
  };

Lambda expressions, embora seja poss�vel utilizar LINQ sem este novo recurso.

Arquitetura da linguagem

LINQ est� integrada com o framework e possui diversas variaç�es, sendo cada uma apropriada para um uso. A Figura 1 mostra a arquitetura desta linguagem.

Figura 1. Arquitetura da linguagem LINQ.

Basicamente esta linguagem est� voltada para tr�s grandes fontes de dados que s�o, conforme exposto, coleç�es de objetos na mem�ria, dados provenientes de bancos de dados relacionais e dados armazenados em arquivos XML. Neste artigo descreverei as tr�s principais subdivis�es desta linguagem conforme j� colocado anteriormente, por�m, antes disto, veremos os elementos comuns a todas elas.

Sintaxe b�sica de uma consulta com LINQ

A sintaxe b�sica do LINQ � a seguinte:

  
var <vari�vel> = from <elemento da lista> in <lista de dados>
   where <cl�usula/cl�usulas de consulta>
   select <elemento>

Onde temos os seguintes elementos:

var: identificador din�mico do tipo de dados que ser� retornado. Uma consulta feita com LINQ retorna uma coleç�o de objetos do tipo System.Collections.Generic.IEnumerable<T>. O uso de �var� indica que o tipo da vari�vel resultante ser� do mesmo tipo usado para a lista de dados consultada;
<vari�vel>: nome do objeto que receber� o resultado da pesquisa;
from: indica a origem dos dados sendo que <elemento da lista> ser� o nome dado para cada inst�ncia da mesma. Por exemplo, se tivermos uma lista de strings, poderemos chamar de str. Cada um dos elementos ser� do tipo dos dados dentro da lista;
in: define a lista de origem. Pode ser qualquer coleç�o de dados como um array ou um List<T>;
<lista de dados>: coleç�o dos dados a serem consultados. Como veremos adiante pode ser qualquer lista de dados na mem�ria quer sejam dados provenientes de um array de objetos, dados armazenados em tabelas de um banco de dados ou arquivos XML;
where: filtro para os dados. Esta cl�usula pode usar os operadores de comparaç�o existentes na linguagem C# como ser� demonstrado mais � frente;
select: executa a seleç�o armazenando os resultados. � atrav�s desta instruç�o que os dados s�o devolvidos para serem utilizados pelo c�digo do programa.

Operadores de comparaç�o

A cl�usula where aceita v�rios operadores de comparaç�o, a Tabela 1 demonstra os principais. Os sinais como, por exemplo, �==� e �!=� s�o exclusivos para o C# sendo que se voc� for usar outra linguagem precisar� usar os sinais pr�prios dessa linguagem. J� aqueles baseados em funç�es s�o equivalentes tanto para C# como para VB.NET por exemplo.

Operador	Funç�o
==	Usado para igualdade entre dois elementos.
>=	Maior ou igual.
<=	Menor ou igual.
!=	Diferença.
!	Operador not pode ser usado em conjunto com outros operadores como o Contains.
&&	E (and) l�gico.
\|\|	Ou (ou) l�gico.
StartsWith()	Aplicado quando se deseja comparar o in�cio de uma express�o do tipo string.
EndsWith()	Usado para comparar o final de uma express�o do tipo string.
Contains()	Verifica se o valor est� dentro de qualquer ponto de um valor do tipo string.

Tabela 1. Principais operadores de comparaç�o.

Lembrando de que estes s�o os principais. Voc� pode usar estes operadores em conjunto e ainda usar m�todos an�nimos e lambda expressions para criar seus filtros personalizados.

Nota: Para mantermos o artigo objetivo n�o irei aprofundar nas extens�es que podem ser feitas com LINQ. Consultas usando lambda expressions e m�todos an�nimos ser�o deixadas para um artigo futuro. Procure compreender as bases da linguagem e começar a usar com os exemplos que ser�o dados. Informe-se sobre estes recursos assim que estiver dominando os elementos mais b�sicos.

Uma opç�o de consulta que merece destaque com LINQ � que voc� pode comparar e selecionar apenas o texto a partir de um determinado tamanho atrav�s da propriedade Length. Uma consulta com este tipo de crit�rio seria feita da seguinte forma:

  
string[] nomes = { �Maria�, �Jo�o�, �Marcos�, �Paulo�, �Alexandre� };
   
  var selecao = from nome in nomes
    where nome.Length > 4
    select nome;

Quando voc� começa a utilizar LINQ para os seus trabalhos, logo percebe que se trata de uma ferramenta poderosa, cheia de recursos e com um alto grau de extensibilidade. Al�m disto, � a base para os pr�ximos passos a serem dados.

Ordenaç�o dos resultados

A ordenaç�o dos elementos � feita com a declaraç�o orderby seguida do elemento que ir� fazer a ordenaç�o. Caso se deseje uma ordenaç�o descendente basta usar ap�s o elemento de ordenaç�o a palavra descending. O exemplo a seguir ordena um vetor num�rico de maneira descendente:

  
int[] numeros = { 3, 9, 0, 50, 3};
   
  var x = from n in  numeros
  orderby n descending
  select n;

LINQ to Objects

Esta � a vers�o que � usada para filtrar dados que est�o na mem�ria. Basicamente qualquer tipo de coleç�es de dados que implemente a interface IEnumerable<T> pode ser filtrada com LINQ. Assim, voc� ir� fazer suas consultas sobre as seguintes coleç�es de dados:

Arrays;
Listas gen�ricas de dados � implementadas com List<T>;
Strings � � poss�vel fazer uma consulta sobre uma �nica string para, por exemplo, extrair determinada palavra;
Dicion�rios gen�ricos de dados.

Consultando Bancos de Dados

A maior parte das aplicaç�es empresariais trabalha intensivamente com bancos de dados. Logo, se voc� est� aprendendo a utilizar uma ferramenta de programaç�o nova, seu principal interesse recai em como esta poder� ser �til nas tarefas mais corriqueiras. Basicamente voc� vai procurar se informar como poder� usar LINQ em uma situaç�o do mundo real. Uma boa not�cia para os programadores corporativos � que agora vai ser poss�vel manter o acesso aos dados mais pr�ximo do grau de abstraç�o atingido com C# e mais amplamente com as linguagens orientadas a objeto.

Para poder demonstrar isto um pouco melhor considere uma situaç�o bastante corriqueira. Tome por exemplo a tabela Orders do banco de dados Northwind. A Tabela 2 demonstra a estrutura dos campos da tabela.

Nome da Coluna	Tipo de Dados
OrderID	Int
CustomerID	nchar(5)
EmployeeID	Int
OrderDate	Datetime
RequiredDate	Datetime
ShippedDate	Datetime
ShipVia	Int
Freight	Money
ShipName	nvarchar(40)
ShipAddress	nvarchar(60)
ShipCity	nvarchar(15)
ShipRegion	nvarchar(15)
ShipPostalCode	nvarchar(10)
ShipCountry	nvarchar(15)

Tabela 2. Estrutura da Tabela Orders do Banco de Dados Northwind.

Se voc� precisar executar a tarefa simples de listar todas as vendas que foram feitas a partir de uma determinada data, voc� precisaria resolver os seguintes problemas:

Estabelecer uma conex�o com o banco de dados, cuidando para que fosse uma conex�o v�lida;
Configurar um objeto, provavelmente um SqlCommand que est� dispon�vel no ADO.NET, para usar esta conex�o;
Escrever uma consulta usando a linguagem SQL tomando o cuidado de informar os nomes corretos para as tabelas e para os campos da mesma;
Se estiver fazendo uma consulta din�mica, precisar� tomar cuidado com os par�metros passados para evitar problemas de segurança como ataques de SQL Injection;
Ler os dados que forem retornados e mostrar para o usu�rio novamente tomando o cuidado de usar os nomes corretos para os campos e principalmente verificar os tipos de dados retornados.

Apenas a t�tulo de exemplo, se isto fosse feito em um programa do tipo console, o c�digo ficaria mais ou menos parecido com o da Listagem 1.

Listagem 1. Consultando a tabela Orders.


 using System;
 using System.Data.SqlClient;
 
 public class Class1
 {
    public static void Main( string[] args )
    {
       // define o objeto de conex�o com o banco de dados
       using (SqlConnection SqlCon =
         new SqlConnection(
            "Data Source=vladimir-note;Initial Catalog=Northwind;Integrated Security=True" ))
      {
         // define o objeto que far� a consulta
         using (SqlCommand SqlCmd = new SqlCommand
         {
            Connection = SqlCon,
            CommandText = @"
               select * from orders
               where orderDate >= @orderDate"
         })
         {
            // configuraç�o do par�metro passado
            DateTime orderDate = new DateTime(1990,1,1);
            // envia o par�metro � consulta
            SqlCmd.Parameters.AddWithValue("@orderDate", orderDate);
            // abre a consulta com o banco de dados
            SqlCon.Open();

            // recebe os registros passados pela consulta
            using (SqlDataReader dr = SqlCmd.ExecuteReader())
            {
               // percorre e imprime os registros
               while (dr.Read())
                  Console.WriteLine( "\t{1:dd/MM/yyyy}\t{2:C}", 
                     dr["OrderID"],
                     dr["OrderDate"],
                     dr["Freight"]);
            }

            // fecha a conex�o com o banco de dados
            SqlCon.Close();
         }
      }
   }
}

Um pouco extenso n�o achou? Mas analisando o c�digo percebemos que os elementos vistos anteriormente, para a soluç�o do problema (consultar a tabela �Orders�) est�o todos ali. Da linha 1 at� a 7 temos os elementos comuns para uma aplicaç�o do tipo console. Acrescentamos apenas a biblioteca System.Data.SqlClient para poder usar as classes para manipulaç�o de dados do ADO.NET, que fazem a ponte entre o .NET e o banco de dados.

Na linha 9 cria-se a inst�ncia do objeto para conex�o com o banco de dados passando a string de conex�o e abaixo, na linha 14 � definido um objeto SqlCommand contendo a instruç�o SQL que ir� executar a consulta. Mais � frente, na linha 23 eu crio uma vari�vel do tipo DateTime para poder passar os par�metros para a consulta na linha 25. Seguindo em frente abrimos a conex�o com o banco de dados (linha 27) e nas pr�ximas linhas exibimos o conte�do dos campos.

Nota: Se voc� j� utiliza C# e o Visual Studio h� algum tempo, deve concordar comigo que este trabalho pode ser feito utilizando-se os datasets tipados com os componentes do tipo TableAdapter, fazendo este trabalho mais facilmente. Entretanto, mesmo usando este tipo de abordagem, o Visual Studio cria um c�digo muito parecido com este apresentado aqui.

Eu gostaria de chamar a atenç�o para alguns aspectos deste tipo de c�digo. Primeiramente, perdeu-se um pouco da abstraç�o fornecida pelas linguagens orientadas a objeto quando se escreveu a instruç�o SQL nas linhas 18 e 19. � muito dif�cil fazer o mapeamento objeto-relacional quando se est� lidando com bancos de dados relacionais e isso faz com que o c�digo do programa contenha partes orientadas a objeto e parte destinada a lidar com as tabelas no banco.

Nota do DevMan

Mapeamento objeto-relacional � o nome que se d� � tarefa de fazer a ponte entre tabelas de um banco de dados relacional e objetos de sistema. A maneira mais simples de se realizar isso � definir que toda tabela se torne uma classe de neg�cio, por�m existem situaç�es no lado orientado a objetos que s�o dif�ceis de se aplicar, ou simplesmente n�o existem no mundo relacional. Herança � um exemplo. Essa falta de compatibilidade entre as duas tecnologias � chamada de imped�ncia objeto relacional. Para suprir essa falta v�rios frameworks foram desenvolvidos, os chamados ORM (Object Relational Mapper). Estes oferecem recursos para facilitar o mapeamento de classes para tabelas e vice-versa. Dentre os existentes, merecem destaque o NHibernate e o recente Entity Framework da Microsoft.

A instruç�o SQL tem como desvantagem n�o poder ser verificada em tempo de compilaç�o. Se por um acaso estiver incorreta, somente ser� percebido o erro em tempo de execuç�o. Tamb�m n�o se consegue verificar os nomes dos elementos envolvidos na instruç�o SQL at� se executar o programa e a validaç�o dos tipos dos par�metros e dos dados retornados s� ser� feita durante a execuç�o do programa. O modelo usado atualmente para manipular dados oferece alguns avanços mas, deixa a desejar nos pontos citados. Nesta brecha � que surge a linguagem LINQ. Mas n�o iremos utiliz�-la diretamente conectada ao banco de dados. Para isso adicionaremos um elemento que ir� fazer o mapeamento objeto-relacional.

ADO.NET Entity Framework e LINQ to Entity

Antes de continuar d� uma boa olhada na Figura 1. Para utilizar LINQ com banco de dados temos que compreender um pouco do ADO.NET Entity Framework. Como foi colocado anteriormente, usa-se LINQ para fazer consultas de coleç�es de objetos na mem�ria e, para poder utilizar a linguagem com dados vindos de bancos de dados, os objetos do banco precisam estar mapeados como classes dentro do projeto. E � neste ponto que um novo elemento torna-se presente. Este � o objetivo das bibliotecas do ADO.NET Entity Framework.

Com o conjunto de bibliotecas e classes presentes neste framework, voc� poder� mapear qualquer banco de dados que possua um provider desenvolvido para ele. O papel de ADO.NET Entity Framework � integrar o banco de dados e permitir o acesso representando tabelas como classes e registros como coleç�es de dados na mem�ria. O mapeamento pode ser feito tanto visualmente como via c�digo, embora voc� ir� preferir fazer da primeira forma. Mas, mesmo com as facilidades para a geraç�o das classes vinculadas com o banco de dados, estas s�o geradas no projeto como partial class, sendo assim, voc� pode adicionar funcionalidades editando os arquivos das classes para customizar seu comportamento.

Durante o mapeamento objeto-relacional n�o s� as tabelas e seus campos s�o codificados para o seu projeto bem como os relacionamentos existentes entre estas tabelas s�o mapeados, ficando tudo mais f�cil de utilizar e compreender, inclusive com uma representaç�o visual destes relacionamentos.

As tabelas mapeadas no projeto com o Entity Framework s�o armazenadas em um arquivo com a extens�o .edmx e podem ser visualizadas na Figura 2. Note os relacionamentos entre as tabelas Products, Categories e Order Details.

Figura 2. Visualizando tabelas mapeadas no projeto.

Todo o c�digo necess�rio para consultar estas tabelas � gerado automaticamente no projeto, inclusive voc� pode visualiz�-lo abrindo o arquivo de designer (extens�o .designer.cs na janela Solution Explorer). A Listagem 2 mostra uma parte deste c�digo.

Listagem 2. C�digo gerado pelo Entity Framework para mapeamento objeto-relacional.


     /// <summary>
         /// There are no comments for NorthwindModel.Categories in the schema.
         /// </summary>
         /// <KeyProperties>
         /// CategoryID
         /// </KeyProperties>
         [global::System.Data.Objects.DataClasses.EdmEntityTypeAttribute(NamespaceName="NorthwindModel", Name="Categories")]
         [global::System.Runtime.Serialization.DataContractAttribute(IsReference=true)]
         [global::System.Serializable()]
         public partial class Categories : global::System.Data.Objects.DataClasses.EntityObject
         {
             /// <summary>
             /// Create a new Categories object.
             /// </summary>
             /// <param name="categoryID">Initial value of CategoryID.</param>
             /// <param name="categoryName">Initial value of CategoryName.</param>
             [global::System.CodeDom.Compiler.GeneratedCode("System.Data.Entity.Design.EntityClassGenerator", "4.0.0.0")]
             public static Categories CreateCategories(int categoryID, string categoryName)
             {
                 Categories categories = new Categories();
                 categories.CategoryID = categoryID;
                 categories.CategoryName = categoryName;
                 return categories;
                }
                ...

Na Listagem 2 vemos parte do c�digo utilizado para a tabela Categories. Este c�digo � gerado automaticamente pelo compilador e dificilmente voc� precisar� fazer alguma manutenç�o. Coloquei aqui somente para que voc� entenda que o Entity Framework representa apenas uma camada de abstraç�o adicionada ao projeto para que seja poss�vel trabalhar com os dados de uma maneira mais vinculada com a sintaxe da linguagem C# (ou a que voc� estiver usando em seu projeto), al�m de fazer todo o trabalho para que usando LINQ sejam poss�veis v�rias consultas, inclusive relacionamentos existentes entre as tabelas. Ser� poss�vel fazer as tradicionais operaç�es de inclus�o, atualizaç�o e exclus�o de registros no banco de dados, pois estas capacidades s�o suportadas por instruç�es espec�ficas. No exemplo que ser� constru�do mostrarei como fazer o mapeamento das tabelas no seu projeto e tamb�m alguns exemplos de consultas com LINQ to Entity.

Nota do DevMan

Voc� j� deve ter ouvido falar de outra opç�o para utilizar LINQ com banco de dados chamada LINQ to SQL. Esta forma permite apenas conex�es com bancos de dados SQL Server e Sql Server Compact. Apesar de apresentar v�rias otimizaç�es para este banco de dados, n�o irei tratar da mesma aqui para n�o prolongar demais. Por outro lado, este tipo de acesso tem sido pouco encorajado quanto ao uso pela comunidade de desenvolvedores por existirem rumores de que n�o ser� inclu�do em vers�es futuras do .NET Framework

LINQ to XML

Nos trabalhos de desenvolvimento de software cedo ou tarde precisaremos trabalhar com arquivos XML. Quer seja para armazenar dados de configuraç�es de suas aplicaç�es, quer seja para permitir o interc�mbio de dados entre programas distintos destacando-se o seu uso intensivo em Web Services, os arquivos XML s�o largamente empregados em qualquer plataforma.

O .NET framework proporciona a biblioteca System.Xml que � baseada em DOM (Document Object Model) para representar os documentos XML. Esta biblioteca representou v�rios avanços na manipulaç�o deste tipo de arquivo e certamente, muitas aplicaç�es j� utilizam estas funcionalidades.

Entretanto, LINQ to XML pretende trazer a manipulaç�o destes arquivos para um n�vel ainda mais intuitivo, como faz com objetos na mem�ria. Vamos fazer uma comparaç�o. Vamos gerar um documento XML utilizando os recursos dispon�veis no System.Xml e em seguida, demonstrar esta mesma operaç�o feita com LINQ to XML. Considere o arquivo XML da Listagem 3.

Listagem 3. Arquivo XML.


  <artigos>
   <titulo>Introduç�o � linguagem LINQ</titulo>
   <subtitulo>Compreendendo LINQ para sua imediata aplicaç�o</subtitulo>
   <autor>Vladimir Rech</autor>
   <revista>Dot Net Magazine</revista>
   <editora>Dev Media</editora>
 </artigos>

Para criarmos este arquivo usando a biblioteca System.Xml e escrevermos o seu conte�do na tela de um programa console, o c�digo seria parecido com o da Listagem 4.

Listagem 4. Usando System.Xml para criar o arquivo XML.


       // declara o documento
       XmlDocument doc = new XmlDocument();
       // cria os n�s
       XmlElement artigos = doc.CreateElement("artigos");
       XmlElement titulo = doc.CreateElement("titulo");
       // inclui o conte�do
       titulo.InnerText = "Introduç�o � linguagem LINQ";
       XmlElement subtitulo = doc.CreateElement("subtitulo");
       subtitulo.InnerText = "Compreendendo LINQ para sua imediata aplicaç�o";
      XmlElement autor = doc.CreateElement("autor");
      autor.InnerText = "Vladimir Rech";
      XmlElement revista = doc.CreateElement("revista");
      revista.InnerText = "Dot Net Magazine";
      XmlElement editora = doc.CreateElement("editora");
      editora.InnerText = "Dev Media";
      // envia os n�s para o arquivo
      artigos.AppendChild(titulo);
      artigos.AppendChild(subtitulo);
      artigos.AppendChild(autor);
      artigos.AppendChild(revista);
      artigos.AppendChild(editora);
      doc.AppendChild(artigos);
      // objeto para escrever o conte�do
      XmlTextWriter writer = new XmlTextWriter(Console.Out);
      writer.Formatting = Formatting.Indented;
      doc.WriteContentTo(writer);

Analisando rapidamente o c�digo voc� percebe que precisa declarar cada elemento expressamente e ainda cuidar da hierarquia do documento. Agora, vejamos como isso seria feito com o uso de LINQ (Listagem 5).

Listagem 5. Criando o arquivo com LINQ to XML.


       // declara o arquivo xml
       var xml = new XElement("artigos",
          new XElement("titulo", "Introduç�o � Linguagem LINQ to XML"),
          new XElement("subtitulo", "Compreendendo LINQ para sua imediata aplicaç�o"),
          new XElement("autor", "Vladimir Rech"),
          new XElement("revista", "Dot Net Magazine"),
          new XElement("editora", "Dev Media"));
       // escreve o conte�do na tela   
       Console.WriteLine(xml);

Acredito que n�o preciso fazer nenhum coment�rio. Qual das duas implementaç�es voc� prefere?

A linguagem LINQ se baseia nos mesmos princ�pios DOM para a modelagem, entretanto, oferece uma implementaç�o mais intuitiva a partir de v�rios elementos, com os quais podemos criar os n�s, elementos, atributos, coment�rios e tudo o mais que faz parte destes elementos. Vejamos quais os principais m�todos de LINQ to XML para criar o arquivo:

XName: � usado para criar uma identificaç�o para o namespace do XML. � usado tanto para um elemento como para um atributo;
XNode: representa o n� dentro da �rvore do documento XML. � usado como uma classe base para os elementos: XComment, XContainer, XDocumentType, XProcessingInstruction e XText;
XContainer: derivado de XNode, disponibiliza caracter�sticas e funcionalidades como subelementos de um n� XML, � tamb�m a base para as pesquisas pelos n�s XML e para XDocument e XElement;
XDocument: representa um documento XML que cont�m os principais elementos do documento como a declaraç�o do tipo do documento (XDocumentType), um elemento raiz (XElement) e podendo ter opcionalmente coment�rios (XComment);
XElement: � o tipo fundamental para construç�o de um documento XML devendo ter um XName e opcionalmente um ou mais atributos, podendo ter ou n�o algum conte�do;
XAttribute: � usado para criar atributos que s�o elementos que possuem uma chave associada a um elemento. N�o s�o n�s XML mas est�o vinculados dentro destes;
XComment: � usado para fazer coment�rios em um n� do documento XML.

A criaç�o dos documentos XML com LINQ � bem facilitada e, embora os exemplos aqui apresentados sejam bem simples, estes podem se tornar complexos conforme a necessidade e a complexidade do documento XML a ser criado. Da mesma forma, a consulta de dados do arquivo XML � bastante simplificada com LINQ. Considere novamente o documento XML da Listagem 3. Para consultar os dados, considerando-se a sintaxe b�sica da consulta, seria da seguinte forma:

  
from <variavel> in <origem>.Element(<elemento a ser recuperado do arquivo>)
  select (<tipo>)<variavel>.Element(<nome do elemento>)

Sendo que voc� pode usar este c�digo para, por exemplo, preencher os dados de uma classe pr�-definida.

Criando o projeto

Para executar os exemplos deste artigo eu utilizei os seguintes recursos (voc� vai encontrar no final uma seç�o com links para fazer downloads dos programas usados):

Visual Studio 2010. Mas voc� poder� executar o exemplo tamb�m com outras vers�es, inclusive vers�es Express;
Microsoft Sql Server 2008 Express Edition;
Banco de dados demonstraç�o Northwind. Este � um banco de dados disponibilizado pela Microsoft para que sejam demonstradas as caracter�sticas do Sql Server.

Os exemplos a serem desenvolvidos ser�o feitos em um projeto do tipo Windows Forms. Neste projeto teremos tr�s abas distintas onde cada uma ser� usada para demonstrar um tipo espec�fico do LINQ. Abra o Visual Studio e crie um novo projeto do tipo Windows Forms usando a linguagem Visual C# e com o Framework 3.5. Para criar o projeto use o menu File>New>Project. A Figura 3 demonstra a janela onde voc� ir� definir o nome do projeto e escolher as opç�es de criaç�o do mesmo.

Figura 3. Janela para criaç�o do novo projeto.

Configurando o formul�rio

O projeto � criado com um formul�rio principal j� adicionado. Ajuste as propriedades do formul�rio da seguinte forma: Size para 640;480 e Text para LINQ Demo. Arraste um componente TabControl para o formul�rio. Acrescente uma p�gina para que o controle fique com tr�s TabPages. A propriedade Dock do controle TabControl deve ser ajustada para Fill.Veja na Figura 4 como deve parecer.

Figura 4. Formul�rio com as Tab Pages.

Demonstrando LINQ to Objects

Na primeira aba do formul�rio ser� demonstrado o uso de LINQ to Objects consultando uma lista de alguns dos estados brasileiros. Arraste os componentes para o formul�rio como na Figura 5 e verifique as propriedades de cada componente na Tabela 3.

Figura 5. Configurando a primeira aba do formul�rio.

Componente	Propriedade	Valor
List Box	(Name)	lstDados
Group Box	(Name)	groupBox1
Radio Button	(Name)	rbPesquisarTexto
	Text	Pesquisar parte do texto
	Checked	True
Radio Button	(Name)	rbNumeroDeLetras
Radio Button	Text	Numero de Letras
Text Box	(Name)	txtPesquisa
Button	(Name)	btnExecutar
Button	Text	Executar
List Box	(Name)	lstResultado

Tabela 3. Configurando os componentes da tela.

A pesquisa ir� funcionar da seguinte forma: no componente ListBox denominado lstDados iremos manter uma lista com alguns estados do Brasil. A pesquisa poder� listar somente os estados com um n�mero de letras maior ou igual ao que for digitado no componente TextBox denominado txtPesquisa, se o componente RadioButton selecionado for rbNumeroDeLetras. Caso o RadioButton selecionado seja rbPesquisarTexto, a pesquisa a ser feita ser� verificar se algum estado da listagem possui (cont�m) parte do texto digitado. O primeiro passo � criar a lista dos estados. Exiba o c�digo fonte do formul�rio pressionando a tecla F7. Logo ap�s a declaraç�o da classe do formul�rio, acrescente o c�digo da Listagem 6.

Listagem 6. Criando a lista de estados.


       using System;
       using System.Windows.Forms;
       using System.Linq;
       
       namespace DemoLINQ
       {
          public partial class Form1 : Form
          {
             string[] ListaDeEstados = { "Paran�", "Santa Catarina", "Rio Grande Do Sul", "S�o Paulo",
                                         "Rio de Janeiro", "Minas Gerais", "Esp�rito Santo", "Bahia",
                                         "Sergipe", "Para�ba", "Cear�" };
      ...

Esta Listagem 6 demonstra o in�cio da declaraç�o da classe para o formul�rio. Ap�s a declaraç�o das principais bibliotecas usadas (linha 1 at� a 3), na linha 5 temos a declaraç�o do namespace usado no programa. Na linha 7, a declaraç�o da classe do formul�rio. Note que ele deriva da classe base Form. Na linha 9 criei um array de strings com alguns estados do Brasil, fique � vontade para incluir mais para tornar o exemplo mais interessante. Para popularmos o componente ListBox de forma que exiba estes estados, vamos acrescentar um c�digo para ser executado ao entrarmos na primeira TabPage. Selecione esta p�gina no designer do formul�rio, pressione F4 para exibir as propriedades. Exiba os eventos e d� um clique duplo sobre o evento Enter, escrevendo em seguida o c�digo da Listagem 7.

Listagem 7. Populando o componente ListBox com os estados.


private void tabPage1_Enter( object sender, EventArgs e )
{
   // popula os dados para a pesquisa com LINQ to Objects
   lstDados.DataSource = ListaDeEstados;
}

O c�digo a ser escrito consiste em passar o array ListaDeEstados para a propriedade DataSource do componente ListBox (linha 20). D� um clique duplo sobre o componente btnExecutar e escreva o c�digo da Listagem 8 para definir o que ser� feito ao executar a consulta.

Listagem 8. C�digo que executa a consulta.


private void btnExecutar_Click( object sender, EventArgs e )
{
   // executa a consulta
   if (rbNumeroDeLetras.Checked)
   {
      // pesquisa pelo tamanho da palavra
      var Resultado = from s in ListaDeEstados
                      where s.Length >= int.Parse( txtPesquisa.Text )
                      select s;

      // popula a list box com o resultado
      lstResultado.DataSource = Resultado.ToList();
   }
   else
   {
      // pesquisa pela palavra digitada
      var Resultado = from s in ListaDeEstados
                      where s.ToUpper().Contains(txtPesquisa.Text.ToUpper())
                      select s;
      // popula a list box com o resultado
      lstResultado.DataSource = Resultado.ToList();
   }
}

Para executar a consulta apropriada, verificando o n�mero de letras ou se o estado cont�m o texto digitado, iniciamos a rotina verificando se o componente RadioButton rbNumeroDeLetras est� selecionado (linha 26). Caso esteja, a pesquisa a ser executada � aquela que verifica o tamanho das palavras comparando-o com o que foi passado. Na linha 30 comparamos a propriedade Length com o valor que foi digitado no componente TextBox fazendo a convers�o do valor. Os resultados encontrados s�o passados para a vari�vel Resultado (linha 29) e enviados como data source para o ListBox lstResultado. Caso o RadioButton selecionado seja aquele que indica a pesquisa de parte do nome, ent�o, a partir da linha 39 verificamos se algum dos nomes cont�m o conte�do que foi digitado (linha 40). Note que � feita uma convers�o do conte�do para mai�scula, pois as consultas fazem diferenças entre mai�sculas e min�sculas.

Nota: Observe que n�o fiz nenhum tipo de tratamento de erro, isto, para manter o c�digo sucinto. Quando estiver trabalhando em projetos do mundo real voc� precisar� verificar se um n�mero v�lido foi digitado, caso contr�rio, o sistema ir� gerar uma exceç�o quando encontrar algum valor inv�lido.

Execute o projeto pressionando a tecla F5. Voc� deve obter um resultado parecido com o da Figura 6.

Figura 6. Consultando lista de objetos.

LINQ to Entity - Demonstrando Consulta a Banco de Dados

O pr�ximo passo na demonstraç�o � consultar dados armazenados no banco Northwind do SQL Server. Para efeitos de objetividade, n�o vou demonstrar como instalar este banco e no final do artigo coloquei o endereço para voc� fazer o download da instalaç�o. Na nossa demonstraç�o iremos fazer tr�s tipos de consulta, uma demonstrando todos os clientes da tabela de clientes, uma segunda mostrando todas as vendas que possuam produtos acima de um determinado valor e outra listando as vendas com os nomes dos clientes.

Começamos fazendo o mapeamento das tabelas Orders, Customers, Products e OrdersDetails no projeto usando ADO.NET Entity Framework. Na janela Solution Explorer clique com o bot�o direito do mouse sobre o �cone do projeto e escolher Add > New Item. Na janela que se abre escolha o item ADO.NET Entity Data Model e nomeie como Northwind.edmx. Voc� pode escolher entre gerar um modelo vazio ou a partir de um banco de dados existente, que � o nosso caso. Na pr�xima janela (Figura 7) escolha o item Generate from database e clique no bot�o Next.

Figura 7. Escolhendo o tipo do Data Model.

Voc� precisa informar como se conectar ao banco de dados. Na pr�xima janela clique no bot�o New Connection para configurar a conex�o com o banco de dados (Figura 8).

Figura 8. Janela para conex�o com o banco de dados.

Escolha o servidor apropriado atrav�s do campo Server name. Informe o seu tipo de autenticaç�o e selecione o nome do banco de dados, no caso do nosso exemplo, Northwind. Os detalhes est�o na Figura 9.

Figura 9. Configurando a conex�o com o banco de dados.

A pr�xima etapa � selecionar quais objetos do banco de dados ser�o mapeados atrav�s da janela Chose Your Database Objects (Figura 10). Expanda o item Tables e escolha as tabelas Customers, Order Details, Orders e Products. Clique no bot�o Finish para concluir a tarefa.

Figura 10. Escolhendo as tabelas do banco de dados.

Nesta figura voc� ainda pode decidir se vai querer que ao mapear as tabelas para classes, no seu projeto os nomes sejam modificados para o plural ou sejam mantidos exatamente como est�o no banco de dados. Isso � feito atrav�s do campo Pluralize or singularize generated object names. Verifique como fica mais interessante para voc�. No caso da demonstraç�o estou mantendo como veio do banco. � ainda poss�vel que voc� personalize o nome do namespace a ser utilizado para referenciar as classes criadas no campo Model Namespace. Depois de conclu�dos estes passos o Visual Studio exibe o modelo visual, como na Figura 11.

Figura 11. Visualizaç�o do Entity Model do projeto.

Observe que os relacionamentos existentes entre as tabelas j� est�o demonstrados no modelo. Note tamb�m que a tabela Order Details por possuir um caractere de espaço no seu nome, teve de ser renomeada para Order_Details. Uma quest�o importante � saber onde fica armazenada a conex�o com o banco de dados. Este ficar� no arquivo App.Config que fica na pasta junto com os fontes do projeto. Este arquivo � convertido para <NomeDoExecut�vel>.config na pasta bin\debug ou bin\release ap�s o projeto compilado e � um arquivo do tipo XML que pode ser editado para personalizar a localizaç�o do banco de dados a ser usado no ambiente de produç�o. A Listagem 9 mostra um exemplo deste arquivo.

Listagem 9. Arquivo App.Config.


<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <connectionStrings>
    <add name="NorthwindEntities" connectionString="metadata=res://*/NorthWind.csdl|res://*/NorthWind.ssdl|res://*/NorthWind.msl;provider=System.Data.SqlClient;provider connection string="Data Source=vladimir-note;Initial Catalog=Northwind;Integrated Security=True;MultipleActiveResultSets=True"" providerName="System.Data.EntityClient" />
  </connectionStrings>
</configuration>

Configurando o formul�rio para consulta com Banco de Dados

Abra o design do formul�rio que estamos trabalhando e selecione a segunda aba. Adicione e configure os componentes configurando como demonstrado na Tabela 4 e os organize como mostra a Figura 12.

Componente	Propriedade	Valor
Label	Text	Clientes (Customers)
Combo Box	(Name)	cmbCustomers
Combo Box	DropDownStyle	DropDownList
Label	Text	Preço Unit�rio
TextBox	(Name)	txtPrecoUnitario
Button	(Name)	btnVendasPorCliente
Button	Text	Vendas por Cliente
Button	(Name)	btnFiltrarPeloPreco
Button	Text	Filtrar pelo Preço
Label	Text	Resultado
DataGridView	(Name)	grdResultado

Tabela 4. Componentes da aba LINQ to Entity.

Figura 12. Alinhamento dos controles.

Nesta janela o controle cmbCustomers listar� todos os clientes cadastrados. Ent�o, vamos escrever um c�digo para assim que entrarmos nesta aba, este controle tenha os dados preenchidos. Selecione o controle tabPage2, que foi onde acabamos de configurar os controles, e na janela Properties d� um duplo clique no evento Enter. Escreva o c�digo como na Listagem 10.

Listagem 10. Populando o controle de clientes.


// evento disparado ao entrar na tabPage
      private void tabPage2_Enter( object sender, EventArgs e )
      {
         // configura o datamodel
         NorthwindEntities nwModel = new NorthwindEntities();
         // faz a consulta
         var Customers = from c in nwModel.Customers
                         select c;
         // configura o campo para ser exibido no controle combobox
         cmbCustomers.DisplayMember = "CompanyName";
         // configura a chave para o controle
         cmbCustomers.ValueMember = "CustomerID";
         // envia os dados para o controle
         cmbCustomers.DataSource = Customers.ToList();
            }

Este c�digo da Listagem 10 inicia criando uma inst�ncia para o Entity Data Model que criamos e denominamos de NorthwindEntities na linha 51. Isto � necess�rio, pois � este namespace que mapeia as tabelas do banco de dados para as classes do projeto. A linha 53 armazena os resultados da consulta na vari�vel Customers. Esta consulta � bem simples, apenas retorna todos os registros da tabela. Provavelmente voc� vai querer fazer algum tipo de filtro posteriormente, mas, veremos mais adiante como fazer isto.

O controle ComboBox pode ser usado para exibir dados retornados de um banco de dados. Para isto, precisamos definir qual ser� o campo que ser� exibido atrav�s de sua propriedade DisplayMember, como est� demonstrado na linha 56. Tamb�m precisamos definir o campo que ser� usado como filtro para consultas posteriores. No caso da tabela Customers � o campo CustomerID que precisa ser passado para a tabela Orders, por isso, na linha 58 informamos este campo para a propriedade ValueMember. E para concluir, passamos os dados da vari�vel Customers, convertendo-os para uma lista, veja m�todo .ToList(), para que seja usada para popular o controle.

Vamos agora definir a consulta que ir� filtrar as vendas pelo cliente selecionado no controle ComboBox. D� um duplo clique no bot�o btnVendasPorCliente e escreva o c�digo da Listagem 11.

Listagem 11. Consultando as vendas por cliente.


// Consulta vendas pelo cliente
      private void btnVendasPorCliente_Click( object sender, EventArgs e )
      {
         // configura o datamodel
         NorthwindEntities nwModel = new NorthwindEntities();
         // recebe o ID do cliente para ser passado para a consulta
         string IDCliente = cmbCustomers.SelectedValue.ToString();
         // executa a consulta trazendo apenas alguns campos
         var Vendas = from o in nwModel.Orders
                      where o.Customers.CustomerID == IDCliente
                      orderby o.OrderDate descending
                      select new { o.OrderID, o.OrderDate, o.ShipCity };
         // envia os dados para a grid
         grdResultado.DataSource = Vendas.ToList();
      }

Este c�digo traz os detalhes da venda como n�mero (OrderID), data (OrderDate) e cidade (ShipCity). Para isso, começamos novamente instanciando o Entity Data Model na linha 67. Separamos o ID do cliente para ser passado para a consulta na linha 69. A linha 71 inicia a consulta sendo que desta vez temos algumas particularidades. Note na linha 72 que estamos fazendo refer�ncia direta � tabela Customers:


where o.Customers.CustomerID

Esta � mais uma caracter�stica forte do LINQ: as tabelas relacionadas s�o agregadas automaticamente �s classes sendo que, as tabelas com chaves estrangeiras s�o mapeadas dentro da classe principal como uma de suas propriedades.

Na linha 73 fazemos a ordenaç�o descendente dos resultados e na linha 74 um novo elemento na consulta que � a seleç�o de apenas alguns campos para serem exibidos. Sempre que quiser, em vez de exibir a entidade inteira, exibir apenas alguns campos, enumere-os dentro das chaves {}. O controle DataGridView recebe o resultado da consulta na linha 76. Por fim, quero demonstrar o LINQ filtrando os produtos pelo preço. Para fechar esta demonstraç�o vamos listar o n�mero das vendas com o valor dos produtos iguais ou acima do valor dado e tamb�m o nome do produto e o cliente que fez a compra. Voc� pode perceber que estamos fazendo novamente refer�ncia a tabelas relacionadas. Veja na Listagem 12 como isto fica bem simples de se fazer com LINQ.

Listagem 12. Filtrando vendas pelo preço do produto.


 // Filtrando vendas pelo preço do produto
       private void btnFiltrarPeloPreco_Click( object sender, EventArgs e )
       {
          // recebe o valor do produto
          decimal PrecoUnitario = decimal.Parse( txtPrecoUnitario.Text );
          // configura o datamodel
          NorthwindEntities nwModel = new NorthwindEntities();
          // executa a consulta
          var Produtos = from p in nwModel.Order_Details
                         where p.UnitPrice >= PrecoUnitario
                         orderby p.UnitPrice
                         select new
                         {
                            IDVenda = p.OrderID,
                            Produto = p.Products.ProductName,
                            Valor = p.UnitPrice,
                            Cliente=p.Orders.Customers.CompanyName
                         };
          // envia dados para a grid
          grdResultado.DataSource = Produtos.ToList();
       }

Novamente temos um c�digo bem simples. Na linha 83 estamos convertendo o valor do produto digitado no controle txtPrecoUnit�rio.

Nota: N�o estou fazendo em nenhum momento tratamento de erros no c�digo, por�m, sempre faça isto nos seus c�digos, principalmente nas operaç�es de convers�es de tipos e consultas a bancos de dados, mesmo usando LINQ. Embora o compilador possa validar o c�digo � poss�vel ainda que ocorram erros n�o tratados.

Na linha 85 instanciamos novamente o Entity Model sendo que, em projetos maiores voc� pode deixar isto previamente configurado no seu c�digo. E a partir da linha 87 temos a consulta com novas caracter�sticas. Começamos bem simples fazendo refer�ncia � tabela Order_Details que � onde iremos aplicar o filtro do preço na linha 88. Fazemos uma ordenaç�o crescente dos registros na linha seguinte e da linha 90 at� a 95 selecionamos quais colunas queremos usar. Neste caso, al�m de fazer refer�ncia aos campos da tabela original, consultamos o nome do produto na tabela referenciada Products e o nome do cliente. Na linha 95 temos uma refer�ncia indireta, primeiramente fazemos refer�ncia � tabela Orders, diretamente ligada com Order_Details para a partir desta, fazer refer�ncia � tabela Customers para poder obter o nome do cliente. A seguir o detalhe do c�digo para voc� entender melhor:

Cliente=p.Orders.Customers.CompanyName

Nesta consulta al�m de selecionarmos os campos que desejamos exibir, estamos renomeando os nomes para exibiç�o na grid, ou, se preferir, estamos fazendo uso dos tipos an�nimos do C# que � o que est� sendo usado na realidade.

Execute o projeto. As Figuras 13 e 14 mostram os resultados do c�digo feito para a consulta com banco de dados que fizemos at� agora.

Figura 13. Filtrando vendas pelo cliente.

Figura 14. Filtrando vendas pelo preço do produto.

Consultando dados de um documento XML

O passo final � demonstrar como consultar um arquivo XML usando LINQ e preencher um controle DataGridView com este arquivo. O arquivo XML cont�m os seguintes dados, conforme na Listagem 13.

Listagem 13. Arquivo XML de exemplo


 <?xml version="1.0" encoding="utf-8"?>
 <guitarras>
   <guitarra NumeroDeSerie="111201STRAT">
     <fabricante>Fender</fabricante>
     <modelo>Stratocaster</modelo>
     <MadeiraCorpo>Alder</MadeiraCorpo>
     <MadeiraEscala>Mapple</MadeiraEscala>
     <MadeiraBraco>Mapple</MadeiraBraco>
     <ano>1990</ano>
   </guitarra>
   <guitarra NumeroDeSerie="123202STRAT">
     <fabricante>Fender</fabricante>
     <modelo>Stratocaster</modelo>
     <MadeiraCorpo>Mogno</MadeiraCorpo>
     <MadeiraEscala>Mapple</MadeiraEscala>
     <MadeiraBraco>Rowsewood</MadeiraBraco>
     <ano>1989</ano>
   </guitarra>
   <guitarra NumeroDeSerie="112301TELE">
     <fabricante>Fender</fabricante>
     <modelo>Telecaster</modelo>
     <MadeiraCorpo>Alder</MadeiraCorpo>
     <MadeiraEscala>Mapple</MadeiraEscala>
     <MadeiraBraco>Mapple</MadeiraBraco>
     <ano>2000</ano>
   </guitarra>
   <guitarra NumeroDeSerie="99901LPAUL">
     <fabricante>Gibson</fabricante>
     <modelo>Les Paul</modelo>
     <MadeiraCorpo>Mogno</MadeiraCorpo>
     <MadeiraEscala>Mogno</MadeiraEscala>
     <MadeiraBraco>Rosewood</MadeiraBraco>
     <ano>1980</ano>
   </guitarra>
 </guitarras>

Para preencher o controle, vamos criar uma classe que ser� preenchida com os dados do arquivo. Adicione uma classe ao projeto clicando com o bot�o direito do mouse sobre o �cone do projeto na janela Solution Explorer e escolhendo a opç�o Add > New Class (Figura 15).

Figura 15. Adicionando uma classe ao projeto.

Na janela que se abre preencha o campo Name com guitarra para definir o nome da classe e clique no bot�o Add para concluir. O c�digo para esta classe � muito simples sendo que apenas definimos os campos a serem usados. Optei por manter os mesmos nomes dos elementos do arquivo XML. Veja o c�digo na Listagem 14.

Listagem 14. Classe guitarra.


 namespace DemoLINQ
 {
    public class guitarra
    {
       public string modelo { get; set; }
       public string MadeiraCorpo { get; set; }
       public string MadeiraBraco { get; set; }
       public string MadeiraEscala { get; set; }
       public string NumeroDeSerie { get; set; }
       public string ano { get; set; }
       public string fabricante { get; set; }
    }
 }

Abra o formul�rio no designer do Visual Studio e adicione os controles como na Tabela 5. Veja na Figura 16 a disposiç�o dos controles.

Componente	Propriedade	Valor
Label	Text	Nome do arquivo
TextBox	(Name)	txtArquivoXML
	AutoCompleteMode	Suggest. (Esta propriedade permite ao controle sugerir o conte�do a partir de uma origem configurada. Ver a pr�xima propriedade).
	AutoCompleteSource	FileSystem. Indica onde o controle busca os dados para sugerir para o usu�rio. Neste caso, vai consultar os arquivos armazenados no disco r�gido.
Button	(Name)	btnCarregarXML
Label	Text	Resultado
DataGridView	(Name)	grdXML

Tabela 5. Controles para a aba LINQ to XML.

Figura 16. Alinhamento dos controles na aba "LINQ to XML".

D� um duplo clique sobre o bot�o btnCarregarXML e escreva o c�digo da Listagem 15.

Listagem 15. C�digo para consultar o XML.


// le o arquivo xml
private void btnCarregarXML_Click( object sender, EventArgs e )
{
   // executa a consulta
   var resultado = from guit in XElement.Load( txtArquivoXML.Text ).Elements( "guitarra" )
                   select new guitarra
                   {
                      ano = (string)guit.Element( "ano" ),
                      fabricante = (string)guit.Element( "fabricante" ),
                      MadeiraBraco = (string)guit.Element( "MadeiraBraco" ),
                      MadeiraCorpo = (string)guit.Element( "MadeiraCorpo" ),
                      MadeiraEscala = (string)guit.Element( "MadeiraEscala" ),
                      modelo = (string)guit.Element( "modelo" ),
                      NumeroDeSerie = (string)guit.Attribute( "NumeroDeSerie" )
                   };
   // preenche a grid com os resultados
   grdXML.DataSource = resultado.ToList();
}

Neste c�digo estou demonstrando um uso t�pico para a consulta de arquivos XML com LINQ. Na primeira linha (linha 106) � carregado o arquivo do disco a partir do endereço informado no controle txtArquivoXML. O m�todo XElement.Load faz a carga do arquivo que deve estar presente no endereço informado. Com o m�todo .Elements informamos para a instruç�o ler somente os elementos guitarra dentro do arquivo XML.

Em seguida na linha 107 e seguintes, � criada uma inst�ncia da classe guitarra para ser enviada para a lista de resultados indicada por �var resultado�. Cada elemento precisa ser convertido para string e atribu�do para uma propriedade da classe atrav�s da instruç�o guit.Element. Esta instruç�o l� um n� do arquivo XML dentro do elemento raiz passado anteriormente. Voc� deve qualificar qual o elemento ser� lido dentro dos par�metros. Lembrando que os arquivos XML fazem distinç�o entre mai�sculas e min�sculas.

Na linha 115, em vez de ler um elemento do arquivo XML, precisamos ler o conte�do de um atributo, ent�o, em vez de utilizar �.Element� usamos �.Attribute� passando como par�metro o nome do atributo a ser lido. Novamente passamos o resultado para o controle �DataGridView� na linha 118 convertendo para uma lista. Pressione F5 e veja o programa sendo executado como na Figura 17.

Figura 17. Consulta de arquivo XML com LINQ to XML.

Conclus�o

Uma das principais vantagens do uso da linguagem LINQ para se fazer consultas � a possibilidade de consultar dados usando a mesma sintaxe usada pela linguagem que se est� trabalhando (C# ou Visual Basic) diminuindo a dist�ncia que � gerada quando usamos, por exemplo, ADO.NET e instruç�es SQL. Certamente a curva de aprendizado � um pouco acentuada, entretanto, com um pouco de esforço e mantendo o foco em coisas mais simples, voc� consegue iniciar a aplicaç�o desta ferramenta imediatamente em seus projetos, criando aplicaç�es mais �geis e um c�digo mais f�cil de ser entendido por manter o foco na orientaç�o a objetos, o que � dif�cil de fazer quando se est� trabalhando, por exemplo, com dados relacionais. A linguagem LINQ � extensa e pode ser expandida permitindo in�meras variaç�es. Al�m disto, existem assuntos paralelos como o Entity Framework que merecem um pouco mais de atenç�o e estudo para que voc� domine completamente. Tamb�m o uso de LINQ to XML � vasto e o que foi apresentado neste artigo pretendeu apenas servir de porta de entrada para seu uso inicial. Procure se informar mais sobre todos estes assuntos e tire proveito dos recursos oferecidos.

Refer�ncias:

Guia de SQL

Guia

Cursos de SQL e Banco de Dados

Curso

Curso de SQL