Armazenando dados em cache com o ObjectDataSource (C#)

por Scott Mitchell

Descarregar PDF

O cache pode significar a diferença entre um aplicativo Web lento e rápido. Este tutorial é o primeiro de quatro que analisam detalhadamente o cache em ASP.NET. Aprenda os principais conceitos de cache e como aplicar o cache à Camada de Apresentação por meio do controle ObjectDataSource.

Introdução

Em ciência da computação, cache é o processo de pegar dados ou informações que são caros para obter e armazenar uma cópia deles em um local que é mais rápido de acessar. Para aplicativos controlados por dados, consultas grandes e complexas geralmente consomem a maior parte do tempo de execução do aplicativo. O desempenho de tal aplicativo, então, muitas vezes pode ser melhorado armazenando os resultados de consultas de banco de dados caras na memória do aplicativo.

ASP.NET 2.0 oferece uma variedade de opções de cache. Uma página da Web inteira ou uma marcação renderizada do Controle de Usuário pode ser armazenada em cache por meio do cache de saída. Os controles ObjectDataSource e SqlDataSource também fornecem recursos de cache, permitindo que os dados sejam armazenados em cache no nível de controle. E o cache de dados do ASP.NET fornece uma API de cache avançada que permite que os desenvolvedores de páginas armazenem objetos em cache de forma programática. Neste tutorial e nos próximos três, examinaremos o uso dos recursos de cache do ObjectDataSource, bem como o cache de dados. Também exploraremos como armazenar em cache dados de todo o aplicativo na inicialização e como manter os dados armazenados em cache atualizados por meio do uso de dependências de cache SQL. Estes tutoriais não exploram o cache de saída. Para obter uma visão detalhada do cache de saída, consulte Cache de saída no ASP.NET 2.0.

O cache pode ser aplicado em qualquer lugar da arquitetura, desde a Camada de Acesso a Dados até a Camada de Apresentação. Neste tutorial, examinaremos a aplicação de cache à camada de apresentação por meio do controle ObjectDataSource. No próximo tutorial, examinaremos os dados de cache na camada de lógica de negócios.

Conceitos de Key Caching

O cache pode melhorar muito o desempenho geral e a escalabilidade de um aplicativo, pegando dados que são caros para gerar e armazenando uma cópia dele em um local que pode ser acessado de forma mais eficiente. Como o cache contém apenas uma cópia dos dados reais subjacentes, ele pode ficar desatualizado ou obsoleto se os dados subjacentes forem alterados. Para combater isso, um desenvolvedor de página pode indicar critérios pelos quais o item de cache será removido do cache, usando:

• Critérios baseados no tempo : um item pode ser adicionado ao cache por uma duração absoluta ou deslizante. Por exemplo, um desenvolvedor de página pode indicar uma duração de, digamos, 60 segundos. Com uma duração absoluta, o item armazenado em cache é removido 60 segundos depois de ter sido adicionado ao cache, independentemente da frequência com que foi acessado. Com uma duração deslizante, o item armazenado em cache é removido 60 segundos após o último acesso.
• Critérios baseados em dependência Uma dependência pode ser associada a um item quando adicionada ao cache. Quando a dependência do item muda, ele é removido do cache. A dependência pode ser um arquivo, outro item de cache ou uma combinação dos dois. ASP.NET 2.0 também permite dependências de cache SQL, que permitem que os desenvolvedores adicionem um item ao cache e o expulsem quando os dados do banco de dados subjacente forem alterados. Examinaremos as dependências de cache SQL no próximo tutorial Usando dependências de cache SQL .

Independentemente dos critérios de remoção especificados , um item no cache pode ser removido antes que os critérios baseados em tempo ou dependência tenham sido atendidos. Se o cache tiver atingido sua capacidade, os itens existentes deverão ser removidos antes que novos possam ser adicionados. Consequentemente, ao trabalhar programaticamente com dados armazenados em cache, é vital que você sempre assuma que os dados armazenados em cache podem não estar presentes. Veremos o padrão a ser usado ao acessar dados do cache programaticamente em nosso próximo tutorial, Caching Data in the Architecture.

O cache fornece um meio econômico para obter mais desempenho de um aplicativo. Como Steven Smith articula em seu artigo ASP.NET Caching: Techniques and Best Practices:

O cache pode ser uma boa maneira de obter um desempenho bom o suficiente sem exigir muito tempo e análise. A memória é barata, portanto, se você puder obter o desempenho necessário armazenando em cache a saída por 30 segundos em vez de passar um dia ou uma semana tentando otimizar seu código ou banco de dados, faça a solução de cache (supondo que dados antigos de 30 segundos estejam ok) e siga em frente. Eventualmente, um design ruim provavelmente alcançará você, então é claro que você deve tentar projetar seus aplicativos corretamente. Mas se você só precisa obter um desempenho bom o suficiente hoje, o cache pode ser uma excelente [abordagem], ganhando tempo para refatorar seu aplicativo em uma data posterior, quando você tiver tempo para fazê-lo.

Embora o cache possa fornecer melhorias de desempenho apreciáveis, ele não é aplicável em todas as situações, como em aplicativos que usam dados em tempo real e atualizados com frequência ou em que até mesmo dados obsoletos de curta duração são inaceitáveis. Mas para a maioria dos aplicativos, o cache deve ser usado. Para obter mais informações sobre cache no ASP.NET 2.0, consulte a seção Caching for Performance dos tutoriais de início rápido do ASP.NET 2.0.

Etapa 1: Criando as páginas da Web de cache

Antes de começarmos nossa exploração dos recursos de cache do ObjectDataSource, vamos primeiro reservar um momento para criar as páginas ASP.NET em nosso projeto de site que precisaremos para este tutorial e os próximos três. Comece adicionando uma nova pasta chamada Caching. Em seguida, adicione as seguintes páginas ASP.NET a essa pasta, certificando-se de associar cada página à Site.master página mestra:

• Default.aspx
• ObjectDataSource.aspx
• FromTheArchitecture.aspx
• AtApplicationStartup.aspx
• SqlCacheDependencies.aspx

Figura 1: Adicionar as páginas de ASP.NET para os tutoriais do Caching-Related

Como nas outras pastas, Default.aspx na Caching pasta irá listar os tutoriais em sua seção. Lembre-se de que o SectionLevelTutorialListing.ascx Controle de Usuário fornece essa funcionalidade. Portanto, adicione este Controlo do Utilizador a Default.aspx arrastando-o do Gerenciador de Soluções para a vista de Design da página.

Figura 2: Figura 2: Adicionar o controle de usuário a SectionLevelTutorialListing.ascx (Default.aspx imagem em tamanho real)

Por fim, adicione essas páginas como entradas ao Web.sitemap arquivo. Especificamente, adicione a seguinte marcação após o Trabalhando com dados binários <siteMapNode>:

<siteMapNode title="Caching" url="~/Caching/Default.aspx" 
    description="Learn how to use the caching features of ASP.NET 2.0.">
    <siteMapNode url="~/Caching/ObjectDataSource.aspx" 
        title="ObjectDataSource Caching" 
        description="Explore how to cache data directly from the 
            ObjectDataSource control." />
    <siteMapNode url="~/Caching/FromTheArchitecture.aspx" 
        title="Caching in the Architecture" 
        description="See how to cache data from within the 
            architecture." />
    <siteMapNode url="~/Caching/AtApplicationStartup.aspx" 
        title="Caching Data at Application Startup" 
        description="Learn how to cache expensive or infrequently-changing 
            queries at the start of the application." />
    <siteMapNode url="~/Caching/SqlCacheDependencies.aspx" 
        title="Using SQL Cache Dependencies" 
        description="Examine how to have data automatically expire from the 
            cache when its underlying database data is modified." />
</siteMapNode>

Após a atualização Web.sitemap, reserve um momento para visualizar o site de tutoriais através de um navegador. O menu à esquerda agora inclui itens para os tutoriais de cache.

Figura 3: O mapa do site agora inclui entradas para os tutoriais de cache

Etapa 2: Exibindo uma lista de produtos em uma página da Web

Este tutorial explora como usar os recursos de cache internos do controle ObjectDataSource. Antes de olharmos para esses recursos, porém, primeiro precisamos de uma página para começar a trabalhar. Vamos criar uma página da Web que usa um GridView para listar informações do produto recuperadas por um ObjectDataSource da ProductsBLL classe.

Comece por abrir a página ObjectDataSource.aspx na pasta Caching. Arraste um GridView da Caixa de Ferramentas para o Designer, defina sua propriedade ID como Products, e, a partir de sua marca inteligente, escolha vinculá-lo a um novo controle ObjectDataSource chamado ProductsDataSource. Configure o ObjectDataSource para trabalhar com a ProductsBLL classe.

Figura 4: Configurar o ObjectDataSource para usar a classe (ProductsBLL imagem em tamanho real)

Para esta página, vamos criar um GridView editável para que possamos examinar o que acontece quando os dados armazenados em cache no ObjectDataSource são modificados por meio da interface do GridView. Deixe a lista suspensa na guia SELECT definida como padrão, GetProducts(), mas altere o item selecionado na guia UPDATE para a UpdateProduct sobrecarga que aceita productName, unitPrice, e productID como seus parâmetros de entrada.

Figura 5: Defina a lista de atualizações Drop-Down para a sobrecarga apropriada UpdateProduct (Clique para visualizar a imagem em tamanho real)

Por fim, defina as listas suspensas nas guias INSERIR e EXCLUIR como (Nenhum) e clique em Concluir. Ao concluir o assistente Configurar Fonte de Dados, o Visual Studio define a propriedade s OldValuesParameterFormatString de ObjectDataSource como original_{0}. Conforme discutido no tutorial Visão geral da inserção, atualização e exclusão de dados , essa propriedade precisa ser removida da sintaxe declarativa ou redefinida para seu valor padrão, {0}para que nosso fluxo de trabalho de atualização prossiga sem erros.

Além disso, na conclusão do assistente, o Visual Studio adiciona um campo ao GridView para cada um dos campos de dados do produto. Remova todos, exceto o ProductName, CategoryName e UnitPrice BoundFields. Em seguida, atualize as HeaderText propriedades de cada um desses BoundFields para Produto, Categoria e Preço, respetivamente. Como o ProductName campo é obrigatório, converta o BoundField em um TemplateField e adicione um RequiredFieldValidator ao EditItemTemplate. Da mesma forma, converta o UnitPrice BoundField em um TemplateField e adicione um CompareValidator para garantir que o valor inserido pelo usuário seja um valor de moeda válido maior ou igual a zero. Além dessas modificações, sinta-se livre para realizar quaisquer alterações estéticas, como alinhar o valor UnitPrice à direita ou especificar a formatação do texto UnitPrice nas suas interfaces de somente leitura e de edição.

Torne o GridView editável marcando a caixa de seleção Ativar edição no smart tag do GridView. Marque também as caixas de seleção Habilitar paginação e Habilitar classificação.

Observação

Precisa de uma revisão de como personalizar a interface de edição do GridView? Em caso afirmativo, consulte novamente o tutorial Personalizando a interface de modificação de dados .

Figura 6: Habilitar o suporte a GridView para edição, classificação e paginação (Clique para visualizar a imagem em tamanho real)

Depois de fazer essas modificações de GridView, a marcação declarativa de GridView e ObjectDataSource deve ser semelhante à seguinte:

<asp:GridView ID="Products" runat="server" AutoGenerateColumns="False" 
    DataKeyNames="ProductID" DataSourceID="ProductsDataSource" 
    AllowPaging="True" AllowSorting="True">
    <Columns>
        <asp:CommandField ShowEditButton="True" />
        <asp:TemplateField HeaderText="Product" SortExpression="ProductName">
            <EditItemTemplate>
                <asp:TextBox ID="ProductName" runat="server" 
                    Text='<%# Bind("ProductName") %>'></asp:TextBox>
                <asp:RequiredFieldValidator 
                    ID="RequiredFieldValidator1" Display="Dynamic" 
                    ControlToValidate="ProductName" SetFocusOnError="True"
                    ErrorMessage="You must provide a name for the product."
                    runat="server">*</asp:RequiredFieldValidator>
            </EditItemTemplate>
            <ItemTemplate>
                <asp:Label ID="Label2" runat="server" 
                    Text='<%# Bind("ProductName") %>'></asp:Label>
            </ItemTemplate>
        </asp:TemplateField>
        <asp:BoundField DataField="CategoryName" HeaderText="Category" 
            ReadOnly="True" SortExpression="CategoryName" />
        <asp:TemplateField HeaderText="Price" SortExpression="UnitPrice">
            <EditItemTemplate>
                $<asp:TextBox ID="UnitPrice" runat="server" Columns="8" 
                    Text='<%# Bind("UnitPrice", "{0:N2}") %>'></asp:TextBox>
                <asp:CompareValidator ID="CompareValidator1"
                    ControlToValidate="UnitPrice" Display="Dynamic" 
                    ErrorMessage="You must enter a valid currency value with no 
                        currency symbols. Also, the value must be greater than 
                        or equal to zero."
                    Operator="GreaterThanEqual" SetFocusOnError="True" 
                    Type="Currency" runat="server" 
                    ValueToCompare="0">*</asp:CompareValidator>
            </EditItemTemplate>
            <ItemStyle HorizontalAlign="Right" />
            <ItemTemplate>
                <asp:Label ID="Label1" runat="server" 
                    Text='<%# Bind("UnitPrice", "{0:c}") %>' />
            </ItemTemplate>
        </asp:TemplateField>
    </Columns>
</asp:GridView>
<asp:ObjectDataSource ID="ProductsDataSource" runat="server"
    OldValuesParameterFormatString="{0}" SelectMethod="GetProducts" 
    TypeName="ProductsBLL" UpdateMethod="UpdateProduct">
    <UpdateParameters>
        <asp:Parameter Name="productName" Type="String" />
        <asp:Parameter Name="unitPrice" Type="Decimal" />
        <asp:Parameter Name="productID" Type="Int32" />
    </UpdateParameters>
</asp:ObjectDataSource>

Como mostra a Figura 7, o GridView editável lista o nome, a categoria e o preço de cada um dos produtos no banco de dados. Reserve um momento para testar a funcionalidade da página, classificar os resultados, folheá-los e editar um registro.

Figura 7: O nome, a categoria e o preço de cada produto estão listados em um GridView classificável, pagável e editável (Clique para visualizar a imagem em tamanho real)

Etapa 3: Examinando quando o ObjectDataSource está solicitando dados

O Products GridView recupera os seus dados para exibir invocando o método Select do ProductsDataSource ObjectDataSource. Este ObjectDataSource cria uma instância da classe ProductsBLL da camada lógica de negócios e chama o método GetProducts(), que, por sua vez, chama o método ProductsTableAdapter da GetProducts() camada de acesso a dados. O método DAL se conecta ao banco de dados Northwind e emite a consulta configurada SELECT . Esses dados são então retornados para o DAL, que os empacota em um NorthwindDataTablearquivo . O objeto DataTable é retornado para a BLL, que o retorna para o ObjectDataSource, que o retorna para o GridView. Em seguida, o GridView cria um objeto GridViewRow para cada DataRow na DataTable, e cada GridViewRow é eventualmente renderizado no HTML, que é retornado ao cliente e exibido no navegador do visitante.

Essa sequência de eventos acontece toda vez que o GridView precisa se vincular aos seus dados subjacentes. Isso acontece quando a página é visitada pela primeira vez, ao se mover de uma página de dados para outra, ao classificar o GridView ou ao modificar os dados do GridView por meio de suas interfaces internas de edição ou exclusão. Se o estado de exibição de GridView estiver desativado, o GridView também será recuperado em cada postback. O GridView também pode ser explicitamente reassociado aos seus dados através da chamada do seu método DataBind().

Para apreciar completamente a frequência com que os dados são recuperados do banco de dados, deixe s exibir uma mensagem indicando quando os dados estão sendo recuperados. Adicione um controle Web Label acima do GridView chamado ODSEvents. Limpe sua Text propriedade e defina sua EnableViewState propriedade como false. Abaixo do Label, adicione um controle Web Button e defina sua Text propriedade como Postback .

Figura 8: Adicionar um rótulo e um botão à página acima do GridView (Clique para visualizar a imagem em tamanho real)

Durante o fluxo de trabalho de acesso a dados, o evento s Selecting de ObjectDataSource é acionado antes que o objeto subjacente seja criado e seu método configurado invocado. Crie um manipulador de eventos para esse evento e adicione o seguinte código:

protected void ProductsDataSource_Selecting(object sender, 
    ObjectDataSourceSelectingEventArgs e)
{
    ODSEvents.Text = "-- Selecting event fired";
}

Cada vez que o ObjectDataSource faz uma solicitação à arquitetura de dados, o Label exibirá o texto Selecionando evento disparado .

Visite esta página num browser. Quando a página é visitada pela primeira vez, o texto Evento de seleção disparado é mostrado. Clique no botão Postback e observe que o texto desaparece (supondo que a propriedade GridView s EnableViewState esteja definida como true, o padrão). Isso ocorre porque, ao fazer o postback, o GridView é reconstruído a partir do seu estado de visualização e, portanto, não recorre ao ObjectDataSource para obter os seus dados. Classificar, paginar ou editar os dados, no entanto, faz com que o GridView se reassocie à sua fonte de dados e, portanto, o texto disparado do evento Selecting reaparece.

Figura 9: Sempre que o GridView é reassociado à sua fonte de dados, é exibido quando o evento de seleção é disparado (Clique para visualizar a imagem em tamanho real)

Figura 10: Clicar no botão Postback faz com que o GridView seja reconstruído a partir de seu estado de exibição (Clique para visualizar a imagem em tamanho real)

Pode parecer um desperdício recuperar os dados do banco de dados cada vez que os dados são paginados ou classificados. Afinal, como estamos usando a paginação padrão, o ObjectDataSource recuperou todos os registros ao exibir a primeira página. Mesmo que o GridView não forneça suporte a classificação e paginação, os dados devem ser recuperados do banco de dados sempre que a página for visitada pela primeira vez por qualquer usuário (e em cada postback, se o estado de exibição estiver desativado). Mas se o GridView estiver mostrando os mesmos dados para todos os usuários, essas solicitações de banco de dados extras serão supérfluas. Por que não armazenar em cache os resultados retornados do GetProducts() método e vincular o GridView a esses resultados armazenados em cache?

Etapa 4: Armazenando em cache os dados usando o ObjectDataSource

Simplesmente definindo algumas propriedades, o ObjectDataSource pode ser configurado para armazenar automaticamente em cache seus dados recuperados no cache de dados ASP.NET. A lista a seguir resume as propriedades relacionadas ao cache do ObjectDataSource:

• EnableCaching deve ser definido para true para habilitar o cache. A predefinição é false.
• CacheDuration a quantidade de tempo, em segundos, que os dados são armazenados em cache. O padrão é 0. O ObjectDataSource só armazenará dados em cache se EnableCaching for true e CacheDuration tiver um valor maior que zero.
• CacheExpirationPolicy pode ser definido como Absolute ou Sliding. Se Absolute, o ObjectDataSource armazena em cache seus dados recuperados por CacheDuration segundos, se Sliding, os dados expiram somente depois de não terem sido acessados por CacheDuration segundos. A predefinição é Absolute.
• CacheKeyDependency use essa propriedade para associar as entradas de cache de ObjectDataSource a uma dependência de cache existente. As entradas de dados do ObjectDataSource podem ser removidas prematuramente do cache ao expirar seu associado CacheKeyDependency. Essa propriedade é mais comumente usada para associar uma dependência de cache SQL ao cache de ObjectDataSource, um tópico que exploraremos no futuro usando o tutorial Dependências de cache SQL .

Deixe s configurar o ProductsDataSource ObjectDataSource para armazenar em cache seus dados por 30 segundos em uma escala absoluta. Defina a propriedade EnableCaching de ObjectDataSource para true e a sua propriedade CacheDuration para 30. Deixe a CacheExpirationPolicy propriedade definida como padrão, Absolute.

Figura 11: Configurar o ObjectDataSource para armazenar em cache seus dados por 30 segundos (Clique para visualizar a imagem em tamanho normal)

Guarde as suas alterações e volte a visitar esta página num browser. O texto disparado do evento Selecionando aparecerá quando você visitar a página pela primeira vez, pois inicialmente os dados não estão no cache. Mas os postbacks subsequentes acionados clicando no botão Postback, classificando, paginando ou clicando nos botões Editar ou Cancelar não reexibem o texto disparado do evento Selecionando. Isso ocorre porque o Selecting evento só é acionado quando o ObjectDataSource obtém seus dados de seu objeto subjacente, o Selecting evento não é acionado se os dados forem extraídos do cache de dados.

Após 30 segundos, os dados serão removidos do cache. Os dados também serão removidos do cache se os métodos ObjectDataSource s Insert, Update, ou Delete forem invocados. Por conseguinte, após 30 segundos ou o botão Atualizar ter sido clicado, realizar a classificação, paginação ou clicar nos botões Editar ou Cancelar fará com que o ObjectDataSource obtenha os seus dados do seu objeto subjacente, exibindo o texto do evento Selecionando quando o evento Selecting for acionado. Esses resultados retornados são colocados de volta no cache de dados.

Observação

Se vir o evento de Seleção acionado frequentemente, mesmo quando espera que o ObjectDataSource utilize dados em cache, isso pode ser devido a limitações de memória. Se não houver memória livre suficiente, os dados adicionados ao cache pelo ObjectDataSource podem ter sido eliminados. Se o ObjectDataSource não parecer estar armazenando corretamente os dados em cache ou apenas armazenar os dados em cache esporadicamente, feche alguns aplicativos para liberar memória e tente novamente.

A Figura 12 ilustra o fluxo de trabalho de cache de ObjectDataSource. Quando o texto acionado pelo evento Selecionando aparece na tela, é porque os dados não estavam no cache e tiveram que ser recuperados do objeto subjacente. Quando esse texto está faltando, no entanto, é porque os dados estavam disponíveis no cache. Quando os dados são retornados do cache, não há nenhuma chamada para o objeto subjacente e, portanto, nenhuma consulta de banco de dados é executada.

Figura 12: O ObjectDataSource armazena e recupera seus dados do cache de dados

Cada aplicativo ASP.NET tem sua própria instância de cache de dados que é compartilhada entre todas as páginas e visitantes. Isso significa que os dados armazenados no cache de dados pelo ObjectDataSource também são compartilhados entre todos os usuários que visitam a página. Para verificar isso, abra a ObjectDataSource.aspx página em um navegador. Ao visitar a página pela primeira vez, o texto acionado pelo evento Selecionando aparecerá (supondo que os dados adicionados ao cache por testes anteriores já tenham sido removidos). Abra uma segunda instância do navegador e copie e cole o URL da primeira instância do navegador para a segunda. Na segunda instância do navegador, o texto acionado pelo evento Selecionando não é mostrado porque está usando os mesmos dados armazenados em cache que o primeiro.

Ao inserir seus dados recuperados no cache, o ObjectDataSource usa um valor de chave de cache que inclui: os valores das propriedades CacheDuration e CacheExpirationPolicy; o tipo de objeto de negócios subjacente que está sendo usado pelo ObjectDataSource, que é especificado através da TypeName propriedade (ProductsBLL, neste exemplo); o valor da propriedade SelectMethod e o nome e valores dos parâmetros na coleção SelectParameters; e os valores das suas propriedades StartRowIndex e MaximumRows, que são usados ao implementar a paginação personalizada.

Criar o valor da chave de cache como uma combinação dessas propriedades garante uma entrada de cache exclusiva à medida que esses valores mudam. Por exemplo, em tutoriais anteriores, analisamos o uso da ProductsBLL classe s GetProductsByCategoryID(categoryID), que retorna todos os produtos para uma categoria especificada. Um utilizador pode chegar à página e ver bebidas, que tem um CategoryID de 1. Se o ObjectDataSource armazenasse em cache seus resultados sem levar em conta os SelectParameters valores, quando outro usuário chegasse à página para visualizar condimentos enquanto os produtos de bebidas estavam no cache, eles veriam os produtos de bebidas armazenados em cache em vez de condimentos. Ao variar a chave de cache dessas propriedades, que incluem os valores de SelectParameters, o ObjectDataSource mantém uma entrada de cache separada para bebidas e condimentos.

Preocupações com dados obsoletos

O ObjectDataSource remove automaticamente seus itens do cache quando qualquer um de seus Insertmétodos , Update, ou Delete é invocado. Isso ajuda a proteger contra dados obsoletos limpando as entradas de cache quando os dados são modificados pela página. No entanto, é possível que um ObjectDataSource usando cache ainda exiba dados obsoletos. No caso mais simples, pode ser devido à alteração dos dados diretamente dentro do banco de dados. Talvez um administrador de banco de dados tenha acabado de executar um script que modifica alguns dos registros no banco de dados.

Esse cenário também poderia se desenrolar de forma mais sutil. Enquanto o ObjectDataSource remove seus itens do cache quando um de seus métodos de modificação de dados é chamado, os itens em cache removidos são para a combinação particular de valores de propriedade de ObjectDataSource (CacheDuration, TypeName, SelectMethode assim por diante). Se você tiver dois ObjectDataSources que usam diferentes SelectMethods ou SelectParameters, mas ainda podem atualizar os mesmos dados, então um ObjectDataSource pode atualizar uma linha e invalidar suas próprias entradas de cache, mas a linha correspondente para o segundo ObjectDataSource ainda será servida a partir do cache. Eu encorajo você a criar páginas para exibir essa funcionalidade. Crie uma página que exiba um GridView editável que extrai os seus dados de um ObjectDataSource que utiliza cache e está configurado para obter dados do método ProductsBLL da classe GetProducts(). Adicione outro editável GridView e ObjectDataSource a esta página (ou outra), mas para este segundo ObjectDataSource faça com que ele use o GetProductsByCategoryID(categoryID) método. Como as duas propriedades ObjectDataSources SelectMethod diferem, cada uma delas terá seus próprios valores armazenados em cache. Se você editar um produto em uma grade, da próxima vez que vincular os dados de volta à outra grade (paginando, classificando e assim por diante), ele ainda servirá os dados antigos armazenados em cache e não refletirá a alteração feita na outra grade.

Em resumo, use expirações baseadas no tempo apenas se estiver disposto a ter o potencial de dados obsoletos e use expirações mais curtas para cenários em que a atualização dos dados é importante. Se dados obsoletos não forem aceitáveis, renuncie ao cache ou use dependências de cache SQL (supondo que sejam dados de banco de dados que você está armazenando em cache). Exploraremos as dependências do cache SQL em um tutorial futuro.

Resumo

Neste tutorial, examinamos os recursos de cache internos do ObjectDataSource. Simplesmente definindo algumas propriedades, podemos instruir o ObjectDataSource a armazenar em cache os resultados retornados do SelectMethod especificado no cache de dados ASP.NET. As CacheDuration propriedades e CacheExpirationPolicy indicam a duração em que o item é armazenado em cache e se é uma expiração absoluta ou deslizante. A CacheKeyDependency propriedade associa todas as entradas de cache de ObjectDataSource a uma dependência de cache existente. Isso pode ser usado para remover as entradas de ObjectDataSource do cache antes que a expiração baseada em tempo seja atingida, e normalmente é usado com dependências de cache SQL.

Como o ObjectDataSource simplesmente armazena em cache seus valores no cache de dados, poderíamos replicar a funcionalidade interna do ObjectDataSource programaticamente. Não faz sentido fazer isso na camada de apresentação, já que o ObjectDataSource oferece essa funcionalidade pronta, mas podemos implementar recursos de cache em uma camada separada da arquitetura. Para fazer isso, precisaremos repetir a mesma lógica usada pelo ObjectDataSource. Exploraremos como trabalhar programaticamente com o cache de dados de dentro da arquitetura em nosso próximo tutorial.

Feliz Programação!

Leitura adicional

Para obter mais informações sobre os tópicos discutidos neste tutorial, consulte os seguintes recursos:

• ASP.NET Caching: técnicas e práticas recomendadas
• Guia de arquitetura de cache para aplicativos do .NET Framework

Sobre o Autor

Scott Mitchell, autor de sete livros sobre ASP/ASP.NET e fundador da 4GuysFromRolla.com, trabalha com tecnologias Web da Microsoft desde 1998. Scott trabalha como consultor, formador e escritor independente. Seu último livro é Sams Teach Yourself ASP.NET 2.0 in 24 Hours. Ele pode ser contatado em mitchell@4GuysFromRolla.com.

Um agradecimento especial a

Esta série de tutoriais foi revisada por muitos revisores úteis. A revisor principal deste tutorial foi Teresa Murphy. Interessado em rever meus próximos artigos do MSDN? Se for o caso, envie-me uma mensagem para mitchell@4GuysFromRolla.com.

Seguinte