1. Introdução ao ASP.NET - Cadastro Número da Sorte

Transcrição

ASP.NET 3.5 em VB.NET e C#
Copyright©2008, Fernando Amaral. Todos os direitos reservados. Este documento é
protegidos por direitos autorais e outros direitos de propriedade intelectual;
Este documento é de distribuição gratuita para uso pessoal. É vedada qualquer outra
forma de utilização, divulgação, publicação, distribuição etc. sem autorização do autor.
Sobre o Autor
Fernando Amaral trabalha a mais de 10 anos com o desenvolvimento de software. É
certificado Microsoft MCP, MCAD, MCSD, MCDBA e MCT, Comptia CDIA+,
Project Managment Institute PMP. É Pós Graduado em Gestão de Sistemas de
Informação pela Uniderp e em Melhoria de Processo de Software pela UFLA. Além
disso tudo é Ateu. Atualmente reside em Campo Grande MS.
Sobre www.fernandoamaral.com.br
Eu mantenho um site com alguns artigos e tutoriais de tecnologia no endereço
www.fernandoamaral.com.br. Através do site existe um formulário onde posso ser
contatado.
Sobre ASP.NET 3.5 em VB.NET e C#
Existe muito conteúdo para quem quer aprender ASP.NET. Existem centenas de bons
livros. Porém este curso em formato digital traz algumas características que talvez você
não encontre em nenhum lugar:
É completo no sentido que abrange todos os principais temas relacionados ao
ASP.NET 3.5;
Segue uma seqüência lógica. Você não precisará ficar garimpando informações
em lugares diferentes;
É em português.
Porque não um Livro?
Este curso foi criado dentro de minhas possibilidades, de maneira que não precisei
assumir nenhum compromisso.
1. Introdução ao ASP.NET.................................................... 7
2. Visual Studio 2008: O ambiente e as linguagens............. 13
3. Web Forms....................................................................... 31
4. Controle............................................................................ 33
5. Master Page...................................................................... 44
6. Themes e Skins................................................................. 53
7. Navigation........................................................................ 59
8. WebParts.......................................................................... 71
10 LINQ .............................................................................. 116
11. MemberShip e Roles ..................................................... 119
12 .Manutenção de Estado................................................... 153
13 . ASP.NET AJAX ........................................................... 167
14. Criando e Consumindo WebServices ............................ 179
15. Criando uma página de erros personalizada................... 188
16. Eventos da aplicação...................................................... 191
17. Distribuindo sua Aplicação ........................................... 193
18. Relatórios com Crystal Report ...................................... 202
1. Introdução ao ASP.NET
Desenvolver aplicações nunca foi tão fácil. Ambientes RAD cada vez mais modernos e
amigáveis tem tornado o trabalho dos arquitetos de software cada vez mais simples.
Com o versão 3.5 do ASP.NET, conseguiu-se atingir níveis de produtividade nunca
antes imaginados.
Este curso tem por objetivo introduzir o desenvolvedor no mundo do desenvolvimento
de aplicações Web utilizando o ASP.NET 3.5. Não é um curso introdutório de lógica de
programação.
Os exemplos ao longo do curso serão todos demonstrados em VB.NET e C#.
Blocos de código serão precedidos pelo ícone da linguagem utilizada:
para código em VB
para código em C#
O que é o Microsoft .NET FrameWork?
Tradicionalmente o desenvolvedor escreve Software para um sistema Operacional ou
dispositivo especifico. Por exemplo, ao criar um programa no Delphi 7 ou no Visual
Basic 6, ele esta criado um Software para rodar em Sistemas Operacionais Windows
sobre a plataforma Intel.
Ao desenvolver um software para o .NET, o desenvolvedor ao invés disto esta fazendo
um software para rodar em qualquer dispositivo ou plataforma que tenha o .NET
Framework instalado.
Existem dezenas de linguagem que podem ser usadas para criar um programa .NET, a
Microsoft desenvolveu o VB.NET, uma versão Orientada a Objetos do clássico VB e o
C#, que herdou sua sintaxe do C++. Outras empresas desenvolveram outras: COBOL,
Delphi, Fortran etc. só para citar algumas. Você mesmo pode criar sua própria
linguagem. A escolha entre uma linguagem ou outra é apenas uma questão de sintaxe.
6
Copyright©2008, Fernando Amaral. Todos os direitos reservados. Este documento é protegidos por direitos autorais e
outros direitos de propriedade intelectual. www.fernandoamaral.com.br
Isto é possível porque um programa escrito para .NET é compilado em uma linguagem
intermediaria chamada MSIL (Microsoft Intermediate Language). Não importa qual
linguagem em que você codificou, o resultado, em termos de performance, qualidade,
tamanho dos binários etc. será o mesmo. O arquivo compilado em MSIL normalmente
resulta um uma DLL, denominada assembly.
Quando o programa for executado pela primeira vez, entre em cena o JIT (Just In Time
Compiler), que vai fazer uma nova compilação do programa, desta vez de acordo com
as especificações do sistema operacional e do dispositivo em que o .NET Framework se
encontra.
Desenvolver um sistema para o plataforma .NET, traz mais alugmas vantagens além de
das ficaram óbvias nesta introdução. A mais importante é que o seu programa vai rodar
em um ambiente protegido e especifico, sem ter que se preocupar com as especificações
ou problemas do sistema operacinal. Toda a interação com este, como por exemplo, o
gerencimento de memória, é feita pelo .NET.
ASP.NET 1.X
Nos ultimos anos surgiram fantásticas IDEs para desenvolvimento de aplicações
Windows. Algumas permitiam que você abrisse uma tabela qualquer, permitindo ainda
a sua edição, sem sequer escrever uma linha de código. Outras através de assistentes
automatizavam tarefas poupando tempo e muitas dores de cabeça. Surgiram ainda
diversas ferramentas que prometiam a criação de aplicativos inteiros sem a necessidade
de escrever uma linha de código qualquer.
Porem não podemos dizer o mesmo para as aplicações Web. Além algumas frustadas
tentativas, não existiu nenhum ambiente de alta produtividade como existiam para
aplicações convencionais. As linguagens, principalmente o ASP classico, semelhante ao
Visual Basic, era limitada é sem os recusos de linguagens OO.
Ao planejar o .NET, a Microsoft vislumbrou um ambiente para aplicações Web onde se
pudesse desenvolver aplicações no mesmo ambiente e com as mesmas facilidades de
aplicações convencionais, utilizando a mesma linguagem.
7
O ASP.NET foi o primeiro ambiente que permitiu que se desenvolvessem
aplicações convencionais ou para Web em uma mesma IDE, utilizando a
mesma linguagem.
Promessa cumprida: O .NET 1.x junto com o Visual Studio 2002 / 2003 proporcionou
um ambiente para aplicações WEB, totalmente integrado, com as facilidades só antes
vistas em ambientes de aplicações convencionais: WYSIWYG,
Drag and Drop,
Intellisense, recursos de depuração avançados etc. Já era possivel exibir uma tabela
numa aplicação WEB com duas linhas de código, e sem escrever uma Tag HTML
sequer!
Normalmente você não precisa ser um profundo conhecedor de HTML para
desenvover uma aplicação Web no VS 2005. Porém um conhecimento básico
é recomandado: sempre há necessidade de algum ajuste manual.
ASP.NET 2.0
Não há duvidas que a plataforma .NET 1.x e o ASP.NET 1.x mudaram a maneira como
as aplições Web são desenvolvidas. Porém a equipe de desenvolvimento da plataforma
percebeu que muito ainda poderia ser feito, principalmente no que diz respeito a
produtividade,
e esse foi o objetivo principal da equipe de durante seu
desenvolvimento. Como resultado, houve uma melhora de produtividade em até 70% !
Vejamos algumas das melhorias do ASP.NET 2.0 em relação ao seu antecessor:
Mais de 50 novos Server Controls
Novas ferramentas adiminstrativas
Nova IDE do Visual Studio 2005
Site Navigation: Controles que facilitam a navegação em Web Sites
Master Pages: Agora é possível utilizar herança visual em aplicações Web, o que
na versão 1.x só era possivel com aplicações Windows Forms.
Themes: Tornam mais facil o gerenciamento do visual de sua aplicação
Acesso
a
Dados:
O
ADO.NET
embora
extramente
eficiente,
era
demasiadamente complexo. O Acesso a dados foi reformulado e simplificado.
Snippets: Partes de códigos especificas que podem ser armazenadas para
utilização futura.
8
ASP.NET 3.5
As mudanças do ASP.NET 2.0 e 3.5 foram poucas, porém significativas. Na verdade o
core engine das duas versões continua o mesmo. Para projetos em ASP.NET 3.5 o
ASP.NET AJAX Extensions passou a estar integrado a IDE do Visual Studio, não é
mais necessário baixar e instalar separadamente. É encontrado no assemblie
System.Web.Extensions.dll.
Outra grande novidade, já há bastante esperada é o LINQ. A Gap que existe entre dados
relacionais e objetos já não é um assunto novo, já recebendo inclusive artigos meus. Já
postei também alguns artigos técnicos sobre LLBLGen e NHibernate. Agora o .NET
avança nesse sentido com o LINQ. O LINQ não é nenhuma novidade, porém agora é
integrado ao Visual Studio. A idéia do LINQ também não é nova, com esta tecnologia
você pode operar o banco de dados em uma linguagem nativa, como se tivesse gerando
código
VB.NET
ou
C#.
É
encontrado
nos
assemblies
System.Core.dll,
System.Data.Linq.dll, System.Xml.Linq.dll e System.Data.DataSetExtensions.dll.
Também há controles novos. Além dos controles Ajax Extensions que na versão
anterior deviam ser instalados separadamente, existem mais três novos controles:
ListView, DataPager e LinqDataSource. O Listview é um controle de exibição de dados
tabulares, semelhante ao Datagrid e GridView, porém com novas funcionalidades e
maior controle sobre o resultado produzido. DataPager é um controle que prove
paginação de dados ao Listview. LinqDataSource é mais um controle de acesso a dados,
como ObjectDataSource e o SQLDataSource, porém utilizando o modelo LINQ descrito
em sessão anterior.
Estrutura de uma aplicação ASP.NET 2.0 e 3.5
Nesta sessão apresento algumas considerações sobre o estrutura de aplicações ASP.NET
2.0 e 3.5, que como dito em seção anterior, permaneceram inalterados.
Você já percebeu que muita coisa mudou entre o ASP.NET 1.x e seu predecessor. Uma
das grandes propagandas no lançamento da primeira versão do ASP.NET era o modelo
code-behind, onde apresentação e código de servidor ficam armazenados em arquivos
9
fisicamente separados, tornando o código mais limpo e intuitivo tanto para o designer
quanto para o programador. Trabalhar com tudo em um único arquivo até era possível,
porém desvantajoso.
No ASP.NET 3.5, embora o padrão seja um arquivo único, pode-se facilmente optar em
trabalhar com arquivos separados, basta desmarcar a opção place code in separated file
na caixa de dialogo de criação de um novo Web Form:
Este novo modelo é denominado code-inline. Se você optar por trabalhar com este
modelo, seu código de servidor vai estar separado entre tags Script. O grande problema
na versão 1.x era que trabalhando com um único arquivo perdíamos alguns recursos
poderosos de programação, como o Intellisense. Na versão 2.0 e 3.5 não há qualquer
problema: tudo que funciona no modelo code-behind funciona também no code-inline.
Post-Back entre páginas
Até o.NET 1.x um controle só poderia causar um post back para a própria página. Agora
esta limitação acabou, através da propriedade PostBackUrl, presente no botão de
comando e similares, que permite que seja executa um postback para outra pagina Asp.
Este novo recurso é conhecido como Cross-Page Posting.
10
Agora é possível inclusive ler valores de controles ou propriedades de páginas que
deram origem ao postback. Esta fantástica inovação surgida no ASP.NET 2.0 permite
tornar o código mais limpo, mas otimizado, além de reduzir a necessidade de utilização
de variáveis de sessão, querystring e outros.
Pastas
A partir da versão 2.0 o ASP.NET uma aplicação Web deixou de ser orientada a projeto
e passou a ser orientada a arquivos. Em conseqüência foram definidas uma série de
pastas com funções especificas, vamos ver as principais:
App_Code: Para armazenamento de classes
App_data: Armazena fontes de dados
App_Themes: Armazena um tema. Estudaremos temas mais adiante.
App_LocalResources: Armazena arquivos de recursos
Arquivos
Nesta sessão vamos ver os principais tipos de arquivos que uma aplicação ASP.NET
pode conter:
Web.config: è um arquivo contendo as configurações da aplicação, formatado
com XML.
.aspx: arquivo contendo a apresentação de uma página.
.vb ou .cs: arquivo com código de servidor relacionado a uma página
Global.aspx: Arquivo contendo os eventos globais da aplicação.
.master: Arquivo contendo uma MasterPage.
.ascx: Arquivo contendo um WebUserControl
.css: Arquivo css
.resx: Arquivo de recursos
.sitemap: Arquivo contendo um mapa do site
.skin: Arquivo contendo um skin
11
2. Visual Studio 2008: O ambiente e as linguagens
Nesta seção vamos ver os principais compontentes da IDE do VS 2008.
A esquerda, por padrão oculta, existe a Barra de Ferramentas, onde ficam agrupados por
categoria os compontes padrão do VS ou de terceiros instalados no ambiente. Para
instalar um novo componente, basta clicar com o botão direito sobre a barra e selecionar
Choose Itens. Você pode também personalizar a sua barra de ferramentas da maneira
que achar melhor.
A direita temos o Solution Explorer, que permite uma navegação rápida entre os
arquivos de um projeto ou solução.
Abaixo, a janela de propriedades, permite configurar as propriedades de um controle ou
de um formulário, bem como acessar eventos.
Entre as principais novidades do ambiente temos as notificações de status da linha
através de cores: Uma nova linha de código ou código alterado é marcado como
amarelo. Se a linha já foi salva sua cor muda para verde.
12
Outra novidade são os Snippets: pedaços de código pré fabricados para executar uma
tarefa especifica. Tudo bem que isso não é uma grande novidade e já foi utilizada em
outras IDEs por aí a fora, mas com certeza o recurso esta melhor do que nunca e poderá
lhe ajudar a poupar bastante trabalho. Para inserir um Snippet basta chama-lo no menu
rápido sobre a área de código. Obviamente que você também poderá criar seus proprios
snippets.
SINTAXE: VISUAL BASIC .NET e C#
Vamos introduzir os principais aspectos d a sintaxe de programação do VB.NET e do
C#. Este não será um estudo completo ou abrangente, para tal procure bibliografia
específica.
Lembre-se sempre que o C# diferencia entre caracteres maisculos e
minusculos, o VB.NET não.
Você já deve ter encontrado discussões ardentes na internet sobre C# ser
melhor que VB.NET e vice-versa. A verdade que conhecendo os
fundamentos da plataforma sabemos que o resultado é exatamente igual.
Comentários
No C# comentário de linha são feitos com duas barras. Comentários em bloco são
aberto com \* e fechados com *\.
No VB.NET Comentários são inseridos com aspas simples no inicio da linha. O
VB.NET não permite o comentário de blocos de código, a solução é comentar linha a
linha. Porém o Visual Studio possui em sua barra de ferramentas padrão o comando
Comment out the selected lines que comenta um bloco de código selecionado e
Uncomment the selected lines que remove os comentários, a utilização é simples e
intuitiva, e funcina em ambas as linguagens
este é um comentário válido
Dim i as Integer esta também é um comentário válido
//este é um comentário válido
int x = 3;
/* este também é
um comentário válido */
13
Você ainda pode criar comentários no VB.NET utilizando Rem.
No Visual Studio 2008 também é possível documentas seu código sem a necessidade de
instalar qualquer plug-in, basta adcionar três aspas (vb.net) ou tres barras (C#) antes do
procedimento. O VS automaticamente preenche o esqueleto do documento. Observe o
exemplo abaixo:
''' <summary>
''' Função para somar dois números
''' </summary>
''' <param name="x">Primeiro número a somar</param>
''' <param name="y">Segundo número a somar</param>
''' <returns>Resultado da soma</returns>
''' <remarks>By Fulano</remarks>
Public Function Somar(ByVal x As Integer, ByVal y As Integer) _
As Integer
Dim z As Integer
z = x + y
Return z
End Function
///
///
///
///
///
///
int
{
<summary>
Função para somar dois números
</summary>
<param name="x">Primeiro número a somar</param>
<param name="y">Segundo número a somar</param>
<returns>Resultado da soma</returns>
Somar(int x, int y)
int z;
z = x + y;
return z;
}
O VS ainda pode gerar um diagrama de sua classe, basta clicar com o botão direito
sobre o arquivo, e selecionar View Class Diagram
Tipos de Dados
Sendo o .NET um framework, não existem tipos de dados desta ou daquela linguagem.
Os tipos são todos do .NET. Obviamente que existem diferenças de sintaxe na
declaração e manipulação destas variaveis. Abaixo segue uma relação dos principais
tipos de dados, para uma relação completa consulte a documentação do VS 2008:
14
Boolean Verdadeiro ou falso
Char - caractere unicode de 16 bit
String - String
Byte inteiro de 8 bit, sem sinal
UInt16 - inteiro de 16 bit, sem sinal
Int16 inteiro de 16 bit, com sinal
Int32 - inteiro de 32 bit, com sinal
Int64 - inteiro de 64 bit, com sinal
SByte - - inteiro de 8 bit, com sinal
DateTime
data e hora
Decimal número decimal
Double
número de ponto flutuante com 64 bit
Single - número de ponto flutuante com 32 bit
Um valor nulo em VB.NET é representado por NOTHING, em C# por null.
O tipo Int32 pode ser representado no VB.NET por Integer e int no C#.
Operadores
VB.NET
And
Or
XOr
Not
Is Nothing
<>
&
\
\=
Mod
=
C#
&
|
^
!
== null
!=
+
/
/=
%
==
15
Variaveis e Constantes
No VB.NET para declarar uma variável usamos a palavra DIM, seguido pelo nome da
variável e tipo:
Dim i as Integer
A sintaxe do C# é semelhante ao do C++:
int z;
Podemos ainda declara diversas variaveis de um mesmo tipo numa unica declaração:
Dim i,j,k as Integer
int x, y, z;
Ou ainda variaveis de diferentes tipos:
Dim i,m as Integer, j,k as Single
int i, m; Double j,k;
Obviamente i e m serão do tipo inteiro, e j e K do tipo single.
É possível ainda incializar a variável na sua declaração:
Dim i as Integer = 1
int z = 1;
Para declarar uma constante utilizamos a declaração Const:
Const x as integer = 1
16
const int x = 1;
Enumeradores
Para declarar um enumerador usamos a declaração Enum
Public Enum Semana
Domingo
Segunda
Terça
Quarta
Quinta
Sexta
Sabado
End Enum
enum Semana { Domingo, Segunda, Terça, Quarta, Quinta, Sexta, Sabado
};
Você opcionalmente pode inicializar cada menbro, se você não o fizer, o primeiro
menbro será inicializado com zero e assim sucessimvamente.
Enum Semana
Domingo = 1
Segunda = 2
Terça = 3
Quarta = 4
Quinta = 5
Sexta = 6
Sabado = 7
End Enum
enum Semana { Domingo = 1, Segunda =2, Terça =3, Quarta =4, Quinta =5,
Sexta =6, Sabado =7 };
Coleções
Poderíamos dedicar um longo capítulo ao estudo de coleção, sendo nosso objetivo fazer
uma introdução a parte de sintaxe, veremos apenas arrays:
Dim MeuArray(1) As String
MeuArray(0) = "Um"
MeuArray(1) = "Dois"
17
string[] MeuArray = new string[1];
arr[0] = "Um";
arr[1] = "Dois";
Ao contrário do legado VB, um array possui sempre índice iniciado em zero, portanto
um array declarado com (1), terá duas posições.
Estruturas de decisão
O classico if não poderia faltar. A sintaxe é semelhante as suas linguagens legadas:
Dim Nome As String = "ASP.NET"
If Nome = "VB.NET" Then
MessageBox.Show("Certo!")
Else
MessageBox.Show("Errado!")
End If
string Nome = "ASP.NET";
if (Nome == "C#")
{
MessageBox.Show("Certo!");
}
else
{
MessageBox.Show("Errado!");
}
Obviamente que a intrução else é opcional.
Outra forma de controle de fluxo conhecido é o Select (VB.NET) ou Switch (C#):
Dim Nome As String = "VB.NET"
Select Case Nome
Case "VB.NET"
MessageBox.Show("Certo!")
Case "C#"
MessageBox.Show("Errado!")
Case Else
MessageBox.Show("?")
End Select
string Nome = "C#";
18
switch (Nome){
case "VB.NET":
MessageBox.Show("Certo!");
break;
case "C#":
MessageBox.Show("Errado!");
break;
default:
MessageBox.Show("?");
break;
}
Note que no C# devemos usar a palavra break para quebrar o fluxo
Laços
Vamos estudar três estruturas de laços: For, while e laços em coleções.
O laço for tem a sintaxe semelhante em qualquer linguagem:
Dim i As Integer
For i = 1 To 10
MessageBox.Show(CStr(i))
Next i
for (int i = 0; i < 10; i++)
MessageBox.Show(Convert.ToString(i));
A sintaxe do C# nos permite facilmente fazer um loop regressivo, basta alterarmos o
último argumento de i++ para i--, e obviamente mudarmos a condição:
for (int i = 0; i < 10; i++)
No VB.NET podemos conseguir o mesmo efeito utilizando a palavra chave Step:
Dim i As Integer = 0
For i = 10 To 1 Step -1
Next i
Existem laços While com teste de condição no inicio da sentença ou no final, neste
último o laço executa sempre uma primeira vez, independente do resultado da avaliação.
Vamos ver exemplos do primeiro caso:
19
Dim i As Integer = 0
Do While i < 5
i += 1
Loop
int i = 0;
while (i<5) {
i += 1;
}
Finalmente, o que pode ser novidade para quem ainda não conhece a plataforma .NET
são os laços em coleções, que permitem percorrer um a um os membros de uma coleção
qualquer.
Dim numbers() = {4, 5, 6, 1, 2, 3, -2, -1, 0}
Dim i As Integer
For Each i In numbers
MessageBox.Show(Convert.ToString(i))
Next
int[] numbers = { 4, 5, 6, 1, 2, 3, -2, -1, 0 };
foreach (int i in numbers)
{
}
Neste exemplo a titulo de simplicidade nossa coleção é um array, porém a estrutura
funciona da mesma forma para qualquer tipo de coleção.
Convertendo valores
Para a conversão entre tipos de dados utilize a classe convert, seguida do método
apropriado ao tipo que ser converter:
Dim i As Integer, s As String
s = Convert.ToString(i)
int i;
string s;
s = Convert.ToString(i);
20
Procedimentos e funções
Em VB.NET uma função começa com a palavra reservada function e termina com o
tipo do dado de retorno. Já no C# inicia com o tipo do dado de retorno:
Function Somar( x As Integer, y As Integer) _
As Integer
Dim z As Integer
z = x + y
Return z
End Function
int Somar(int x, int y)
{
int z;
z = x + y;
return z;
}
O retorno é inidicado pela palavra-chave return ou pelo próprio nome da função.
Um procedimento que não retorna valor em VB.NET inicia com a palavra chave Sub, e
em C# com void:
Sub Somar( x As Integer, y As Integer) _
As Integer
Dim z As Integer
z = x + y
End Function
void Somar(int x, int y)
{
int z;
z = x + y;
}
A passagem de parametros por padrão ocorre por valor. Para indicar um
parametro a ser passado por referencia, utilize ByRef no VB.BET e ref no
C#.
Visibilidade ou Scopo
21
A visibilidade de um procedimento, classe, inferface etc. é definada através das palavras
reservadas a seguir:
Public / public: acessível de qualquer lugar do projeto ou de instancias da classe
Private / private: Acessível apenas dentro do mesmo contexto;
Friend / internal: Acessivel apenas dentro do projeto;
Protected / protected: Acessivel apenas dentro da classe ou de uma classe derivada;
Protected Friend / Protected Internal: Acessivel apenas dentro da classe derivada ou do
mesmo projeto;
Ao declarar algo sem a visibilidade, por padrão será private.
Tratamento de exceções
O tratamento de exceções será surpresa apenas para quem esta começando agora a
conhecer o VB.NET, que com o lançamento do linguagem ganhou uma forma
estruturada de tratamento de erro semelhante as demais linguagens OO. È o adeus ao
On error go to.
O tratamento de erro é formando por uma estrutura Try...Catch..Finally. Entre o Try e o
Catch deve ser colocado o código que você quer proteger de uma exceção. Entre Catch
e Finnally o código a ser executado no caso de ocorrer uma exceção, e finalmente após
Finnally algum código que você queira que obrigatóriamente seja executado, ocorrendo
ou não uma exceção, geralmente usado para liberar algum recurso alocado. Vale
lembrar que você pode usar apenas parte da funcionalidade do bloco, por exemplo, se
você que apenas tratar uma exceção, pode contruir um bloco contendo apenas os
comando try...catch. Por outro lado se você quer apenas garantir que um recurso seja
liberado, como uma conexão com o banco de dados pro exemplo, você pode fazer uso
apenas do bloco try...finally.
Outra caracteristica importante é que as classes de exceção são executadas da mais
especifica para a menos especifica, isto permite um tratamento de erros mais robusto e
eficaz. Normalmente você deve terminar seu tratamento com a classe Exception, que é
menos específica e que da origem a todas as demais.
22
Try
My.Computer.FileSystem.CopyFile("Aspnet.pdf", "Aspnet.bkp")
Catch ex As System.IO.IOException
MessageBox.Show("Ocorreu um erro na cópia do arquivo")
Catch ex2 As Exception
MessageBox.Show("Ocorreu um Erro desconhecido")
End Try
try
{
string s = null;
}
catch (ArgumentNullException s)
{
MessageBox.Show("Ocorreu um erro na string");
}
catch (Exception r)
{
MessageBox.Show("Ocorreu um Erro desconhecido");
}
With
O with, que não tem equivalente no C#, permite omitir o nome de um objeto quando o
mesmo é utilizado em diversas linhas.
With GridView1
.Caption = "GridView"
.EditIndex = 0
.Enabled = False
End With
Orientação a Objetos
Vamos também apresentar alguns aspectos da sintaxe da criação de classes no VB.NET
e no C#. Porém antes é preciso conhecer o conceito de NameSpaces.
NameSpaces é uma estrutura simples, porém muito eficiente de organizar seu código.
Por exemplo, uma suposta empresa GoodSoftware pode definir que todas suas classes
terão como NameSpace raiz GoodSoftware. Abaixo deste existirão os NameSpaces
ERP, CRM e Global. O NameSpace ERP abrigaria as classes de seus novo sistema
ERP, o CRM idem, e o Global classes que para serem utilizadas em ambos os projetos.
Dentro de cada um destes NameSpaces é possível criar n outros. Outra importante
23
vantagem do seu uso é redução de problemas com conflitos com nomes repetidos de
classes ou métodos.
Abaixo vemos a declaração básica de uma classe de Nome Class1, dentro de um
NameSpace
Namespace GoodSoftware
Public Class ERP
'...
End Class
End Namespace
namespace GoodSoftware
{
public class ERP
{
//
}
}
Você não é obrigado a criar uma classe dentro de um NameSpace.
Não é preciso existir relação entre nomes de classes e namespaces com o
nome fisico do arquivo. Você pode inclusive colocar diversas classes ou
namespaces dentro de um mesmo arquivo.
Um construtor de uma classe em VB.NET se define com a palavra chave New, já em C#
deve ter no mome da classe
Public Sub New()
...
End Sub
public Class1 ()
{
//
}
Obviamente que você pode criar um construtor com passagem de parametros.
Já as propriedades são bastante singular em cada linguagem:
24
Public Property Nome() As String
Get
Return Pnome
End Get
Set(ByVal value As String)
Pnome = value
End Set
End Property
public String Nome
{
get { return Pnome; }
set { Pnome = value; }
}
Uma propridade pode ser apenas leitura ou apenas escrita. Além de inicar
estas caracteristica na declaração da propriedade, você deverá omitir as
sentenças get e set, respectivamente.
Caso você deseje criar um método que por algum motivo não precise ou não deva ter
sua classe instanciada, basta você acrescentar a palavra chave shared no VB.NET ou
static no C#, sempre após a declaração de visibilidade do método:
Public Shared Function Somar(ByVal x As Integer, ByVal y As Integer) _
As Integer
Dim z As Integer
z = x + y
Return z
End Function
public static int Somar(int x, int y)
{
int z;
z = x + y;
return z;
}
Lembre-se que um método definido com shared / static, não pode usar
qualquer recurso da classe, como por exemplo uma variavel privada ou
mesmo, uma propriedade ou um outro método.
A herança de uma classe é definida pela palavra chave inherits em VB.NET e em C#
através da notação : classe pai
Public Class Class2
Inherits Class1
End Class
25
class Class2: Class1
{
}
Para se referir a classe base, utilize MyBase no VB.NET ou base no C#,
seguido do nome do método ou propriedade.
Abaixo alguns outros recursos de OO do .NET, não vou demonstrar exemplos porque
extrapolam o objetivo básico desta sessão. A primeira palavra é a notação em VB.NET
e a segunda em C#:
NotInheritable / sealed: Também conhecido com Classe Fechada , indica que
uma classe não pode ser usada como base, ou seja, nenhuma outra classe poderá
herdá-la
MustInherit / abstract: Define uma classe abstrato, onde apenas uma classe filho
poderá ser instanciada.
Overloads: permite que um método seja sobrecarregado, ou seja, que possa
haver métodos com a mesma função, porém com assinaturas diferentes. O uso
do termo é desnecessário tanto em VB.NET quanto em C#, pois o ambiente
entende que métodos com o mesmo nome porem com assinaturas diferentes
estão sobrecarregados.
Overridable / virtual: Indica que uma classe filho deve programar uma nova
versão do método.
Overrides / override: Utilizado para sobrescrever uma implementação na classe
pai.
MustOverride: Em uma classe marcada como MustInherit. Indica que o método
ou propriedade deve não foi implementado na classe pai e deve ser
implementado na classe derivada.
Interfaces
Interfaces é um recurso que permite criar uma padronização maior entre classe. Uma
interface é uma assinatura , que compreende nada mais que métodos e propriedades
ocas . Uma classe que programe determinada interface deve obrigatoriamente seguir
essa assinatura. Você pode definir que determinada classe implemente determinada
interface para ter uma certa funcionalidade.
26
Confuso? Vou citar um exemplo: você pode conectar tanto um array quanto um
SqlDataSource
a
um
GridView,
pois
ambos
implementam
a
interface
System.Collections.IEnumerable.
Interface Interface1
Sub Metodo1()
Function Metodo2() As Integer
End Interface
Public Class UsaInterface
Implements Interface1
Public Sub Metodo1() Implements Interface1.Metodo1
'
End Sub
Public Function Metodo2() As Integer Implements Interface1.Metodo2
'
End Function
End Class
public interface Interface1
{
void Metodo1();
int Metodo2();
}
public class UsaInterface : Interface1
{
public void Metodo1()
{
//
}
public int Metodo2()
{
//
}
}
Como um ambiente de alta produtividade, O VS vai criar automaticamente
pra você todas as estruturas que precisam ser implementadas na classe, no
momento que você informar que deseja utilzar determinada interface.
O .NET não suporta herança multipla, porém uma classe pode implementar
diversas interfaces.
Utilizando o IIS
Certifique-se que o IIS esta devidamente instaldo e rodando.
27
Ao contrario do seu entecessor, o VS 2005 e 2008 vem com um pequeno servidor Web
embutido. Porém devido as limitações deste, vamos trabalhar com IIS.
Para criar uma nova aplicação usando o IIS siga os seguintes passos:
Na IDE do VS selecione File / New Web Site;
Na caixa de dialogo New Web Site selecione ASP.NET Web Site;
Clique em Browse;
Na caixa de dialogo Chose Location, selecione Local IIS;
Selecione Site da Web Padrão;
Clique em Create New Web Aplication;
Digite um nome para sua aplicação, no exemplo Teste;
28
Clique em Open;
De volta a new Web Site, clique em Ok.;
29
3. Web Forms
Um Web Form é uma pagina de sua aplicação. Na IDE do VS ele se comporta de forma
semelhante a um Windows Form: Uma área onde você pode arrastar e soltar controles
visuais, codificar eventos e configurar propriedades que vão regrar seu comportamento.
Fisicamente, um Web Form é composto por um arquivo com extensão aspx e,
dependendo do modelo adotado, poderá ou não estar vinculado a ele um arquivo vb ou
cs, com a codificação para execução no servidor.
Abaixo você vê o código gerado pelo próprio VS na criação da um Web Form:
<%@ Page Language="VB" AutoEventWireup="false"
CodeFile="Default2.aspx.vb" Inherits="Default2" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
<title>Untitled Page</title>
</head>
<body>
<form id="form1" runat="server">
<div>
</div>
</form>
</body>
</html>
Nesta página você alguns dos principais elementos que formam uma pagina HTML
padrão, como as tags Html, Head, Body, Form e Title.
Todos controles e todo conteúdo de apresentação de seu formulário, vai estar entre as
Tags Body.
Diretivas
Na primeira linha da página temos uma diretiva de página. Uma diretiva é representada
pelo símbolo <%@. O que nos diz que se trata de uma diretiva de página é palavra
page, logo após a abertura da tag. Uma diretiva de página possuiu algumas informações
que serão úteis ao compilador no momento da geração da pagina. No código acima,
vemos que na diretiva criada por padrão pelo VS, temos já diversos atributos, você pode
alterá-las ou mesmo inserir diretivas especificas, desde obviamente que você saiba o
que esta fazendo.
30
Abaixo veremos as principais diretivas existentes no ASP.NET 3.5:
@Control: Diretiva de um User Control (arquivo ascx)
@Master: Diretiva de uma Máster Page
@OutPutCache: Diretiva de controle de cachê
@Assembly: Vincula um assembly a página
@Import: Importa um namespace especificado
@Page: Diretiva de um Web Form (arquivo aspx
Cada diretiva pode conter n atributos. Os atributos são configurações que na verdade
ditam as funcionalidades da diretiva. Veremos a seguir os principais atributos da
diretiva @page:
AutoEventWireUp: Determina que os eventos de uma página sejam disparados
automaticamente
ClassName: Especifica o nome da classe relacionada a página
CodeFile: Especifica o arquivo code-behind da página
Culture: Especifica as configurações de cultura da página
Debug: Compila a página com os símbolos de depuração
EnableSessionState: Indica se é permitido armazenamento de sessão na página
EnableTheming: indica se é permitido o uso de temas na página
EnableViewState:Indica se o viewstate será mantido na página
Language: Defina a linguagem em que a página é codificada
SmartNavigation: Habilita os recursos do SmartNavigation na página
Theme: Defini um tema especifico para a pagina
ValidateRequest: Indica se a requisição será validada. Quando este atributo esta
com verdadeiro, se existir algum conteúdo potencialmente perigoso postado na
página, será gerada uma exceção.
No arquivo web.config ou mesmo até no machine.config, podemos
configurar muitos dos atributos que também são configuráveis a nível de
pagina. Normalmente a configuração através de diretiva de página
sobrescreve a definida em um arquivo de configuração.
31
32
4. Controles
Em seção posterior veremos os novos controles adicionados no ASP.NET 3.5, que
como vimos na seção de novidades desta versão, são poucos.
No ASP.NET 2.0 foram adicionados de cerca de 50 novos controles de servidor. Alguns
presentes na versão 1.x, como o DataGrid, não estão mais disponíveis na caixa de
ferramentas, porém podem ser facilmente adicionados.
Não estudaremos detalhadamente todos os Server Controls.
Você pode criar uma aplicação utilizando basicamente dois grandes grupos de
controles: controles HTML, que são os controles padrão conhecidos e Server Controls,
ou controles de servidor.
Você pode criar aplicativos usando apenas controles HTML, porém tenha um
bom motivo para fazer isto.
Server Controls são controles ricos em funcionalidade, que podem ter seus eventos ou
propriedades manipulados no código executado no servidor. Todo controle de servidor é
codificado através de uma tag ASP, que não é HTML padrão que conhecemos. Em
tempo de execução, o ASP.NET renderiza esta tag em HTML otimizado para o
navegador em que a aplicação é executada.
Por exemplo, um dos controles mais simples é o Label. Ao colocar um Label em um
WebForm o VS gera o seguinte código:
<asp:Label ID="Label1" runat="server" Text="Label"></asp:Label>
Você pode gerenciar a apresentação de seu site manualmente, se preferir.
Ao executarmos a aplicação, a tag ASP:Label é renderizado em uma tag span:
<span id="Label1">Label</span>
33
O atributo runat=Server não define que o controle é um controle de servidor, mas sim
que ele será visível no código executado no servidor. Isto significa que se adicionarmos
este atributo a um controle HTML, este também poderá ser manipulado no servidor,
porém de forma mais pobre:
<input id="Text1" runat="server" type="text" />
Não estudaremos controles HTML.
Acessando eventos e propriedades de controles
Na caixa de propriedades, clicando no botão Events
, você tem uma relação de todos
os eventos possíveis para um determinado controle. Para que o VS crie
automaticamente um manipulador para o evento basta dar um duplo clique no nome.
Alguns manipuladores podem ser criados quando clicamos sobre o próprio controle,
como o evento Click de um Button:
Protected Sub Button1_Click(ByVal sender As Object,ByVal e _
As System.EventArgs) Handles Button1.Click
End Sub
protected void Button1_Click(object sender, EventArgs e)
{
}
Junto com o evento são passadas duas propriedades, sender, do tipo object, que contem
o objeto que disparou o evento, e e,
do tipo EventArgs, que contem algumas
propriedades especificas do evento.
Ler ou alterar propriedades de um controle é feito no modelo controle.propriedade,
como nos exemplos abaixo:
Protected Sub Button1_Click(ByVal sender As Object, ByVal e _
As System.EventArgs) Handles Button1.Click
Button1.Text = "Gravar"
Button1.ToolTip = "Clique Aqui para Gravar"
End Sub
34
{
Button1.Text = "Gravar";
Button1.ToolTip = "Clique Aqui para Gravar";
}
Você pode definir que mais de um controle dispare um mesmo manipulador de evento,
internamente basta você verificar qual foi o controle que causou o evento. De uma
maneira geral, para ambas as linguagens, basta você selecionar o evento no dropdown
na caixa de propriedades. O interessante é como o VS trata isto em tempo de design de
forma tão diferenciada. No C# o nome do manipulador do evento é colocada no arquivo
ASPX, no atributo OnClick. No VB.NET, é adicionado o nome do controle ao grupo
handles, ao final da assinatura do evento. O resultado em tempo de execução
obviamente é o mesmo.
Propriedades Comuns
Algumas propriedades são comuns, se não a todos, mas a maioria dos controles. Vamos
vê-las agora:
ID: O nome do controle, deve ser único
BackColor: Cor de fundo do controle
BorderColor: Cor de Borda do Controle
BorderStyle: Estilo da borda do Controle
BorderWidt: Largura da borda do controle
CssClass: Indica a classe CSS a ser aplicada no controle
Enabled: indica se o controle esta habilitado
EnableTheming: Indica se é o tema do controle estará ativo
EnableViewState: Indica se o controle vai armazenar seu estado no viewstate da
pagina
Font: Fonte do controle
SkinID: Indica o ID do skin a ser utilizado. Skins serão estudados mais adiante
Text: Representa o texto que será exibido ao usuário da aplicação
ToolTip: é a dica que será exibida ao usuário quando este posicionar o mouse
sobre o controle.
35
Uso de HotKeys
Duas propriedades novas e interessantes, que estão presentes em alguns controles, são
AcessKey e AssociatedControlID. Com a primeira definimos uma tecla de atalho para o
controle, que no navegador e acionado junto com a tecla ALT. Já com
AssociatedControlID podemos definir qual o controle vai receber o foco no caso da
combinação de teclas ser acionadas. Este recurso é conhecido como HotKeys.
Vamos estudar agora os três principais controles de servidor, que formam um conjunto
básico para a criação de qualquer aplicativo.
Label
Um controle simples, porém poderoso, que nos permite exibir algum texto em uma
página Web. Todas suas propriedades podem ser manipuladas no código gerado no
servidor.
Alguns exemplos de codificação de controles, mostram primeiro em tempo
de design (ASP) e em seguida em tempo de execução (HTML) .
É definido pela a tag ASP:Label e quando executado renderizado em uma tag span:
<asp:Label ID="Label1" runat="server" Text="ASP.NET 3.5
Rules!!"></asp:Label>
span id="Label1">ASP.NET 3.5 Rules!!</span>
TextBox
O textbox é um controle de edição simples. Através da propriedade TextMode podemos
utilizá-lo ainda para receber senhas ou mesmo transforma-lo em um controle com
múltiplas linhas. Uma novidade é a propriedade AutoCompleteType, que pode receber
apenas valores pré-definidos. Ao preencher um segundo controle com o mesmo valor
para esta propriedade, o navegador deverá sugerir o preenchimento do valor informado
no primeiro campo.
È definido pela a tag ASP:TextBox e quando executado renderizado em uma tag input
do tipo text ou password ou então textarea, de acordo com a propriedade textmode.
36
<asp:TextBox ID="TextBox1" runat="server">Normal</asp:TextBox>
<asp:TextBox ID="TextBox2" runat="server"
TextMode="Password">Senha</asp:TextBox>
<asp:TextBox ID="TextBox3" runat="server"
TextMode="MultiLine">MultiLine</asp:TextBox>
<input name="TextBox1" type="text" value="Normal" id="TextBox1" />
<input name="TextBox2" type="password" id="TextBox2" />
<textarea name="TextBox3" rows="2" cols="20"
id="TextBox3">MultiLine</textarea>
Button
O button é um botão de comando básico. Sua principal função é causar um post back
para a execução de algum código no servidor. O principal evento é Click, que,
obviamente, é disparando quando clicamos no botão. É renderizado em uma tag input
do tipo submit.
<asp:Button ID="Button1" runat="server" Text="Button" />
<input type="submit" name="Button1" value="Button" id="Button1" />
Uma importante propriedade é a PostBackUrl, que indica para qual página será
executado o post back.
Para exemplificar, o código abaixo lê a um TextBox de um formulário que originou o
PostBack:
Dim Nome As String = CType(PreviousPage.FindControl("Nome"), _
TextBox).Text
LinkButton
O controle linkbutton é uma mistura de botão de comando com HyperLink. Sua
aparência é de um Link, seu comportamento e suas propriedades o assemelham a um
Button. Não existe propriedade NavigateUrl, o redirecionamento deve ser codificado no
post back ou através da propriedade PostBackUrl.
<asp:LinkButton ID="LinkButton1"
runat="server">LinkButton</asp:LinkButton>
Nos bastidores, o LinkButton renderiza uma tag a, cujo atributo Href, ao invés de conter
uma URL, dispara uma função Java Script gerada pelo ASP.NET.
37
<a
id="LinkButton1"
href="javascript:__doPostBack('LinkButton1','')">LinkButton</a>
ImageButton
Um ImageButton é um botão de comando onde podemos adicionar uma imagem para
exibição. Possui todas as funcionalidades do Button, mais a propriedade ImageURL
onde definimos a imagem. Em tempo de execução é renderizado como Input do tipo
Image.
<asp:ImageButton ID="ImageButton1" runat="server" ImageUrl="web.gif"
/>
<input type="image" name="ImageButton1" id="ImageButton1"
src="web.gif" />
HyperLInk
O hyperlink permite criar links de navegação, sua propriedade mais importante é
NavagateURL, que é valor para a atribuo HREF. É um controle simples que é
renderizado com uma tag a. Seu poder maior esta na possibilidade de, por exemplo,
definir a URL dinamicamente no código do servidor. Através de uso de HotKey pode-se
ainda facilitar a navegação na pagina. A propriedade text define o texto de exibição, já
ImageUrl pode definir uma imagem a ser exibida ao invés do texto.
<asp:HyperLink ID="HyperLink1" runat="server"
NavigateUrl="http:\\www.fernandoamaral.com.br">Clique
Aqui</asp:HyperLink>
<a id="HyperLink1" href="http:\\www.fernandoamaral.com.br">Clique
Aqui</a>
CheckBox
O checkbox gera um controle HTML input do tipo checkbox
<asp:CheckBox ID="CheckBox1" runat="server" Text="Lembrar" />
<input id="CheckBox1" type="checkbox" name="CheckBox1" />
38
RadioButton
O RadioButton gera um controle HTML input do tipo radio
<asp:RadioButton ID="RadioButton1" runat="server" Text="Lembrar" />
<input id="RadioButton1" type="radio" name="RadioButton1"
value="RadioButton1" />
Image
O controle Image deve ser utilizado para exibição de Imagens. A imagem a ser exibida
deve ser definida através da propriedade ImageUrl.
<asp:Image ID="Image1" runat="server" ImageUrl="web.gif" />
<img id="Image1" src="web.gif" />
DropDownList e ListBox
O DropDownList e ListBox são controles altamente poderoso. Suas propriedades e
eventos trazem recursos que só poderiam ser obtidos com muita mão de obra em uma
aplicação WEB. A propriedade AutoPostBack, causa um post back automático ao
servidor quando um valor é selecionado. Os controles podem ter seus itens adicionados
em tempo de design ou de execução, através da propriedade Itens. Também é possível
vinculá-lo a uma fonte de dados qualquer, que pode ser um array, um dataset ou mesmo
um SqlDataSource, só para citar alguns.
Para cada item é possível ler e escrever um texto e um valor, armazenados nas
propriedades text e value, respectivamente. Isto é muito útil, por exemplo, para
recuperar o código de um item selecionado pelo usuário.
<asp:DropDownList ID="DropDownList1" runat="server">
<select name="DropDownList1" id="DropDownList1">
O exemplo abaixo adiciona um item a um DropDownList:
DropDownList1.Items.Add("Selecione uma opção")
39
DropDownList1.Items.Add("Selecione uma opção");
Para recuperar o valor da propriedade text bem como value basta ler as propriedades
específicas:
Dim s As String = DropDownList1.SelectedValue
Dim t As String = DropDownList1.SelectedItem.Text
string s = DropDownList1.SelectedValue;
string t = DropDownList1.SelectedItem.Text;
O evento SelectedIndexChange é executado quando um item do controle é selecionado.
Se a propriedade AutoPostBack estiver marcada como verdadeira, um postback é
executado imediatamente, caso contrário o evento só será executado no próximo
postback.
Existem ainda diversos métodos interessantes, como itens.clear, que limpa os itens, e
propriedades, como itens.count, que retorna o número de itens no controle.
CheckBoxList e RadioButtonList
Os controles CheckBoxList e RadioButtonList em tempo de design são apresentados
como um conjunto de controles CheckBox e RadioButton, que podem ter suas
propriedades gerenciadas mais facilmente e conectados a uma fonte de dados qualquer.
Em tempo de execução, o ASP.NET renderiza cada controle como diversos controles
input do tipo checkbox ou radiobutton.
No exemplo abaixo o código verifica se um determinado item de um
If CheckBoxList1.Items(0).Selected = True Then
''
End If
if (CheckBoxList1.Items[0].Selected==true)
{
//
}
40
Calendar
O Calendar é um calendário que é renderizado utilizando uma tag table, e na sua forma
mais simples tem pelo menos 7 KB de texto. É excelente para exibição e entrada de
datas. Possuiu um conjunto poderosíssimo de propriedades, métodos e eventos que
permitem praticamente exibi-lo de qualquer forma imaginada.
Entre seus eventos mais significativos, temos o SelectionChange, que é disparado
quando ocorre uma alteração na seleção do calendário, e VisibleMonthChange, que
ocorre quando o mês visível no calendário é alterado. A propriedade SelecteDate nos
permite ler a data selecionada.
No exemplo abaixo um label exibe a data selecionada pelo usuário:
Protected Sub Calendar1_SelectionChanged(ByVal sender As _
Object, ByVal e As System.EventArgs) Handles _
Calendar1.SelectionChanged
Lbldata.Text = String.Format("A data selecionada é {0:d}",_
Calendar1.SelectedDate)
End Sub
protected void Calendar1_SelectionChanged(object sender, EventArgs e)
{
Lbldata.Text = String.Format("A data selecionada é {0:d}",
Calendar1.SelectedDate);
}
Através das propriedades SelectionMode podemos definir se o usuário poderá
selecionar um único dia, uma semana, um mês inteiro ou nada. Caso ele possa
selecionar, por exemplo, uma semana, podemos recuperar os dias selecionados através
de um laço for each, que percorre a coleção de objetos DateTime da propriedade
SelectedDates:
Dim s As System.DateTime
For Each s In Calendar1.SelectedDates
ListBox1.Items.Add(String.Format("Data Selecionada {0:d}", s))
Next
41
foreach (System.DateTime s in Calendar1.SelectedDates)
{
ListBox1.Items.Add(String.Format("Data Selecionada {0:d}", s));
}
AdRotator
O AdRotator nos permite incluir um banner em nosso site, onde o próprio ASP.NET
através de um arquivo de configuração, vai cuidar da rotatividade das exibições de
imagens. O segredo todo está em um arquivo de configuração, que pode ser um XML
ou mesmo uma tabela de banco de dados.
Para testar este controle, crie um arquivo XML dentro do diretório App_Data de sua
aplicação (se não existir o diretório, crie-o também), com o seguinte texto:
<?xml version="1.0" encoding="utf-8" ?>
<Advertisements>
<Ad>
<ImageUrl>~/imagens/cafezinho.bmp</ImageUrl>
<NavigateUrl>http://www.cafezinho.com</NavigateUrl>
<AlternateText>Café</AlternateText>
<Keyword>Café</Keyword>
<Impressions>40</Impressions>
</Ad>
<Ad>
<ImageUrl>~/imagens/deserto.bmp</ImageUrl>
<NavigateUrl>http://www.deserto.com</NavigateUrl>
<AlternateText>Deserto</AlternateText>
<Keyword>Site Deserto</Keyword>
<Impressions>20</Impressions>
</Ad>
</Advertisements>
Certifique-se que você tem uma pasta imagens com as imagens informadas. Você pode
configurar os parâmetros de acordo com sua preferência: NavigateUrl é a URL para
qual o usuário será direcionado quando clicar no banner, AlternateText é o texto a ser
exibido no local da imagem. Impressions representa o número de impressões do banner.
No exemplo acima, note que o primeiro banner deverá aparecer em dobro.
Para vincular o seu AdRotator ao arquivo XML basta informá-lo na propriedade
AdvertisementFile.
Um arquivo XML é sensível a caracteres maiúsculos e minúsculos.
42
View e MultiView
Mais uma novidade surgida no ASP.NET 2.0. Provavelmente você já necessitou que
parte de sua aplicação ficasse invisível em determinados momentos. Claro que isso não
era uma tarefa impossível, mas com os controles MultiView e View isto ficou mais
simples.
A idéia é: Dentro de um Multiview você agrega um ou mais Views. Em cada um dos
Views você coloca controles conforme a necessidade. A partir daí é só determinar qual
View estará visível através da propriedade ActiveViewIndex.
MultiView1.ActiveViewIndex = 0
MultiView1.ActiveViewIndex = 0;
Wizard
Continuando com as novidades, o Wizard é um assistente para páginas Web, onde você
pode determinar passos (Steps). Em cada Step você tem uma área onde pode colocar
seus controles conforme a necessidade.
Entre os eventos tempos NextButtonClick, que é disparado sempre que o usuários clicar
no botão Next, FinishButtonClick, disparado no encerramento, e CancelButtonClick,
disparado ao final.
O mais interessante de tudo é que Wizard mantém estado de tudo o que é colocado em
seus passos. Isto significa que você pode fazer o processamento dos dados ao final do
assistente.
O controle é totalmente configurável, desde aparências até texto dos botões.
Controles de validação
43
O ASP.NET desde sua primeira versão tem integrador alguns controles que permitem
validar entradas do usuário, tanto no cliente como no servidor, de forma simples e
rápida.
A partir da versão 2.0 foi incluía a propriedade ValidationGroup, que permite que
agrupemos grupos diferentes de validação em um mesmo WebForm. Na versão anterior
isto era um problema, ou fazíamos a validação manualmente ou dividíamos a nossa
lógica de negocio em dois formulários diferentes. Na versão 3.5 não houveram
novidades em relação aos controles de validação.
Os controles de validação são:
RequiredFieldValidator: Permite validar se um controle foi preenchido.
RangeValidator: Permite verificar se o valor informado esta entre determinado
intervalo.
RegularExpressionValidator: Permite validar o valor informado com uma
expressão regular
CompareValidator: Permite comparar dois valores.
CustomValidator: Permite que customizemos nossa expressão de validação.
Um controle de validação vai exibir uma mensagem caso a validação falhe. Com o
controle ValidationSummary podemos agrupar as mensagens de todos os controles em
um único local ou numa mesma caixa de dialogo.
Se você quer garantir que um controle tenha um valor preenchido e seja, por
exemplo, um inteiro maior que zero, você terá que usar além de um
RangeValidator um RequiredFiledValidador, apenas este último obriga o
preenchimento do valor.
Um controle de validação tem duas propriedades para exibição de mensagens: Text e
ErrorMessage. Se você utilizar um ValidationSummary você pode trabalhar com as
duas: A mensagem em ErrorMessage será exibida no ValidationSummay, e text no
proprio controle de validação (um * por exemplo).
44
Para criar grupos de validação, basta escolher um nome para o grupo e preencher as
propriedades ValidationGroup tanto dos controles a serem validados quanto dos
controles de validação.
Se você quiser causar um post back sem disparar os validadores, basta setar a
propriedade CausesValidation do controle para False.
Para obrigar o preenchimento de um textbox:
Coloque num formulário um controle TextBox, um RequiredFieldValidator e um
ValidationSummary e um Button;
Configure a propriedade ControlToValidade do RequiredFieldValidator para o TextBox
adicionado no furmaulario;
Preencha a propriedade text do RequiredFieldValidator para *, e ErrorMessage para
Preenchimento Obrigatório ;
Configure a propriedade ShowMessageBox do ValidationSummary para true, e
ShowSummary para false;
Rode a aplicação;
Clique no botão sem preencher qualquer informação no textbox.
45
Por fim, para verificar também no servidor se todas as validações foram feitas, verifique
a propriedade isvalid da página.
5. Master Pages
É comum em aplicações convencionais ou mesmo Web a necessidades de criarmos
partes de conteúdo que serão exibidas em todas ou pelo menos em diversas páginas. No
ASP clássico isso era resolvido da seguinte forma: Você desenvolvia o conteúdo
separadamente e sua inclusão era feito onde necessário através de uma tag Include.
No ASP.NET 1.1 surgiu uma novidade: os chamados Web User Controls, que são
arquivos com a extensão ascx, que podiam ser programados na IDE do Visual Studio e
adicionados a qualquer Web Form. Trouxe significativas vantagens em relação ao uso
46
do include, como o fato da pagina host ter a possibilidade de ler ou alterar valores de
controles ou propriedades.
Sua grande desvantagem era que não possuía herança visual como já há um longo
tempo era possível em aplicações convencionais: O user control em tempo de design
eram representados na IDE do VS como um botão cinza.
No ASP.NET 2.0 uma das grandes novidades apresentadas e que obviamente continuam
disponíveis na versão 3.5 são as Master Pages, que trazem finalmente a herança de
conteúdo de forma visual.
Uma MasterPage é um arquivo com extensão master. Pode ser criada no IDE do VS no
modelo code-behing ou code-inline, assim como um Web Form. Sua estrutura básica
também é muito parecida com um Web Form:
<%@ Master Language="VB" CodeFile="Master.master.vb" Inherits="Master"
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
<title>Untitled Page</title>
</head>
<body>
<form id="form1" runat="server">
<div>
<asp:contentplaceholder id="ContentPlaceHolder1"
runat="server">
</asp:contentplaceholder>
</div>
</form>
</body>
</html>
A principal diferença é a diretiva de compilação @Master, no lugar de @Page. Esta
diretiva informa ao ASP.NET durante o processo de compilação que trata-se uma
Master Page.
Uma página aspx que utiliza uma Master Page é chamada de página de conteúdo
(Content Page). Uma página de conteúdo não contem os elementos que formam uma
página HTML comum, pois estes serão herdados da Master Page. Numa Master Page,
47
as áreas onde uma pagina de conteúdo terão disponível para exibir seu conteúdo são
definidas através de controles de servidor contentplaceholder. No código acima você
pode ver um controle contentplaceholder criado por padrão na criação da MasterPage.
Criando uma Master page
Criar uma Master Page no Visual Studio é simples: Na caixa de dialogo Add New Item
Selecione Master Page, defina um nome para a página. O VS cria a MasterPage com o
nome escolhido.
Se você optou pelo modelo code-behind, serão criados dois arquivos: um arquivo
master e um vb ou cs, conforme a linguagem escolhida. Se a opção foi code-inline, será
criado apenas o arquivo .master.
Utilizando uma Mater Page
Definir a(s) página(s) de conteúdo é simples e pode ser feito quatro maneiras diferentes:
Durante a criação da página, na caixa de dialogo Add New Item, marque a opção Select
Master Page
48
Será exibida a caixa de dialogo Master Page, que exibe as Master Pages disponíveis no
projeto:
Baste selecionar a página Master e clicar em Ok.
A segunda é através da própria pagina Master, selecionando a opção Add Content Page.
Será criada uma página de conteúdo em branco. Você não poderá escolher o nome da
página no momento da sua criação.
A terceira é de forma manual. Crie um Web Form normalmente, remova todo o HTML
gerado, com exceção da diretiva de página. Adicione a diretiva de página o atributo
MasterPageFile, que indica que esta é uma página de conteúdo que utiliza a Master
Page especificada no atributo.
Finalmente, a quarta e última, e em tempo de execução:
49
Protected Sub Page_PreInit(ByVal sender As Object, ByVal e _
As System.EventArgs) Handles Me.PreInit
Page.MasterPageFile = "~/MasterUm.master"
End Sub
protected void Page_PreInit(object sender, EventArgs e)
{
Page.MasterPageFile = "~/MasterUm.master";
}
A defninição de uma pagina Master em tempo de execução deve ser feito no
evento PreInit da página.
Obviamente que esta última forma nos priva dos beneficios da herança visual.
Trabalhando com uma Master Page
Este não é um curso de Web Design, portanto não perca tempo ou se
preocupe com a aparência de suas atividades práticas.
Nesta sessão vamos demonstrar de maneira prática como tirar proveito da utilização de
uma Master Page.
Crie uma nova aplicação ASP.NET;
Crie uma nova Master Page;
Defina o layout da Master Page de acordo com a figura abaixo:
50
Para os quatro controles da esquerda, que deverão funcionar como HyperLinks, utilize
controles de Servidor HyperLinks, defina a propriedade text de cada um como
Desentupimento, Hidráulica, Limpeza e Hidrojateamento. A propriedade NavigateUrl
de cada um deve ser definida pelo mesmo conteúdo da propriedade text mais a extesão
aspx, por exemplo: Desentupimento.aspx.
Crie quatro páginas de conteúdo com os nomes especificados nas propriedades
NavigateUrl acima, especificando como Master Page a página criada.
Defina um conteúdo especifico para cada página de conteúdo, conforme exemplo
abaixo:
Na área Content da página de conteúdo você pode trabalhar livremente:
adicionar controles, eventos etc.
51
Defina uma das páginas de conteúdo criada como página inicial e rode a aplicação.
Navega entre as páginas e veja na prática o funcionamento da aplicação.
Acessando a página Master da página de conteúdo
Você pode facilmente acessar qualquer controle ou propriedade da página Master, na
página de conteúdo, através da propriedade Master.
Por exemplo, para ler o conteúdo de um dos HyperLinks da página Master:
If Not Page.IsPostBack Then
Dim s As String = CType(Master.FindControl _
("Desentupimento"), HyperLink).Text
End If
if (!Page.IsPostBack)
{
string s = (Master.FindControl("Desentupimento")
as HyperLink).Text;
}
52
Também podemos alterar o texto ou mesmo qualquer propriedade do controle na Master
Page, pois nossa operação é por referencia:
Dim Hyper As HyperLink
Hyper = CType(Master.FindControl("Desentupimento"), HyperLink)
Hyper.ForeColor = System.Drawing.Color.Red
HyperLink Hyper;
Hyper = (Master.FindControl("Desentupimento") as HyperLink);
Hyper.ForeColor = System.Drawing.Color.Red;
Neste exemplo, estamos mudando a cor do HyperLink do conteúdo da página Master
para vermelho.
Alterando o Título das páginas de conteúdo
A página de conteúdo deve conter um atributo title, onde deve ser definido o titulo para
exibição da página. Na ausência deste, será exibido o titulo da Master Page.
Outra alternativa é definir no código o título para a página:
Master.Page.Title = "Titulo definido em tempo de execução"
Master.Page.Title = "Titulo definido em tempo de execução";
Trabalhando com conteúdo padrão
Outra possibilidade interessante é a de trabalhar com conteúdo padrão. Você pode
definir um conteúdo padrão de exibição na área da página de conteúdo, da mesma forma
que você define o restante da página. Na página de conteúdo, para exibir o conteúdo
padrão, basta clicar em Default to Master Content na Smart Tag do controle de
conteúdo.
Master Pages aninhadas
Alem de tudo o que estudamos, é possível mais. Você pode criar Master Pages
aninhadas, em diferentes níveis. O VS 2005 não da suporte em sua IDE para este
recurso, portanto você terá que fazer todo o trabalho manualmente.
53
54
6. Themes e Skins
A formatação de suas páginas ASP.NET poderão ser feitas de diversas maneiras, entre
elas:
Uso de arquivos CSS;
Formatação diretamente nas pagina.
Utilizando o novo recurso de temas, é possível definir um padrão para toda a aplicação
sem necessidade de altera qualquer página. As possibilidades são muitas, vamos ver um
exemplo prático.
Crie um WebForm com os seguintes controles:
Crie a pasta App_themes. Esta é uma pasta de sistema do ASP.NET. Para criá-la acesse
o menu WebSite, ASP.NET Folder, Themes.
Na caixa de dialogo Add New Item exibida em seguida, selecione Skin File, de o nome
de Red.
Clique sobre o botão direito sobre a pasta Themes e crie um novo Skin, desta vez com o
nome Gray.
55
A formatação de controles num Skin é definida usando a própria tag de definição do
controle, obviamente que alguns atributos não deverão ser utilizados, como ID ou text.
No exemplo abaixo o definição para o Skin Red:
<asp:Label runat="server" Font-Names="Arial" ForeColor="Maroon" />
<asp:Button runat="server" Font-Bold="True" ForeColor="Maroon" />
<asp:RadioButton runat="server" Font-Names="Arial" ForeColor="Maroon"
/>
<asp:CheckBox runat="server" Font-Names="Arial" ForeColor="Maroon" />
Já o skin Gray fica assim:
<asp:Label runat="server" Font-Names="Verdana" ForeColor="Gray" />
<asp:Button runat="server" Font-Bold="True" ForeColor="DimGray" />
<asp:RadioButton runat="server" Font-Names="Verdana" ForeColor="Gray"
/>
<asp:CheckBox runat="server" Font-Names="Verdana" ForeColor="Gray" />
Agora vamos definir que sua página ASP.NET vai utilizar um Theme. Clique sobre o
formulário e localize a propriedade Theme, note que todos os temas criados estão
disponíveis:
56
Escolha o tema Red. Nos bastidores o tema escolhido é adicionado em uma diretiva da
página:
<%@ Page Language="VB" Theme="RED" AutoEventWireup="false"
CodeFile="Default.aspx.vb" Inherits="_Default" %>
Rode a aplicação e observe o resultado.
57
Altere o tema para Gray e rode a aplicação novamente.
Definindo o tema dinamicamente
Você pode definir o tema durante a execução do programa, através de uma escolha do
usuário, por exemplo. Para isto basta alterar a propriedade Theme da página:
58
Page.Theme = "red"
Page.Theme = "Red";
A alteração de tema dinamicamente deve ser feita no evento PreInit da
página.
Definindo um tema para toda a aplicação
Você também pode definir um tema no arquivo de configuração da aplicação, no nó
system.web. Esta configuração será aplicada automaticamente para todas as páginas da
aplicação:
<pages theme="Red" >
O nó pages já deve existir no seu arquivo de configuração, localize-o ao invés
de criar um novo nó.
Vale lembrar que uma configuração de página sobrescreve a de aplicação. Portanto se
em determinada página você não quiser usar o tema padrão da aplicação, basta definir o
tema desejado na página.
Apresentação diferenciada
Se você precisar dar uma apresentação diferente para um determinado controle que já
esta definido no arquivo skin, você pode criar um nova definição deste controle
adicionando a ele um SkinId. Para exemplificar, vamos alterar o arquivo skin Red de
maneira que o titulo da página, Cadastro, seja exibido maior e de outra cor.
Primeiramente alteramos nosso arquivo Red:
<asp:Label runat="server" Font-Names="Arial" ForeColor="Maroon" />
<asp:Label SkinId="Titulo" runat="server" Font-Names="Arial" FontSize="X-Large" ForeColor="Black" />
<asp:Button runat="server" Font-Bold="True" ForeColor="Maroon" />
<asp:RadioButton runat="server" Font-Names="Arial" ForeColor="Maroon"
/>
<asp:CheckBox runat="server" Font-Names="Arial" ForeColor="Maroon" />
Observe que foi adicionada uma nova tag asp:label, com SkinID como Titulo. Agora
basta na página, alterar a propriedade SkinID do controle para Titulo:
59
Certifique-se que sua página esta utilizando o Skin Red. Rode a aplicação:
60
7. Navigation
Surgido no ASP.NET 2.0, são uma série de controles para auxiliar a navegação do
usuário. Estes controles podem ser encontrados no grupo Navigation da barra de
ferramentas do VS 2008, são eles:
SiteMapPath
Menu
TreeView
SiteMapPath
O controle SiteMapPath permite exibir um mapa de navegação para o usuário, numa
estrutura hierárquica a partir da página raiz da aplicação. Para demonstrar as
funcionalidades do controle, vamos criar um suposto aplicativo de comércio eletrônico,
com a seguinte estrutura:
61
A funcionalidade do controle SiteMapPath esta baseada em arquivo xml denominado
web.sitemap, que pode ser facilmente criado pela opção Add New Item. Sua estrutura
básica é a seguinte:
<siteMap xmlns="http://schemas.microsoft.com/AspNet/SiteMap-File-1.0"
>
<siteMapNode url="" title="" description="">
<siteMapNode url="" title="" description="" />
<siteMapNode url="" title="" description="" />
</siteMapNode>
</siteMap>
Trata-se de um arquivo XML padrão. O nó raiz é denominado SiteMap. A estrutura do
site deve ser representada por nós SiteMapNode, onde estes devem ser organizados de
forma a representar a estrutura hierárquica do site. O atributo Url define o endereço da
página, Title o titulo a ser exibido no controle, e descrição o Tool Tip que também será
exibido no controle.
Importante ressaltar que o arquivo deve ser montado de forma hierárquica, ou seja, uma
página deve ser adicionada dentro do nó siteMapNode da página hierarquicamente
superior.
Para nossa aplicação proposta anteriormente, montei o seguinte arquivo:
<siteMap xmlns="http://schemas.microsoft.com/AspNet/SiteMap-File-1.0"
>
<siteMapNode url="Index.aspx" title="Página Principal"
description="Página Principal da Site">
<siteMapNode url="~/Informatica/Informatica.aspx"
title="Departamento de Informática" description="Produtos de
Informática">
<siteMapNode url="~/Informatica/Impressoras/Impressoras.aspx"
title="Impressoras" description="VImpressoras Diversas" />
<siteMapNode
url="~/Informatica/Monitores/Convencionais/Convencionais.aspx"
title="Monitores Convencionais" description="Monitores Convencionais"
/>
<siteMapNode url="~/Informatica/Monitores/LCD/LCD.aspx"
title="Monitores LCD" description="Monitores LCD" />
</siteMapNode>
</siteMapNode>
</siteMap>
62
Observe que as impressoras estão dentro do nó do departamento de informática. Se não
criarmos o arquivo desta forma, da página do departamento de informática poderemos
navegar apenas para a página inicial.
Observe o sistema rodando:
Você não precisa configurar nenhuma propriedade do controle SiteMapPath
para o mesmo funcionar, desde que o arquivo Web.sitemapth esteja correto.
Bbasta adicionar o controle ao Web Form.
Analisando a janela de propriedades do SiteMapPath, você pode descobrir algumas
coisas interessantes: Por exemplo, a propriedade Path Separator permite definir um
caractere de separação entre os caminhos.
Através da Smart Tag você também pode definir uma auto-formatação para seu
controle.
Menu
O controle Menu permite adicionar as funcionalidades de um menu em uma aplicação
Web. Seu uso é simples: após adicionar um controle a um Web Form, basta abrir o
63
editor de itens do menu através da Smart Tag do controle ou mesmo da janela de
propriedades, onde é possível gerenciar o conteúdo do Menu.
O editor de menu possui uma pequena barra de ferramentas com as seguintes
funcionalidades:
Add a root item:
Adiciona um novo item no mesmo nível da seleção atual
Add a child item:
Adiciona um novo item um nível acima da seleção atual
Remove an iten:
Remove o item selecionado.
Move the item up amongst its siblings:
Sobe o item verticamente;
Move the item down amongst its siblings:
Desce o item verticalmente;
Make the selected item a sibling of its parent:
Desce o item
horizontalmente;
Make the selected item a sibling of its parent:
Sobe o item horizontalmente.
Cada item possui diversas propriedades configuráveis, as mais significativas são text,
que indica o texto a ser exibido no item, e navigateUrl: A URL de destino caso o
usuário clique no item;
64
Adicionar os itens e configurar suas propriedades é tudo o que você precisa para tornar
o controle funcional, mas isso não é tudo: Na smart tag do controle outra opção
disponível é auto-format: Você pode dar um visual agradável ao seu menu sem muito
trabalho.
Entre as propriedades do menu, orientation define o comportamento do menu:
Horizontal ou Vertical.
Ligando seu Menu a um arquivo Web.sitemap
Se você tem um arquivo Web.sitemap em sua aplicação, vimos que o controle
SiteMapPath passa a utilizá-lo automaticamente, sem qualquer configuração ou
alteração de propriedade.
Um controle Menu também pode fazer uso do arquivo, porém você terá que ligá-los
manualmente. É extremante simples:
Adicione um controle SiteMapDataSource ao seu Web Form (disponível na Guia data
da caixa de Ferramentas)
No Menu, altera a propriedade DataSourceID para o controle SiteMapDataSource
adicionado.
Pronto! A partir de agora os itens de seu menu serão mapeados a partir do arquivo
Web.sitemap que você criou anteriormente.
65
TreeView
O terceiro controle que estudaremos no capitulo é o TreeView. Trata-se de um poderoso
controle que nos permite exibir estruturas navegáveis e aninhadas. Sua configuração
básica é simples, ao mesmo tempo em que prove uma grande quantidade de
propriedades e alguns eventos que tornam o controle altamente poderoso e flexível.
Para usar o controle basta adicioná-lo ao Web Form. Através da smart tag do controle
podemos acessar um editor de itens idêntico ao do controle Menu:
66
Ainda na smart tag podemos definir um modelo de auto-formatação:
A propriedade Show Lines também presente na smart tag do controle permite que sejam
exibidas linhas entre o nó raiz e seus nós aninhados:
67
Definidas as propriedades de cada Item, o controle esta pronto para ser utilizado.
Ligando seu TreeView a um arquivo Web.sitemap
Um controle TreeView também pode fazer uso do arquivo Web.sitemap, o processo é o
mesmo do Menu:
Adicione um controle SiteMapDataSource ao seu Web Form (disponível na Guia data
da caixa de Ferramentas)
No Menu, altera a propriedade DataSourceID para o controle SiteMapDataSource
adicionado.
68
Seleção Múltipla
A propriedade ShowCheckBoxes permite que cada nó seja transformado em caixas de
verificação, de forma que você poderá selecionar mais de um nó simultaneamente. Os
valore possíveis para esta propriedade são:
Root: Apenas os nós da raiz serão exibidos como caixas de verificação.
Parent: Apenas os nós pais serão exibidos como caixas de verificação.
Leaf: Apenas os nós folhas serão exibidos como caixas de verificação.
All: Todos os nós serão exibidos como caixas de verificação.
69
Verificar programaticamente quais nós estão marcados é relativamente simples. Tudo a
fazer é percorrer a lista de nós do controle usando um laço for next. No exemplo abaixo
o código percorre a relação de nós e adiciona o texto do nó a um listbox:
Dim node As TreeNode
For Each node In TreeView1.CheckedNodes
ListBox1.Items.Add(node.Text)
Next
foreach (TreeNode node in TreeView1.CheckedNodes)
{
ListBox1.Items.Add(node.Text);
}
Gerenciando o controle em tempo de execução
Você também pode adicionar um nó programaticamente. No exemplo abaixo o nó é
adicionado na raiz do TreeView:
Dim node As New TreeNode
node.Text = "Móveis para escritório"
node.NavigateUrl = "moveis.aspx"
TreeView1.Nodes.Add(node)
TreeNode node;
node = new TreeNode();
70
node.Text = "Móveis para escritório";
node.NavigateUrl = "moveis.aspx";
TreeView1.Nodes.Add(node);
Adicionar um nó aninhado a outro é um pouco mais complicado. Primeiro você deve
localizar o nó pai utilizando o método FindNode, que recebe o caminho (path) do nó.
Então basta adicionar um novo nó a sua coleção de nós filhos:
Dim Atual As TreeNode = _
TreeView1.FindNode("PáginaPrincipal/Departamento de Informática")
Dim Novo As New TreeNode
Novo.Text = "Móveis para escritório"
Novo.NavigateUrl = "moveis.aspx"
Atual.ChildNodes.Add(Novo)
TreeNode Atual = TreeView1.FindNode
("PáginaPrincipal/Departamento de Informática");
TreeNode Novo = new TreeNode();
Novo.Text = "Móveis para escritório";
Novo.NavigateUrl = "moveis.aspx";
Atual.ChildNodes.Add(Novo);
Na imagem abaixo você pode ver o resultado:
Para remover nós temos o método Remove.
Finalmente, podemos recolher um TreeView em tempo de execução:
71
TreeView1.CollapseAll
TreeView1.CollapseAll();
Ou mesmo expandir:
TreeView1.ExpandAll;
TreeView1.ExpandAll();
72
8. WebParts
WebParts não é um conceito novo, mas que surgiu a partir do ASP.NET 2.0 de forma
fácil e poderosa.
WebParts nos permite criar páginas com conteúdo gerenciável pelo usuário, onde esse
pode arrastar controles, mudar aparências, ocultar o que não for preciso ou exibir
novamente, enfim, traz para o ambiente Web uma interatividade completa entre o
usuário e a aplicação, tudo isto com persistência.
Modos
Uma página ASP.NET utilizando WebParts pode estar em diferentes modos. Cada
modo diz respeito ao comportamento do conteúdo da página e como o usuário poderá
interagir com este conteúdo. Os quatro modos possíveis são:
Normal: A página esta em modo normal, não permite quase nenhuma
interatividade com o usuário;
Catalog: Exibe a relação de seções da página, bem como permite ao usuário
indicar em qual seção determinado item deverá permanecer. Permite restaurar
controles que foram fechados.
Design: Permite fazer o gerenciamento de zonas em uma página;
Edit: Permite editar zonas de uma página
WebPartManager
O WebPartManager é um controle disponível na guia WebParts e é o responsável por
todo o gerenciamento do conteúdo e de seu estado. É o principal controle e é obrigatório
quanto trabalhamos com WebParts.
O gerenciamento de estado e conteúdo do WebPartManager é feito utilizando um banco
de dados do SQL Server 2005, de nome ASPNETDB.MDF, que pode ser encontrando
dentro da pasta App_Data.
73
WebPartZone
Outro controle importantíssimo e essencial é o WebPartZone. Através deste podemos
definir as zonas onde serão agrupados o conteúdo da página. Este controle é um
container para controles comuns, que de forma declarativa devem estar dentro da tag
ZoneTemplate.
Utilizando WebParts
Coloque sobre o Web Form criado um controle WebPartManager;
Coloque sobre o Web Form criado um controle WebPartZone;
Através da Smart Tag escolha uma das opções de auto-formatação;
Arraste para dentro do WebPartZone criado dois controles textbox;
Rode a aplicação
Com esta simplicidade nossa aplicação já contem alguma interatividade. Observe que
cada controle dentro da WebPartZone pode ser minimizado ou fechando, através da seta
a direita do controle:
74
Caso não apareça em sua aplicação o menu, ou mesmo se você não consegue
alterar o modo de sua página, basta você autenticar o usuário que esta
acessando a página, ou seja, não permitir acesso anônimo. A maneira mais
simples de faz isto é utilizando autenticação integrada do Windows.
Se você fechar um controle, não conseguirá mais restaurá-lo, mesmo que
reinicie a aplicação. Isto porque o WebPartManager mantém o estado da
aplicação. Na próxima seção veremos que no modo Catalog podemos trazer
os controles fechados de volta ao formulário.
Observe que no exemplo acima os controles possuem um texto personalizado, Primeiro
e Segundo. Isto pode ser feito através do atributo Title de cada controle contido dentro
da Zone Template. Isto deve ser feito de forma declarativa, pois esta não é uma
propriedade do controle:
<ZoneTemplate>
<asp:TextBox Title="Primeiro" ID="TextBox1"
runat="server"></asp:TextBox>
<asp:TextBox Title="Segundo" ID="TextBox2"
runat="server"></asp:TextBox>
</ZoneTemplate>
Você também pode personalizar os textos do Menu de controle através das propriedades
CloseVerb e MinimizeVerb, procurando pelo atributo Text. Outras mensagens e rótulos
que surgirão mais adiante poderão também ser personalizadas, basta procurar a
propriedade equivalente.
Modo Catalog
Como dissemos o modo padrão de uma página é o Normal. Vamos ver agora como
colocar uma página em modo Catalog, e quais as funcionalidades deste modo. Porém
antes vamos criar mais duas zonas, para isto adicione mais dois novos controles
WebPartZone ao formulário. Dentro do primeiro adicione dois controles Button, e no
segundo dois controles CheckBox. Adicione um terceiro botão, alterando a propriedade
text para Catalog, porém não o coloque dentro de nenhuma zona.
Para que seja possível colocar a página em modo catalogo você deve adicionar um
controle CatalogZone. De ao mesmo uma auto formatação. O Controle CatalogZone é
um container para Catálogos de Página. Coloque um controle PageCatalogPart dentro
do CatalogZone.
75
De um duplo clique sobre o botão Catalog, no manipulador de evento criado adicione o
seguinte código:
Dim mgr As WebPartManager
mgr = WebPartManager.GetCurrentWebPartManager(Page)
mgr.DisplayMode = mgr.SupportedDisplayModes.Item("Catalog")
WebPartManager mgr;
mgr = WebPartManager.GetCurrentWebPartManager(Page);
mgr.DisplayMode = mgr.SupportedDisplayModes["Catalog"];
O código acima declara um tipo WebPartManager e recebe o gerenciador da página por
referencia, em seguida altera seu modo para Catalog. Rode a aplicação e a coloque no
modo Catalog. Neste modo você pode:
Restaurar um controle fechado. Note que através das zonas listadas no DropDownList
Add to você pode inclusive restaurar o controle em outra zona:
76
Arrastar controles entre as zonas. Para isto basta clicar no titulo do controle e arrastá-lo
até a posição desejada:
77
Você pode ainda querer voltar a página ao modo normal. Para isto adicione um novo
botão externo a qualquer zona, coloque o titulo Normal e adicione o seguinte código:
mgr.DisplayMode = mgr.SupportedDisplayModes.Item("Browse")
WebPartManager mgr;
mgr.DisplayMode = mgr.SupportedDisplayModes["Browse"];
As alterações que o usuário faz nas zonas são persistentes, voltar ao modo
normal não irá desfazê-las.
Modo Design
Neste modo o usuário pode, alem de minimizar e fechar um controle, arrastá-los de uma
zona para outra ou mesmo ordená-los, tarefas que são possíveis também no modo
78
Catalog, porém sem exibir o controle CatalogZone e sem possibilidade de mostrar um
controle oculto.
Veja abaixo um exemplo de como colocar a página em modo Design:
mgr.DisplayMode = mgr.SupportedDisplayModes.Item("Design")
WebPartManager mgr;
mgr.DisplayMode = mgr.SupportedDisplayModes["Browse"];
Modo Edit
O modo mais complexo e rico em funcionalidades é o modo de Edição. Através dele o
usuário final poderá personalizar inúmeros aspectos dos controles, como aparência,
comportamento e layout.
O Modo de edição é possível com a adição do controle EditorZone, este também é um
container, que pode receber um ApperanceEditorPart e/ou BehaviorEditorPart e /ou
LayoutEditorPart e /ou PropertyEditorPart.
Vamos os dois primeiros em funcionamento, para isso adicione um controle EditorZone
a sua página e um button com a propriedade text configurada como Edit. No
manipulador de evento do botão adicione o seguinte código:
mgr.DisplayMode = mgr.SupportedDisplayModes.Item("Edit")
WebPartManager mgr;
mgr.DisplayMode = mgr.SupportedDisplayModes["Edit"];
É preciso fazer algumas configurações para o modo de edição funcionar.
Primeiramente adicione o seguinte nó ao arquivo web.config de sua aplicação
79
<webParts>
<personalization>
<authorization>
<allow users="*" roles="admin" verbs="enterSharedScope"/>
</authorization>
</personalization>
</webParts>
Esta configuração deve estar dentro do nó system.web.
Em seguida adicione o seguinte código ao evento PageLoad da página:
If WebPartManager1.Personalization.Scope = PersonalizationScope.User _
AndAlso WebPartManager1.Personalization.CanEnterSharedScope Then
WebPartManager1.Personalization.ToggleScope()
End If
if (WebPartManager1.Personalization.Scope = PersonalizationScope.User
&& WebPartManager1.Personalization.CanEnterSharedScope)
{
WebPartManager1.Personalization.ToggleScope();
}
Para não tornar o aprendizado mais claro e simples, vamos estudar um os quatro
editores existentes.
ApperanceEditorPart
Adicione um controle ApperanceEditorPart ao EditorZone. Rode a aplicação e clique
em Edit para permitir que um controle entre em modo de edição. Observe que em todo o
controle, no menu a esquerda, surge uma nova opção: Edit:
80
Ao clicar na opção Edit, as opções do controle ApperanceEditorPart que adicionamos
ao container são exibidas, você pode alterá-las a seu gosto. Para persistir as alterações
clique em Apply, ou Cancel para cancelar.
81
As alterações irão persistir mesmo se você fechar o navegador.
BehaviorEditorPart
Remova o ApperanceEditorPart e adicione um BehaviorEditorPart, clique no botão Edit
e em seguida no comando edit de algum controle:
82
83
Veja que são muitas configurações de comportamento possíveis. Faça alguns testes, por
exemplo, desmarque a opção Allow Close e verifique que a opção de fechar desaparece
do controle.
84
9. Acesso a Dados
Um das novidades no lançamento do primeira versão do Framework .NET, foi o
ADO.NET, sucessor do ADO que até então era o modelo de acesso a dados da
Microsoft.
Surgiu com a promessa de ser um modelo desconectado para um mundo conectado: sua
arquitetura era preparada para a Internet, onde as aplicações poderiam abrir uma
conexão e recuperar dados, fechar a conexão, trabalhar desconectados e só voltar a abrir
a conexão no momento de atualizar a fonte de dados.
O ADO.NET cumpriu seu objetivo: Trouxe um modelo de acesso a dados poderoso e
bastante flexível, otimizado para aplicações remotas.
SQLDataSource e GridView
O modelo de acesso a dados proposto pelo ADO.NET embora poderoso, é extramente
complexo: para executar operações em uma fonte de dados o desenvolvedor teria que
utilizar uma grande quantidade de classes como Connection, Transaction, Command,
DataReader, DataAdapter, DataSet, DataTable etc. e entender como elas se interrelacionam.
Na verdade isso não mudou desde a versão 1.1: A estrutura do ADO.NET é
basicamente a mesma. Porém uma novidade a partir do .NET 2.0 foram algumas classes
denominados DataSource, entre eles o SQLDataSource.
Estudamos no módulo II a classe SiteMapDataSource
As classes DataSource é uma classe que nos permite acessar diversos bancos de dados
relacionais ou não, e que internamente utiliza diversas objetos do ADO.NET, tornando
o seu uso mais simples através de um único objeto. Por exemplo, para retornar um
conjunto de dados de um servidor SQLServer, por exemplo, você precisar no mínimo
de um SQLConnection, um SQLCommand e um SQLDataReader. Por outro lado você
pode obter o mesmo conjunto de dados utilizando um único SQLDataSource, que
internamente fará uso destes objetos.
85
Apesar do SQLDataSource fornecer um modelo simplificado e mais
amigável, você deve conhecer os componentes do ADO.NET, pois a
verdadeira funcionalidade de acesso a dados está nestas classes. ADO.NET
será estudado mais adiante neste capitulo.
Para demonstrar como é fácil e rápido criar uma aplicação que retorne uma tabela de um
banco de dados em uma página ASP.NET, vamos demonstrar passo a passo a criação de
uma aplicação utilizando o SQLDataSource.
Uma tabela sem nenhum código
Neste exemplo você verá que é possível retornar um conjunto de dados sem escrever
sequer uma linha de código:
Nestes exemplos estaremos utilizando o banco de dados AdventureWorks,
que é o banco de dados de demonstração do SQL Server 2005. Você pode
baixar este banco de dados do site oficial do SQL Server e instalá-lo,
inclusive na versão Express. Se preferir você pode praticar com qualquer
outro banco de dados, inclusive da versão 2000.
Da barra de ferramentas Data, arraste um controle SQLDataSorce para o Web Form
Default.aspx;
Na Smart Tag do controle, clique em Configure DataSource;
86
É exibido um assistente de configuração. Na primeira etapa você deve informar com
qual servidor deseja realizar a conexão. Para isto clique em New Connection, selecione
Microsoft SQL Server em Data Source e .NET FrameWork Data Provider for SQL
Server em Data Provider, em seguida clique em continue.
Em seguida é exibida a caixa de dialogo Add Connection, onde você deve informar as
opções de conexão com os servidor:
87
De volta ao assistente, clique em Next;
Neste passo você deve definr uma clausula Where e / ou OrderBy. Se você informar
que deseja salvar a String de Conexão. Mantenha a opção marcada com o nome padrão
para a string de conexão;
No próximo passo você deve montar a consulta SQL. Informe uma tabela e as colunas
que deseja incluir na consulta. Se incluir a chave primaria entre as colunas de seus
Select, através da opção Advanced poderá ainda solicitar que sejam criados comandos
SQL para inclusão, alteração e exclusão:
88
A próxima etapa permite que você teste a consulta SQL Criada. Clique em Finish.
Se você examinar seu arquivo aspx poderá notas que o assistente configurou diversas
propriedades do controle:
89
<asp:SqlDataSource ID="SqlDataSource1" runat="server"
ConnectionString="<%$ ConnectionStrings:AdventureWorksConnectionString
%>"
DeleteCommand="DELETE FROM [Department] WHERE [DepartmentID] =
@DepartmentID"
InsertCommand="INSERT INTO [Department] ([Name], [GroupName],
[ModifiedDate]) VALUES (@Name, @GroupName, @ModifiedDate)"
SelectCommand="SELECT * FROM [Department]" UpdateCommand="UPDATE
[Department] SET [Name] = @Name, [GroupName] = @GroupName,
[ModifiedDate] = @ModifiedDate WHERE [DepartmentID] = @DepartmentID">
<DeleteParameters>
<asp:Parameter Name="DepartmentID" Type="Int16" />
</DeleteParameters>
<UpdateParameters>
<asp:Parameter Name="Name" Type="String" />
<asp:Parameter Name="GroupName" Type="String" />
<asp:Parameter Name="ModifiedDate" Type="DateTime" />
<asp:Parameter Name="DepartmentID" Type="Int16" />
</UpdateParameters>
<InsertParameters>
<asp:Parameter Name="Name" Type="String" />
<asp:Parameter Name="GroupName" Type="String" />
<asp:Parameter Name="ModifiedDate" Type="DateTime" />
</InsertParameters>
</asp:SqlDataSource>
Além dos comandos de seleção, atualização, exclusão e inclusão, foram criados os
parâmetros para a execução destas operações. Isto foi possível graças a inclusão da
chave primária entre os campos a serem utilizados durante o assistente.
Vamos agora exibir os dados na página:
Adicione um GridView da barra de ferramentas data. Use a opção Auto Format da
Smart Tag do controle para definir um layout para a tabela.
O GridView será estudado melhor neste capitulo, por enquanto ele é um
acessório para o estudo do SQLDataSource.
Ainda na Smart Tag, selecione SQLDataSource1 na opção ChoseDataSource.
Marque as opções Enable Paging. Enable Sorting, Enable Editing, Enable Deleting e
Enable Selecion na Smart Tag:
90
Por fim, adicione a propriedade DataKeyNames, o(s) nome(s) do(s) campo(s) que
compõe a chave primária da tabela.
Rode a aplicação
Parabéns! Você acabou de criar um software para exibir uma tabela em uma aplicação
Web, onde é possível ordenar, paginar, alterar e excluir registros sem escrever nenhuma
única linha de código!!
91
Obviamente se a operação de inclusão ou atualização violar alguma regra de
integridade do banco de dados, será gerado um erro.
As operações de atualização e exclusão só ocorrerão de forma correta desde
que você tenha as instruções SQL respectivas configuradas de forma correta.
Vamos ver agora algumas propriedades importantes do SQLDataSource:
Cache
O SQLDataSource possui embutido suporte a cache. Isto significa que após a execução
de uma consulta, o conjunto de resultados será armazenados na memória do servidor.
Na próxima consulta ao invés de recuperar as informações do banco de dados, o
SQLDataSource irá recuperá-los do cache.
Para habilitar cache no SQLDataSource, basta definir a propriedade EnableCache como
True. A propriedade CacheDurantion deve conter o tempo, em segundos, que os dados
serão mantidos em cache antes de nova consulta.
DataSourceMode
Esta propriedade indica como os dados serão carregados: Em um objeto DataSet ou um
objeto DataReader. No modo DataSet o controle que estiver ligado ao SQLDataSource
terá mais funcionalidades, como paginação e ordenação. No modo DataReader estas
funcionalidades não estarão disponíveis, porém por se tratar de um cursor unidirecional
e somente leitura, seu desempenho é superior.
ConnectionString
Através desta propriedade é definida a string de conexão, que contem as informações
para conexão como sistema gerenciador de banco de dados.
Executando uma consulta com parâmetros
Você pode querer definir dinamicamente um valor para a clausula where de sua
consulta. Para isto criamos um parâmetro e definimos um valor em tempo de execução.
92
O ASP.NET 2.0 prove funcionalidade para diversos tipos de parâmetros, como uma
QueryString, um controle, um cookie, uma variável de sessão entre outros.
Para exemplificar, vamos filtrar nossa consulta a partir de um valor da QueryString do
formulário, para isso faremos uma pequena alteração na propriedade SelectQuery do
SQLDataSource, adicionando uma clausula where e um parâmetro de nome
DepartmentID do tipo QueryString:
Ao rodar a aplicação passando um valor para a QueryString, nossa consulta é filtrada:
93
Neste segundo exemplo, vamos obter o valor para passar ao parâmetro através de um
controle. Primeiramente adicionamos um controle textbox ao formulário, em seguida
modificamos o mesmo parâmetro criado há pouco:
94
Coloque um button no formulário para causar um postback, preencha um valor no
textbox e clique no button, mesmo sem código nenhum nos eventos de servidor o filtro
deverá funcionar graças ao viewstate do textbox.
Você pode utilizar parametros também para as operações de atualização,
exclusão e inclusão.
Mais GridView
Na primeira versão do ASP.NET, um dos controles mais famoso foi o DataGrid. Com
ele era possível exibir dados tabulares com pouco código. No ASP.NET 2.0 ele foi
substituído pelo GridView, um controle ainda mais poderoso e que permite que muita
coisa possa ser feita sem uma linha de código sequer.
Na seção anterior estudamos rapidamente o GridView, vamos agora entende-lo melhor.
Editando Colunas
Você já viu como configurar um SQLDataSource. Faça isso e adicione um GridView a
um Web Form. Na Smart Tag do GridView indique o SQLDataSource no item Choose
Data Source. Isto também pode ser feito através da propriedade DataSourceID. Ainda
na Smart Tag, selecione Edit Colums. É exibido o editor de colunas:
95
A área de edição de colunas é dividida em três partes.
Na pequena área acima à esquerda temos a relação de campos disponíveis. BoundFields
são campos oriundos de nossa fonte de dados, se você já ligou seu DataGridView ao
SQLDataSource, os campos já devem aparecer disponíveis nesta sessão. Podemos ainda
definir campos como CheckBoxField, HyperLinkField, ButtonField, ImageField,
CommandField que podem ser Edit, Update, Cancel ou Select ou Delete, e
TemplateField, onde podemos criar um campo Customizado.
Em baixo a esquerda vemos os campos selecionados para exibição em nosso GridView,
e a direita, podemos configurar as propriedades de cada campo. Você pode, por
exemplo, criar uma mascara de formatação para exibir um valor de moeda, ou mesmo
mudar o texto do cabeçalho do campo.
Na tela acima, observe que é exibido entre os campos selecionados, um campo
CommandField. Isto porque na Smart Tag do controle foram marcadas as opções de
habilitar seleção, exclusão e edição. Podemos definir a aparência destes botões.
96
Por exemplo, se você quer que eles apareçam a direita do GridView e não a esquerda,
basta move-los para baixo. A propriedade ButtonType permite os mesmos sejam
exibidos como, por exemplo, botões ou imagens ao invés de links. Se você optar por
imagem deve informar o caminho delas através da propriedade ImageUrl, formado pelo
prefixo do nome do botão. Outra propriedade importante é definir o texto de cada botão.
Vejam um exemplo de um GridView com alguma personalização:
Se seu DataSource tiver um campo do tipo boleano, será incluido automaticamente
entre as colunas disponíveis um CheckBoxFiled
Não vamos estudar todas as propridades de cada tipo de campo. O importante
é você saber onde encontra-las.
Utilizando um DetailView
Uma outra novidade a partir do ASP.NET 2.0 é o DetailView. Sua principal utilidade é
exibir detalhes de um único registro, que normalmente são ocultados num GridView por
97
otimização de espaço. Você também pode utilizá-lo para incluir ou até mesmo excluir
um registro.
Para utilizá-lo basta adicionar ao Web Form e configurar suas principais propriedades
através da smart tag, não esquecendo de informar a fonte de dados e de configurar as
colunas. O ideal é que colunas que estejam marcadas como invisíveis no GridView,
sejam visualizadas no DetailView.
Para que o controle se mantenha atualizado, ou seja, exiba sempre os detalhes do
registro selecionado no GridView, é preciso adicionar um segundo SQLDataSource,
cujo comando de seleção tenha um parâmetro que aponte para campo chave do item
selecionado no GridView. A tela abaixo exibe a construção de um parâmetro. Observe
que é indicada a coluna, o operador, a origem (source) que é control, e em ControlID
informamos o GridView que fornecerá o valor para o parâmetro.
Abaixo você pode observar a aplicação em execução:
98
FormView
Com certa semelhança com o DetailView, o FormView é formado por diversos
templates com controles como labels e caixas de texto. È ideal para exibir dados na tela
em forma de formulário. Também possui templates prontos e incluir um novo registro.
Se seus SQLDataSource possui a instrução Insert, o FormView vai estar pronto para a
inclusão de novos registros. No imagem abaixo podemos ver um FormView conectado
a um SQLDataSource:
99
Abaixo você pode observar os templates que formam o FormsView. Cada um deles
pode ser configurado de acordo com sua funcionalidade.
Controles ListView e DataPager
Os controles ListView e DataPager foram introduziados no ASP.NET .35. Desde o
lançamento da primeira versão do ASP.NET a Microsoft incluiu em suas IDEs diversos
controle de listagem de dados: DataGrid, GridView, Repeater entre outros. Embora
sejam todos controles de listagem de dados, eles tem focos diferentes: o Repeater
permite maior controle sobre o conteúdo renderizado, o DataList veio otimizado para
exibição de dados em várias colunas etc. A evolução mesmo ficou por conta dos
100
controles
multifuncionais , inicialmente o DataGrid na versão 1.X, o GridView
surgindo na versão 2.0 trazendo novas características e agora, no ASP.NET 3.5, o
ListView.
O ListView é tudo de bom: Permite maior controle sobre o conteúdo gerado através de
diversos eventos e templates, e, na minha opinião, o mais interessante: agora com um
InsertItemTemplate. O que isto significa? As operações de insert para o DataGrid e para
o GridView eram órfãs e tinham que ser tratadas a parte. Particularmente, com o
GridView, eu colocava um Formview em modo de inserção no EmptyDataTemplate do
GridView, e, ao clicar em um botão inserir normalmente colocado sobre o cabeçalho de
uma coluna, desconectava o controle de seu datasource. O efeito era que a listagem de
dados desaparecia dando lugar ao controle para inserção.Agora finalmente posso ter
todas as operações (Select, Insert, Update, Delete) em um mesmo controle! A inserção é
por padrão feita próxima ao rodapé do Listview.
ListView na prática
Se você já usou algum ancestral do ListView não terá qualquer dificuldade em se
familiarizar com este novo controle. Neste exemplo utilizo a boa e velha base de dados
NorthWind, rodando em uma instancia do SQL Server 2005 Express. Vale lembrar que
você pode baixar esta base de dados como um download independente a qualquer
momento, através do site da Microsoft, ou utilize qualquer base de dados de sua
preferência.
Primeiramente abra o Visual Studio 2008, clique em New Web Site. Selecione .NET
Framework 3.5 em na parte superior da janela, marque a opção ASP.NET Web Site e
escolha a linguagem de sua preferência.
101
Abra a guia Data na caixa de ferramentas. Neste tutorial vamos trabalhar com três
controles: ListView, DataPager e SqlDataSource. Observe na asp3imagem abaixo os
controles circulados:
Inicialmente jogue um controle ListView sobre o WebForm.
102
Na SmartTag do controle, clique em New data source, desta forma o Visual Studio vai
criar um novo controle de acesso a dados. Poderíamos ter feito isto manualmente,
arrastando um controle SqlDataSource para o WebForm.
É exibido o DataSource Configuration Wizard. Na primeira etapa devemos informar a
origem dos dados. Selecione Database e clique em Ok.
Na próxima etapa devemos configurar a conexão:
103
Clique em New Connection e informe os dados de sua conexão, como no exemplo
abaixo:
De volta ao assistente, clique em Next. Nesta etapa você deve informar se deseja salvar
a string de conexão no arquivo de configuração da aplicação (Web.config). Marque sim
e clique em Next.
Agora é o momento de informar a tabela ou a consulta que vai dar origem aos dados.
No exemplo abaixo selecionei a tabela Employees com algumas colunas.
104
Antes de prosseguir, clique em Advanced e marque a opção Generate Insert, Update,
and Delete statements para que o Visual Studio produza automaticamente as instruções
Sql para que o ListVew possa incluir, atualizar e excluir dados automaticamente.
Importante observar que para esta opção estar habilitada é fundamental que entre as
colunas selecionadas estejam aquelas que compõem a chave primária da tabela. No
exemplo acima trata-se da coluna EmployeeID.
Clique em Next, nesta última opção do assistente você pode testar a consulta gerada.
Clique em Finish.
Se observarmos o código gerado para o ListView até o momento é demasiadamente
simples, pois ainda não definimos nenhuma propriedade além de DataSourceID:
105
<asp:ListView ID="ListView1" runat="server"
DataSourceID="SqlDataSource1">
</asp:ListView>
Vamos tratar de configurar o ListView. Voltando a área de design, na Smart tag do
ListView clique em configure ListView:
Nesta janela podemos configurar as funcionalidade principais do ListView.
Primeiramente um Layout, teste todas as opções e veja o comportamento na janela
Preview. Abaixo você pode selecionar um estilo. Em opções devemos informar se o
ListView vai ter habilitadas funções de edição, inserção, exclusão e paginação. Para este
exemplo deixa marcado todas as opções, com exceção de paginação:
Clique em ok e rode a aplicação. Observe que temos agora uma listagem de dados 100%
funcional. Observe que a linha de inserção é incluída no junto ao rodapé da listagem:
106
DataPager
Assim como seus ancestrais, o ListView tem paginação nativa embutida. Porém agora
temos um controle de paginação à parte: O DataPager.
Curioso é que o DataPager funciona apenas com o ListView. Você deve estar se
perguntando: Então porque usá-lo ao invés da paginação embutida no ListView?
Como um controle separado temos mais poder sobre como queremos nossa paginação.
Também devemos lembrar que o DataPager não foi concebido para funcionar
exclusivamente com o ListView, mas com qualquer controle que implemente a interface
IPageableItemContainer. No ambiente do ASP.NET 3.5 este é o único controle nativo
que implementa tal interface.
Mãos a obra. Arraste um controle DataPager para o Web Form. Na janela de
propriedades do controle, defina PagedControlId para ListView1 e PageSize para 5,
pois a tabela que escolhi para o exemplo possui menos que 10 registros:
Na Smart Tag do DataPager, defina um estilo de paginação, que pode ser com botões do
tipo próximo/anterior ou mesmo numérica. Para o exemplo escolhi Próximo/anterior:
107
Neste momento, ao rodar a aplicação, já temos nosso ListView com as funcionalidades
de paginação em funcionamento:
Ado.net
Como dissemos no inicio do capitulo, o ADO.NET é foi criado para ser um modelo de
dados desconectado, pronto para Web.
È formando por uma série de objetos, alguns independentes de fonte de dados, outros
não. Um objeto independe de fonte pode abrigar ao mesmo tempo dados de origens
diversas, como por exemplo, uma tabela de um banco de dados Oracle e outra de um
arquivo Access.
O Objeto de conexão para o SQLSever é o SQLConnection. Havendo uma conexão os
dados podem ser recuperados para um SQLDatareader, SQLCommand ou mesmo um
DataSet.
O SQLCommand permite executar um comando SQL contra uma fonte de dados. Pode
trabalhar apenas com um SQLConnection ou em conjunto com outras classes
ADO.NET.
Um SQLDataReader é um cursor unidirecional e somente leitura. É ótimo para leitura
de dados ou geração de relatórios, pois é veloz. Porém não permite qualquer alteração
nos dados, além de monopolizar a conexão com o banco de dados enquanto esta
operando.
108
Um DataSet é um pequeno banco de dados em memória. Você não precisa de uma
conexão permanente com o banco de dados enquanto estiver utilizando os dados. Você
pode abrir a conexão, recuperar os dados, executar alterações, exclusões ou inclusões,
abrir novamente a conexão e atualizar a fonte de dados. Dentro de uma DataSet
podemos ter uma ou mais DataTables, que são tabelas, que podem ter origens de fontes
de dados independentes. Podemos ainda ter DataRelations, que representam relações
entre tabelas. Uma DataTable é formado por DataRows, que representam colunas. Outra
classe importante é DataView, que é exatamente o que parece: Uma visão de dados. Um
DataTable possui um DataView padrão, outros podem ser criados. Todos os objetos
descritos neste parágrafo são independentes da fonte dos dados, pois são armazenados
em memória no formato XML.
Agora como transformar dados de uma fonte especifica em um DataSet? Esta tarefa é
do SQLDataAdapter , que faz a transformação dos dados entre a sua origem, através da
conexão, até o DataSet e vice-versa. O SQLDataAdapter devolve a conexão no estado
que a encontrou: Se estava aberta, mantém aberta. Se estava fechado, abre, executa a
operação e fecha a conexão.
109
Vamos ver as principais classes do ADO.NET
Embora existam provedores para acessar as mais variadas fontes de dados,
iremos demostrar as funcionalidades do ADO.NET com classes de acesso ao
SQLServer. A funcionalidade das demais classes é bem semelhante.
SQLConnection
Para utilizar as classes ADO.NET para SQL Server, você deve importar o
namespace system.data.sqlclient. Para as classes independentes de fonte de
dados, como o DataSet, o namespace é sytem.data
O SQLConnection representa uma conexão com um banco de dados SQLServer. Suas
principais propriedades são ConnectionString, que é a string com os parâmetros de
conexão com o servidor. Entre os métodos temos Open, que abre a conexão, e close,
que fecha a mesma. A propriedade State retorna o estado atual da conexão. Vejamos o
exemplo abaixo:
110
Dim Conexao As New SqlConnection
Conexao.ConnectionString = "Data Source=LOCALHOST\SQLEXPRESS;" & _
"Initial Catalog=AdventureWorks;Integrated Security=True"
Conexao.Open()
'Executa algum código
Conexao.Close()
SqlConnection Conexao = new SqlConnection();
Conexao.ConnectionString = "Data Source=LOCALHOST'\'SQLEXPRESS;" +
"Initial Catalog=AdventureWorks;Integrated Security=True";
Conexao.Open();
//Executa algum código
Conexao.Close();
Ao abrir uma conexão mil coisas podem dar errado: O servidor não estar
disponível, a string de conexão esta errada, o usuário não ter permissão de
acesso...só para citar algumas. Por este motivo a abertura da conexão acima
deveria ser protegida em um bloco try...except. Isto foi omitido para fins de
clareza do código...no mundo real, é uma prática que deve ser considerada.
SQLCommand
A classe SQLCommand permite que sejam executados quaisquer comando SQL. Para
ser executado com sucesso precisa de uma instrução SQL ou de um nome de tabela ou
procedure, a ser informada na propriedade CommandText e uma conexão informada
através da propriedade Connection, que deve ser um objeto SQLConnection.
A execução do comando pode ser feito através de quatro métodos distintos:
ExecuteNonQuery: Ideal para execução de instruções que não retornam um conjunto de
dados. Retorna um valor inteiro informando o número de linhas afetadas;
ExecuteReader: Para utilização com um SQLDataReader, a ser estudado na próxima
sessão;
ExecuteScalar: Retorna apenas a primeira coluna da primeira linha, o restante dos
valores são ignorados. Ideal para sumarização de valores.
O exemplo abaixo retorna o total de registros de uma tabela e exibe em um textbox,
para funcionar perfeitamente basta encaixá-lo no comentário do exemplo anterior, de
demonstração da conexão:
111
Dim comando As New SqlCommand
comando.Connection = Conexao
comando.CommandText = "SELECT COUNT(*) FROM Sales.Currency"
Dim a As Integer = comando.ExecuteScalar
TextBox1.Text = Convert.ToString(a)
SqlCommand comando = new SqlCommand();
comando.Connection = Conexao;
comando.CommandText = "SELECT COUNT(*) FROM Sales.Currency";
int a = Convert.ToInt32(comando.ExecuteScalar());
TextBox1.Text = Convert.ToString(a);
SQLDataReader
Como dito o SQLDataReader é um cursor unidirecional e somente leitura, porém muito
veloz. Você pode ligar seu resultado diretamente a um controle:
comando.CommandText = "SELECT CurrencyCode,Name FROM Sales.Currency"
Dim reader As SqlDataReader = comando.ExecuteReader
GridView1.DataSource = reader
GridView1.DataBind()
comando.CommandText = "SELECT CurrencyCode,Name FROM Sales.Currency";
SqlDataReader reader = comando.ExecuteReader();
GridView1.DataSource = reader;
GridView1.DataBind();
Neste outro exemplo, ele é ligado a um DropDownList. Note que nome da moeda é
ligado a propriedade TextField, enquanto o código a propriedade Valuefield, desta
forma será exibida a nome da moeda para o usuário, mas programaticamente poderemos
facilmente recuperar o código da moeda selecionada:
Dim reader As SqlDataReader = comando.ExecuteReader
DropDownList1.DataSource = reader
DropDownList1.DataValueField = "CurrencyCode"
DropDownList1.DataTextField = "Name"
DropDownList1.DataBind()
112
SqlDataReader reader = comando.ExecuteReader();
DropDownList1.DataSource = reader;
DropDownList1.DataValueField = "CurrencyCode";
DropDownList1.DataTextField = "Name";
DropDownList1.DataBind();
No próximo exemplo, temos apenas uma pequena alteração: È passado um argumento a
sobrecarga do construtor do ExecuteReader: CommandBehavior, que é um enumerador
que vai determinar o comportamento do SQLDataReader. Neste exemplo,
CommandBehavior.CloseConnection fecha a conexão com o banco de dados após a
utlização:
Dim reader As SqlDataReader =
comando.ExecuteReader(CommandBehavior.CloseConnection)
DropDownList1.DataSource = reader
DropDownList1.DataValueField = "CurrencyCode"
DropDownList1.DataTextField = "Name"
DropDownList1.DataBind()
SqlDataReader reader =
comando.ExecuteReader(CommandBehavior.CloseConnection);
DropDownList1.DataSource = reader;
DropDownList1.DataValueField = "CurrencyCode";
DropDownList1.DataTextField = "Name";
DropDownList1.DataBind();
Finalmente, para percorrer os itens de um SQLDataReader, podemos utilizar o método
Read, que retorna verdadeiro e avança um registro, enquanto houverem linhas
disponíveis. Neste exemplo as linhas são adicionadas a um ListBox:
While reader.Read
ListBox1.Items.Add(reader.Item("Name"))
End While
113
while (reader.Read())
{
ListBox1.Items.Add(Convert.ToString(reader["Name"]));
}
Parâmetros
A utilização dos classes de parametros do ADO.NET são um ponto
importante no quesito segurança, pois eliminam o risco de injeção de SQL
A classe parâmetros permite que sejam criados parâmetros para a execução de
instruções sql. Na instrução o parâmetro deve ser identificado por @ mais um
identificador único. O objeto parâmetro deverá ter o mesmo nome o qual vai passar o
valor. Vejamos o exemplo abaixo:
comando.CommandText = "SELECT * FROM Person.Contact " & _
" where ContactID = @ContactID"
Dim parametro As New SqlParameter("@ContactID", SqlDbType.Int)
parametro.Value = Convert.ToInt32("1")
comando.Parameters.Add(parametro)
GridView1.DataSource = reader
SqlParameter parametro = new SqlParameter("@ContactID",
SqlDbType.Int);
parametro.Value = Convert.ToInt32("1");
comando.Parameters.Add(parametro);
GridView1.DataSource = reader;
Primeiro instanciamos o objeto SQLParameter utilizando um de seus construtores.
Existem sete sobrecargas. No exemplo, é passado o nome do parâmetro e o tipo. Em
114
seguida atribuímos um valor ao parâmetro, e finalmente o adicionamos a coleção de
parâmetros do comando.
O objeto parametro não precisa ter o mesmo nome do campo da tabela
Se você estiver usando outro provider, como o OleDb, os parametros devem
ser identificados por ? . Os valores devem ser fornecidos na ordem em que
eles estão no SQL, pois não há como nomealos
SQLDataAdapter , DataSet e DataTable
A unica função do SQLDataAdapter é fazer a ligação entre a fonte de dados e o
DataSet. Um DataAdapter, assim como um SQLDataSource, pode receber até quatro
instruções SQL: Para consulta, inclusão, exlcusão e alteração.
Existem quatro sobrecargas do contrutor de um DataAdapter. Se você não quizer
instanciar objetos connection e command, pode utilizar uma sobrecarga que recebe o
comando sql de seleção e a string de conexão, que estes objetos são criados
implicitamente.
O preenchimento de um DataSet por um DataAdapter é feito através do método fill:
Dim Adp As New SqlDataAdapter("SELECT * FROM Person.Contact ",_
Conexao)
Dim Ds As New DataSet
Adp.Fill(Ds)
GridView1.DataSource = Ds
SqlDataAdapter Adp = new SqlDataAdapter
("SELECT * FROM Person.Contact ", Conexao);
DataSet Ds = new DataSet();
Adp.Fill(Ds);
GridView1.DataSource = Ds;
A atualização dos dados é feita através do método update. Apenas quando o método é
executado que qualquer alteração nos dados serão replicados ao banco de dados, pois,
lembrando, o DataSet trabalha desconectado.
115
Outro aspecto importante é que o para fazer uma atualização, seja exclusão, inclusão ou
alteração, o Adapter precisa obter os comando SQL para tais operações. Através da
classe CommadBuilder podemos gerar automaticamente estas instruções para o
SQLDataAdapter. No exemplo abaixo, o campo FirstName da tabela Person.Contact é
alterado para Gustavo II:
Dim Adp As New SqlDataAdapter("SELECT * FROM Person.Contact ",_
Conexao)
Dim CmdBuilder As New SqlCommandBuilder(Adp)
Ds.Tables(0).Rows(0).Item("FirstName") = "Gustavo II"
Adp.Update(Ds)
SqlCommandBuilder CmdBuilder = new SqlCommandBuilder;
Ds.Tables[0].Rows[0]["FistName"] = "Gustavo II";
Adp.Update(Ds);
Como o DataSet é um pequeno banco de dados em memória, podemos adicionar varias
tabelas ao mesmo, inclusive de fontes diferentes. No exemplo a seguir dois objetos
DataTable são preenchidos e depois adicionados a um mesmo DataSet.
Dim Adp1 As New SqlDataAdapter("SELECT * FROM Person.Contact ",_
Conexao)
Dim Dt1 As New DataTable
Adp1.Fill(Dt1)
Dim Adp2 As New SqlDataAdapter("SELECT * FROM Person.ContactType ",_
Conexao)
Dim Dt2 As New DataTable
Adp2.Fill(Dt2)
Ds.Tables.Add(Dt1)
Ds.Tables.Add(Dt2)
SqlDataAdapter Adp1 = new SqlDataAdapter
DataTable Dt1 = new DataTable();
Adp1.Fill(Dt1);
SqlDataAdapter Adp2 = new SqlDataAdapter
("SELECT * FROM Person.ContactType ", Conexao);
DataTable Dt2 = new DataTable();
Adp2.Fill(Dt2);
116
Ds.Tables.Add(Dt1);
Ds.Tables.Add(Dt2);
Finalmente, neste último exemplo adicionamos uma linha a uma tabela. Primeiramente
preechemos a tabela através de um DataAdapter. Em seguida instanciamos um objeto
DataRow a partir da tabela, ou seja, com sua definição de dados, preenchemos os
valores dos campos, adicionamos a coleção de dados do DataTable
e finalmente
invocamos o método Update do Adapter para atualizar a fonte de dados:
Dim Adp As New SqlDataAdapter("SELECT * FROM Sales.Currency ",
Conexao)
Dim Dt As New DataTable
Adp.Fill(Dt)
Dim Dr As DataRow = Dt.NewRow
Dr("CurrencyCode") = "BRU"
Dr("Name") = "Brazilian UNReal"
Dr("ModifiedDate") = "01/01/2006"
Dt.Rows.Add(Dr)
Adp.Update(Dt)
("SELECT * FROM Sales.Currency ", Conexao);
SqlCommandBuilder CmdBuilder = new SqlCommandBuilder(Adp);
DataTable Dt = new DataTable();
Adp.Fill(Dt);
DataRow Dr = Dt.NewRow();
Dr["CurrencyCode"] = "BRU";
Dr["Name"] = "Brazilian UNReal";
Dr["ModifiedDate"] = "01/01/2006";
Dt.Rows.Add(Dr);
Adp.Update(Dt);
Observe que neste último exemplo sequer utlizamos um DataSet!
SQLTransaction
O ADO.NET também possui classes que dão suporte a controle de transações. Devemos
declarar uma transação e iniciá-la pelo objeto de conexão e ainda atribuí-la aos objetos
que farão parte da operação. Para confirmar as operações chamamos o método commit
do objeto Transaction, para desfazer o método é rollback.
117
No exemplo abaixo, adaptado de exemplo anterior, é criado um objeto SQLTransaction
e atribuído a propriedade Transaction do comando insert do DataDdapter, que é o
comando utilizado para inserir um novo registro. O método update do DataAdapter, que
é o método que de fato atualiza a base de dados, é chamado em um bloco protegido
try..cacth. Se tudo der certo a transação é confirmada. Caso algo de errado a transação é
desfeita.
Dim Trans As SqlTransaction = conexao.BeginTransaction
Dim Adp As New SqlDataAdapter("SELECT * FROM Sales.Currency ",_
Conexao)
Adp.InsertCommand.Transaction = Trans
Dim Dt As New DataTable
Adp.Fill(Dt)
Dim Dr As DataRow = Dt.NewRow
Dr("CurrencyCode") = "BRU"
Dr("Name") = "Brazilian UNReal"
Dr("ModifiedDate") = "01/01/2006"
Dt.Rows.Add(Dr)
Try
Adp.Update(Dt)
Trans.Commit()
Catch ex As Exception
Trans.Rollback()
End Try
SqlTransaction Trans = Conexao.BeginTransaction();
SqlDataAdapter Adp = new SqlDataAdapter(
"SELECT * FROM Sales.Currency ", Conexao);
Adp.InsertCommand.Transaction = Trans;
SqlCommandBuilder CmdBuilder = new SqlCommandBuilder(Adp);
DataTable Dt = new DataTable();
Adp.Fill(Dt);
DataRow Dr = Dt.NewRow();
Dr["CurrencyCode"] = "BRU";
Dr["Name"] = "Brazilian UNReal";
Dr["ModifiedDate"] = "01/01/2006";
Dt.Rows.Add(Dr);
try
{
Adp.Update(Dt);
Trans.Commit();
}
catch (Exception s)
{
Trans.Rollback();
}
118
10. LINQ
Como falamos nas seções iniciais deste curso, o LINQ, uma promessa antiga da
Microsoft, veio para preencher o vazio existente entre a orientação a objetos e os
bancos de dados relacionais.
Na verdade o LINQ foi um pouco além disso, se tornando uma linguagem padrão de
manipulação de dados em diversos formatos. Existem três forma de LINQ: LINQ para
Objetos, LINQ para XML e LINQ para SQL.
Vamos agora fazer uma breve introdução ao LINQ para SQL. Crie uma nova aplicação
ASP.NET 3.5, na caixa de dialogo Add New Item selecione LINQ to SQL Classes, de o
nome da base de dados que irá utilizar, no meu Caso, NorthWind:
O VS sugere que o arquivo será criado na pasta App_code, clique em Sim.
Abra o Server Explorer, conecte com o banco de dados que irá utilizar, expanda a pasta
Tables:
119
Arraste as tabelas que deseja utilizar para a área especifica do arquivo dbml. No
exemplo arrastei a entidade Customers e Orders. Note que o VS mapeou a tabela em
duas classes, inclusive alterando o nome para Customer e Order. O VS também indiciou
o relacionamento entre as classes:
120
Agora vá para o WebForm criado na sua aplicação. Na área de design coloco que
controle GridView, de um duplo clique sobre o formulário para criar um manipular para
o envento OnLoad do WebForm. Digite o seguinte código:
Protected Sub Page_Load(ByVal sender As Object, ByVal e As
System.EventArgs) Handles Me.Load
Dim db As New NorthwindDataContext
Dim consulta = From n In db.Customers Select n
GridView1.DataSource = consulta
End Sub
public partial class Default3 : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
NorthwindDataContext db = new NorthwindDataContext();
var consulta = from n in db.Customers select n;
GridView1.DataSource = consulta;
}
}
Rode a aplicação e observe o resultado.
121
11. MemberShip e Roles
No ASP Clássico e em outras linguagem para web você tinha que fazer todo o trabalho
de gerenciamento de usuários e grupos: Criar usuários, paginas de logins, trocas de
senhas, recuperação de senhas, autenticação, criação de grupos de usuários,
gerenciamento de grupos além de toda a estrutura de armazenamento necessária para
isto tudo. Você também tinha que programar toda a parte de autorização de seu
aplicativo: normalmente cada grupo de usuários estava restrito a um determinado
numero de ações que poderiam ser executadas e ou paginas a qual ele poderia acessar.
Na primeira versão do ASP.NET muita coisa mudou, a programação de tudo isso citado
no parágrafo anterior ficou um pouco mais fácil, mas ainda era preciso muito trabalho
manual.
A partir do ASP.NET 2.0, um novo recurso denominado MemberShip, veio para tornar
tudo isso muito mais fácil. Mais do que isso, para revolucionar o gerenciamento de
usuário, grupos e permissões. Além de uma série de controles prontos para
gerenciamento de usuários e autenticação, o ASP.NET pode agora cuidar do
armazenamento de tudo isso automaticamente através de um banco de dados do
SQLExpress ou em qualquer outra fonte de dados que você quiser, inclusive o
Active
Directory.
Definindo um Site para utilizar Forms Autentication
Uma aplicação Web pode ser totalmente publica, com um porta de noticias, ou pode
requerer autenticação, como um InternetBanking, ou ainda pode ser um misto de ambos:
Um site de comércio eletrônico onde você navega e compra de forma anônima e se
autentica na hora do pagamento.
A autenticação em uma aplicação Web pode se dar de varias formas: Integrada com o
Active Directory, onde poderão ser utilizadas as credencias que o usuário logou no
diretório, Passport, que é um serviço pago mantido pela Microsoft e que já teve seu fim
decretado, ou Forms, em que o usuário é autenticado através de informações digitadas
em um formulário.
122
A forma de autenticação na mais comum na internet é Forms. Windows é util por
exemplo, em uma aplicação de Intranet, em que podemos aproveitar as credencias do
usuário no Diretório.
Sugiro que você acompanhe os exemplos passa a passo, já que uma etapa é
diretamente dependente da outra.
Ao criar uma nova aplicação ASP.NET, por padrão ele não terá qualquer tipo de
autenticação e seus acesso será irrestrito.
Para conhecermos os conceitos crie uma aplicação com cinco WebForms:
Administracao.aspx, Default.aspx, Login.aspx, NovoUsuario.aspx e TrocarSenha.aspx.
Observe a aplicação na imagem abaixo:
Rode a aplicação e note que você pode navegar livremente entre os formulários.
Preparando o Arquivo web.config
123
Para definir autenticação Forms devemos fazer algumas alterações no arquivo
web.config como no exemplo abaixo:
Você pode fazer as alterações necessárias no web.config através da
ferramenta ASP.NET Configuration, que pode ser acionada através do ícone
no Solution Explorer.
<authentication mode="Forms">
<forms name=".ASPXAUTH"
loginUrl="login.aspx"
defaultUrl="default.aspx">
</forms>
</authentication>
Você esta informando ao ASP.NET que vai utilizar autenticação do tipo Forms, que o
nome do cookie de autenticação utilizado será .ASPXAUTH (padrão), que o formulário
de autenticação será login.aspx e que o formulário padrão será default. Outras
configurações podem ser adicionadas a este nó, estas exibidas são as mais relevantes.
Se você rodar a aplicação agora perceberá que ainda poderá navegar livremente entre as
páginas. O que deu errado? Embora você tenha definido um método de autenticação,
você ainda não restringiu o acesso de usuários anonimos a aplicação. Isso deve ser feito
com a adição de uma de um nó autorization, onde negamos acesso a usuários
desconhecidos (não autenticados) representado pelo ? :
<authorization>
<deny users="?" />
</authorization>
Ao final deste capitulo, apresento o web.config completo, da maneira que o
seu deverá estar após todos os exemplos. Utilize-o para localizar onde
determinada configuração deve se encaixar. Não copie o arquivo inteiro.
Agora defina a página clientes como página inicial e rode a aplicação.
Você deve observar duas coisas:
Você foi redirecionado para a página login.aspx, pois é a página definida para
autenticação em nosso arquivo de configuração.
124
Na URL, o ASP.NET adicionou a página inicial solicitada, de forma que você possa ser
redirecionado automaticamente após a autenticação
Agora estamos prontos para autenticar o usuário. Porém antes de autenticá-los
precisamos criá-los, é o que vamos ver a seguir.
Criando novos usuários com o controle CreateUserWizard
Criamos uma página para criação de usuários, NovoUsuario.aspx. Em aplicações este
tipo de pagina normalmente tem seu acesso irrestrito, ou seja, usuários anônimos podem
entrar livremente e se cadastrarem. Porém como definimos autenticação por
formulários, nenhum usuário conseguirá acessá-las sem estar autenticado. Temos que
torná-la publica, ou seja, de acesso anônimo.
Precisar definir algumas paginas, ou diretórios inteiros, com acesso anônimo e outras
não é algo comum, portanto é algo que você vai usar com freqüência em suas futuras
aplicações.
Para definirmos uma determinada página como publica basta adicionarmos um nó
location após o nó </system.web> já existente em nosso web.config, da seguinte forma:
<location path="NovoUsuario.aspx">
<system.web>
<authorization>
<allow users="*"/>
</authorization>
</system.web>
</location>
Estamos definindo que a página NovoUsuario.aspx é de acesso anonimo. Defina
NovoUsuario.aspx como página inicial e rode a aplicação. Note que você consegue
125
acessa-la normalmente, embora o restante da aplicação ainda lhe redirecione para o
Login.
Agora basta acionar um controle CreateUserWizard a nossa página de criação de
usuários. Note que este controle possui dezenas de propriedades que permitem sua
personalização, inclusive a troca das mensagens e labels. Não vamos entrar em detalhes
porque é quase tudo bem intuitivo, basta explorar o controle por alguns minutos.
Rode novamente a aplicação e crie um novo usuário, preenchendo todos os campos
obrigatórios, como na imagem abaixo:
Por padrão, a senha deve conter no mínimo 7 caracteres, sendo no mínimo um caractere
não alfanumérico ( # por exemplo).
O ASP.NET informa que a criação do usuário ocorreu com sucesso.
126
Antes de continuarmos, vamos entender o que o ASP.NET fez internamente.
Primeiramente abra ao Solution Explorer, clique com o botão direito em cima da
aplicação e clique em Refresh. Expanda o nó data. Note que foi criado um banco de
dados SQL Server Express (mdb).
De um duplo clique sobre o banco para abri-lo no Server Explorer. Note que foi criada
toda a estrutura de tabelas necessárias para o gerenciamento de usuários, grupos e
permissões:
127
Se você examinar a tabela aspnet_user, verá que o usuário criado esta armazenado
nesta.
Autenticando usuários com Login
Criado nosso usuário, agora podemos autenticá-lo. Para isso vamos utilizar o controle
Login, encontrado também na barra de ferramentas de mesmo nome. Coloque um
controle na pagina Login.aspx, defina a pagina default.aspx com pagina inicial e rode a
aplicação.
128
Se você informou o usuário e senha corretamente será redirecionado para a página
Default e terá livre acesso a todas as demais páginas da aplicação.
Trocando a senha com ChangePassword
Outra funcionalidade pronta e encapsulada em um controle é o ChangePassword. Para
utilizá-lo adicione o mesmo a pagina TrocarSenha.aspx, defina esta como pagina inicial
e rode a aplicação, após o login você é redirecionado para uma troca de senha, onde
você deve informar a senha atual, a nova senha e a confirmação da nova senha:
Uma mensagem informa que a senha foi troca com sucesso:
129
Criando um atalho para Login ou Logout com LoginStatus
O controle LoginStatus permite criar um atalho para efetuar um login ou Logout do
usuário. O controle possui duas visualização: Logged Out, que deve ser definida em
situações em que o usuário não se encontra autenticado, e Logged In, quando o usuário
já se autenticou no sistema, como você pode ver na imagem abaixo:
Normalmente você vai colocá-lo na visualização Logged Out em áreas publicas e como
Logged In em áreas autenticadas. Vamos testá-lo das duas formas.
Definimos anteriormente a pagina NovoUsuario.aspx como publica, portanto a mesma
poderá ser acessada sem autenticação. Coloque um controle LoginStatus nesta pagina
com a visão Logged out, defina esta pagina como página inicial e rode a aplicação:
130
Ao clicar em Login o usuário é redirecionado para a página de login da aplicação.
Agora vamos testá-lo na visão Logged In. Coloque um controle LogginStatus na página
default.aspx, defina sua visão como Logged In e defina esta página como inicial. Ao
rodar a aplicação você é direcionado para o Login, pois default.aspx não permite acesso
anônimo. Após a autenticação você é redirecionado para a página default, onde o
controle pode ser visualizado:
131
Clicando sobre o controle seu cookie de autenticação é excluído, e você passa a ser um
usuário não autenticado, portanto a aplicação o redireciona para a página de login.
Informando o usuário autenticado com LoginName
O controle LoginName permite que seja exibido em qualquer local o nome do usuário
autenticado. Basta colocá-lo sobre a página. Abaixo você pode ver o mesmo sobre a
página default.aspx, acessada obviamente após a autenticação:
Para personalizar a mensagem você pode utilizar a propriedade FormatString, que por
padrão esta preenchida como {0}. Para exibir uma mensagem como Usuário Logado:
Fernando basta alterar a propriedade da seguinte forma:
132
Observe o resultado em tempo de execução:
Se você colocá-lo em uma página publica e acessá-la sem autenticação, nada será
exibido.
Recuperando senhas com PasswordRecovery
O controle PasswordRecovery permite recuperar senhas esquecidas. Para utilizá-lo basta
colocar o controle sobre a pagina. O usuário terá que informar o nome de usuário e
responder a pergunta cadastrada durante a criação do usuário. A senha será enviada
para o E-mail também cadastrado durante a criação do usuário.
133
Para testar o controle primeiro você precisa informar um servidor smtp em seu arquivo
web.config, a fim de enviar o e-mail, para isso adicione o seguinte nó, logo após o nó
location criado anteriormente:
<system.net>
<mailSettings>
<smtp from="[email protected]">
<network
host="smtp.portal.com"
port="25"
userName="user"
password="123" />
</smtp>
</mailSettings>
</system.net>
Obviamente as informações acima são fictícias, você deve colocar informações de um
servidor smtp válido.
O próximo passo é colocar um controle PasswordRecovery em sua página de
login.aspx, que é local mais apropriado por ser onde normalmente o usuário descobre
que esqueceu a senha e também por ter acesso publico:
Defina login.aspx como página inicial e rode a aplicação. Para recuperar a senha,
primeiramente você vai ter que informar o nome do usuário:
134
Em seguida, deve responder a pergunta secreta cadastrada durante o login:
135
Se tudo correr bem, a aplicação informa que o e-mail foi enviado:
136
Ok, agora é só abrir o e-mail. Você vai receber uma mensagem semelhante a listada
abaixo:
Please return to the site and log in using the following information. User Name:
Fernando Password: rnaIrYqSBLAb|s
Bom, temos um problema. A senha retornada não é nem parecida com a que você
cadastrou. o que deu errado?
O motivo é simples: É uma boa prática armazenar senhas no forma de Hashs. Um hash
é um conjunto de caracteres obtidos através da aplicação de um algoritmo de
criptografia sobre alguma informação. Um hash tem algumas características peculiares:
Tem tamanho fixo, ou seja, se você aplicar um hash sobre a bíblia ou sobre o seu nome,
o tamanho do hash deverá ser o mesmo.
137
Deve ser único, ou seja, nenhum hash gerado a partir de uma informação diferente deve
ser igual a outro qualquer.
É irreversível. Ao contrário da criptografia simétrica em que podem embaralhar alguns
dados e fazer o caminho inverso, com um hash não podemos obter a informação
original.
O uso de hash é ideal para o armazenamento se senhas. No login, o sistema gera um
hash a partir da senha informada e compara com o valor armazenado. A grande
vantagem é que a senha original não precisa ser armazenada, corremos menos riscos. A
desvantagem é que se o usuário esquecer a senha, a única saída é criar outra. Foi o que
ASP.NET fez, gerou uma nova senha e enviou para o E-mail do usuário.
Opcionalmente você pode alterar este comportamento, para que as senhas sejam
armazenadas Criptografadas ou sem qualquer mecanismo de criptografia, porém é
recomendável manter o comportamento padrão do ASP.NET.
Conteudos para usuários anonimos e autenticados em uma mesma página
É comum também quereremos exibir para nossos usuários conteudos especificos
conforme sua situação na Site. Por exemplo, em uma determinada parte da página, se o
usuário esta logado exibimos seu nome de usuário, se não estiver logado, colocamos
uma caixa de login.
O controle LoginView tem exatamente este objetivo. Ele é formado de dois templates:
Anonymous e LoggedIn. Para testa-lo abra a pagina NovoUsuario.aspx e coloque um
LoginView, no template Anonymous coloque um controle Login, e no template
LoggedIn coloque um controle LoginName Login.
Defina a página NovoUsuario.aspx como inicial e rode a aplicação. Note que é exibido
o conteudo do template Anonymous, pois o usuário ainda não efetuou login:
138
Agora defina Login.aspx como página inicial, efetue o login e redirecione para
NovoUsuario.aspx (digite a URL no navegador). Note que agora é exibido o conteudo
do template LoggedIn:
139
Gerenciado usuários manualmente
O ASP.NET prove ainda uma API com diversas classes que nos permitem fazer tudo o
que foi estudado até o momento manualmente (e muito mais).
Para exemplificar, vamos listar na página Default.aspx todos os usuário do sistema em
um ListBox através do método GetAllUser. Para isso, adicione um Listbox a sua pagina
e no evento Load da página escreva o seguinte código:
ListBox1.DataSource = Membership.GetAllUsers
ListBox1.DataBind()
End If
140
{
ListBox1.DataSource = Membership.GetAllUsers();
ListBox1.DataBind();
}
Listar todas as classes com seus métodos e exemplos requer um curso inteiro, por isso
vou listar abaixo as principais classes e seus membros mais importantes, com suas
respectivas funções:
Classe MemberShip
Funções especificas de gerenciamento de usuários.
CreateUser: Permite Criar um novo usuário.
DeleteUser: Permite excluir um usuário.
FindUserByEmail: Retorna uma coleção de usuários com o E-mail especificado.
GeneratePassword: Gera uma senha aleatória.
GetAllUsers: Retorna uma coleção de usuários.
GetUserNameByEmail: Retorna um usuário cujo E-mail equivale ao
especificado.
UpdateUser: Atualiza o usuário.
ValidateUser: Verifica se o usuário e sua senha são válidos.
141
Classe MemberShipUser
Trás informações especificas de um usuário
CreationDate: Data e hora em que o usuário foi criado.
Email: Retorna ou determina o E-mail do usuário.
IsOnLine: Retorna se o usuário esta on-line.
LastActivityDate: Retorna a data e hora da última atividade do usuário
LastLoginDate: Retorna a data do ultimo login do usuário.
Autorização e Funções
Até agora vimos alguns métodos de gerenciamento de usuários. Porém normalmente
usuários têm funções diferentes em um negócio, e sua aplicação deverá ser capaz de
gerenciar isto. Embora neste quesito já não existam controles prontos, o gerenciamento
de funções é também muito mais fácil e rápido no ASP.NET 3.5.
Para testarmos o gerenciamento e uso de funções vamos executar as seguintes tarefas:
Criar um cadastro de funções em nossa página Default.aspx. Cadastrar a função admin.
Criar um controle de atribuição de funções a usuários também na pagina Default.
Adicionar seu usuário a esta função.
Definir que nossa página administracao.aspx só poderá ser acessada por um usuário
pertencente a função admin.
Testar a aplicação.
Criando um cadastro de Funções
Antes de tudo devemos habilitar o gerenciamento de funções em nossa aplicação, que
por padrão é desabilitado. Para isso adicione o seguinte nó dento de <system.web>:
<roleManager enabled="True"/>
142
Agora adicione a página Default.aspx um controle textbox com um rótulo Grupo e um
button com um rótulo adicionar logo ao lado. Adicione também um novo controle
ListBox (já deve existir um para exibição de usuários) com o rótulo Funções. Sua
página, em tempo de design, deve se parecer com a imagem abaixo.
Agora vamos adicionar algumas linhas de código. Altere seu método Load da pagina de
acordo com a listagem abaixo:
ListBox1.DataSource = Membership.GetAllUsers
ListBox1.DataBind()
Roles_DataBind()
End If
{
ListBox1.DataSource = Membership.GetAllUsers();
Roles_DataBind();
}
Crie um método Roles_dataBind, que atualiza as funções no listbox:
143
Sub Roles_DataBind()
ListBox2.DataSource = Roles.GetAllRoles
ListBox2.DataBind()
End Sub
void Roles_DataBind()
{
ListBox2.DataSource = Roles.GetAllRoles();
}
Agora de um duplo clique sobre o botão Incluir, e sobre o manipulador de evento criado
adicione o seguinte código:
Roles.CreateRole(TextBox1.Text)
Roles_DataBind()
Roles.CreateRole(TextBox1.Text);
Roles_DataBind();
Tudo o que foi feito é adicionar uma nova função a partir do texto informado no
controle textbox. Rode a aplicação, informe admin como nome para a função clique em
Incluir:
144
Criando um controle de atribuição de funções a usuários
Para adicionar uma função a um usuário, vamos verificar o usuário selecionado, a
função seleciona e em seguida fazer a adição, tudo através do clique de um botão
Adicionar Função. Para exibir a função de um determinado usuário, um clique em outro
botão Funções do Usuário devera exibir em um listbox as funções atribuídas ao usuário
selecionado.
Primeiramente adicione ao seu WebForm default.aspx um botão de texto Adicionar
Função, um botão de texto Funções do Usuário ao lado do listbox de usuários, e um
novo listbox abaixo deste botão. Seu formulário agora deverá se parecer com a imagem
abaixo:
145
Agora um pouco de código. No manipulador do evento do botão Adicionar Função
coloque:
Roles.AddUserToRole(ListBox1.SelectedItem.Text,_
ListBox2.SelectedItem.Text)
Roles.AddUserToRole(ListBox1.SelectedItem.Text,
ListBox2.SelectedItem.Text);
Já para o botão Funções do usuário:
ListBox3.DataSource =
Roles.GetRolesForUser(ListBox1.SelectedItem.Text)
ListBox3.DataBind()
146
ListBox3.DataSource =
Roles.GetRolesForUser(ListBox1.SelectedItem.Text);
O que o código acima faz é simplesmente pegar as funções do atribuídas ao usuário
selecionado no Listbox1 e listadas no listbox3.
Rode a aplicação e adicione a função admin ao seu usuário:
147
Definindo que nossa página Administracao.aspx só poderá ser acessada por um
usuário pertencente a função admin
Para que apenas usuários do grupo admin possam acessar a página Administracao.aspx,
tudo a fazer é adicionar um novo nó location em nosso web.cofig, da seguinte forma:
<location path="Administracao.aspx">
<system.web>
<authorization>
<allow roles="admin"/>
<deny users="*"/>
</authorization>
</system.web>
</location>
Observe que a estrutura do nó é semelhante a utilizada anteriormente para tornar a
página NovoUsuario.aspx, porém aqui ao invés de autorizarmos um usuário estamos
autorizando uma função, e negando acesso a todos os demais usuários. Para testar crie
um novo usuário e não o adicione a função admin, faça o login com o mesmo e tente
acessar a pagina Administracao.aspx. Faça o mesmo com seu usuário que foi incluído
na função admin.
Arquivo web.config
Abaixo segue o arquivo web.config final, utilizado em nossos exemplos até aqui.
Apenas comentários foram removidos por praticidade.
<?xml version="1.0"?>
<configuration
xmlns="http://schemas.microsoft.com/.NetConfiguration/v2.0">
<appSettings/>
<connectionStrings/>
<system.web>
<compilation debug="true" strict="false" explicit="true"/>
<pages>
<namespaces>
<clear/>
<add namespace="System"/>
<add namespace="System.Collections"/>
<add
namespace="System.Collections.Specialized"/>
<add namespace="System.Configuration"/>
<add namespace="System.Text"/>
<add
namespace="System.Text.RegularExpressions"/>
<add namespace="System.Web"/>
<add namespace="System.Web.Caching"/>
<add namespace="System.Web.SessionState"/>
<add namespace="System.Web.Security"/>
148
<add namespace="System.Web.Profile"/>
<add namespace="System.Web.UI"/>
<add namespace="System.Web.UI.WebControls"/>
<add
namespace="System.Web.UI.WebControls.WebParts"/>
<add namespace="System.Web.UI.HtmlControls"/>
</namespaces>
</pages>
<roleManager enabled="True"/>
<authentication mode="Forms">
<forms name=".ASPXAUTH" loginUrl="login.aspx"
defaultUrl="default.aspx">
</forms>
</authentication>
<authorization>
<deny users="?"/>
</authorization>
</system.web>
<location path="Administracao.aspx">
<system.web>
<authorization>
<allow roles="admin"/>
<deny users="*"/>
</authorization>
</system.web>
</location>
<location path="NovoUsuario.aspx">
<system.web>
<authorization>
<allow users="*"/>
</authorization>
</system.web>
</location>
<system.net>
<mailSettings>
<smtp from="[email protected]">
<network
host="smtp.portal.com"
port="25"
userName="user"
password="123" />
</smtp>
</mailSettings>
</system.net>
</configuration>
MemberShip e Roles, algumas técnicas avançadas
Agora veremos alguns recursos avançados de MemberShip e Roles disponíveis no
ASP.NET 3.5. Por padrão, o ASP.NET cria um banco de dados SQL Express de nome
ASPNETDB.MDF em App_Data com todos os objetos necessário para a gerenciamento
de memberships e roles. O cenário pode ser visualizado na figura 1:
149
Com certeza é uma alternativa prática, porém temos aqui alguns problemas:
Seu site provavelmente vai ter um banco de dados de aplicação. Você terá então dois
bancos de dados independentes para uma mesma aplicação!
Provavelmente alguma regra de negócio de seu aplicativo vai precisar interagir de
alguma forma com a base de dados de membership e roles, como numa auditoria, por
exemplo. Sua aplicação vai ter que buscar estar informações em outro banco de dados,
em outro SGBD!
Por padrão o banco de dados de gerenciamento estará junto ao Servidor de Internet.
Você pode querer colocá-lo em um servidor de banco de dados dedicado, ou mesmo
sequer deseja instalar o SQL Server junto ao Servidor Web.
Um banco de dados SQL Server edição Express possui algumas limitações técnicas.
A boa noticia é que o ASP.NET permite que seja utilizado nosso próprio banco de
dados para o gerenciamento de membership e roles, como exibido na figura 2. Fazer
isso é simples, e basicamente deve ser feito em duas etapas:
Criar os objetos necessários no seu banco de dados: O gerenciamento de memberships e
roles é feito através de um conjunto especifico de tabelas, views e stored procedures,
que deverão ser de alguma maneira criados no seu banco de dados.
150
Configurar a sua aplicação para usar seu banco de dados: Devemos configurar a
aplicação para que faça o gerenciamento de usuários e funções não mais através do
banco de dados padrão, utilizando o nosso banco de dados ao invés disso.
Criando os Objetos
Você pode criar os objetos necessários diretamente no seu banco de dados ou então
produzir um script DDL com os mesmos.
O .NET possui a Ferramenta ASP.NET SQL Server SetupWizard que pode ser utilizado
tanto para criá-los ou mesmo para produzir o script.
Gerando os objetos diretamente no seu banco de dados
Para gerar o schema diretamente no seu banco de dados, basta rodar o aplicativo
ASP.NET SQL Server SetupWizard (ASPNET_REGSQL), que pode ser encontrado no
caminho C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727 , ou executado mais
facilmente através do Visual Studio 2008 Command Prompt que pode ser encontrado no
conjunto de programas do Visual Studio. No prompt de comando basta digitar
ASPNET_REGSQL.
A primeira tela do programa traz algumas informações sobre a criação dos objetos:
151
Na segunda etapa devemos informar se desejamos preparar nossa aplicação ou remover
as configurações, obviamente vamos optar pela primeira opção:
Em seguida devemos informar o servidor, o banco de dados e as informações de login
para a criação dos objetos:
152
Em seguida um sumário das configurações é exibido:
Por fim o aplicativo informa que os objetos foram criados:
153
Se examinarmos o banco de dados, podemos ver que foram criadas diversas tabelas,
procedures e views específicas para o uso do ASP.NET:
154
Gerando um Script
Além do wizard exibido anteriormente, através do mesmo aplicativo, porém através da
linha de comando, podemos produzir um script DDL.
Se você for distribuir o banco de dados de sua aplicação através de um script,
provavelmente você acharia ótimo incluir também o script para criação dos objetos de
Membership e Roles. Podemos gerar o script para um arquivo, informando quais
funcionalidades desejamos utilizar.
Por exemplo, para gerarmos um script com toda a funcionalidade para um arquivo de
nome ASPScript.SQL, basta executar o seguinte comando:
ASPNET_REGSQL
sqlexportonly C:\ASPScrip.sql -A all
Será gerado o script no arquivo C:\ASPScrip.sql com todas as funcionalidades
incluídas. Para mais opções digite o comando
ASPNET_REGSQL -?
Configurando sua aplicação
Criar os objetos necessários em seu banco de dados não é o suficiente. Se o ASP.NET
não souber que você deseja que as funcionalidades de Membership e Roles sejam
armazenadas em seu próprio banco de dados, ele vai continuar a usar o arquivo
SQLExpress na pasta App_Data.
Tudo a fazer é incluir algumas entradas no arquivo web.config de sua aplicação:
<membership defaultProvider="SqlProvider" userIsOnlineTimeWindow="15">
<providers>
<add name="SqlProvider"
type="System.Web.Security.SqlMembershipProvider"
connectionStringName="MinhaString"
applicationName="MinhaAplicacao"
enablePasswordRetrieval="false"
enablePasswordReset="true"
passwordFormat="Hashed"
requiresQuestionAndAnswer="true" minRequiredPasswordLength="1"
minRequiredNonalphanumericCharacters="0"/>
</providers>
155
</membership>
Acima configuramos as funcionalidades de MemberShip, observer o nó provider, o
atributo
name
tem
o
valor
System.Web.Security.SqlMembershipProvider.
de
SqlProvider,
Outro
atributo
type
como
importante
é
ConnectionStringName, que deve apontar para um string de conexão no mesmo arquivo
web.config contendo as informações do servidor e banco de dados onde deverá estar a
estrutura de gerenciamento de membership. Para exemplificar, a string de conexão
MinhaString poderia ser adiciona no web.config da seguinte forma:
<connectionStrings>
<add name="MinhaString" connectionString="Data
Source=Servidor;Initial Catalog= AdventureWorks;User
ID=sa;Password=123" providerName="System.Data.SqlClient"/>
</connectionStrings>
Para o gerenciamento de Roles devemos adicionar um nó roleManager, semelhante ao
anterior:
<roleManager defaultProvider="SqlProvider" enabled="true"
cacheRolesInCookie="true" cookieName=".ASPROLES"
cookieTimeout="30" cookiePath="/" cookieRequireSSL="false"
cookieSlidingExpiration="true" cookieProtection="All">
<providers>
<add name="SqlProvider"
type="System.Web.Security.SqlRoleProvider"
connectionStringName="MinhaString" applicationName="MinhaAplicacao"/>
</providers>
</roleManager>
Observe novamente as informações de name do provedor, tipo e string de conexão.
Os recursos de membership e roles foram sem duvida uma grande novidade no
ASP.NET 3.5. Poder direcionar suas funcionalidades para um banco de dados
especifico torna este recurso ainda mais funcional e útil!
156
12 .Manutenção de Estado
Em aplicação que não mantêm estado por natureza, como nossas aplicações web,
utilizamos alguns mecanismos para manter as informações importantes para nosso
negocio entre uma requisição e outra. O IIS por sua vez incorpora um cookie com um
identificador único no cabeçalho de cada requisição http, que é enviada de volta pelo
navegador. Esse cookie que torna possível identificar um mesmo usuário entre os
diversos vai e volta de uma aplicação Web.
Desta forma a cada requisição poderíamos gravar em um banco de dados às
informações importantes daquele momento, vamos supor o nome do usuário. Na
próxima requisição pegamos novamente este identificador único e faríamos uma
consulta em no banco de dados, já saberíamos de qual usuário se trata, poderíamos
então armazenar neste momento as informações de um produto que o usuário resolver
comprar e assim a vida seguiria tranquilamente.
Esta é uma forma primitiva e árdua de manter estado, existem diversas outras técnicas,
todas com seus prós e contras, é o que vamos estudas nas próximas sessões.
Profiles
Manter informações em variáveis de sessão é um dos recursos mais simples e utilizados
para manter o estado de uma aplicação Web: Armazenamos as informações importantes
em variáveis de sessão. A aplicação faz automaticamente a associação entre o
Identificador Único explicado na sessão anterior e as varias de sessão do mesmo.
No ASP.NET 2.0 o recurso de personalization tornou isso mais fácil. Agora, podemos
gerenciar informações de forma mais intuitiva e fácil, com ajuda inclusive do
Intelissense.
Um exemplo simples
Vamos começar com um exemplo simples, para isso crie uma aplicação ASP.NET. Esta
aplicação será usada durante todos os exemplos deste capitulo.
157
Crie duas páginas em sua aplicação: Inicial.aspx e Final.aspx. Na primeira coloque um
controle TextBox e um Controle Button de texto Enviar e na outra um controle label.
Altere seu arquivo web.config, incluindo um nó profile da seguinte forma:
<profile>
<properties>
<add name="Nome"/>
</properties>
</profile>
Ao final deste capitulo você pode encontrar o web.config na sua versão final.
De um duplo clique no botão Enviar e adicione o seguinte:
Profile.Nome = TextBox1.Text
Response.Redirect("Final.aspx")
Profile.Nome = TextBox1.Text;
Response.Redirect("Final.aspx");
No evento Load da pagina Final.aspx:
Label1.Text = Profile.Item("Nome")
Label1.Text =Convert.ToString( Profile["Nome"]);
Note que o qualquer propriedade que você definir no profile estará disponível no
intellisense:
158
Turbinando a propriedade
Você pode ainda definir algumas características de uma propriedade de um profile,
como tipo e valores padrão. Veja o web.config anterior agora com a propriedade nome
definida como string e com valor padrão igual a Anônimo:
<profile>
<properties>
<add name="Nome" type="System.String" defaultValue="Anônimo"
</properties>
</profile>
/>
Definindo Grupos
Outra funcionalidade é organizarmos nossas propriedades em grupos. No nosso
exemplo vamos adicionar um grupo Endereco, para armazenar o logradouro, número,
cidade e estado do usuário:
<profile>
<properties>
<add name="Nome" type="System.String" defaultValue="Anônimo"
<group name="Endereco">
<add name="Logradouro"/>
<add name="Numero"/>
<add name="Cidade"/>
<add name="Estado"/>
</group>
</properties>
</profile>
/>
Adicione mais três controles textbox na pagina Inicial.aspx para que o usuário digite
estas novas propriedades:
159
Altere o código do botão enviar de acordo com o exemplo a seguir:
Profile.Nome = TextBox1.Text
Profile.Endereco.Logradouro = TextBox2.Text
Profile.Endereco.Numero = TextBox3.Text
Profile.Endereco.Cidade = TextBox4.Text
Profile.Endereco.Estado = TextBox5.Text
Response.Redirect("inicial.aspx")
Profile.Nome = TextBox1.Text;
Profile.Endereco.Logradouro = TextBox2.Text;
Profile.Endereco.Numero = TextBox3.Text;
Profile.Endereco.Cidade = TextBox4.Text;
Profile.Endereco.Estado = TextBox5.Text;
Response.Redirect("inicial.aspx");
Já nosso evento Load na página Final.aspx devera ficar assim:
Label1.Text = Profile.Nome & " " & _
Profile.Endereco.Logradouro & " " & _
Profile.Endereco.Numero & " " & _
Profile.Endereco.Cidade & " " & _
Profile.Endereco.Estado
160
Label1.Text = Profile.Nome + " " +
Profile.Endereco.Logradouro + " " +
Profile.Endereco.Numero + " " +
Profile.Endereco.Cidade + " " +
Profile.Endereco.Estado;
Session
Como explicado algumas sessões atrás, uma das formas mais simples de manutenção de
estado é através de variáveis de sessão. Cada variável esta associada ao cookie de
identificação do usuário. Por padrão, estas informações estão armazenadas no próprio
processo do ASP.NET. Uma novidade da era .NET foi a possibilidade de
armazenamento de informações de sessão em um processo separado (um servidor de
estado) ou até mesmo em um SGBD. Isto trouxe novos horizontes ao desenvolvimento
de aplicações Web em ASP.NET, pois simplificou a criação dos chamados Web Farms,
termo que define um conjunto de servidores rodando uma aplicação especifica.
Em nosso curso vamos estudar apenas o gerenciamento de sessão no próprio
processo do ASP.NET (inProc), que é o comportamento padrão.
Uma variável de sessão esta associada a exclusivamente a uma única sessão. Isto
significa que um dado armazenado em uma variável de nome X para o usuário João não
será visível na variável de sessão de mesmo nome do usuário Pedro, e vice-versa.
Para testarmos o uso de variáveis de sessão, vamos criar uma pequena aplicação que vai
armazenar um valor em uma variável e exibi-lo em outra página. Em seguida vamos
rodar uma outra instancia da mesma aplicação para verificar que os valores
armazenados diferem de uma instancia para outra. Para isso crie uma nova aplicação
ASP.NET com duas páginas: Inicial.aspx e Final.aspx. Na primeira coloque um controle
TextBox e um Controle Button de texto Enviar e na outra um controle label.
De um duplo clique sobre o botão enviar e no manipulador de evento criado insira o
seguinte código:
Session("Nome") = TextBox1.Text
Response.Redirect("Final.aspx")
161
Session["Nome"] = TextBox1.Text;
Response.Redirect("Final.aspx");
No evento Load da página Final.aspx insira a código abaixo:
Label1.Text = Session("Nome")
Label1.Text = Session["Nome"];
O identificador de uma variável de sessão é sensível a diferenciação entre
letras maiúsculas e minúsculas, portanto Nome representa uma variável e
nome outra.
Defina Inicial.aspx como pagina inicial, rode a aplicação, digite um valor na caixa texto
e observe o valor ser exibido na página seguinte.
Você tambem pode armazenar qualquer tipo de objeto em uma variavel de sessão.
HiddenField
Uma das formas mais simples e antigas de manter estado dentro de uma mesma página
é através de campos ocultos. O valor atribuído ao controle é mantido na propriedade
value entre post backs, porém não é renderizado na página.
ViewState
Imagine a seguinte situação: em um determinado ponto de um cadastro o usuário, após
informar diversos dados cadastrais, tem que digitar o CEP para que o sistema faça a
busca do endereço. O post back é acionado e quando a requisição volta ao navegador,
todos os dados digitados se perderam em algum lugar do cyberspace.
Claro que
ninguem vai criar um aplicativo com desta forma, porém o exemplo é para lembrar que
no ASP classico e em outras diversas linguagens de programação para Web, devemos
manter o estado da página manualmente, ou seja, digitando muitas linhas de código.
No ASP.NET o recurso de ViewState mantem automaticamente os valores de controles
de servidor entre um post back e outro. Na verdade o ViewState internamente nada mais
162
é do que uma campo oculto um pouco mais sofisticado. Se você rodar uma aplicação
ASP.NET sem qualquer controle verá que é criado um campo oculto para o
armazenamento do ViewState:
<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE"
value="/wEPDwUJNzgzNDMwNTMzZGS8mO25pQR00V4slvgSxG3dEvK+hA==" />
Note que os dados não são exibidos em texto plano, por questões de segurança. Porém
este é um recurso palhativo e não devemos utilizá-lo para manter dados sensíveis.
Você ainda pode usar o ViewState para adicionar manualmente valores ao ViewState,
lembrando que você vai conseguir recuperá-los apenas entre um post back e outro na
mesma página. Abaixo um pequeno exemplo de atribuição de um valor ao ViewState:
ViewState("Nome") = "Fernando Amaral"
ViewState["Nome"] = "Fernando Amaral";
QueryString
Outro modelo clássico de manutenção de estado é o através do uso de querystrings, que
nada mais são do que conjuntos de pares/valores anexados a URL, provavelmente você
já deve ter visto dezenas de páginas usando este recurso.
Sua utilização é simples, após a URL você adiciona o primeiro valor na forma
?Chave=Valor. Para passar mais de um conjunto, os mesmos devem ser concatenados
através do caractere &. Para recuperar o valor na outra página basta usar
Request.QueryString.
Crie uma nova aplicação ASP.NET com duas páginas: Inicial.aspx e Final.aspx. Na
primeira coloque dois controles TextBox, um para digitação do nome e outro para idade
e um Controle Button de texto Enviar e na outra um controle label.
Para montar a URL de redirecionamento com as duas variáveis:
Response.Redirect("Final.aspx?" & "Nome=" & TextBox1.Text & "&Idade="
163
& TextBox2.Text)
Response.Redirect("Final.aspx?" + "Nome=" + TextBox1.Text + "&Idade="
+ TextBox2.Text);
Para recuperar os valores na pagina seguinte:
Label1.Text = Request.QueryString("Nome") & " " &
Request.QueryString("Idade")
Label1.Text = Request.QueryString["Nome"] + " " +
Request.QueryString["Idade"];
Cookies
Outra forma de manutenção de estado é através do uso de cookies, que nada mais é do
que um pequeno arquivo de texto que armazenado na maquina do usuário. Sua grande
vantagem é que você pode identificar o usuário mesmo dias depois de seu acesso a
página. Este recurso é muito usado, pro exemplo, em sites de comercio eletrônico, para
exibir as preferências do usuário os últimos produtos que ele navegou.
O grande problema dos cookies é que o usuário simplesmente pode desabilitar este
recurso em seu navegador.
Cross Page Postback
Uma nova funcionalidade do ASP.NET a partir da versão 2.0 é capacidade de
recuperação de informações entre diferentes páginas. Este recurso já foi visto em nosso
primeiro módulo.
Application
Semelhante em diversos aspectos com variáveis de sessão, com uma importante
diferença: As variáveis de aplicação são compartilhadas entre todas os usuários da
aplicação. Uma variável de aplicação esta associada a toda a aplicação. Isto significa
que um dado armazenado em uma variável de nome X para o usuário João será visível
na variável de aplicação de mesmo nome do usuário Pedro, e vice-versa.
164
Outra diferença importante é que uma variável de aplicação estará disponível durante
toda a vida da aplicação, enquanto uma variável de sessão será perdida ao fim da sessão
do usuário.
Crie uma nova aplicação ASP.NET com duas páginas: Inicial.aspx e Final.aspx. Na
primeira coloque um controle TextBox para digitação do nome e um Controle Button de
texto Enviar e na outra um controle label.
Na página Incial.aspx digite o seguinte código no manipulador de evento criado no
botão Enviar (observe que não há redirecionamento):
Application("Nome") = TextBox1.Text
Application["Nome"] = TextBox1.Text;
No evento Load da pagina Final.aspx digite o seguinte código:
Label1.Text = Application("Nome")
Label1.Text = Application["Nome"];
Para testar, defina Inicial.aspx como página inicial, informe seu nome e clique no botão
enviar. Feche a aplicação e vá tomar um copo de água. Na volta, defina Final.aspx como
pagina inicial, rode a aplicação e observe o resultado.
Você pode ser perguntar como foi possível recuperar o valor já que ninguém
estava usando a aplicação em determinado momento. Na verdade, mesmo que
ninguém utiliza a aplicação, os valores de variáveis de aplicação só serão
perdidos quando a última sessão expirar.
Caching
Aplicações web podem ter de atender centanas de milhares de usuários, e temos que
usar todos os recursos disponíveis para mante-la rodando com uma boa performance.
Normalmente alguns recursos são exibidos a diferentes usuários sem sequer que tenha
havido tempo para estas informações serem alteradas. De qualquer forma, se nada for
165
feito, a cada acesso a aplicação vai novamente buscar essas informações onde quer elas
estejam. Para citar um exemplo, se seu aplicativo em uma pagina de cadastro exibe uma
relação de cidades em um ComboBox para que o usuário faça a escolha de uma. A cada
novo usuário sua aplicação vai abrir uma conexão com o banco de dados, executar a
consulta e preencher o ComboBox. Qual o custo desta tarefa para sua aplicação? Qual a
probabilidade da relação de cidades mudar nas proximas horas?
O ASP.NET nos oferece diversos recusos de armazenamento em cache, vamos estadalos a seguir.
Output Caching
A adicão de uma diretiva de compilação em uma página ASP.NET já vai colocar a
página em cache. Para fazer um teste, coloque a diretiva a seguir logo abaixo da diretiva
@Page:
<%@ OutputCache Duration="30" VaryByParam="None" %>
Coloque um label em sua página e no evento Load digite o código abaixo:
Label1.Text = DateTime.Now.ToString
Label1.Text = DateTime.Now.ToString();
Rode a aplicação. Observe a hora exibida. Pare a aplicação e rode novamente ou
simplismente atualize a página. Veja que a hora continua a mesma, sem atualização.
Aguarde em torno de 30 segudos, que foi o tempo de duração informado na diretiva e
rode a aplicação novamente. Observe que a hora é atualizada.
Variação por Parametros
O atributo VaryByParam, utilizado no exemplo anterior nos permite criar versões
diferentes para variações de determinado parâmetro na Query String da aplicação.
Para exemplificar, no exemplo anterior altera a diretiva da seguinte maneira:
166
<%@ OutputCache Duration="30" VaryByParam="Codigo" %>
Rode a aplicação e adicione a ?Codigo=1 ao final da Url, como no exemplo abaixo:
Memorize a hora, altere o código para 2 e tecle Enter. Note que hora mudou. Volte o
valor do parâmetro para 1 e tecle Enter. Note que é exibido a hora anterior, ou seja, que
estava armazenada em cachê.
Você pode especificar o armazenamento por mais de um parâmetro, bastando para isso
informa-los separados por ; . O armazenamento se dará sempre pela combinação de
todos os parâmetros, ou seja, sempre que surgir uma nova combinação de valores, um
novo armazenamento será gerado. Para que seja aplicado cache a todos os parâmetros,
basta informa * .
VaryByControl
Através do atributo VaryByControl, podemos definir que determinado controle da
página seja armazenado em cachê, bastando para tanto informar o nome do mesmo:
<%@ OutputCache Duration="30" VaryBycontrol="Label1"
%>
O uso de VaryByControl é ideal para o armazenamento de User Controls.
Substitution
167
As vezes queremos manter em cache a página inteira, porem determinada informação
precisa ser dinâmica e variar de usuário pra o usuário ou mesmo em função do tempo.
Um bom exemplo é exibir a hora atualizada pro usuário, ou mesmo seu nome de login.
O ASP.NET disponibiliza para isso um controle Subtituton, que recebe na sua
propriedade MetodName o nome de um método que será dinâmico, ou seja, não será
armazenado em cache. Este método deve deve ser shared /static e receber como
parâmetro um tipo HttpContext.
Adaptar o nosso primeiro exemplo, em que exibimos a data e hora em label, para ter
uma porção da página exibindo a hora sem armazendo em cache, utilizando um
Substitution, é facil. Primeiramente adicione a seguinte função a página:
Public Shared Function RetornaHora(ByVal context As HttpContext) _
As String
Return DateTime.Now.ToString()
End Function
public static string RetornaHora(HttpContext context)
{
return DateTime.Now.ToString();
}
Em seguida acione um controle Subtitutio e denina sua propriedade MethodName como
RetornaHora.
Rode a aplicação. Atualize a página algumas vezes e note que o Label colocado
anteriormente mantem fixo o valor da hora enquato o cache não espira. Já o controle
Substitution renderiza a data e hora atualizados.
168
Programando cache manualmente
Para poder aproveitar o Maximo da funcionalidade de cache, você pode programar a sua
utilização. O funcionamento básico é semelhante ao de variáveis de sessão e aplicação,
basta ler ou gravar o valor através de um identificador único:
Cache("Nome") = "Fernando"
Cache["Nome"] = "Fernando";
Outra maneira de utilizar cache é usando o método Insert. O primeiro parâmetro é o
identificador, o segundo é o abjeto a ser armazenado:
Cache.Insert("Nome", "Fernando")
Cache.Insert("Nome", "Fernando");
O método Insert possui ainda algumas sobrecargas, que permitem criar dependências,
ou determinar o tempo de expiração do cache. O tempo de expiração pode ser absoluto,
onde você deve informar a hora exata em que o cache vai expirar, ou sliding, em que
169
você informa o tempo de expiração a partir da criação do cache. O exemplo abaixo
coloca um string em cache por 20 segundos:
Cache.Insert("Nome", "Fernando", Nothing, DateTime.MaxValue,_
TimeSpan.FromSeconds(20))
Cache.Insert("Nome","Fernando", null, DateTime.MaxValue,
TimeSpan.FromSeconds(20));
170
ASP.NET AJAX
Antes de tentarmos entender o Ajax, é preciso conhecer a Web 2.0 e onde o Ajax se encaixa
neste conceito.
Web 2.0
Embora a Web seja algo revolucionário e tecnologicamente inovador, na verdade hoje ela
esta passando pela sua
pré-história . Fazendo-se uma analogia, podemos pensar na
revolução que foi a produção da TV em escala industrial lá pela década de 40, com
baixíssima qualidade, preto e branca com a TV digital que esta surgindo nos dias de hoje. A
Web atual é uma TV da década de 40.
Já muito se fala em Web 2.0, que seria a segunda geração de aplicações para Internet, onde
a Internet passaria a ser a plataforma das aplicações, acessadas inteiramente através de
navegadores: mais interativas, mas leves, mas dinâmicas...
Mas aonde o Ajax entra nisso tudo? O Ajax é a tecnologia que torna possível trazer muitos
dos conceitos da Web 2.0 para as aplicações de fato. O Ajax é o responsável pela
característica de interatividade e interfaces ricas e amigáveis da Web 2.0.
Ajax
Quando ensino ASP.NET para programadores que nunca criaram uma aplicação Web, noto
que alguns tem dificuldades em entender o diferente modelo de funcionamento de uma
aplicação Internet: O que estamos vendo no browser é o resultado de um requisição
processada por uma aplicação no servidor. Em nosso navegador, cada vez que enviamos
uma requisição de processamento, todo conteúdo é empacotado, enviado e processado pelo
servidor e em seguida devolvido ao navegador, que trata de interpretar e exibir este
resultado novamente para o usuário.
O problema é que, a cada requisição, a página inteira trafega entre o servidor e o cliente.
Isto nos trás alguns problemas: Trafego desnecessário na rede, maior carga de
processamento, tempo de espera pelo processamento da requisição.
171
A idéia do Ajax, acrônimo para Asynchronous JavaScript and XML, é permitir que apenas
a parte necessária da página seja enviada e processada no servidor: é um modelo de
funcionamento assíncrono: isto quer dizer que o usuário não precisa esperar o final do
processamento da requisição para continuar executando a aplicação...note agora que o
benefício é muito maior do que apenas evitar que a página pisque: é redução de tráfego, é
aumento de desempenho, é maior interatividade.
Embora o acrônimo fale apenas em JavaScript e XML, temos diversas outras tecnologias
envolvidas quando usamos Ajax: CSS, DOM e XMLHttpRequest. A requisição ao Ajax ao
servidor é na forma de um objeto XMLHttpRequest. Após processada, o resultado em XML
é processado pelo cliente, onde apenas as alterações são exibidas.
Nada de Novo
É curioso o fato de que muitas tecnologias já existentes a muito tempo, às vezes décadas, de
repente se tornam a sensação do momento: Orientação a Objetos, infra-estrutura de Chaves
Públicas etc. para citar apenas alguns.
Da mesma forma, o modelo de funcionamento do Ajax, através de chamadas assíncronas
por javascript, não é novo. O objeto XMLHttpRequest surgiu no final da década de 90,
lançado primeiro pela Microsoft, junto com o navegador Internet Explorer 5, na forma de
um ActiveX. Mais tarde surgiu em outros navegadores, na forma de um objeto Java.
AJAX no ASP.NET 2.0 e Visual Studio 2005
Para o Visual Studio 2005, o Ajax Extensions traz um conjunto de controles simples, que
permitem a execução de chamadas assíncronas através de controles visuais, ocultando a
complexidade de se trabalhar diretamente com o objeto XMLHttpRequest.
Além disso, foi lançado também um conjunto de controles, o AJAX toolkit, com um
conjunto de diversas funcionalidades já prontas.
No Visual Studio 2005 e ASP.NET 2.0 o AJAX deve ser instalado a parte, através de um
instalador fornecido pela Microsoft.
AJAX no ASP.NET 3.5 e Visual Studio 2008
172
O AJAX já é parte integrante do .NET Framework 3.5 e do ASP.NET 3.5. Os controles
AJAX Extensions, ao contrário do que ocorre com o Visual Studio 2005, já vem
integrados ao Visual Studio 2008 e não requerem instalação a parte.
No Visual Studio 2005 era necessário criar uma aplicação a partir de um Templates para
podermos utilizar AJAX em uma aplicação, ou alguma informações deveriam ser
inseridas manualmente no arquivo Web.Config.
No Visual Studio 2008 qualquer aplicação ASP.NET já esta pronta para o AJAX, não é
preciso criá-la a partir de um Templates, tampouco é necessário intervenções no
Web.Config.
AJAX Extensions
O poder do AJAX esta disponível em conjunto de controles na barra de ferramentas do
Visual Studio:
Antes de entrarmos na parte prática, vamos qual a função de cada controle:
ScriptManager: O controle mais importante, ele que habilita as funcionalidades
do AJAX na página. Deve existir apenas um em cada web form;
ScriptManagerProxy: Utilizado com a função do ScriptManager em uma página
de conteúdo. No capitulo sobre Master Pages, vimos que cada página que utiliza
uma página Master, é denominada página de conteúdo. Deve funcionar em
conjunto com o controle ScriptManager da página Master;
Timer: Este controle deve ser utilizado para executar eventos em determinados
intervalos. Veremos seu uso na prática;
UpdatePanel: Talvez o controle mais importante, permite que partes de uma
pagina sejam atualizados de forma assíncrona;
173
UpdateProgress: Se a requisição assíncrona for demorada, podemos utilizar este
controle para dar feedback ao usuário enquanto ele aguarda, seja exibindo uma
mensagem ou mesmo uma imagem animada;
Exemplo prático com Update Panel
Neste primeiro exemplo veremos como é simples e rápido criar uma aplicação simples
já capaz de fazer chamadas assíncronas através do ASP.NET Ajax.
Primeiramente crie uma nova aplicação ASP.NET:
Na web form criado pelo Visual Studio, adicione um controle ScriptManager. Este
controle deve ser o primeiro da página.
Em seguida adicione um controle UpdatePanel. Este controle é um container, ou seja,
dentro dele podemos colocar outros controles. É o que vamos fazer agora, adicione
dentro do UpdatePanel um controle Button e um controle Label.
Seu código deverá conter os seguintes elementos:
<div>
174
<asp:ScriptManager ID="ScriptManager1" runat="server">
</asp:ScriptManager>
<br />
</div>
<asp:UpdatePanel ID="UpdatePanel1" runat="server">
<ContentTemplate>
<asp:Button ID="Button1" runat="server" Text="Button" />
<asp:Label ID="Label1" runat="server"
Text="Label"></asp:Label>
</ContentTemplate>
</asp:UpdatePanel>
Hora de escrever algum código de servidor. A idéia é atualizar a hora no label. Como
estaremos rodando a aplicação local e o processamento será mínimo, não teremos
nenhum efeito visual das funcionalidades do AJAX, por isso, alem de atualizar o
horário, vamos causar um delay no servidor.
De um duplo clique sobre o Button e escreva o seguinte código:
Protected Sub Button1_Click(ByVal sender As Object, ByVal e As
System.EventArgs) Handles Button1.Click
System.Threading.Thread.Sleep(1000)
Label1.Text = DateTime.Now.ToString()
End Sub
{
System.Threading.Thread.Sleep(1000);
}
Agora coloque outro Button e outro label abaixo do UpdatePanel (do lado de fora
deste). De um duplo clique sobre o novo botão e escreva o mesmo código, porém
escrevendo a data no label2:
End Sub
175
{
}
Visualmente seu web form deverá estar semelhante a imagem abaixo:
O que teremos ao rodar a aplicação? O primeiro botão irá fazer uma requisição
assíncrona, enviando uma informação mínima entre o postback. A segunda requisição
fará um postback de toda a página.
Rode a aplicação, clique nos dois botões e observe os resultados.Se você acha que não
pode observar nada diferente, preste mais atenção: Observe que quando você clicar no
botão o navegador estará carregando a pagina (Se você usa o Internet Explorer 7,
observe o ícone de carregar, que substitui o logo do IE na guia da página), aguardando o
final do processamento.
176
Adicionando um UpdateProgress
Muitas vezes um postback pode ter uma grande carga de processamento e demorar mais
do que gostaríamos. Em casos extremos o usuário pode ficar impaciente, ou até achar
que ocorreu algum problema. O Controle UpdateProgress é forma de dar um feedback
ao usuário enquanto ele aguarda o processamento. O Controle é também do tipo
container, você decide o que vai colocar lá dentro: uma mensagem, um gif, uma
animação etc. O único requisito para seu funcionamento é colocá-lo na página já
preparada para o AJAX e conectá-lo a um UpdataPanel.
Vamos ver o funcionamento na prática. Crie uma nova aplicação ASP.NET, coloque um
controle ScriptManager e um controle UpdatePanel. Dentro do UpdatePanel coloque um
controle label e um controle Button. De um duplo clique sobre o Button e digite o
seguinte código:
End Sub
177
{
}
Note que voltamos a colocar um código para causar um atraso na aplicação, a fim de
podermos ter uma visualização do efeito. Agora coloque um controle UpdateProgress,
defina a propriedade AssociatedUpdatePanelID como UpdatePanel1, dentro do
container do controle escreva uma mensagem como Aguarde...processando! :
Rode a aplicação, clique sobre o botão e observe o resultado:
178
Triggers
No exemplo anterior colocamos o botão que dispara o evento, e o label que mostra a
data, dentro de um elemento ContentTemplate. Isto significa que a requisição
assíncrona envio informações de ambos os controles no postback. Através de um
elemento trigger podemos separar o conteúdo que será atualizado do conteúdo que
dispara o evento, otimizando o postback.
Vamos ver o funcionamento na prática. Crie uma nova aplicação ASP.NET, coloque um
controle ScriptManager e um controle UpdatePanel. Dentro do UpdatePanel coloque um
controle label, abaixo e fora do container do UpdatePanel um controle Button. De um
duplo clique sobre o Button e digite o seguinte código:
End Sub
{
}
179
Agora devemos informar o controle que vai disparar o evento. Selecione o UpdatePanel,
na janela de propriedades clique em Triggers. Esta é uma coleção de eventos que podem
disparar a atualização do conteúdo do UpdatePanel. Clique em Add. Informe em
ControlID Button1, em EventName Clik, conforme imagem abaixo:
Observe agora o código gerado pelo VS, compare com os exemplos anteriores:
<asp:UpdatePanel ID="UpdatePanel1" runat="server">
<ContentTemplate>
<asp:Label ID="Label1" runat="server"
Text="Label"></asp:Label>
</ContentTemplate>
<Triggers>
<asp:AsyncPostBackTrigger ControlID="Button1"
EventName="Click" />
</Triggers>
</asp:UpdatePanel>
Observe que foi criado um elemento Triggers, que aponta para o controle e o evento que
dispara o postback Assíncrono. Roda a aplicação e teste o resultado.
180
Usando um Timer
Nos exemplos anteriores utilizamos o clique de um botão para disparar a chamada
assíncrona ao servidor. O controle Timer permite que chamadas sejam realizadas
automaticamente, sem a necessidade da disparada de um evento pelo usuário.
Para tal, basta colocarmos um controle Timer dentro de um UpdatePanel, e em seu
evento Tick escrever o código a ser executado no servidor. Através da propriedade
Interval definimos o intervalo de disparo destes eventos.
Para testarmos sua funcionalidade, crie uma nova aplicação ASP.NET 3.5, adicione ao
web form criado um ScriptManager e logo abaixo um UpdatePanel. Dentro do
UpdatePanel coloque um controle Label e um controle Timer. Defina a propriedade
Interval do Timer em 1000 milesecundos, o que equivale a 1 segundo. De um duplo
clique sobre o controle Timer e no manipulador de evento criado escreva o seguinte
código:
End Sub
protected void Timer1_Tick(object sender, EventArgs e)
{
}
Rode a aplicação e observe a atualização da data a cada segundo:
181
182
14. Criando e Consumindo WebServices
Ao menos que você tenha estado em uma caverna nos últimos anos, com certeza já
ouviu falar em XML e Web Service.
XML é um padrão de troca de informações, no formato texto. É um padrão aberto e
legível até para humanos, por isso tem se tornado um padrão na indústria. Não vou ficar
aqui explicando o que o XML é ou não é, pois existem toneladas de material na WEB
sobre o mesmo, estou apenas o introduzindo já que ele é importantíssimo na
funcionalidade dos Web Services.
Um Web Service é uma aplicação web que disponibiliza um serviço qualquer. Quem
usa o serviço é o consumidor. As informações trafegam sobre http, através de um
protocolo conhecido com SOAP. O formato em que estar informações trafega é nada
mais do que em XML.
Vários outros acrônimos se aplicação a um Web Service. WSDL, ou Web Service
Description Languagem é um arquivo disponibilizado pelo serviço com informações a
quem estiver interessado em consumi-lo. Disco é um protocolo de busca de Web
Services.
Com o advento do .NET, criar e consumir Web Services se tornou muito fácil. Quase
tudo é feito por trás das câmeras e você precisa se preocupar unicamente com seu
produto. Nesta seção vamos criar e consumir um Web Service.
Criando um Web Service
Para criar um Web Service, vá em New Web Site, e selecione ASP.NET Web Service.
183
Por padrão é criado um arquivo asmx, que é equivalente a uma página aspx, porém sua
função é prover serviços e não conteúdo. Cada arquivo asmx tem um arquivo .vb ou .cs
equivalente, onde são criados os métodos a serem publicados.
Um método deve conter um atributo webmetodo, caso contrário ele estará disponível
dentro da aplicação mas não externamente a esta. Se você examinar o arquivo .cs ou .vb
criado, notará que já existe um método de demonstração criado automaticamente:
<WebMethod()> _
Public Function HelloWorld() As String
Return "Hello World"
End Function
[WebMethod]
public string HelloWorld() {
return "Hello World";
}
Vamos criar um método para realizar uma consulta em um banco de dados, em seguida
vamos fazer uma aplicação para consumir este método.
Nosso método simplesmente vai receber uma consulta como parâmetro, executa-la
usando classes do ADO.NET e retornar o resultado. Todo o restante é problema do
184
FrameWork, nós não precisamos nos preocupar em gerar arquivos WSDL, gerar XML,
incluí-lo na mensagem SOAP etc., tudo é feito de forma transparente.
Abaixo segue todo o arquivo service.vb / .cs
Imports
Imports
Imports
Imports
Imports
System.Web
System.Web.Services
System.Web.Services.Protocols
System.Data
System.Data.SqlClient
<WebService(Namespace:="http://tempuri.org/")> _
<WebServiceBinding(ConformsTo:=WsiProfiles.BasicProfile1_1)> _
<Global.Microsoft.VisualBasic.CompilerServices.DesignerGenerated()> _
Public Class Service
Inherits System.Web.Services.WebService
<WebMethod()> _
Public Function Consulta(ByVal SQL As String) As DataSet
Dim Adapter As New SqlDataAdapter(SQL, "Data
Source=SERVIDOR;Initial Catalog=AdventureWorks;User
ID=sa;Password=123456")
Dim Data As New DataSet
Adapter.Fill(Data)
Return Data
End Function
End Class
using
using
using
using
using
using
System;
System.Web;
System.Web.Services;
System.Web.Services.Protocols;
System.Data;
System.Data.SqlClient;
[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
public class Service : System.Web.Services.WebService
{
public Service () {
//Uncomment the following line if using designed components
//InitializeComponent();
}
[WebMethod]
public DataSet Consulta(string SQL) {
SqlDataAdapter Adapter = new SqlDataAdapter(SQL, "Data
Source=SERVIDOR;Initial Catalog=AdventureWorks;User
ID=sa;Password=123456");
DataSet Data = new DataSet();
Adapter.Fill(Data);
185
return Data;
}
}
Note que a única parte adicionada foi o método Consulta.
Rode a aplicação, é exibida uma página com informações do Web Service:
Clique em Service Description, é exibido o arquivo WSDL gerado pelo ASP.NET, este
arquivo contém informações sobre o serviço e é um meio de consulta para um aplicação
que deseja consumi-la:
186
Você ainda pode testar o Web Service, para isso volte a página inicial, e clique sobre o
nome do método Consulta. A página exibe um campo onde você deve entrar o valor do
parâmetro, nesta casa SQL. Preencha com um comando SQL:
187
Clique em Invoke. O Resultado é exibido em uma nova janela:
Consumindo o Serviço
Para consumir o serviço crie adicione uma nova aplicação ASP.NET a solução. Clique
em propriedades, em seguida clique em Add Web Reference, é exibida a caixa de
dialogo abaixo:
188
Clique em Web Service in this Solution. Na janela seguinte em Service, que o nome do
serviço que criamos no nosso Web Service:
189
Em Web reference name mantenha o nome sugerido e clique em Add Rererence:
Agora vá a nossa página Default.aspx, adicione um GridView, e no evento OnLoad da
página adicione o seguinte código:
Imports System.Data.SqlClient
Imports System.Data
Imports localhost.Service
Protected Sub Page_Load(ByVal sender As Object, ByVal e As
System.EventArgs) Handles Me.Load
Dim Con As New localhost.Service
Dim Ds As DataSet = Con.Consulta("SELECT * FROM
Person.Address"
GridView1.DataSource = Ds
End Sub
using
using
using
using
using
using
using
using
using
System;
System.Data;
System.Configuration;
System.Web;
System.Web.Security;
System.Web.UI;
System.Web.UI.WebControls;
System.Web.UI.WebControls.WebParts;
System.Web.UI.HtmlControls;
190
using localhost;
public partial class _Default : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
Service Con = new Service();
DataSet Ds = Con.Consulta("SELECT * FROM Person.Address");
GridView1.DataSource = Ds;
}
}
Rode a aplicação e observe o GridView ser preenchido.
Abstraia o fato de você estar rodando o serviço e o consumindo em uma mesma
maquina, com um Web Service é possível trocar e fornecer informações de qualquer
lugar, através de ambientes heterogêneos ou mesmo incomunicáveis de uma outra
forma, utilizando um protocolo aberto e trocando informações através de um padrão
reconhecido por toda a industria (XML).
191
15. Criando uma página de erros personalizada
Erros acontecem e sempre vão acontecer mesmo nas mais grandiosas aplicações. Se não
podemos nos livrar totalmente deles, pelo menos temos que tentar encarar uma situação
desagradável com esta com a maior classe possível.
O ASP.NET nos prove alguns recursos para tratamento de erro, no sentido de exibirmos
mensagens padronizadas e mais amigáveis para o usuário.
Para exemplificar, primeiramente crie uma aplicação ASP.NET, e na página default
digite o seguinte código:
Dim con As New SqlConnection
con.Open()
SQLConnection con = New SQLConnection;
con.Open;
Como não informamos os parâmetros necessários para a abertura da conexão,
obviamente que nos será exibido um erro:
192
Além da mensagem não estar nada amigável, é importante ressaltar que determinadas
mensagem, se exibidas para o usuário final, pode expor aspectos delicados de nossa
aplicação, podendo inclusive coloca-la em risco.
Para criar uma página de erro personalizada, primeiramente devemos criar uma página
com este fim especifico. No exemplo, eu crie uma página chamada Erro.aspx e coloquei
uma mensagem para o usuário:
Em seguida, adicionamos um nó no web.config, como no exemplo abaixo:
<customErrors defaultRedirect="Erro.aspx"
mode="RemoteOnly">
<error statusCode="500"
redirect="Erro.aspx"/>
</customErrors>
Vamos entender o que cada elemento significa. Primeiramente o atributo defaulredirect
indica qual a página padrão será utilizada caso o código do erro não seja especificado.
Note que mais abaixo um nó erro nos diz que para o código 500, utilizamos a mesma
página, mas podemos personalizar o redirecionamento para uma página especifica,
conforme o tipo de erro.
193
O atributo mode é importantíssimo. Ele pode ter três valores: RemoteOnly, que o valor
padrão, indica que a página de erro personalizada só será exibida para usuários remotos.
Isto permite que você, que esta depurando a aplicação localmente, continue vendo as
mensagens de erros detalhas. On significa que todos, remotamente ou localmente verão
a página de erro personalizada, e Off, significa que ninguém vai ver a página
personalizada, ou seja, será exibido o erro detalhado para todo mundo.
Para ver a página de erro funcionando em sua máquina, altere o atributo mode para On,
e rode a aplicação:
194
16. Eventos da aplicação
Diversos eventos disparados por uma aplicação web podem ser capturados e tratados
pelo seu sistema. Os manipuladores para este eventos podem ser encontrados no arquivo
global.aspx
Para criar um arquivo global.aspx, vá em Add new Item e selecione Global
Application Class.
Os eventos disponíveis são:
Application_Start: Ocorre quando a aplicação é iniciada, ou seja, quando o
primeiro usuário acessa o site
Application_End: Ocorre quando a aplicação termina.
Application_Error: Disparado quando há um erro na aplicação.
Session_Start: Ocorre quando a sessão inicia.
Session_End: Ocorre quando a sessão finaliza.
No exemplo abaixo, cada vez que uma sessão inicia, uma variável de aplicação é
incrementada e decrementada quando a sessão termina:
Sub Session_Start(ByVal sender As Object, ByVal e As EventArgs)
Application("conta") += 1
End Sub
Sub Session_End(ByVal sender As Object, ByVal e As EventArgs)
Application("conta") -= 1
End Sub
void Session_Start(object sender, EventArgs e)
{
int i = Convert.ToInt32(Application["conta"]);
i += 1;
Application["conta"] = i;
}
void Session_End(object sender, EventArgs e)
{
int i = Convert.ToInt32(Application["conta"]);
i -= 1;
Application["conta"] = i;
195
}
Para exibirmos o número de usuários em nosso site, basta exibir o valor da variável em,
por exemplo, um label:
Label1.Text = Application("conta")
Label1.Text = Convert.ToString(Application["conta"]);
196
17. Distribuindo sua Aplicação
Normalmente todo o software, depois de finalizado, deve ser distribuído. Aplicações
convencionais na sua maioria são distribuídas através de instaladores específicos, o que
permite que qualquer usuário possa instalar a aplicação em seu computador de maneira
fácil, simplesmente seguindo alguns passos básicos.
Aplicações Web na sua maioria são instaladas em um único ou em alguns poucos
servidores. Você pode simplesmente copia-la para o destino ou até mesmo gerar um
instalador, como numa aplicação convencional.
Mas além de distribuir sua aplicação existem outros cuidados que você deve ter antes de
colocar sua aplicação em produção.
Primeiramente quando você cria sua aplicação, por padrão ele vai estar com a depuração
habilitada. A depuração é habilitada no arquivo web.config:
<compilation debug="false" strict="false" explicit="true" />
A depuração, como você deve imaginar, permite que você depure seu aplicativo. Isto
tem um custo: Alguns arquivos temporários têm que ser mantidos e o desempenho da
aplicação é afetado. Quando você roda seu aplicativo pela primeira vez, dentro da IDE
do VS, uma caixa de dialogo informa que a depuração esta desabilitada. Você pode
habilitá-la ou rodar a aplicação sem depuração, que seria o equivalente a executá-la fora
da ambiente do VS:
197
Ao autorizar a habilitação de depuração, seu web.config é alterado:
<compilation debug="true" strict="false" explicit="true"/>
O que isto tem a ver com distribuição de aplicação? É importante lembrar de desabilitar
a depuração quando compilar sua aplicação para distribuição, pois será gerado um
código otimizado e mais compacto.
Outra dica importante é colocar a aplicação em modo de Realise, no próprio VS, como
na imagem abaixo:
Utilizando Copy Web Site
A ferramenta Copy Web Site permite fazer uma copia de sua aplicação, seja para pasta
em um sistema de arquivo, um servidor FTP ou até mesmo um diretório sobre o IIS.
Para utilzir a ferramenta clique no ícone
no solution Explorer.
A ferramenta possui uma interface simples, mostrando a esquerda os arquivos da sua
apalicação e a direita os arquivos no destino:
198
O primeiro passo é apontar o destino, para isso clique em Connect. Neste exemplo
escolhi uma pasta local em meu comutador:
199
Você pode agora tranferir normalmente um arquivo de um lado para o outro.
Note que arquivos alterados e não atualizados sem marcados com uma seta Azul,
arquivos escluidos com um icone vermelho:
O processo de copia porem simplismente copia a aplicação da forma em que ela se
encontra. Para que possamos fazer uma copia para publicação, vamos utilizar o recurso
especifico com este fim.
Publicação
A ferramanta de publicação cria uma cópia pré-compilada de seu site. Para aciona-la,
basta clicar com o botão direito sobre o nome da aplicação no Solution Explorer e
escolher Publish. A caixa de dialo de publicação é exibida:
200
A escolha do local é feita da mesma forma que a ferramenta de copia: pode ser uma
pasta, um FTP ou mesmo um diretorio virtual do IIS.
Após escolhido o local, basta clicar em Publish. Observe no diretório de destinho que é
gerado uma pasta de nome bin, com um assembly em seu interior. Note também que
arquivos .vb ou .cs não são incluidos na publicação:
Criando um instaldor
Outra forma é criar um instaldor. O Visual Studio 2005 permite criar projetos de
instação para praticamente qualquer tipo de aplicação.
Para criar uma instalador para um web site, clique com o botão direito sobre a solução,
selecione Add New Project.
Em Other Project Type selecione Setup and Deployment a esquerda, e em templates
selecione Web Setup Project:
201
No projeto criado, a pasta WebApplicationFolder representa a aplicação a ser instalada.
Para adicionar sua apliação ao instalador clique com o botão direito sobre esta pasta,
selecione Project Output
Na caixa de dialogo Add Projectt Output Grop são exibidos os projetos da solução, se
existir apenas um como no exemplo abaixo, simplismente clique em OK.
202
Bom, neste ponto você já tem o instalador Pronto! Para testa-lo basta clicar com o botão
direito sobre o projeto do instaldor e selecionar Install. O instalador do projeto é
executado:
203
Durante a instalação você deve informar o nome do Site e do diretório virtual.
Após a instalação você pode desintala-la, para isso clique com o botão direito sobre o
projeto do instalador e selecione Unistall.
Mais recursos de instalação
O que você fez foi criar um instalador sem praticamente qualquer configuração, mas as
opções que você tem são enormes.
Primeiramente, ao clicar no projeto do instalador, veja que você pode personalizar
diversas atributos do instalador, como autor, descrição, nome do produto etc.
204
Existem ainda diversos editores que podem ser acessados através do solution explorer,
são eles:
Properties: Permite configurar algumas caracteristicas do instalador.
File System Editor: Permite adicionar ou remover arquivos ao instaldor, bem
como atalhos para a aplicação na maquina de destino.
Registry Editor: Permite manipular o registro do Windows durante a instalação.
File Type Editor: Permite associar extensões de arquivo com a programa
instalado.
User Interface Editor: Talvez o mais interessante e trabalhosos, permite criar,
remover e personalizar as janelas que serão exibidas durante o processo de
instalação.
Custom Action Editor: Permite executar ações personalizadas durante a
instalação. A ação deve ser associada a uma fase, como Install, Commit,
RollBack, Unistall
Lauch condition Editor: Permite avaliar condições para a instalação.
205
18. Relatórios com Crystal Report
Nesta sessão vamos aprender a criar alguns relatórios básicos com Crystal Report
Crie uma nova aplicação Web.
Clique com o botão direito sobre a aplicação, selecione Add New Item. Na caixa de
dialogo selecione Crystal Report:
Será exibido um assitente para configurar o relatório, selecione As a Blank Report e
clique em OK:
206
No Fields Explorer, clique em Database Fields com botão direito e selecione Database
Expert.
207
Expanda Create New Connection e selecione OLE DB(ADO):
Selecione Microsoft Ole DB Provider for SQL Server e clique em avançar:
208
Preencha as informações de servidor, usuário, senha e banco de dados, clique em
avançar:
209
Algumas informações são exibidas, clique em concluir. De volta ao DataBase expert,
selecione a tabela da qual será gerado o relatório:
210
De volta ao DataBase Fiedls, expanda o nó da tabela, arraste os campos para a sessão
detais de seu relatório:
211
Agora abra a sua página Default.aspx, adicione um controle CrystalReportViewer, que
pode ser encontrado na Guia Crystal Reports. Na Smart Tag do controle, em Chose
Report Souce, selecione New Report Souce:
Mantenha o nome padrão e selecione o relatório criado em Specify a Crystal...
Rode a aplicação.
212

1. Introdução ao ASP.NET - Cadastro Número da Sorte

Transcrição

Documentos relacionados

Mútua dos Pescadores – Mútua de Seguros C.R.L, seguradora

Oferta - Igreja Evangélica em Silvalde

Os interessados poderão pré-inscrever

das especificações em PDF

mauro manoel de oliveira

intervalo - Neiva Mello

Milton Alexandre da Si... - Uni

Programação III

Salinas Country Club Price: 465 000,00€ BEAUTIFUL 2 BEDROOM

criando uma experiência atrativa para o paciente engaje