ASP.NET, tratando exceções não tratadas

Quando as exceções não são tratadas e recuperadas internamente em nossa aplicação o ASP.NET ainda fornece maneiras para logarmos, liberar recursos e fazer qualquer outro processamento necessário antes de mostrarmos a exceção para o usuários.

Para isto é possível utilizar dos eventos Page_Error e Application_Error, um programado na página e o segundo no global.asax. Dentro destes eventos podemos então chamar o método Server.GetLastError() para obtermos a exception que está ocasionando o erro e podemos também, se só tivermos que logar ou fazer outra manipulação, chamar o método Server.ClearError(), para que o erro não continue sendo propagado.

Na imagem 1, estamos programando o evento da página para adicionar informações ao trace, que permitirá a análise da requisição.

Imagem 1 - Programando o Page_Error

Para programar o evento Page_Error, somente criamos o método com o nome, parâmetros e retorno acima e este foi chamado devido ao atributo AutoEventWireup da diretiva @Page estar definido para true, conforme Imagem 2.

Imagem 2 - Atributo AutoEventWireup

No global.asax podemos programar o método Application_Error que deve ser utilizado para logar, armazenar informações, enviar notificações e outros procedimentos sobre o erro. Veja na Imagem 3.

Imagem 3 - Application_Error

Na página é possível também configurar o atributo ErrorPage, para definir qual página será executada ao acontecer um erro não tratado.

Configurando o Web.config

No web.config, no elemento customErros, podemos configurar qual a página de erro padrão e página de erros para os diferentes códigos de errors HTTP. O atributo mode do elemento customErrors pode ter os seguintes valores:

• On
  Exceções não manipuladas redirecionarão o usuário a página configurada no atributo defaultRedirect. Este é utilizado mais frequentemente em produção.
• Off
  Usuários visualizarão as informações de exceção da página padrão de erro padrão do ASP.NET, esta mostra várias informações sobre o erro. Utilizado frequentemente no desenvolvimento.
• RemoteOnly
  Usuário acessando a máquina usando localhost na url visualizarão o erro padrão do ASP.NET, enquanto usuários remotos serão redirecionados para a página configurada no atributo defaultRedirect

Veja um exemplo de configuração na Imagem 4

Imagem 4 – customErrors no web.config

Referências:

http://msdn2.microsoft.com/en-us/library/ms954599.aspx

http://msdn2.microsoft.com/en-us/library/ms972393.aspx

http://msdn2.microsoft.com/en-us/library/aa479319.aspx

Pensando no resultado esperado

TDD ou Test Driven Develpment é relacionado ao conceito de testar antes de codificar, proposto pela metodologia XP(Extreme Programming). Para quem é averso a sopa de letrinhas ou acha que é modismo, no mínimo vale a pena conhecer a proposta. Eu particularmente gosto da idéia de quando você for codificar, no mínimo já tenha quebrado o problema que vai resolver em pedaços menores e tenha em mente a competência e o escopo de cada parte. Isto faz com que você pense na solução e no resultado esperado pelo usuário, e esqueça as dificuldades de implementação no momento da concepção da idéia.

Este link em português da linha de código dá uma boa introdução para quem tiver dificuldade com o inglês: http://www.linhadecodigo.com.br/Artigo.aspx?id=510

O NUnit é a framework que permite o teste unitário mais utilizada pela comunidade .Net atualmente. Quem vem do java ou ouviu falar do conceito deve estar achando o nome parecido com o JUnit. Não é só o nome que parece, a idéia é a mesma.


Vale a pena ficar de olho também no XUnit.net, que é uma framework de teste unitário que pretende substituir o NUnit, estes blogs em inglês dão uma boa introdução:
http://weblogs.asp.net/rosherove/archive/2007/09/21/xunit-net-aims-to-be-the-next-nunit-but-it-s-too-soon.aspx
http://blog.benhall.me.uk/2008/01/introduction-to-xunit.html

E este é o site do projeto no CodePlex:
http://www.codeplex.com/xunit

No mínimo vale a pena conhecer.

Erros acontecem

Mais cedo ou mais tarde nossa aplicação terá um comportamento técnico inesperado, uma situação até então não conhecida, ou simplesmente um bug ou erro. Talvez o pior deles seja achar que não erramos, dessa forma não teremos atuado para contorná-los ou ter coletado informações suficientes para que quando um erro aconteça, seja apenas uma vez e possamos descobrir seu motivo e resolve-lo.

Problemas acontecem durante o processo de desenvolvimento de software e profissionais trabalham no sentido codificar de forma defensiva, logando e manipulando erros inesperados.

Com o tempo e experiência a tendência é desenvolvermos produtos mais maduros, no sentido de ter menos bugs, mas também melhorando nosso processo de manipulação de erros. Pois é assim, por mais que você tenha feito sua parte, o disco rígido pode estar cheio, a conexão pode cair no meio de um processo. Até mesmo um inesperado inseto pode atrapalhar nossa vida...

Exception

As exceções nos programas do .net são tratadas todas de forma uniforme, independente de linguagem. Ou seja, as exceções que ocorrerem em nossas implementações ou em assemblies .net de terceiros, serão tratados da mesma maneira.

Podemos definir exceção como um comportamento ou estado esperado de forma implícita pelo sistema que não é atendido. Um exemplo seria ler um arquivo em disco que não existe, outro exemplo seria programarmos uma exceção para informar um comportamento ou estado inesperado.

