ASP.

NET
Neste artigo os principais fundamentos de
desenvolvimento de projetos web serão
apresentados. Tratará de demonstrar a
arquitetura de um projeto do tipo Web
Application e Web Site, manutenção,
características básicas, algumas das suas
funcionalidades e utilizações.

Do que trata o artigo

Neste artigo os principais fundamentos de desenvolvimento de projetos web

serão apresentados. Tratará de demonstrar a arquitetura de um projeto do tipo
Web Application e Web Site, manutenção, características básicas, algumas
das suas funcionalidades e utilizações.

Para que serve

A finalidade do artigo é apresentar quais as principais diferenças na criação de

projetos web. Dessa forma, auxiliando na escolha do melhor tipo de projeto a
ser utilizado em um determinado caso de uso.

Em que situação o tema é útil

Permite explorar, de forma mais aprofundada, os conceitos de projetos

voltados para a internet solucionando possíveis dúvidas de escolha na criação
de uma aplicação. Será possível verificar em qual situação um determinado
modelo melhor se enquadra para obter o custo/benefício mais adequado no
seu desenvolvimento e manutenção.

Resumo do DevMan

Este artigo abordará as principais diferenças entre um projeto do tipo Web

Application e um projeto do tipo Web Site para o desenvolvimento de um
aplicativo web. Como introdução é demonstrado o processo de
desenvolvimento de um site, passando pelo planejamento, análise, design,
criação das interfaces, programação das funcionalidades, compilação, testes e
implantação em um servidor. Relacionado ao planejamento é possível
escolher determinados tipos de templates a serem utilizados no projeto, com
isso acelerando o desenvolvimento, visto que irá utilizar modelos pré-
determinados com funcionalidades específicas. Para esses modelos, existem
determinados tipos de arquivos e os principais podem ser analisados no
decorrer deste artigo. Após, é demonstrado como criar um projeto do tipo
Web Application, suas funcionalidades, comportamento, tipos de arquivos e
pastas presentes na Solution Explorer do Visual Studio 2010. Tratamento
semelhante é apresentado para um projeto do tipo Web Site. Por fim, as
principais diferenças são destacadas e uma tabela comparativa com algumas
situações de uso é descrita.

Ao criar um projeto web em ASP.ET, existem duas possibilidades, a criação

de um Web Site ou a criação de um Web Application. Muitas vezes podemos
parar para pensar e realizar a pergunta de qual o modelo é mais adequado para
determinado tipo de situação. Ou então, utilizando uma maneira nada
adequada de se pensar, simplesmente utilizar sempre um determinado tipo de
projeto e ignorar o restante, fazendo com que este tipo de projeto se adapte ao
seu desenvolvimento. Outras vezes, podemos nos deparar com situações em
que realizamos a escolha errada do tipo de projeto ou então ela não oferece
suporte para determinado tipo de tarefa.

O processo de desenvolvimento de aplicações web

Uma aplicação web possui algumas características próprias de planejamento

do projeto, desenvolvimento, testes e implantações em servidores. Devido à
utilização da internet e de um browser para a visualização de suas páginas
web, estas características de planejamento e desenvolvimento são
diferenciadas das de um aplicativo Windows tradicional.

Como o aplicativo será voltado para a web, este projeto deverá ter uma
especificação e um planejamento de design adequado para atender ao conjunto
de requisitos necessários para o desenvolvimento de todo o projeto de uma
forma clara, coerente e concisa.

Quando um novo projeto web é criado, o Visual Studio se encarrega de criar

os arquivos iniciais para o desenvolvimento de aplicativos, este projeto deve
ser considerado seu projeto base e, a partir dele, é que devemos adicionar as
funcionalidades necessárias para o funcionamento do aplicativo, tomando por
base o que foi planejado pelo passo anterior, a especificação do projeto e
design.

Com o projeto criado, interfaces do aplicativo são definidas, os controles

adicionados, necessários ao funcionamento de cada formulário. Para isso pode
ser utilizado o ambiente de design do Visual Studio ou diretamente por meio
de código. As propriedades iniciais de cada formulário e de seus objetos são
definidas, além do código necessário para dar funcionalidade ao aplicativo.

Após estas fases chegamos ao processo de compilação. O Visual Studio

possui duas formas de compilação: o modo debug (de depuração) e o modo
release (utilizado para publicar o aplicativo). Para realizar testes básicos
utilizamos o modo debug, é este modo de depuração que irá nos garantir que o
aplicativo estará livre de erros e realizando as tarefas que foram especificadas.
Por fim, após desenvolver e testar todo o projeto é realizado o deploy do
projeto em um servidor web que irá conter a versão do projeto apta a ser
utilizada pelos usuários do sistema desenvolvido.

Templates de projeto

Ao desenvolver um novo projeto, devemos escolher um tipo, também

chamado de projeto de sistema, como por exemplo web ou Windows. Para
cada tipo de projeto existem modelos reutilizáveis pré-definidos e pré-
configurados com as funcionalidades básicas para determinado tipo de
aplicação, a cada um desses modelos damos o nome de template. O principal
objetivo de um template é evitar que o programador tenha que desenvolver
todo o projeto a partir do zero, ou seja, um aplicativo em branco sem nenhuma
característica própria para o desenvolvimento de seu sistema.

Para o desenvolvimento web, existem dois tipos de projetos de sistema que

podem ser utilizados: Web Application e Web Site. Cada um deles possui
determinados templates de projeto que podem ser utilizados. Os principais
para o tipo Web Application são: ASP.NET Web Application, ASP.NET
MVC2 Web Application, ASP.NET Empty Web Application, ASP.NET
MVC2 Empty Web Application, ASP.NET Dynamic Data Entities Web
Application e ASP.NET Dynamic Data LINQ to SQL Web Application. Já
para o tipo Web Site são: ASP.NET Web Site, ASP.NET Empty Web Site,
ASP.NET Dynamic Data Entities Web Site, ASP.NET Dynamic Data LINQ
to SQL Web Site, WCF Service e ASP.NET Reports Web Site.

A solução de um projeto, também chamada de Solution, permite conter vários

projetos relacionados e com modelos de template distintos, um projeto pode
conter vários itens que podem ser gerenciados pela solução, podendo explorar
seus detalhes e determinar a forma como serão utilizados. Cada item irá
representar uma funcionalidade no projeto, como por exemplo, ser uma
referência a uma conexão de dados, pastas, biblioteca de classes ou ainda um
arquivo em si, dessa forma compondo todo o seu projeto.
Principais tipos de arquivos para aplicações web

Todo projeto utiliza arquivos, e cada arquivo deverá ter determinadas

funcionalidades básicas, para tanto, um arquivo deve ser de certo tipo e cada
tipo de arquivo possui funções pré-definidas que podem ser utilizadas em um
projeto web no Visual Studio 2010.

Um arquivo do tipo ASP.NET Web Form possui a extensão “.aspx” e é um

modelo de arquivo utilizado para gerar páginas dinâmicas, podendo possuir
controles e imagens, suportando adição de código em uma determinada
linguagem de programação. O arquivo do tipo javascript contém a extensão
“.js” e é responsável por possuir determinadas funcionalidades pré-definidas
que deem suporte a um objetivo específico, o funcionamento client-side
(execução no browser). Para os arquivos com extensão “.css” é possível
definir estilos de página a serem utilizados no projeto, tais estilos podem
incluir definições de fontes (nomes, tamanhos, cores), espaçamentos entre
outros. Além disso, podemos ter um arquivo “.resx” que é um arquivo de
recurso, podendo conter definições de algum tipo de informação (mensagem
ao usuário), imagens ou descrição de alguma informação de interface, para
este tipo de arquivo é possível alterar as informações nele contidas sem a
necessidade de recompilar o projeto.

Existem outros tipos de arquivos, apenas alguns foram mencionados para

ressaltar a importância de seus usos em um projeto web e a possibilidade de se
adicionar vários tipos de arquivos em um projeto utilizando o Visual Studio
2010.

Web Application

A criação de um projeto do tipo web application constitui um modelo no qual

é escolhido um template Web Application que mais se adapte às necessidades
de desenvolvimento do projeto, levando em conta algumas características
próprias deste tipo de aplicativo. Tais características podem ser visualizadas já
no momento em que o projeto é criado, descritas na estrutura de arquivos
criada na Solution Explorer. Além de arquivos diferenciados em relação a um
Web Site, um projeto Web Application tem o princípio de ao realizar uma
compilação do projeto, este irá gerar um único Assembly (uma DLL única)
adicionada na pasta Bin e os arquivos .aspx e .ascx devem ser incluídos no
servidor web onde o site será hospedado, pois estes arquivos serão acessados
dinamicamente utilizando os recursos do servidor web e retornando as
informações para o usuário. Na Figura 1 podemos ver a criação de um projeto
Web Application utilizando o Visual Studio 2010.
Figura 1. Criação de um projeto Web Application e escolha de um template

Após a criação do projeto, na Figura 2 é demonstrado a sua estrutura na

janela Solution Explorer e alguns arquivos especiais para esse tipo de projeto
são criados.

Figura 2. Solution Explorer de um projeto Web Application

Como possuímos alguns arquivos especiais, na Tabela 1 podemos visualizar

os principais arquivos e pastas deste tipo de projeto utilizando a linguagem de
programação C#.

Tipo Nome Descrição

Pasta App_Data É uma pasta que contém os arquivos de
dados, como arquivos XML, MDF e outros
tipos que possam armazenar dados.
Pasta Bin É a pasta que contém o Assembly do
projeto.
Pasta Obj Uma pasta que contém arquivos para a
constituição do Assembly do projeto.
Pasta Properties É a pasta que contém o arquivo
AssemblyInfo.cs da linguagem C#
responsável pelas informações dos
conjuntos de atributos e versão do
Assembly.
Pasta Nome_do_Projeto É a pasta base contendo o nome do projeto
criado e alguns arquivos de configuração
como o web.config, global.asax e os
arquivos .aspx iniciais.
Pasta Scripts Pasta destinada à adição de scripts para
serem utilizados em páginas do projeto.
Como exemplo, podemos ter scripts Ajax e
jQuery.
Pasta Styles Pasta destinada à adição dos estilos de
página (arquivos .css) que serão utilizados
no projeto.
Arquivo Default.aspx O web form padrão do ASP.NET.
Arquivo Default.aspx.cs Arquivo que contém o código fonte em C#
do web form.
Arquivo Default.aspx.designer.cs Arquivo de design para o web form.
Arquivo Web.config Arquivo de configuração que contém as
definições do aplicativo web.
Arquivo webNome_Projeto.csproj Documento XML que contém todas as
referências aos itens do projeto.
Arquivo webNome_projeto.csproj.user Arquivo que contém as configurações de
projeto para o usuário.

Tabela 1. Descrição de arquivos e pastas do projeto

Algumas das pastas não estão visíveis na janela Solution Explorer, mas estão
presentes na estrutura de pastas do local onde está salvo o projeto.

Ao criar o projeto e compilá-lo, o arquivo .sln, por padrão, com o mesmo

nome do projeto, é o responsável por representar a solução, um Assembly
único é gerado (DLL) referente aos arquivos necessários que compõem o
projeto e adicionado na pasta Bin.

Web Site

Um projeto do tipo Web Site é bastante diferenciado de um projeto do tipo

Web Application desde a sua criação, estruturação, arquivos e compilação.
Primeiramente não existe um arquivo de projeto do tipo .csproj, considerando
a linguagem de programação C#, como acontece no web application e todos
os arquivos presentes nas pastas deverão ser incluídos no servidor web do site.
Outra diferença, diz respeito à compilação do web site, onde a compilação
pode produzir vários arquivos Assembly e o código fonte é normalmente
compilado dinamicamente pelo servidor web onde está instalado o ASP.NET
na primeira vez em que o web site é executado.

[nota]A compilação de um web site também pode ser chamada de pré-

compilação para disponibilizá-la ao servidor web.[/nota]

Na Figura 3 podemos ver a criação de um web site utilizando o Visual Studio

2010 (disponível no menu File / New / Web Site).

Figura 3. Criação de um projeto web site e escolha de um template

Conforme ilustrado na Figura 4, podemos ver a estrutura de um projeto Web

Site na Solution Explorer.

Figura 4. Solution Explorer de um web site

Quando criamos um projeto web site, o Visual Studio 2010 cria em uma pasta
separada o arquivo da solução do projeto (arquivo .sln), tal local reservado,
que não aparece no projeto web site, normalmente, por padrão é a pasta
\Visual Studio 2010\Projects, onde contém as definições do projeto. Além
disso, o web site é criado em outro local, por padrão, é na pasta \Visual Studio
2010\WebSites, com as definições de arquivos e pastas semelhantes às
da Figura 4, descrita anteriormente. Na Tabela 2 podemos visualizar algumas
das pastas e arquivos juntamente com suas definições.

Tipo Nome Descrição

Pasta Account É uma pasta que contém os arquivos destinados
a autenticação de usuário.
Pasta App_Data É a pasta responsável pelo armazenamento de
dados.
Pasta Scripts Pasta utilizada para armazenar qualquer tipo de
scripts inclusive scripts Ajax e jQuery.
Arquivo Default.aspx O web form padrão do ASP.NET.
Arquivo Default.aspx.cs Arquivo que contém o código fonte em C# do
web form.
Arquivo Site.master Arquivo responsável pela visualização em
formato master-page do web form.

Tabela 2. Descrição dos principais arquivos e pastas de um projeto web site

Conhecendo as diferenças e escolhendo o tipo de projeto

Escolher um tipo de projeto irá depender de suas exigências e do estilo de

desenvolvimento do projeto a ser usado. Certas vezes será mais prático usar o
modelo Web site, por ele estar implicitamente definido em uma determinada
pasta, outras vezes será necessário utilizar um modelo com controle mais
rigoroso sobre o projeto, utilizando assim o modelo de Web Application. Em
resumo, dependerá do planejamento e da situação em que o projeto será
aplicado para, assim, definirmos qual tipo de projeto que deverá ser utilizado.

Os dois tipos de projetos web se diferenciam, basicamente, nos aspectos de

estrutura de projeto, compilação, uso de namespaces e implantação do projeto.
Cada item possui características próprias para determinado tipo de projeto,
sendo assim, iremos descrever esses aspectos para melhor entendimento de
suas diferenças.

Um projeto web application contém um arquivo do tipo .csproj, no caso da

linguagem de programação C#, que é o responsável por armazenar as
informações sobre o projeto, tais como os arquivos que fazem parte de sua
estrutura, suas referências e até mesmo o vínculo a outros projetos. Já um
projeto web site não possui este tipo de arquivo, pois todos os arquivos
contidos na sua estrutura de pastas são automaticamente incluídos como parte
presente do web site. Esta é uma das principais diferenças entre esses dois
tipos de projeto, visto que para incluir um arquivo em um projeto do tipo web
site podemos simplesmente copiar e colar os arquivos em sua estrutura de
pastas, já, no caso de um projeto web application, devemos adicionar os novos
arquivos para o projeto através do Visual Studio 2010, pois é ele quem irá
gerenciar o controle do projeto através de seu documento XML, ou seja, seu
arquivo .csproj.

Ao compilar um projeto web application, todas as classes incluídas no projeto

são compiladas e adicionadas em um único Assembly, que é adicionado na
pasta de projeto Bin. Tal Assembly é o responsável por ser o carro chefe que
irá gerenciar a aplicação e ele deve ser implantado no servidor web no qual o
sistema será disponibilizado, além disso, os arquivos .aspx de formulários
(web form), os arquivos .ascx de controle de usuários e outros arquivos de
conteúdo estático que façam referências ao projeto também devem ser
adicionados. No caso de um web site, o projeto será compilado com a
finalidade de realizar testes gerando múltiplos arquivos Assembly e sua
implantação em um servidor web pode ser realizada simplesmente copiando
os arquivos do projeto, incluindo os códigos fontes dos formulários do
aplicativo, para o servidor, sendo que o ASP.NET será o responsável por
gerenciar o aplicativo.

A compilação de um web site, por padrão, é realizada dinamicamente pelo

ASP.NET no servidor web onde possui o IIS instalado na primeira execução
de chamada do site, após os arquivos serem adicionados ou atualizados.

Os namespaces adicionados em um projeto web application, por padrão, são

explicitamente adicionados às páginas, controles e classes, já em um projeto
web site, eles devem ser adicionados manualmente para que possam ser
referenciados.

Após testar e validar o aplicativo, ele poderá ser implantado em um servidor

web, tal processo é chamado de Deploy, que consiste basicamente em copiar
os arquivos necessários para a execução do projeto no servidor. Tais arquivos
variam dependendo do tipo de projeto desenvolvido. Para um projeto web
application, o projeto compilado que irá gerar um Assembly único presente na
pasta bin, será adicionado ao servidor e a primeira chamada do aplicativo o
Assembly é copiado para uma determinada pasta temporária do ASP.NET,
sendo compilado pelo JIT. Após esta tarefa, o aplicativo estará pronto para ser
instanciado. Ao contrário, o projeto web site, por padrão não é pré-compilado,
no lugar disso o ASP.NET realiza a compilação na primeira vez em que uma
página do site é requisitada, podendo gerar um ou mais arquivos Assembly, o
que facilita a implantação e alteração de formulários em um servidor, sem a
necessidade de se compilar o projeto.
[nota]JIT é o acrônimo para compilador just-in-time, que é um tradutor que
converte, em tempo de execução, instruções de um formato para outro, por
exemplo, IL (Intermediate Language) para código de máquina.[/nota]

Na Tabela 3 é possível verificar algumas situações de uso que podem

influenciar a utilizar determinado tipo de projeto.

Situação Projeto mais indicado

O código fonte é Web site permite a alteração, pois o projeto não necessita do Visual Studio
implantado no servidor e para realizar a compilação, tarefa realizada pelo ASP.NET.
existe a possibilidade de
alterá-lo diretamente no
servidor.
Existe a necessidade de se Web application possibilita o desenvolvimento e a implantação somente de
manter, com maior arquivos necessários ao funcionamento do aplicativo, não salvando o
segurança, o código fonte código fonte no servidor.
do projeto.
Acessar o projeto via FTP No web site é possível alterar o código sem a necessidade de recompilar,
e alterá-lo. pois este serviço será realizado pelo ASP.NET.
Após desenvolver o projeto Web application permite integração com as demais ferramentas e técnicas
existe a intenção de utilizar de desenvolvimento presentes no Visual Studio 2010.
alguma outra ferramenta do
Visual Studio 2010 para
aperfeiçoamento ou
complementação do
projeto.
Gostaria de criar um Somente disponível como Web Application.
projeto ASP.NET MVC2.
Depurar o código sem Web application permite alterar o código sem parar a execução, pode-se
parar a execução do utilizar as funcionalidades de stop/continue do Visual Studio 2010.
aplicativo.
Existe a necessidade de se Um web site permite esta possibilidade com a adição de exceções de
incluir código da códigos que possibilitem estas funcionalidades.
linguagem C# e VB.NET
no mesmo projeto.
O projeto pode ser O web site possibilita ir adicionando os arquivos de acordo com a análise
implantado em módulos ou realizada no servidor (etapas de implantação de módulos definidas pelo
páginas e que seja programador). Exemplo: adiciona uma página, realiza verificações e passa
analisado no servidor. para a página seguinte.
Possui a intenção de O modelo de web site é mais indicado nesta situação, visto que não ocorre a
atualizar constantemente necessidade de se recompilar todo o projeto.
alguns arquivos .aspx e
.aspx.cs ou .aspx.vb no
servidor.
Possuirá uma equipe de A utilização de um web site facilita o desenvolvimento nesta situação, visto
desenvolvimento que cada programador da equipe poderá trabalhar de forma independente no
trabalhando desenvolvimento de arquivos pontuais do projeto.
constantemente em vários
arquivos distintos.

Tabela 3. Situações de uso de projetos web

A Tabela 3 apenas sugere qual o tipo de projeto é mais aconselhado a

utilizar, algumas das funcionalidades podem, também, estar presentes no
outro tipo.

Conclusão

Neste artigo alguns assuntos relacionados ao planejamento e desenvolvimento

