Almacenar datos en caché con ObjectDataSource (C#)

2023-07-13

El almacenamiento en caché puede significar la diferencia entre una aplicación web lenta y rápida. Este tutorial es el primero de cuatro que examinan el almacenamiento en caché en ASP.NET. Obtenga información sobre los conceptos clave del almacenamiento en caché y cómo aplicar el almacenamiento en caché a la capa de presentación a través del control ObjectDataSource.

Introducción

En informática, el almacenamiento en caché es el proceso de tomar datos o información que resulta costoso obtener y almacenar una copia de ella en una ubicación a la que se accede más rápido. En el caso de las aplicaciones controladas por datos, las consultas grandes y complejas suelen consumir la mayoría del tiempo de ejecución de la aplicación. Este rendimiento de una aplicación, a menudo, se puede mejorar almacenando los resultados de las consultas de base de datos costosas en la memoria de la aplicación.

ASP.NET 2.0 ofrece una variedad de opciones de almacenamiento en caché. Se puede almacenar en caché una página web completa o un marcado representado de Control de usuario mediante el almacenamiento en caché de salida. Los controles ObjectDataSource y SqlDataSource también proporcionan funcionalidades de almacenamiento en caché, lo que permite almacenar los datos en caché en el nivel de control. Además, ASP.NET caché de datos proporciona una API de almacenamiento en caché enriquecida que permite a los desarrolladores de páginas almacenar en caché objetos mediante programación. En este tutorial y los tres siguientes examinaremos el uso de las características de almacenamiento en caché de ObjectDataSource, así como la caché de datos. También exploraremos cómo almacenar en caché los datos en todo el inicio de la aplicación y cómo mantener actualizados los datos almacenados en caché mediante el uso de dependencias de caché de SQL. Estos tutoriales no exploran el almacenamiento en caché de salida. Para ver un análisis detallado del almacenamiento en caché de salida, consulte Almacenamiento en caché de salida en ASP.NET 2.0.

El almacenamiento en caché se puede aplicar en cualquier lugar de la arquitectura, desde la capa de acceso a datos hasta la capa de presentación. En este tutorial veremos cómo aplicar el almacenamiento en caché a la capa de presentación a través del control ObjectDataSource. En el siguiente tutorial examinaremos los datos de almacenamiento en caché en la capa de lógica de negocios.

Conceptos clave sobre almacenamiento en caché

El almacenamiento en caché puede mejorar considerablemente el rendimiento general y la escalabilidad de una aplicación tomando datos que son costosos de generar y almacenar una copia de ella en una ubicación a la que se puede acceder de forma más eficaz. Dado que la memoria caché solo contiene una copia de los datos reales subyacentes, puede quedar obsoleto o obsoleto, si cambian los datos subyacentes. Para combatir esto, un desarrollador de páginas puede indicar criterios por los que el elemento de caché se expulsará de la memoria caché mediante:

Los criterios basados en el tiempo permiten que un elemento se agregue a la memoria caché por una duración absoluta o deslizante. Por ejemplo, un desarrollador de páginas puede indicar una duración de, por ejemplo, 60 segundos. Con una duración absoluta, el elemento almacenado en caché se expulsa 60 segundos después de agregarlo a la memoria caché, independientemente de la frecuencia con la que se obtuvo acceso. Con una duración deslizante, el elemento almacenado en caché se expulsa 60 segundos después del último acceso.
Los criterios basados en dependencias se pueden asociar a un elemento cuando se agregan a la memoria caché. Cuando cambia la dependencia del elemento, se expulsa de la memoria caché. La dependencia puede ser un archivo, otro elemento de caché o una combinación de los dos. ASP.NET 2.0 también permite las dependencias de caché de SQL, que permiten a los desarrolladores agregar un elemento a la caché y expulsarlo cuando cambian los datos en la base de datos subyacente. Examinaremos las dependencias de caché de SQL en el próximo tutorial Uso de dependencias de caché de SQL .

Independientemente de los criterios de expulsión especificados, un elemento de la memoria caché puede ser recuperado antes de que se cumplan los criterios basados en el tiempo o en dependencias. Si la memoria caché ha alcanzado su capacidad, se deben quitar los elementos existentes antes de que se puedan agregar nuevos. Por lo tanto, cuando se trabaja mediante programación con datos almacenados en caché, es fundamental que siempre suponga que los datos almacenados en caché no pueden estar presentes. Veremos el patrón que se va a usar al acceder a los datos desde la memoria caché mediante programación en el siguiente tutorial, Almacenamiento en caché de datos en la arquitectura.

El almacenamiento en caché proporciona un medio económico para apretar más rendimiento desde una aplicación. Como Steven Smith articula en su artículo ASP.NET Almacenamiento en caché: Técnicas y procedimientos recomendados:

El almacenamiento en caché puede ser una buena manera de obtener un buen rendimiento sin necesidad de mucho tiempo y análisis. La memoria es barata, por lo que si puede obtener el rendimiento que necesita almacenando en caché la salida durante 30 segundos en lugar de pasar un día o una semana intentando optimizar el código o la base de datos, realice la solución de almacenamiento en caché (suponiendo que los datos antiguos de 30 segundos sean correctos) y continúe. Finalmente, el diseño deficiente probablemente se pondrá al día, por lo que, por supuesto, debe intentar diseñar las aplicaciones correctamente. Pero si solo necesita obtener un rendimiento suficiente hoy en día, el almacenamiento en caché puede ser un excelente [enfoque], comprándole tiempo para refactorizar su aplicación en una fecha posterior cuando tenga tiempo para hacerlo.

Aunque el almacenamiento en caché puede proporcionar mejoras de rendimiento apreciables, no es aplicable en todas las situaciones, como con aplicaciones que usan datos en tiempo real, actualizando con frecuencia o donde incluso los datos obsoletos de corta duración son inaceptables. Pero para la mayoría de las aplicaciones, se debe usar el almacenamiento en caché. Para obtener más información sobre el almacenamiento en caché en ASP.NET 2.0, consulte la sección Almacenamiento en caché para rendimiento de los tutoriales de inicio rápido de ASP.NET 2.0.

Paso 1: Crear las páginas web de almacenamiento en caché

Antes de comenzar nuestra exploración de las características de almacenamiento en caché de ObjectDataSource, primero dediquemos un momento a crear las páginas de ASP.NET en nuestro proyecto de sitio web que necesitaremos para este tutorial y los tres siguientes. Empiece agregando una nueva carpeta denominada Caching. Después, agregue las siguientes páginas ASP.NET a esa carpeta, asegurándose de asociar cada página a la página maestra Site.master:

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

Agregar las páginas de ASP.NET para los tutoriales de Caching-Related

Figura 1: Agregar las páginas de ASP.NET para los tutoriales de Caching-Related

Igual que en las otras carpetas, Default.aspx en la carpeta Caching enumerará los tutoriales en su sección. Recuerde que el control de usuario SectionLevelTutorialListing.ascx proporciona esta funcionalidad. Por lo tanto, agregue este control de usuario a Default.aspx arrastrándolo desde el Explorador de soluciones a la vista Diseño de la página.

Figura 2: Agregar el control de usuario a SectionLevelTutorialListing.ascx (Default.aspx)

Por último, agregue estas páginas como entradas al Web.sitemap archivo. En concreto, agregue el marcado siguiente después de Trabajar con datos binarios <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>

Después de actualizar Web.sitemap, dedique un momento a ver el sitio web de tutoriales a través de un explorador. El menú de la izquierda ahora incluye elementos para los tutoriales de almacenamiento en caché.

El mapa del sitio ahora incluye entradas para los tutoriales de almacenamiento en caché

Figura 3: El mapa del sitio ahora incluye entradas para los tutoriales de almacenamiento en caché

Paso 2: Mostrar una lista de productos en una página web

En este tutorial se explora cómo usar las características integradas de almacenamiento en caché del control ObjectDataSource. Sin embargo, para poder examinar estas características, primero necesitamos una página para trabajar. Vamos a crear una página web que use gridView para enumerar la información del producto recuperada por un ObjectDataSource de la ProductsBLL clase .

Para empezar, abra la página ObjectDataSource.aspx en la carpeta Caching. Arrastre un GridView desde el Cuadro de herramientas en el Diseñador, establezca su propiedad ID a Products y, desde su etiqueta inteligente, elija la opción de enlazarlo a un nuevo control ObjectDataSource denominado ProductsDataSource. Configure ObjectDataSource para que funcione con la ProductsBLL clase .

Figura 4: Configurar objectDataSource para usar la clase (ProductsBLL imagen de tamaño completo)

En esta página, vamos a crear una GridView editable para que podamos examinar lo que sucede cuando los datos almacenados en caché en objectDataSource se modifican a través de la interfaz de GridView. Deje la lista desplegable en la pestaña SELECT establecida en su valor predeterminado, GetProducts(), pero cambie el elemento seleccionado en la pestaña UPDATE a la sobrecarga de UpdateProduct que acepta productName, unitPrice, y productID como sus parámetros de entrada.

Figura 5: Establecer la lista de la pestaña UPDATE Drop-Down en la sobrecarga adecuada UpdateProduct (haga clic para ver la imagen en tamaño completo)

Por último, establezca las listas desplegables en las pestañas INSERT y DELETE en (Ninguno) y haga clic en Finalizar. Al completar el asistente Configuración de Orígenes de Datos, Visual Studio establece la propiedad OldValuesParameterFormatString de ObjectDataSource en original_{0}. Como se describe en el tutorial Introducción a la inserción, actualización y eliminación de datos , esta propiedad debe quitarse de la sintaxis declarativa o volver a establecerse en su valor predeterminado, {0}, para que el flujo de trabajo de actualización continúe sin errores.

Además, al finalizar el asistente, Visual Studio agrega un campo a GridView para cada uno de los campos de datos del producto. Quite todos los campos excepto los BoundFields ProductName, CategoryName y UnitPrice. A continuación, actualice las HeaderText propiedades de cada uno de estos BoundFields a Product, Category y Price, respectivamente. Dado que el ProductName campo es obligatorio, convierta BoundField en templateField y agregue requiredFieldValidator a EditItemTemplate. Del mismo modo, convierta BoundField UnitPrice en templateField y agregue un CompareValidator para asegurarse de que el valor especificado por el usuario es un valor de moneda válido mayor o igual que cero. Además de estas modificaciones, siéntase libre de hacer cualquier cambio estético, como alinear a la derecha el valor UnitPrice, o especificar el formato del texto UnitPrice en sus interfaces de solo lectura y edición.

Haga que GridView se pueda editar activando la casilla Habilitar edición en la etiqueta inteligente gridView. Active también las casillas Habilitar paginación y Habilitar ordenación.

Nota:

¿Necesita una revisión de cómo personalizar la interfaz de edición de GridView? Si es así, consulte el tutorial Personalización de la interfaz de modificación de datos .

Figura 6: Habilitar la compatibilidad con GridView para editar, ordenar y paginar (haga clic para ver la imagen de tamaño completo)

Después de realizar estas modificaciones de GridView, el marcado declarativo de GridView y ObjectDataSource debería ser parecido al siguiente:

<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 se muestra en la figura 7, gridView editable enumera el nombre, la categoría y el precio de cada uno de los productos de la base de datos. Dedique un momento a probar la funcionalidad de la página para ordenar los resultados, paginarlos y editar un registro.

Figura 7: El nombre, categoría y precio de cada producto aparece en un control GridView ordenable, paginable y editable (Haga clic para ver la imagen de tamaño completo)

Paso 3: Examinar cuándo objectDataSource solicita datos

Products GridView recupera sus datos que se van a mostrar invocando el Select método de ProductsDataSource ObjectDataSource. Este ObjectDataSource crea una instancia de la clase de la capa lógica de negocios ProductsBLL y llama a su método GetProducts(), que a su vez llama al método ProductsTableAdapterGetProducts() de la capa de acceso a datos. El método DAL se conecta a la base de datos Northwind y emite la consulta configurada SELECT . A continuación, estos datos se devuelven a la DAL, que la empaqueta en un NorthwindDataTable. El objeto DataTable se devuelve al BLL, que lo devuelve a ObjectDataSource, que lo devuelve a GridView. A continuación, GridView crea un GridViewRow objeto para cada DataRow uno de dataTable y cada GridViewRow uno se representa en el HTML que se devuelve al cliente y se muestra en el explorador del visitante.

Esta secuencia de eventos se produce cada vez que GridView necesita enlazarse a sus datos subyacentes. Esto sucede cuando la página se visita por primera vez, cuando se pasa de una página de datos a otra, al ordenar el GridView, o al modificar los datos del GridView a través de sus interfaces integradas de edición o eliminación. Si el estado de vista de GridView está deshabilitado, GridView también se volverá a enlazar en cada postback. El GridView también se puede volver a enlazar explícitamente a sus datos llamando a su método DataBind().

Para apreciar completamente la frecuencia con la que se recuperan los datos de la base de datos, vamos a mostrar un mensaje que indica cuándo se vuelven a recuperar los datos. Agregue un control Web Label encima de GridView denominado ODSEvents. Borre la propiedad Text y establezca la propiedad EnableViewState en false. Debajo de la etiqueta, agregue un control Web Button y configure su propiedad Text como Postback.

Figura 8: Agregar una etiqueta y un botón a la página encima de gridView (haga clic para ver la imagen de tamaño completo)

Durante el flujo de trabajo de acceso a datos, el evento de ObjectDataSource se activa Selecting antes de que se cree el objeto subyacente y se invoque su método configurado. Cree un controlador de eventos para este evento y agregue el código siguiente:

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

Cada vez que ObjectDataSource realiza una solicitud a la arquitectura para obtener datos, la Etiqueta mostrará el texto El evento de selección se activó.

Visite esta página en un explorador. Al visitar la página por primera vez, se muestra el texto Evento de selección activado. Haga clic en el botón Postback y observe que el texto desaparece (suponiendo que la propiedad GridView s EnableViewState está establecida trueen , el valor predeterminado). Esto se debe a que, durante un postback, el GridView se reconstruye a partir de su estado de vista y, por lo tanto, no recurre al ObjectDataSource para obtener sus datos. La ordenación, paginación o edición de los datos hace que GridView se vuelva a enlazar a su origen de datos y, por lo tanto, el texto del evento Selecting vuelva a aparecer.

Figura 9: Cada vez que el GridView se vuelve a enlazar a su origen de datos, se activa el evento `Selecting` (Haga clic para ver la imagen de tamaño completo).

Figura 10: Hacer clic en el botón Postback hace que gridView se reconstruya a partir de su estado de vista (haga clic para ver la imagen de tamaño completo)

Puede parecer inútil recuperar los datos de la base de datos cada vez que los datos se paginan o se ordenan. Después de todo, ya que estamos usando la paginación predeterminada, ObjectDataSource ha recuperado todos los registros al mostrar la primera página. Incluso si GridView no proporciona compatibilidad con la ordenación y paginación, los datos deben recuperarse de la base de datos cada vez que cualquier usuario visite la página (y en cada postback, si el estado de vista está deshabilitado). Pero si GridView muestra los mismos datos para todos los usuarios, estas solicitudes de base de datos adicionales son superfluas. ¿Por qué no almacenar en caché los resultados devueltos desde el GetProducts() método y enlazar GridView a esos resultados almacenados en caché?

Paso 4: Almacenar en caché los datos mediante objectDataSource

Simplemente estableciendo algunas propiedades, ObjectDataSource se puede configurar para almacenar automáticamente en caché sus datos recuperados en la memoria caché de datos ASP.NET. En la lista siguiente se resumen las propiedades relacionadas con la memoria caché de ObjectDataSource:

EnableCaching debe establecerse en true para habilitar el almacenamiento en caché. El valor predeterminado es false.
CacheDuration la cantidad de tiempo, en segundos, que los datos se almacenan en caché. El valor predeterminado es 0. ObjectDataSource solo almacenará en caché los datos si EnableCaching es true y CacheDuration se establece en un valor mayor que cero.
CacheExpirationPolicy se puede establecer en Absolute o Sliding. Si Absolute, ObjectDataSource almacena en caché sus datos recuperados durante CacheDuration segundos; si Sliding, los datos expiran solo después de que no se haya accedido durante CacheDuration segundos. El valor predeterminado es Absolute.
CacheKeyDependency usa esta propiedad para asociar las entradas de caché de ObjectDataSource a una dependencia de caché existente. Las entradas de datos de ObjectDataSource se pueden expulsar prematuramente de la memoria caché al expirar su objeto asociado CacheKeyDependency. Esta propiedad se usa normalmente para asociar una dependencia de caché de SQL con la memoria caché de ObjectDataSource, un tema que exploraremos en el futuro tutorial Uso de dependencias de caché de SQL .

Vamos a configurar ProductsDataSource ObjectDataSource para almacenar en caché sus datos durante 30 segundos en una escala absoluta. Establezca la propiedad EnableCaching de ObjectDataSource en true y la propiedad CacheDuration en 30. Deje la CacheExpirationPolicy propiedad establecida en su valor predeterminado, Absolute.

Figura 11: Configurar objectDataSource para almacenar en caché sus datos durante 30 segundos (haga clic para ver la imagen de tamaño completo)

Guarde los cambios y vuelva a visitar esta página en un explorador. El texto activado del evento Selecting aparecerá cuando visite por primera vez la página, ya que inicialmente los datos no están en la memoria caché. Pero los postbacks posteriores desencadenados al hacer clic en el botón Postback, ordenar, paginar o hacer clic en los botones Editar o Cancelar no vuelven a mostrar el texto generado por el evento Selecting. Esto se debe a que el Selecting evento solo se desencadena cuando ObjectDataSource obtiene sus datos de su objeto subyacente; el Selecting evento no se desencadena si los datos se extraen de la caché de datos.

Después de 30 segundos, los datos se expulsarán de la memoria caché. Los datos también se expulsarán de la memoria caché si se invocan los métodos ObjectDataSource s Insert, Updateo Delete . Por lo tanto, después de que hayan pasado 30 segundos o se haya hecho clic en el botón Actualizar, ordenar, paginar o hacer clic en los botones Editar o Cancelar hará que ObjectDataSource obtenga sus datos de su objeto subyacente, mostrando el texto del evento Selecting activado cuando se dispara el evento Selecting. Estos resultados devueltos se vuelven a colocar en la caché de datos.

Nota:

Si ve el texto desencadenado por el evento Selecting con frecuencia, incluso cuando espera que ObjectDataSource trabaje con datos almacenados en caché, puede deberse a restricciones de memoria. Si no hay suficiente memoria libre, es posible que los datos agregados a la memoria caché por ObjectDataSource hayan sido eliminados. Si objectDataSource no parece estar almacenando en caché correctamente los datos o solo almacena en caché los datos esporádicamente, cierre algunas aplicaciones para liberar memoria e inténtelo de nuevo.

En la figura 12 se muestra el flujo de trabajo de almacenamiento en caché de ObjectDataSource. Cuando el texto activado del evento Selecting aparece en la pantalla, se debe a que los datos no se encontraban en la memoria caché y tenían que recuperarse del objeto subyacente. Sin embargo, cuando falta este texto, se debe a que los datos están disponibles en la memoria caché. Cuando se devuelven los datos de la memoria caché no hay ninguna llamada al objeto subyacente y, por lo tanto, no se ejecuta ninguna consulta de base de datos.

ObjectDataSource almacena y recupera sus datos de la caché de datos.

Figura 12: El objetoDataSource almacena y recupera sus datos de la caché de datos

Cada aplicación ASP.NET tiene su propia instancia de caché de datos que se comparte en todas las páginas y visitantes. Esto significa que los datos almacenados en la caché de datos por ObjectDataSource también se comparten entre todos los usuarios que visitan la página. Para comprobarlo, abra la ObjectDataSource.aspx página en un explorador. Cuando visite por primera vez la página, aparecerá el texto del evento Selecting que se activó (suponiendo que los datos agregados a la memoria caché por las pruebas anteriores ya se hayan expulsado). Abra una segunda instancia del explorador y copie y pegue la dirección URL de la primera instancia del explorador en la segunda. En la segunda instancia del explorador, no se muestra el texto desencadenado del evento Selecting porque usa los mismos datos almacenados en caché que el primero.

Al insertar sus datos recuperados en la memoria caché, ObjectDataSource usa un valor de clave de caché que incluye: los valores de propiedad CacheDuration y CacheExpirationPolicy ; el tipo del objeto de negocio subyacente utilizado por objectDataSource, que se especifica a través de la TypeName propiedad (ProductsBLL, en este ejemplo); el valor de la SelectMethod propiedad y el nombre y los valores de los parámetros de la SelectParameters colección; y los valores de sus StartRowIndex propiedades y MaximumRows , que se usan al implementar la paginación personalizada.

La creación del valor de clave de caché como combinación de estas propiedades garantiza una entrada de caché única a medida que cambian estos valores. Por ejemplo, en los tutoriales anteriores hemos examinado el uso de la ProductsBLL clase s GetProductsByCategoryID(categoryID), que devuelve todos los productos de una categoría especificada. Un usuario puede venir a la página y ver bebidas, que tiene un CategoryID de 1. Si ObjectDataSource almacena en memoria caché sus resultados sin tener en cuenta los SelectParameters valores, cuando otro usuario llega a la página para ver los condimentos mientras los productos de bebidas estaban en la memoria caché, verían los productos de bebidas almacenados en vez de los condimentos. Al variar la clave de caché por estas propiedades, que incluyen los valores de SelectParameters, ObjectDataSource mantiene una entrada de caché independiente para bebidas y especias.

Problemas de datos obsoletos

ObjectDataSource expulsa automáticamente sus elementos de la memoria caché cuando se invoca a cualquiera de sus Insertmétodos , Updateo Delete . Esto ayuda a protegerse contra los datos obsoletos borrando las entradas de caché cuando los datos se modifican a través de la página. Sin embargo, es posible que un ObjectDataSource que use el almacenamiento en caché siga mostrando datos obsoletos. En el caso más sencillo, puede deberse a que los datos cambian directamente dentro de la base de datos. Quizá un administrador de bases de datos acaba de ejecutar un script que modifique algunos de los registros de la base de datos.

Este escenario también podría desarrollarse de una manera más sutil. Aunque ObjectDataSource expulsa sus elementos de la memoria caché cuando se llama a uno de sus métodos de modificación de datos, los elementos almacenados en caché que se eliminan son para la combinación específica de valores de propiedad de ObjectDataSource (CacheDuration, TypeName, SelectMethod, etc.). Si tiene dos ObjectDataSources que usan diferentes SelectMethods o SelectParameters, pero aún pueden actualizar los mismos datos, un ObjectDataSource puede actualizar una fila e invalidar sus propias entradas de caché, pero la fila correspondiente para el segundo ObjectDataSource seguirá siendo atendida desde la memoria caché. Te animamos a crear páginas para mostrar esta funcionalidad. Cree una página que muestre un GridView editable que extraiga sus datos de un ObjectDataSource que use almacenamiento en caché y esté configurado para obtener datos del método ProductsBLL de la clase GetProducts(). Agregue otro GridView y ObjectDataSource editable a esta página (u otra página), pero para este segundo ObjectDataSource, use el método GetProductsByCategoryID(categoryID). Dado que las dos propiedades ObjectDataSources difieren, cada una tendrá sus propios valores almacenados SelectMethod en caché. Si edita un producto en una cuadrícula, la próxima vez que vuelva a enlazar los datos a la otra cuadrícula (paginando, ordenando, etc.), seguirá sirviendo los datos antiguos almacenados en caché y no reflejará el cambio realizado desde la otra cuadrícula.

En resumen, use solo las expiraciones basadas en el tiempo si está dispuesto a tener el potencial de datos obsoletos y use expiraciones más cortas para escenarios en los que es importante la actualización de los datos. Si los datos obsoletos no son aceptables, prescinda del almacenamiento en caché o use dependencias de caché de SQL (suponiendo que los datos que está almacenando en caché son de la base de datos). Exploraremos las dependencias de la caché de SQL en un tutorial futuro.

Resumen

En este tutorial hemos examinado las funcionalidades integradas de almacenamiento en caché de ObjectDataSource. Simplemente estableciendo algunas propiedades, podemos indicar al ObjectDataSource que almacene en caché los resultados devueltos del especificado SelectMethod en la memoria caché de datos de ASP.NET. Las CacheDuration propiedades y CacheExpirationPolicy indican la duración que el elemento se almacena en caché y si es una expiración absoluta o deslizante. La CacheKeyDependency propiedad asocia todas las entradas de caché de ObjectDataSource a una dependencia de caché existente. Esto se puede usar para expulsar las entradas de ObjectDataSource de la memoria caché antes de que se alcance la expiración basada en el tiempo y se usa normalmente con dependencias de caché de SQL.

Puesto que ObjectDataSource simplemente almacena en caché sus valores en la memoria caché de datos, podríamos replicar la funcionalidad integrada de ObjectDataSource mediante programación. No tiene sentido hacerlo en la capa de presentación, ya que ObjectDataSource ofrece esta funcionalidad de forma predeterminada, pero podemos implementar funcionalidades de almacenamiento en caché en una capa independiente de la arquitectura. Para ello, es necesario repetir la misma lógica que usa ObjectDataSource. Exploraremos cómo trabajar mediante programación con la caché de datos desde la arquitectura en nuestro siguiente tutorial.

¡Feliz programación!

Lecturas adicionales

Para obtener más información sobre los temas tratados en este tutorial, consulte los siguientes recursos:

Acerca del autor

Scott Mitchell, autor de siete libros de ASP/ASP.NET y fundador de 4GuysFromRolla.com, ha estado trabajando con tecnologías web de Microsoft desde 1998. Scott trabaja como consultor independiente, entrenador y escritor. Su último libro es Sams Teach Yourself ASP.NET 2.0 en 24 horas. Se puede contactar con él en mitchell@4GuysFromRolla.com.

Agradecimientos especiales a

Esta serie de tutoriales contó con la revisión de muchos revisores que fueron de gran ayuda. El revisor principal de este tutorial fue Teresa Murphy. ¿Le interesa revisar mis próximos artículos de MSDN? Si es así, mándame un mensaje a mitchell@4GuysFromRolla.com.

Compartir a través de