As exceções são classes System.Exception ou descendentes desta e a .Net Framework já disponibiliza várias exceções que podem ser utilizadas. É interessante pensarmos no desenvolvimento de nossos sistemas em criarmos exceções específicas do nosso sistema, e estas devem descender de System.ApplicationException. Apesar da Classe ApplicationException descender de Exception, ela não acrescenta nenhum comportamento específico, apenas é uma prática sugerida A imagem 1 demonstra a hierarquia de exceções.

Imagem 1 - Hierarquia de Excecoes.gif

Dentre as propriedades mais utilizadas da classe Exception estão a propriedade Message, que tem as mensagem da exceção e a propriedade InnerException, que pode conter a exceção que ocasionou a exceção atual, isto será exemplificado no próximo parágrafo.

As exceções devem ser detectadas pelo nosso sistema, se a exceção for detectada por um método de nosso código e for possível recuperar desta, ou seja, atuar para resolvê-la, isto deve ser feito. Caso não seja possível a recuperação e tenha sido feito a detecção da exceção, podemos gerar informações do contexto atual, efetuarmos a liberação de recursos utilizados e repassarmos uma exceção para o método chamador. Veja na Imagem 2 este fluxo.

Imagem 2 - Tratamento de uma exceção

Em última instância, ou seja, caso uma exceção não seja manipulada e recuperada em nenhuma parte do programa, podemos logar a exceção, notificar usuários, informar o usuário do erro e devemos também liberar os recursos utilizados. Veja este esquema representado na Imagem 3.

Imagem 3 - Tratando exceções em última instância

Veremos agora como a .Net Framework, o C# e o ASP.NET facilitam a implementação deste tratamento.

Detectando, recuperando, liberando recursos ou repassando exceções

O C# implementa o detectar, recuperar, liberar e repassar exceções através das declarações try-catch-finally e throw. Por causa desta implementação ser um recurso do C# é utilizado para o desenvolvimento de aplicações WebForms ou WinForms da mesma maneira. Para mostrarmos uma aplicação, suponha que precisemos consultar no banco de dado AdventureWorks o total de contatos cadastrados na tabela Person.Contact, veja a imagem 4:

Imagem 4 - Try Finally.jpg

O bloco de código try é executado até o seu final ou até que uma exeção seja levantada. No bloco de código try devemos colocar todo e somente o código que pode levantar a exceção que queremos manipular, ou neste caso, garantir que o recurso seja liberado. Devemos evitar colocar códigos desnecessários no bloco try para liberarmos os recursos assim que não precisemos mais utilizá-los. O bloco finally é sempre executado, independente se o bloco try foi executado com sucesso ou alguma execeção foi levantada.

Uma outra sintaxe para utilizarmos algum recurso garantindo que este seja liberado após sua utilização é a declaração using. A Imagem 5 tem a mesma funcionalidade que o da imagem 4. A declaração using, permite utilizar-se de classes que implementam a interface IDisposable para que este recurso seja fechado após sua utilização.

Imagem 5 - Declaração Using.jpg

Podemos também querer recuperar de um exceção ou adicionar informações de um contexto do método ou parte do código. Vejamos na imagem 6

Imagem 6 - Try Catch Finally.jpg

O bloco catch é executado quando uma exceção é levantada pelo bloco try. Outro ponto importante é que somente o primeiro catch, que é do tipo da exceção levantada ou de algum dos tipos ancestrais da exceção levantada, é executado. Então devemos colocar as exceções mais genéricas por último. Depois da execução do bloco catch o bloco finally é executado se existir.

Caso queria ver mais sobre o tratamento de exceções, confira uma entrevista do Anders Hejlsberg, onde explica porque da opção de não implementar no C# o conceito de Checked e Unchecked exceptions, conceito este, existente no Java: http://www.artima.com/intv/handcuffsP.html

Referências:

http://msdn2.microsoft.com/en-us/library/ms954599.aspx

http://msdn2.microsoft.com/en-us/library/0yd65esw(VS.80).aspx
http://msdn2.microsoft.com/en-us/library/dszsf989(VS.80).aspx
http://msdn2.microsoft.com/en-us/library/dszsf989(VS.80).aspx
http://msdn2.microsoft.com/en-us/library/1ah5wsex(VS.80).aspx
http://weblogs.asp.net/jasonsalas/archive/2005/02/08/368811.aspx

Fundamentos ASP.Net

Poderíamos definir como uma aplicação ASP.NET um web site configurado para executar ASP.NET. Cada site tem os seus próprios recursos(Imagens, páginas, javascripts, aspx e outros) e inclusive seu próprio Application Domain para processamento das requisições do usuário. Podemos e é até uma das grandes vantagens da Web fazer hiperlinks entre recursos entre diferentes sites e até servidores, mas cada site, mesmo que num mesmo servidor, tem seu próprio Application Domain.

Extensões de arquivo

Na versão dos IIS 6.0 é possível ver que algumas extensões são registradas para o processamento pelo ASP.NET, no IIS 7.0 há algumas mudanças, no sentido do ASP.NET já ser integrado, com certeza há estas extensões, mas ainda não vi como vai ficar.

