Cache é uma tecnologia que armazena dados/informações usados com frequência na memória para que na próxima vez que os mesmos dados/informações sejam necessários, eles possam ser recuperados diretamente da memória em vez de serem gerados novamente a partir do aplicativo.
O cache é muito importante para melhorar o desempenho do ASP porque as páginas e os controles ASP são gerados dinamicamente. Isto é extremamente importante para dados relacionados à interação, onde o tempo de resposta é escasso.
Em mídias que precisam ser acessadas rapidamente, como a memória de acesso aleatório de um computador, os caches armazenam dados usados com frequência. O tempo de execução ASP contém pares de valores-chave chamados objetos CLR armazenados em cache. Ele está localizado no aplicativo e está disponível por meio de HttpContext e System.Web.UI.Page.
De certa forma, o armazenamento em cache e o armazenamento de objetos de estado são semelhantes. No entanto, as informações armazenadas no objeto de estado são determinísticas. Por exemplo, você pode calcular os dados armazenados no objeto de estado, mas os dados armazenados em cache não são determinísticos.
Os dados não estão disponíveis nas seguintes circunstâncias:
Se o seu ciclo de vida tiver terminado,
Se o aplicativo liberar memória,
Se por algum motivo o cache não for substituído.
Você pode usar um indexador para acessar itens no cache e é possível controlar o tempo de vida dos objetos no cache e definir o relacionamento entre os objetos armazenados em cache e seus recursos físicos.
ASP fornece os seguintes tipos diferentes de cache:
Cache de saída : O cache de saída pode armazenar uma cópia da última página da web renderizada ou uma página parcial enviada ao cliente. Na próxima vez que o cliente solicitar a página, uma cópia em cache da página será enviada ao cliente em vez de regenerar a página, o que economiza tempo.
Cache de dados : O cache de dados refere-se ao armazenamento em cache de dados da fonte de dados. Enquanto o cache não for substituído, os dados serão obtidos do cache quando solicitados novamente. Quando o cache é substituído, novos dados são obtidos da fonte de dados e o cache é preenchido novamente.
Cache de objetos : O cache de objetos serve para armazenar em cache os objetos da página, como controles vinculados a dados, etc. Os dados armazenados em cache são colocados na memória do servidor.
Cache de classe : na primeira vez que uma página da web ou serviço da web é executado, as classes da página compiladas são montadas. A montagem é então armazenada em cache no servidor. Na próxima vez que a página ou serviço for solicitado, o assembly armazenado em cache será usado. Quando o código-fonte é alterado, o CLR recompila o assembly.
Cache de configuração : as informações de configuração do aplicativo são armazenadas em um arquivo de configuração. O cache de configuração armazena informações de configuração na memória do servidor.
Neste tutorial, consideraremos o cache de saída, o cache de dados e o cache de objetos.
A renderização de uma página pode envolver alguns processos complexos, como acesso ao banco de dados, renderização de controles complexos, etc. O cache de saída permite ignorar viagens de ida e volta ao servidor armazenando dados em cache na memória. Até a página inteira pode ser armazenada em cache.
A diretiva OutputCache é responsável pelo cache de saída. Ele permite o cache de saída e fornece um certo grau de controle sobre seu comportamento.
Sintaxe da diretiva OutputCache:
<%@ OutputCache Duration="15" VaryByParam="None" %>
Coloque esta diretiva sob a diretiva da página. Isso informa ao ambiente que a página precisa ser armazenada em cache por 15 segundos. O seguinte manipulador de eventos de carregamento de página ajudará a confirmar se a página foi armazenada em cache.
protected void Page_Load(object sender, EventArgs e){ Thread.Sleep(10000);}O método Thread.Sleep() interrompe o processo por um período específico de tempo. Neste exemplo, o encadeamento é interrompido por 10 segundos, portanto, quando a página é baixada pela primeira vez, leva 10 segundos. No entanto, na próxima vez que você atualizar a página, não demorará muito porque a página já foi obtida do cache e não será baixada novamente.
A diretiva OutputCache possui os seguintes recursos para ajudar a controlar o comportamento do cache de saída:
| propriedade | valor | descrever |
|---|---|---|
| DiskCacheable | verdadeiro/falso | Descreve se a saída pode ser gravada em disco com cache. |
| Sem loja | verdadeiro/falso | Descreve se o cabeçalho de cache "no store" é enviado. |
| Perfil de cache | Nome da sequência | O nome do arquivo de configuração de cache armazenado em web.config. |
| VaryByParam | Nenhum*Nome do parâmetro | Use valores de string separados por ponto e vírgula em solicitações GET ou valores de variáveis em solicitações POST. |
| VaryByHeader | *Nome do arquivo de cabeçalho | Pode ser uma string delimitada por ponto e vírgula especificando cabeçalhos enviados pelo cliente. |
| VaryByCustom | String personalizada do navegador | Notifique o ASP.NET sobre alterações no cache de saída por meio da versão do nome do navegador ou da string do cliente. |
| Localização | Qualquer cliente baixa o servidor de streamingNenhum | Qualquer: A página pode ser armazenada em cache em qualquer lugar Cliente: O conteúdo em cache está contido no navegador Fluxo de download: O conteúdo em cache é armazenado no fluxo de download e no servidor Servidor: O cache é armazenado apenas no servidor Nenhum: Nenhum armazenamento em cache é permitido. |
| Duração | número | O número de segundos para uma página ou operação ser armazenada em cache. |
Vamos adicionar uma caixa de texto e um botão ao exemplo anterior e adicionar um manipulador de eventos para esse botão.
protegido void btnmagic_Click(objeto remetente, EventArgs e){ Response.Write("<br><br>"); Response.Write("<h2> Olá, " + this.txtname.Text + "</h2>") ;}Altere a diretiva OutputCache:
<%@ OutputCache Duration="60" VaryByParam="txtname" %>
Quando o programa é executado, o ASP armazena em cache a página com base no nome na caixa de texto.
O principal aspecto do cache de dados é o cache de controle da fonte de dados. Discutimos os controles de fonte de dados que representam dados de uma fonte de dados, como um banco de dados ou um arquivo XML. Esses controles são derivados da classe abstrata DataSourceControl e possuem as seguintes propriedades herdadas para armazenamento em cache:
Período de cache — O tempo para a fonte de dados armazenar os dados em cache.
Política de expiração de cache — define o comportamento do cache quando os dados no cache expiram.
Dependência de valor de cache - define um valor de controle que move automaticamente os dados para fora do cache quando ele expirar.
Habilitar cache: você pode confirmar se os dados estão armazenados em cache.
Para demonstrar o cache de dados, criamos um novo site e adicionamos um novo formulário web a ele. Adicione um controle SqlDataSource ao banco de dados que se conecta ao tutorial de acesso a dados.
Neste exemplo, adicionamos um rótulo à página que exibe o tempo de resposta da página.
<asp:Label ID="lbltime" runat="server"></asp:Label>
Tirando essa tag, a página inteira é igual ao tutorial de acesso a dados. Adicione um manipulador de eventos a esta página para baixar o horário.
protegido void Page_Load(objeto remetente, EventArgs e){ lbltime.Text = String.Format("Página postada em: {0}", DateTime.Now.ToLongTimeString());}A página projetada deve ficar assim:
Quando você executa a página pela primeira vez, nada de diferente acontece. Exibição da etiqueta, toda vez que a página for atualizada, a página será recarregada e a mudança de horário será exibida na etiqueta.
Em seguida, defina a propriedade EnableCaching do controle de fonte de dados como "true" e a propriedade Cacheduration como "60". Ele implementará o cache e o cache expirará a cada 60 segundos.
Cada vez que for atualizado, o carimbo de data/hora será alterado. Mas se você alterar os dados da tabela em 60 segundos, eles não serão exibidos até que o cache expire.
<asp:SqlDataSource ID = "SqlDataSource1" runat = "servidor" ConnectionString = "<%$ ConnectionStrings: ASPDotNetStepByStepConnectionString %>" ProviderName = "<%$ ConnectionStrings: ASPDotNetStepByStepConnectionString.ProviderName %>" SelectCommand = "SELECT * FROM [DotNetReferences]" EnableCaching = "verdadeiro" CacheDuration = "60"> </asp:SqlDataSource>
O cache de objetos oferece maior flexibilidade do que outras tecnologias de cache. Você pode usar o cache de objetos para colocar qualquer objeto no cache. Os objetos também podem ser de qualquer tipo – tipos de dados, controles de rede, classes, objetos de configurações de dados, etc. Esses itens podem ser adicionados ao cache simplesmente atribuindo-lhes um nome de valor, conforme mostrado abaixo:
Cache["key"] = item;
Para inserir objetos no cache, o ASP fornece o método Insert(). Existem quatro versões sobrecarregadas deste método. Vamos dar uma olhada:
| Sobrecarga | descrever |
|---|---|
| Cache.Insert((chave, valor); | Insira no cache na forma de pares chave-valor, sendo a prioridade e o ciclo de vida o padrão. |
| Cache.Insert(chave, valor, dependências); | Insira o cache no cache como pares de valores-chave, com prioridades e tempos de vida padrão, e dependências de cache vinculadas a outros arquivos ou conteúdo, para que as modificações do cache não sejam mais limitadas. |
| Cache.Insert(chave, valor, dependências, AbsolutExpiration, deslizanteExpiration); | Indique o período de validade da configuração acima. |
| Cache.Insert(chave, valor, dependências, absolutoExpiration, deslizamentoExpiration, prioridade, onRemoveCallback); | Junto com a configuração também permite definir a prioridade do conteúdo e delegação em cache, indicando um método a ser chamado quando um objeto é removido. |
O ciclo de vida dinâmico é usado para remover um item de cache que não é válido para qualquer intervalo de tempo especificado. O snippet de código a seguir salva um item de cache livre de dependência com um tempo de vida deslizante de 10 minutos:
Cache.Insert("meu_item", obj, null, DateTime.MaxValue, TimeSpan.FromMinutes(10));Crie uma página usando apenas um botão e um rótulo. Escreva o seguinte código no evento de carregamento da página:
protected void Page_Load(object sender, EventArgs e){ if (this.IsPostBack) { lblinfo.Text += "Página postada de volta.<br/>" } else { lblinfo.Text += "página criada.<br/> "; } if (Cache["testitem"] == null) { lblinfo.Text += "Criando item de teste.<br/>"; DateTime testItem = DateTime.Now; lblinfo.Text += "Armazenando item de teste no cache"; lblinfo.Text += "por 30 segundos.<br/>"; (30), TimeSpan.Zero } else { lblinfo.Text += "Recuperando item de teste.<br/>"; = (DateTime)Cache["testitem"]; lblinfo.Text += "O item de teste é: " + testItem.ToString(); />";}Quando a página é carregada pela primeira vez, ela exibe:
Página criada.Criando item de teste.Armazenando item de teste no cache por 30 segundos.
Se você clicar no botão novamente em 30 segundos, embora a página tenha sido excluída, o controle de rótulo obterá as informações do cache, conforme mostrado abaixo:
Página postada atrás.Recuperando item de teste.Item de teste é: 14-07-2010 01:25:04