Exportando DataTables p

ara arquivos XML

O artigo dá sequência ao uso dos arquivos
XML dentro do framework .NET e a
linguagem C#. Desta vez, será mostrado
como manipular estes arquivos usando as
classes do ADO.NET que é a camada
destinada ao trabalho dos dados contidos
em bancos de dados, muito embora, não
fique restrita apenas a bancos de dados
relacionais.
De que se trata o artigo

O artigo dá sequência ao uso dos arquivos XML dentro do framework .NET e

a linguagem C#. Desta vez, será mostrado como manipular estes arquivos
usando as classes do ADO.NET que é a camada destinada ao trabalho dos
dados contidos em bancos de dados, muito embora, não fique restrita apenas a
bancos de dados relacionais.

Para que serve

O uso de ADO.NET facilita bastante o acesso aos dados armazenados em

arquivos XML que é feito usando as classes que permitem trabalhar com os
dados da mesma forma que tabelas armazenadas em bancos de dados. Se a
aplicação a ser desenvolvida não usar arquivos XML muito complexos com
vários níveis, a escolha do ADO.NET pode facilitar bastante o trabalho.

Em que situação o tema é útil

No desenvolvimento de aplicações que manipulem dados que precisem ser
gravados em arquivos XML quer seja para armazenamento de configurações,
intercâmbio de dados entre aplicativos etc. Na leitura e geração de arquivos
XML sem que seja necessário conhecer DOM (um modelo mais avançado
para manipular XML) ou lançar mão das classes contidas em System.Xml.

ADO.NET e Arquivos XML

O framework .NET oferece uma vasta quantidade de classes e métodos para

acesso aos dados armazenados em arquivos XML que são cada vez mais
utilizados pelos programas especialmente pelo fato de permitir estruturar os
dados que são armazenados. Porém muitos dos recursos para o trabalho com
os arquivos são complexos e extremamente detalhados exigindo que se tenha
um vasto conhecimento da formação dos arquivos XML e o número extenso
de classes dificulta mais ainda o trabalho. Por causa do largo uso destes
arquivos aos poucos os ambientes de programação como o framework .NET
foram criando recursos para facilitar o acesso, leitura e gravação dos
conteúdos para o formato XML. Um dos primeiros recursos do framework foi
uma biblioteca para facilitar o trabalho de manipulação de bancos de dados
que é chamada de ADO.NET. Sendo que esta é uma evolução da biblioteca
ADO existente anteriormente no Visual Basic. A característica mais
interessante acrescentada nesta biblioteca – além do suporte a vários tipos de
bancos de dados – foi o acréscimo de métodos e classes capazes de carregar
arquivos a partir dos arquivos XML e gravar neste formato. Uma vez
carregado na memória através de um simples método, o conteúdo dos
arquivos pode ser modificado usando-se o modo de trabalho desconectado do
ADO.NET e ser gravado facilmente com um ou dois passos. Não é um
recurso que poderá ser usado em todos os tipos de projeto porque depende da
complexidade do arquivo XML a ser manipulado envolvendo seus tipos de
dados, profundidade de nós etc. Para por em prática tudo o que será tratado no
artigo, um projeto de exemplo fará a exportação de dados lidos do banco
Northwind e também irá ler dados de arquivos salvos no formato XML.

Se existe uma tecnologia recente que rapidamente começou a ser adotada

dentro do processamento de dados foi a linguagem de marcação XML.
Surgida em meados dos anos 1990 é utilizada em quase todos os tipos de
aplicação principalmente para a persistência e intercâmbio de dados dos
programas. O aspecto mais importante da linguagem é a forma estruturada e
hierárquica que os dados são gravados nos arquivos. Com um editor de texto
simples como o bloco de notas do Windows e um mínimo de conhecimento de
estrutura de dados é possível com pouco tempo entender a estrutura do
arquivo e saber quais os dados armazenados e qual a sua estrutura e
hierarquia. Veja um arquivo de teste sendo exibido dentro do bloco de notas
na Figura 1.
Figura 1. Exemplo de arquivo XML lido no bloco de notas

No arquivo pode-se perceber rapidamente que se trata de um registro de dados

de um fictício funcionário de uma empresa. Além de alguns dados do mesmo,
armazena diversos registros com dados de seus dependentes. Note que o
arquivo permite vários tipos de dados como texto, números inteiros, decimais
e datas. É possível também preparar o arquivo para aceitar caracteres especiais
vinculados com determinados idiomas como a acentuação do idioma
português. Tudo isso é identificado rapidamente apenas olhando-se para o
arquivo. Mas, justamente por causa desta facilidade de se entender a estrutura
do arquivo é que é tão complicado manipular via programação estes arquivos.
Considere por exemplo a hierarquia dos nós de dependentes. Normalmente
são usadas as classes de System.Xml para ler e gravar os dados dos arquivos
XML. O que ainda assim é complicado porque este arquivo possui diversos
níveis nos nós dos dados. Considere ainda se existir a necessidade de se editar
estes dados e em seguida, gravar novamente o seu conteúdo.

ADO.NET
Este componente do framework .NET (encontrado em System.Data)
disponibiliza uma série de classes que fazem o trabalho de acesso e
manipulação aos dados de formas bem distintas. O acesso e edição dos dados
estão bem separados permitindo e facilitando principalmente o método de
trabalho “desconectado”.

Neste modelo a conexão com a fonte de dados, que pode ser um servidor
SQL, arquivos do Access ou qualquer outra fonte de dados suportada é
realizada para recuperar os arquivos e enviar as atualizações. Uma vez
carregados os dados, estes são manipulados localmente, sem a necessidade de
manter a conexão aberta, sendo esta, requisitada somente quando houver
necessidade de nova consulta ou de se enviar os dados de volta para a sua
fonte. Os principais componentes para o trabalho com os dados de forma
hierárquica e que serão vistos neste artigo são as classes DataTable e DataSet.

O número de componentes de ADO.NET é vasto. Graças a arquitetura aberta

do framework (arquitetura aberta não é o mesmo que código fonte aberto)
onde as especificações de cada componente é bem documentada, foi possível
que os desenvolvedores criassem classes para manipulação de outros bancos
de dados diferente dos que são suportados nativamente pelo framework. Este
artigo não vai se aprofundar em ADO.NET mas, apenas descrever como este
pode ser usado para se manipular os arquivos XML.

A classe DataTable
Consiste de um conjunto de colunas – ligadas às colunas de uma tabela do
banco de dados – e linhas representando cada uma, um registro. As colunas
são definidas pela classe DataColumn sendo que suas propriedades
armazenam características tais como:

• Tipo do dado a ser armazenado: texto, números inteiros e decimais, data etc.;

• Restrições: valor máximo e mínimo, duplicações, bloqueio de valores nulos;

• Expressões: usadas para que o conteúdo de dados seja definido a partir do

conteúdo de uma ou mais colunas;

• A coluna de origem na tabela do banco de dados.

Também é possível classificar os registros dentro de um objeto deste tipo e

realizar relacionamentos com outros objetos do mesmo tipo. Dentre os
métodos que a classe oferece, os que nos interessam para a manipulação dos
arquivos XML são dois: WriteXml e ReadXml.

O primeiro, como é possível perceber logo no nome, é responsável pela

gravação dos dados que estão contidos na tabela para o arquivo XML. Este
método possui muitas sobrecargas as quais permitem escrever os dados no
formato XML em um arquivo localizado localmente ou na rede, usando uma
instância da classe XmlWriter que é responsável por gerar um documento
XML na memória, no disco, etc., ou ainda, usando uma stream para enviar
dados pela rede ou mesmo pela Internet. Para o trabalho deste artigo vamos
estudar duas sobrecargas sendo que a primeira escreve em um arquivo
recebendo como parâmetro apenas o nome deste:

DataTable.WriteXml(<nome do arquivo>);
Desta forma somente os dados são enviados com as tags sendo geradas a
partir do nome das colunas da tabela de origem. A estrutura do arquivo criada
é a mínima necessária apenas para possibilitar a sua interpretação pelos
programas que fazem a leitura deste tipo de arquivo.

Nota: Como toda operação com arquivos é necessário que o usuário que esteja
conectado com o Windows e executando o programa possua as devidas permi
ssões para ler e para gravar os arquivos no disco local ou nas unidades de rede
, caso contrário, o programa irá causar uma exceção relacionada com a falta d
e permissão.

Outra variação importante do método permite gravar também a estrutura dos

dados armazenados, contendo informação sobre o tipo de dados entre outras
coisas. Esta estrutura é denominada nos arquivos XML de schema e veremos
um pouco deste assunto mais à frente. O envio da estrutura é importante, pois
existem casos em que se esta informação não for enviada com os dados do
arquivo, ao se realizar a leitura em outro programa, os dados podem ser
recuperados incorretamente, como é o caso de arquivos gerados em versões de
idiomas diferentes do sistema operacional.

A sobrecarga do método que grava o schema é:

DataTable.WriteXml(<nome do arquivo>, <modo de gravação>);

O segundo parâmetro “<modo de gravação>” aceita um dos modos contidos

no enumerador XmlWriteMode. Os principais são:

• WriteSchema: como o próprio nome sugere, grava o conteúdo e o schema

no arquivo. Se não houver dados, somente o schema será enviado, se não
houver uma estrutura – por exemplo, para uma tabela vazia, sem nenhuma
coluna – nenhum schema será gravado;

• IgnoreSchema: grava somente o conteúdo, sem nenhuma informação sobre

o schema.

Nota do DevMan

Ao se trabalhar com a classe DataTable e enviar os dados para o arquivo XML

deve-se conhecer alguns aspectos de seu funcionamento, como por exemplo, o
comportamento dos dados quando estes são editados. Uma vez carregados os
dados no objeto DataTable este pode preencher controles visuais para que este
s sejam editados. Após o trabalho de edição é conveniente realizar um commit
ou seja, garantir que os dados que estão na tabela correspondem exatamente a
os que foram editados. Um dos métodos que faz isto nesta classe é o AcceptC
hanges.
Para a leitura de um arquivo XML é necessário apenas executar o método
ReadXml tendo como a sintaxe básica:

DataTable.ReadXml(<nome do arquivo>);

Esta é mais indicada para a maior parte dos casos em que se deseja carregar
dados destes arquivos. É possível, assim como no método WriteXml ler de
diversas origens como streams de arquivos ou ainda de um documento XML
carregado na memória passando-se um elemento do tipo XmlReader. Caso o
schema esteja gravado no arquivo, as colunas do DataTable usarão os tipos de
dados existentes no schema, caso contrário, os dados serão assumidos todos
como do tipo string mesmo que sejam de tipos distintos como números ou
datas.

A classe DataSet
DataTables são objetos e, assim como a maior parte dos objetos do .NET
podem ser trabalhados em coleções. A classe DataSet é feita para este fim.
Consiste de uma coleção de DataTables que podem ser acessados via
indexadores de vetores usando os colchetes “[]”. Através desta classe que todo
o trabalho desconectado do ADO.NET é feito e permite manipular dados
independentemente do banco de dados ou a fonte onde estejam armazenados.
Toda a arquitetura do DataSet é baseada em XML o que explica a facilidade
de se gerar e ler dados deste tipo de arquivos. Assim como a classe DataTable
os principais métodos usados para gravar e ler arquivos XML são
respectivamente, WriteXml e ReadXml. O diferencial é que estes executarão o
comando gravando ou lendo todas as tabelas existentes na coleção do DataSet
carregado na memória ou gravadas no arquivo XML. Por exemplo, considere
um DataSet contendo três tabelas (Figura 2).
Figura 2. Estrutura do DataSet

Ao executar o método WriteXml um único arquivo XML é gerado contendo

as três tabelas e os seus dados. Assim sendo, o uso do DataSet é interessante
para se persistir várias tabelas em um único arquivo. Já, se um arquivo XML
possuir vários nós aninhados de uma forma que possam estes ser separados
em tabelas (como no exemplo inicial dado com o XML dos dados do
funcionário), o método ReadXml faz a leitura do arquivo procurando criar o
número certo de tabelas dentro do DataSet.

DataSet e projetos orientados a

bancos de dados
A classe DataSet apresentada aqui serve para trabalhar com coleções de
tabelas na memória e exportar os dados para o formato XML ou importar
deste. Para os que já trabalharam com aplicações .NET voltadas para usar
banco de dados, já devem ter trabalhado com o DataSet dentro dos projetos
para agrupar tabelas do banco de dados e os respectivos componentes
TableAdapter – que fazem o acesso ao banco executando as consultas e
comandos SQL para manipulação dos dados. O DataSet usado nos projetos
(principalmente do tipo Windows Forms) é semelhante a classe vista
anteriormente, possuindo os mesmos métodos de exportação e importação de
dados XML que o primeiro. A configuração do DataSet para o projeto é
extremamente visual e permite que através de um designer se configure a
conexão com o banco de dados e a execução de instruções SQL para obter os
dados. O principal objetivo do DataSet dentro do projeto é facilitar a ligação
dos controles visuais com os dados carregados do banco. Este elemento do
projeto representa as tabelas mapeadas do banco de dados da forma como está
na Figura 3.
Figura 3. Exemplo de DataSet de um projeto Windows

Cada objeto visual consiste de um DataTable vinculado com um objeto do

tipo TableAdapter. O DataTable é um componente que é criado dentro do
projeto derivado do DataTable original. Este tipo recebe o nome da tabela na
qual é baseado. Dentro desta estão definidas as colunas do banco de dados que
são recuperadas via instrução SQL. Logo abaixo da definição da tabela
encontra-se a classe TableAdapter. Esta classe define métodos para o
preenchimento dos dados da tabela com a qual está vinculada. Um aspecto
interessante é que estes métodos somente poderão preencher tabelas deste tipo
e nenhum outro mais. O TableAdapter deriva da classe de mesmo nome
básico do ADO.NET e é vinculado com o banco de dados com o qual o
DataSet está conectado. É possível definir vários métodos dentro de um
mesmo TableAdapter bastando para isto, dentro do designer, clicar com o
botão direito do mouse e escolher a opção adequada no menu de contexto
“Add” (Figura 4).
Figura 4. Menus de contexto do DataSet

Nota do DevMan

O DataSet de projeto é muito bom e facilita demais o trabalho deixando mais

visual as tarefas de acesso ao banco de dados o que aumenta a produtividade n
a teoria. Entretanto, dada esta facilidade, é muito fácil cometer excessos e, se
m que o desenvolvedor perceba, ele começa a crescer demais. O problema é q
ue para poder gerar as informações visuais, muito código é gerado em backgro
und em arquivos que normalmente não são acessados pelo desenvolvedor e ist
o, caso muitas tabelas comecem a ser acrescentadas, torna a carga do projeto e
o trabalho no Visual Studio muito lento. No projeto de exemplo que contém a
penas três tabelas, o código só para o designer do DataSet contém mais de três
mil e quatrocentas (3.400) linhas. Quando estiver trabalhando com este compo
nente do Visual Studio, procure definir cuidadosamente quantas tabelas serão
usadas para evitar problemas futuros.

A estrutura de um arquivo XML –

Schemas
Dados muitas vezes precisam estar estruturados e conter dados sobre eles
próprios, o que geralmente são chamados de “metadados”. Isto é necessário
para facilitar a compreensão tanto da parte de programas como para quem lê o
arquivo. Os arquivos XML são caracterizados pela forte estruturação dos
dados que carregam. Isto é feito através da definição da sua estrutura através
do schema que usa tags especiais de marcação contendo os metadados.
Considere o XML da Listagem 1.

Listagem 1. Arquivo de XML de exemplo

<nome>
<nome>José Antonio</nome>
<salario>2000</salario>
<admissao>2000-12-01T00:00:00-02:00</admissao>
</nome>

Este documento possui três tags e cada uma sendo de um tipo de dado
diferente. A tag “nome” deve ser do tipo string enquanto “salario” armazena
valores decimais e “admissao" representa uma data. Observe ainda que para a
data poder ser compatível com sistemas de outros idiomas, é enviada a data, a
hora e também um indicador GMT do horário. O schema para este XML
corresponde ao da Listagem 2.

Listagem 2. Exemplo de schema XML

3 <xs:schema id="NewDataSet" xmlns=""

xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-
microsoft-com:xml-msdata">
4 <xs:element name="NewDataSet" msdata:IsDataSet="true"
msdata:MainDataTable="nome" msdata:UseCurrentLocale="true">
5 <xs:complexType>
6 <xs:choice minOccurs="0" maxOccurs="unbounded">
7 <xs:element name="nome">
8 <xs:complexType>
9 <xs:sequence>
10 <xs:element name="nome" type="xs:string"
minOccurs="0" />
11 <xs:element name="salario" type="xs:decimal"
minOccurs="0" />
12 <xs:element name="admissao" type="xs:dateTime"
minOccurs="0" />
13 </xs:sequence>
14 </xs:complexType>
15 </xs:element>
16 </xs:choice>
17 </xs:complexType>
18 </xs:element>
19 </xs:schema>
A estrutura principal do schema está presente nas linhas 10 a 12. Este schema
pode ser interno, definido dentro do próprio conteúdo do arquivo XML ou
externo. Quando é este o caso, o arquivo recebe uma extensão especial “XSD”
e deve ser referenciado pelo arquivo XML de destino para poder fazer sua
validação de acordo com o schema definido.

Nota do DevMan

O trabalho com schemas XML requer mais conhecimento do que os pontos bá

sicos explicados aqui. No final do artigo, existem alguns links para tutoriais so
bre este assunto que devem proporcionar uma boa base de conhecimentos. O f
ramework tem classes que ajudam a fazer a validação dos arquivos XML conf
rontando-os com sua estrutura carregando, lendo, comparando e escrevendo o
s arquivos XSD.

O projeto de exemplo
Para demonstrar como salvar e importar dados no formato XML usando
ADO.NET com as classes DataTable e DataSet será usado um projeto
Windows Forms.

O objetivo deste projeto será carregar os dados da tabela Customers

(Clientes), Orders (Pedidos) e Order Details (detalhes do pedido ou, produtos
do pedido) do banco de dados de exemplo do SQL Server Northwind.

O programa deve exportar todos os registros da tabela Customers e para a

tabela Orders, precisa permitir que o usuário selecione um registro, carregue
este na tela juntamente com os produtos que o compõe.

Nota: este banco de dados é muito usado pelos programadores das tecnologias
da Microsoft para demonstrações porque é muito completo e bem feito. Além
disto, suas tabelas, stored procedures, views e dados que estão armazenados re
presentam bem dados e a estrutura de um banco de dados do mundo real. No f
inal deste artigo serão disponibilizados links para o download tanto do SQL S
erver como do banco de dados de exemplo.

Criando o projeto
Para iniciar o trabalho, deve ser criado um projeto novo no Visual Studio
através do menu File > New Project, a Figura 5 mostra os detalhes. É preciso
tomar cuidado com a escolha da linguagem Visual C# para o modelo do
projeto. Embora seja possível também usar a linguagem Visual Basic .Net
para executar o projeto, os códigos escritos no artigo usam o C#. O projeto
cria automaticamente um formulário padrão que para o exemplo deve ser
renomeado para “frmPrincipal”. Faça isto clicando com o botão direito do
mouse na janela Solution Explorer sobre o arquivo “Form1.cs” e escolha
“Rename”.

Figura 5. Janela para criação do projeto no Visual Studio

Configurando o acesso ao banco de

dados
O acesso ao banco Northwind é feito no projeto usando ADO.NET. É
necessário adicionar um DataSet ao projeto através do qual o código fará as
operações com o banco. Para isso, execute as opções do menu Data > Add
new Data Source, ao executar este comando, o Visual Studio inicia um
assistente para a conexão. O primeiro passo é escolher o tipo da fonte de
dados. No caso do projeto, usa-se Database conforme pode ser conferido
na Figura 6.
Figura 6. Escolhendo o tipo da fonte de dados

Para conectar-se ao banco deve-se informar a localização do servidor de

banco de dados que pode estar localizado local ou remotamente. Na próxima
tela, clique no botão New Connection para definir a conexão ao servidor
(Figura 7).
Figura 7. Configurando a conexão com a fonte de dados

O Visual Studio possui um assistente para configuração da conexão. Neste

assistente (Figura 8) deve-se informar o campo “Server name”, configurar o
tipo de autenticação usada (integrada com o usuário do Windows ou via Sql
Server) no campo “Log on to the server” e definir qual o banco de dados a ser
acessado.
Figura 8. Escolhendo o servidor e o banco de dados

A partir da versão 3.5 do framework é possível que se tenha dois modelos

para acessar o banco de dados: Dataset que é o mais comum para o ADO.NET
e Entity Data Mode, padrão para o LINQ. Na próxima janela demonstrada
na Figura 9 escolha o modelo “Dataset”.

Nota do DevMan
LINQ é a abreviação de Language Integrated Query. É uma linguagem para c
onsulta de dados integrada com a linguagem usada no framework para desenv
olver o projeto (C#, VB.Net etc.). Pode ser usada para consultar bancos de dad
os, coleções de objetos na memória e também arquivos XML. Não será tratada
neste artigo por fugir do assunto principal.

Figura 9. Definindo o modelo de acesso ao banco de dados

A próxima janela do assistente permite escolher as tabelas que serão

acessadas. No caso do projeto deve-se deixar em branco. As tabelas serão
definidas manualmente. No campo “DataSet name” deve-se digitar um nome
para o mesmo (Figura 10).
Figura 10. Finalizando a tarefa e definindo um nome

Com o final da operação a janela “Solution Explorer” terá o ícone do Dataset

criado acrescentado como na Figura 11.

Figura 11. DataSet do projeto na janela Solution Explorer

Ajustando a configuração de
conexão com o banco de dados
Uma característica importante das aplicações Windows é armazenar as
configurações, como a string de conexão com o banco de dados em um
arquivo chamado “app.config” em tempo de projeto e “<nome do
projeto.exe.config>” em tempo de execução. Faremos um ajuste neste arquivo
para poder recuperar a string de conexão quando for fazer consulta ao banco
de dados. Dê um duplo clique no arquivo “app.config” na janela “Solution
Explorer” e altere o conteúdo do arquivo conforme a Listagem 3.

Listagem 3. Alteração da string de conexão no arquivo de configuração

1 <?xml version="1.0" encoding="utf-8" ?>

2 <configuration>
3 <configSections>
4 </configSections>
5 <connectionStrings>
6 <add name="Northwind"
7 connectionString="Data Source=Vladimir-
note\sqlexpress;Initial Catalog=Northwind;Integrated Security=True"
8 providerName="System.Data.SqlClient" />
9 </connectionStrings>
10 </configuration>

A alteração precisa ser feita no item “name” mudando o seu conteúdo para
“Northwind” conforme pode ser conferido na linha 6. As demais linhas devem
ser mantidas inalteradas.

Nota do DevMan

O arquivo app.config representa a forma padrão do Framework .Net armazena

r configurações diversas necessárias para o funcionamento da aplicação. Emb
ora possa se criar outros mecanismos de armazenamento de configurações, o u
so deste arquivo facilita bastante as coisas por possuir vários recursos já nativ
os. Sempre que possível procure usar este arquivo.

Acessando as tabelas
Anteriormente foi explicado que para carregar os dados do banco de dados
localmente como o ADO.Net precisamos definir objetos do tipo
DataAdapter/TableAdapter que fazem a conexão com o banco de dados e
executam as consultas que recuperam os registros. Abra o DataSet que foi
criado no projeto. Na janela, clique com o botão direito do mouse sobre o
mesmo e escolha a opção do menu “Add > TableAdapter...” para iniciar o
assistente que configura este componente (Figura 12).
Figura 12. Adicionando um componente TableAdapter no DataSet

A conexão com o banco de dados que foi configurada ao se criar o Dataset

está armazenada no arquivo de configurações da aplicação (app.config). O
assistente dá uma opção para usar a conexão existente (Figura 13) abrindo
uma janela para escolher a conexão ou criar uma nova. Neste projeto será
usada a conexão que foi configurada anteriormente.
Figura 13. Escolhendo a conexão a ser usada

Na próxima janela deve-se escolher como os dados serão recuperados. No

projeto serão usadas instruções SQL. Por isso, deve-se marcar na próxima
janela (Figura 14) o campo “Use SQL statements”.
Figura 14. Definindo a forma como os dados serão consultados

Digite a instrução SQL conforme a Figura 15.

Nota: uma das boas práticas do uso das instruções SQL recomenda declarar os
nomes dos campos na consulta para otimizar o tráfego dos dados na rede. Entr
etanto, como este exemplo foca em outros pontos, podemos usar a consulta co
nforme está no exemplo sem problemas.
Figura 15. Inserindo a instrução SQL

O controle TableAdapter que está sendo configurado permite além de

consultar os dados também gerar automaticamente as instruções SQL para as
operações CRUD. Como neste exemplo não existirão estas operações, o
assistente do Visual Studio permite que se desabilite a geração destes
comandos, o que acaba otimizando a geração de código. Na janela seguinte do
assistente, desmarque o campo como demonstrado na Figura 16.
Figura 16. Fazendo ajustes na consulta SQL

A tarefa final do assistente é definir o nome para o método que preenche os

dados (Figura 17), configure os campos conforme demonstrado. A Figura
18 mostra o resultado.

Nota: O assistente para a criação do TableAdapter permite a criação dos méto

dos que preenchem um DataTable, retornam um objeto deste tipo com os dado
s preenchidos (Return a DataTable) e também os métodos que executam as op
erações CRUD no banco de dados. Perceba na figura que apenas o primeiro m
étodo será criado pois os demais não serão usados. Ao escrever e configurar o
s controles TableAdapter nos projetos do mundo real, esteja atento a esta etap
a da configuração para gerar código que seja necessário.
Figura 17. Nomeando o método que preenche os dados
Figura 18. Etapa final da configuração do TableAdapter

Repita o processo para a tabela Orders. A primeira consulta que está sendo
configurada (Figura 19) retorna um registro específico através do parâmetro
“@OrderID)”. A instrução SQL possui uma particularidade que é retornar o
nome do cliente juntamente com os dados da tabela Orders de uma maneira
que, se for necessário criar as instruções para alterar os dados, o mesmo objeto
TableAdapter possa ser usado. Note o bloco:

(
SELECT CompanyName FROM Customers
WHERE CustomerID = Orders.CustomerID
) AS CompanyName

Desta forma, executando uma subconsulta, será possível aproveitar o mesmo

TableAdapter quando se precisar criar instruções Insert, Update e Delete.
Figura 19. Configurando a consulta da tabela Orders

Este método pode ser nomeado como “FillByOrderID” para ser fácil de
compreender (Figura 20).
Figura 20. Nomeando a consulta

Para preencher os dados da janela de consulta de registros, é necessário criar

um método que consulte todos os registros da tabela conforme a Figura 21.
Mas atenção, use a opção Add Query no Adapter existente, não adicione um
novo Adapter.
Figura 21. Adicionando uma segunda consulta à tabela Orders

Nomeie o método como demonstrado na Figura 22.

Figura 22. Definindo o nome da segunda consulta da tabela Orders

O último passo, é configurar a instrução que retorna os produtos vinculados

com o pedido da tabela Orders executando uma consulta na tabela Order
Details. Note que novamente uma subconsulta recupera o nome do produto
informado na tabela Order Details (Figura 23).
Figura 23. Definindo a consulta que retorna os produtos

Nomeie o método e finalize a definição deste TableAdapter (Figura 24).

Figura 24. Nomeando a consulta

Ao final da configuração, o DataSet possui os controles DataTable e

TableAdapters automaticamente vinculados e nomeados conforme o nomes do
banco de dados (Figura 25).
Figura 25. DataSet com os componentes finais

Configuração visual do aplicativo

Abra o formulário principal (frmPrincipal) configurando as propriedades
como na Tabela 1.

Propriedade Valor
Font Segoe UI; 8,25pt
Size 640; 480
Text Easy 9 - DataTable para XML

Tabela 1. Configurações do formulário principal

Adicione um controle Panel com as seguintes propriedades configuradas:

01. BackColor: White.

02. Dock: Top.

Dentro deste controle adicione dois controles Label e coloque o texto como
na Figura 26. No componente de título, defina a fonte como “Segoe UI;
11,25pt; style=Bold”. O formulário possui ainda um controle TabControl.
Adicione três controles TabPages (use a figura do formulário para tirar as
dúvidas sobre as configurações básicas). A primeira página será usada para
exportar os dados da tabela Customers. Foram acrescentados os seguintes
componentes:

01. Panel: para definir o título. Este controle teve a propriedade Dock também
configurada como Top para alinhar na parte de cima do controle e servir como
título adicional para a aba. Além disto, a propriedade Color está definida
como “WhiteSmoke”.

02. ListBox: lista os registros.

03. Button: sendo um para preencher os dados (nomeado como

“btnPreencher”) e outro para exportar (“btnExportarCustomers”).

Figura 26. Layout da tela principal com destaque para a primeira aba

A segunda aba, Orders, deve mostrar os dados da tabela de mesmo nome.

Possui os controles conforme na Figura 27. Para o título foi usado um
controle Panel conforme a primeira aba. Para os campos da tabela Orders
foram usados controles TextBox. Ao lado do campo Order ID foi
acrescentado um controle Button nomeado como “btnCarregar” que abre a
janela de pesquisa de registros e faz a carga do registro, caso algum seja
selecionado.

Para exibir os produtos, foi usado um controle DataGridView. O botão na

base da janela foi nomeado como btnExportarOrders e executa a exportação
dos dados para o arquivo XML.

Figura 27. Layout da aba para exportar a tabela Orders

Vinculando os campos com a tabela

Os aplicativos Windows Forms permitem a associação dos controles visuais
como o TextBox com os campos das tabelas de um banco de dados. Neste
projeto, estes devem ser ligados com o DataSet que foi configurado. Isto é
feito na janela de propriedades através do agrupador de propriedades
“(DataBindings)”. Para os controles, configure a propriedade Text vinculando
com os campos respectivos do banco. O funcionamento básico é demonstrado
na Figura 28.
Figura 28. Binding (ligação) dos controles visuais com o DataSet

Configurando as abas para

importação
O programa possuirá duas abas aninhadas na aba “Importar”. Acrescente um
controle TabControl neste TabPage. Configure as duas abas como na Figura
29 e Figura 30. Na página Customers além do controle do tipo Panel para
configurar o título e as instruções, foi inserido um Button
(btnImportarCustomers) e um controle DataGridView que vai exibir os dados
importados.
Figura 29. Layout da aba de importação da tabela Customers

A página Orders vai importar os dados desta tabela que estão gravados no
arquivo XML. Possui um controle Panel usado como título e para instruções,
um botão nomeado como “btnImportarOrders” e dois controles DataGridView
sendo um para a tabela Orders e outro para Order Details.
Figura 30. Layout da aba de importação da tabela Orders e Order Details

Para completar a configuração do formulário principal adicione dois

componentes não visuais sendo um do tipo SaveFileDialog para mostrar a
janela que seleciona o arquivo para configuração e outro componente
OpenFileDialog. Configure as seguintes propriedades dos dois controles da
mesma forma:

01. DefaultExt: *.Xml

02. Filter: Arquivos XML (*xml) | *.xml

Note que estes controles ficam na base da janela (Figura 31).

Figura 31. Componentes para janelas de diálogo

Janela de pesquisa e carga de

registros
O projeto precisará de uma janela para exibir os registros da tabela Orders.
Esta janela permitirá visualizar e carregar os registros. Adicione um novo
formulário ao projeto clicando com o botão direito do mouse sobre o ícone do
projeto na janela Solution Explorer. Nomeie este formulário como
“frmPesqOrders”. Este deve possuir um controle Panel como no formulário
principal. Um controle DataGrid para mostrar os registros. Este deve ser
vinculado a sua propriedade DataSource com a tabela Orders. Na base da
janela, adicione um controle Panel para servir de rodapé e um botão para
enviar o registro para a janela principal. Este botão deve ser nomeado como
“btnCarregar”. A Figura 32 ilustra o formulário de pesquisa.

Figura 32. Layout da janela de pesquisa da tabela Orders

Preenchendo os dados da janela de