No IIS 6.0 é possível ver isto abrindo o IIS, se estiver instalado, através do Iniciar / Painel de Controle / Ferramentas Administrativas / Internet Information Services. Expanda para visualizar o Default Web Site, e clique com o botão direito e vá em propriedades, conforme Imagem 1.

Imagem 1 - Propriedades do Web Site

Vá na tab Home Directory e clique no botão configuração, será aberto uma janela onde é mostrado as extensões de arquivos registradas para o IIS, há extensões ASP.NET e outras, veja na Imagem 2.

Imagem 2 - Mapeamento de extensões no IIS

Existem diferentes tipos de arquivos e com diferentes finalidades para um ASP.NET web site. A extensão mais conhecida é a extensão ASPX, que contêm html, xhtml e aspx markup. Veja a tabela abaixo as extensões de arquivos, versão da .Net framework em que foram incorporadas e sua descrição:

Extensão	Versão Requerida	Descrição
asax	1.0	Usado para a lógica de aplicação Global.asax
ascx	1.0	UserControls: controles customizados do usuário que são utilizados como controles dentro de páginas.
ashx	1.0	Usado para crier um HttpHandler customizado
asmx	1.0	Usado para responder por web services
aspx	1.0	Respondem como páginas para o usuário, normalmente se tem html, xhtml e aspx markup nestes
axd	1.0	Usado para recursos web especiais, que permitem empacotar componentes, controles, javascript, imagens e demais conteúdos a critério do desenvolvedor. Também utilizado pelo trace. package
browser	2.0	Características de diferentes navegadores guardados em formato XML; Com este o ASP.NET sabe qual capacidade tem o navegador e pode customizar o retorno da requisição do usuário. Substitui a antiga seção BrowserCaps do web.config do ASP.NET
config	1.0	Arquivo para configurar a aplicação web.config , seu conteúdo é armazenado em XML.
cs/vb	1.0	Arquivo de código, a extensão cs é para linguagem C# e vb para Visual Basic. Poderão ser arquivos que estão no diretório App_Code ou arquivos code behind de outro recurso ASP.NET
master	2.0	Usado para master pages
resx	1.0	Arquivos de recursos para internacionalização e localização.
sitemap	2.0	Usado para configuração do sitemap
skin	2.0	Usado como skin para Themes
svc	3.0	arquivo de service baseado no Windows Communication Foundation

Existe a extensão de projeto “csproj”, mas na versão 3.5 o padrão de web sites é não ter arquivos de projetos.

Estrutura de diretórios

Além dos diretórios que é possível criar para a organização da aplicação, como pastas para imagens, estilos e javascripts, existem diretórios especiais da aplicação, conforme tabela abaixo:

Diretório	Descrição
App_Browsers	Contem arquivos específicos de definição para navegadores
App_code	Contem arquivos de código. Estes arquivos são compilados em um assembly que é acessível no código de toda página
App_Data	Diretório padrão para arquivos de dados e base de dados como Access e Sql Express.
App_LocalResources	Diretório que contêm arquivos de recursos de localização para toda página do site’
App_GlobalResources	Armazena arquivos de recurso de localização disponível para toda página do site
App_Themes	Armazenam themas
App_WebReferences	Armazem arquivos wsdl que referênciam web services consumidos pela aplicação asp.net
Bin	Armazenam assemblies da aplicação e que a aplicação faz referência

Ciclo de vida da aplicação ASP.NET para IIS 7.0

O IIS 7.0 permite dois modos de executar de executar aplicações ASP.NET, integrado para framework .net 3.0 ou posteriores, ou modo clássico que se comporta da mesma maneira que aplicações ASP.NET rodando em IIS 5.0 e IIS 6.0.

Para responder a uma requisição de usuário, há várias etapas de processamento que devem ocorrer.

Modo clássico

O usuário requisita um recurso de um servidor web, tipicamente o IIS. O servidor web examina a extensão do recurso solicitado, determina qual extensão ISAPI manipula a requisição e repassa a requisição para para a extensão ISAPI apropriada.

Se for a primeira requisição, o Application Manager cria um Application Domain. Dentro do Application Domain uma instancia do HostingEnviroment é criado, este fornece informações sobre a aplicação. A imagem 3 mostra este cenário:

Imagem 3 – Relação IIS, Application Manager, Application Domain e HostingEnviroment

Para toda requisição são criados e inicializados objetos como HttpContext, HttpRequest e HttpResponse.

O próximo passo é criar uma instância da classe HttpApplication. Esta será compartilhada por todos usuários da aplicação. Se a aplicação for configurada para tal, o módulo SessionStateModulo é criado. A Imagem 4 ilustra estas instâncias:

Imagem 4 – Contexto de objetos da requisição

Eventos de Ciclo de vida e o Global.asax

Durante o ciclo de vida da aplicação, eventos são levantados que podemos programar através do arquivo Global.asax, que fica na raiz da aplicação. Estes eventos propiciam um controle da aplicação e da sessão. Importante ainda ressaltar o conceito aplicação, como seus eventos e variável HttpApplication é comum a todos os usuários do site e o conceito de sessão é único para cada usuário. A Imagem 5 mostra alguns dos eventos, os mais comumente utilizados:

Imagem 5 - Eventos do Global.asax

Application_Start – executado somente quando a aplicação é iniciada

Application_End – executado no encerramento da aplicação