web foram tratados inicialmente, para logo depois realizarmos o foco
principal do artigo, a descrição de um projeto web application e a descrição de
um projeto web site. Foi descrito como criar um projeto do tipo web
application e como criar um projeto do tipo web site, além disso, suas
principais pastas e arquivos também foram mencionados, juntamente com
suas funcionalidades. Também vimos uma tabela descrevendo algumas
possíveis situações de uso foi abordada para tentar auxiliar na escolha de um
determinado tipo de projeto.

Para concluir, vale lembrar que o tipo de projeto web a ser utilizado deverá ser
escolhido por quem o desenvolve tomando por base o planejamento inicial do
site e quais as características que ele deverá possuir, levando em conta, layout,
design, desenvolvimento, segurança, manutenção, backups, detecção e
correção de erros entre outros planejamentos.

Links

Web Site versus Web Application

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

Visual Studio Templates

http://msdn.microsoft.com/en-us/library/6db0hwky%28v=VS.80%29.aspx

Introduction: Planning an ASP.NET Web Site

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

ASP.NET Web Projects

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

ASP.NET Web Project file types

http://msdn.microsoft.com/en-us/library/2wawkw1c.aspx
ASP.NET Web Folder Structure
http://msdn.microsoft.com/en-us/library/ex526337.aspx

ASP.NET Web Site Projects

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

Building Web Site Projects

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

ASP.NET Deployment Content Map

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

Asp.Net MVC 2
http://msdn.microsoft.com/en-us/library/ff520618(VS.100).aspx

Understanding and Using Assemblies and Namespaces in .NET

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

Introduction to ASP.NET and Web Forms

http://msdn.microsoft.com/en-us/library/ms973868.asp[/nota]

por Rodrigo Araujo

Guru .net e tecnologias MS

Aplicações Windows
Forms, Class Libraries e
Arquivos TXT
Entre diversos assuntos, o artigo trata da
criação de arquivos de texto com uma
codificação específica para que possa ser
lido por programas de outras plataformas e
outros idiomas. Além disto, novidades da
linguagem C# na versão 4 são introduzidas
e também alguns aspectos práticos da
programação como leitura de configurações
da aplicação e o trabalho um pouco mais
avançado na criação de interfaces de
programas para o Windows.
Do que trata o artigo

Entre diversos assuntos, o artigo trata da criação de arquivos de texto com

uma codificação específica para que possa ser lido por programas de outras
plataformas e outros idiomas. Além disto, novidades da linguagem C# na
versão 4 são introduzidas e também alguns aspectos práticos da programação
como leitura de configurações da aplicação e o trabalho um pouco mais
avançado na criação de interfaces de programas para o Windows.

Para que serve

O artigo pode servir como referência e consulta para temas como gravação e
leitura de arquivos. Criação de projetos compartimentados onde as
funcionalidades estão divididas em diversos projetos. Criação de interfaces
Windows usando os componentes nativos da plataforma e também o trabalho
com classes com a linguagem C#.

Em que situação o tema é útil

Ainda que existam editores de textos profissionais, pode ser necessário criar
um editor personalizado, ou ainda, executar a leitura ou gravação de arquivos
de texto para diversas finalidades como, por exemplo, troca de informações
entre aplicações legadas.

Por outro lado, existem dentro do framework em que é difícil encontrar

exemplos práticos rapidamente, como por exemplo uso das classes para leitura
de arquivos ou ajustes para os programas Windows forms.
Pode-se usar o artigo também para tirar dúvidas sobre inclusão de referências
entre projetos e o trabalho com múltiplos projetos numa mesma Solution do
Visual Studio.

Resumo do DevMan

A gravação de arquivos de texto é muito simplificada quando se está usando o

framework .net, mas existem aspectos que precisam ser tratados com um
pouco mais de cuidado. Um destes é a codificação que o arquivo será criado e
armazenado. Ainda que o sistema Windows esteja presente na maior parte dos
computadores, ele está longe de ser uma unanimidade. Logo, pode surgir a
necessidade de se escrever um arquivo de texto que possa ser lido por outra
plataforma e também por um programa escrito em outro idioma. A
codificação correta resolve estes problemas. Neste artigo serão demonstrados
os principais elementos da linguagem C# para se realizar esta tarefa bem
como as noções principais para se gravar arquivos. Também serão abordados
alguns passos para se criar um programa separando-se suas funcionalidades
em módulos. A principal separação a ser feita é da funcionalidade
propriamente dita da interface gráfica com o usuário. No desenvolvimento do
projeto você terá contato com o funcionamento dos parâmetros de
configurações dos aplicativos Windows que são usados para dar maior
flexibilidade aos programas.

Um dos primeiros trabalhos realizados pelos programas de computador foi

permitir a edição de texto. Com isto tornou-se possível para produzir grandes
quantidades de texto rapidamente e permitindo ao escritor revisar, corrigir,
salvar o trabalho e continuar mais tarde, aproveitar textos escritos
anteriormente e inserir partes em um novo etc.

Com o tempo, a maior parte das informações trocadas entre os programas era
feita através de arquivos de texto e, ainda hoje, muitas das comunicações
feitas entre os programas, quer estejam no mesmo computador, distribuídos
numa rede ou pela Internet é feita desta forma, ou seja, usando arquivos de
texto puro.

Quando se diz “texto puro” deve-se entender um arquivo que contém apenas
o texto, sem formatação alguma. Quando editamos um arquivo em um
programa como o Microsoft Word por exemplo, além do texto digitado, são
armazenados os dados de formatação referente ao tipo da fonte, tamanho,
parágrafos etc.

É necessário para o programador conhecer os recursos para gravar e ler os

dados dos arquivos de texto para poder escrever aplicativos que executem
estas tarefas. Normalmente em ambientes de programação como o framework
.net, muitas classes estão disponibilizadas para que o trabalho seja feito da
forma mais abstrata possível. Estes recursos incluem desde classes que
executam o trabalho de uma vez só até as mais sofisticadas que tratam de
aspectos como permissões de escrita/leitura, indicação de que o arquivo deve
ser recriado quando o canal de escrita for aberto, tipo de acesso – leitura,
escrita, ambos.

Ao se criar uma aplicação para manipulação de textos pode ser interessante

fazer todo o trabalho com os arquivos no disco de uma maneira mais clara e se
possível separada do código que cuida da interface com o usuário. Isto vem
sendo enfatizado em vários artigos e por diversos programadores pois dá
maior flexibilidade. A forma mais básica de conseguir isto é escrever o código
necessário para trabalhar com os arquivos no disco em um projeto que pode
ser uma class library (dll´s) por exemplo e, outro projeto, que vai oferecer a
interface para digitar o texto, ler e criar os arquivos em outro.

Com o Visual Studio isto é bem simples de se conseguir já que uma mesma
“solution” pode ter vários projetos, inclusive interligados ou não. E como a
palavra de ordem para os desenvolvedores é “flexibilidade” uma maneira de
se implementar esta é mantendo a aplicação configurável, ou seja, permitindo
que se altere parâmetros que mudem um ou outro aspecto de seu
comportamento.

Os projetos do Visual Studio e do framework .net armazenam as

configurações em arquivos XML que são fáceis de compreender já que são
baseados em texto puro e lembram um pouco a linguagem de marcação
HTML. Da mesma forma, acessar estes dados de configuração é bem fácil
com a linguagem C# que vem evoluindo muito desde o seu lançamento.

Trabalhando com arquivos

Inicialmente, persistir dados, quer seja texto ou não, para sua posterior
recuperação era uma tarefa bem complexa. Nas primeiras linguagens de
programação era necessário lidar com problemas como encontrar espaço livre
no disco, alocar este espaço para o arquivo, transferir dados da memória para
o disco, certificar que os dados foram gravados corretamente etc.

Hoje isto tudo ficou bem mais fácil. O framework .net possui classes que
simplificam bastante a tarefa. Por exemplo, o código a seguir executa a
gravação de um arquivo de texto:

TextWriter tw = File.CreateText(@"d:\arquivo.txt");
tw.Write("Texto gravado no arquivo.");
tw.Close();
A classe “TextWriter” cria um objeto que faz a gravação. O método estático
“CreateText” da classe “File” que está contida na biblioteca “System.IO”
retorna um objeto para a gravação. Para gravar o arquivo texto, usamos o
método “Write”. Este objeto é em seguida fechado. Note que somente irá
funcionar com dados de texto, do tipo string. Se você precisar gravar dados
binários deve usar outro tipo de objeto como o código a seguir demonstra:

// objeto para gravar arquivo no disco

FileStream fs = new FileStream(@"d:\Data.bin", FileMode.Create);
// objeto que permite gravar dados binários
BinaryWriter bw = new BinaryWriter(fs);

for (int i = 0; i < 10; i++)

{
// grava o conteúdo no arquivo
bw.Write(i);
}

// fecha o writer
bw.Close();
// fecha o objeto que escreve no arquivo
fs.Close();

A diferença é que enquanto podemos escrever strings diretamente no objeto

que grava os dados no disco, para os dados binários, como números no
exemplo, é necessário um objeto do tipo “BinaryWriter” para fazer a
formatação. Este objeto está vinculado com o objeto do tipo “FileStream”.

Nota do DevMan

A classe “FileStream” é completa para as tarefas de ler e escrever em

arquivos e suporta tanto que se escreva e leia dados do tipo texto como
também dados binários. O detalhe é que para fazer isto você deve posicionar
o arquivo no ponto certo para leitura e escrita. A classe possui vários outros
métodos que permitem entre outras coisas, travar o arquivo enquanto estiver
sendo usado, procurar por dados dentro do mesmo etc.

Da mesma forma que a escrita, a leitura de arquivos texto é bem simplificada

podendo ser executada da seguinte forma:

TextReader tr = File.OpenText(@"d:\arquivo.txt");
Console.WriteLine(tr.ReadToEnd());
tr.Close();

Já a leitura de arquivos binários requer um pouco mais de código:

FileStream fs = new FileStream(@"d:\data.bin", FileMode.Open,
FileAccess.Read);
BinaryReader br = new BinaryReader(fs);
for(int i = 0; i < 10; i++)
Console.WriteLine(br.ReadInt32());

br.Close();
fs.Close();

Da mesma forma que precisamos de um objeto “FileStream” para gravar os

dados binários anteriormente, usamos o mesmo para ler os dados do arquivo
juntamente com um objeto da classe “BinaryReader”.

Na criação de uma instância do objeto “FileStream” precisamos passar além

do nome do arquivo o modo de acesso do arquivo, já que é possível abrir o
arquivo para criar um novo ou apenas para leitura. Além do modo do arquivo
é preciso dizer que operação será feita para que o mesmo seja corretamente
alocado na memória e bloqueie ou não o seu acesso para outros programas.
Isto foi feito no exemplo através da indicação “FileAccess.Read” que está
indicando que o arquivo será aberto apenas para leitura.

Estes passos são os mais básicos para fazer leitura, a seguir, existem algumas
considerações a serem feitas para escrever arquivos de texto.

A questão da codificação

Os arquivos de texto não são todos iguais. Considere questões como alfabeto
suportado pelo idioma, controle de quebra de linha e retorno de parágrafo
(sempre que um parágrafo termina, o novo deve começar em uma nova linha
na primeira coluna).

Para resolver estes problemas o sistema operacional grava junto com o texto
informações sobre como deverá formatar o texto e qual o conjunto de
caracteres a ser usado. Este processo é chamado de “Codificação”
(“Encoding” em inglês).

Normalmente, o framework trata muito bem as questões de codificação e

grava o arquivo num formato que seja compatível para a maioria dos
programas. Entretanto, você vai precisar fazer um tratamento mais minucioso
nas seguintes situações:

• Trocar informações entre programas legados (antigos) ou escritos em outras

plataformas como o UNIX ou mesmo MS-DOS;

• Precisar gravar ou ler textos em outros idiomas;

• Estiver criando páginas HTML;

• Estiver gerando mensagens de email.

Os principais tipos de codificação do framework estão presentes na classe

“System.Text.Encoding” e são:

1. Unicode UTF-8 Encoding: é representado no framework por

“Encoding.UTF8”. Codifica os bytes usando um conjunto de 8, 16, 24 e até
mais de 48 bits. É o mais recomendado para manter compatibilidade com
outros padrões;

2. Unicode UTF-16 Encoding: “Encoding.Unicode” representa os caracteres

em sequências de 16 bits;

3. ASCII: “Encoding.ASCII”. Usa apenas 7 bits para codificar e representa

apenas 127 caracteres sendo suficiente apenas para representar algarismos e
letras do alfabeto inglês. Não dá suporte para acentuação ou outros caracteres
especiais.

Nota do DevMan

Existem vários tipos de codificação suportados pelo framework. Cada um

possuindo um conjunto de caracteres em particular. Para poder representar
os caracteres de cada idioma, o Windows possui uma tabela atribuindo um
número de “code page” para cada um. Para poder trabalhar corretamente
com o texto, procure conhecer a “code page” apropriada. Programas
escritos em outras plataformas como o UNIX/LINUX ou mesmo o MS-DOS,
tendem a usar uma página de códigos diferente da que é usada pelo Windows.
No artigo não será tratado como usar as “code page” apenas, como gravar e
ler arquivos usando a codificação do framework.

Métodos no C# 4 – novidades

O C# é uma linguagem nova, mas desde seu lançamento muitas características

foram incorporadas, mas na versão 4 que é a última lançada, começou-se a
aproximar das linguagens dinâmicas.

Um dos principais pontos em que se percebe isto foi o suporte aos parâmetros
opcionais dentro dos métodos. Estes, são parâmetros que podem ser omitidos
na assinatura de um método tendo um valor default estabelecido caso o
parâmetro não seja passado. Para poder usar um parâmetro como opcional,
estes devem estar sempre no final da lista de parâmetros do método como, por
exemplo:

public int calcular(int num1, int num2, char operacao = ‘+’)

 {
...
}

Neste caso, o método deve obrigatoriamente receber dois parâmetros que são
os números para o cálculo. O terceiro parâmetro pode ser omitido que, neste
caso, o seu valor padrão será ‘+’.

Então, tanto faz usar o código assim:

Console.WriteLine( calcular(10, 10, ‘+’) );

Ou assim:

Console.WriteLine( calcular(10, 10) );

Também é possível usar uma ordem diferente ao passar os parâmetros para o

método, nomeando-os da seguinte forma:

Console.WriteLine( calcular( operacao: '/', num1: 10, num2: 5 ) );

Neste caso, estamos passando o nome dos parâmetros. Assim, não é

necessário obedecer a ordem em que foram criados na assinatura do método.

Parâmetros nomeados são úteis quando se estiver escrevendo métodos que

podem estar fazendo interface com linguagens dinâmicas, embora, se o
objetivo for somente trabalhar com a linguagem C#, isto pode tornar o código
um pouco confuso. A recomendação é evitar usar se não houver necessidade.

Configuração das aplicações Windows

A palavra de ordem nas empresas é flexibilidade. Isto se aplica também ao

software que se vai usar. Quanto mais configurável for a aplicação, mais fácil
será adaptar-se a novas situações que surgirem ou mudanças de requisito sem
que seja muitas vezes necessário reescrever a aplicação inteira.

Os programas que são feitos dentro do framework .net são fáceis de serem
configurados pois usam arquivos de configuração no formato XML.

XML é a sigla para “eXtensible Markup Language”, ou “Linguagem de

Marcação Extendida”. É uma forma de representar dados usando TAGS
muito parecida com a linguagem HTML, embora, um arquivo XML possa
possuir vários níveis de hierarquia e atributos e seja altamente extensível.

Nos projetos do Visual Studio, os arquivos de configuração levam a extensão

“.config”. Em tempo de projeto levam o nome “app.config”, sendo que,
depois de compilados, são copiados para a pasta dos arquivos binários gerados
(“bin\debug” ou “bin\release”) com o nome do executável mais a extensão
“.config”.

Estes arquivos não são gerados automaticamente. Para fazer isto você deve
usar o menu “Project >> Properties” e gerar pelo menos uma configuração.

Mesmo com um assistente para gerar estas configurações você vai precisar
fazer ajustes finos no arquivo de configurações abrindo e editando
manualmente para que seja possível acessar usando o código:

string val =
ConfigurationManager.AppSettings["ParmetroDeConfiguracao"];

A classe responsável pela leitura dos parâmetros é “ConfigurationManager”

que está em “System.Configuration” e não é inserida no projeto por padrão. O
atributo “AppSettings” acessa chave que foi inserida no arquivo de
configurações como se estivesse acessando dados de uma coleção do tipo
“Dictionary” do framework. Tome o cuidado de inserir o nome certo para a
chave ou será dado um “NullReferenceException” em tempo de execução.

Referenciando bibliotecas adicionais

Foi exposto anteriormente que a biblioteca “System.Configuration” não é

referenciada por padrão quando se cria um projeto no Visual Studio. Mesmo
que você inclua nas “usings” do seu projeto dessa forma:

using System.Configuration;

É necessário que você faça a referência usando a janela “Solution Explorer”

do projeto. Esta e muitas outras bibliotecas precisam ser incluídas nos projetos
muitas vezes. Verifique que, na demonstração que será dada está se
explicando como fazer referências a bibliotecas adicionais nos projetos. Isto
serve tanto para aquelas bibliotecas que fazem parte do mesmo projeto, que
será como o exemplo será desenvolvido, como para outras do framework ou
mesmo, dll´s de terceiros.

Requisitos da aplicação – funcionalidades

Para demonstrar os conceitos, será criado um projeto de um editor de textos

básico. Este editor permitirá criar e editar documentos de texto gravando o seu
conteúdo nas codificações “ASCII”, “UTF8” e “UNICODE”. Este aplicativo
vai mostrar uma janela para abrir arquivos existentes que podem ser do tipo
texto ou todos os arquivos. Também, através de um botão, limpa o conteúdo
do texto carregado, e cria um documento novo.
Para executar este projeto você vai precisar do Visual Studio 2010 ou uma de
suas edições Express. Também será necessário ter algum conhecimento em
como criar projetos nesta ferramenta, além de noções de programação
orientada a objetos e fundamentos da linguagem C#.

Estrutura

Para criar o aplicativo, tudo será feito em uma solução do Visual Studio 2010
usando a linguagem C# 4.0. As funcionalidades de ler e gravar o arquivo
serão realizadas por uma biblioteca (DLL) contida em um projeto do tipo
“Class library”. Este projeto será chamado “EditorLib”. A interface será
elaborada em uma aplicação Windows Forms chamada “Editor” que fará
referência ao projeto “EditorLib”.

Nota do DevMan

A separação de interface e funcionalidades em projetos distintos permite além

de uma divisão melhor das tarefas uma maior flexibilidade. Você irá perceber
que ambos os projetos terão apenas o código necessário para fazer cada uma
de suas tarefas. Por outro lado, este tipo de abordagem, permite também que
se você aproveite a biblioteca das rotinas de gravação e leitura em outros
tipos de projeto de interface. Suponha que você deseje mudar a interface com
o usuário para por exemplo WPF, isto será fácil de ser feito.

Criando a aplicação

Crie uma solução vazia no Visual Studio 2010 através da opção de menu “File
>> New >> Project” e escolha a opção “Other Project Types >> Visual Studio
Solution” na janela “New Project” e escolha “Blank Solution”. Veja os
detalhes na Figura 1.
Figura 1. Criando solução em branco

O próximo passo é criar um projeto do tipo “Class Library”. Faça isto

clicando com o botão direito do mouse, na janela “Solution Explorer” e
escolhendo “Add >> New Project” sobre o ícone da “Solution”. A Figura
2 mostra os detalhes para adicionar um novo projeto. Tome o cuidado de
escolher a linguagem C# e a versão 4 do framework.
Figura 2. Criando projeto de biblioteca

Projeto “EditorLib”

Este projeto contém as classes responsáveis pela manipulação dos arquivos.

Adicione uma classe neste projeto seguindo as configurações como estão
na Figura 3.
Figura 3. Adicionando classe ao projeto de biblioteca

