Almacenar datos en caché en la arquitectura (VB)

de Scott Mitchell

Descargar PDF

En el tutorial anterior hemos aprendido a aplicar el almacenamiento en caché en la capa de presentación. En este tutorial, aprenderá a aprovechar nuestra arquitectura superpuesta para almacenar en caché los datos en la capa lógica de negocios. Para ello, ampliamos la arquitectura para incluir una capa de almacenamiento en caché.

Introducción

Como vimos en el tutorial anterior, el almacenamiento en caché de los datos de ObjectDataSource es tan sencillo como establecer un par de propiedades. Desafortunadamente, ObjectDataSource aplica el almacenamiento en caché en la capa de presentación, que acopla estrechamente las directivas de almacenamiento en caché con la página de ASP.NET. Una de las razones para crear una arquitectura superpuesta es permitir que estos acoplamientos se rompan. La capa lógica de negocios, por ejemplo, desacopla la lógica de negocios de las páginas de ASP.NET, mientras que la capa de acceso a datos desacopla los detalles de acceso a datos. Esta desacoplamiento de la lógica de negocios y los detalles de acceso a datos es preferible, en parte, porque hace que el sistema sea más legible, más fácil de mantener y más flexible para cambiar. También permite el conocimiento del dominio y la división del trabajo, de modo que un desarrollador que trabaja en la capa de presentación no necesita estar familiarizado con los detalles de la base de datos para realizar su trabajo. Desacoplar la directiva de almacenamiento en caché de la capa de presentación ofrece ventajas similares.

En este tutorial vamos a aumentar nuestra arquitectura para incluir una capa de almacenamiento en caché (o CL para abreviar) que emplea nuestra directiva de almacenamiento en caché. La capa de almacenamiento en caché incluirá una ProductsCL clase que proporciona acceso a la información del producto con métodos como GetProducts(), GetProductsByCategoryID(categoryID), etc., que, cuando se invoca, primero intentará recuperar los datos de la memoria caché. Si la memoria caché está vacía, estos métodos invocarán el método adecuado ProductsBLL en el BLL, que a su vez obtendrá los datos del DAL. Los ProductsCL métodos almacenan en caché los datos recuperados del BLL antes de devolverlos.

Como se muestra en la figura 1, el CL reside entre las capas de presentación y lógica de negocios.

Figura 1: La capa de almacenamiento en caché (CL) es otra capa en nuestra arquitectura

Paso 1: Crear las clases de capa de almacenamiento en caché

En este tutorial, crearemos un CL muy sencillo con una sola clase ProductsCL que solo tiene unos pocos métodos. La construcción de una capa de caché completa para toda la aplicación requeriría crear las clases CategoriesCL, EmployeesCL, y SuppliersCL, y proporcionar un método en estas clases de capa de caché para cada método de acceso o modificación de datos en la BLL. Al igual que con BLL y DAL, la capa de almacenamiento en caché debe implementarse idealmente como un proyecto de biblioteca de clases independiente; sin embargo, lo implementaremos como una clase en la App_Code carpeta .

Para separar más limpiamente las clases CL de las clases DAL y BLL, vamos a crear una subcarpeta en la App_Code carpeta . Haga clic con el botón derecho en la App_Code carpeta del Explorador de soluciones, elija Nueva carpeta y asigne el nombre a la nueva carpeta CL. Después de crear esta carpeta, agréguela a una nueva clase denominada ProductsCL.vb.

Figura 2: Agregar una nueva carpeta denominada CL y una clase denominada ProductsCL.vb

La ProductsCL clase debe incluir el mismo conjunto de métodos de acceso y modificación de datos que se encuentran en su clase de capa lógica de negocios correspondiente (ProductsBLL). En lugar de crear todos estos métodos, vamos a construir un par aquí para familiarizarnos con los patrones usados por CL. En concreto, agregaremos los métodos GetProducts() y GetProductsByCategoryID(categoryID) en el paso 3 y una sobrecarga UpdateProduct en el paso 4. Puede agregar los métodos restantes ProductsCL y las clases CategoriesCL, EmployeesCL y SuppliersCL en su tiempo libre.