Application_Error – executado quando houver erros não tratados pela aplicação

Session_Start – executado quando iniciar a sessão de usuário

Session_End – executado ao encerrar uma sessão, quando o sessionstate estiver configurado como InProc no weeb.config

Variáveis de sessão e aplicação

Podemos armazenar variáveis comuns a todos usuários que acessam nossa aplicação ASP.NET através da instância Application que é um objeto da classe HttpApplicationState. Como esta instância é compartilhada entre todos os usuários usuários o ASP.NET fornece uma maneira de garantir que somente você esteja fazendo alterações, através do método Lock() e do UnLock(). Como estes métodos fazem que outros usuários que desejam acessar a session fiquem travados, use-os com cuidado.

Podemos armazenar variáveis comum a determinado usuário com o uso de sessão, o servidor possibilita o uso de sessão através de configuração, e esta é ativa por padrão. Para usarmos a sessão podemos utilizar o objeto Session que é uma instância da classe HttpSessionState. A Imagem 6 mostra o uso dessas variáveis no Global.asax, o que também é possível em páginas e outras classes da aplicação Web.

Imagem 6 – Uso de Application e Session

Dica: use Application e Session com cuidado e ver quando estamos as utilizando por necessidade ou comodismo.

Se atente ainda ao fato que as sessões expiram com um tempo determinado, o padrão que pode ser alterado são 20 minutos. É importante também lembrar da arquitetura Web, Stateless

A Imagem 6 já dá uma idéia de como começar, mas já pensou em como montar um site onde mostraríamos o nome do usuário e informassemos a quantidade de usuários ativos? Depois de feito, poderíamos abrir vários navegadores e ao acessar o site, ver este contador aumentando, e utilizarmos do método Session.Abandon() para vermos este número diminuindo.

Referências:

http://msdn2.microsoft.com/en-us/library/bb470252.aspx

http://msdn2.microsoft.com/en-us/library/ms178473.aspx

http://wiki.asp.net/page.aspx/274/file-extension/

http://en.wikipedia.org/wiki/ASP.NET

http://wiki.asp.net/page.aspx/246/directory-structure-in-aspnet/

http://msdn2.microsoft.com/pt-br/magazine/cc135973.aspx

http://msdn2.microsoft.com/en-us/library/bb470252.aspx

http://msdn2.microsoft.com/en-us/library/bf9xhdz4(vs.71).aspx

Depurando com o Visual Web developer 2008 Express Edition

Continuando a exploração do ambiente de desenvolvimento integrado Visual Web developer 2008 Express Edition, vamos agora ver outros recursos disponíveis para nos auxiliar no desenvolvimento. Criamos então um novo web site, para isto, e editaremos o design do Default.aspx(Não sabendo fazer isto, releia o post)

Nesta página criaremos controles que permitam ao usuário definir escrever um HTML, visualizá-lo e salvá-lo.

Definindo o layout

Na janela Toolbox, arrastaremos um Label, um TextBox, dois Buttons e outro Label.

Altere as propriedade do primeiro Label, conforme abaixo:

• ID: lblDigiteHTML
• Text : Digite o HTML no campo abaixo:

Altere as propriedades do TextBox conforme abaixo:

• Columns : 60
• ID : txtTexto
• Rows : 10
• TextMode : Multiline

Altere as propriedades do primeiro Button, conforme abaixo:

• ID: btnVisualizar
• Text: Visualizar

Altere as propriedades do segundo Button, conforme abaixo:

· ID: btnSalvar

· Text: Salvar

Altere as propriedade do segundo Label, conforme abaixo:

• ID: lblVisualizacao
• Limpe a propriedade Text

Termine de formatar a página para que esteja conforme a imagem 1:

Imagem 1:

Adicionando eventos

A janela Properties, além de mostrar as propriedades dos controles, mostra também os eventos do elemento ativo, iremos então selecionar o btnVisualizar e clicar no botão para ver seus eventos, conforme imagem 2:

Imagem 2: Eventos do btnVisualizar no properties

Clique duas vezes no evento Click, seremos direcionado ao code behind desta página, neste caso, o Default.aspx.cs, e foi criado um método que é chamado ao disparar o evento selcionado.

Crie um método que será responsável por copiar o texto digitado pelo usuário no txtTexto para o lblVisualizacao. Caso tenha terminado, terá algo parecido com o código da Imagem 3:

Imagem 3 : Código para atualizar o texto no lblVisualizacao

Coloque um breakpoint na linha que copia o texto do txtTexto para o lblVisualizacao. Quando estamos depurando uma aplicação, o breakpoint interrompe a execução do código, no ponto especificado, para que possamos analisar o código e várias informações da execução. Veja o breakpoint definido na Imagem 4.

Imagem 4 - Colocando o breakpoint.jpg

Depurando a aplicação

Feito vamos agora depurar a aplicação: clique no menu Debug / Start Debugging(Ou pressione F5). Será iniciado o ASP.NET Development Server e apresentado a tela da Imagem 5, para configurar o web site para permitir depuração. Clique em Ok.

Imagem 5 – Permitindo a depuração do Web Site

Repare que no web site, na janela Solution Explorer, foi criado o arquivo web.config. Clique duas vezes neste, para visualizar no editor. Este é um arquivo que contêm as configurações do web site no formato XML, depois falaremos mais, por enquanto encontre o elemento pages e adicione neste o atributo validateRequest com o valor false. Caso o elemento não exista, adicione conforme código 1 após o elemento authentication. Veja adicionando o atributo na Imagem 6.

