Olá! Quinta Feira, 23 de Maio de 2013.



Dicas CódigoFonte.net
Segunda Feira, 09 de Fevereiro de 2009

Armazenando a ViewState na Session no ASP.Net

Olá Pessoal,

Hoje vou explicar como diminuirmos um tamanho da página trocando a forma como é armazenado um mecanismo chamado ViewState no ASP.Net

Como vocês devem saber, as nossas páginas ASP.NET armazenam os estatos dos componentes no HTML gerado para o cliente, isto permite que os controles sejam preenchidos e seus valores possam ser acessados em nosso código .cs. É simplesmente uma maravilha, porém, caso tenhamos muitas informações nestes controles, nosso viewstate também crescerá e, como consequência, a página gerada para o usuário também.

Já cheguei a pegar projetos que consegui economizar mais de 70Kb só com informações de viewstate. Mas, como eu consegui isto? Armazenando o nosso viewstate no CACHE ou na Sessão!

No código a seguir, a classe, baseada nos parâmetros de configuração no web.config, irá armazenar nosso viewstate no CACHE ou na SESSION (recomendo colocá-los na SESSION).

Primeiro, você deve adicionar as seguintes configurações dentro do seu Web.config (lembre-se de colocá-las dentro da tag <appSettings>aqui</appSettings>.

  1. <add key="ServerSideViewState" value="True"/>
  2. <add key="ViewStateStore" value="Session"/>
  3. <add key="ViewStateTableSize" value="150"/>

Isto será necessário em nossa classe. Explico cada linha dentro do código.

Crie uma classe dentro do projeto Web, provavelmente o ASP.Net (se você não tiver) irá perguntar se deseja criar uma pasta chamada "App_Code". Diga sim. Esta nova classe será criada dentro desta pasta.

O código dela segue:

  1. public abstract class ViewStatePage : System.Web.UI.Page
  2. {
  3.     protected override void SavePageStateToPersistenceMedium(object viewState) {
  4.         // cria uma chave única para este viewstate
  5.         string VSKey = "VIEWSTATE_" + Session.SessionID + "_" + Request.RawUrl + "_" + DateTime.Now.Ticks.ToString();
  6.  
  7.         // verifica se o parâmetro do appsettings foi ativado
  8.         if (ConfigurationManager.AppSettings["ServerSideViewState"].ToUpper() == "TRUE") {
  9.             // verifica se o tipo de armazenamento é por CACHE ou Session
  10.             if (ConfigurationManager.AppSettings["ViewStateStore"].ToUpper() == "CACHE") {
  11.                 //armazena o viewstate no CACHE
  12.                 Cache.Add(VSKey, viewState, null, System.DateTime.Now.AddMinutes(Session.Timeout), System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.Default, null);
  13.             }           
  14.             else {
  15.                 // armazena o viewstate na sessão
  16.                 DataTable VsDataTable;
  17.                 DataRow DbRow;
  18.  
  19.                 // verifica se já existe um datatable das viewstates na sessão
  20.                 if ((Session["__VSDataTable"] == null)) {
  21.                     // não existe, cria...
  22.                     DataColumn[] PkColumn = new DataColumn[1];
  23.                     DataColumn DbColumn;
  24.                     VsDataTable = new DataTable("VState");
  25.                    
  26.                     //Coluna 1 - Nome: VSKey - PrimaryKey
  27.                     DbColumn = new DataColumn("VSKey", typeof(string));
  28.                     VsDataTable.Columns.Add(DbColumn);
  29.                     PkColumn[0] = DbColumn;
  30.                     VsDataTable.PrimaryKey = PkColumn;
  31.  
  32.                     //Coluna 2 - Nome: ViewStateData
  33.                     DbColumn = new DataColumn("VSData", typeof(object));
  34.                     VsDataTable.Columns.Add(DbColumn);
  35.  
  36.                     //Coluna 3 - Nome: DateTime
  37.                     DbColumn = new DataColumn("DateTime", typeof(System.DateTime));
  38.                     VsDataTable.Columns.Add(DbColumn);
  39.                 } else {
  40.                     // o datatable das viewstates já existe, pega ele da sessão
  41.                     VsDataTable = (DataTable)Session["__VSDataTable"];
  42.                 }
  43.  
  44.                 // verifica se já temos uma viewstate com esta mesma chave
  45.                 // se sim, atualiza as informações na linha
  46.                 // do contrário, adiciona ela no datatable
  47.                 DbRow = VsDataTable.Rows.Find(VSKey);
  48.  
  49.                 if ((DbRow != null)) {
  50.                     // linha encontrada! atualiza as informações sem criar uma nova linha
  51.                     DbRow["VsData"] = viewState;
  52.                 } else {
  53.                     // cria uma nova linha
  54.                     DbRow = VsDataTable.NewRow();
  55.                     DbRow["VSKey"] = VSKey;
  56.                     DbRow["VsData"] = viewState;
  57.                     DbRow["DateTime"] = System.DateTime.Now;
  58.                     VsDataTable.Rows.Add(DbRow);
  59.                 }
  60.  
  61.                 // isto evita que o datatable tenha um grande tamanho.
  62.                 // apaga a primeira linha
  63.                 if (Convert.ToInt32(ConfigurationManager.AppSettings["ViewStateTableSize"]) < VsDataTable.Rows.Count) {
  64.                     VsDataTable.Rows[0].Delete();                   
  65.                 }
  66.  
  67.                 // grava o datatable na sessão
  68.                 Session["__VSDataTable"] = VsDataTable;
  69.             }
  70.  
  71.             // registra um campo hidden da página
  72.             // que irá conter somente a key que foi gerada.
  73.             // com ela, será possível encontrar este viewstate armazenado
  74.             // no nosso datatable que está na session e, com isto, recuperar a sessão.
  75.             RegisterHiddenField("__VIEWSTATE_KEY", VSKey);
  76.         } else {
  77.             // chama o processo normal, pois não foi ativo no appsettings no web.config
  78.             base.SavePageStateToPersistenceMedium(viewState);
  79.         }
  80.     }
  81.  
  82.     protected override object LoadPageStateFromPersistenceMedium() {
  83.         //Verifica se o ServerSideViewState está ativado
  84.         if (ConfigurationManager.AppSettings["ServerSideViewState"].ToUpper() == "TRUE") {
  85.  
  86.             // pega a key que está no campo hidden criado
  87.             string VSKey = Request.Form["__VIEWSTATE_KEY"];
  88.            
  89.             // e valida
  90.             if (!VSKey.StartsWith("VIEWSTATE_")) {
  91.                 throw new Exception("Invalid VIEWSTATE Key: " + VSKey);
  92.             }
  93.  
  94.             // verifica se utiliza CACHE
  95.             if (ConfigurationManager.AppSettings["ViewStateStore"].ToUpper() == "CACHE") {
  96.                 return Cache[VSKey];
  97.             } else {
  98.                 // ou session
  99.                 DataTable VsDataTable = (DataTable)Session["__VSDataTable"];
  100.  
  101.                 if (VsDataTable != null) {
  102.                     DataRow DbRow = VsDataTable.Rows.Find(VSKey);
  103.  
  104.                     if ((DbRow == null)) {
  105.                         //throw new Exception("Não foi possível encontrar o 'VIEWStateKey'. Tente limpar o cache de seu navegador ou recarregar esta página usando as teclas CTRL + F5.");
  106.                         return null;
  107.                     }
  108.                     return DbRow["VsData"];
  109.                 }
  110.                 return null;
  111.             }
  112.         } else {
  113.             // retorna o viewstate no modo normal
  114.             return base.LoadPageStateFromPersistenceMedium();
  115.         }
  116.     }
  117. }

Pronto. Criado a classe, você deverá alterar suas páginas para não mais herdar da classe

System.Web.UI.Page, mas sim da sua nova classe ViewStatePage.

Feito isto, todo o resto do processo será automático e, caso tenha curiosidade, poderá ver que seu HTML terá um tamanho bastante reduzido, comparado a quando era antes.

Caso deseje não mais utilizar este mecanismo, basta setar a configuração como False no seu parâmetro ServerSideViewState do Web.config.

Tem também uma outra forma de fazer este processo de economia do ViewState, é compactando ele. Veja como compactar um viewstate no ASP.Net neste artigo.

Bom, por hoje é só pessoal.

Até a próxima.


Comentários do artigo [Novo comentário]

Renato Mattos - 03 de Março de 2010 - 18:08
Parabéns pelo artigo. O código funcionou perfeitamente sem erros e melhorou o desempenho de minha aplicação. Obrigado por compartilhar o seu código.
claudio furukawa - 24 de Maio de 2010 - 12:39
O artigo funciona, mas usando AJAX apresenta erros no codigo :

"Erro em tempo de execução do Microsoft JScript: Sys.WebForms.PageRequestManagerParserErrorException: The message received from the server could not be parsed. Common causes for this error are when the response is modified by calls to Response.Write(), response filters, HttpModules, or server trace is enabled."

Será que tem como resolver isto?
Alguem tem uma solução?

Abraços..
Emmanuel Alves Nóbrega - 06 de Setembro de 2010 - 00:52
Iae kra, pra poder resolver o problema, altera a linha onde tem RegisterHiddenField("__VIEWSTATE_KEY", VSKey); para ScriptManager.RegisterHiddenField(this, "__VIEWSTATE_KEY", VSKey);
Para adicionar um comentário você deve efetuar o login


Gostou do CódigoFonte.net? Quer indicar a um amigo?
Preencha os campos a seguir.
Seu Nome:
Seu E-mail:
E-mail de seu Amigo:
busca recomenda validação banco de dados msn usuário códigos para blogger fotos captcha pdf formulario de email mensagem buscador formulario html galeria relogio mural de recados iframe gerador python boletim sql formulário previsão do tempo calendário pagina formularios usuarios c dj

» Busca avançada

Siga-nos no Twitter






CodigoFonte.net » CodigoFonte.eti.br » Compre De Tudo » Meu Mural » Competiva - Criação de Sites » Todos os Direitos Reservados © 2002/2010