Esta classe armazenará os dados do arquivo e deverá ter seu código como
naListagem 1. Observe na linha 1 a inclusão da biblioteca “Sytem.Text” nas
cláusulas “Using”. Isto se faz necessário para que possamos ter uma
propriedade que armazena o tipo da codificação do arquivo. Na linha 5
declaramos a classe com a acessibilidade “public” para poder ser referenciada
fora do projeto. Nas linhas 7 a nove temos as propriedades do arquivo que
são:

• “Nome” (linha 7), para o nome do arquivo;

• “Conteudo” para armazenar o texto do arquivo;

• “CodificacaoDoTexto” que guarda o tipo do “encoding” usado no arquivo

para gravação e leitura.

Listagem 1. Classe Arquivo

1 using System.Text;
2
3 namespace EditorLib
4 {
5 public class Arquivo
 6 {
7 public string Nome { get; set; }
8 public string Conteudo { get; set; }
9 public Encoding CodificacaoDoTexto { get; set; }
10 }
11 }
12

Esta classe só armazena. Para manipular os dados crie outra classe no projeto
chamada “ArquivoDisco”. Observe a declaração da classe e as bibliotecas que
devem ser importadas na Listagem 2.

Esta classe manipula arquivos no disco, por isso deve conter uma referência a
“System.IO”. Também fará a codificação do texto via classe “Encoding”, por
isso contém uma referência para “System.Text” na linha 2 e por fim, como faz
tratamento de “Exceptions” que são erros que podem acontecer durante a
execução, incluímos na linha 3 uma referência para “System”. Os métodos
serão do tipo “static” ou seja, não necessitam de uma instância da classe para
serem executados. Isto foi feito porque nenhum dado específico é armazenado
pela classe, logo não há a necessidade de instância da mesma. Este tipo de
classe é muito comum. É muito usado quando precisamos apenas executar
operações com dados vindos de outros objetos. A seguir, seguem as
descrições dos métodos que foram criados.

Listagem 2. Cabeçalho da classe ArquivoDisco