Este atributo é necessário pois iremos enviar um HTML do navegador para o servidor, assim temos que desabilitar esta validação do servidor.

<pages validateRequest="false" />

Código 1:

Imagem 6 - Adicionando o atributo validateRequest

Agora podemos vamos ao navegador que já foi aberto. Neste é possível ver nossa aplicação, digitaremos então um HTML no campo criado para isto e clicaremos no botão Visualizar.

Repare que o código foi interrompido no breakpoint, vamos aproveitar para conhecer as ferramentas e janelas disponíveis de depuração.

Janelas para Depurar

Call Stack

Esta janela tem o empilhamento da chamada, ou seja, você pode ver o método atual no topo da lista de métodos e seus chamadores abaixo. Neste caso o método AtualizarTextoVisualizacao foi chamado pelo método btnVisualizar_Click conforme Imagem 7

Imagem 7 : Call Stack

Watch

Nesta janela podemos definir as variáveis que desejamos visualizar, seja arrastando-as, ou digitando na coluna Name. Define as variáveis que desejamos visualizar conforme Imagem 8

Imagem 8 : Watch

Debug toolbar

A barra de ferramentas de depuração está visível na parte superior da IDE e com ela podemos controlar o fluxo de execução, veja na Imagem 9. São as mesmas opções disponíveis no menu Debug.

Imagem 9 - Debug toolbar

O nome do botão, seu atalho e o que faz é mostrado abaixo, na sequência em que aparecem:

• Continue(F5) – Cotinua a execução, após o break point
• Pause – Se o código estiver em execução, para na parte do código depurável e permite a depuração
• Stop Debugging(Shift + F5) – Interrompe a depuração
• Restart(Ctrl + Shift + F5) – Reinicia a aplicação e a depuração
• Show Next Statement – Foca na linha de código da execução
• Step into(F11) – Entra dentro do método ou código para depurá-lo
• Step over(F10) – Vai para a próxima linha de execução, se a linha atual for uma função, não entra na mesma
• Step out(Shift + F11) – Sai do método atual e vai para o método o que chamou

Clique no Step out, veja que as variáveis são atualizar na janela Watch. Após isto, interrompa a depuração, Stop Debugging, e vamos escrever o salvar.

Programe o click do btnSalvar para atualizar o texto na visualização e salvar o conteúdo do txtTexto em um arquivo em disco do servidor, na raiz do site, chamado TextoUsuario.htm. Depois de feito seu código ficará parecido com o código da Imagem 10.

Imagem 10 – Default.aspx.cs

O código pega o diretório raiz do site, e cria um arquivo texto. Adiciona texto ao arquivo dentro de um try finally, para garantir que o arquivo sempre será fechado. Se quisermos ainda saber sobre algum método ou classe, basta posicionarmos o cursor neste e pressionar F1 que será aberto o help do item selecionado.

Execute o código sem depurar, através do menu Debug / Start Without Debugging. Digite um texto e clique em salvar. Feito isto, vá no solution explorer, clique no botão refresh e veja que o novo arquivo agora é listado, conforme imagem 11.

Imagem 11 – Atualizando o Solution Explorer

O nome é importante

Podemos até achar que não, mas o nome é importante. Desde comprimentar aquela pessoa que encontramos frequentemente falando seu nome até definir O nome para o que desenvolvemos.

O Básico

Quando vamos programar, ainda mais no começo de nossa vida de desenvolvedor, podemos estar tão ansiosos em utilizar a coleção genérica, ou o LINQ que acabamos de aprender, que esquecemos de dar importância a alguns pontos básicos. Dentre os que podem ser deixados para traz, está o nome do que escrevemos.

Para enfatizar isto ainda mais, uma das características de um código bem escrito é ser fácil de entender. Se expressamos nossa idéia, por exemplo escrevendo um método, e ninguém o entende. Ou somos muito inteligentes ou achamos que somos muito inteligentes. A tendência é cairmos no segundo caso. Uma das coisas mais importantes de um método é seu nome.

A idéia é que com um nome consigamos:
• Deixar suficientemente explicativo ao ler
• Definir de forma clara a competência do método(O que ele faz e o que não faz)
• Ser consistente

Antigamente, algumas linguagens tinham limites de tamanho para nomes. Vamos supor que nós tivessemos 8 caracteres para definir nomes, realmente isto seria um dificultador. Por exemplo, se eu desejar criar um método que retorne a data de vencimento da última prestação de um financiamento, teria certa dificuldade:

public DateTime GeVeUlPr

Hoje em dia, linguagens modernas como o C#, permitem escrever nomes com certa liberdade. No caso do C#, estes nomes não podem ser maiores que 512 caracteres(Você já precisou de mais?). Poderíamos então usar o nome assim:

public DateTime GetVencimentoUltimaPrestacao

Tendo um nome bem definido nos ajuda a achar este método para uma posterior reutilização, e principalmente no momento de escrever seu corpo, estaríamos direcionados a resolver o problema a que ele se propõe, nada mais e nada a menos.

Se você ainda não está convencido, imagine que neste sistema de financiamento tenhamos estas variáveis