Paso 2: Lectura y escritura en la caché de datos

La característica de almacenamiento en caché ObjectDataSource explorada en el tutorial anterior usa internamente la memoria caché de datos ASP.NET para almacenar los datos recuperados de BLL. Se puede acceder a la caché de datos mediante programación desde las clases de ASP.NET en el código subyacente de las páginas o desde las clases de la arquitectura de la aplicación web. Para leer y escribir en la caché de datos desde la clase de código subyacente de una página de ASP.NET, use el siguiente patrón:

' Read from the cache
Dim value as Object = Cache("key")
' Add a new item to the cache
Cache("key") = value
Cache.Insert(key, value)
Cache.Insert(key, value, CacheDependency)
Cache.Insert(key, value, CacheDependency, DateTime, TimeSpan)

El Cache método de la clase s Insert tiene una serie de sobrecargas. Cache("key") = value y son sinónimos y Cache.Insert(key, value) agregan un elemento a la memoria caché mediante la clave especificada sin una expiración definida. Normalmente, queremos especificar una expiración al agregar un elemento a la memoria caché, ya sea como una dependencia, una expiración basada en el tiempo o ambas. Use una de las otras Insert sobrecargas del método para proporcionar información de expiración basada en dependencias o tiempo.

Los métodos de la capa de almacenamiento en caché deben comprobar primero si los datos solicitados están en la memoria caché y, si es así, devolverlos desde allí. Si los datos solicitados no están en la memoria caché, se debe invocar el método BLL adecuado. Su valor devuelto debe almacenarse en caché y, a continuación, devolverse, como se muestra en el diagrama de secuencia siguiente.

Figura 3: Los métodos de la capa de almacenamiento en caché devuelven datos de la memoria caché si está disponible

La secuencia que se muestra en la figura 3 se realiza en las clases CL con el siguiente patrón:

Dim instance As Type = TryCast(Cache("key"), Type)
If instance Is Nothing Then
    instance = BllMethodToGetInstance()
    Cache.Insert(key, instance, ...)
End If
Return instance

Aquí, Type es el tipo de datos que se almacenan en la memoria caché Northwind.ProductsDataTable, por ejemplo, mientras que key es la clave que identifica de forma única el elemento de caché. Si el elemento con la clave especificada no está en la memoria caché, la instancia será Nothing y los datos se recuperarán del método BLL adecuado y se agregarán a la memoria caché. Cuando se alcanza Return instance, la instancia contiene una referencia a los datos, ya sea de la memoria caché o obtenida de la BLL.

Asegúrese de usar el patrón anterior al acceder a los datos de la memoria caché. El siguiente patrón, que, a primera vista, parece equivalente, contiene una diferencia sutil que introduce una condición de carrera. Las condiciones de carrera son difíciles de depurar porque se revelan esporádicamente y son difíciles de reproducir.

If Cache("key") Is Nothing Then
    Cache.Insert(key, BllMethodToGetInstance(), ...)
End If
Return Cache("key")

La diferencia en este segundo fragmento de código incorrecto es que, en lugar de almacenar una referencia al elemento almacenado en caché en una variable local, se accede a la caché de datos directamente en la instrucción condicional y en Return. Imagine que cuando se alcanza este código, Cache("key") no Nothinges , sino antes de que se alcance la Return instrucción, el sistema expulsa la clave de la caché. En este raro caso, se devolverá Nothing el código en lugar de un objeto del tipo esperado.

Nota:

La caché de datos es segura para subprocesos, por lo que no es necesario sincronizar el acceso a subprocesos para lecturas o escrituras simples. Sin embargo, si necesita realizar varias operaciones en los datos cacheados que deben ser atómicas, es responsable de implementar un bloqueo o algún otro mecanismo para garantizar la seguridad del hilo. Consulte Synchronizing Access to the ASP.NET Cache (Sincronizar el acceso a la caché de ASP.NET ) para obtener más información.

Un elemento se puede expulsar mediante programación de la memoria caché de datos mediante el Remove método de este modo:

Cache.Remove(key)