1 using System.IO;
2 using System.Text;
3 using System;
4
5 namespace EditorLib
6 {
7 public class ArquivoDisco
8 {
...

Lendo os arquivos

A leitura será feita por um método chamado “AbrirArquivo” que está

demonstrado na Listagem 3.

O método deve receber o nome do arquivo a ser lido e o tipo de codificação a

ser retornado. Devolve um objeto do tipo “Arquivo” indicando se foi possível
ler o arquivo e armazena erros que ocorreram no parâmetro de saída “erro”.
Nota do DevMan

A assinatura do método contida na linha 16 possui duas particularidades. A

primeira é o uso do parâmetro de saída que é referenciado pela palavra
chave “out” colocada ao lado da variável “erro”. Este tipo de parâmetro
deve ser obrigatoriamente inicializado antes de o método finalizar, por isso,
isto é feito logo na primeira linha do método (linha 19). Outra característica
é o uso dos parâmetros opcionais da linguagem C# versão 4. Observe que
após o nome do parâmetro é adicionado um valor padrão para ser usado,
caso nenhum parâmetro seja passado.

Toda a operação é feita dentro de um bloco protegido de código (blocos

try...catch) que se inicia na linha 21. Para poder indicar qual o tipo de
codificação a ser usada na leitura do arquivo, deve-se usar a classe
“StreamReader”. A linha 24 declara um objeto deste tipo, mas como o tipo da
codificação é passado por parâmetro e precisa ser verificada para ser
instanciada, o objeto é inicializado com um valor nulo. O método recebeu o
tipo da codificação como uma string para que seja possível deixar este
parâmetro opcional.

Por motivos didáticos, optou-se por deixar este parâmetro de codificação

opcional e usando strings, você pode fazer isto de outras maneiras passando,
por exemplo, um parâmetro já do tipo de codificação a ser usado.

Da linha 26 até a linha 33 um laço “switch” verifica a string que foi usada
como parâmetro de codificação. Em cada linha é inicializado o objeto stream
de leitura passando o nome do arquivo a ser carregado e a codificação correta.

A leitura do arquivo é feita juntamente com a inicialização do objeto que será

retornado. Na linha 36 fazemos uma instância ao objeto do tipo “Arquivo”. A
inicialização do objeto é feito de maneira direta, sem construtor, passando os
valores para cada propriedade da classe diretamente, note na linha 39 como o
conteúdo é passado de uma só vez através do método “ReadToEnd()” da
classe “stream”.

Terminando o bloco, fecha-se o objeto stream na linha 44 e retorna-se o objeto

do arquivo na linha seguinte. Das linhas 47 até a 51 caso algum erro aconteça,
como por exemplo impossibilidade de ler o arquivo, é capturado o erro que
ocorreu (linha 47) e passado para a variável de erro (linha 50). Se o seu código
chegar até a linha 53, isto indica que não foi possível ler, então, um valor nulo
é retornado pelo método.

Nota do DevMan
Existem várias maneiras de se fazer estas operações sendo que você pode
experimentá-las quando achar conveniente. O uso de inicialização direta dos
objetos, sem uso de um construtor deve ser feito com cuidado porque podem
existir parâmetros importantes que fiquem sem ser inicializados. Nesta
implementação não foram feitas verificações como se o arquivo existe, se o
usuário tem permissões etc., para poder simplificar a demonstração,
entretanto, faça isto sempre que puder.

Listagem 3. Método para ler o arquivo

9 /// <summary>
10 /// Abre o arquivo recebendo opcionalmente uma codificação
11 /// </summary>
12 /// <param name="nome"></param>
13 /// <param name="erro"></param>
14 /// <param name="codificacao"></param>
15 /// <returns></returns>
16 public static Arquivo AbrirArquivo(string nome, out string
erro, string codificacao = "ASCII")
17 {
18 // inicializa variável para mensagens de erro
19 erro = string.Empty;
20
21 try
22 {
23 // objeto que faz a leitura
24 StreamReader sr = null;
25
26 // verifica qual a codificação será usada
27 switch (codificacao)
28 {
29 case "ASCII": sr = new StreamReader(nome, new
ASCIIEncoding()); break;
30 case "UTF8": sr = new StreamReader(nome, new
UTF8Encoding()); break;
31 case "UNICODE": sr = new StreamReader(nome, new
UnicodeEncoding()); break;
32 default: sr = new StreamReader(nome, new
UTF8Encoding()); break;
33 }
34
35 // cria um objeto para receber o texto
36 Arquivo arquivoRetorno = new Arquivo
37 {
 38 Nome = nome,
39 Conteudo = sr.ReadToEnd(),
40 CodificacaoDoTexto = sr.CurrentEncoding
41 };
42
43 // fecha o objeto de leitura
44 sr.Close();
45 return arquivoRetorno;
46 }
47 catch (Exception ex)
48 {
49 // captura a mensagem de erro
50 erro = string.Format("Não foi possível abrir o
arquivo. {0}", ex.Message);
51 }
52
53 return null;
54 }

Gravando o arquivo

Adicione o método Listagem 4 que faz a gravação do arquivo na classe

“ArquivoDisco”. A declaração do método, na linha 63 recebe os seguintes
parâmetros:

1. Um objeto indicando o arquivo a ser gravado;

2. Um parâmetro string de saída para armazenar mensagens de erro;

3. Um parâmetro opcional (C# 4 apenas) indicando o tipo da codificação a ser

usada na gravação.

Na linha 66 inicializamos a variável para as mensagens de erro. Toda a

operação começa na linha 68 e será executada em um bloco protegido de
código. Na linha 71 inicializamos o objeto que fará a gravação do texto de
maneira codificada. Como será necessário examinar o tipo de codificação a
ser usada, o objeto recebe um valor nulo, sendo instanciado dentro do bloco
“switch” da linha 77 até a 83.

Precisaremos de um objeto do tipo “FileStream” para poder fazer a gravação

do texto codificado, na linha 73 criamos este objeto indicando que deverá
truncar o arquivo se existir, deverá ter acesso de escrita e não permitirá o
acesso enquanto estiver sendo usado. Uma vez instanciado o objeto é feita a
escrita na linha 86 e fechado o acesso ao arquivo, liberando-o para outros
acessos nas linhas 87 e 88. Por fim, é retornado um valor boolean indicando
que a operação foi bem-sucedida. Das linhas 92 até 96 é feito o tratamento de
erro e, caso tenha ocorrido, o método retorna “false” indicando que a operação
não foi bem-sucedida.

Listagem 4. Método para gravar o arquivo

56 /// <summary>
57 /// Grava o arquivo de texto.
58 /// </summary>
59 /// <param name="objArquivo"></param>
60 /// <param name="erro"></param>
61 /// <param name="codificacao"></param>
62 /// <returns></returns>
63 public static bool GravarArquivo(Arquivo objArquivo, out
string erro, string codificacao = "ASCII")
64 {
65 // inicializa variável para mensagem de erro
66 erro = string.Empty;
67
68 try
69 {
70 // objeto stream para gravar
71 StreamWriter sr = null;
72 // objeto para manipular o arquivo
73 FileStream fs = new FileStream(objArquivo.Nome,
74 FileMode.OpenOrCreate, FileAccess.Write,
FileShare.None);
75
76 // configura a codificação a ser usada
77 switch (codificacao)
78 {
79 case "ASCII": sr = new StreamWriter(fs,
Encoding.ASCII); break;
80 case "UTF8": sr = new StreamWriter(fs,
Encoding.UTF8); break;
81 case "UNICODE": sr = new StreamWriter(fs,
Encoding.Unicode); break;
82 default: sr = new StreamWriter(fs,
Encoding.ASCII); break;
83 }
84
85 // grava o texto no arquivo
86 sr.Write(objArquivo.Conteudo);
 87 // fecha os objetos
88 sr.Close();
89 fs.Close();
90 return true;
91 }
92 catch (Exception ex)
93 {
94 // captura mensagens de erro
95 erro = string.Format("Não foi possível gravar o
arquivo. {0}", ex.Message);
96 }
97
98 return false;
99 }

Aplicação Windows

Para demonstrar e consumir o código criado até aqui, usaremos uma aplicação
do tipo Windows Forms. Adicione na sua solution do Visual Studio como fez
anteriormente, observando o tipo de projeto conforme na Figura 4. Configure
as propriedades do formulário principal como na Tabela 1.

Figura 4. Adicionando projeto Windows Forms•

Propriedade Valor
(Name) frmPrincipal
Size 640; 480
Text Editor de Texto

Tabela 1. Ajustando o formulário principal

Arraste no formulário os seguintes componentes:

1. ToolStrip;

2. TextBox;

3. OpenFileDialog;

4. SaveFileDialog.

Ajuste as propriedades de cada um destes componentes como na Tabela 2.

Controle Propriedade Valor

ToolStrip Dock Top
TextBox (Name) textBox1
Dock Fill
Font Consolas; 9,75pt
MaxLength 64000
Multiline True
ScrollBars Both
SaveFileDialog (Name) saveFileDialog1
Title Gravar arquivo
OpenFileDialog (Name) openFileDialog1
Title Abrir arquivo

Tabela 2. Controles do formulário principal

No controle “ToolStrip” adicione os controles padrão clicando sobre o mesmo

com o botão direito do mouse sobre ele e escolhendo a opção “Insert Standard
Items” como na Figura 5. Isto irá inserir os botões básicos deste controle.
Figura 5. Configurando a barra de ferramentas

Ainda usando este controle usando o botão do designer, insira um

“Label” e um controle “ComboBox” que será usado para escolher o tipo da
codificação do texto. Configure estes controles como na Tabela 3. A janela
deverá ficar com uma aparência parecida com a da Figura 6.

Controle Propriedade Valor

Label Text Codificação
ComboBox (Name) cmbEncoding
DropDownStyle DropDownList
Items ASCII

UTF8

UNICODE

Tabela 3. Controles adicionais do controle “ToolStrip”

Figura 6. Design do formulário

Adicionando referência ao projeto “EditorLib”

Como foi explicado, a aplicação Windows consome código da biblioteca que

foi criada. É necessário adicionar uma referência para este projeto. Dentro da
janela “Solution Explorer”, no projeto da aplicação Windows, clique sobre a
pasta “References” com o botão direito do mouse e clique em “Add
Reference...”. (Ilustrado na Figura 7). Na janela “Add Reference” que se
abre, escolha a opção “Projects”. Veja detalhes na Figura 8. Com isto já é
possível começar a escrever o código da aplicação.

Figura 7. Adicionando referência ao projeto

Figura 8. Referenciando projeto da mesma solution

Nota do DevMan

É possível também usar bibliotecas de outros projetos ou uma “DLL”

existente. O processo é bem simples como você pode ver pela janela. Procure
pesquisar sobre como fazer referências a outros executáveis e outras
bibliotecas em seu projeto.

Código da aplicação

Feita as configurações visuais básicas chegou a hora de escrever o código.

Para poder controlar as alterações no arquivo a ser usado, precisaremos de um
objeto armazenando os dados como o nome do arquivo que está sendo
editado. Alterne o editor do Visual Studio para mostrar o código do
formulário. A Listagem 5 mostra como deve ficar o começo deste código.

Listagem 5. Definindo objeto para manipular o arquivo

1 using System.Configuration;
2 using System.Windows.Forms;
3
4 namespace Editor
5 {
6 public partial class frmPrincipal : Form
7 {
8 EditorLib.Arquivo objArq;
9
10
...

Observe nas linhas 1 e 2 as bibliotecas que devem ser referenciadas. Na linha

1, referenciamos “System.Configuration” seu uso será visto em seguida para
que possamos ler dados da configuração da aplicação. Na linha 2, uma
referência a “System.Windows.Forms”. Na linha 8 foi criado um objeto do
tipo “Arquivo” que faz parte da “Class library” referenciada no projeto. É este
objeto que irá controlar se o arquivo já foi gravado alguma vez etc.
Configurações da aplicação

Se você olhar para a Tabela 2 onde foram configurados os controles visuais e

não visuais da janela, perceberá que não foram acrescentados filtros de
arquivo para os controles “OpenFileDialog” e “SaveFileDialog”. Isto foi feito
para demonstrar como ler dado do arquivo de configuração.

Para criar as configurações básicas da aplicação, acesse o menu “Project >>

Properties”. Na janela que se abre escolha a opção “Settings” como na Figura
9 abaixo. Digite o conteúdo como está na figura, não se preocupe muito com
seu conteúdo porque vamos editar o arquivo de configurações manualmente
para poder fazer ajustes.

Figura 9. Configurando o projeto

Do jeito que está fica muito difícil para acessar os dados de configuração.
Edite o arquivo de configurações clicando na janela “Solution Explorer” no
ícone “app.config”. Tome cuidado para clicar no ícone correspondente ao
projeto correto. Altere seu conteúdo para que fique como o daListagem 6.
Nas linhas 8 a 10 inserimos a configuração que armazena o filtro a ser usado
nas caixas de diálogo para abrir e gravar os arquivos.

Listagem 6. Arquivo de configuração

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

2 <configuration>
3 <configSections>
4 <sectionGroup name="applicationSettings"
type="System.Configuration.ApplicationSettingsGroup, System,
Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >
5 <section name="Editor.Properties.Settings"
type="System.Configuration.ClientSettingsSection, System,
Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
requirePermission="false" />
6 </sectionGroup>
7 </configSections>
8 <appSettings>
9 <add key="TipoDeArquivo" value="Arquivo de texto
(*.txt)|*.txt|Todos os arquivos (*.*)|*.*"/>
10 </appSettings>
11 </configuration>

A Listagem 7 demonstra como ler esta configuração. Note que este arquivo
de configuração em tempo de projeto chama-se “app.config”, após o “build” o
mesmo é copiado para a basta “bin\debug” (ou “bin\release”) e é renomeado
para <nome do projeto>.config.

Listagem 7. Lendo configurações para configurar caixas de diálogo

111 /// <summary>

112 /// Configuração das caixas de diálogo
113 /// </summary>
114 /// <param name="sender"></param>
115 /// <param name="e"></param>
116 private void frmPrincipal_Load(object sender, System.EventArgs
e)
117 {
118 // lê as configurações do programa
119 openFileDialog1.Filter =
ConfigurationManager.AppSettings["TipoDeArquivo"];
120 saveFileDialog1.Filter = openFileDialog1.Filter;
121 // configura a opção padrão para a
122 // codificação do arquivo
123 cmbEncoding.SelectedIndex = 0;
124 }

Esta listagem demonstra o código que é executado no evento “Load” do

formulário. Para gerar este método, dê um clique duplo sobre o formulário.
Este código é executado apenas uma vez quando se carrega o formulário. Na
linha 119 configuramos o filtro dos arquivos para a janela de abertura dos
mesmos. Para isso usamos a classe “ConfigurationManager”. Esta classe
requer que se referencie a biblioteca “System.Configuration” (faça isso
através da Solution Explorer). Na linha seguinte, copiamos o filtro da janela
de abertura de arquivos para a janela de gravação. Por fim, a configuração do
formulário deixa selecionado no controle combo box a primeira opção de
codificação.
Criando arquivo novo

O editor de texto deve permitir criar um documento novo. Dê um duplo clique

sobre o botão |(novo) e digite o código da Listagem 8. Este código
pergunta para o usuário se deve limpar o texto que está carregado (na linha
102). Caso o usuário confirme esta operação através de uma janela de
confirmação, na linha 106, se limpa o conteúdo do texto e deixa o objeto que
se refere ao arquivo como nulo para, quando for fazer a gravação pela
primeira vez, seja perguntado um nome para o arquivo.

Listagem 8. Criando um arquivo novo

89 /// <summary>
90 /// Criando um arquivo novo
91 /// </summary>
92 /// <param name="sender"></param>
93 /// <param name="e"></param>
94 private void newToolStripButton_Click(object sender,
System.EventArgs e)
95 {
96 // antes de criar um arquivo novo
97 // verifica se já existe algum arquivo
98 // carregado no editor.
99 if (objArq != null)
100 {
101 // pede confirmação da operação
102 if (MessageBox.Show("Descartar modificações do arquivo
atual?",
103 "Confirmação", MessageBoxButtons.YesNo,
MessageBoxIcon.Question) ==
104 System.Windows.Forms.DialogResult.Yes)
105 {
106 textBox1.Text = string.Empty;
107 objArq = null;
108 }
109 }
110 }

Gravação do texto

O passo seguinte é gravar o texto usando a codificação que foi escolhida. Para
incluir o código da Listagem 9, dê um clique duplo no botão . Este método
começa verificando se o objeto do arquivo já foi instanciado. Na linha 55 se
ainda não foi, o objeto está nulo. Neste caso é necessário obter um nome para
o arquivo através do controle “SaveFileDialog” que é exibido na linha 59.

Este controle verifica se o arquivo já existe e se pode ser sobrescrito. Caso não
seja validado o nome do arquivo, a propriedade “FileName” ficará vazio. Isto
é inspecionado na linha 61. Continuando, é criada uma instância para o objeto
da classe “Arquivo” e são passados o nome e o conteúdo (linhas 68 até 72).
Caso o arquivo já tenha sido instanciado, atualiza-se o texto como na linha 76.

O método ‘GravarArquivo” da classe “ArquivoDisco” requer um parâmetro

de retorno para mensagens de erro. Criamos uma variável string para isso na
linha 80.

Embora como vimos no método anteriormente esta variável é sempre

inicializada, é uma boa prática inicializar valores padrões para variáveis que
podem ficar vazias, Por isso está sendo passado “string.Empty” para a
variável de erro.

O método da classe é invocado na linha 83 e, se houver um erro, é exibida a

mensagem de erro retornada na linha 86, ou caso tudo corra bem, o controle
“TextBox” recebe o foco.

Listagem 9. Gravando o arquivo

47 /// <summary>
48 /// Grava o arquivo
49 /// </summary>
50 /// <param name="sender"></param>
51 /// <param name="e"></param>
52 private void saveToolStripButton_Click(object sender,
System.EventArgs e)
53 {
54 // verifica se foi criado algum arquivo
55 if (objArq == null)
56 {
57 // se não foi criado ainda um nome
58 // abre a caixa de diálogo para salvar
59 saveFileDialog1.ShowDialog();
60
61 // verifica se um nome válido foi digitado
62 if (string.IsNullOrEmpty(saveFileDialog1.FileName))
63 {
64 return;
65 }
66
 67 // cria o objeto para gravar
68 objArq = new EditorLib.Arquivo
69 {
70 Conteudo = textBox1.Text,
71 Nome = saveFileDialog1.FileName
72 };
73 }
74 else
75 {
76 objArq.Conteudo = textBox1.Text;
77 }
78
79 // variável para receber erros
80 string erro = string.Empty;
81
82 // invoca o método para gravar
83 if (!EditorLib.ArquivoDisco.GravarArquivo(objArq,
84 out erro, cmbEncoding.Text))
85 {
86 MessageBox.Show(erro);
87 }
88 else
89 {
90 textBox1.Focus();
91 }
92 }

Carregando o arquivo no editor

O editor também permite que se abra arquivos existentes e faça edição. Dê um

duplo clique no botão e insira o código da Listagem 10. O código para
abrir o arquivo começa mostrando a janela “OpenFileDialog” que pergunta
pelo nome do arquivo a ser aberto na linha 22.

Este controle, assim como a janela “SaveFileDialog” também valida o nome

do arquivo e se existe. Caso positivo, um valor válido é passado para a
propriedade “FileName” do controle (linha 25). Caso não seja possível abrir o
arquivo, o método é finalizado (linha 27).

O método que abre o arquivo também requer um parâmetro de saída para

receber mensagens de erro. Para isso inicializamos uma variável do tipo string
para receber estas mensagens na linha 31.
Na linha 33 fazemos o objeto da classe “Arquivo” receber o resultado do
método “AbrirArquivo” da classe “ArquivoDisco”. Este método recebe o
nome do arquivo (que foi passado para o controle “OpenFileDialog”), a
variável de saída para a mensagem de erro e o tipo da codificação que foi
escolhida no controle “ComboBox”.

Na linha 38 caso tenha havido erro, o objeto estará nulo, neste caso, na linha
40, é exibida a mensagem de erro retornada pelo método, caso contrário, na
linha 44, o texto que foi lido é carregado no controle TextBox.

A Figuras 10, 11 e 12 mostram o projeto sendo executado.

Listagem 10. Abrindo e carregando arquivo

14 /// <summary>
15 /// Abre a caixa de dialogo para abrir o arquivo
16 /// </summary>
17 /// <param name="sender"></param>
18 /// <param name="e"></param>
19 private void openToolStripButton_Click(object sender,
System.EventArgs e)
20 {
21 // mostra a caixa de diálogo
22 openFileDialog1.ShowDialog();
23
24 // se nenhum arquivo foi retornado, sai da rotina
25 if (string.IsNullOrEmpty(openFileDialog1.FileName))
26 {
27 return;
28 }
29
30 // variável que receberá as mensagens de erro
31 string erro = string.Empty;
32 // invoca método da biblioteca
33 objArq =
EditorLib.ArquivoDisco.AbrirArquivo(openFileDialog1.FileName,
34 out erro,
35 cmbEncoding.Text);
36
37 // verifica se houve algum erro
38 if (objArq == null)
39 {
40 MessageBox.Show(erro);
41 }
 42 else
43 {
44 textBox1.Text = objArq.Conteudo;
45 }
46 }

Figura 10. Janela principal da aplicação

Figura 11. Janela para gravar o arquivo
Figura 12. Abrindo arquivos

Conclusão

A manipulação de arquivos de texto no framework.net é bem simplificada

graças às classes demonstradas. Tanto o trabalho com os dados executando
tarefas de criação de arquivos, gravação e leitura como a elaboração de uma
interface para facilitar o trabalho do usuário final nestas tarefas pode ser
elaborado rapidamente com os recursos do framework e das aplicações
Windows Forms.

Se optar por separar as funcionalidades da aplicação final em módulos ou

projetos como “class library” terá mais flexibilidade e reusabilidade de
código. Como foi colocado neste artigo, a classe que faz a manipulação dos
arquivos pode ser usada em projetos de outro tipo como aplicações Web ou
WPF.

Existem vários aspectos quanto à codificação do texto, mas, o primeiro passo

foi dado ao escolher o tipo de codificação ao se gravar o arquivo. É possível
ainda configurar como sua exibição será feita no controle de texto que será
usado e ainda, existem vários componentes pagos e gratuitos para a criação de
editores de texto profissionais.
Links

Desenvolvimento de aplicações Windows Client

http://www.windowsclient.net.

Download Visual Studio 2010 Express

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

por Vladimir Rech

Guru .net e tecnologias MS

XML
O artigo descreve técnicas básicas para ler
e criar documentos XML que são a base
para várias das aplicações modernas,
conectadas ou não. Através de exemplos
práticos será possível iniciar o uso e
entendimento destes documentos com o
framework .net.
Do que trata o artigo

O artigo descreve técnicas básicas para ler e criar documentos XML que são a
base para várias das aplicações modernas, conectadas ou não. Através de
exemplos práticos será possível iniciar o uso e entendimento destes
documentos com o framework .net.

Para que serve

Documentos XML são usados em um número enorme de aplicações. Seu

objetivo principal é a troca de dados entre aplicações on line ou não, mas
vários outros usos surgiram com o passar do tempo, sendo hoje usados para
armazenar dados de aplicativos como o Office 2007 em diante e também
parâmetros de configuração. Logo, ter um início da compreensão do uso
destes arquivos e de como escrever e ler nestes de forma objetiva acelera o
início do uso destes documentos nos trabalhos do dia a dia.

Em que situação o tema é útil

Sempre que se precisar ler ou escrever documentos XML, este artigo poderá
ser usado como um ponto de partida para a execução das tarefas. Como as
tarefas serão expostas em classes separadas, estas poderão ser usadas
posteriormente em outros projetos e ter suas funcionalidades expandidas. Os
documentos XML têm um número grande de aplicações sendo a base para os
Webservices e também para a plataforma WPF da Microsoft que usa uma
variação desta linguagem para montar interfaces com o usuário mais
aprimoradas.

Resumo do DevMan

O armazenamento dos dados gerados e gerenciados pelos programas de

computador sempre foi um grande problema. Inicialmente, todos estes dados
eram armazenados em arquivos binários sendo necessária a utilização de
programas específicos para ler o seu conteúdo.

Com a chegada do sistema UNIX, procurou-se fazer tudo usando documentos

de texto o que realmente simplificou boa parte dos trabalhos. Entretanto,
quando se deseja expressar os dados seguindo uma estrutura que facilite a
compreensão tanto dos dados armazenados como informações sobre estes
dados – o que é chamado de “metadados” – sempre havia uma lacuna a ser
preenchida. Os documentos XML são revolucionários pois permitem tanto
armazenar os dados de maneira estruturada como permitem que qualquer
pessoa compreenda os dados que estão guardados ao ver sua estrutura. Estes
tipos de documentos são armazenados em arquivos de texto puro, logo, têm
caminho livre pelas redes e podem ser visualizados com programas bem
simples. Mas sua manipulação requer conhecimentos avançados tanto de
programação como de criação de interfaces. O artigo procura colocar os
primeiros elementos que devem ser conhecidos pelo programador que deseja
aprender a usar esta tecnologia.

O framework .net é especialmente preparado para trabalhar com XML, mas a

grande quantidade de recursos pode fazer com que o programador mais
novato fique intimidado. Para resolver este problema, este artigo mostra
algumas das formas mais básicas de executar o trabalho com o XML e
também um exemplo bem simples e prático.

O armazenamento de dados e troca destes entre os programas sempre causou

dificuldades para os programadores. Ocorre que ao fazer este armazenamento
e também o intercâmbio entre programas diferentes é necessário que além dos
dados sejam passadas informações sobre a forma que estes estão estruturados
e a sua hierarquia. Isto é o que se chama de “metadados” ou usando uma
pequena paródia “dados sobre os dados”. A ideia parece simples para
programar, mas não é. Como enviar, juntamente com os documentos, a
informação sobre a sua estrutura?

O sistema operacional UNIX procurou fazer isto bem feito usando os arquivos
de texto que, sob o ponto de vista de segurança da rede e compatibilidade com
outros programas são quase inofensivos, mas têm limitações quando se
pretende descrever sua estrutura.

Geralmente, quando se usa arquivos de texto puro, precisa-se conhecer o

layout dos dados ali armazenados e isto normalmente é feito usando-se
arquivos com a estrutura em separado, o que complica as tarefas. Caso se opte
por enviar a estrutura junto com os dados, precisa-se de pelo menos mais um
documento indicando em que parte do arquivo começa a estrutura e onde
começam os dados. Arquivos binários fazem o mesmo gravando geralmente
num cabeçalho a estrutura dos dados e em seguida os dados. Mas existe a
questão da segurança.

Num cenário ideal, seria necessário que um documento já descrevesse sua

estrutura diretamente com os dados e se isto pudesse ser feito usando arquivos
de texto, que possam ser compreendidos por qualquer pessoa que leia este
arquivo, seria perfeito.

O desenvolvimento das tecnologias de rede e posteriormente a Internet

potencializou a troca de dados entre computadores remotos. Uma das
primeiras criações que permitiu estruturar os dados e formatá-los para
exibição foi a linguagem HTML que usa marcadores (TAGS) para formatar e
estruturar os documentos. Documentos HTML são compostos de texto puro,
embora ultimamente vários dados binários venham se incorporando. Mas a
essência é texto mesmo.

Como evolução natural surgiu em meados do final da década de 1990 um

novo formato de documento, o XML. XML é uma sigla para o termo em
inglês “eXtensible Markup Language” ou, Linguagem de Marcação
Extensível e são o foco dos próximos tópicos.

Documentos XML

Documentos XML são arquivos criados com uma linguagem de marcação

baseada em TAGS muito parecida com a linguagem HTML.

As principais diferenças são:

1. Documentos XML são hierárquicos. Cada elemento pode ter elementos
filhos, mas devem ser rigidamente estruturados;

2. Documentos XML são "case sensitive" quanto a nomenclatura das TAGS;

3. Todo elemento deve ter uma TAG de abertura e de fechamento;

4. As TAGS podem ter atributos.

O documento da Listagem 1 mostra um XML mais básico onde, na primeira

linha é feita a declaração da versão da linguagem XML que está sendo usada.
Isto embora não seja mandatório, facilita ao programa que fará a leitura
executar sua tarefa. A TAG de definição da linguagem possui um sinal de
interrogação “?” e dois atributos. Entretanto, mais atributos podem ser
acrescentados como o indicador do "namespace" e o arquivo de "schema" no
qual o documento XML se baseou.

Nota do DevMan

Documentos XML geralmente possuem um indicador do "namespace" para

que seu conteúdo seja validado. Geralmente, trata-se de um endereço no
formato URL para outro documento onde constam as regras para validação
do documento. Já um arquivo de “schema” contém a estrutura do XML
indicando quais são as TAGS que o documento pode ter e também o conteúdo
que será permitido. Este arquivo é identificado pela extensão “XSD”.

Continuando na análise do documento XML da listagem, o conteúdo inicia-se

na TAG “<contato>”. Esta contém outros elementos aninhados. Note que cada
elemento deve possuir uma TAG de abertura e de fechamento correspondente.
O elemento “<contato>” é fechado na linha 9.

Listagem 1. Documento XML básico

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

2 <contato>
3 <nome>Jose Ferreira</nome>
4 <telefone>4444-3322</telefone>
5 <celular>9876-2334</celular>
6 <email>[email protected]</email>
7 <dataNascimento>8/3/1975</dataNascimento>
8 <outros>Twitter: @joseferreira</outros>
9 </contato>

Um documento XML pode ter vários elementos do mesmo tipo como

a Listagem 2demonstra. Este documento é um pouco mais complexo e
demonstra uma aplicação muito próxima do mundo real para um documento
XML. A listagem expressa um pedido de compra com a identificação do
emitente e também os produtos que fazem parte do produto.

A linha 2 abre o elemento principal que é o pedido propriamente dito. Nesta

TAG existe um atributo indicando o número do pedido. Os atributos são como
elementos auxiliares para conterem dados sobre a TAG. O elemento “<itens>”
é usado para aninhar os produtos do pedido. Cada item é composto por um
elemento do tipo “<produto>”. Note que este elemento (que se inicia na linha
8) possui ele próprio um atributo, mais elementos e um elemento filho
denominado “<tributacao>”.

Listagem 2. Documento XML com vários níveis e atributos

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

2 <pedido id="2332">
3 <data>23/11/2010</data>
4 <empresa>Alimentos Naturais Ltda</empresa>
5 <prazo>30</prazo>
6 <desconto>30,00</desconto>
7 <itens>
8 <produto id="1">
9 <descricao>Sal marinho iodado</descricao>
10 <quantidade>1000</quantidade>
11 <unidade>KG</unidade>
12 <unitario>3,50</unitario>
13 <tributacao>
14 <icms>
15 <aliquota>12</aliquota>
16 <cf>000</cf>
17 </icms>
18 </tributacao>
19 </produto>
20 <produto id="1003">
21 <descricao>Tomate organico seco</descricao>
22 <quantidade>3500</quantidade>
23 <unidade>KG</unidade>
24 <unitario>15</unitario>
25 <tributacao>
26 <icms>
27 <aliquota>12</aliquota>
28 <cf>000</cf>
29 </icms>
30 </tributacao>
 31 </produto>
32 <produto id="3020">
33 <descricao>Molho Shoyu</descricao>
34 <quantidade>500</quantidade>
35 <unidade>Garrafa</unidade>
36 <unitario>4,38</unitario>
37 <tributacao>
38 <icms>
39 <aliquota>12</aliquota>
40 <cf>000</cf>
41 </icms>
42 </tributacao>
43 </produto>
44 </itens>
45 </pedido>

Os documentos do tipo XML podem ser facilmente visualizados nos browser

mais atuais. Estes além de mostrar o conteúdo do documento também permite
uma navegação pela hierarquia dos nós abrindo e fechando os mesmos.
Geralmente os documentos XML são associados com o browser padrão do
sistema, no caso do Windows, o Internet Explorer. Logo se você der um
clique duplo sobre este arquivo o seu conteúdo é exibido neste programa
como demonstra a Figura 1.
Figura 1. Documento XML visualizado no browser

Outros browsers também fazem este trabalho, mas servem apenas para
visualizar o conteúdo e não editar. Existem vários programas que permitem
fazer isto, além de você poder usar um editor de textos básico como o bloco
de notas do Windows. Existem também editores mais especializados que além
de editar o XML validam o seu conteúdo.

Estrutura

Além dos elementos citados até aqui, um arquivo XML deve ser validado. Ou
seja, toda a sua estrutura deve estar correta quanto à abertura e fechamento das
TAGS. Também existem tipos de conteúdo que não são corretamente
processados tais como caracteres de marcação como “<, >, &”, neste caso
você deve usar os códigos HTML usados para estes símbolos para evitar erros
de validação do XML.

Também é possível verificar se o documento XML está conforme uma

estrutura previamente definida em um arquivo de schema. Isto é feito com
ferramentas externas e o framework possui classes que permitem este tipo de
tarefa.

Um documento XML típico possui os seguintes elementos:

1. Nós. Estes são representados pelas TAGS. Um documento pode ter um nó
único contendo algum tipo de dado, ou, vários nós aninhados, como foi visto
anteriormente;

2. Atributos. São elementos que são passados dentro (não entre) as TAGS para
armazenar valores adicionais, geralmente referentes à própria TAG. No nó
“pedido” do XML anterior, existe um atributo “id” passando o número do
pedido que está referenciado no documento.

Nota do DevMan

Na verdade, o framework .Net possui uma biblioteca completa para

manipulação dos documentos XML chamada “System.Xml”. Usando esta
biblioteca e outras ferramentas você pode criar, validar, ler, modificar
documentos XML. Isto tudo porque este tipo de documento é muito versátil
sendo possível criar aplicações completadas dependendo da forma como o
mesmo é estruturado. O objetivo deste artigo será apenas ler e escrever um
arquivo XML dando uma introdução ao assunto. Outras tarefas serão
oportunamente tratadas em outros artigos.

O framework .net e os documentos XML

O framework foi criado tendo em mente a manipulação destes documentos. A

grande maioria dos arquivos de configuração tanto do framework como dos
projetos e aplicações criadas nesta plataforma usa documentos XML
levemente modificados.

Na versão 3 do framework foi introduzida uma nova plataforma para

aplicações com interfaces ricas com o usuário baseada em uma linguagem de
marcação chamada de “XAML” que nada mais é do que os documentos XML
modificados novamente (justificando o nome “eXtensible”). Esta plataforma é
conhecida como "Windows Presentation Foundation" (WPF).

Para permitir um uso tão extenso do XML foi necessário criar uma biblioteca
específica para trabalhar com estes tipos de arquivo. Dentro da biblioteca
“System.Xml” existe um número enorme de classes usadas para criar,
gerenciar e ler documentos deste tipo. Existem classes que permitem ler o
conteúdo sem conhecer a estrutura. Outras, para formatar o documento ao
realizar a escrita no disco.

Também é possível realizar a validação da estrutura confrontando o seu

conteúdo com um arquivo de schema (que possui a extensão “XSD”). Para
simplificar, vou demonstrar algumas das classes que faremos uso no projeto e
a primeira, é a classe que carrega os dados de um arquivo gravado no disco
chamada “XmlDocument”. Esta classe cria um documento XML e permite
que se carregue o seu conteúdo do disco, ou de uma string previamente
informada. Veja seu uso básico:

// declara um documento
XmlDocument xmlDoc = new XmlDocument();
// carrega o documento do disco
xmlDoc.Load(@"d:\teste.xml");

Opcionalmente, como foi dito, pode-se carregar um XML a partir de uma

string, entretanto esta deve conter um documento válido para não gerar erros
na aplicação:

// declara um documento
XmlDocument xmlDoc = new XmlDocument();
// cria uma string contendo um xml
string sConteudo = @"
<disco id='1'>
<titulo>Money for nothing</titulo>
<artista>Dire Straits</artista>
</disco>";
// carrega o documento da string
xmlDoc.LoadXml(sConteudo);

Por outro lado, você pode gravar os dados no disco após criar o conteúdo.
Alterando o código anterior, você pode gravar o conteúdo no disco:

// declara um documento
XmlDocument xmlDoc = new XmlDocument();
// cria uma string contendo um xml
string sConteudo = @"
<disco id='1'>
<titulo>Money for nothing</titulo>
<artista>Dire Straits</artista>
</disco>";
// carrega o documento da string
xmlDoc.LoadXml(sConteudo);
// grava o conteúdo do xml no disco
xmlDoc.Save(@"d:\disco.xml");

Os documentos XML permitem o encadeamento em vários níveis. Para isto,

você deve usar a classe “XmlNode” e ir acrescentando os nós um ao outro se
necessário. Se fosse refazer o exemplo anterior de uma maneira mais
estruturada, o código ficaria igual ao da Listagem 3.
Listagem 3. Principais elementos para a criação de um documento XML

1 // declara um documento
2 XmlDocument xmlDoc = new XmlDocument();
3 // declara e cria o nó raiz
4 XmlNode noPrincipal = xmlDoc.CreateNode(XmlNodeType.Element,
"disco", "");
5 // cria um elemento atributo
6 XmlAttribute xmlAtr = xmlDoc.CreateAttribute("id");
7 // seta o valor do atributo
8 xmlAtr.Value = "1";
9 // adiciona o atributo ao no principal
10 noPrincipal.Attributes.Append(xmlAtr);
11 // cria um nó secundário
12 XmlNode noSecundario = xmlDoc.CreateNode(XmlNodeType.Element,
"titulo", "");
13 // configura o valor
14 noSecundario.InnerText = "Money for Nothing";
15 // adiciona o no secundário para o principal
16 noPrincipal.AppendChild(noSecundario);
17 // cria outro nó
18 noSecundario = xmlDoc.CreateNode(XmlNodeType.Element,
"artista", "");
19 // configura o valor
20 noSecundario.InnerText = "Dire Straits";
21 // adiciona ao nó principal
22 noPrincipal.AppendChild(noSecundario);
23 // adiciona o nó principal ao documento
24 xmlDoc.AppendChild(noPrincipal);
25 // grava o texto
26 xmlDoc.Save(@"d:\disco1.xml");

A linha 2 declara e instancia o novo documento. Em seguida é criado um nó

com “XmlNode” para o qual passamos o tipo do elemento que deve ser criado
e também o nome a ser usado na TAG. Este elemento recém-criado deve
possuir um atributo, que é criado na linha 6 e configurado na linha 8. Em
seguida, este deve ser adicionado ao nó ao qual faz parte. Da linha 12 até 22 o
código alterna entre criar um nó secundário, configurar o seu valor e adicionar
ao nó principal do documento. Por fim, na linha 24 o nó principal é
adicionado ao documento e este é gravado no disco.
Nota do DevMan

Existem outras formas de escrever o documento XML usando as classes

“XmlWriter” e “XmlReader” para leitura. Estes permitem um controle bem
mais refinado do arquivo gerado removendo espaços em branco, recuos de
espaço e quebras de linhas desnecessárias. Certamente, você precisará
conhecer estas classes para executar trabalhos mais elaborados.

A grande dificuldade do aprendizado da manipulação dos documentos XML é

saber quando usar um elemento e quando usar outro. Você deve considerar os
seguintes pontos quando estiver trabalhando com estes tipos de documento:

1. A estrutura do documento é conhecida ou não? Se sim, torna-se mais fácil

pois você pode usar o nome dos atributos e TAGS na manipulação;

2. Ao ler os dados do documento eles serão apenas exibidos ou deverão

preencher controles visuais ou classes;

3. Existe a necessidade ou não de validar o documento com o schema,

principalmente ao gravar um documento;

4. O arquivo precisa ser enviado pela rede ou pela Internet.

A melhor forma de aprender é fazer uma aplicação usando este tipo de

documento, siga o exemplo dado e procure entender como foram usados os
recursos do framework.

Aplicação de exemplo

O projeto que será executado terá duas funcionalidades: a criação de um

arquivo XML simples e a leitura e exibição do conteúdo de arquivos deste
tipo em um controle do tipo “TreeView”.

Na Figura 2 está demonstrada a funcionalidade de criação de um arquivo

XML. De forma bem simples o programa irá permitir que se digite o nome da
TAG a ser criada na coluna apropriada e o seu conteúdo na coluna seguinte.
Ao clicar no botão para gravar, o programa deverá validar se os dados
digitados podem ser armazenados em um arquivo XML validando se não
existem TAGS duplicadas e também substituindo espaços em branco dos
nomes da TAG pelo caractere de “underline” (“_”).
Figura 2. Tela de exemplo da aplicação - Criando um documento XML

A aba “Visualizar” deverá mostrar o documento XML hierarquicamente, ou

seja, permitindo que se “navegue” pelos nós do documento. Para isso será
usado um controle “TreeView” do framework .net. Este controle é o mesmo
que é usado pelo programa Windows Explorer para mostrar as pastas do disco
rígido. A Figura 3demonstra um exemplo da tela do programa em
funcionamento.
Figura 3. Visualizando um documento XML hierarquicamente

Criando o projeto

No Visual Studio 2010, crie um novo projeto do tipo “Windows Forms”

usando a linguagem C# e a versão 4 do framework .net através do menu “File
>> New >> Project”. A Figura 4 mostra detalhes para a criação do projeto.
Figura 4. Criando um novo projeto

Classe que cria o XML

Teremos classes separadas para escrever o arquivo e para fazer a leitura.

Adicione uma classe chamada “CriaXml” ao projeto através da janela
“Solution Explorer”. Faça isso clicando com o botão direito do mouse sobre o
ícone do projeto e escolhendo as opções “Add >> Class”. A Listagem
4 mostra o cabeçalho da classe que deve conter referência para algumas
bibliotecas do framework que não são incluídas por padrão.

Listagem 4. Cabeçalho da classe

1 using System;
2 using System.Collections.Generic;
3 using System.Xml;
4
5 namespace Easy8XML
6 {
7 // classe que gera xml
8 public class CriaXml
...

Note no cabeçalho da classe as bibliotecas que devem ser importadas para o

correto funcionamento da classe. Na linha 1, a biblioteca “System” é
necessária para o tratamento de exceções, uma vez que é esta biblioteca que
possui a classe “Exception” que é responsável por manipular exceções
genéricas do framework. A biblioteca “System.Collections.Generic” contém
classes para manipulações de coleções de dados como “Dictionary” que é
usada nesta classe. Por fim, para manipulação dos documentos XML fazemos
uma referência à biblioteca “System.Xml” na linha 3.

A classe irá possuir um método público chamado “CriarXml”. Como a classe

não armazena nenhum dado, este método pode ser do tipo “static”,
dispensando uma instância de objeto para ser chamado. A Listagem
5 descreve o método.

O método recebe os seguintes parâmetros de entrada (a assinatura do método

está na linha 11):

1. Nome do arquivo que será usado para gravar o conteúdo XML,

representado pelo parâmetro “arquivo”;

2. Um "array" de duas dimensões que contém o nome da TAG que será gerada
e o seu conteúdo representado pelo parâmetro ”dados”;

3. Um parâmetro de saída (out) para armazenar mensagens de erro;

4. E por fim um parâmetro opcional (disponível apenas a partir da versão 4 da

linguagem C#) que determina qual será o nó raiz do documento, caso nenhum
seja informado, este assumirá o valor “xml” por padrão.

Os parâmetros de saída devem ser obrigatoriamente inicializados e isso é feito

na linha 14. Na linha seguinte, um objeto do tipo “Dictionary” recebe os
dados que serão enviados para o arquivo XML. Estes dados foram recebidos
como um parâmetro do método e são processados através do outro método
chamado “CriarConteudo”. Este por sua vez valida os nomes das TAGS que
foram digitadas. Um arquivo XML como o que estamos criando, com apenas
um nível, não deve ter elementos duplicados e é isso que o método faz.

Nota do DevMan

A classe “Dictionary” faz parte da biblioteca “System.Collections.Generic”.

Uma das vantagens no uso desta classe está nos métodos que a mesma possui
para pesquisa dentro do seu conteúdo e também na capacidade de se usar um
conjunto “chave/valor” para acessar os elementos da lista. Esta classe foi
exposta em um artigo anterior da revista. Se possível, dê uma olhada neste
artigo para conhecer um pouco mais sobre este recurso.

Na linha 18 é feita a verificação do resultado da operação anterior. Caso o

objeto retornado esteja nulo, isto indica que houve algum problema e o
método não prossegue na execução. A linha 23 inicializa um objeto do tipo
“XmlDocument” que faz parte da biblioteca “System.Xml”. Este objeto é
inicializado com o resultado de outro método “RetornarXml” que cria os
elementos do documento. Novamente, na linha 25 é feito um teste para
verificar se o objeto retornado está nulo. Por fim, o bloco das linha 30 até 40
cria o arquivo no disco e faz tratamento de erros.

Você percebeu que para gerar um arquivo XML foram necessários outros
métodos além do que foi explicado. Você poderia ter feito o trabalho com um
único método, mas teria um código mais extenso. Por outro lado, é uma boa
prática procurar dividir as tarefas específicas em métodos separados. Isto
aumenta a reusabilidade do seu código.

Listagem 5. Método que salva o arquivo

10 // gera um xml a partir de um array de string

11 public static bool CriarXml(string arquivo, string[,]
dados, out string erro, string raiz = "xml")
12 {
13 // variável para armazenar erros
14 erro = string.Empty;
15 // faz a normalização dos dados
16 Dictionary<string, string> conteudo =
CriarConteudo(dados, out erro);
17
18 if (conteudo == null)
19 {
20 return false;
21 }
22 // formata o documento
23 XmlDocument xml = RetornarXml(conteudo, out erro);
24
25 if (xml == null)
26 {
27 return false;
28 }
29
30 try
31 {
32 // grava no disco
33 xml.Save(arquivo);
34 return true;
35 }
36 catch (Exception ex)
 37 {
38 // armazena eventuais mensagens de erro
39 erro = string.Format("Não foi possível gravar o
arquivo. {0}", ex.Message);
40 }
41
42 return false;
43 }

Na Listagem 6 está demonstrado o método que cria o “Dictionary” que

contém as chaves e valores a serem enviados para o documento. Este método
se inicia recebendo a lista de dados que foi criada anteriormente e também,
como já é de costume, uma variável para armazenar eventuais mensagens de
erro e que é inicializada na linha 87.

A linha 89 cria uma instância da classe “Dictionary” para receber o conjunto

de TAGS e valores que serão usados. Os dois elementos são do tipo “string”
sendo que o primeiro receberá o nome da TAG e o segundo, o valor a ser
armazenado.

Na linha 92 inicia-se o loop para percorrer os elementos da lista de dados que

foi passada. Esta lista de dados consiste de um "array" de duas dimensões,
logo para poder verificar a quantidade de linhas e passar como condição para
o loop, é necessário usar o método “GetLength”. Este método retorna a
quantidade de elementos numa determinada dimensão do "array". A linha 95
faz uma verificação dentro do “Dictionary” quanto à existência da chave.

Esta verificação substitui os caracteres de espaço que possam ter sido

passados para a chave pelo caractere “underline” (_). Isto é necessário pois
não é permitido TAG XML com espaços em branco, por isso o uso da função
“Replace”.

A linha 97 preenche uma mensagem informando da chave duplicada e a linha

seguinte encerra o método. Na linha 100, caso a chave seja válida, o código
insere a chave dentro do “Dictionary” fazendo a substituição dos espaços em
branco. Por fim, o resultado do método, ou seja, a lista de chaves/valores é
retornada na linha 107.

Listagem 6. Método que retorna o conteúdo preparado

82 // Monta os dados a serem gerados. Verifica se existem

chaves duplicadas.
83 private static Dictionary<string, string>
CriarConteudo(string[,] dados,
84 out string erro)
 85 {
86 // armazena mensagens de erro
87 erro = string.Empty;
88 // objeto que normaliza os dados
89 Dictionary<string, string> retorno = new
Dictionary<string, string>();
90
91 // percorre a lista de dados
92 for (int i = 0; i < dados.GetLength(0); i++)
93 {
94 // verifica se a chave é única
95 if (retorno.ContainsKey(dados[i, 0].Replace(' ',
'_')))
96 {
97 erro = string.Format("A chave <{0}> está
duplicada.", dados[i, 0]);
98 return null;
99 }
100 else
101 {
102 // envia para o dictionary
103 retorno.Add(dados[i, 0].Replace(' ', '_'), dados[i,
1]);
104 }
105 }
106
107 return retorno;
108 }

Como foi explicado na introdução do artigo, um documento XML é composto

de vários nós. O método que cria e formata o documento está expresso
na Listagem 7. O método recebe o “Dictionary” que contém os elementos
para gerar o arquivo junto com uma variável para mensagens de erro como
parâmetros.

Na linha 50 é instanciado o documento XMLe na linha 51 configuramos um

atributo para eliminar espaços em branco adicionais. A geração do conteúdo é
feita dentro de um bloco “try...catch” que inicia-se na linha 54.

O primeiro elemento do documento a ser criado é um nó raiz que irá receber

os outros elementos do documento (linha 57). Em seguida é declarado outro
nó para os elementos secundários. Este objeto receberá os demais elementos
do documento.
O laço “foreach” na linha 61 percorre todas as chaves do objeto “Dictionary”
através da verificação da propriedade “Keys”. Esta técnica permite que se use
as próprias chaves do “Dictionary” como indexador.

Na linha 64 o nó XML recebe um novo valor através do método

“CreateNode”. Usamos o objeto do tipo “XmlDocument” instanciado no
método para criar um objeto do tipo “XmlNode”. Na criação, declaramos que
este nó será do tipo “Element” e passamos o nome da TAG a ser criada
através da variável “keys”. Em seguida, na linha 66, armazenamos o texto
correspondente à TAG criada. Por fim, adicionamos este nó ao objeto
“noRaiz” para vincular com o documento. O último passo a ser dado é
vincular o “noRaiz” com o documento “ret” (linha 71) e fazer o retorno deste
objeto.

Nota do DevMan

Basicamente, a criação de um documento XML envolve cuidar da hierarquia

dos nós do documento já que estes podem estar aninhados. Se você precisar
criar documentos com múltiplos níveis, terá de criar métodos recursivos para
melhorar o desempenho e tomar cuidado com os níveis. Este tipo de trabalho
é bastante complexo e deve-se tomar cuidado ao elaborar o código.

Listagem 7. Método que formata o XML

44 // Formata o documento xml com o conteúdo informado

45 private static XmlDocument RetornarXml(Dictionary<string,
string> conteudo, out string erro, string raiz = "xml")
46 {
47 // recebe mensagens de erro
48 erro = string.Empty;
49 // objeto que faz a formatação
50 XmlDocument ret = new XmlDocument();
51 // comando para não quebrar linhas
52 ret.PreserveWhitespace = false;
53
54 try
55 {
56 // cria o elemento principal
57 XmlNode noRaiz = ret.CreateNode(XmlNodeType.Element,
raiz, "");
58 // prepara elementos secundários
59 XmlNode elemento;
60 // percorre o dicionário de dados
61 foreach (string keys in conteudo.Keys)
 62 {
63 // cria o elemento
64 elemento = ret.CreateNode(XmlNodeType.Element, keys,
"");
65 // adiciona o valor
66 elemento.InnerText = conteudo[keys];
67 // adiciona ao documento xml
68 noRaiz.AppendChild(elemento);
69 }
70 // finaliza a criação do xml
71 ret.AppendChild(noRaiz);
72 return ret;
73 }
74 catch (Exception ex)
75 {
76 // captura erros que ocorrerem
77 erro = string.Format("Não foi possível criar o xml.
{0}", ex.Message);
78 }
79
80 return null;
81 }

Classe que lê o documento

Para recuperar os dados do arquivo XML elaborei um exemplo que percorre

todos os nós e retorna sua estrutura para ser usada em um controle do tipo
“TreeView”. Este controle é interessante porque permite a navegação pela
hierarquia do documento inspecionando os elementos aninhados. Como regra,
o último elemento dentro da árvore será sempre o conteúdo da TAG.

Adicione uma classe ao projeto nomeada como “LerXML”. A Listagem

8 mostra as bibliotecas que devem ser adicionadas na classe através da
instrução “using“.Estes elementos são necessários para poder instanciar
diretamente as classes que serão usadas.

Listagem 8. Cabeçalho da classe

1 using System.Text;
2 using System.Windows.Forms;
3 using System.Xml;
4
5 namespace Easy8XML
6 {
7 public class LerXml
8 {
9
...

Como o método principal desta classe irá retornar uma lista de nós que será
usado no controle “TreeView” que faz parte da biblioteca
“System.Windows.Forms”, precisamos declarar esta na classe, ainda que não
possua nenhum componente visual.

A classe possuirá apenas um método externo chamado “RetornarArvore” que

vai receber o nome do arquivo para leitura. Este método será estático (static),
pois como nenhum dado será armazenado na classe, não é necessário criar
uma instancia da mesma. A Listagem 9 mostra o método.

O método é relativamente simples pois apenas lê o arquivo XML (linha 13 e

15). O principal problema a ser resolvido é percorrer todos os nós do
documento XML. Lembre-se de que um elemento XML pode conter um texto,
atributos ou mais elementos XML e assim por diante. Isto é o que torna
complexa a leitura do documento.

Primeiramente, devemos obter uma lista com todos os nós do documento. Na

linha 17 isto é feito com uma instância de “XmlNodeList”. Na linha 19,
criamos o principal elemento para retorno do método, este do tipo “TreeNode”
que é a classe que compõe o controle “TreeView”. Este primeiro componente
leva o nome do arquivo que foi passado. O loop da linha 22 percorre cada nó
do documento que foi carregado e faz a primeira chamada para o método
“PreencherNos”.

Listagem 9. Método principal

9 // retornar os nós xml

10 public static TreeNode RetornarArvore(string arquivo)
11 {
12 // componente que lê o arquivo xml
13 XmlDocument xml = new XmlDocument();
14 // carrega o arquivo xml
15 xml.Load(arquivo);
16 // lê todos os nos existentes
17 XmlNodeList nosXml = xml.ChildNodes;
18 // componente TreeNode para ser retornado
19 TreeNode noPrincipal = new TreeNode(arquivo);
20
21 // percorre os elementos do XML
22 foreach (XmlNode xmn in nosXml)
 23 {
24 PreencherNos(xmn, ref noPrincipal);
25 }
26
27 return noPrincipal;
28 }

Veja a Listagem 10 e acompanhe a explicação. Preste atenção pois trata-se de

um método recursivo. Examinando a listagem teremos na linha 34 a
verificação do nó ser o último elemento dentro da lista de nós XML. Se for,
adicionamos o seu texto para o controle acessando a propriedade “InnerText”.
Caso contrário, o elemento possui filhos. Na linha 41, criamos um
“TreeNode” que será uma ramificação adicional. É nesta linha que se lê qual é
a TAG XML. Por isso, ao criar o nó, precisamos verificar também se a TAG
possui algum atributo. É preciso ler estes atributos, para isso, foi usado um
método chamado “RetornarAtributos” já que, podem existir vários destes na
TAG. O método percorre e retorna todos os atributos já formatados.
A Listagem 11 abaixo descreve o método.

Na linha 43, obtemos a lista de nós XML dentro do elemento atual. Na linha
45 percorremos os nós que foram encontrados fazendo a chamada recursiva
para o método e por fim, adicionamos o controle “TreeNode” ao elemento
inicial, passado para o método.

Listagem 10. Método que percorre o XML

30 // Faz o preenchimento dos dados

31 private static void PreencherNos(XmlNode noXml, ref
TreeNode noPai)
32 {
33 // verifica se chegou no elemento final
34 if (noXml.NodeType == XmlNodeType.Text)
35 {
36 noPai.Nodes.Add(noXml.InnerText);
37 }
38 else
39 {
40 // cria um sub nó
41 TreeNode noFilho = new
TreeNode(string.Format("<{0}{1}>", noXml.Name,
RetornarAtributos(noXml)));
42 // obtem os nós filhos do xml atual
43 XmlNodeList xmlNodeList = noXml.ChildNodes;
44
 45 foreach (XmlNode xmn in xmlNodeList)
46 {
47 PreencherNos(xmn, ref noFilho);
48 }
49
50 noPai.Nodes.Add(noFilho);
51 }
52 }

Nota do DevMan

Métodos recursivos são extensamente utilizados na programação. Eles

permitem fazer chamadas a si mesmo em cadeia sempre que necessário. O
principal ponto de um método deste tipo é saber o seu “ponto de parada” ou
seja, quando ele deixa de chamar a si mesmo e retorna algum valor de fato.
No método visto foi usada a seguinte lógica: se o elemento passado através
do nó XML for elemento final contendo já um valor, nenhuma chamada
recursiva é feita e o seu valor é armazenado. Caso contrário, ou seja, existam
outros elementos abaixo do atual, deve-se:

- Criar um nó filho para ser inserido no nó atual.

- Obter a lista de nós XML que estão contidos no nó atual.

- Percorrer cada um destes nós e enviar o nó XML e o nó do controle

“TreeView” fazendo uma chamada recursiva na função.

- Ao sair do loop, deve-se adicionar o nó filho do controle “TreeView” para o

nó pai.

Listagem 11. Método de leitura dos atributos

54 // retorna uma string formatada

55 // contendo os atributos de um nó
56 private static string RetornarAtributos(XmlNode noXml)
57 {
58 // componente que formata a string
59 StringBuilder sbRet = new StringBuilder();
60 // obtém a coleção de atributos do nó
61 XmlAttributeCollection listaAtributos =
noXml.Attributes;
62
63 if (listaAtributos != null)
64 {
65 foreach (XmlAttribute atributo in listaAtributos)
 66 {
67 sbRet.AppendFormat(" {0}={1}", atributo.Name,
atributo.Value);
68 }
69 }
70
71 return sbRet.ToString();
72 }

O método “RetornarAtributos” recebe um “XmlNode”, verifica se existem

atributos e os formata. Na linha 59 é criada uma instância da classe para
composição de texto “StringBuilder”. Este foi usado porque permite a criação
de "strings" complexas e também permite fazer sua formatação enquanto vai
sendo criada.

A linha 61 cria um objeto para verificar os atributos da TAG XML. Se houver

conteúdo (linha 63), um loop percorre cada elemento, adicionando o nome e o
valor para o objeto “StringBuilder” (linha 67).

Definindo a interface

Com as classes que fazem o trabalho definidas, chegou a hora de cuidar da

interface. Primeiramente, renomeie o formulário criado por padrão pelo
Visual Studio para um nome mais significativo como “frmPrincipal”. Faça
isso clicando no seu ícone, na janela “Solution Explorer” e pressionando a
tecla F2. Em seguida, pelo editor de propriedades, altere as propriedades
conforme a Tabela 1.

Propriedade Valor
(Name) frmPrincipal
Size 640; 480
Text Demonstração XML

Tabela 1. Formulário principal

No formulário adicione um controle do tipo “TabControl” e ajuste as

propriedades conforme a Tabela 2. Ao ajustar a propriedade “Dock” como
“Fill” o controle ocupa toda a área do formulário e quando este é
redimensionado, o controle se ajusta automaticamente.

Propriedade Valor
Dock Fill
Tabela 2. Propriedades do controle TabControl

Criando o XML

A primeira página do formulário será usada para criar um documento XML

através do conteúdo que for digitado em um controle “DataGrid”. Adicione os
controles e configure suas propriedades conforme a Tabela 3.

Controle Propriedade Valor

TabPage Text Criar
Documento
ToolStrip (Name) toolStrip1
TextBox BackColor Control
Dock Top
Multiline True
ReadOnly True
Text Use o botão
"Novo" para
criar um novo
documento.
Clique em
"Gravar" para
salvar o
documento.
Digite o nome
do campo na
coluna "TAG" e
o conteúdo na
coluna "Texto".
DataGridView (Name) dgXML
AutoSizeColumnsMode Fill
BorderStyle Fixed3D
Dock Fill
SaveFileDialog Filter Arquivos XML
(*.xml) | *.xml
Title Gravar arquivo
XML

Tabela 3. Propriedades e controles do TabPage1 (Criação do documento

XML)
Configure as colunas do controle “DataGridView” editando a propriedade
“Columns” conforme a Tabela 4 demonstra.

Nome (Name) Texto do cabeçalho

(HeaderText)
TAG TAG
Texto Texto

Tabela 4. Colunas do controle DataGrid

Compare o seu design com a Figura 5. Note que foram deixados apenas dois
botões no controle “ToolStrip”.

Figura 5. Design da aba de criação do documento

Se você ainda não sabe como inserir os botões padrão no controle “ToolStrip”
basta clicar sobre ele com o botão direito do mouse e escolher a opção “Insert
Standard Items” conforme demonstrado na Figura 6.
Figura 6. Inserindo componentes padrão do controle ToolStrip

A página que faz a criação do XML deve permitir a digitação do conteúdo e

enviar para o arquivo XML fazendo alguns tratamentos. Um dos aspectos
importantes ao se trabalhar com o controle “DataGridView” é que quando se
digita nas suas células, caso o usuário não pressione a tecla ENTER ao
finalizar, o conteúdo da mesma não é armazenado para o controle.

Para evitar isto, que pode causar erros de referência a valores nulos, você deve
tratar o evento “CurrentCellDirtyStateChanged” do controle. Dê um duplo
clique no inspetor de eventos do controle “DataGridView” conforme
demonstrado na Figura 7. A Listagem 12 mostra o código necessário.

Figura 7. Editando evento do controle DataGridView

Listagem 12. Evento de edição de célula do controle DataGridView

63 // Valida dados quando digitados na célula da DataGrid

64 private void dgXML_CurrentCellDirtyStateChanged(object
sender, EventArgs e)
65 {
66 if (dgXML.IsCurrentCellDirty)
67 {
68
dgXML.CommitEdit(DataGridViewDataErrorContexts.Commit);
69 }
70 }
Sempre que estiver usando valores editados em um “DataGridView”, este
código deve ser escrito. A linha 66 verifica se é necessário fazer uma
atualização dos dados que foram digitados e, caso seja, a linha 68 realiza isto
com o “CommitEdit”.

Feito este tratamento, podemos escrever o código que chama a classe para
fazer a gravação do documento XML. Dê um clique duplo no botão gravar e
escreva o código da Listagem 13.

A primeira coisa a verificar é se existem linhas no controle “DataGridView”

(linha 17). Caso não haja, o método mostra uma mensagem para o usuário e
sai da rotina. A seguir, a janela padrão para gravar arquivos do Windows é
mostrada através do método “ShowDialog” do controle “saveFileDialog”.

Se um arquivo válido for passado, na linha 31 é criado um “array” de duas

dimensões que recebe os dados digitados pelo usuário no controle
“DataGridView”. Isto é feito chamando uma função “CriarListaDeDados”.
Esta função será descrita adiante.

A linha 33 cria uma variável para armazenar mensagens de erro e na linha 35

é feita a chamada para o método da classe que grava o arquivo, mostrando a
mensagem de sucesso ou de erro, se houver.

Listagem 13. Código que grava os dados no arquivo XML

13 // evento do botão que grava o arquivo xml

14 private void saveToolStripButton_Click(object sender,
EventArgs e)
15 {
16 // verifica se existe conteúdo na DataGrid
17 if (dgXML.Rows.Count == 0)
18 {
19 MessageBox.Show("Nenhum conteúdo para gravar.");
20 return;
21 }
22 // mostra caixa de diálogo para gravar
23 saveFileDialog1.ShowDialog();
24
25 if (string.IsNullOrEmpty(saveFileDialog1.FileName))
26 {
27 return;
28 }
29
30 // prepara lista para enviar dados
 31 string[,] lista = CriarListaDeDados();
32 // variável que receberá mensagens de erro
33 string erro = string.Empty;
34
35 if (CriaXml.CriarXml(saveFileDialog1.FileName, lista,
out erro, "raiz"))
36 {
37 MessageBox.Show("Arquivo criado com sucesso");
38 }
39 else
40 {
41 MessageBox.Show(erro);
42 }
43 }

O método “CriarListaDeDados” (Listagem 14) percorre cada uma das linhas

da grade. Faz uma verificação na linha 53 para evitar que valores nulos sejam
enviados e armazena os valores válidos na linha 55 e 56. Com isto feito, a
tarefa de gravar o arquivo usando a interface Windows é concluída.

Listagem 14. Método que prepara a lista de dados

45 // transforma dados digitados no DataGrid

46 private string[,] CriarListaDeDados()
47 {
48 string[,] lista = new string[dgXML.Rows.Count - 1, 2];
49
50 for (int i = 0; i < dgXML.Rows.Count - 1; i++)
51 {
52 // verifica se existem dados
53 if (dgXML[0, i].Value != null && dgXML[1, i].Value !=
null)
54 {
55 lista[i, 0] = dgXML[0, i].Value.ToString();
56 lista[i, 1] = dgXML[1, i].Value.ToString();
57 }
58 }
59
60 return lista;
61 }

Resta permitir que um documento novo seja criado. Dê um duplo clique no

botão novo e escreva o código da Listagem 15. Este código pede uma
confirmação ao usuário para a operação (linha 92) e simplesmente, limpa o
conteúdo da grade na linha 94 e restabelece o foco na mesma, na linha
seguinte.

Listagem 15. Criando um documento novo

89 // limpa os dados digitados no DataGrid

90 private void newToolStripButton_Click(object sender, EventArgs e)
91 {
92 if (MessageBox.Show("Deseja limpar os dados e iniciar novo
documento?", "Confirmação", MessageBoxButtons.YesNo) ==
System.Windows.Forms.DialogResult.Yes)
93 {
94 dgXML.Rows.Clear();
95 dgXML.Focus();
96 }
97 }

Lendo o XML

Na página seguinte do programa disponibilizamos a visualização do

documento XML através de um controle “TreeView” que é o mesmo que é
usado pelo programa Windows Explorer. Seleciona o “TabPage2” e adicione
os controle e configure, conforme a Tabela 5.

Controle Propriedade Valor

TabPage Text Visualizar
ToolStrip (Name) toolStrip2
TextBox BackColor Control
Dock Top
Multiline True
ReadOnly True
Text Este painel mostra
um documento
XML com seus nós.
Clique no botão
"Abrir" para
carregar um
documento.
TreeView (Name) treeView1
Dock Fill
OpenFileDialog Filter Arquivos XML
(*.xml) | *.xml
Title Abrir arquivo XML

Tabela 5. Propriedades e controles do componente TabPage para leitura do

XML

Novamente, no controle “ToolStrip”, adicione os botões padrão conforme no

exemplo anterior e deixe apenas o botão “Open/Abrir”, excluindo os demais.
Use a Figura 8 para conferir o layout dos controles.

Figura 8. Design da aba de visualização do XML

Uma vez que o trabalho principal de leitura do XML foi feito em uma classe
em separado, resta ao formulário apenas popular o controle com o resultado
deste trabalho. Dê um duplo clique sobre o botão “Abrir” e insira o código
da Listagem 16.

A linha 75 mostra uma janela padrão do Windows para abertura de arquivos.

Esta janela foi configurada através do controle “openFileDialog1”. Caso um
nome de arquivo válido tenha sido informado (o controle faz as devidas
validações), primeiramente o código remove qualquer conteúdo anterior do
controle “TreeView” na linha 83.

Em seguida, o controle é preenchido com o resultado do método

“RetornarArvore”. Por fim, para que todo o conteúdo seja visualizado, usamos
o método “ExpandAll”, isto fará com que todos os itens sejam expandidos.
Execute o seu projeto e verifique se o resultado está correto.

Listagem 16. Abrindo o arquivo XML para leitura

71 // abre o arquivo XML e carrega para visualização

72 private void openToolStripButton_Click(object sender,
EventArgs e)
73 {
74 // mostra a janela de diálogo para abrir
75 openFileDialog1.ShowDialog();
76 // testa se foi passado algum arquivo
77 if (string.IsNullOrEmpty(openFileDialog1.FileName))
78 {
79 return;
80 }
81
82 // limpa o conteúdo
83 treeView1.Nodes.Clear();
84 // recebe os dados
85 treeView1.Nodes.Add(
LerXml.RetornarArvore(openFileDialog1.FileName));
86 // marca para expandir todos os nós
87 treeView1.ExpandAll();
88 }

Conclusão

Documentos XML são extremamente flexíveis e consequentemente difíceis

para se lidar. Só que havendo uma delimitação bem clara das tarefas que serão
executadas o trabalho torna-se menos árduo. Por sua vez, o framework .net é
preparado para trabalhar com este tipo de documentos oferecendo vários
recursos distribuídos dentro da biblioteca “System.Xml”.

Ainda é possível executar muitas outras tarefas tais como, serializar classes
inteiras no formato XML, persistir uma tabela de dados carregada na memória
com um único comando e mais interessante ainda, usar a novíssima linguagem
de consultas LINQ para trabalhar com estes documentos. Estes temas poderão
ser abordados em próximos artigos. Aguardo ansiosamente o feedback pois
este assunto é muito vasto e interessante. Como sugestão, ficam os links para
você poder se aprofundar.

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 XML

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

Outro tutorial sobre XML

http://www.learn-xml-tutorial.com/

Documentação On Line da Microsoft

http://msdn.microsoft.com/en-us/library/system.xml%28VS.71%29.aspx

Expression Web – Edição e validação de arquivos XML

http://www.microsoft.com/expression/products/StudioWebPro_Overview.asp
x4

por Vladimir Rech

Guru .net e tecnologias MS

Visual Studio 2010

Este artigo é o segundo de uma série que
vai abordar as principais novidades
presentes no Visual Studio 2010. Nesta
segunda etapa, será visto o visualizador de
ajuda, object browser, gerações de código a
partir do uso, breakpoints, ferramentas de
arquitetura e code snippets.
Do que trata o artigo

Este artigo é o segundo de uma série que vai abordar as principais novidades
presentes no Visual Studio 2010. Nesta segunda etapa, será visto o
visualizador de ajuda, object browser, gerações de código a partir do uso,
breakpoints, ferramentas de arquitetura e code snippets.

Para que serve

Esta série de artigos serve como um excelente guia para aqueles que estão
iniciando o uso do Visual Studio 2010 e precisam de uma forma rápida e
prática aprender os principais recursos e novidades desta versão.

Em que situação o tema é útil

Os novos recursos serão úteis na utilização do Visual Studio para acelerar e

aperfeiçoar o desenvolvimento de aplicações, observando itens de código,
design, interface e planejamento. Permite familiarizar-se de maneira ágil e
direta nas funcionalidades relacionadas ao desenvolvimento ampliando o
conhecimento da ferramenta.

Resumo do DevMan

Neste artigo conheceremos os detalhes de utilização do menu de ajuda, com

ele é possível conhecer melhor praticamente todos os comandos, caso alguma
dúvida exista, é uma boa fonte de auxílio e aprendizado. Após será a vez do
object browser e sua utilização em projetos de desenvolvimento. A opção de
geração a partir do uso é interessante quando uma equipe de desenvolvimento
trabalha com programação por módulos, onde cada parte da equipe é
responsável por determinadas tarefas, permitindo até, a programação e
definição de testes ao mesmo tempo por equipes distintas. E, ao falar em
desenvolvimento, a parte de depuração de código utilizando breakpoints é
extremamente útil para analisar os problemas encontrados no decorrer do
projeto, facilitando e auxiliando na detecção e correção de erros. Além disso,
tratando-se de desenvolvimento, não poderia faltar a descrição de ferramentas
de arquitetura, relacionadas à análise e planejamento do software, composto
por diagramas de vários tipos, auxiliando, ainda mais, quem irá desenvolver
um sistema. Por fim, os code snippets contendo suas definições e
melhoramentos nesta versão 2010 do Visual Studio.
O visualizador foi remodelado para o Visual Studio 2010, a sua documentação
poderá ser acessada de maneira online ou offline usando um navegador web
de sua preferência, além disso, poderá ser executado o download da
documentação mais recente e a possibilidade de navegar através de um índice
ou por palavra-chave pesquisada. A utilização da tecla F1 está aprimorada
para pesquisar o conteúdo específico de um texto selecionado.

A sua base de funcionamento está centrada no Help Library Manager (HLM)

que permite pesquisar a documentação de forma a ser armazenada como
conteúdo local. Ao utilizar o HLM ele gerencia a documentação local
podendo realizar atualizações através da internet ou de algum tipo de mídia,
para isso, utiliza um serviço chamado BITS que realiza um acesso a internet
com o objetivo de baixar o conteúdo para uso offline. Para visualizar o HLM
utilize o menu Help e selecione a opção Manage Help Settings. A Figura
1 indica as opções presentes no HLM, podendo indicar se o help será
executado de forma online ou offline, além da instalação de novos conteúdos.

Figura 1. Opções do Help Library Manager

BITS Background Intelligent Transfer Service é um serviço que realiza

download de atualizações de conteúdo, ele verifica se um novo conteúdo
online está disponível e irá atualizá-lo de forma local.

Object Browser

Tem por finalidade auxiliar na pesquisa de palavras ou símbolos para

utilização em projetos. Com ele é possível realizar pesquisas em toda a
solução, por palavras utilizadas ou definidas ou realizar buscas de
documentação. Além disso, é permitido na opção Browse indicar o formato da
pesquisa (Figura 2), podendo ser informada a versão do .NET Framework,
todos os componentes ou ainda de forma customizada.
Figura 2. Object Browser, pesquisa, resultados, filtros e descrições

Na Figura 2 é possível definir uma palavra para pesquisa onde do lado

esquerdo são retornados os resultados e ao clicar em um item a sua descrição
será apresentada do lado direito, logo abaixo, maiores informações serão
demonstradas, caso existam. Outras configurações podem ser definidas
através das opções de Object Browser, conforme a indicação do menu,
definindo a visualização de tipos básicos, tipos derivados, membros públicos,
protegidos e outros.

Gerar a partir do uso

O recurso de gerar a partir de uso (generate from usage) possibilita utilizar

classes e membros mesmo antes de criar a sua definição. A geração poderá
ocorrer para novos tipos e membros sem abandonar o trecho de código que
está sendo inserido, minimizando interrupções de fluxo de trabalho. Além
disso, possibilita a definição de casos de testes, mesmo sem existir a definição
do que será testado, facilitando o desenvolvimento de uma equipe, visto que
nem sempre quem irá desenvolver será o responsável pelos testes. A Figura
3 demonstra a definição de testes sem existir no momento a classe que será
utilizada.
Figura 3. Criando testes, mesmo sem a definição da classe pessoa

Observe na Figura 3 que o Visual Studio 2010 permite realizar a definição de

pessoa utilizando a classe pessoa, mesmo sem conter a sua definição.
Na Figura 4 ocorre a definição, basta clicar com o botão direito do mouse e
indicar a opção Generate, neste caso, Class ou New Type.

Figura 4. Definindo a classe pessoa através de Generate from usage

Em C#, generate from usage poderá ser utilizado para as seguintes opções:
gerar propriedades, campos, métodos, classes e novos tipos. Os novos tipos
poderão ser definidos como classe, estrutura, interface ou enumeração.
A Figura 5 indica a geração de um novo tipo, onde em Access poderá ser
definido o tipo de acesso (Default, public, internal ou private), em Kind o seu
tipo (class, struct, interface ou enum), em project location o local onde será
salvo (no projeto atual ou em outro projeto da solução) e o file name
representa o nome do arquivo.

Figura 5. Definindo um novo tipo através de Generate from usage

Breakpoints

A depuração de código no Visual Studio 2010 está bastante aperfeiçoada, é

possível depurar o código adicionando um breakpoint em determinada linha,
dessa forma o aplicativo será executado em modo de depuração, o Visual
Studio saberá o que realizar nesta linha. Na Figura 6 é possível verificar um
breakpoint adicionado.
Figura 6. Adição de um breakpoint ao código fonte

O breakpoint adicionado foi destacado (representado pelo item

comboBox1.SelectedIndex == 1) para sempre mostrar o valor que estará
sendo reproduzido pela depuração de código, para destacá-lo basta passar o
mouse sobre a linha indicada de depuração e habilitar a opção.

Uma funcionalidade interessante no breakpoint é a possibilidade de utilizar

labels, que são nomes ou descrições que podem ser definidas para nomear um
breakpoint, a Figura 7 demonstra esta opção clicando-se com o botão direito
do mouse sobre um breakpoint é possível adicionar um nome.
Figura 7. A opção Edit labels permite adicionar um nome ao breakpoint

A definição de um nome para o breakpoint é interessante quando o aplicativo

a ser depurado possui muitas linhas de código e muitos breakpoints
adicionados, facilitando a sua ordenação e pesquisa por filtros utilizando a
opção Filter descrita no menu da Figura 7. Outra possibilidade é a definição
de uma condição para a parada em determinado breakpoint, esta opção pode
ser descrita por Condition, conforme o menu anterior, neste caso o breakpoint
somente será acionado se a condição informada for satisfeita. Além disso,
existe a opção de exportar para documento XML a lista de breakpoints
adicionados ao projeto, possibilitando, em um momento futuro, caso haja
necessidade de depuração, utilizar a importação desta lista para realizar novas
depurações no aplicativo.

Ferramentas de arquitetura

O Visual Studio 2010 apresenta ferramentas para auxiliar na arquitetura de um

projeto. Tais ferramentas estão dispostas no menu Architecture do Visual
Studio. Neste menu é possível criar novos diagramas utilizando Templates
pré-definidos, entre eles, diagramas de classe, sequência, casos de uso e
diagrama de camadas. A outra opção deste menu é a geração do gráfico de
dependências descrito na Figura 8, ela permite explorar de forma visual a
arquitetura do projeto em questão, facilitando a sua análise e entendimento.
Figura 8. Geração de um gráfico de dependências

Na Figura 8 o gráfico de dependências foi gerado utilizando a opção por

assembly, existindo, ainda, outras opções como por namespace, classes e
modo customizado. Uma das vantagens na geração do gráfico de
dependências é a sua forma visual de observação, onde um desenvolvedor ou
analista poderá verificar o que consta e quais os relacionamentos que existem
no projeto, mesmo depois dele estar desenvolvido, possibilitando entender o
seu funcionamento de forma mais ágil. Outra vantagem é a constatação
imediata de quais namespaces são utilizados, descritos na parte Externals.

No gráfico existe um número, no canto superior esquerdo de cada bloco, que

mostra o número de artefatos (Namespaces, Classes ou Métodos) que existem
dentro de cada bloco. Quando um bloco é selecionado, ele fica destacado com
uma cor diferenciada mostrando as linhas de dependência do bloco em
destaque. Também, possui a possibilidade de customização do formato de
visualização presentes na IDE do Visual Studio 2010. As linhas dos blocos
indicam a dependência entre eles, quanto mais larga for a linha maior será o
nível de dependência entre elas.

No Visual Studio 2010 está incluído o suporte à UML (Unified Modeling

Language) diretamente no IDE, possuindo o diagrama de classes, de
atividade, de sequência, de caso de uso e diagrama de componentes. Com isso,
é possível realizar a modelagem do sistema no início ou anteriormente ao
desenvolvimento do projeto. A Figura 9 indica um diagrama de caso de uso
composto por um ator e um caso de uso representando uma operação.

Figura 9. Definição de um diagrama de caso de uso

Na Figura 9 a janela Toolbox possibilita utilizar alguns controles como

atores, casos de uso, associações e dependências e sua representação visual é
indicada ao centro, ao arrastar algum controle. Neste exemplo, o ator pessoa
possui um caso de uso para “pagamento de um almoço / refeição”. Além
disso, com o botão direito do mouse é possível criar um work item, indicando
casos de testes, tarefas a serem realizadas e descrições do que deverá ser
definido no caso de uso.

Um work item possui as opções: bug (representa um problema no aplicativo),

shared steps (indicando algo compartilhado), task (a necessidade de realizar
alguma tarefa por alguém), test case (casos de teste), user story (anotações
para o desenvolvimento) e issue (é uma situação que poderá interromper o
desenvolvimento).

Já o diagrama de sequência poderá ser utilizado para reapresentar uma

sequência de processos, é possível gerar o diagrama após o desenvolvimento
do código fonte do aplicativo. Para isso a Figura 10 demonstra a opção de
menu ao clicar com o botão direito do mouse sobre um método representando
a possibilidade de geração do diagrama.
Figura 10. Definição de um diagrama de seqüência

Ao clicar na opção Generate Sequence Diagram, um diagrama de sequência

será criado podendo ser analisados o fluxo e tempo de execução de cada
método, proporcionando um melhor entendimento e iteratividade com o
código fonte já existente.

Outra opção interessante é o uso de diagramas de camada para visualizar o

código ou definir sua arquitetura lógica de desenvolvimento do sistema.
Possibilita organizar as classes, arquivos de código, projetos e outros tipos de
arquivos presentes na solução em camadas lógicas e utilizar suas
dependências e relacionamentos para objetivar o que será desenvolvido.

Code snippets

Um code snippet representa um fragmento de código utilizado no IntelliSense

que pode ser personalizado de várias formas e sua principal tarefa é acelerar o
desenvolvimento, poupando a digitação de códigos. Ele permite a inserção
rapidamente de códigos prontos pressionando-se determinadas sequências de
teclas que irão indicar estruturas prontas para construções de trechos de
códigos em um aplicativo.

Podem ser inseridos através de opção de menu, pressionando o botão direito

do mouse, e indicando o snippet desejado que irá representar determinada
funcionalidade, ao selecioná-lo o código será apresentado.
O Visual Studio 2010 apresenta uma melhoria feita nos code Snippets. Com
ele, é possível incluir no IDE templates de código para que possam se
reaproveitados em diferentes projetos, agilizando a codificação por parte do
desenvolvedor. No IDE, existem novas funcionalidades, como a possibilidade
de usar templates para códigos XML, HTML e JavaScript / JScript, inclusive
templates de código para as novas tecnologias da Microsoft como ASP.NET
MVC 2, MVC 3 e AJAX 4. A Figura 11acessada pelo menu Tools na opção
code snippets manager mostra o gerenciador de code snippets.

Figura 11. Gerenciador do code snippets

Na Figura 11 é possível adicionar, remover, ou ainda, realizar a importação

de um arquivo no formato code snippets. O botão add do code snippets
manager acrescenta um novo diretório inteiro à estrutura pré-definida. Este é
um bom modo de adicionar à coleção fragmentos novos armazenados em um
diretório em disco. A pasta a ser adicionada poderá conter alguns arquivos que
não são fragmentos de código, mas quando for observada no Snippet Manager
será visto somente subpastas e fragmentos de código. A seleção atual na
árvore (descrita por location na Figura 11) não afeta a localização onde a
nova pasta será adicionada; sempre será adicionada ao diretório raiz. O botão
Import acrescenta um ou mais fragmentos de código à estrutura de diretório
mostrada pelo snippet manager. Uma vez selecionados os fragmentos que
serão importados, poderão ser escolhidas as pastas onde adicionar os
fragmentos. A estrutura de diretório de fragmentos contém uma pasta
chamada My Code Snippets, onde poderão ser instalados snippets
personalizados ou obtidos de outros usuários. O botão Remove excluirá
apenas a pasta atualmente selecionada da estrutura de diretório mostrada pelo
code snippets manager. A pasta removida não será apagada do sistema de
arquivos, podendo ser utilizado o comando Add para recuperá-la. O Code
Snippets Manager representa os fragmentos que poderão ser inseridos no
editor de código fonte no momento de edição de código representados pelo
snippet inserter (acessando o menu com o botão direito do mouse), dessa
forma, ao remover uma pasta do gerenciador, ela não poderá ser acessada
como snippets de código.

Code Snippets presentes no Visual Studio 2010 possibilitam um aumento

significativo na produtividade e além disso, permitem realizar seu
aprimoramento e reutilização. Existem sites hospedeiros de Code Snippets
disponibilizando vários modelos para uso.

Conclusão

O Visual Studio 2010 é uma excelente ferramenta de desenvolvimento de

software, com ele é possível criar diversos tipos de projetos para diferentes
utilizações, sejam projetos voltados para internet ou utilização de interfaces ao
estilo de Windows Forms. No artigo foi possível visualizar as ferramentas
voltadas ao planejamento de um sistema, como diagramas de caso de uso,
definindo os atores e seus casos de usos, diagramas de sequência podendo
realizar uma engenharia reversa através do código fonte e a possibilidade de
criação de gráfico de dependências, visando auxiliar, de forma visual, o
entendimento de um projeto. Voltados à depuração de código de um
aplicativo, foi demonstrada a utilização de breakpoints, suas aplicações,
estruturas, utilização de labels e possibilidade de importação e exportação
para uso futuro em um aplicativo, caso precise. Relacionados ao
desenvolvimento a praticidade de gerar a partir do uso é bastante útil quando o
desenvolvimento é realizado por uma equipe, dessa forma, ninguém ficará
dependente de outra pessoa na espera de alguma funcionalidade ainda não
realizada. E as funcionalidades presentes no Help e object browser servem
para auxiliar em dúvidas na criação do projeto, assim, auxiliando e facilitando
a utilização do Visual Studio.

Links

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

Visual Studio 2010

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

Destaques do produto Visual Studio 2010

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

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

Generate from Usage

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

por Rodrigo Araujo

Guru .net e tecnologias MS

WebMatrix e ASP.NET
Razor
Neste artigo será apresentada a nova
ferramenta da Microsoft para construção de
aplicações web de pequeno e médio porte
para usuários iniciantes ou novos no
universo de aplicações para internet – o
WebMatrix. Como modelo de programação
de apoio, este artigo apresentará o
ASP.NET Razor.
Do que trata o artigo

Neste artigo será apresentada a nova ferramenta da Microsoft para construção

de aplicações web de pequeno e médio porte para usuários iniciantes ou novos
no universo de aplicações para internet – o WebMatrix. Como modelo de
programação de apoio, este artigo apresentará o ASP.NET Razor.

Para que serve

O WebMatrix é uma ferramenta que visa inovar a forma de construção de web

sites de pequeno e médio portes. Além disso, o WebMatrix pretende
enriquecer a experiência de desenvolvimento de aplicações web para usuários
iniciantes ou novos neste cenário.

Em que situação o tema é útil

WebMatrix é extremamente útil quando o assunto é o desenvolvimento de

soluções web pequenas e médias, proporcionando produtividade e uma rica
experiência para o desenvolvedor, já que um dos focos da ferramenta é a
usabilidade.

Resumo do DevMan

Há alguns meses a Microsoft trouxe novamente ao cenário de ferramentas

para construção de aplicações web o WebMatrix. Muito embora a ferramenta
não seja nova, seu conceito o é. A ferramenta, que retorna com uma roupagem
totalmente nova, traz consigo uma versão compacta do SQL Server, uma
versão expressa do IIS e um set de linguagens suportadas. Neste artigo, você
será apresentado à ferramenta e aprenderá como criar aplicações web
utilizando suas funcionalidades.

A internet é um cenário que sofre mutações constantes e radicais. Esta

afirmação pode ser facilmente comprovada realizando-se uma rápida análise
em sua história. No Brasil a internet surgiu comercialmente em meados de
1995. Inicialmente, consistia basicamente de alguns poucos navegadores que
interpretavam uma linguagem simples de marcação de texto, conhecida como
HTML. Com conteúdos estáticos, as páginas dos websites possuíam a única
responsabilidade de exibir as informações formatadas através do HTML. Anos
mais tarde, a internet passou de um modelo estático para um modelo
dinâmico. Essa mudança se deu em função de dois aspectos fundamentais: a
inserção de repositórios de dados (bancos de dados) e linguagens do tipo
server-side. Assim, as informações encontravam-se armazenadas em um
repositório de dados em um servidor remoto e eram exibidas em páginas web
construídas com linguagens de servidor em conjunto com as tags HTML.
Mais alguns anos e chegamos ao modelo de web que temos hoje – uma
internet interativa.

Na internet atual, exibir informações não mais é suficiente. Usuários

interagem com as aplicações, aproximando-as da experiência de
navegabilidade e utilização de aplicações tradicionais de desktop.
Evidentemente que um banco de dados relacional, HTML, uma linguagem
server-side e JavaScript não mais são suficientes para proporcionar tal
experiência. Para que as aplicações web alcancem este objetivo, novas
tecnologias foram naturalmente adicionadas, dentre as quais podemos citar:
AJAX, jQuery, Ruby, ASP.NET WebForms, Silverlight, dentre outras.

Realizando uma análise simplista do cenário apresentado, é possível notar a

existência de três fases distintas e bem definidas para a internet. Na primeira,
temos como característica principal a “simplicidade” para construção das
aplicações, bastando ao desenvolvedor conhecer fundamentalmente HTML e
Javascript. Na segunda, com o advento de novas tecnologias, coube ao
desenvolvedor dominar além dos já conhecidos HTML e Javascript, conceitos
de bancos de dados e ao menos uma linguagem do tipo server-side. Na
internet atual (terceira fase), estes conceitos não mais são suficientes para
atender a demanda dos usuários, assim, o domínio de novas tecnologias por
parte do desenvolvedor se faz necessário.

É possível afirmar, portanto, que a internet atual é incomparavelmente mais

poderosa do que há alguns anos. Evidentemente que há um preço a ser pago.
Maior poder necessariamente implica em maior complexidade. O profissional
que desenvolvia websites há cinco ou seis anos, hoje não consegue mais criar
aplicações aceitáveis apenas com seus conhecimentos de outrora.
Evidentemente que estamos falando de complexidade no processo de
desenvolvimento, já que, para o usuário final esta fica encapsulada.

Neste cenário, desenvolvedores iniciantes ou migrados de outro modelo de

desenvolvimento se deparam com uma dúvida cruel: por onde começar em
relação ao desenvolvimento para web já que existem tantas tecnologias
disponíveis no mercado? A Microsoft, olhando para este cenário e tentando
ajudar desenvolvedores iniciantes a responder a esta questão, reeditou e trouxe
novamente ao cenário de desenvolvimento de aplicações web o WebMatrix.

Neste artigo você será apresentado ao WebMatrix e suas principais

funcionalidades. Inicialmente serão apresentadas as características do produto.
Em seguida serão apresentados alguns aspectos fundamentais em relação ao
ASP.NET Razor. Finalmente, construiremos juntos um pequeno aplicativo
que insere e exibe os dados cadastrados.

Na ocasião em que este artigo foi escrito, o WebMatrix encontrava-se na

versão Beta 3, portanto, é possível que até a leitura deste artigo, uma versão
mais recente da ferramenta esteja disponível.

Conhecendo o WebMatrix

WebMatrix é um Integrated Development Enviroment (IDE) aplicado

especificamente à construção de aplicações web. Assim, ele reúne neste
ambiente integrado um conjunto de recursos e pequenas ferramentas
necessárias para construir Web Sites e Web Applications de forma rápida e
descomplicada. A ideia envolvida com o WebMatrix é a de deixar ao
desenvolvedor apenas as atribuições inerentes a ele, sem que este se preocupe
com aspectos tais como: configuração de servidor de banco de dados, de
hospedagem, instalação de plug-ins, gerenciamento de dependências, dentre
outros.

Outro aspecto a ser ressaltado em relação ao WebMatrix é o fato de que o

mesmo é uma suíte completa para desenvolvimento web sem ser
demasiadamente grande. Em poucos minutos é possível efetuar o download
no site oficial do produto (realizado via Web Platform Installer) e a instalação
do mesmo. Assim, o WebMatrix pode ser utilizado sem dificuldades em
praticamente qualquer PC disponível. É o equilíbrio entre disponibilidade de
ferramentas e tecnologias e recursos de software e hardware disponíveis.

Há ainda que se ressaltar o forte conceito de usabilidade presente na

ferramenta. A presença de ribbons menu (menus de contexto), ícones com boa
semântica e interface intuitiva trabalham concomitantemente para enriquecer a
experiência do usuário no trabalho com a ferramenta. A Figura 1 apresenta a
tela de entrada de um projeto no WebMatrix.

Nota do DevMan

Ribbon Menu é a implementação do conceito de menu contextualizado. Ele foi

introduzido no Office 2007 e acompanha os principais produtos da Microsoft.
Com o WebMatrix não é diferente. As opções de menu acompanham a
natureza da operação a ser realizada.
Figura 1. Tela de abertura de um projeto no WebMatrix

O WebMatrix traz consigo um conjunto de ferramentas e recursos integrados,

que facilitam em grande escala o processo de desenvolvimento das aplicações.
Os recursos e ferramentas acoplados ao WebMatrix a serem destacados são:

• IIS Express: o WebMatrix traz consigo uma versão simplificada do já

consagrado IIS. Evidentemente que esta versão não traz opções avançadas de
outras versões do servidor web, entretanto, para as aplicações que o
WebMatrix pretende ser útil, os recursos disponíveis no IIS Express são
suficientes. Como o WebMatrix é um IDE, todo o gerenciamento dos recursos
disponíveis no IIS são realizados através dele, sem alternância de ambientes;

• SQL Server CE: além do IIS Express, o WebMatrix traz em seu conjunto
de ferramentas uma versão compacta do SQL Server. A exemplo do IIS
Express, o SQL Server CE não disponibiliza todos os recursos de outras
versões, entretanto as básicas, necessárias para a construção de aplicações
pequenas e médias, estão presentes. Esta versão é mais leve e oferece suporte
nativo ao ASP.NET. Para acessar o banco de dados, basta referenciar o
arquivo com a extensão “sdf”. Da mesma forma como se dá o gerenciamento
do IIS Express pelo WebMatrix, dá-se o gerenciamento de bancos de dados,
ou seja, tudo em um único ambiente;

• Suporte a várias linguagens: o WebMatrix suporta o desenvolvimento das

aplicações de diversas formas. É possível desenvolver as aplicações utilizando
o ASP.NET Razor (e aí optar entre C# ou Visual Basic), é possível também
utilizar ASP.NET puro, como também é possível utilizar PHP;

• Galeria de aplicações: como mencionado anteriormente, o foco do

WebMatrix é enriquecer a experiência de desenvolvimento de aplicações web
de usuários iniciantes. Assim, o WebMatrix traz uma galeria completa de
aplicações já prontas, para que o usuário entenda o funcionamento e possa
personalizá-las, se assim for conveniente. As aplicações são divididas em
categorias para facilitar a busca. As aplicações disponíveis vão desde Blogs
até lojas virtuais. A Figura 2 apresenta a tela de aplicações disponíveis.

• Publicação de Aplicações: o WebMatrix conta com uma ótima ferramenta

para publicação das aplicações. Totalmente intuitiva, a ferramenta de deploy
do WebMatrix permite inclusive a busca por servidores de hospedagem
assinados pela Microsoft. É possível efetuar o deploy diretamente no servidor
com apenas alguns cliques (via FTP ou Web Deploy);

• Integração com Visual Studio 2010: esta é uma das características

interessantes do WebMatrix. É perfeitamente possível criar uma aplicação no
WebMatrix e utilizar recursos do Visual Studio 2010 para esta aplicação,
como por exemplo debug, IntelliSense, dentre outros;

• Relatórios: o WebMatrix vem munido de um novo recurso que é

extremamente útil para a grande maioria dos casos – os relatórios. Com este
recurso, é possível visualizar quais páginas de sua aplicação estão com algum
tipo de incompatibilidade em relação aos padrões web, se a estratégia de SEO
adotada é adequada ou não, e assim por diante. O relatório pode ser gerado
para a aplicação como um todo ou para arquivos específicos da aplicação.

Figura 2. Galeria de aplicativos disponíveis para o WebMatrix

Nota do DevMan

SEO é a sigla para Search Engine Optimization (Engenharia para

Otimização de Busca). SEO consiste de um conjunto de estratégias para
otimização de Web Sites para que robôs de sites de busca (Bing, Google, etc.)
possam encontrá-los.

Uma observação importante em relação ao trabalho com PHP no WebMatrix é

que, por padrão, o IIS não vem habilitado para o trabalho com esta linguagem,
entretanto, para habilitar é extremamente simples e bastam alguns cliques.
Basta criar um novo projeto do tipo PHP. Em seguida, caso não tenha o PHP e
o MYSQL instalado em seu computador, o WebMatrix perguntará se você
deseja que ele instale para você. Ao confirmar, o WebMatrix efetuará o
download do PHP e do MySQL, instalará e configurará estes componentes
junto ao IIS automaticamente. A Figura 3 apresenta o PHP e o MYSQL
sendo baixados e posteriormente instalados.

Figura 3. O WebMatrix baixando e instalando PHP, WordPress e MYSQL

ASP.NET Razor

Sem dúvida alguma, um dos fatores que contribuirão em maior escala para o
sucesso do WebMatrix é o suporte nativo do mesmo ao ASP.NET Razor.

ASP.NET Razor é uma view engine criada pela Microsoft com o objetivo de
fornecer ao desenvolvedor maior poder no processo de construção de suas
páginas. Originalmente, o ASP.NET Razor foi projetado para ser utilizado
como view engine padrão do ASP.NET MVC (e este pôde ser comprovado
com o lançamento da versão 3 RC da framework), entretanto, a comunidade
técnica foi surpreendida quando, ao disponibilizar a versão Beta 1 do
WebMatrix, a Microsoft trouxe a possibilidade de construir aplicações
pequenas e médias utilizando o ASP.NET Razor de forma desacoplada da
estrutura MVC.

Basicamente, a ideia do ASP.NET Razor é introduzir entre as tags HTML

porções de código C# ou Visual Basic, sem precisar necessariamente de
receber informações apenas através de um controller, como acontece no
ASP.NET MVC, simplificando e agregando valor ao processo de
desenvolvimento.

O ASP.NET Razor possui uma série de características que o torna

extremamente interessante. A seguir, apresentamos as principais delas:

• Código limpo e legível: sem dúvida, a principal característica do ASP.NET

Razor é a simplicidade na construção dos códigos. É possível construir
páginas extremamente elaboradas, ricas em conteúdo com código organizado
e limpo, gerando assim, facilidade no processo de manutenção do mesmo;

• Razor não é uma linguagem: aqui está um motivo de grande confusão

daqueles que iniciam os estudos com ASP.NET Razor. Muito embora você
seja levado a pensar desta forma, o ASP.NET Razor não é uma nova
linguagem de programação e sim, um novo modelo de programação. Para
utilizar Razor em suas aplicações, você poderá utilizar seus conhecimentos
das linguagens C# (C-Sharp) ou VB (Visual Basic). Caso sua escolha seja
pela linguagem C#, o arquivo em que trabalhará terá a extensão “cshtml”.
Caso a linguagem escolhida seja o Visual Basic, seu arquivo possuirá a
extensão “vbhtml”;

• Helpers: uma das possibilidades interessantes do ASP.NET Razor é a de

utilizar helpers. Helpers são funcionalidades específicas (por exemplo:
formulário de busca no Bing, exibição de twits, integração com Facebook,
etc.) já implementadas e disponibilizadas gratuitamente para utilização. Para
alguns casos, a utilização de helpers diminui em grande escala o tempo gasto
no processo de desenvolvimento de algumas tarefas. É possível também criar
helpers personalizados;

• Fácil aprendizagem: outra característica importante do ASP.NET Razor é a

facilidade na aprendizagem do mesmo, haja vista a simplicidade para escrever
códigos proporcionada por ele.

Para utilização do ASP.NET Razor é preciso estar utilizando a versão 4.0 da

.NET framework.
Aplicação de Exemplo: CRUD Simples

Para demonstrarmos os conceitos mencionados anteriormente, criaremos uma

aplicação simples, mas que apresenta todo poder proporcionado pelo
WebMatrix em parceria com ASP.NET Razor.

O que faremos é criar uma aplicação baseada em um modelo fornecido pelo

WebMatrix que implementa um CRUD (Create, Read, Update e Delete) de
usuários. Iniciaremos criando um banco de dados com uma tabela de
“Usuários”. Em seguida criaremos as páginas de inserção, edição, remoção e
listagem. À medida que evoluímos com a aplicação, vamos entendendo o
funcionamento do ASP.NET Razor e aprendendo a utilizar os diversos
recursos disponíveis no WebMatrix.

Criando o Banco de Dados

Iniciaremos a construção de nossa aplicação de exemplo através da criação do

banco de dados. Para isso, utilizaremos o próprio gerenciador de bases de
dados do WebMatrix. Assim, criaremos um novo projeto do tipo “Starter
Site”, localizado na categoria “Site From Template”. Nomearemos nosso
projeto como “CRUDWebMatrixRazor”.

Agora, criaremos o banco de dados de nossa aplicação. Na tela seguinte, ao

alternarmos a visualização de nossa aplicação para a guia “Databases”,
localizada no canto inferior esquerdo, obtemos a área de gerenciamento de
bancos de dados da aplicação. Como mencionado anteriormente, o
WebMatrix traz o conceito de menu contextualizado, portanto, ao se alternar
para a aba “Databases”, o WebMatrix contextualiza todas as opções de menu
para databases. Selecionamos a opção “New Database” e criamos o banco
“StarterSite.sdf”. Expandindo a aba a frente do banco de dados, tem-se a
opção “Tables”. Clicando com o botão direito sobre esta, e em seguida em
“New Table”, obtemos a tela com as configurações da nova tabela, conforme
apresenta a Figura 4.
Figura 4. Criando e configurando a tabela da aplicação

Note que a Figura 4 apresenta uma relação de tabelas. Lembre-se, estamos

criando nossa aplicação sob um modelo já pronto, fornecido pelo WebMatrix,
portanto, estas tabelas previamente existentes são aquelas necessárias para que
o modelo funcione. São tabelas de apoio ao helper “Membership”.

Em nosso exemplo, o que faremos é inserir, editar, listar e remover usuários,

portanto, é suficiente apenas uma tabela, a de usuários, que sugestivamente
nomearei como “tbUsuarios”. A Figura 5 apresenta o desenho final de nossa
tabela.

Figura 5. Tabela “tbUsuarios” criada e devidamente configurada

Neste ponto temos nosso banco de dados e nossa tabela pronta. Vamos então à
criação das páginas responsáveis pelo CRUD. Assim, ao alternar-se a guia
“Databases” para “Files”, temos a área de gerenciamento dos arquivos de
nossa aplicação. É notória a presença de alguns arquivos neste contexto.
Novamente, isto ocorre em função de estarmos estruturando a aplicação de
exemplo sob um modelo fornecido pelo WebMatrix, portanto, estes são
arquivos iniciais sugeridos pelo modelo. Não necessariamente estes devem ser
utilizados na aplicação de exemplo.

Página para criar Usuários

Para este exemplo, é de nosso interesse somente o arquivo

“_SiteLayout.cshtml”, pois é ele o responsável por armazenar todas as
informações padrão das páginas a serem exibidas para este modelo. Assim,
personalizamos a aplicação, de forma que as alterações sejam refletidas por
ela de forma geral, é necessário referenciar (herdar) esta página nas demais.

A primeira página a ser implementada neste exemplo é a de

“inserção/cadastro de usuários”. Note que ao centro do contexto de
gerenciamento de arquivos, existe a opção “Add file to your site”. Clicando
nesta opção, uma janela com as opções de arquivos suportadas pelo
WebMatrix é exibida. Selecione a opção “cshtml” e em seguida nomeie o
arquivo como “Create.cshtml”. O que estamos fazendo aqui é criar uma
página no modelo ASP.NET Razor com suporte à linguagem C#. O código da
página “Create” pode ser visualizado na Listagem 1.

O código da Listagem 1 é simples e direto, como você pode perceber.

Naturalmente não entraremos em maiores detalhes em relação a linguagem C#
e ao HTML apresentado, pois não são foco deste artigo.

Como é possível notar, o ASP.NET Razor consiste na inserção de comandos

C# com a lógica da aplicação entre as tags HTML, possibilitando assim a
escrita de um código limpo e legível. Como é possível observar, a lógica de
nossa página encontra-se implementada entre as linhas 01 e 27. Entendamos
então linha a linha o que faz nossa aplicação na página “Create”:

• Linha 02: Referenciamos a página padrão de nossa aplicação. Com isso,

estamos informando ao framework que, ao criar a página “Create.cshtml”, seu
visual deve ser exatamente aquele proposto pela principal;

• Linha 03: Através da diretiva “Page.Title” adicionamos o nome à página

atual;

• Linha 04: Estabelecemos a conexão de nossa página com o banco de dados

“StarterSite”. Note que o resultado da conexão é armazenado no objeto “bd”;
• Linha 06: Verificamos se a página encontra-se em postback. Se sim, da linha
8 até a linha 18 o que fazemos é, recuperar as informações do formulário (via
Request), verificar se estas existem (através de IsEmpty) e, em seguida,
validamos estas informações via ModelState;

• Linha 20: Verificamos se o modelo de dados é válido. Caso seja, executamos

a sentença SQL de inserção (Linha 22) através do método “Query”;

• Linha 29: Via “ValidationSummary”, exibimos as mensagens de erro (caso

estes ocorram);

• Linhas 33 a 64: Trecho HTML onde é criado o formulário onde os usuários

deverão informar seus dados.

Listagem 1. Código da página “Create”

01 @{
02 Layout = "~/_SiteLayout.cshtml";
03 Page.Title = "Inserção de Usuário";
04 var bd = Database.Open("StarterSite");
05
06 if(IsPost)
07 {
08 string email = Request["txtEmail"];
09 string senha = Request["txtSenha"];
10
11 if(email.IsEmpty())
12 {
13 ModelState.AddError("E-mail", "Por favor, informe seu
e-mail.");
14 }
15 if(senha.IsEmpty())
16 {
17 ModelState.AddError("Senha", "Por favor, informe sua
senha.");
18 }
19
20 if(ModelState.IsValid)
21 {
22 var resultado = bd.Query("INSERT INTO tbUsuarios
(Email, Senha) VALUES (@0, @1)", email, senha);
23 Response.Redirect("~/ListUsers");
24 }
25
 26 }
27 }
28
29 @Html.ValidationSummary("Erros encontrados:")
30
31
32
33 <div style="width:800px; margin-top:15px;">
34 <form method="post" action="">
35 <table>
36 <tr>
37 <td>
38 Informe seu e-mail:
39 </td>
40 </tr>
41 <tr>
42 <td>
43 <input type="text" id="txtEmail" name="txtEmail" />
44 </td>
45 </tr>
46 <tr>
47 <td>
48 Informe sua senha:
49 </td>
50 </tr>
51 <tr>
52 <td>
53 <input type="password" id="txtSenha" name="txtSenha"
/>
54 </td>
55 </tr>
56 <tr>
57 <td>
58 <input type="submit" id="btnAdicionar"
value="Adicionar" />
59 </td>
60 </tr>
61 </form>
62 </table>
63
64 </div>
Página para listar Usuários

O passo seguinte consiste na criação da página que lista os usuários

previamente cadastrados pela página “Create.cshtml”. Assim, adicionaremos
uma nova página a nosso projeto e a nomearemos como “ListUsers.cshtml”. A
codificação desta página pode ser visualizada através da Listagem 2.

A seguir destacamos os principais aspectos do código apresentado:

Linha 06: Selecionamos os usuários cadastrados no banco de dados e

armazenamos no objeto “linhas”;

Linha 16: Estrutura “foreach” que percorre os registros constantes no objeto

“linhas”. Internamente, é criada em tempo de execução a listagem de usuários
cadastrados (linhas 20, 25 e 26).

Listagem 2. Código da página que lista usuários

01 @{
02 Layout = "~/_SiteLayout.cshtml";
03 Page.Title = "Usuários cadastrados";
04 var bd = Database.Open("StarterSite");
05
06 var linhas = bd.Query("SELECT * FROM tbUsuarios ORDER BY
IDUsuario DESC");
07
08 }
09
10 <p>&nbsp;</p>
11
12 <div>
13 <table>
14 <tr>
15 <td>
16 @foreach(var item in linhas) {
17 <table>
18 <tr>
19 <td>
20 @item.Email
21 </td>
22 </tr>
23 <tr>
24 <td>
 25 <a href="@href("~/Edit",
@item.IDUsuario)" target="_self">Editar usuário</a>
&nbsp;&nbsp;|&nbsp;&nbsp;
26 <a href="@href("~/Remove",
@item.IDUsuario)" target="_self">Remover usuário</a>
27 </td>
28 </tr>
29 <tr>
30 <td>
31 <hr size="1" />
32 </td>
33 </tr>
34 </table>
35 }
36 </td>
37 </tr>
38 </table>
39 </div>

Página para atualizar Usuários

O passo seguinte, consiste na implementação da rotina de atualização dos

dados de usuários cadastrados. Para isso, adicione uma nova página ao projeto
e nomeie-a como “Edit.cshtml”. O código apresentado pela Listagem 3 é
aquele que implementa a lógica da página referida.

Em relação ao código apresentado pela Listagem 3, temos poucas mudanças

em relação ao apresentado pela Listagem 1. Note que o formulário é
basicamente o mesmo, haja vista que estamos atualizando os dados de um
usuário já existente. Portanto, a novidade aqui consiste na busca das
informações do usuário com base no código passado como parâmetro para
esta página (via barra de endereços). Portanto temos:

• Linha 06: Recuperamos o valor do código do usuário passado via barra de

endereços através de “UrlData” e armazenamos na variável UsuarioID. Caso o
valor desta variável seja vazio ou nulo (Linha 08), o usuário é redirecionado
para a listagem de usuários (Linha 10);

• Linha 13: Criamos a query para selecionar os dados do usuário com base em
UsuarioID;

• Linha 14: Através do método “QuerySingle” retornamos um registro único

de usuário para exibição nos campos do formulário;
• Linha 35: Caso o modelo de dados seja válido, é executada a sentença de
atualização dos dados;

• Linhas 53 e 68: As propriedades “value” de ambos os inputs recebem os

valores retornados em cada objeto “Email” e “Senha” respectivamente.

Listagem 3. Código da página que atualiza os dados do usuário

01 @{
02 Layout = "~/_SiteLayout.cshtml";
03 Page.Title = "Atualizando dados do usuário";
04
05 var bd = Database.Open("StarterSite");
06 var UsuarioID = UrlData[0];
07
08 if(UsuarioID.IsEmpty())
09 {
10 Response.Redirect(@href("~/ListUsers"));
11 }
12
13 var varQuery = "SELECT * FROM tbUsuarios WHERE IDUsuario =
@0";
14 var registro = bd.QuerySingle(varQuery, UsuarioID);
15
16 var Email = registro.Email;
17 var Senha = registro.Senha;
18
19 if(IsPost)
20 {
21 Email = Request["txtEmail"];
22 if(String.IsNullOrEmpty(Email))
23 {
24 ModelState.AddError("E-mail", "Por favor, informe seu
e-mail.");
25 }
26
27 Senha = Request["txtSenha"];
28 if(String.IsNullOrEmpty(Senha))
29 {
30 ModelState.AddError("Senha", "Por favor, informe sua
senha.");
31 }
32
33 if(ModelState.IsValid)
 34 {
35 bd.Execute("UPDATE tbUsuarios SET Email = @0, Senha =
@1 WHERE IDUsuario = @2", Email, Senha, UsuarioID);
36 Response.Redirect(@href("~/ListUsers"));
37 }
38 }
39 }
40
41 @Html.ValidationSummary("Erros encontrados:")
42
43 <div style="width:800px; margin-top:15px;">
44 <form method="post" "action=">
45 <table>
46 <tr>
47 <td>
48 Informe seu e-mail:
49 </td>
50 </tr>
51 <tr>
52 <td>
53 <input type="text" id="txtEmail" name="txtEmail"
value="@Email" />
54 </td>
55 </tr>
56 <tr>
57 <td>
58 Informe sua senha:
59 </td>
60 </tr>
61 <tr>
62 <td>
63 <input type="password" id="txtSenha" name="txtSenha"
value="@Senha" />
64 </td>
65 </tr>
66 <tr>
67 <td>
68 <input type="submit" id="btnAtualizar"
value="Atualizar" />
69 </td>
70 </tr>
71 </form>
72 </table>
 73
74 </div>

Página para excluir Usuários

Finalmente, nos resta criar a página que implementará a rotina de remoção de

usuários. Assim, após adicionarmos uma nova página do tipo Razor com
suporte a C# e nomeá-la como “Remove.cshtml” em nosso projeto, a
codificaremos conforme apresenta a Listagem 4.

O código apresentado pela Listagem 4 não traz maiores novidades em relação

aos códigos das páginas anteriores. Basicamente, o que fazemos é recuperar o
código do usuário e armazená-lo na variável “UsuarioID” (Linha 06), verificar
se o valor recuperado é válido (Linha 08), armazenar os valores retornados do
banco de dados pela query de seleção nos objetos “Email” e “Senha”.
Finalmente, os dados do usuário são removidos da base de dados (Linha 23).

Listagem 4. Código da página “Remove.cshtml”

01 @{
02 Layout = "~/_SiteLayout.cshtml";
03 Page.Title = "Removendo usuário";
04
05 var bd = Database.Open("StarterSite");
06 var UsuarioID = UrlData[0];
07
08 if(UsuarioID.IsEmpty())
09 {
10 Response.Redirect(@href("~/ListUsers"));
11 }
12
13 var varQuery = "SELECT * FROM tbUsuarios WHERE IDUsuario =
@0";
14 var registro = bd.QuerySingle(varQuery, UsuarioID);
15
16 var Email = registro.Email;
17 var Senha = registro.Senha;
18
19 if(IsPost)
20 {
21 if(ModelState.IsValid)
22 {
23 bd.Execute("DELETE tbUsuarios WHERE IDUsuario = @0",
UsuarioID);
 24 Response.Redirect(@href("~/ListUsers"));
25 }
26 }
27 }
28
29 <h1 style="color:Red;">Confirme os dados antes de remover</h1>
30
31 <div style="width:800px; margin-top:15px;">
32 <form method="post" "action=">
33 <table>
34 <tr>
35 <td>
36 Código do usuário:
37 </td>
38 </tr>
39 <tr>
40 <td>
41 @UsuarioID
42 </td>
43 </tr>
44 <tr>
45 <td>
46 E-mail do usuário:
47 </td>
48 </tr>
49 <tr>
50 <td>
51 @Email
52 </td>
53 </tr>
54 <tr>
55 <td>
56 <input type="submit" id="btnRemover"
value="Remover" />
57 </td>
58 </tr>
59 </form>
60 </table>
61
62 </div>
Página modelo

Antes de executarmos nossa aplicação e realizarmos todos os testes,

realizaremos algumas pequenas personalizações em nossa página modelo.
Para isso, dê um duplo clique na página “_SiteLayout.cshtml” e nas linhas em
negrito da Listagem 5, você pode visualizar as alterações realizadas.
Basicamente o que foi alterado é: o título geral de nossa aplicação e os itens
de menu.

Listagem 5. Código fonte da página modelo da aplicação com as alterações

realizadas

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>CRUD WebMatrix e Razor - @Page.Title</title>
<link href="@href("~/Styles/Site.css")" rel="stylesheet" />
</head>
<body>
<div id="page">
<div id="header">
<p class="site-title">FabricioSanchez.com.br / .NET
Interior</p>
<div id="login">
@if (WebSecurity.IsAuthenticated) {
<p>
Welcome <a
href="@href("~/Account/ChangePassword")" title="Change
password">@WebSecurity.CurrentUserName</a>!
<a
href="@href("~/Account/Logout")">Logout</a>
</p>
} else {
<ul>
<li><a
href="@href("~/Account/Register")">Register</a></li>
<li><a
href="@href("~/Account/Login")">Login</a></li>
</ul>
}
</div>
<ul id="menu">
<li><a href="@href("~/")">Home</a></li>
 <li><a href="@href("~/Create")">Inserir
usuário</a></li>
<li><a href="@href("~/ListUsers")">Editar
usuário</a></li>
<li><a href="@href("~/ListUsers")">Remover
usuário</a></li>
</ul>
</div>
<div id="main">
<div id="content">
<h1>@Page.Title</h1>
@RenderBody()
</div>
<div id="footer">
&copy; @DateTime.Now.Year - Minha página
</div>
</div>
</div>
</body>
</html>

Testando

Com todas as páginas da aplicação construídas e personalizações do tema

devidamente realizadas, podemos executar nossa aplicação e verificar se tudo
está funcionando corretamente. As Figuras 6, 7, 8, 9, 10 e 11 apresentam o
resultado final de nossa aplicação em execução. Para executar a aplicação,
basta clicar sobre o botão “Run” localizado no menu superior esquerdo do
WebMatrix.

Figura 6. Inserindo um novo usuário

Figura 7. Listando os usuários cadastrados no sistema

Figura 8. Atualizando os dados do usuário cadastrado

Figura 9. Verificando os usuários com dados alterados

Figura 10. Removendo usuário do sistema

Figura 11. Verificando a remoção dos usuários

Conclusão

A internet atual com sua alta complexidade, tende a confundir usuários

iniciantes no processo de desenvolvimento de aplicações, assim, é de
fundamental importância uma ferramenta como o WebMatrix.

O WebMatrix é uma ferramenta realmente interessante por vários motivos,

sendo que o principal deles, é a simplicidade e produtividade proporcionadas
ao desenvolvedor. Evidentemente, o WebMatrix não é uma ferramenta para
construção de aplicações maiores, onde escalabilidade, gerenciamento de
grandes massas de dados e outras características avançadas são requeridas.
Para estes casos, o produto mais indicado é o Visual Studio.

Em relação ao ASP.NET Razor, é preciso reafirmar todo poderio

proporcionado por ele. Com códigos extremamente simplificados,
possibilidade de utilização de helpers e a utilização do expertise já adquirido
pelo usuário em linguagens de programação como C# e Visual Basic, é
possível obter dinamismo nas aplicações.
Considere a adoção do WebMatrix com ASP.NET Razor em seus projetos.
Com certeza absoluta você não irá se decepcionar.

por Fabrício Lopes

Guru .net e tecnologias MS