DateTime DtVen;
DateTime DtPag;
DateTime DtCan;
DateTime DtJur;
Decimal Val;
Decimal JurDi;
Decimal ValCJur;
Bool ParAtr;

Você sabe intuir sobre o que elas armazenam? Talvez sim, mas escrevendo da forma abaixo, seria no mínimo mais fácil imaginar o que elas armazenam:
DateTime DataVencimento;
DateTime DataPagamento;
DateTime DataCancelamento;
DateTime DataJuros;
Decimal Valor;
Decimal JurosDiario;
Decimal ValorComJuros;
Bool ParcelaAtrasada.

Para finalizar, é importante o parâmetro ser consistente, quero dizer que se eu criei a variável acima ParcelaAtrasada, eu não poderia reutilizá-la para outra coisa, por exemplo para armazenar que a parcela foi paga. Depois de alguns dias, nem você lembraria disso. É interessante criarmos outra variável para isso, ou até pensar em armazenar estas informações de outra forma, quem sabe um enumerado?

Com esta idéia de bom senso acima, já estaremos muito bem encaminhados para um código bem escrito, mas existe algo a mais...

Referência:
(Caso alguém tenha sugestão de alguma referência, de algum livro que trate do tema acima, ficarei grato para me embasar não somente em experiência)

Naming Convention

A convenção para nomeação é utilizar padrões para nomear o que se desenvolve, esta parte talvez seja mais metódica, mas faz sentido. Como o C# é uma linguagem Case Sensitive, escrever com o padrão ajuda a achar e utilizar toda a Framework .net. Não seria interessante seguir o padrão e ter a mesma facilidade para achar o nosso código?

Abaixo segue alguns links sobre a convenção de nomes utilizada pela microsoft:
http://msdn2.microsoft.com/en-us/library/xzf533w0(VS.71).aspx
http://msdn2.microsoft.com/en-us/library/ta31s3bc(VS.71).aspx

Liberando o fonte

Condificamos, testamos e está funcionando. Agora é só ficar livre disto e acabou, certo? Claro que não, agora é a hora de revermos o que acabamos de escrever. Não muito diferente da escola, quando revíamos o texto para entregar para professora. Não gostava da professora? Tudo bem, é a mesma coisa de rever a carta da surpresa para a namorada. Nunca releu? Nem no dia dos namorados?

Nos limitando a resolver nosso código, a idéia é rever o texto, ver se os métodos estão bem definidos, bons nomes e atuar no sentido de deixar o código ainda mais claro. Pense que você quem pode dar manutenção nisso daqui a alguns meses e poderá se orgulhar ou não do que encontrar. E temos até ferramenta para nos ajudar no trabalho manual, podemos usar um recurso do Visual Studio que é o Refactor.

O Refactor

Escreveu um nome e não gostou? Quer mudar? O Visual Studio nos ajuda, use o refactor:
http://msdn2.microsoft.com/en-us/library/ms379618(VS.80).aspx

Visual Web developer 2008 Express Edition

O Visual Web Developer 2008 Express Edition é a versão grátis do ambiente de desenvolvimento integrado da Microsoft para o desenvolvimento de aplicações utilizando ASP.NET 3.5.

Baixar e instalar

Para utilizá-la:
1. Baixe a versão http://www.microsoft.com/express/download/;
2. Instale em sua máquina, desde que atenda os seguintes requisitos:

Arquitetura suportada

· x86
· x64
Sistemas Operacionais
· Microsoft Windows XP
· Microsoft Windows Server 2003
· Windows Vista
Hardware requerido
· Mínimo: 1.6 GHz CPU, 192 MB RAM, 1024x768 display, 5400 RPM hard disk space
· Recomendado: 2.2 GHz CPU ou maior, 384 MB ou mais, 1280x1024 display, 7200 RPM or higher
· Windows Vista: 2.4 GHz CPU, 768 MB RAM 1.3 GB de espaço disponível para instalção completa

Caso você tenha alguma dúvida, pode frequentar a página de FAQ:
http://www.microsoft.com/express/support/faq/

Geral sobre o ambiente

Ao abrir o Visual Web developer 2008 Express Edition será mostrado a Start Page(página inicial), conforme imagem 1.

Imagem 1 : Visual Web developer 2008 Express Edition Start Page

As opção aqui são:
Recent Projects
Neste estão listados todos os projetos abertos recentemente, é possível abri-lo ao clicar neste.

Getting Started
Aqui estão disponíveis links com informações e tutoriais para se iniciar no uso do Visual Web developer 2008 Express Edition.

MSDN: Visual Web developer Express EditionDisponível diversos links com as últimas novidades.

Vamos criar um novo web site para explorar os recursos da IDE. No menu File/New Web Site, nos será mostrado a tela da imagem 2.

Imagem 2 : Tela para criar um novo web site.

Aqui há diferentes tipos de aplicações que podemos criar, ASP.NET é a que vamos nos ater e utilizar por agora. Na seleção de Location, podemos escolher os diferentes tipos de localização: File System, Http e Ftp. Selecionamos File System e especificamos um caminho e nome de projeto na próxima caixa de texto. Na seleção Language, podemos escolher entre as linguagens Visual Basic e C#, selecionamos C#. Clicamos em OK.

Será aberto o projeto criado conforme imagem 3:

Image 3 : Projeto criado