pesquisa
Como a janela de pesquisa e carga dos registros não realizará uma pesquisa,
propriamente dito, mostrando os registros apenas, o melhor momento de
preencher o controle DataGridView é no evento Load do formulário.
Para poder enviar informação de qual registro deve ser enviado para ser
carregado no formulário principal, foi definida para este formulário uma
propriedade adicional que é colocada logo abaixo da definição da classe
(Listagem 4). Esta propriedade está acessível fora do formulário e armazena o
código de retorno do registro da tabela Orders que deverá ser carregado.

Listagem 4. Declaração da propriedade para retorno do registro Orders

selecionado

12 public partial class frmPesqOrders : Form

13 {
14 public int CodigoRetorno { get; set; }

Em seguida, no inspetor de eventos (visualizado pela tecla F4) você deve dar
um duplo clique no evento Load e escrever o código da Listagem 5.

Listagem 5. Carga dos registros na tela de pesquisa

20 // carrega os registros para a pesquisa

21 private void frmPesqOrders_Load(object sender, EventArgs
e)
22 {
23 // configura a conexão do table adapter
24 ordersTableAdapter.Connection = new
System.Data.SqlClient.SqlConnection(
25
System.Configuration.ConfigurationManager.ConnectionStrings["Northwind
"].ToString());
26 // executa a consulta dos registros
27 ordersTableAdapter.Fill(this.northwindDataSet.Orders);
28 // configura um valor inicial para a variável de retorno
29 CodigoRetorno = -1;
30 }

Este código inicia configurando a conexão do objeto TableAdapter na linha

24. A string de conexão necessária para a configuração da conexão com o
banco está sendo recuperada do arquivo de configurações app.config.

Nota: O TableAdapter do código foi adicionado ao formulário quando o contr

ole DataGridView foi vinculado com a tabela Orders do DataSet do projeto. N
ão deve ser problema fazer este tipo de ligação.

A linha 27 preenche a tabela e em seguida define-se um valor inicial para a

propriedade “CodigoRetorno”. O passo seguinte é escrever o código que
devolve o registro que foi selecionado para carga. Seu funcionamento consiste
em armazenar na variável “CodigoRetorno” o ID do registro que está
selecionado no controle DataGridView. A Listagem 6 mostra o código
necessário para esta tarefa. Este código selecionou a célula correspondente ao
campo ID tomando o cuidado de converter o valor (que no controle
DataGridView está armazenado como objeto).

Listagem 6. Retornando um registro

31 // armazena o código para retorno

32 private void btnCarregar_Click(object sender, EventArgs e)
33 {
34 CodigoRetorno = Convert.ToInt32(this.dataGridView1[0,
dataGridView1.SelectedCells[0].RowIndex].Value);
35 // fecha o formulário
36 this.Close();
37 }

A linha 34 lê o conteúdo da célula que contém o campo ID. Está sendo usado
um indexador numérico mas poderia ser usado o nome da coluna. No caso
desta janela, isto não pode ser feito porque o preenchimento das colunas está
sendo feito automaticamente.

Escrevendo os códigos para

carregar os dados
Abra o formulário principal. Pressione F7 para inspecionar o código. Se você
fez a ligação do controle ListView com a tabela Customers o Visual Studio
adicionou um código automaticamente para preencher este controle no evento
Load do formulário. Comente o código como na Listagem 7. Vamos deixar o
preenchimento do controle ListView de forma manual.

Nota: Em projetos do mundo real é interessante sempre estar inspecionando c

ódigos gerados automaticamente pelo Visual Studio principalmente para cone
xões e comunicação com bancos de dados. Principalmente se o arquivo de con
figurações for diferente do padrão do Visual Studio.

Listagem 7. Comentando o código gerado automaticamente

14 private void frmPrincipal_Load(object sender, EventArgs e)

15 {
16 // TODO: This line of code loads data into the
'northwindDataSet.Customers' table. You can move, or remove it, as
needed.
 17 //
this.customersTableAdapter.Fill(this.northwindDataSet.Customers);
18 }

Para escrever o código que preenche manualmente o controle ListView e

mostra os registros da tabela Customers dê um clique duplo sobre o botão
nomeado como “btnPreencher” na aba correspondente à tabela Customers.
A Listagem 8demonstra os passos a serem seguidos.

Listagem 8. Preenchendo os dados da tabela Customers

19 // Preenche o controle com dados da tabela "Customers"

20 private void btnPreencher_Click(object sender, EventArgs
e)
21 {
22 // configura a conexão do componente TableAdapter
23 customersTableAdapter.Connection = new
System.Data.SqlClient.SqlConnection(
24
System.Configuration.ConfigurationManager.ConnectionStrings["Northwind
"].ToString());
25 // executa a consulta
26
customersTableAdapter.Fill(this.northwindDataSet.Customers);
27 }

O código da linha 23 inicia configurando a conexão do objeto

customersTableAdapter (mais uma vez inserido automaticamente no
formulário quando se fez o vínculo do controle ListView com a tabela
“Customers” do DataSet do projeto). Na linha seguinte o método Fill preenche
a tabela. Para carregar os registros das tabelas Orders e Order Details é
necessário exibir primeiramente a janela de pesquisa (cujos códigos foram
definidos anteriormente). Selecione a aba referente a estas tabelas. Dê um
clique duplo no botão “Carregar” desta aba ( ). A Listagem 9 possui os
códigos para preenchimento.

Listagem 9. Carregando os dados das tabelas Orders e Order Details

28 // Carrega os controles vinculados com a tabela "Orders" e

"Order Details"
29 private void btnCarregar_Click(object sender, EventArgs e)
30 {
31 using (frmPesqOrders fmPesq = new frmPesqOrders())
32 {
 33 // mostra o formulário de seleção de registros
34 fmPesq.ShowDialog();
35
36 // verifica se algum registro foi selecionado
37 if (fmPesq.CodigoRetorno > 0)
38 {
39 // configura a conexão dos componentes TableAdapter
40 ordersTableAdapter.Connection = new
System.Data.SqlClient.SqlConnection(
41
System.Configuration.ConfigurationManager.ConnectionStrings["Northwind
"].ToString());
42 order_DetailsTableAdapter.Connection = new
System.Data.SqlClient.SqlConnection(
43
System.Configuration.ConfigurationManager.ConnectionStrings["Northwind
"].ToString());
44 // preenche a tabela "Orders"
45
ordersTableAdapter.FillByOrderID(this.northwindDataSet.Orders,
fmPesq.CodigoRetorno);
46 // preenche a tabela "Order Details"
47
order_DetailsTableAdapter.FillByOrderID(this.northwindDataSet.Order_De
tails, fmPesq.CodigoRetorno);
48 }
49 }
50 }

Na linha 31 é criada uma instância do formulário de pesquisa dentro de um

bloco using sendo que este é exibido na linha 34 de forma que a janela
principal fique inacessível até o usuário selecionar um registro e clicar no
botão “Carregar”. A partir da linha 37 é feita a inspeção da propriedade
“CodigoRetorno” do formulário de pesquisa, que, se for maior do que zero,
indica que um registro foi selecionado. Na linha 40 e 42 novamente são
configuradas as conexões dos objetos TableAdapter que fazem as consultas
para as tabelas Orders e OrderDetail respectivamente. Por fim, as linha 45 e
47 executam a consulta preenchendo os controles.

Exportando os dados
Para fazer a exportação dos dados o formulário conta com um método
chamado Gravar este deve ser vinculado tanto com o botão que exporta os
dados da tabela Customers como com o botão para exportar os dados da tabela
Orders. Abra o código do formulário principal e escreva o código
da Listagem 10.

Listagem 10. Código para gerar o arquivo XML

51 // Rotina para exportação

52 // Exporta tanto "Customers" como "Orders"
53 private void Gravar(Object sender, EventArgs e)
54 {
55 // variável para inspecionar qual o botão chamou a
rotina
56 Button botao;
57 // verifica se o evento foi disparado por um botão
58 if (sender is Button)
59 {
60 botao = (Button)sender;
61 }
62 else
63 {
64 return;
65 }
66 // mostra janela para gravar arquivo XML
67 saveFileDialog1.ShowDialog();
68
69 // se nenhum nome de arquivo foi informado, abandona
70 if (string.IsNullOrEmpty(saveFileDialog1.FileName))
71 {
72 return;
73 }
74
75 // verifica qual botão chamou pelo seu nome
76 if (botao.Name == "btnExportarCustomers")
77 {
78 // grava XML da tabela "Customers"
79
northwindDataSet.Customers.WriteXml(saveFileDialog1.FileName,
XmlWriteMode.WriteSchema);
80 }
81 else
82 {
83 // cria um DataSet vazio
84 DataSet ExportarPedido = new DataSet();
85 // adiciona uma cópia das tabelas
 86
ExportarPedido.Tables.Add(this.northwindDataSet.Orders.Copy());
87
ExportarPedido.Tables.Add(this.northwindDataSet.Order_Details.Copy());
88 // grava o arquivo XML
89 ExportarPedido.WriteXml(saveFileDialog1.FileName,
XmlWriteMode.WriteSchema);
90 }
91
92 MessageBox.Show("Exportou arquivo com sucesso.");
93 }

Para que este método possa ser vinculado com o evento Click dos botões é
necessário que sua assinatura seja com os parâmetros conforme está
demonstrado na linha 53. O primeiro elemento, do tipo object, armazena qual
controle que foi o responsável pela chamada do método. Na listagem, na linha
56 é criada uma variável do tipo Button para receber dados do controle que
fez a chamada.

O exemplo não permite que outro tipo de controle faça a chamada para o
método, mas, se por algum motivo, o evento estiver vinculado com outro tipo
de controle, antes de fazer a conversão do parâmetro “sender” do tipo “object”
para “button” é necessário verificar se esta variável contém realmente dados
de um objeto do tipo correto através da palavra chave da linguagem C# “is”
conforme demonstrado das linhas 58 a 64. A conversão para “Button”
somente é executada se o objeto for do tipo correto, caso contrário, a rotina é
abandonada.

Antes de exportar é preciso obter um nome de arquivo, assim, na linha 67 o

controle não visual SaveFileDialog mostra a janela que receberá o nome e
local para gravar o arquivo. Se nenhum nome válido for informado ou o
usuário pressionar a tecla ESC a propriedade FileName deste controle ficará
em branco, o que fará com que a rotina seja cancelada (linhas 70 e 72).

Chegou o momento de fazer a exportação propriamente dita. Para saber se o

botão que fez a chamada é da tabela Customers ou Orders está sendo
verificado o nome (linha 76). A exportação da tabela Customers é bem
simplificada, bastando chamar o método WriteXml do objeto DataTable. Este
método grava também a definição da estrutura do arquivo XML (schema)
como se pode notar no segundo parâmetro passado para o método, na linha
79. Já a exportação da tabela Orders é um pouco mais complexa. Para poder
usar um único arquivo no qual estejam as duas tabelas contidas é preciso
lançar mão de alguns truques.
O componente DataSet possui o método WriteXml da mesma forma que o
componente DataTable. Mas, como só desejamos exportar duas tabelas, não
podemos chamar o método no DataSet que está sendo usado para preencher os
controles. Assim foi criado na linha 84 um novo DataSet que receberá as
cópias das tabelas Orders (linha 86) e Order_Details (linha 87). Feito isto, é
hora de gravar o arquivo XML (linha 89).

Nota do DevMan

O método Copy da classe DataTable copia a estrutura e os dados para outra va

riável do mesmo tipo. É possível também copiar apenas a estrutura usando o
método “Clone”. Não é necessário preocupar-se com questões como a cultura
que os dados estão sendo armazenados, pois, ao gravar também o schema das
tabelas no arquivo, esta informação é armazenada corretamente.

Nota: No exemplo foi usado um único método para fazer a exportação apenas
para fins didáticos, principalmente, para demonstrar como inspecionar o tipo d
e um objeto enviado para um método. Entretanto, você pode achar interessant
e escrever métodos separados para exportar as tabelas.

Após escrever os códigos anteriores, você deve selecionar os botões da aba

Customer e Orders, vincular com o método Gravar a partir da janela de
manipulação de eventos do Visual Studio configurando a propriedade Click
conforme a Figura 33.

Figura 33. Vinculando o evento Click com o método Gravar

Importando os arquivos XML

A importação dos dados é feita pelo método ReadXml que quando usado
sobre um arquivo XML com os dados da estrutura (schema) gravados
juntamente com o seu conteúdo garantem uma carga perfeita do arquivo.
Primeiramente está demonstrado na Listagem 11 como é feita a importação
do conteúdo da tabela Customers.

Listagem 11. Importação do arquivo XML da tabela Customers

94 // Importação do arquivo Customers

95 private void btnImportarCustomers_Click(object sender,
EventArgs e)
96 {
97 // mostra a janela para selecionar o arquivo XML
98 openFileDialog1.ShowDialog();
99
100 // se nenhum nome de arquivo foi informado, abandona
101 if (string.IsNullOrEmpty(openFileDialog1.FileName))
102 {
103 return;
104 }
105 // cria uma tabela para receber os dados
106 DataTable TabelaCustomers = new DataTable("Customers");
107 // faz a leitura do arquivo XML
108 TabelaCustomers.ReadXml(openFileDialog1.FileName);
109 // envia os dados para o controle
110 this.gridCustomers.DataSource = TabelaCustomers;
111 }

Na linha 98 o programa abre uma janela de diálogo do tipo OpenFile para que
o usuário informe qual o arquivo deve ser lido. Se nenhum nome válido foi
informado (linha 101) a rotina é encerrada, caso contrário, é criada uma
instância de um objeto DataTable para poder ler o arquivo XML (linha 106).
O método ReadXml é chamado na linha 108 e o os dados carregados são
passados como fonte de dados para o controle DataGridView na linha 110.

Nota: No exemplo do artigo o controle DataGridView não possui as colunas c

onfiguradas sendo que o seu conteúdo é preenchido dependendo do conteúdo
do arquivo XML. Entretanto, em aplicações do mundo real, pode ser necessári
o validar a estrutura do arquivo XML e também os nomes de campos que serã
o carregados. Este detalhe é importante pois, caso sejam carregadas colunas q
ue não estejam configuradas no controle, o conteúdo do arquivo não será visu
alizado.

A leitura do conteúdo das tabelas Orders e Order Details é feita de uma

maneira diferente. Como o arquivo XML foi gravado com o conteúdo das
duas tabelas, é mais prático usar uma classe DataSet para carregar as duas
tabelas como a Listagem 12 demonstra.
Listagem 12. Importação das tabelas Orders e Order Details

112 // Importa o arquivo XML com as tabelas "Orders" e "Order

Details"
113 private void btnImportarOrders_Click(object sender,
EventArgs e)
114 {
115 // mostra a janela para selecionar o arquivo XML
116 openFileDialog1.ShowDialog();
117
118 // se nenhum nome de arquivo foi informado, abandona
119 if (string.IsNullOrEmpty(openFileDialog1.FileName))
120 {
121 return;
122 }
123 // cria um DataSet de cópia para receber os dados.
124 DataSet DataSetImporta = new DataSet();
125 // faz a leitura dos arquivos XML
126 DataSetImporta.ReadXml(openFileDialog1.FileName);
127 // preenche os controles DataGrid com os dados.
128 this.gridOrders.DataSource = DataSetImporta.Tables[0];
129 this.gridOrderDetails.DataSource =
DataSetImporta.Tables[1];
130 }

Pelo código, das linhas 116 até 121 é buscado e validado um nome de arquivo
para ser carregado. A linha 124 cria um objeto DataSet que possui o método
ReadXml igual a classe DataTable. O método ReadXml carrega
automaticamente o conteúdo das tabelas, definindo um DataTable para cada
uma que for encontrada no arquivo. Isto simplifica bastante o trabalho uma
vez que, para percorrer os nós XML do arquivo seriam necessários muitos
passos. No interior da classe DataSet as tabelas podem ser acessadas através
dos enumeradores “[]” do C# e com isso, facilmente pode-se preencher os
controles DataGridView vinculando a propriedade DataSource com a tabela
adequada.

Nota: Novamente é importante observar que no projeto de exemplo não foi co

nsiderado que em vez de a tabela acessada pelo índice zero apontar para a tabe
la Orders, pudesse estar apontando para Order Details. O nome da tabela carre
gada pode ser verificado através da propriedade TableName.

Execute o projeto corrigindo eventuais erros e problemas que possam ocorrer.

Nas figuras a seguir são demonstradas algumas das janelas do programa sendo
executado como a Figura 34 que mostra os dados da tabela Customers.
Figura 34. Janela de exportação da tabela Customers

Na Figura 35 a janela para pesquisar os registros da tabela Orders.

Figura 35. Pesquisando dados da tabela Orders

Por fim, na Figura 36, um registro carregado da tabela Orders com os

produtos informados.
Figura 36. Visualizando detalhes da tabela Orders

Conclusão
É sempre complicado tentar demonstrar os pontos principais de um recurso
porque o que em um projeto é essencial pode não ser em outro, entretanto, o
que foi exposto pode ser um bom ponto de partida para quem precisa trabalhar
com arquivos XML e precisa fazer isso com agilidade.

Existem muitas áreas onde os documentos XML estão presentes, para citar
apenas uma e com um alto grau de importância cito o projeto da Nota Fiscal
Eletrônica (NFE) que usa este formato de documento para envio e recepção
dos dados das empresas.

O trânsito de dados pela Internet baseado no protocolo SOAP usa o formato

XML como padrão, ainda que alguns dados binários precisem ser enviados, o
XML é o “envelope” que carregará estes dados. Então, quanto mais formas de
se criar arquivos XML forem conhecidas pelo desenvolvedor, mais
rapidamente este poderá resolver os problemas que possam surgir.
Finalmente fica a dica: além do ADO.NET o framework disponibilizou a
linguagem LINQ to XML que lê e grava arquivos XML e também recursos
para a serialização das classes de dados para este formato. Está aí uma boa
dica de leitura. Até a próxima.

Links

Desenvolvimento de aplicações Windows Client

http://www.windowsclient.net.

Download Visual Studio 2010 Express

http://www.microsoft.com/express/Downloads/

Tutorial do W3C sobre XM

http://www.w3schools.com/xml/default.asp

Definição do W3C sobre Xml Schema

http://www.w3.org/XML/Schema

Introduction to XML Schema

http://www.w3schools.com/schema/schema_intro.asp

Using W3C XML Schema

http://www.xml.com/pub/a/2000/11/29/schemas/part1.html

Reading and Writing XML Schemas

http://msdn.microsoft.com/en-us/library/04x694fe%28v=VS.100%29.aspx

Documentação oficial da Microsoft sobre DataTable e WriteXml

http://msdn.microsoft.com/en-us/library/system.data.datatable.writexml.aspx

DataTables (ADO.NET)
http://msdn.microsoft.com/en-us/library/t31h6yhs.aspx

ADO.NET Overview
http://msdn.microsoft.com/en-us/library/h43ks021(v=VS.100).aspx

SQL Server 2008 R2 Express

http://www.microsoft.com/express/database/

Download do Northwind
http://download.microsoft.com/download/d/e/5/de57f203-3140-43e0-9473-d6
94d45bbd9b/SQL2000SampleDb.msi
 por Vladimir Rech
Guru .net e tecnologias MS

Enviando e-mails
O artigo mostra como é fácil e rápido enviar
e-mails utilizando a plataforma .NET. Com
poucos passos e alguns conceitos qualquer
programa pode ser adaptado para envio de
mensagens de e-mail usando os recursos
que serão demonstrados.

De que se trata o artigo

O artigo mostra como é fácil e rápido enviar e-mails utilizando a plataforma

.NET. Com poucos passos e alguns conceitos qualquer programa pode ser
adaptado para envio de mensagens de e-mail usando os recursos que serão
demonstrados.

Para que serve

O envio de e-mails usando a plataforma .NET pode ajudar quando for

necessário adaptar uma aplicação comercial onde haja a necessidade de envio
de informações ou arquivos por este meio de comunicação.

Em que situação o tema é útil

Mesmo havendo um grande número de programas que enviem e-mails, em

vários casos é necessário fazer com que o programa – que pode ser um
aplicativo comercial – tenha a capacidade de enviar os seus dados via e-mail,
de forma personalizada.

Enviando e-mails no .NET Framework

Uma das primeiras formas de aplicação prática que surgiram na Internet foi a
troca de mensagens, logo apelidada de “E-mail” originalmente referindo-se a
“Eletronic Mail” ou, “Correio Eletrônico”. Hoje em dia este tipo de
nomenclatura parece obsoleto, entretanto, o seu uso ainda é intenso. O envio
de mensagens usando a Internet como meio de transmissão passa pela solução
de diversos problemas como o tipo de protocolo a ser usado, o servidor usado
para fazer o roteamento da mensagem, credenciais do usuário para poder usar
o servidor, formato da mensagem etc. Durante algum tempo era uma tarefa
bem difícil considerando os problemas acima, mas a evolução das linguagens
e plataformas permitiu que hoje tudo seja mais fácil. O framework .NET é
uma das plataformas que facilita muito o trabalho. Com poucas classes o
desenvolvedor poderá facilmente agregar ao seu aplicativo a funcionalidade
de envio de dados usando as mensagens de e-mail. Mesmo existindo muitos
programas específicos para esta finalidade, programas comerciais precisam
enviar os dados que estes manipulam e geram.

Autores: Márcio Fábio Althmann e Vladimir Rech

Independente do tipo de aplicação que desenvolvemos, Web ou Windows, se

é utilizando ASP.NET, Winforms, WPF entre outras, sempre precisamos
enviar e-mails, desde um simples formulário de contato em um WebSite, a
pedidos de compra. Para dar uma ideia da integração desta função com os
sistemas operacionais abra o prompt de comandos do Windows e digite o
comando como na Figura 1.
Figura 1. Chamando o envio de e-mail através do prompt de comandos

Este comando abrirá uma janela do programa padrão de e-mail – se houver

algum instalado – para envio, como mostra a Figura 2.

Figura 2. Janela de envio de e-mail aberta pelo prompt de comandos

Embora esta facilidade exista, é pouco provável que você venha a usar este tip
o de comando com frequência, principalmente porque é pouco intuitivo. Em t
odos os casos, serve para demonstrar como houve evolução dos sistemas oper
acionais no sentido de se integrar com as tarefas que podem ser feitas usando-
se a Internet, inclusive o envio de mensagens de e-mail.

No .NET Framework o envio de e-mail pode ser feito de forma fácil e rápida,
graças às classes disponíveis no namespace System.Net.Mail, onde temos todo
o controle necessário para a criação de e-mails, configuração de servidor entre
outros.

System.Net.Mail
Tudo que precisamos para o envio de e-mails está no namespace
System.Net.Mail, na versão 1.0 do .NET utilizávamos o namespace
System.Web.Mail, mas desde a versão 2.0, foi criado o System.Net.Mail, com
mais funcionalidades e mais flexível, então não confudir na declaração do
namespace, o recomendado desde a versão 2.0 do .NET Framework é este
último citado. Dentre todas as classes disponíveis nele as principais e mais
utilizadas são:

• SmtpClient;

• MailMessage;

• MailAddress.

A classe SmtpClient
É a classe responsável pelo envio do e-mail, onde vamos informar qual o
nosso servidor de SMTP, segurança, vamos informar qual o usuário e senha
para autenticação. Um exemplo simples das configurações que podemos fazer
está naListagem 1.

Listagem 1. Código básico para envio de e-mail

14 var smtpClient = new SmtpClient();

15 smtpClient.Host = "smtp.marcioalthmann.net";
16 smtpClient.Port = 587;
17 smtpClient.Credentials = new
NetworkCredential("usuario", "senha");
18 smtpClient.EnableSsl = true;

Este exemplo requer System.Net e System.Net.Mail. Atenção para a porta de

envio na linha 16, normalmente os provedores de envio de e-mail usam outras
portas. Esta informação deve ser obtida com o provedor ou o administrador do
servidor. Verifique também se realmente está habilitado SSL para envio de e-
mail (linha 18).

Nota do Devman

A sigla SSL significa Secure Sockets Layer, a configuração desta propriedade

faz com que a mensagem seja criptografada durante o seu envio, o que dificult
a sua interceptação no meio do caminho e verificação do seu conteúdo por pes
soas não autorizadas.

Na linha 15 é informado qual o servidor que será usado para o envio. Outro
item importante é a identificação do usuário do servidor (host) através da
propriedade Credentials. Na linha 17 estão sendo enviados um nome e uma
senha (que deverão ser obtidas em um arquivo de configuração, por exemplo,
ou através da digitação do usuário). Uma outra maneira de se definir as
credenciais do usuário é da seguinte forma:

smtpClient.Credentials = CredentialCache.DefaultNetworkCredentials;

Neste caso, se o sistema a partir do qual se estiver enviando o e-mail for

também configurado para envio – o que requer configuração do servidor e vai
ser comum por exemplo em um servidor Web – e também o usuário que
executa o programa estiver cadastrado no mesmo, deixa-se de lado o envio
dos dados do usuário pois serão usadas as credenciais integradas com o
sistema.

Observe, entretanto, que isto só ocorrerá em um cenário bastante específico.

Por outro lado, também é necessário tomar cuidado com a forma que as
credenciais são enviadas pois dados críticos de segurança como a senha do
usuário, devem ser protegidas para evitar o uso e acesso indevido.

A classe SmtpClient ainda possui duas formas de envio do e-mail, com os

métodos Send() e SendAsync(), a diferença entre os dois é simples, o
SendAsync() manda o e-mail de forma assíncrona, ou seja nossa aplicação não
vai parar esperando o envio do e-mail, então temos que ter um trabalho a
mais, como tratar evento de conclusão de envio.

A classe MailMessage
É utilizando a classe MailMessage que vamos configurar nosso e-mail, desde
quem está enviando, quem vai receber, se vamos enviar no formato de HTML,
título do e-mail, corpo do e-mail, é nela que também configuramos os anexos.
As principais propriedades desta classe estão exibidas na Tabela 1. A classe
MailMessage interage com várias outras classes do namespace, como por
exemplo, a classe MailAddress.
Propriedade Conteúdo
AlternativeViews Retorna uma coleção com os formatos alternativos que
podem ser usados para a mensagem. Por exemplo, ao se
enviar uma mensagem no formato HTML, pode se
enviar também nesta propriedade uma versão da mesma
mensagem no formato de texto puro para evitar que a
mensagem seja incorretamente exibida para o
destinatário, caso o programa que este esteja usando não
dê suporte para este formato – como por exemplo
mensagens visualizadas em alguns tipos de dispositivos
móveis ou programas de e-mail de outras plataformas.
Attachments Retorna uma coleção com os anexos que estão
vinculados com a mensagem. Use esta propriedade
quando precisar enviar algum arquivo junto com a
mensagem de e-mail. Este objeto é do tipo
AttachmentCollection – corresponde a uma coleção de
objetos da classe Attachment.
Bcc Retorna uma coleção contendo os endereços para o qual
será enviada uma cópia oculta (blind carbono copy) da
mensagem atual.
Body Representa o corpo da mensagem.
BodyEncoding Usada para definir a codificação – tipo de caracteres
ligados com o idioma – em que a mensagem será
enviada.
CC Retorna uma coleção com os endereços de e-mail para
os quais uma cópia da mensagem será enviada.
DeliveryNotificationOptions Configura o tipo de mensagem de entrega que será
usada para a mensagem. Use esta propriedade, por
exemplo, se desejar que o destinatário envie uma
confirmação do recebimento ou de leitura da mensagem
de e-mail.
From Configura o endereço de e-mail do remetente da
mensagem.
Headers Retorna os dados do header da mensagem (dados
adicionais).
HeadersEncoding Configura a codificação dos dados do header da
mensagem.
IsBodyHtml Informa se o corpo da mensagem está no formato
HTML ou não.
Priority Marca a prioridade a ser usada para a mensagem.
ReplyToList Configura uma coleção de endereços para os quais a
resposta para a mensagem poderá ser enviada.
Sender Configura um endereço de e-mail do remetente da
mensagem (semelhante a propriedade From).
Subject Usado para configurar o assunto da mensagem.
SubjectEncoding Define a codificação do campo Subject.
To Retorna uma lista com os endereços dos destinatários da
mensagem

Tabela 1. Principais propriedades da classe MailMessage

Nota do DevMan

Nesta tabela, todos os itens onde são retornadas coleções de objetos as operaç
ões para acrescentar ou remover itens são feitas através dos métodos Add ou
Remove comuns para as coleções de objetos. Deve-se apenas observar que ca
da tipo de coleção corresponde a uma classe e deve-se conhecer detalhes desta
s classes. Também é importante perceber que nem sempre todos estes itens ser
ão usados, principalmente quando o tipo da mensagem for básica, mas é impor
tante conhecer quais os elementos pois, com certeza alguns virão a ser bem us
ados, como o envio de arquivos anexos.

Na Listagem 2, com o código básico para envio de uma mensagem de e-mail.

O primeiro passo é criar uma instância da mensagem (linha 14), seguido do
remetente (linha 15). Em seguida, um destinatário padrão é configurado na
linha 16 e nas linhas seguintes, destinatários adicionais são acrescentados. Na
linha 18 é feita a configuração do assunto da mensagem – lembre-se: é
importante um assunto para a mensagem de e-mail, o que fará com que seja
lida ou não pelo destinatário. Na linha 19 indicamos que a mensagem está no
formato HTML e, na linha 20 é enviado para o corpo da mensagem o código
HTML com a mensagem.

Listagem 2. Código para envio de uma mensagem

14 var email = new MailMessage();

15 email.From = new
MailAddress("[email protected]");
16 email.To.Add("[email protected]");
17 email.To.Add("[email protected]");
18 email.Subject = "Teste de e-mail";
19 email.IsBodyHtml = true;
20 email.Body = string.Format("Teste de envio de e-mail <br
/> {0}", DateTime.Now);

Outras formas de se enviar uma mensagem são através da inicialização direta

dos principais elementos:
 MailMessage msgEmail = new MailMessage(
“[email protected]”,
“[email protected]”,
“Teste de e-mail”,
“Teste de envio de e-mail”);

Neste exemplo os principais dados são passados diretamente para o construtor

na sequência: remetente, destinatário, assunto e corpo da mensagem (que está
no formato de texto puro).

A classe MailAddress
A classe MailAddress pode ser utilizada nas propriedades From, To, CC e
BCC da MailMessage, é nela que criamos um endereço de e-mail, de envio ou
recebimento, também podemos definir um nome mais amigável ao endereço
de e-mail:

var email = new MailMessage();

email.From = new MailAddress("[email protected]", "Márcio
Fábio Althmann");
email.To.Add(new MailAddress("[email protected]",
"Márcio Althmann –
Consultoria"));

Existe uma diferença desse código para o anterior, onde mostrei a

MailMessage, nas propriedades To, CC e BCC, não precisamos criar a classe
MailAddress como está no código anterior, podemos simplesmente passar
uma string como e-mail. O uso desta classe ou da inicialização direta não afeta
diretamente o envio da mensagem e deve se usar o que for mais apropriado ao
projeto que se está trabalhando.

O projeto de exemplo
Como foi demonstrado até este ponto, o envio de e-mail é bastante
simplificado com o .Net, logo não há muito o que inventar ao se fazer um
projeto deste tipo. A aplicação vai ter a função de envio de mensagens usando
as configurações que forem digitadas pelo usuário. Nenhuma função de
persistência será implantada, isso você poderá fazer mais tarde, apenas será
criada uma interface para o propósito de envio de e-mail. Crie um novo
projeto do tipo Windows Forms no Visual Studio através do menu File > New
Project, como mostra a Figura 3.
Figura 3. Criando o projeto no Visual Studio 2010

Lembre-se que alguns detalhes como a localização do projeto e o nome podem

variar, mantenha apenas a linguagem a ser usada, através da escolha da janela
Installed Templates. Também é possível fazer o projeto usando o Visual Studi
o 2008 já que o código e os elementos que serão usados pertencem a esta vers
ão da IDE.

Design geral
Ao criar o projeto imediatamente um formulário padrão é adicionado.
Acrescente os seguintes componentes ao formulário para o design principal
que pode ser conferido na Figura 4:

• Panel (Painel), alinhado no topo da janela para o título e instruções;

• TabControl que conterá duas abas sendo uma para digitação do

endereçamento da mensagem e a segunda, para as configurações de envio;

• TextBox, alinhado logo abaixo do controle anterior e com a propriedade

Multiline como true para permitir digitar todo o texto da mensagem;

• StatusStrip na base do formulário com um controle do tipo Label

acrescentado e nomeado como lblStatus para mostrar o estado da aplicação.
Figura 4. Tela principal do projeto

Alinhe os controles Panel e TabControl no topo da janela preenchendo a propr

iedade Dock como Top e o controle TextBox com a mesma propriedade preen
chida com Fill para que o alinhamento fique parecido com o da figura.

Adicione ainda, através da barra de ferramentas Dialogs do Visual Studio, um

componente OpenFileDialog que será o responsável por mostrar a janela
padrão do Windows para abrir arquivos. É com este controle que o usuário
poderá selecionar um arquivo para envio como anexo. Os demais controles
têm os seus detalhes descritos a seguir.

Aba de endereçamento
É na primeira aba do controle TabControl onde o usuário deverá digitar os
dados de endereçamento da mensagem, para tanto arraste os seguintes
controles para a janela:

• Controle Button nomeado como btnEnviar. É no evento Click deste que será
definido o código para o envio da mensagem;
• Seis controles do tipo TextBox nomeados respectivamente como:
txtRemetente, txtDestinatario, txtCopia, txtBCC, txtAssunto, txtAnexo;

• Ao lado do último controle de texto adicione outro Button nomeado como

btnSelecionarArquivo.

Verifique o layout da tela na Figura 5.

Figura 5. Aba de endereçamento

Nota do Devman

Neste exemplo não se está fazendo considerações sobre validações dos dados
como o endereço de e-mail, por exemplo. Entretanto, existem maneiras de se
validar este tipo de informação forçando inclusive o usuário a digitar somente
caracteres minúsculos nos campos e validando o endereço de e-mail com o us
o de expressões regulares. No momento este tipo de tratamento não cabe aqui,
mas pesquise sobre estas funcionalidades e enriqueça os projetos através da ag
regação destas funcionalidades.

Aba de configurações
É na segunda aba onde os dados da conexão serão digitados. Acrescente três
controles TextBoxs nomeando-os respectivamente como txtServidor,
txtUsuario e txtSenha. Neste último controle configure a propriedade
UseSystemPasswordChar como true para que ao digitar a senha o conteúdo do
campo não seja exibido. O design desta aba deve ficar parecido com o
da Figura 6.
Figura 6. Aba de configurações

Nota do Devman

Considere aprender um pouco mais sobre o uso dos arquivos de configuração

dos projetos do framework .Net para persistir e recuperar os dados das configu
rações das aplicações. Os projetos do tipo Windows Forms possuem um arqui
vo app.config que facilita bastante este trabalho. Verifique os números anterio
res da revista onde eu mesmo tratei deste assunto.

Anexando arquivo
As mensagens de e-mail podem eventualmente conter arquivos anexos. No
projeto de exemplo esta funcionalidade vai ser implementada. Para facilitar a
localização dos arquivos no computador, foi acrescentado um controle não
visual do tipo OpenFileDialog. Com isto um componente deve estar
disponível na parte de baixo da janela de design como mostra a Figura 7.

Figura 7. Componentes não visuais do formulário

A ideia geral é que ao clicar no botão com a legenda “...” que foi colocado ao
lado do campo Anexo, uma janela seja mostrada para se escolher o arquivo,
que pode ser de qualquer tipo. A Listagem 3 mostra o código necessário para
a pesquisa do arquivo.

Listagem 3. Pesquisando o arquivo

14 //Carrega arquivo para anexar

 15 private void btnSelecionarArquivo_Click(object sender,
EventArgs e)
16 {
17 openFileDialog1.ShowDialog();
18 if (!string.IsNullOrEmpty(openFileDialog1.FileName))
19 {
20 txtAnexo.Text = openFileDialog1.FileName;
21 }
22 }

Neste código o componente é exibido na linha 17 e a seguir é feita uma

inspeção se o arquivo foi informado corretamente e caso afirmativo, na linha
20 o código armazena o nome no campo respectivo.

Enviando a mensagem
Com todos os campos preenchidos ao clicar no botão Enviar da interface o
código deve preencher os dados da classe MailMessage e também SmtpClient.
No código da Listagem 4 estão colocados todos os passos desta aplicação de
exemplo para fazer o envio, além de alguns tratamentos para evitar problemas.

Listagem 4. O código para fazer o envio da mensagem

23 //Faz o envio de e-mail

24 private void btnEnviar_Click(object sender, EventArgs e)
25 {
26 //Inicializa a mensagem
27 using (MailMessage msgEmail = new
MailMessage(txtRemetente.Text, txtDestinatario.Text, txtAssunto.Text,
txtMensagem.Text))
28 {
29 lblStatus.Text = "Aguarde...";
30 //Configura valores adicionais
31 if (!string.IsNullOrEmpty(txtCopia.Text))
32 {
33 //Endereço para envio de cópia
34 msgEmail.CC.Add(txtCopia.Text);
35 }
36
37 if (!string.IsNullOrEmpty(txtBCC.Text))
38 {
39 //Endereço para "Blind copy"
40 msgEmail.Bcc.Add(txtBCC.Text);
 41 }
42
43 if (!string.IsNullOrEmpty(txtAnexo.Text))
44 {
45 //Anexo
46 msgEmail.Attachments.Add(new
Attachment(txtAnexo.Text));
47 }
48
49 //Detalhes de envio
50 SmtpClient smtpMail = new
SmtpClient(txtServidor.Text);
51 //Credenciais do usuário da rede
52 smtpMail.Credentials = new
NetworkCredential(txtUsuario.Text, txtSenha.Text);
53 try
54 {
55 smtpMail.Send(msgEmail);
56 MessageBox.Show("Mensagem enviada com sucesso.");
57 }
58 catch (Exception ex)
59 {
60 MessageBox.Show(string.Format("Não foi possível
enviar a mensagem.\n{0}", ex.Message));
61 lblStatus.Text = "Erro!";
62 }
63 }

Logo de início é feita uma inicialização da classe MailMessage passando os

principais elementos para o objeto através do construtor (linha 27). Para que o
usuário não pense que o programa parou de responder – o que é comum no
caso de aplicações conectadas – uma mensagem é configurada na barra de
status (linha 29).

Neste código algumas validações são feitas, a primeira (da linha 31 a 35) é
verificar se algum endereço foi digitado no campo “CC”. Este campo é
responsável pelo endereço do Carbon Copy para envio de uma cópia – visível
aos outros destinatários. Ou seja, ao preencher este campo, todos os
destinatários saberão quem está recebendo uma cópia do e-mail.

O passo seguinte é inspecionar o campo BCC (linhas 37 a 40) e verificar para

quais destinatários serão enviadas cópias ocultas ou Blind Carbon Copy.
Neste caso, os outros destinatários não terão conhecimento destes outros
endereços, mas os destinatários das BCC saberão os endereços dos
destinatários do campo Destinatário e CC.

<

Caso seja necessário enviar uma mensagem para vários destinatários mas não
se deseja que nenhum tome conhecimento do endereço de e-mail do outro, de
ve-se preencher somente o campo Bcc da mensagem. Isto evita inclusive a pro
pagação das mensagens indesejadas de e-mail (spans).

No bloco da linha 43 até a 47 se o campo contendo o nome do anexo estiver

preenchido, este nome é anexado também à mensagem. Observe que este
código não verifica o tipo do arquivo e nem se o mesmo existe, isto deverá ser
feito pois, se tentar enviar um arquivo inexistente, o programa irá causar uma
exceção. Terminada a configuração da mensagem a linha 50 inicializa o
objeto SmtpClient passando para o construtor da classe o endereço do
servidor.

No projeto de exemplo a única configuração adicional que está sendo feita

neste controle é a passagem das credenciais do usuário a serem usadas para
autenticação e envio da mensagem (linha 52), considere, quando estiver
trabalhando em um projeto do mundo real, trocar este tipo de autenticação
(obtida através da digitação em um formulário), pela leitura de parâmetros de
configuração armazenados da aplicação ou ainda, em um banco de dados
vinculado com o programa.

O bloco try...catch da linha 53 até 62 executa o método Send. O uso deste

bloco garante que caso algum problema ocorra uma mensagem mais ou menos
amigável seja enviada para o usuário e o programa não trave ou feche
abruptamente – o que certamente causa algum transtorno para o usuário.

Nota do Devman

Considere fazer um bloco try...catch mais elaborado nos projetos do mundo re

al. A classe SmtpClient possui vários tipos mais específicos de exceção que p
odem ser filtrados para ajudar o desenvolvedor a resolver problemas que venh
am a acontecer. Além disto, não adianta muito o uso do bloco de tratamento d
e erros sem que estes ajudem a descobrir o causador do erro. Em todos os caso
s, como está sendo focado apenas no envio, verifique a classe System.Net.Mai
l.SmtpClient e suas Exceptions posteriormente na documentação do framewor
k.

Enviando o e-mail
Preencha os dados da mensagem colocando os seus próprios dados de
endereços da mesma forma como foi feito na Figura 8.

Figura 8. Preenchendo dados da mensagem

Em seguida, na aba configurações preencha os dados das configurações

substituindo os dados que estão na Figura 9 pelos seus dados de servidor de
e-mail.
Figura 9. Configurações para o envio

Conclusão
Mesmo com especialistas apontando o fim da era do e-mail, acho difícil nos
livrarmos do bom e velho e-mail tão cedo, principalmente no meio
corporativo. Com o .NET podemos enviar e-mails simples como o
demonstrado aqui, a e-mails mais complexos, a qualquer momento, não
precisamos depender do cliente possuir um client de e-mail instalado para
conseguir enviar e-mails pelos nossos sistemas, podemos automatizar essa
tarefa e facilitar a vida dos nossos clientes. Considere situações, por exemplo,
de mala direta, envio de documentos vinculados a processos (como o projeto
NF-e), publicidade (embora, neste caso, é necessário uma permissão dos
destinatários), mailings lists etc., as possibilidades são muitas e certamente,
será fácil de serem executadas com .Net e as suas classes.

Links

MailMessage Class
http://msdn.microsoft.com/en-us/library/system.net.mail.mailmessage.aspx
System.Net.Mail Namespace
http://msdn.microsoft.com/en-us/library/system.net.mail.aspx

Site com informações detalhadas sobre System.Net.Mail

http://www.systemnetmail.com/

Desenvolvimento de aplicações Windows Client

http://www.windowsclient.net.

Download Visual Studio 2010 Express

http://www.microsoft.com/express/Downloads

por Equipe DevMedia

Guru .net e tecnologias MS

Windows Phone 7
O artigo apresentará uma introdução básica
ao Windows Phone 7 e um overview sobre
a criação de telas utilizando o Silverlight. O
Silverlight disponibiliza um recurso chamado
layout controls, utilizaremos no artigo para
criar o layout das telas no Windows Phone
7.

De que se trata o artigo

O artigo apresentará uma introdução básica ao Windows Phone 7 e um

overview sobre a criação de telas utilizando o Silverlight. O Silverlight
disponibiliza um recurso chamado layout controls, utilizaremos no artigo para
criar o layout das telas no Windows Phone 7.

Para que serve

Os layout controls são os controles para a criação do layout das telas no
Windows Phone 7 utilizando o Silverlight, com eles podemos dispor os
elementos na tela conforme os recursos que cada layout control disponibiliza.

Em que situação o tema é útil

O Windows Phone 7 tem suporte ao Microsoft Silverlight e ao Microsoft

XNA, o Silverlight é a tecnologia indicada para a criação de aplicativos no
Windows Phone 7 e o XNA é voltado para a criação de jogos. Os Layout
Controls são recursos disponíveis para a manipulação dos elementos nas telas
em Silverlight, se você quiser desenvolver qualquer aplicativo para o
Windows Phone 7 com Silverlight você deverá conhecer os layout controls.

Windows Phone 7 – Trabalhando com Layout Controls

Os Layout Controls são os recursos do Silverlight para desenhar os layouts. É

possível criar aplicativos utilizando todo o poder do Silverlight para
desenvolver aplicativos ricos para o Windows Phone 7. Neste artigo veremos
quais são os controles de layout disponíveis para o WP7 e também como
utilizá-los.

Neste artigo apresentarei uma breve introdução ao Windows Phone 7, com

foco no layout das telas, utilizaremos na prática os layout controls Grid,
StackPanel, Canvas, Border e Scrollviewer. Estarei utilizando o Visual Studio
2010 Premium, mas você poderá utilizar as versões gratuitas da Microsoft, o
Visual Studio 2010 Express ou o Expression Blend for Windows Phone,
ambos são instalados junto com o Windows Phone Developers Tools.

Nota do DevMan

O Expression Blend é uma ferramenta da Microsoft cujo o objetivo principal é

auxiliar no desenvolvimento de designs em Silverlight, WPF e WP7, nela voc
ê pode criar interfaces aprimoradas para suas aplicações. O Expression Blend
é totalmente integrado ao Visual Studio. O Microsoft Expression Blend 4 já es
tá disponível para download de avaliação no site da Microsoft.

Nota do DevMan

O WPF (Windows Presentation Foundation) é um componente do .net framew

ork que possibilita criar aplicações elaboradas voltadas para Windows, é a bas
e do Silverlight.

Com a evolução dos aparelhos celulares, cada vez mais estamos trocando-os
com mais frequência, um dos motivos é a melhoria ou inclusão de diversos
recursos que facilitam o dia a dia de quem gosta de utilizar o celular para
tarefas além de fazer e receber ligações. Essa evolução tecnológica no
hardware também refletiu em uma evolução tecnológica no software, com
destaque aos sistemas operacionais que atualmente temos disponíveis.

Atualmente temos celulares ou smartphone com telas de tamanhos maiores e

recursos de touch screen, com isso os aplicativos que rodam sobre esses
equipamentos usam e abusam desses pontos. Antigamente o desenho das telas
eram bem limitados, não existiam recursos suficientes para criar um aplicativo
em ambiente mobile que fosse bonito e prático. Com os equipamentos atuais
temos a possibilidade de criar aplicativos visualmente ricos e funcionais, e
com isso surgiram ferramentas de desenvolvimento poderosas que
possibilitam ao desenvolvedor a criação desses softwares.

É neste cenário que a Microsoft apresentou recentemente o seu mais novo

sistema operacional chamado de Windows Phone 7, ou WP7, que é totalmente
diferente dos outros sistemas operacionais da Microsoft para a plataforma
mobile. Com ele é possível criar aplicativos de negócios utilizando todo o
poder da tecnologia Silverlight ou criar jogos modernos com o framework
XNA.

O XNA é um framework completo e maduro para a criação de jogos, tanto

para PCs com Windows , como para o XBOX 360 e o Windows Phone 7. O
Silverlight é voltado para a criação de aplicações ricas, com ele é possível
criar aplicativos RIA, ou seja, aplicativos ricos para a internet. Podemos
também criar aplicativos que rodam fora do browser, ou seja, instalado no
computador. Com a chegada do Windows Phone 7, temos agora a
possibilidade de criar aplicativos mobile, utilizando a mesma tecnologia.

Neste tutorial estarei criando um aplicativo utilizando o Silverlight, simples e

introdutório. O exemplo tem como objetivo apresentar o conceito de Layout
Controls, se você já conhece o Silverlight , provavelmente já conhece os
layout controls utilizados para criar interfaces no Windows Phone 7.

Um dos pontos interessantes é que se você já conhece a linguagem C# ou

Silverlight, vai poder aproveitar todo o seu conhecimento para criar
aplicativos para o Windows Phone 7, tendo uma curva de aprendizado menor
para entrar no mundo mobile.

Os celulares ou smartphones com Windows Phone 7 ainda não chegaram ao

Brasil, e ainda não temos uma previsão oficial a respeito de quando teremos o
sistema operacional nas lojas para comprar. Se você tiver oportunidade,
poderá importar o equipamento, existem equipamentos desbloqueados que
funcionam com as operadoras de telefonia no Brasil. Não se preocupe se você
não tiver um celular em mãos, pois os emuladores são bem completos e a
maioria dos recursos são possíveis de simular usando os emuladores do Visual
Studio 2010 ou Expression Blend 4.
Atualmente os equipamentos com o Windows Phone 7 têm um display e 3
botões na parte inferior, os botões são o Back, Start e Search. O botão Back
tem a função de voltar quando utilizado dentro de um navegador, na home ele
finaliza o programa, mas os softwares desenvolvidos podem utilizar esse
botão para qualquer finalidade. No equipamento ele geralmente fica
localizado no lado esquerdo e tem um ícone de setinha para esquerda. O botão
Start tem o desenho do símbolo do Windows, ele leva o usuário a tela inicial
do sistema e não é acessível aos softwares criados pelo desenvolvedor. O
botão Search é o botão utilizado pelo sistema operacional para pesquisas, ele
inicia uma página com o buscador da Microsoft, o Bing.

As versões iniciais dos celulares ou smartphones com Windows Phone 7 têm

uma tela com o tamanho de 480 x 800 pixels, essa informação é importante
para o desenvolvedor do aplicativo. É esperado telas com outros formatos,
porém, inicialmente podemos trabalhar pensando em uma tela com esse
tamanho. O interessante é criar aplicativos que possam se adaptar a diversos
tamanhos de telas, mas como nem sempre é possível, você poderá utilizar o
tamanho inicial para criar a sua aplicação.

O tamanho é somente um parâmetro, os celulares e smartphones com o WP7

reconhecem a orientação do aparelho. Por exemplo, inicialmente os
aplicativos iniciam em formato “retrato”, ou seja, com o celular em pé, você
poderá programar para que quando o celular for “deitado” , o software
reconheça automaticamente e ajuste e redimensione a tela para o usuário.

A maioria dos programas para os celulares e smartphones com Windows

Phone abusam de recursos de touch screen. Nem todos os aparelhos têm um
teclado, porém ao criar o seu aplicativo você verá um teclado virtual, que
aparecerá ocupando parte da tela.

O recurso de touch screen do Windows Phone 7 é poderoso, reconhece até

quatro pontos de toques, sendo multi-touch, com esse recurso podemos, por
exemplo, dar um zoom em uma imagem, com dois toques simultâneos,
abrindo e fechando os dedos.

Tanto o Visual Studio 2010 como o Expression Blend têm um emulador do

Windows Phone 7. Podemos criar nossos aplicativos e simular sem precisar de
um celular ou smartphone com o WP7. Quando criamos um novo aplicativo
do tipo Windows Phone 7 Application no Visual Studio 2010, uma tela é
apresentada com o design do Windows Phone 7, as propriedades de tamanho e
altura da tela são definidas conforme o padrão do Windows Phone 7.

Quando criamos um novo aplicativo do tipo Windows Phone 7 Application no

Visual Studio 2010, ele vai adicionar um modelo básico para o início do
projeto. Esse modelo básico já contém algumas definições iniciais, no caso do
layout da tela, ele apresenta um projeto Silverlight com um arquivo XAML
principal. Nele temos uma página do tipo PhoneApplicationPage com algumas
propriedades iniciais, como por exemplo, a fonte utilizada, o tamanho e a cor
da fonte, a orientação inicial como retrato, entre outras.

A tela inicial contém uma barra chamada System Tray no topo. Essa barra
apresenta o sinal do celular, um medidor de bateria e a hora atual. Se o seu
aplicativo precisa aproveitar o máximo da tela, você poderá remover essa
barra de forma simples, colocando a propriedade SystemTray.IsVisible como
false no XAML. Em seguida temos uma tela padrão do Windows Phone, a
tela utiliza dos Layout Controls Grid e StackPanel, que veremos em detalhes
mais adiante. Os Layout Controls ajudam a separar as áreas na tela para que
os elementos possam ser posicionados de forma adequada.

Layout Controls
Para dispor os elementos em uma página no Windows Phone 7 temos cinco
recursos disponíveis, são eles, o Canvas, Grid, Stackpanel, Border e
Scrollviewer. Vamos conhecer um pouco sobre cada um deles e quando
utilizá-los.

O Layout Control Canvas é um layout simples e básico, com ele podemos

definir uma posição exata para um determinado elemento na tela, ou seja, ele
fornece o suporte ao posicionamento absoluto dos elementos filhos. Por
exemplo, podemos definir a altura e o tamanho do Canvas e inserir alguns
botões. Se você desejar colocar um botão por cima do outro, basta você
posicioná-lo dentro do canvas informando qual a posição de cada elemento.

Temos 4 propriedades disponíveis, Canvas.Left e Canvas.Right, para definir a

posição da esquerda e direita, e Canvas.Top e Canvas.Bottom para definir a
posição de cima e de baixo. A Listagem 1 apresenta o código XAML de
quatro botões que foram posicionados propositalmente um em cima do outro.
O resultado pode ser visto na Figura 1.

Listagem 1. Layout Control Canvas

<Canvas>

<Button Background="Red"
Content="Botão 1"
Canvas.Left="10"
Canvas.Top="0" ></Button>
<Button Background="Blue"
Content="Botão 2"
 Canvas.Left="40"
Canvas.Top="30" ></Button>
<Button Background="Yellow"
Content="Botão 3"
Canvas.Left="70"
Canvas.Top="60"></Button>
<Button Background="Green"
Content="Botão 4"
Canvas.Left="100"
Canvas.Top="90" ></Button>
</Canvas>

Figura 1. Emulador com layout control Canvas

O StackPanel ajusta os seus elementos em uma pilha, podendo ser uma pilha
vertical ou horizontal. Por padrão ele ajusta os elementos de cima para baixo.
Ele é interessante para quando quisermos trabalhar com um layout simples e
padronizado. Por exemplo, quando você inserir um elemento dentro do
StackPanel, ele vai ficar um embaixo do outro, isso porque a orientação
padrão do Stackpanel é Vertical. Veja na Listagem 2 um exemplo utilizando
os mesmos quatro botões, o resultado pode ser visto na Figura 2.

Listagem 2. Layout Control Stackpanel com orientation vertical

<StackPanel Orientation="Vertical" >

<Button Background="Red"
 Content="Botão 1"/>
<Button Background="Blue"
Content="Botão 2" />
<Button Background="Yellow"
Content="Botão 3" />
<Button Background="Green"
Content="Botão 4"/>

</StackPanel>

Figura 2. Emulador com layout control Stackpanel com orientação vertical

Você pode modificar a orientação do Stackpanel para Horizontal, os seus

elementos filhos ficarão lado a lado. Cada elemento filho também pode
utilizar um alinhamento dentro do Stackpanel, podendo ser alinhado à
esquerda, direita, centralizado, ajustado, no topo ou em baixo, utilizando das
propriedades HorizontalAlignment e VerticalAlignment. Um exemplo de
Stackpanel com orientação Horizontal e alinhamento dos seus elementos
filhos utilizando a propriedade VerticalAlignment pode ser visto na Listagem
3, o resultado pode ser visto na Figura 3.

Listagem 3. Layout Control Stackpanel com orientation horizontal

<StackPanel Orientation="Horizontal" >

<Button Background="Red"
 VerticalAlignment="Top"
Content="Botão 1"/>
<Button Background="Blue"
VerticalAlignment="Bottom"
Content="Botão 2" />
<Button Background="Yellow"
VerticalAlignment="Center"
Content="Botão 3" />
<Button Background="Green"
VerticalAlignment="Stretch"
Content="Botão 4" />

</StackPanel>

Figura 3. Emulador com layout control Stackpanel com orientação horizontal

O Layout Control Grid é o mais flexível dos controles de layouts disponíveis,

semelhante a uma tabela HTML, esse controle permite criar linhas e colunas e
definir os tamanhos e a altura de cada linha e coluna. Através de duas tags
Grid.RowDefinitions e Grid.ColumnDefinitions podemos definir quantas e
quais os tamanhos de cada linha e coluna respectivamente, podemos definir
linhas e colunas com tamanhos fixos ou com tamanhos proporcionais, como
por exemplo, que a primeira linha tenha um tamanho fixo de 100 e que o
restante seja proporcional ao tamanho da tela.

Após definir quantas linhas e colunas e quais os tamanhos de cada uma, os

elementos filhos deverão ser posicionados através das propriedades Grid.Row
e Grid.Column, ou seja, para posicionar uma botão na segunda linha e na
primeira coluna, você digitará <Button Grid.Row=”1” Grid.Column=”0”>. É
possível utilizar também as propriedades Grid.ColumnSpan e Grid.RowSpan
para mesclar as colunas e linhas respectivamente, dessa forma temos uma
grande flexibilidade para posicionar os elementos dentro do layout da tela.
Veja um exemplo de uso do Layout Control Grid na Listagem 4 e o
respectivo resultado na Figura 4.

Listagem 4. Layout Control Grid

<Grid>

<Grid.ColumnDefinitions>
<ColumnDefinition Width="230*" />
<ColumnDefinition Width="230*" />
</Grid.ColumnDefinitions>
<Grid.RowDefinitions>
<RowDefinition Height="90*" />
<RowDefinition Height="678*" />
</Grid.RowDefinitions>

<Button Background="Red"
Content="Botão 1"
Grid.Row="0"
Grid.Column="0"/>
<Button Background="Blue"
Content="Botão 2"
Grid.Column="1"
Grid.Row="0"/>
<Button Background="Yellow"
Content="Botão 3"
Grid.Row="1"
Grid.Column="0" />
<Button Background="Green"
Content="Botão 4"
Grid.Column="1"
Grid.Row="1" />
 </Grid>

Figura 4. Emulador com layout control Grid

Se você deseja inserir um elemento dentro de uma borda personalizada, você

pode utilizar o recurso Border. O recurso Border tem algumas propriedades
como o CornerRadius que arredonda as extremidades da borda e BorderBrush
que permite inserir uma cor na borda. Apesar de simples ela pode ser útil em
determinadas situações ou para somente trabalhar na parte visual de alguns
elementos. Na Listagem 5 temos um botão dentro de um elemento Border, e
na Figura 5 o resultado.

Listagem 5. Layout Control Grid

<Border CornerRadius="50"
BorderBrush="Blue"
Background="AliceBlue"
BorderThickness="2" >

<Button Background="Red" Margin="10"

Content="Botão 1"/>

</Border>
Figura 5. Border

O Scrollviewer é um elemento que permite que você adicione outro elemento

e disponibiliza barras de rolagem vertical e horizontal, é útil em algumas
situações. Vamos supor que você queira inserir uma imagem um pouco maior
que a tela do celular e através do touch screen andar pela imagem, isso é
possível se a imagem foi adicionada dentro de um Scrollviewer, e utilizando
as propriedades HorizontalScrollBarVisibility e VerticalScrollBarVisibility.
Veja um exemplo na Listagem 6 e o resultado na Figura 6.

Listagem 6. Scrollviewer

<ScrollViewer
HorizontalScrollBarVisibility="Auto"
VerticalScrollBarVisibility="Auto">
<Image Source="foto.jpg" />
</ScrollViewer>
Figura 6. Scrollviewer

Analisando uma aplicação simples

Vimos até agora um pouco sobre os layout controls disponíveis para serem
utilizados no Windows Phone 7. Para criar aplicações no Windows Phone 7,
um layout control pode conter diversos elementos, inclusive outro layout de
controle, por exemplo, podemos ter um layout control Grid com duas linhas e
na primeira linha ter um Stackpanel, e na segunda linha um Canvas. Essa
liberdade permite ao programador uma flexibilidade para montar suas telas
conforme a necessidade do aplicativo.

Vamos agora analisar uma simples aplicação que utiliza os layout controls
Grid e Stackpanel. A aplicação divide a tela em duas linhas, na primeira temos
um Stackpanel com dois botões, na segunda temos outro Stackpanel com um
formulário simples, contendo dois campos para que o usuário possa digitar seu
nome e sobrenome. Veja Listagem 7 e resultado na Figura 7.
Figura 7. Formulário com Layout Controls

Listagem 7. Código XAML de um formulário simples

<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="105*" />
<RowDefinition Height="663*" />
</Grid.RowDefinitions>

<StackPanel Grid.Row="0"
Orientation="Horizontal">
<Button Content="Enviar"
VerticalAlignment="Center" ></Button>
<Button Content="Limpar"
VerticalAlignment="Center" ></Button>
</StackPanel>

<StackPanel Grid.Row="1">
<TextBlock Text="Nome"
Margin="10"></TextBlock>
 <TextBox ></TextBox>
<TextBlock Text="Sobrenome"
Margin="10"></TextBlock>
<TextBox ></TextBox>

</StackPanel>

</Grid>

Analisando o código vemos que o controle de layout principal é o Grid. Com

as propriedades RowDefinition foram definidas duas linhas, a primeira com a
altura de 105 e a segunda com a altura de 663. Na primeira linha do Grid
temos um Stackpanel, isso foi definido através da propriedade Grid.Row =”0”
dentro da TAG Stackpanel, o mesmo processo foi feito para deixar o segundo
Stackpanel na segunda linha do Grid, modificando apenas o número da linha.

Analisando o código gerado pelo

Visual Studio 2010
Quando criamos um projeto do tipo “Windows Phone Application” no Visual
Studio 2010, o Layout Control inicial do projeto é o Grid, ele forma a grande
tela que fica abaixo do System Tray. Dentro do Layout Control Grid temos a
divisão da tela em duas áreas. A primeira é onde temos os elementos que
fazem parte do cabeçalho da aplicação, como o título, que inicialmente vem
como “MY APPLICATION”, e o título da página inicial, que vem como
“page name”. A segunda parte é a área disponível para criar o aplicativo
propriamente dito. Veja o código inicial da aplicação gerada pelo Visual
Studio na Listagem 8.

Listagem 8. Código XAML inicial de um aplicativo WP7

1 <phone:PhoneApplicationPage
2 x:Class="WindowsPhoneApplication3.MainPage"
3
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
4 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
5 xmlns:phone="clr-
namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
6 xmlns:shell="clr-
namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone"
7 xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
8 xmlns:mc="http://schemas.openxmlformats.org/markup-
compatibility/2006"
 9 mc:Ignorable="d" d:DesignWidth="480" d:DesignHeight="768"
10 FontFamily="{StaticResource PhoneFontFamilyNormal}"
11 FontSize="{StaticResource PhoneFontSizeNormal}"
12 Foreground="{StaticResource PhoneForegroundBrush}"
13 SupportedOrientations="Portrait" Orientation="Portrait"
14 shell:SystemTray.IsVisible="True">
15
16 <!--LayoutRoot is the root grid where all page content is
placed-->
17 <Grid x:Name="LayoutRoot" Background="Transparent">
18 <Grid.RowDefinitions>
19 <RowDefinition Height="Auto"/>
20 <RowDefinition Height="*"/>
21 </Grid.RowDefinitions>
22
23 <!--TitlePanel contains the name of the application and
page title-->
24 <StackPanel x:Name="TitlePanel" Grid.Row="0"
Margin="12,17,0,28">
25 <TextBlock x:Name="ApplicationTitle"
26 Text="MY APPLICATION"
27 Style="{StaticResource PhoneTextNormalStyle}"/>
28 <TextBlock x:Name="PageTitle" Text="page name"
Margin="9,-7,0,0"
29 Style="{StaticResource PhoneTextTitle1Style}"/>
30 </StackPanel>
31
32 <!--ContentPanel - place additional content here-->
33 <Grid x:Name="ContentPanel" Grid.Row="1"
Margin="12,0,12,0"></Grid>
34 </Grid>
35
36 <!--Sample code showing usage of ApplicationBar-->
37 <!--<phone:PhoneApplicationPage.ApplicationBar>
38 <shell:ApplicationBar IsVisible="True"
IsMenuEnabled="True">
39 <shell:ApplicationBarIconButton
IconUri="/Images/appbar_button1.png"
40 Text="Button 1"/>
41 <shell:ApplicationBarIconButton
IconUri="/Images/appbar_button2.png"
42 Text="Button 2"/>
43 <shell:ApplicationBar.MenuItems>
 44 <shell:ApplicationBarMenuItem Text="MenuItem 1"/>
45 <shell:ApplicationBarMenuItem Text="MenuItem 2"/>
46 </shell:ApplicationBar.MenuItems>
47 </shell:ApplicationBar>
48 </phone:PhoneApplicationPage.ApplicationBar>-->
49
50 </phone:PhoneApplicationPage>

O código XAML apresenta da linha 2 a 8 os namespaces utilizados pela

aplicação para rodar um aplicativo básico para o Windows Phone 7. Em
seguida temos definições quanto ao tipo, tamanho e cor da fonte. Com a
propriedade supportedOrientations podemos definir como queremos que a
nossa aplicação fique na tela, se retrato, paisagem ou ambas. No caso de
ambas, o equipamento vai reconhecer qual o orientação do aplicativo e
responder. Por último você pode definir se deseja que o System Tray apareça
ou não através da propriedade SystemTray.isVisible.

Na linha 16 temos o Layout Control principal da aplicação, o padrão da

aplicação é o GRID, com fundo transparente e nome LayoutRoot, mas você
pode modificar a qualquer momento qualquer uma dessas propriedades. Da
linha 18 a 21 temos a definição das linhas do GRID, a primeira vai conter a
parte do título da aplicação e da página e a segunda o contéudo da aplicação.

Na linha 24 temos o Stackpanel que vai conter o cabeçalho da aplicação. Note

que ele está inserido na linha 0 do Layout Control principal, que é o Grid. Na
linha 33 temos outro layout Control Grid, que está na linha 1 do Grid
principal, é dentro deste layout control que o contéudo da sua aplicação pode
ser codificado.

Da linha 36 a 48 temos um código comentado na aplicação, esse código pode

ser usado para inserir uma barra no canto inferior da aplicação, essa barra
pode ser utilizada para diversas finalidades, podendo conter elementos
diversos, como botões e menus, podendo ser útil em determinadas situações.

O código gerado pelo Visual Studio é somente um exemplo, você pode apagar
tudo e criar o layout que desejar, conforme a necessidade de sua aplicação.

Conclusão
Vimos uma introdução aos controles de layouts e analisamos os códigos
gerados pela aplicação default quando criamos uma aplicação do tipo
“Windows Phone Application”. Além desse tipo de aplicação básica, existem
outros modelos “templates” para você utilizar como base para uma aplicação
Windows Phone 7, uma delas é chamado de “Windows Phone Panorama
Application”, um tipo de projeto modelo do Windows Phone que permite criar
aplicações que usam um tipo de recurso que disponibiliza uma navegação de
forma panorâmica, em uma tela através de touch screen. Existem diversos
projetos que utilizam desses recursos, como os próprios aplicativos do Office
e o XBOX Live que acompanham o Windows Phone 7.

A criação de aplicativos para celulares e smartphones sempre foi um mercado

atrativo, agora com a nova geração de sistemas operacionais e equipamentos
modernos, existe uma oportunidade para os desenvolvedores. O Windows
Phone Marketplace é onde você testa e compra aplicativos para o Windows
Phone 7, ele já está aberto para você enviar e vender seus aplicativos. Apesar
de serem necessárias algumas etapas, o processo não é complicado, em meu
blog tem um tutorial com o passo a passo para você vender seus aplicativos no
Windows Phone Marketplace.

Links

Windows Phone 7 for Developers

http://developer.windowsphone.com

Microsoft Silverlight Reference

http://www.silverlight.net/

por Alexandre
Guru .net e tecnologias MS
Visual Studio 2010
Este artigo é o terceiro de uma série que vai
abordar as principais novidades presentes
no Visual Studio 2010, bem como
importantes recursos presentes em outras
versões da ferramenta.
De que se trata o artigo

Este artigo é o terceiro de uma série que vai abordar as principais novidades
presentes no Visual Studio 2010, bem como importantes recursos presentes
em outras versões da ferramenta.

Para que serve

Os novos recursos nos designers WPF servem para facilitar o

desenvolvimento de aplicações ricas, inclusive com Silverlight. A
programação paralela e as janelas para suportar esse tipo de desenvolvimento
no Visual Studio permitem criar aplicações mais robustas e performáticas. O
gerenciador de pacotes facilita a instalação e manutenção de add-ins no IDE.
Além disso, o novo suporte ao Azure facilita o desenvolvimento para Cloud
Computing.

Em que situação o tema é útil

Conhecer os novos recursos do Visual Studio, e também outros mais antigos

mas não menos importantes, é muito útil para que o desenvolvedor tire o
máximo de proveito das possibilidades que a ferramenta permite, em todos os
tipos de aplicações desenvolvidas. Um desenvolvedor que conheça bem as
características do produto com certeza terá uma maior produtividade em seu
trabalho no dia a dia.

Visual Studio

Neste artigo serão indicados os melhoramentos de designer para

desenvolvimento em WPF e Silverlight aperfeiçoando e acelerando a criação
de um aplicativo. Logo após, a utilização de programação paralela para
aumentar o desempenho de um sistema e duas de suas principais janelas de
depuração: a Parallel Stacks e a Parallel Tasks ambas voltadas para a
depuração de aplicativos, principalmente de tarefas com desenvolvimento em
paralelo auxiliando de maneira bastante intuitiva a depuração de um sistema.
O gerenciador de extensões do Visual Studio 2010, possibilitando instalar,
atualizar e realizar consultas online de novas extensões para serem utilizadas.
O desenvolvimento para SharePoint, que está aprimorado, possibilitando criar
projetos por completo para serem utilizados com SharePoint. A utilização da
computação em nuvem usando recursos integrados do Visual Studio com o
Windows Azure auxiliando a criação de aplicativos para web e a construção
de serviços com base nesse ambiente em nuvem. O comportamento avançado
de janelas permitindo várias formas de ajustes para melhor visualização dentro
e fora da IDE do Visual Studio e, indo além, suportando visualização em mais
de um monitor. E, por último, os aprimoramentos implantados na seleção de
texto ampliando sua utilização e manutenção de textos tanto para o formato de
fluxo contínuo como em formato de seleção de texto em colunas.

O Visual Studio 2010 provê alguns aperfeiçoamentos de designer para melhor

auxiliar no desenvolvimento de aplicativos em WPF (Windows Presentation
Foundation) e Silverlight. Para estes dois tipos de projeto, o suporte ao
designer é apresentado com o mesmo formato, incluindo a vinculação de
dados semelhante ao tipo arrastar e soltar e a visualização de objetos ou
controles. O designer possibilita utilizar um conjunto de ferramentas que
permitem obter um grande aumento de produção no desenvolvimento de
aplicativos. As ferramentas auxiliam e aceleram a criação de aplicações
possibilitando explorar os recursos de WPF e Silverlight dando capacidade de
acesso completo aos dados e controles ampliando as práticas para desenvolver
estilos e recursos para aperfeiçoar o visual de aplicativos. Na Figura 1 é
possível visualizar um aplicativo desenvolvido em WPF utilizando recursos
de designer do Visual Studio.
Figura 1. Designer do Visual Studio para WPF

O WPF possui recursos gráficos baseados no .NET Framework que utilizam

uma linguagem de marcação chamada de XAML para desenvolvimento de
interfaces gráficas de visual bastante expressivo. Apresenta um modelo básico
de programação e possui uma separação distinta entre a interface e a lógica de
negócios, também representada pela implementação de código em uma
linguagem de programação como C#.

XAML é uma linguagem bastante declarativa. Ela simplifica a criação de uma

interface de usuário para um aplicativo em WPF. Um arquivo XAML é repres
entado em formato texto e sua estrutura é semelhante a de um documento XM
L.
O Silverlight permite criar aplicações semelhantes ao estilo Flash utilizando o
.NET Framework combinando o seu visual com funcionalidade e qualidade. A
presenta grande destaque na transmissão de vídeos. Sua estrutura de projeto ut
iliza os mesmos princípios do WPF, arquivos XAML e arquivos de programaç
ão representados em alguma linguagem.

Programação Paralela
O .NET Framework 4 trouxe novas bibliotecas que permitem a utilização de
tarefas em paralelo em um aplicativo, ou seja a capacidade de executar
múltiplas threads ao mesmo tempo, simultaneamente. Neste aspecto os
aplicativos poderão utilizar vários processadores sem a preocupação de
trabalhar diretamente com as threads, assim, o Visual Studio 2010 permite
facilitar a programação com as suas bibliotecas de computação paralela. Neste
aspecto, utilizando os computadores mais atuais, praticamente todos são
multiprocessados, e essa arquitetura permite a divisão de tarefas entre seus
núcleos de processadores, assim os trabalhos podem ser divididos e
executados em paralelo, dessa forma, ampliando o desempenho e podendo
utilizar de forma mais adequada a capacidade de processamento de um
processador.

Utilizando o .NET é possível verificar a existência de uma biblioteca de

classes com funcionalidades que auxiliam no desenvolvimento de aplicativos
com programação paralela. A biblioteca recebeu o nome de Task Parallel
Library (TPL) e possui um conjunto de tipos públicos e APIs presentes nos
namespaces System.Threading e System.Threading.Tasks que simplificam o
processo de adição de tarefas em paralelo no desenvolvimento de sistemas. A
principal preocupação de quem utilizará TPL é basicamente no desempenho
do aplicativo, visto que o trabalho relacionado às Threads quem irá gerenciar
é o próprio TPL como a divisão do trabalho, o agendamento de Threads, o
cancelamento e a gestão de estado de determinada tarefa. Na Listagem 1 está
indicado um código utilizando programação paralela em uma estrutura de
repetição. O código representado por Parallel é que fará a diferença, esta
expressão indicará que a estrutura de repetição For será executada de forma
paralela, onde na expressão seus parâmetros são separados por vírgula e não
por ponto e vírgula, como em uma estrutura For tradicional.

Listagem 1. Código utilizando recursos de programação paralela

Parallel.For(0, 5, delegate(int x)
{
MessageBox.Show("Mensagem nº: " + x.ToString());
});

Algumas janelas relacionadas à depuração de código e à programação paralela

estão aprimoradas. Novas tarefas permitem visualizar janelas onde se verifica
uma lista de instâncias do que está em execução em um aplicativo, a exibição
das pilhas de chamadas para determinada instância de tarefas e a navegação
mais fácil no código que está sendo depurado. A Figura 2 indica duas janelas
utilizadas para auxiliar na programação paralela e visualização de detalhes de
forma fácil e prática. A janela Parallel Tasks é uma janela que mostra
informações de cada objeto, semelhante a uma janela de Thread, mas mais
ampla indicando tarefas que representam operações assíncronas e suas
execuções de cada um desses objetos. Ela permite obter informações no
momento em que o código está sendo depurado, tais informações incluem um
ID indicando o identificador da tarefa que está sendo analisada, o seu status,
local de execução, uma descrição da tarefa em si e da Thread em análise e
informações relacionadas ao próprio aplicativo. Já a janela Parallel Stacks é de
bastante utilidade para uma depuração mais visual de um aplicativo, pois nela
é possível visualizar tópicos de informações das pilhas de chamadas para os
segmentos do aplicativo, permitindo navegar entre os segmentos e as pilhas de
execução apresentando de forma intuitiva as tarefas e as Threads que o
aplicativo possui. Em resumo, estas janelas permitem a visualização da
depuração do código e o controle do que está sendo executado, além de
auxiliar na observação do que está na fila para execução.

Figura 2. Apresentação da Parallel Stacks e Parallel Tasks

Além disso, a LINQ (Language Integrated Query), que foi uma linguagem
introduzida no .NET 3.0, auxilia na consulta a diferentes fontes de dados,
como bancos de dados relacionais, documentos XML ou outros tipos de
objetos. A partir de sua definição, o .NET Framework 4.0 adicionou um novo
conceito à LINQ e a programação paralela dando origem ao chamado PLINQ
(Parallel LINQ). Este novo modelo de execução de consultas é semelhante ao
formato utilizado em consultas de uma expressão LINQ tradicional, a
vantagem está na sua execução, que utilizará maiores recursos de
processamento, como vários processadores ou núcleos de execução quando
estiverem presentes e disponíveis no ambiente. A alteração na forma de
realizar uma consulta é bastante pequena e o uso de PLINQ será uma ótima
escolha para implementações em arquiteturas que exijam um grande
processamento paralelo.

O gerenciador de extensões
O Visual Studio 2010 possui o chamado Extension Manager (gerenciador de
extensões) através do gerenciador, é possível instalar extensões para a IDE do
Visual Studio, ele irá realizar o download, caso seja necessário, instalar a
extensão e realizar toda a manutenção em extensões já presentes no sistema,
como desinstalar, desativar ou reativar alguma que já foi instalada. Outra
opção disponível é a utilização de extensões desenvolvidas por terceiros,
outros fabricantes, presentes no gerenciador através da opção de pesquisa
online. A Figura 3 acessada pelo Visual Studio 2010 através do menu Tools,
indica a janela do gerenciador de extensões.

Figura 3. Gerenciador de extensões do Visual Studio 2010

Observe que a janela do gerenciador é dividida em três painéis, esses painéis

possuem funcionalidades distintas, o painel da direita, possibilita realizar uma
pesquisa por extensões, dependendo da seleção de opção no painel esquerdo,
esta pesquisa será realizada por extensões instaladas, galeria online ou por
atualizações disponíveis. O painel central exibe informações de determinados
itens selecionados, de acordo com a opção escolhida no painel da esquerda, ou
com os critérios de pesquisa indicados no painel da direita, ao selecionar um
item neste painel central, informações sobre ele serão indicadas no painel da
direita. E o painel da esquerda que permite agrupamentos por extensões
instaladas, extensões da galeria online e atualizações para as que já estão
presentes no Visual Studio 2010.

O gerenciador de extensões suporta arquivos com extensões no formato

VSIX, que é um formato de pacote que pode incluir modelos de projeto,
modelos de item, item de caixa de ferramentas, componentes de
gerenciamento de extensões e VSPackages. Ele também poderá carregar e
instalar extensões com base no formato de instalação de arquivos MSI, mas
não poderá habilitar ou desativá-los. A galeria do Visual Studio contém estes
dois tipos de extensões.

SharePoint
O desenvolvimento para SharePoint no Visual Studio 2010 foi aprimorado
possibilitando criar, editar, depurar, empacotar, implantar e ativar projetos
desenvolvidos diretamente no Visual Studio. Suas ferramentas auxiliam na
criação de projetos SharePoint que poderão se relacionar com o Microsoft
SharePoint Foundation 2010 e com o Microsoft SharePoint Server 2010. As
novas funcionalidades auxiliam na importação e modificação de soluções,
utilização de modelos de tipo de projeto e modelos de item de projeto, criação
de formulários de associação e inicialização para fluxo de trabalhos,
agregação e integração de dados, criação de web parts, navegação entre sites
do SharePoint utilizando o gerenciador de servidores, depuração, criação e
validação de soluções. A Figura 4apresenta a tela de criação de um projeto
SharePoint em branco no Visual Studio.
Figura 4. Tela para criação de um novo projeto SharePoint no Visual Studio
2010

O SharePoint possibilita um formato de colaboração utilizando a web e o

Visual Studio, disponibiliza modelos de projeto para a criação de sites,
incluindo listas, fluxos de trabalho, modelos de conexão a fonte de dados
definições e gerenciamentos de site, e vai além, permitindo criar extensões
customizadas para projetos em SharePoint que utilizem as ferramentas do VS
2010.

Computação em nuvem
A utilização do Windows Azure Tools no Visual Studio 2010 é bastante
simplificada e possibilita o desenvolvimento de aplicativos voltados para web
de forma escalável e serviços que utilizem o Windows Azure. Este ambiente,
que é um sistema para desenvolvimento de serviços em nuvem, serve como
ponto de hospedagem e gerenciamento de serviços, fornecendo
armazenamento e gerenciamento de aplicações através de data centers. O
princípio básico indica que os aplicativos nele adicionados poderão ser
executados através de serviços do Windows Azure, possibilitando maior
escalabilidade e economia de manutenção de servidores de armazenamento e
licenciamento de recursos.
O Visual Studio possui extensões para habilitar, criar, depurar e concluir o
desenvolvimento de aplicativos e serviços que utilizem esta tecnologia, dessa
forma, as ferramentas do Windows Azure, voltadas para o VS 2010, facilitam
todo o processo de criação de software.

Comportamento avançado de
janelas
Ao utilizar o Visual Studio 2010, as janelas de documentos não estão
limitadas ao local de edição no ambiente de desenvolvimento (IDE). Neste
ambiente, principalmente as janelas de ferramentas e janelas de documentos,
podem ser ajustadas para uma melhor visualização e edição de espaço para
código, dependendo da forma como se deseja organizar as janelas. Dessa
forma, as janelas podem ser organizadas de diversas maneiras como arrastá-
las para as bordas do IDE, movê-las em qualquer parte do desktop, incluindo
arrastar para um segundo monitor, facilitando a visualização do código, e é
claro, as opções lado a lado e agrupamentos, circulando livremente entre o
ambiente de desenvolvimento ou sob alguma área flutuante permanecendo
com um estado de interligação com o projeto que está sendo desenvolvido em
todos os momentos. Observe que, obviamente, ao alterar o código em uma
janela de documento, a sua janela de designer também será modificada.
A Figura 5 demonstra o estilo flutuante da janela de código.
Figura 5. Janela de código em estilo flutuante podendo ser arrastada para
qualquer parte da tela, inclusive outro monitor

As opções de organização normalmente mais utilizadas são: janelas agrupadas

para o quadro de edição, janelas de ferramentas ajustadas para a borda de um
local no IDE, flutuar sobre janelas ou fora do ambiente de desenvolvimento,
minimizar janelas ao longo do ambiente, janelas de exibição em monitores
distintos, janelas lado a lado e a redefinição no posicionamento de janelas para
o layout padrão do Visual Studio 2010.

Caixa de seleção de texto

aprimorada
Em versões anteriores do Visual Studio, já era possível selecionar regiões de
texto em formato retangular mantendo a tecla Alt pressionada e utilizando o
mouse para delimitar a seleção, permitindo copiar e colar o texto selecionado.
No Visual Studio 2010 esse recurso foi aprimorado, aperfeiçoando ainda mais
a seleção de texto, estes recursos disponibilizam funcionalidades para o texto
de inserção, permitindo inserir o novo texto em formato de caixa,
disponibilizando, assim, em cada linha selecionada, colar o conteúdo de uma
caixa de seleção em outra, o comprimento zero, que realiza uma seleção
vertical de nenhum caractere de largura para delimitar um ponto de inserção
de várias linhas para o texto delimitado. A Figura 6 demonstra um estilo de
seleção de texto.

Figura 6. Seleção de texto atravessando quase que por inteiro o código

O editor de código apresenta dois estilos de seleção de texto, o primeiro,

demonstrando um formato mais tradicional de seleção de texto, chamado de
fluxo contínuo de seleção, onde o texto é selecionado continuamente e de
formato linear a partir do início de um texto até o seu final, neste modelo
todas as linhas são selecionadas por inteiro, o segundo modelo, o mais
interessante, é a seleção em coluna, onde apenas uma parte retangular de texto
é delimitada não selecionando todo o texto das linhas, qualquer texto inserido
na área selecionada é adicionado no mesmo ponto em cada linha da seleção.

Conclusão
O Visual Studio 2010 apresenta várias novidades e melhorias no seu ambiente
de desenvolvimento integrado na utilização do .NET Framework versão 4, que
também apresenta novidades. Neste artigo foram abordadas algumas das
novidades presentes, seguindo a seqüência inicial desde o primeiro artigo
relacionado a este tema. Foram indicados os aperfeiçoamentos de designer
para desenvolvimento de aplicativos WPF e Silverlight, a sua fácil e simples
composição visual aprimorada que irá aumentar a produtividade na confecção
de aplicativos voltados para este tipo de desenvolvimento. Um grande
destaque aos principais recursos que podem ser vistos e utilizados na
programação paralela, a sua utilização visando aumentar o desempenho de um
aplicativo e a depuração de um aplicativo utilizando, principalmente, as
janelas Parallel Stacks e Parallel Tasks. Dando continuidade, e seguindo o
artigo, surge o gerenciador de extensões do Visual Studio que está melhorado
possuindo opções de instalação de novas extensões, atualização e pesquisas
online em busca de extensões disponíveis, inclusive as desenvolvidas por
terceiros que não sejam especificadamente da Microsoft.

Além disso, a utilização do Visual Studio para desenvolvimento voltado a

SharePoint permitindo criar projetos, adicionar itens, depurar e implantar um
projeto. Também foi feito referência a computação em nuvem utilizando
recursos do ambiente integrados com o Windows Azure, permitindo criar
aplicativos web e serviços que utilizem este tipo de desenvolvimento. Logo
após surge o comportamento avançado de janelas do Visual Studio auxiliando
e se adequando de forma mais precisa de acordo com a melhor visualização
que o usuário achar conveniente. E por último, o comportamento aprimorado
das caixas de seleção de texto permitindo várias formas de seleção, incluindo
os tradicionais recursos de copiar e colar. Neste aspecto, pode-se claramente
dizer que o Visual Studio é um poderoso ambiente de desenvolvimento
sempre voltado para melhor atender as necessidades no desenvolvimento de
sistemas.

Links

Visual Studio
http://www.microsoft.com/visualstudio

Introdução ao Visual Studio

http://msdn.microsoft.com/pt-br/library/fx6bk1f4.aspx

Visual Studio 2010 Product Highlights

http://msdn.microsoft.com/en-us/library/dd547188.aspx

What's New in Visual Studio 2010

http://msdn.microsoft.com/en-us/library/bb386063.aspx

Task Parallel Library

http://msdn.microsoft.com/en-us/library/dd460717.aspx

Using the Parallel Tasks Window

http://msdn.microsoft.com/en-us/library/dd998369.aspx

Using the Parallel Stacks

http://msdn.microsoft.com/en-us/library/dd998398.aspx

Gerenciador de Extensões
http://msdn.microsoft.com/pt-br/library/dd293638.aspx
O que há de novo no desenvolvimento do SharePoint
http://msdn.microsoft.com/pt-br/library/ee290856.aspx

por Rodrigo Araujo

Guru .net e tecnologias MS

Windows Azure
Este artigo aborda alguns conceitos sobre
computação na nuvem e começa a
demonstrar a plataforma de
desenvolvimento na nuvem da Microsoft, o
Windows Azure

De que se trata o artigo

Este artigo aborda alguns conceitos sobre computação na nuvem e começa a

demonstrar a plataforma de desenvolvimento na nuvem da Microsoft, o
Windows Azure.

Para que serve

Conhecer a plataforma Windows Azure nos dá bagagem suficiente para

tomadas de decisões estratégicas. Conhecer o modelo de computação na
nuvem, atualmente, é algo essencial para todo desenvolvedor.

Em que situação o tema é útil

Quando precisamos criar aplicações com alta disponibilidade e que sejam
escaláveis, ou ainda quando não queremos nos preocupar com a infraestrutura
onde estas aplicações serão executadas, podemos adotar o Windows Azure
como plataforma e manter nosso foco como desenvolvedores em nossas
aplicações.

Windows Azure

Windows Azure é a plataforma de computação na nuvem da Microsoft. Com

o Windows Azure podemos explorar e tirar proveito de desenvolvimento na
nuvem, atingindo alta performance e escalabilidade em nossas aplicações
fazendo uso de uma infraestrutura virtualmente ilimitada. Entenderemos quais
problemas podemos resolver utilizando a plataforma de cloud da Microsoft.

Há alguns anos o mercado de tecnologia já vem se deparando com restrições

físicas no que diz respeito a disponibilidade e escalabilidade de recursos de
computação. Muitas empresas de tecnologia possuem uma infraestrutura
interna e particular de máquinas que utilizam servidores de banco de dados e
servidores de aplicação. Muitas vezes esta infraestrutura interna de máquinas
acaba sendo também utilizada para prover serviços. Ou seja, muitas vezes o
servidor de banco de dados das aplicações da empresa fica dentro da própria
empresa, os servidores web onde ficam hospedados os sites, blogs, e-
commerces e outros ficam também dentro da empresa.

Na maioria das vezes o discurso que apóia este tipo de decisão é a segurança
dos dados estarem fisicamente dentro da empresa, o que é tema para um outro
artigo. Se por um lado a segurança é utilizada como argumento para manter
uma infraestrutura interna ou “on premise”, por outro lado existem fortes
argumentos contra esta posição. Um destes argumentos é referente ao alto
custo de manutenção para esta infraestrutura interna. Quando falamos em
manutenção estamos falando em manter as máquinas funcionando e em bom
estado, com poder de processamento suficiente para suportar a carga do
sistema mesmo em eventuais picos. Além disso, manter memória suficiente
para suportar a carga necessária para o sistema, prover suporte de rede e
internet disponíveis para que as máquinas (e consequentemente os serviços)
estejam acessíveis, prover suporte de energia garantindo que o serviço não
saia do ar mesmo em caso de falha na alimentação convencional dentre uma
série de outros fatores. Manter toda uma estrutura como esta, com qualidade, é
realmente muito caro.

Entendendo o problema da
escalabilidade
Quando falamos em escalabilidade geralmente pensamos em um ambiente de
muita demanda como bancos, grandes sites de vendas, grandes portais de
internet etc. A verdade é que todo serviço tem necessidade de escalabilidade.
Não são raros os serviços onde temos uma demanda crescente e em alguns
casos imprevisível. E ainda que tenhamos uma demanda previsível, por
estarmos fazendo uso de uma infraestrutura interna não temos a facilidade de
escalabilidade.

Mas o que escalabilidade quer dizer? Vejamos um pequeno exemplo para

ilustrar este ponto de maneira mais simples. Imaginemos que a revista Easy
.NET Magazine possui cinco mil acessos mensais em seu portal e possui um
servidor dentro da própria DevMedia para suportar este website. Com um
acesso mensal de cinco mil usuários é relativamente simples manter esta
estrutura. Dado que um dia a equipe de marketing da empresa faz um anúncio
da Easy .NET na final da copa do mundo. Uma propaganda na televisão
divulgando a proposta da revista e seu site. O que você imagina que vai
acontecer? O site pode ter ao invés de cinco mil acessos por mês cinco mil
acessos por minuto. Isso não vai acontecer apenas durante a exibição do
comercial, esse volume poderia se manter por mais ou menos dois meses até
que ele caia para um novo limiar, atingindo 30 mil acessos por dia na nova
média.

Quanto uma empresa levaria para, digamos, multiplicar por 40 mil seu poder
de processamento? Quantos novos servidores seriam necessários para manter
a aplicação no ar durante os 2 meses de pico?

Supondo que seja bastante simples comprar 10, 20 ou 30 novos servidores

para suportar o período de pico e manter a aplicação/site no ar, o que acontece
depois deste período? A maioria das máquinas ficará ociosa e isso representa
um custo muito alto e desnecessário, afinal de contas uma enorme quantia de
dinheiro foi investida para um período muito curto e não há como se desfazer
disso de forma simples.

Deixando de lado então a aquisição de novas máquinas, é preciso pensar

também em toda a infraestrutura necessária para colocar essas máquinas
disponíveis: switches, cabos, roteadores, balanceadores de carga, suprimento
de energia etc. Isso é algo que leva tempo e mão de obra especializada, muitas
vezes está além da barreira dos custos necessários e disponíveis. É preciso
espaço físico, disponibilidade de prestadores de tal serviço, dentre outros
fatores. Fica bem claro então que manter uma estrutura local não é algo tão
simples quanto parece, e a menos que a empresa e/ou o serviço não possuam
planos nem expectativas de crescimento, é necessário pensar e considerar
estes fatores.
A plataforma Windows Azure
Windows Azure é um sistema operacional criado para ser executado na
nuvem. Isto quer dizer que ele (o Azure) não é um sistema operacional como
estamos acostumados. Ele é composto de uma série de partes interconectadas
em imensos data centers espalhados pelo mundo.

Quando falamos em nuvem estamos nos referindo à possibilidade de abstrair a

infraestrutura na qual estamos executando nossas aplicações. Isto que dizer
que a Microsoft criou diversos mega data centers com uma capacidade de
processamento gigantesca e todo um sistema pronto para atender praticamente
qualquer demanda de processamento.

A dificuldade em fazer isso, em dimensionar nossa aplicação e seu poder de

processamento está na simples mudança de algumas informações de
configuração. Assim podemos sair de um estado onde utilizamos uma única
máquina com um único processador para 1000 máquinas usando 4
processadores cada em alguns minutos. E o melhor é que podemos facilmente
voltar para uma única máquina no momento em que for necessário e
precisarmos, pois não precisamos ficar gerenciando as máquinas do data
center, que estão sob responsabilidade dos profissionais da Microsoft.

O Windows Azure possui ainda uma inteligência muito grande no que diz
respeito à disponibilidade de nossas aplicações. Quando solicitamos a ele que
disponibilize duas máquinas com a nossa aplicação ele é inteligente o
suficiente para disponibilizar duas máquinas que sejam completamente
separadas de forma que não estejam sob a mesma dependência de alimentação
de energia ou rede. Desta forma caso o fornecimento de energia para uma das
máquinas seja interrompido a outra máquina continuará executando, e o
Windows Azure providenciará imediatamente uma nova máquina para o lugar
daquele que foi desligada. Esta mesma inteligência ocorre em momentos de
falha de hardware. O Azure possui um constante monitoramento de todos os
itens que compõem sua malha(ou Fabric). E no momento em que identifica
um problema automaticamente ele começa a remover as aplicações sob o
problema e as distribui para outras máquinas saudáveis.

Além de separar nossas máquinas no que é chamado domínios de falha, o

Azure garante que sempre que solicitarmos uma nova máquina(ou uma nova
instância) para nosso serviço seja providenciada e disponibilizada uma
máquina exatamente igual as outras, mantendo nosso serviço em um conjunto
equivalente de máquinas com um mesmo poder de processamento e
armazenamento solicitados por nós.
A economia nestes casos é realmente muito significativa pois por todo um
serviço e plataforma como estes você paga somente pelo processamento e
alocação de recursos que você estiver usando e no momento em que estiver
usando. Você não terá máquinas ociosas em 90% do tempo. Assim em
momento de pico e necessidade você para um pouco mais para atender sua
demanda de negócios, e quando essa demanda diminuir, você também diminui
seus gastos. Você passa a ter um poder de processamento e armazenamento
virtualmente ilimitados a um custo muito acessível para empresas de todos os
portes.

Além de toda esta estrutura para executar nossos serviços o Windows Azure
ainda possui um conjunto de soluções de storage (ou armazenamento) que
estão prontas para atender soluções distribuídas e grandes processamentos
com uma capacidade também virtualmente ilimitadas.

É possível utilizar um poderoso sistema de armazenamento de arquivos

chamado Azure BLOBs. Este sistema de armazenamento vai nos garantir,
automaticamente, replicação de nossos dados como parte do processo de
envio de informações. Ou seja, o Azure BLOBs só considera que uma
operação de gravação foi realizada com sucesso a partir do momento em que
isso também já foi replicado em paralelo.

Além dos BLOBs está disponível uma solução para armazenamento de dados
chamada de Azure Tables. É importante não confundir o Azure Tables com
alguma solução de banco de dados relacional: Azure Tables não é banco de
dados relacional. O Azure Tables provê uma maneira bastante eficiente de
armazenarmos dados de forma distribuída e escalável. Para processamentos de
serviços e comunicação entre aplicações existe ainda o Azure Queues. As
Queues são filas distribuídas onde são armazenadas tarefas para que diversos
outros serviços distribuídos possam executá-las em paralelo, facilitando a
comunicação e a distribuição de serviços de maneira escalável.

Para as aplicações que dependem ainda de bancos de dados relacionais está

disponível também uma solução que atende esta demanda: SQL Azure. Como
o nome já diz o SQL Azure é uma versão do SQL Server customizada para a
nuvem, visando atender as necessidades relacionais que aplicações no Azure
possuem.

Conclusão
O Windows Azure não é apenas uma nova plataforma, um novo produto ou
ainda algo de momento. As soluções de cloud computing são soluções novas,
até então não disponíveis, que visam resolver grandes problemas que já
existem há tempos. A economia de recursos(tempo, dinheiro, equipe, espaço
etc.) é realmente muito significativa na maioria dos ambientes que possuem
soluções com demandas sazonais e esporádicas. Além disso a computação na
nuvem atende muito bem pequenos negócios com grande potencial de
crescimento.

Links

Site Oficial
http://www.microsoft.com/windowsazure/

Posts e tutoriais sobre Windows Azure

http://viniciusquaiato.com/blog/category/windows-azure/

por Vinicius Quaiato

Guru .net e tecnologias MS