Curso ASP.NET 3.5 em VB.NET e C# - 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 negócio entre uma requisição e outra.

por Fernando Amaral

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.

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:

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:

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

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")

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 é 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=" & 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.

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 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 estada-los 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:

<%@ 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

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.

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 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));