Cache
pela Microsoft
Uma compreensão do cache é importante para um aplicativo de ASP.NET com bom desempenho. ASP.NET 1.x ofereceu três opções diferentes para cache; cache de saída, cache de fragmentos e a API de cache.
Uma compreensão do cache é importante para um aplicativo de ASP.NET com bom desempenho. ASP.NET 1.x ofereceu três opções diferentes para cache; cache de saída, cache de fragmentos e a API de cache. ASP.NET 2.0 oferece todos esses três métodos, mas adiciona alguns recursos adicionais significativos. Há várias novas dependências de cache e os desenvolvedores agora têm a opção de criar dependências de cache personalizadas também. A configuração do cache também foi aprimorada significativamente em ASP.NET 2.0.
Novos recursos
Perfis de cache
Os perfis de cache permitem que os desenvolvedores definam configurações de cache específicas que podem ser aplicadas a páginas individuais. Por exemplo, se você tiver algumas páginas que devem expirar do cache após 12 horas, poderá criar facilmente um perfil de cache que possa ser aplicado a essas páginas. Para adicionar um novo perfil de cache, use a <seção outputCacheSettings> no arquivo de configuração. Por exemplo, abaixo está a configuração de um perfil de cache chamado twoday que configura uma duração de cache de 12 horas.
<outputCacheSettings>
<outputCacheProfiles>
<add name="TwoDay" duration="43200" />
</outputCacheProfiles>
</outputCacheSettings>
Para aplicar esse perfil de cache a uma página específica, use o atributo CacheProfile da diretiva @ OutputCache, conforme mostrado abaixo:
<%@ OutputCache CacheProfile="TwoDay" %>
Dependências de cache personalizadas
ASP.NET desenvolvedores 1.x pediram dependências de cache personalizadas. No ASP.NET 1.x, a classe CacheDependency foi selada, o que impediu os desenvolvedores de derivar suas próprias classes dela. No ASP.NET 2.0, essa limitação é removida e os desenvolvedores são livres para desenvolver suas próprias dependências de cache personalizadas. A classe CacheDependency permite a criação de uma dependência de cache personalizada com base em arquivos, diretórios ou chaves de cache.
Por exemplo, o código abaixo cria uma nova dependência de cache personalizada com base em um arquivo chamado stuff.xml localizado na raiz do aplicativo Web:
System.Web.Caching.CacheDependency dep = new
System.Web.Caching.CacheDependency(Server.MapPath("stuff.xml"));
Response.AddCacheDependency(dep);
Cache.Insert("key", "value");
Nesse cenário, quando o arquivo stuff.xml é alterado, o item armazenado em cache é invalidado.
Também é possível criar uma dependência de cache personalizada usando chaves de cache. Usando esse método, a remoção da chave de cache invalidará os dados armazenados em cache. O exemplo a seguir ilustra isso:
// insert a value into cache that will serve
// as the cache key
Cache["CacheKey"] = "something";
// create an array of cache keys
string[] keys = new String[1];
keys[0] = "CacheKey";
CacheDependency dep = new CacheDependency(null, keys);
// insert an item into cache with a dependency on
// the above CacheDependency
Cache.Insert("Key", "Value", dep);
Para invalidar o item que foi inserido acima, basta remover o item que foi inserido no cache para atuar como a chave de cache.
// Remove the cache item that serves as the cache key
Cache.Remove("CacheKey");
Observe que a chave do item que atua como a chave de cache deve ser igual ao valor adicionado à matriz de chaves de cache.
Polling-Based dependências do Cache SQL (também chamadas de dependências de Table-Based)
SQL Server 7 e 2000 usam o modelo baseado em sondagem para dependências de cache do SQL. O modelo baseado em sondagem usa um gatilho em uma tabela de banco de dados disparada quando os dados na tabela são alterados. Esse gatilho atualiza um campo changeId na tabela de notificação que ASP.NET verifica periodicamente. Se o campo changeId tiver sido atualizado, ASP.NET saberá que os dados foram alterados e invalida os dados armazenados em cache.
Observação
SQL Server 2005 também pode usar o modelo baseado em sondagem, mas como o modelo baseado em sondagem não é o modelo mais eficiente, é aconselhável usar um modelo baseado em consulta (discutido posteriormente) com SQL Server 2005.
Para que uma dependência de cache do SQL usando o modelo baseado em sondagem funcione corretamente, as tabelas devem ter notificações habilitadas. Isso pode ser feito programaticamente usando a classe SqlCacheDependencyAdmin ou usando o utilitário aspnet_regsql.exe.
A linha de comando a seguir registra a tabela Products no banco de dados Northwind localizado em uma instância de SQL Server chamada dbase para dependência de cache do SQL.
aspnet_regsql -S dbase -ed -d Northwind -E -et -t Products
Veja a seguir uma explicação das opções de linha de comando usadas no comando acima:
| Comutador de Linha de Comando | Finalidade |
|---|---|
| -S server | Especifica o nome do servidor. |
| -Ed | Especifica que o banco de dados deve ser habilitado para dependência de cache do SQL. |
| -d database_name | Especifica o nome do banco de dados que deve ser habilitado para a dependência de cache do SQL. |
| -E | Especifica que aspnet_regsql deve usar autenticação do Windows ao se conectar ao banco de dados. |
| -Et | Especifica que estamos habilitando uma tabela de banco de dados para dependência de cache SQL. |
| -t table_name | Especifica o nome da tabela de banco de dados a ser habilitada para dependência de cache do SQL. |
Observação
Há outras opções disponíveis para aspnet_regsql.exe. Para obter uma lista completa, execute aspnet_regsql.exe -? de uma linha de comando.
Quando esse comando executa, as seguintes alterações são feitas no banco de dados SQL Server:
- Uma tabela AspNet_SqlCacheTablesForChangeNotification é adicionada. Esta tabela contém uma linha para cada tabela no banco de dados para a qual uma dependência de cache SQL foi habilitada.
- Os seguintes procedimentos armazenados são criados dentro do banco de dados:
| AspNet_SqlCachePollingStoredProcedure | Consulta a tabela de AspNet_SqlCacheTablesForChangeNotification e retorna todas as tabelas habilitadas para dependência de cache sql e o valor de changeId para cada tabela. Esse procedimento armazenado é usado para sondagem para determinar se os dados foram alterados. |
|---|---|
| AspNet_SqlCacheQueryRegisteredTablesStoredProcedure | Retorna todas as tabelas habilitadas para dependência de cache SQL consultando a tabela AspNet_SqlCacheTablesForChangeNotification e retorna todas as tabelas habilitadas para dependência de cache SQL. |
| AspNet_SqlCacheRegisterTableStoredProcedure | Registra uma tabela para dependência de cache SQL adicionando a entrada necessária na tabela de notificação e adiciona o gatilho. |
| AspNet_SqlCacheUnRegisterTableStoredProcedure | Cancela o registro de uma tabela para a dependência de cache do SQL removendo a entrada na tabela de notificação e removendo o gatilho. |
| AspNet_SqlCacheUpdateChangeIdStoredProcedure | Atualizações a tabela de notificação incrementando a changeId da tabela alterada. ASP.NET usa esse valor para determinar se os dados foram alterados. Conforme indicado abaixo, esse proc armazenado é executado pelo gatilho criado quando a tabela está habilitada. |
- Um gatilho SQL Server chamado table_name_AspNet_SqlCacheNotification_Trigger é criado para a tabela. Esse gatilho executa o AspNet_SqlCacheUpdateChangeIdStoredProcedure quando um INSERT, UPDATE ou DELETE é executado na tabela.
- Uma função SQL Server chamada aspnet_ChangeNotification_ReceiveNotificationsOnlyAccess é adicionada ao banco de dados.
A função SQL Server aspnet_ChangeNotification_ReceiveNotificationsOnlyAccess tem permissões EXEC para o AspNet_SqlCachePollingStoredProcedure. Para que o modelo de sondagem funcione corretamente, você deve adicionar sua conta de processo à função aspnet_ChangeNotification_ReceiveNotificationsOnlyAccess. A ferramenta aspnet_regsql.exe não fará isso por você.
Configurando Polling-Based dependências do Cache SQL
Há várias etapas necessárias para configurar dependências de cache sql baseadas em sondagem. A primeira etapa é habilitar o banco de dados e a tabela, conforme discutido acima. Depois que essa etapa for concluída, o restante da configuração será o seguinte:
- Configurando o arquivo de configuração ASP.NET.
- Configurando o SqlCacheDependency
Configurando o arquivo de configuração do ASP.NET
Além de adicionar uma cadeia de conexão conforme discutido em um módulo anterior, você também deve configurar um <elemento de cache> com um <elemento sqlCacheDependency> , conforme mostrado abaixo:
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<connectionStrings>
<add name="Pubs"
connectionString="Data Source=(local);
Initial Catalog=pubs;Integrated Security=true;"
providerName="System.Data.SqlClient" />
</connectionStrings>
<system.web>
<caching>
<sqlCacheDependency enabled = "true" pollTime = "60000" >
<databases>
<add name="pubs" connectionStringName = "pubs" pollTime = "9000000" />
</databases>
</sqlCacheDependency>
</caching>
</system.web>
</configuration>
Essa configuração permite uma dependência de cache SQL no banco de dados pubs . Observe que o atributo pollTime no <elemento sqlCacheDependency> usa como padrão 60000 milissegundos ou 1 minuto. (Esse valor não pode ser inferior a 500 milissegundos.) Neste exemplo, o <elemento add> adiciona um novo banco de dados e substitui o pollTime, definindo-o como 9000000 milissegundos.
Configurando o SqlCacheDependency
A próxima etapa é configurar o SqlCacheDependency. A maneira mais fácil de fazer isso é especificar o valor para o atributo SqlDependency na diretiva @ Outcache da seguinte maneira:
<%@ OutputCache duration="60"
VaryByParam="none" SqlDependency="pubs:authors" %>
Na diretiva @ OutputCache acima, uma dependência de cache sql é configurada para a tabela authors no banco de dados pubs . Várias dependências podem ser configuradas separando-as com um ponto e vírgula da seguinte forma:
<%@ OutputCache duration="60"
VaryByParam="none"
SqlDependency="database_name:table_name;database_name:table_name" %>
Outro método de configuração do SqlCacheDependency é fazer isso programaticamente. O código a seguir cria uma nova dependência de cache SQL na tabela authors no banco de dados pubs .
SqlCacheDependency dep = new SqlCacheDependency("pubs", "authors");
Um dos benefícios de definir programaticamente a dependência do cache SQL é que você pode lidar com quaisquer exceções que possam ocorrer. Por exemplo, se você tentar definir uma dependência de cache SQL para um banco de dados que não foi habilitado para notificação, uma exceção DatabaseNotEnabledForNotificationException será gerada. Nesse caso, você pode tentar habilitar o banco de dados para notificações chamando o método SqlCacheDependencyAdmin.EnableNotifications e passando o nome do banco de dados.
Da mesma forma, se você tentar definir uma dependência de cache SQL para uma tabela que não foi habilitada para notificação, um TableNotEnabledForNotificationException será gerado. Em seguida, você pode chamar o método SqlCacheDependencyAdmin.EnableTableForNotifications passando-lhe o nome do banco de dados e o nome da tabela.
O exemplo de código a seguir ilustra como configurar corretamente o tratamento de exceções ao configurar uma dependência de cache SQL.
try {
SqlCacheDependency SqlDep = new
SqlCacheDependency("pubs", "authors");
} catch (DatabaseNotEnabledForNotificationException exDBDis) {
try {
SqlCacheDependencyAdmin.EnableNotifications("pubs");
} catch (UnauthorizedAccessException exPerm) {
Response.Redirect("ErrorPage.htm");
}
} catch (TableNotEnabledForNotificationException exTabDis) {
try {
SqlCacheDependencyAdmin.EnableTableForNotifications("pubs",
"authors");
} catch (System.Data.SqlClient.SqlException exc) {
Response.Redirect("ErrorPage.htm");
}
} finally {
Cache.Insert("SqlSource", Source1, SqlDep);
}
Mais informações: https://msdn.microsoft.com/library/t9x04ed2.aspx
Query-Based Dependências do Cache SQL (somente SQL Server 2005)
Ao usar SQL Server 2005 para dependência de cache SQL, o modelo baseado em sondagem não é necessário. Quando usadas com SQL Server 2005, as dependências do cache SQL se comunicam diretamente por meio de conexões SQL com a instância de SQL Server (nenhuma configuração adicional é necessária) usando notificações de consulta SQL Server 2005.
A maneira mais simples de habilitar a notificação baseada em consulta é fazer isso declarativamente definindo o atributo SqlCacheDependency do objeto de fonte de dados como CommandNotification e definindo o atributo EnableCaching como true. Usando esse método, nenhum código é necessário. Se o resultado de um comando executado na fonte de dados for alterado, ele invalidará os dados de cache.
O exemplo a seguir configura um controle de fonte de dados para a dependência do cache SQL:
<asp:SqlDataSource ID="ProductList" runat="server"
ConnectionString="<%$ ConnectionStrings:Northwind %>"
EnableCaching="true"
SqlCacheDependency="CommandNotification"
SelectCommand="SELECT * FROM [Products]" />
Nesse caso, se a consulta especificada no SelectCommand retornar um resultado diferente do que originalmente, os resultados armazenados em cache serão invalidados.
Você também pode especificar que todas as suas fontes de dados sejam habilitadas para dependências de cache SQL definindo o atributo SqlDependency da diretiva @ OutputCache como CommandNotification. O exemplo a seguir ilustra isso.
<%@ OutputCache SqlDependency="CommandNotification"
duration="60" VaryByParam="none" %>
Observação
Para obter mais informações sobre notificações de consulta no SQL Server 2005, consulte os SQL Server Manuais Online.
Outro método de configuração de uma dependência de cache SQL baseada em consulta é fazer isso programaticamente usando a classe SqlCacheDependency. O exemplo de código a seguir ilustra como isso é feito.
string sql = "SELECT ProductName, ProductID FROM Products";
SqlConnection conn = new
SqlConnection(ConfigurationManager.ConnectionStrings["Northwind"].ConnectionString);
SqlCommand cmd = new SqlCommand(sql, conn);
SqlCacheDependency dep = new SqlCacheDependency(cmd);
Response.AddCacheDependency(dep);
Mais informações: https://msdn.microsoft.com/library/default.asp?url=/library/enus/dnvs05/html/querynotification.asp
Substituição pós-cache
Armazenar em cache uma página pode aumentar drasticamente o desempenho de um aplicativo Web. No entanto, em alguns casos, você precisa que a maior parte da página seja armazenada em cache e alguns fragmentos dentro da página sejam dinâmicos. Por exemplo, se você criar uma página de notícias totalmente estática por períodos de tempo definidos, poderá definir a página inteira como armazenada em cache. Se você quiser incluir uma faixa de anúncios rotativa que foi alterada em cada solicitação de página, a parte da página que contém o anúncio precisará ser dinâmica. Para permitir que você armazene em cache uma página, mas substitua algum conteúdo dinamicamente, você pode usar ASP.NET substituição pós-cache. Com a substituição pós-cache, toda a página é armazenada em cache com partes específicas marcadas como isentas de cache. No exemplo das faixas de anúncios, o controle AdRotator permite que você aproveite a substituição pós-cache para que os anúncios criados dinamicamente para cada usuário e para cada atualização de página.
Há três maneiras de implementar a substituição pós-cache:
- Declarativamente, usando o controle Substituição.
- Programaticamente, usando a API de controle substituição.
- Implicitamente, usando o controle AdRotator.
Controle de substituição
O controle substituição ASP.NET especifica uma seção de uma página armazenada em cache que é criada dinamicamente em vez de armazenada em cache. Você coloca um controle Substituição no local na página em que deseja que o conteúdo dinâmico apareça. Em tempo de execução, o controle Substituição chama um método que você especifica com a propriedade MethodName. O método deve retornar uma cadeia de caracteres, que, em seguida, substitui o conteúdo do controle Substituição. O método deve ser um método estático no controle Page ou UserControl que contém. O uso do controle de substituição faz com que a capacidade de cache do lado do cliente seja alterada para a capacidade de cache do servidor, para que a página não seja armazenada em cache no cliente. Isso garante que as solicitações futuras para a página chamem o método novamente para gerar conteúdo dinâmico.
API de substituição
Para criar conteúdo dinâmico para uma página armazenada em cache programaticamente, você pode chamar o método WriteSubstitution em seu código de página, passando-lhe o nome de um método como um parâmetro. O método que manipula a criação do conteúdo dinâmico usa um único parâmetro HttpContext e retorna uma cadeia de caracteres. A cadeia de caracteres de retorno é o conteúdo que será substituído no local especificado. Uma vantagem de chamar o método WriteSubstitution em vez de usar o controle Substituição declarativamente é que você pode chamar um método de qualquer objeto arbitrário em vez de chamar um método estático do objeto Page ou UserControl.
Chamar o método WriteSubstitution faz com que a capacidade de cache do lado do cliente seja alterada para a capacidade de cache do servidor, para que a página não seja armazenada em cache no cliente. Isso garante que as solicitações futuras para a página chamem o método novamente para gerar conteúdo dinâmico.
Controle AdRotator
O controle de servidor AdRotator implementa o suporte para substituição pós-cache internamente. Se você colocar um controle AdRotator em sua página, ele renderizará anúncios exclusivos em cada solicitação, independentemente de a página pai ser armazenada em cache. Como resultado, uma página que inclui um controle AdRotator só é armazenada em cache no lado do servidor.
Classe ControlCachePolicy
A classe ControlCachePolicy permite o controle programático do cache de fragmentos usando controles de usuário. ASP.NET insira controles de usuário em uma instância BasePartialCachingControl . A classe BasePartialCachingControl representa um controle de usuário que tem o cache de saída habilitado.
Ao acessar a propriedade BasePartialCachingControl.CachePolicy de um controle PartialCachingControl , você sempre receberá um objeto ControlCachePolicy válido. No entanto, se você acessar a propriedade UserControl.CachePolicy de um controle UserControl , receberá um objeto ControlCachePolicy válido somente se o controle de usuário já estiver encapsulado por um controle BasePartialCachingControl. Se não estiver encapsulado, o objeto ControlCachePolicy retornado pela propriedade gerará exceções quando você tentar manipulá-lo porque ele não tem um BasePartialCachingControl associado. Para determinar se uma instância usercontrol dá suporte ao cache sem gerar exceções, inspecione a propriedade SupportsCaching .
Usar a classe ControlCachePolicy é uma das várias maneiras de habilitar o cache de saída. A lista a seguir descreve os métodos que você pode usar para habilitar o cache de saída:
- Use a diretiva @ OutputCache para habilitar o cache de saída em cenários declarativos.
- Use o atributo PartialCachingAttribute para habilitar o cache para um controle de usuário em um arquivo code-behind.
- Use a classe ControlCachePolicy para especificar as configurações de cache em cenários programáticos em que você está trabalhando com instâncias BasePartialCachingControl que foram habilitadas para cache usando um dos métodos anteriores e carregadas dinamicamente usando o método System.Web.UI.TemplateControl.LoadControl .
Uma instância de ControlCachePolicy só pode ser manipulada com êxito entre os estágios Init e PreRender do ciclo de vida do controle. Se você modificar um objeto ControlCachePolicy após a fase PreRender, ASP.NET gerará uma exceção porque as alterações feitas após a renderização do controle não poderão realmente afetar as configurações de cache (um controle é armazenado em cache durante o estágio renderização). Por fim, uma instância de controle de usuário (e, portanto, seu objeto ControlCachePolicy) só está disponível para manipulação programática quando ela é realmente renderizada.
Alterações na configuração de cache – o <elemento de cache>
Há várias alterações na configuração de cache no ASP.NET 2.0. O <elemento de cache> é novo no ASP.NET 2.0 e permite que você faça alterações de configuração de cache no arquivo de configuração. Os atributos a seguir estão disponíveis.
| Element | Descrição |
|---|---|
| Cache | Elemento opcional. Define as configurações de cache de aplicativo global. |
| Outputcache | Elemento opcional. Especifica as configurações de cache de saída em todo o aplicativo. |
| Outputcachesettings | Elemento opcional. Especifica as configurações de cache de saída que podem ser aplicadas às páginas no aplicativo. |
| Sqlcachedependency | Elemento opcional. Configura as dependências de cache do SQL para um aplicativo ASP.NET. |
O <elemento cache>
Os seguintes atributos estão disponíveis no <elemento de cache> :
| Atributo | Descrição |
|---|---|
| Disablememorycollection | Atributo booliano opcional. Obtém ou define um valor que indica se a coleção de memória de cache que ocorre quando o computador está sob pressão de memória é desabilitada. |
| disableExpiration | Atributo booliano opcional. Obtém ou define um valor que indica se a expiração do cache está desabilitada. Quando desabilitados, os itens armazenados em cache não expiram e a limpeza em segundo plano de itens de cache expirados não ocorre. |
| Privatebyteslimit | Atributo Int64 opcional. Obtém ou define um valor que indica o tamanho máximo dos bytes privados de um aplicativo antes que o cache comece a liberar itens expirados e tentar recuperar a memória. Esse limite inclui a memória usada pelo cache, bem como a sobrecarga de memória normal do aplicativo em execução. Uma configuração de zero indica que ASP.NET usará sua própria heurística para determinar quando começar a recuperar memória. |
| Percentagephysicalmemoryusedlimit | Atributo Int32 opcional. Obtém ou define um valor que indica a porcentagem máxima da memória física de um computador que pode ser consumida por um aplicativo antes que o cache comece a liberar itens expirados e tentar recuperar a memória Esse uso de memória inclui tanto a memória usada pelo cache quanto o uso normal de memória do aplicativo em execução. Uma configuração de zero indica que ASP.NET usará sua própria heurística para determinar quando começar a recuperar memória. |
| privateBytesPollTime | Atributo TimeSpan opcional. Obtém ou define um valor que indica o intervalo de tempo entre a sondagem para o uso de memória de bytes privados do aplicativo. |
O <elemento outputCache>
Os atributos a seguir estão disponíveis para o <elemento outputCache> .
| Atributo | Descrição |
|---|---|
| enableOutputCache | Atributo booliano opcional. Habilita/desabilita o cache de saída da página. Se desabilitada, nenhuma página será armazenada em cache, independentemente das configurações programáticas ou declarativas. O valor padrão é true. |
| enableFragmentCache | Atributo booliano opcional. Habilita/desabilita o cache do fragmento do aplicativo. Se estiver desabilitado, nenhuma página será armazenada em cache, independentemente da diretiva @ OutputCache ou do perfil de cache usado. Inclui um cabeçalho de controle de cache que indica que upstream servidores proxy, bem como clientes de navegador, não devem tentar armazenar em cache a saída da página. O valor padrão é false. |
| Sendcachecontrolheader | Atributo booliano opcional. Obtém ou define um valor que indica se o cabeçalho cache-control:private é enviado pelo módulo de cache de saída por padrão. O valor padrão é false. |
| Omitvarystar | Atributo booliano opcional. Habilita/desabilita o envio de um cabeçalho Http "Vary: </strong>" na resposta. Com a configuração padrão de false, um cabeçalho "*Vary: *" é enviado para páginas armazenadas em cache de saída. Quando o cabeçalho Vary é enviado, ele permite que diferentes versões sejam armazenadas em cache com base no que é especificado no cabeçalho Vary. Por exemplo, Vary:User-Agents armazenará diferentes versões de uma página com base no agente de usuário que está emitindo a solicitação. O valor padrão é **false. |
O <elemento outputCacheSettings>
O <elemento outputCacheSettings> permite a criação de perfis de cache, conforme descrito anteriormente. O único elemento filho para o <elemento outputCacheSettings> é o <elemento outputCacheProfiles> para configurar perfis de cache.
O <elemento sqlCacheDependency>
Os atributos a seguir estão disponíveis para o <elemento sqlCacheDependency> .
| Atributo | Descrição |
|---|---|
| Habilitado | Atributo booliano necessário. Indica se as alterações estão sendo sondadas ou não. |
| Polltime | Atributo Int32 opcional. Define a frequência com que o SqlCacheDependency sonda a tabela de banco de dados em busca de alterações. Esse valor corresponde ao número de milissegundos entre sondagens sucessivas. Ele não pode ser definido como menos de 500 milissegundos. O valor padrão é 1 minuto. |
Mais informações
Há algumas informações adicionais que você deve estar ciente sobre a configuração de cache.
Se o limite de bytes privados do processo de trabalho não estiver definido, o cache usará um dos seguintes limites:
- x86 2 GB: 800 MB ou 60% de RAM física, o que for menor
- x86 3 GB: 1800 MB ou 60% de RAM física, o que for menor
- x64: 1 terabyte ou 60% de RAM física, o que for menor
Se o limite de bytes privados do processo de trabalho e <o cache privateBytesLimit/> estiverem definidos, o cache usará o mínimo dos dois.
Assim como no 1.x, removemos entradas de cache e chamamos GC. Colete por dois motivos:
- Estamos muito próximos do limite de bytes privados
- A memória disponível é próxima ou inferior a 10%
Você pode desabilitar efetivamente o corte e o cache para condições de memória de baixa disponibilidade definindo <o percentual de cachePhysicalMemoryUseLimit/ como> 100.
Ao contrário de 1.x, 2.0 suspenderá o corte e coletará chamadas se o último GC. A coleta não reduziu os bytes privados nem o tamanho dos heaps gerenciados em mais de 1% do limite de memória (cache).
Lab1: Dependências de cache personalizadas
Crie um novo site.
Adicione um novo arquivo XML chamado cache.xml e salve-o na raiz do aplicativo Web.
Adicione o seguinte código ao método Page_Load no code-behind de default.aspx:
System.Web.Caching.CacheDependency dep = new System.Web.Caching.CacheDependency(Server.MapPath("cache.xml")); Response.AddCacheDependency(dep); Cache.Insert("time", DateTime.Now.ToString()); Response.Write(Cache["time"]);Adicione o seguinte à parte superior de default.aspx na exibição de origem:
<%@ OutputCache Duration="240" VaryByParam="None" %>Procure Default.aspx. O que o tempo diz?
Atualize o navegador. O que o tempo diz?
Abra cache.xml e adicione o seguinte código:
<anElement></anElement>Salve cache.xml.
Atualize seu navegador. O que o tempo diz?
Explique por que o tempo foi atualizado em vez de exibir os valores armazenados em cache anteriormente:
Laboratório 2: Usando dependências de cache Polling-Based
Este laboratório usa o projeto que você criou no módulo anterior que permite a edição de dados no banco de dados Northwind por meio de um controle GridView e DetailsView.
Abra o projeto no Visual Studio 2005.
Execute o utilitário aspnet_regsql no banco de dados Northwind para habilitar o banco de dados e a tabela Produtos. Use o seguinte comando de um Prompt de Comando do Visual Studio:
aspnet_regsql -S server -ed -d Northwind -E -et -t ProductsAdicione o seguinte ao arquivo web.config:
<caching> <sqlCacheDependency enabled = "true" pollTime = "60000" > <databases> <add name="Northwind" connectionStringName = "Northwind" pollTime = "9000000" /> </databases> </sqlCacheDependency> </caching>Adicione uma nova webform chamada showdata.aspx.
Adicione a seguinte diretiva @ outputcache à página showdata.aspx:
<%@ OutputCache SqlDependency="Northwind:Products" Duration="480" VaryByParam="None"%>Adicione o seguinte código ao Page_Load de showdata.aspx:
Response.Write(DateTime.Now.ToString() + "<br><br>");Adicione um novo controle SqlDataSource para showdata.aspx e configure-o para usar a conexão de banco de dados Northwind. Clique em Avançar.
Marque as caixas de seleção ProductName e ProductID e clique em Avançar.
Clique em Concluir.
Adicione um novo GridView à página showdata.aspx.
Escolha SqlDataSource1 na lista suspensa.
Salve e procure showdata.aspx. Anote o tempo exibido.
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de