Janela de edição

Neste projeto já é criado a página Default.aspx. Já podemos visualizar, na janela de edição, o código ASPX e HTML desta página. Conforme imagem 4, estamos visualizando o fonte desta página(Source), ainda podemos trocar para desenhar visualmente(Design) e a visualização dividida, onde é mostrado os dois anteriores(Split).

Imagem 4 : Tipo de visualizações ASPX.

Solution Explorer(Explorar solução)

Há também a janela solution explorer, imagem 5, que permite explorar nossa solução, onde é listado todos os arquivos que fazem parte de nossa solução, se clicarmos duas vezes em um arquivo visualizamos o arquivo no editor.
Imagem 5: Solution Explorer

Clicando com o botão direito no web site, temos várias opções, podemos montar o site, adicionar novos arquivos e existentes, e criar diretórios e muito mais, veja na imagem 6.

Imagem 6 : Clicando com o botão direito na solução

Properties(Janela de propriedade)

Esta janela mostra as propriedades disponíveis, de acordo com o elemento ativo. Neste caso, como havia clicado no web site, estou visualizando e podendo editar as propriedades pertinentes a este, conforme imagem 7. Como a propriedade Virtual path está selecionada, ainda podemos ver uma descrição da propriedade na parte inferior da janela.

Esta janela mostra diferentes propriedades de acordo com o elemento selecionado.

Imagem 7: Janela de propriedades

Existem propriedades que podem somente ser visualizadas, outras editadas alterando valores no próprio editor e outras que mostram uma janela de edição da propriedade. Para demonstrar, selecionamos o elemento DIV na nossa janela de edição, imagem 8, e posteriormente sua propriedade Style, imagem 9. Nos será mostrado um botão com texto “...”, que ao clicado será aberta a janela de edição da propriedade, imagem 10.


Imagem 8 - Selecionando o elemento DIV

Imagem 9 - Propriedade Style

Imagem 10 - Janela de edição da propriedade Style

Estas janelas nos auxiliam no preenchimento da propriedade do controle. Neste caso, temos acesso a várias propriedades de estilo do controle de forma visual

Janelas não visíveis

Caso uma janela não esteja visível, podemos abrí-la através do menu View ou Debug Windows. Veremos a janela Ferramentas clicando no menu View/Toolbox

Janela Ferramentas

Como o nome diz, a janela ferramentas mostra as ferramentas disponíveis, mas estas podem variar de acordo com o item selecionado na janela de edição. Neste caso, selecionamos o Default.aspx, desta forma veremos controles e componentes possíveis de utilizar nesta página.

Arrastaremos um label para a página e alteraremos as seguintes propriedades:
Text para “Conhecendo o Visual Web developer 2008 Express Edition”, edite seu estilo;
Expandiremos a propriedade Font e iremos definir as propriedades:
Bold para True;
Size para Large;
Agora para a propriedade ForeColor, selecionaremos na janela de edição da propriedade a cor azul;

Editando o código C#

Na janela Solution Explorer clicamos duas vezes no arquivo Default.aspx.cs, se este não estiver visível expanda o arquivo Default.aspx. Aberto o arquivo Default.aspx.cs podemos reparar que este é uma classe, que descende de System.Web.UI.Page e já está com o método Page_Load criado. Neste método, adicionaremos o código conforme imagem 11:

Imagem 11 - Editando o code behind

O ASP.NET usado desta forma, com dois arquivos, permite uma separação de código(Default.aspx.cs) e de desenho(Default.aspx). Assim podemos ter numa equipe designers e desenvolvedores trabalhando de forma conjunta e evitando que ao fazer atualizações pertinentes ao seu contexto, seja desenhando ou programando, atrapalhe o trabalho do outro.

Executando o código

Iremos então executar o código para ver o resultado. Para isto vá no menu Debug/Start Without Debug. Será aberto o ASP.NET Development Server, iremos falar dele mais tarde, e o navegador mostrando a página criada.

Será mostrado uma mensagem javascript e clicamos em OK.

O ASPX gera código HTML

Ainda no navegador, visualize o código fonte da página que acabamos de criar. Para isto, se você estiver utilizando o Internet Explorer, clique com o botão direito e vá em Exibir Código fonte. A imagem 12 mostra o código fonte:


Imagem 12: ASPX gera código HTML
Repare que tudo que criamos gerou um HTML! Não importa as diferentes propriedades que você defina, os diferentes controles, no final, tudo será gerado como HTML. Por isto é muito importante para que você, que deseja ser um bom desenvolvedor Web, domine o uso do HTML.

Referências:
http://msdn2.microsoft.com/en-us/beginner/bb964635.aspx
http://www.microsoft.com/express/vwd/

Caso queira ver algumas dicas sobre este ambiente de desenvolvimento:
http://weblogs.asp.net/scottgu/archive/2007/07/28/nice-vs-2008-code-editing-improvements.aspx
http://vincenthomedev.wordpress.com/2007/08/09/vs-2008-ide/

Evoluções do ASP.NET

O ASP.Net, atualmente na versão 3.5 vem evoluindo desde 2002, quando publicado sua primeira versão 1.0. Há ainda a versão ASP, sua predescessora, mas as mudanças foram tão grandes, que o comum poderia ser: a opção da Microsoft para desenvolvimento Web, cada uma em sua época.