Paso 3: Retornar la información del producto desde laProductsCLclase

En este tutorial se implementarán dos métodos para devolver información del producto de la ProductsCL clase : GetProducts() y GetProductsByCategoryID(categoryID). Al igual que con la ProductsBL clase en la capa lógica de negocios, el método GetProducts() en CL devuelve información sobre todos los productos como un objeto Northwind.ProductsDataTable, mientras GetProductsByCategoryID(categoryID) devuelve todos los productos de una categoría especificada.

El código siguiente muestra una parte de los métodos de la ProductsCL clase :

<System.ComponentModel.DataObject()> _
Public Class ProductsCL
    Private _productsAPI As ProductsBLL = Nothing
    Protected ReadOnly Property API() As ProductsBLL
        Get
            If _productsAPI Is Nothing Then
                _productsAPI = New ProductsBLL()
            End If
            Return _productsAPI
        End Get
    End Property
    <System.ComponentModel.DataObjectMethodAttribute _
    (DataObjectMethodType.Select, True)> _
    Public Function GetProducts() As Northwind.ProductsDataTable
        Const rawKey As String = "Products"
        ' See if the item is in the cache
        Dim products As Northwind.ProductsDataTable = _
            TryCast(GetCacheItem(rawKey), Northwind.ProductsDataTable)
        If products Is Nothing Then
            ' Item not found in cache - retrieve it and insert it into the cache
            products = API.GetProducts()
            AddCacheItem(rawKey, products)
        End If
        Return products
    End Function
    <System.ComponentModel.DataObjectMethodAttribute _
        (DataObjectMethodType.Select, False)> _
    Public Function GetProductsByCategoryID(ByVal categoryID As Integer) _
        As Northwind.ProductsDataTable
        If (categoryID < 0) Then
            Return GetProducts()
        Else
            Dim rawKey As String = String.Concat("ProductsByCategory-", categoryID)
            ' See if the item is in the cache
            Dim products As Northwind.ProductsDataTable = _
                TryCast(GetCacheItem(rawKey), Northwind.ProductsDataTable)
            If products Is Nothing Then
                ' Item not found in cache - retrieve it and insert it into the cache
                products = API.GetProductsByCategoryID(categoryID)
                AddCacheItem(rawKey, products)
            End If
            Return products
        End If
    End Function
End Class

En primer lugar, tenga en cuenta los DataObject atributos y DataObjectMethodAttribute aplicados a la clase y los métodos. Estos atributos proporcionan información al asistente de ObjectDataSource, que indica qué clases y métodos deben aparecer en los pasos del asistente. Dado que se tendrá acceso a las clases y métodos CL desde objectDataSource en la capa de presentación, agrego estos atributos para mejorar la experiencia en tiempo de diseño. Consulte el tutorial Creación de una capa de lógica de negocios para obtener una descripción más detallada sobre estos atributos y sus efectos.

En los GetProducts() métodos y GetProductsByCategoryID(categoryID) , los datos devueltos desde el GetCacheItem(key) método se asignan a una variable local. El GetCacheItem(key) método, que examinaremos en breve, devuelve un elemento determinado de la memoria caché en función de la clave especificada. Si no se encuentra ningún dato en la memoria caché, se recupera del método de clase correspondiente ProductsBLL y, a continuación, se agrega a la memoria caché mediante el AddCacheItem(key, value) método .

Los métodos GetCacheItem(key) y AddCacheItem(key, value) se interfazan con la memoria caché de datos, leyendo y escribiendo valores, respectivamente. El GetCacheItem(key) método es el más sencillo de los dos. Simplemente devuelve el valor de la clase Cache mediante la clave pasada:

Private Function GetCacheItem(ByVal rawKey As String) As Object
    Return HttpRuntime.Cache(GetCacheKey(rawKey))
End Function
Private ReadOnly MasterCacheKeyArray() As String = {"ProductsCache"}
Private Function GetCacheKey(ByVal cacheKey As String) As String
    Return String.Concat(MasterCacheKeyArray(0), "-", cacheKey)
End Function

GetCacheItem(key) no usa el valor de clave tal como se proporciona, sino que llama al GetCacheKey(key) método, que devuelve la clave antepuesta con ProductsCache-. El MasterCacheKeyArray, que contiene la cadena ProductsCache, también lo usa el AddCacheItem(key, value) método , como veremos momentáneamente.

Desde una clase de código subyacente de una página de ASP.NET, se puede tener acceso a la caché de datos mediante la propiedad de la Page clase y Cachepermite la sintaxis como Cache("key") = value, como se describe en el paso 2. Desde una clase dentro de la arquitectura, se puede acceder a la caché de datos mediante HttpRuntime.Cache o HttpContext.Current.Cache. La entrada de blog de Peter JohnsonHttpRuntime.Cache frente a HttpContext.Current.Cache señala la ligera ventaja de rendimiento en el uso HttpRuntime en lugar de HttpContext.Current; en consecuencia, ProductsCL usa HttpRuntime.

Nota:

Si la arquitectura se implementa mediante proyectos de System.Web biblioteca de clases, deberá agregar una referencia al ensamblado para poder utilizar las HttpRuntime clases and HttpContext .

Si el elemento no se encuentra en la memoria caché, los métodos de la ProductsCL clase s obtienen los datos de la BLL y lo agregan a la memoria caché mediante el AddCacheItem(key, value) método . Para agregar valor a la memoria caché, podríamos usar el código siguiente, que usa una expiración de 60 segundos:

Const CacheDuration As Double = 60.0
Private Sub AddCacheItem(ByVal rawKey As String, ByVal value As Object)
    DataCache.Insert(GetCacheKey(rawKey), value, Nothing, _
        DateTime.Now.AddSeconds(CacheDuration), _
        System.Web.Caching.Cache.NoSlidingExpiration)
End Sub

DateTime.Now.AddSeconds(CacheDuration) especifica la expiración basada en el tiempo 60 segundos en el futuro, mientras que System.Web.Caching.Cache.NoSlidingExpiration indica que no existe una expiración deslizante. Aunque esta Insert sobrecarga de método tiene parámetros de entrada para una expiración absoluta y deslizante, solo puede proporcionar uno de los dos. Si intenta especificar una hora absoluta y un intervalo de tiempo, el Insert método producirá una ArgumentException excepción.

Nota:

Esta implementación del AddCacheItem(key, value) método actualmente tiene algunas deficiencias. Abordaremos y solucionaremos estos problemas en el paso 4.

Paso 4: Invalidación de la memoria caché cuando los datos se modifican a través de la arquitectura

Junto con los métodos de recuperación de datos, la capa de almacenamiento en caché debe proporcionar los mismos métodos que el BLL para insertar, actualizar y eliminar datos. Los métodos de modificación de datos de CL no modifican los datos almacenados en caché, sino que llaman al método de modificación de datos correspondiente de BLL y, a continuación, invalidan la memoria caché. Como vimos en el tutorial anterior, este es el mismo comportamiento que aplica el ObjectDataSource cuando se habilitan sus características de almacenamiento en caché y se invocan sus métodos Insert, Update o Delete.

La sobrecarga siguiente UpdateProduct muestra cómo implementar los métodos de modificación de datos en CL:

<DataObjectMethodAttribute(DataObjectMethodType.Update, False)> _
Public Function UpdateProduct(productName As String, _
    unitPrice As Nullable(Of Decimal), productID As Integer) _
    As Boolean
    Dim result As Boolean = API.UpdateProduct(productName, unitPrice, productID)
    ' TODO: Invalidate the cache
    Return result
End Function

Se invoca el método de la capa lógica de negocios adecuada de modificación de datos, pero antes de que se devuelva su respuesta, es necesario invalidar la memoria caché. Desafortunadamente, la invalidación de la memoria caché no es sencilla porque la ProductsCL clase s GetProducts() y GetProductsByCategoryID(categoryID) los métodos agregan elementos a la memoria caché con claves diferentes y el GetProductsByCategoryID(categoryID) método agrega un elemento de caché diferente para cada categoryID único.