ASP.Net 1.0 – 13/02/2002
Introdução a plataforma de desenvolvimento .Net e para aplicações Web o ASP.NET. Apesar de 1.0 é uma plataforma extremamente robusta e bem definida.
Suas inovações foram soluções para problemas já vividos como a divisão em dois arquivos por página, um definindo o layout da página e outro o código(code behind).
A compilação para linguagem intermediária(MSIL) e a utilização da framework para prover diversas classes e seus serviços para o desenvolvimento, que continuaram nas versões posteriores da framework.
Vários controles para facilitar o desenvolvimento, como os Validators, que permitem validar o conteúdo inserido pelos usuários.

ASP.Net 1.1 – 03/04/2003
Praticamente não houve grandes mudanças em relação à versão 1.0. Correção de alguns bugs e melhorias.

ASP.Net 2.0 – 22/01/2006
As definições da plataforma até agora foram bem acertadas, mas esta versão trouxe grandes mudanças para o desenvolvimento. O acesso a dados passou a ser feito através dos componentes DataSources. Existem DataSources especialistas para cada diversas fontes de dados, dentre eles:

• XML - XMLDataSource
• Base de dados - SqlDataSource
• Objetos - ObjectDataSource.
• Representa uma camada intermediária para recuperar e atualizar objetos. Este é flexível para permitir o acesso a diferentes arquiteturas e usar na parte ASP.Net os controles de forma transparente.

Houve a introdução ao que foi chamado Two-way data binding. Os dados eram lidos e poderiam ser salvos(http://msdn2.microsoft.com/en-us/magazine/cc163505.aspx).

O controle DataGrid foi substituído pelo GridView. Este para mostrar vários registros, por exemplo, várias linhas de uma consulta da base de dados.

O controle FormView foi introduzido, para possibilitar a visualização, edição e exclusão de registro. O Controle DetailView, similar ao FormView, mostra dados de forma tabular, ou seja, de forma menos flexível que o FormView.

Introdução ao Master Page, themas e skins, que permitem uma padronização e melhor organização do layout da aplicação.

.Net framework 3.0 – 21/11/2006
Esta não trouxe uma versão para o ASP.Net, mas trouxe novas tecnologias para a framework como:

Windows Presentation Foundation(WPF)
http://msdn2.microsoft.com/en-us/netframework/aa663326.aspx

Windows Workflow Foundation(WF)
http://msdn2.microsoft.com/en-us/netframework/aa663328.aspx

Windows Communication Fundation(WCF) - code-named Indigo http://msdn2.microsoft.com/en-us/netframework/aa663324.aspx

ASP.NET AJAX - 23/01/2007 - code-named Atlas
O Ajax(Asynchronous Javascript And XML) trouxe uma maior interatividade para as aplicações Web, diminuindo a quantidade de refreshs no cliente(navegador) através da utilização de Javascript, XML e XMLHttpRequest para buscar informações no servidor.

O Ajax não é uma tecnologia, mas um nome comercial para o conjunto de tecnologias. A principal delas, se é que podemos definir alguma como principal, é o XMLHttpRequest, originalmente desenvolvido pela Microsoft para o Outlookup Web Access 2000.

Um dos grandes responsáveis pela popularização do AJAX foi o Gmail(01/04/2004), hoje em dia praticamente todo web mail utiliza-se de AJAX.

O ASP.net AJAX é a biblioteca da Microsoft para utilização de AJAX com o ASP.NET 2.0 ou 3.5.
http://asp.net/ajax/

ASP.Net 3.5 – 19/11/2007
Esta versão adiciona novas funcionalidades ao ASP.NET 2.0, ou seja, as funcionalidades e controles do ASP.NET 2.0 foram todos mantidos.

Mas houve novidades, como os controles:
ListView
Permite mostrar dados utilizando templates(modelos), permitindo uma grande flexibilidade
http://www.asp.net/learn/3.5-videos/video-225.aspx

DataPage
Permite a paginação controles que são Data-Bound, como o ListView
http://www.asp.net/learn/3.5-videos/video-221.aspx

E a principal novidade, que é o Linq, uma linguagem para query em objetos, que podem estar na memória ou na base de dados. Isto só é possível graças ao mapeamento objeto relacional. Caso queira ver um vídeo disto:
http://www.asp.net/learn/videos/video-232.aspx

O Java disponibiliza funcionalidades equivalentes, como o TopLink e o Hibernate.

E depois:
Há também o Silverlight, para o desenvolvimento de aplicações RIA(Rich Internet Application). É um plugin de browser, assim como o Adobe Flash, atualmente está no desenvolvimento de sua versão 2.0.

Ufa! É isto, muita informação, mas somente para termos uma idéia de onde estamos.

Desenvolvendo aplicações WEB?

De HTML, CSS, Javascript e AJAX até tecnologias de servidor como o ASP.Net ou Java de tudo é possível achar na Internet.

Apesar das evoluções e revoluções, estas têm uma sequência lógica, de problemas e soluções, que mesmo para quem trabalha a muito com as tecnologias ou chegou agora, pode se perder ou não achar o embasamento necessário para adotar uma solução...

A idéia deste blog é divulgar algumas pesquisas de tecnologias WEB, simplificar e principalmente mostrar que as idéias boas são as simples e fáceis de entender e fazer-se entender.