Al invalidar la memoria caché, es necesario quitar todos los elementos que puede haber agregado la ProductsCL clase . Esto se puede lograr asociando una dependencia de caché con cada elemento agregado a la memoria caché en el AddCacheItem(key, value) método . En general, una dependencia de caché puede ser otro elemento de la memoria caché, un archivo en el sistema de archivos o datos de una base de datos de Microsoft SQL Server. Cuando la dependencia cambia o se quita de la memoria caché, los elementos de caché a los que está asociado se expulsan automáticamente de la memoria caché. En este tutorial, queremos crear un elemento adicional en la memoria caché que actúa como dependencia de caché para todos los elementos agregados a través de la ProductsCL clase . De este modo, todos estos elementos se pueden quitar de la memoria caché simplemente quitando la dependencia de caché.

Vamos a actualizar el AddCacheItem(key, value) método para que cada elemento agregado a la memoria caché a través de este método esté asociado a una sola dependencia de caché:

Private Sub AddCacheItem(ByVal rawKey As String, ByVal value As Object)
    Dim DataCache As System.Web.Caching.Cache = HttpRuntime.Cache
    ' Make sure MasterCacheKeyArray[0] is in the cache - if not, add it
    If DataCache(MasterCacheKeyArray(0)) Is Nothing Then
        DataCache(MasterCacheKeyArray(0)) = DateTime.Now
    End If
    ' Add a CacheDependency
    Dim dependency As New Caching.CacheDependency(Nothing, MasterCacheKeyArray) _
        DataCache.Insert(GetCacheKey(rawKey), value, dependency, _
        DateTime.Now.AddSeconds(CacheDuration), _
        System.Web.Caching.Cache.NoSlidingExpiration)
End Sub

MasterCacheKeyArray es una matriz de cadenas que contiene un valor único, ProductsCache. En primer lugar, se agrega un elemento de caché a la memoria caché y se le asigna la fecha y hora actuales. Si el elemento de caché ya existe, se actualiza. A continuación, se crea una dependencia de caché. El CacheDependency constructor de la clase tiene una serie de sobrecargas, pero el que se usa aquí espera dos String entradas de matriz. La primera especifica el conjunto de archivos que se van a usar como dependencias. Dado que no queremos usar ninguna dependencia basada en archivos, se usa un valor de Nothing para el primer parámetro de entrada. El segundo parámetro de entrada especifica el conjunto de claves de caché que se van a usar como dependencias. Aquí especificamos nuestra única dependencia, MasterCacheKeyArray. A continuación, CacheDependency se pasa al método Insert.

Con esta modificación en AddCacheItem(key, value), la invalidación de la memoria caché es tan sencilla como quitar la dependencia.

<DataObjectMethodAttribute(DataObjectMethodType.Update, False)> _
Public Function UpdateProduct(ByVal productName As String, _
    ByVal unitPrice As Nullable(Of Decimal), ByVal productID As Integer) _
    As Boolean
    Dim result As Boolean = API.UpdateProduct(productName, unitPrice, productID)
    ' Invalidate the cache
    InvalidateCache()
    Return result
End Function
Public Sub InvalidateCache()
    ' Remove the cache dependency
    HttpRuntime.Cache.Remove(MasterCacheKeyArray(0))
End Sub

Paso 5: Llamar a la capa de almacenamiento en caché desde la capa de presentación

Las clases y métodos de la capa de almacenamiento en caché se pueden usar para trabajar con datos mediante las técnicas que hemos examinado en estos tutoriales. Para ilustrar cómo trabajar con datos almacenados en caché, guarde los cambios en la ProductsCL clase y, a continuación, abra la FromTheArchitecture.aspx página en la Caching carpeta y agregue una clase GridView. En la etiqueta inteligente del GridView, cree un nuevo ObjectDataSource. En el primer paso del asistente, debería ver la clase ProductsCL como una de las opciones de la lista desplegable.

Figura 4: La ProductsCL clase se incluye en la lista de objetos de negocio Drop-Down (haga clic para ver la imagen de tamaño completo)

Después de seleccionar ProductsCL, haga clic en Siguiente. La lista desplegable de la pestaña SELECT tiene dos elementos - GetProducts() y GetProductsByCategoryID(categoryID), y la pestaña UPDATE tiene la única sobrecarga UpdateProduct. Elija el GetProducts() método en la pestaña SELECT y el UpdateProducts método de la pestaña UPDATE y haga clic en Finalizar.

Figura 5: Los ProductsCL métodos de clase se enumeran en las listas de Drop-Down (haga clic para ver la imagen de tamaño completo).

Después de completar el asistente, Visual Studio establecerá la propiedad OldValuesParameterFormatString ObjectDataSource en original_{0} y agregará los campos adecuados a GridView. Vuelva a cambiar la OldValuesParameterFormatString propiedad a su valor predeterminado, {0}y configure GridView para admitir la paginación, la ordenación y la edición. Puesto que la UploadProducts sobrecarga usada por CL solo acepta el nombre y el precio del producto editado, limite GridView para que solo se puedan editar estos campos.

En el tutorial anterior definimos un GridView para incluir campos para los ProductName, CategoryName y UnitPrice. No dude en replicar este formato y estructura, en cuyo caso el marcado declarativo de GridView y ObjectDataSource debe lucir similar 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:RequiredFieldValidator ID="RequiredFieldValidator1"
                    ControlToValidate="ProductName" Display="Dynamic" 
                    ErrorMessage="You must provide a name for the product." 
                    SetFocusOnError="True"
                    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" runat="server" 
                    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" 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="ProductsCL" UpdateMethod="UpdateProduct">
    <UpdateParameters>
        <asp:Parameter Name="productName" Type="String" />
        <asp:Parameter Name="unitPrice" Type="Decimal" />
        <asp:Parameter Name="productID" Type="Int32" />
    </UpdateParameters>
</asp:ObjectDataSource>

En este punto tenemos una página que usa la capa de almacenamiento en caché. Para ver la memoria caché en acción, establezca puntos de interrupción en la clase ProductsCL sGetProducts() y los métodos UpdateProduct. Visite la página en un explorador y recorra el código al ordenar y paginar para ver los datos extraídos de la memoria caché. A continuación, actualice un registro y observe que la memoria caché se invalida y, por lo tanto, se recupera de la BLL cuando los datos se vuelven a enlazar al GridView.

Nota:

La capa de almacenamiento en caché proporcionada en la descarga que acompaña a este artículo no está completa. Contiene solo una clase, , ProductsCLque solo tiene un puñado de métodos. Además, solo una sola página de ASP.NET usa cl (~/Caching/FromTheArchitecture.aspx) todos los demás siguen referenciando directamente al BLL. Si planea usar un CL en su aplicación, todas las llamadas de la capa de presentación deben dirigirse al CL, lo que requeriría que las clases y métodos del CL cubran aquellas clases y métodos en el BLL que usa actualmente la capa de presentación.

Resumen

Aunque el almacenamiento en caché se puede aplicar en la capa de presentación con controles SqlDataSource y ObjectDataSource de ASP.NET 2.0 s, idealmente las responsabilidades de almacenamiento en caché se delegarían en una capa independiente de la arquitectura. En este tutorial hemos creado una capa de almacenamiento en caché que reside entre la capa de presentación y la capa lógica de negocios. La capa de almacenamiento en caché debe proporcionar el mismo conjunto de clases y métodos que existen en el BLL y que se llaman desde la capa de presentación.

Los ejemplos de capa de almacenamiento en caché que hemos explorado en este y los tutoriales anteriores mostraron la carga reactiva. Con la carga reactiva, los datos se cargan en la memoria caché solo cuando se realiza una solicitud del dato y este falta en la memoria caché. Los datos también se pueden cargar de forma proactiva en la memoria caché, una técnica que carga los datos en la memoria caché antes de que sea realmente necesario. En el siguiente tutorial, veremos un ejemplo de carga proactiva cuando veamos cómo almacenar valores estáticos en la memoria caché durante el inicio de la aplicación.

¡Feliz programación!

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.

Siguiente anterior