Cachelagring av data i arkitekturen (VB)

av Scott Mitchell

Ladda ned PDF

I den föregående självstudien lärde vi oss att tillämpa cachelagring på presentationsskiktet. I den här handledningen lär vi oss att dra nytta av vår skiktade arkitektur för att cachelagra data på affärslogiklagret. Vi gör detta genom att utöka arkitekturen till att omfatta ett cachelagringslager.

Inledning

Som vi såg i föregående självstudiekurs är cachelagring av ObjectDataSource-data lika enkelt som att ange ett par egenskaper. ObjectDataSource tillämpar tyvärr cachelagring på presentationsskiktet, vilket nära kopplar samman cachelagringsprinciperna med sidan ASP.NET. En av anledningarna till att skapa en arkitektur i flera lager är att tillåta att sådana kopplingar bryts. Affärslogiklagret frikopplar till exempel affärslogik från de ASP.NET sidorna, medan dataåtkomstlagret frikopplar dataåtkomstinformationen. Den här avkopplingen av information om affärslogik och dataåtkomst föredras delvis eftersom det gör systemet mer läsbart, mer underhållsbart och mer flexibelt att ändra. Det möjliggör också användningen av domänspecifik kunskap och arbetsfördelning, där en utvecklare som arbetar med presentationslagret inte behöver vara insatt i databasen detaljer för att kunna utföra sitt arbete. Att koppla bort cachelagringsprincipen från presentationslagret ger liknande fördelar.

I den här självstudien utökar vi vår arkitektur till att omfatta ett cachelagringslager (eller CL för kort) som använder vår cachelagringsprincip. Cachelagringslagret innehåller en ProductsCL klass som ger åtkomst till produktinformation med metoder som GetProducts(), GetProductsByCategoryID(categoryID)och så vidare, som, när det anropas, först försöker hämta data från cachen. Om cacheminnet är tomt anropar dessa metoder lämplig ProductsBLL metod i BLL:n, vilket i sin tur skulle hämta data från DAL. Metoderna ProductsCL cachelagrar data som hämtats från BLL innan de returneras.

Som bild 1 visar finns CL mellan presentations- och affärslogiklagren.

Bild 1: Cachelagringsskiktet (CL) är ett annat lager i vår arkitektur

Steg 1: Skapa cachelagringslagrets klasser

I den här självstudien skapar vi en mycket enkel CL med en enda klass ProductsCL som bara har en handfull metoder. Att skapa ett fullständigt cachelagringslager för hela programmet kräver att du skapar CategoriesCL, EmployeesCLoch SuppliersCL klasser och tillhandahåller en metod i dessa cachelagringslagerklasser för varje dataåtkomst- eller ändringsmetod i BLL:n. Precis som med BLL och DAL bör cachelagringsskiktet helst implementeras som ett separat klassbiblioteksprojekt. Men vi implementerar den som en klass i App_Code mappen.

Om du vill skilja CL-klasserna från DAL- och BLL-klasserna på ett tydligare sätt skapar vi en ny undermapp i App_Code mappen. Högerklicka på App_Code mappen i Solution Explorer, välj Ny mapp och ge den nya mappen CLnamnet . När du har skapat den här mappen lägger du till en ny klass med namnet ProductsCL.vb.

Bild 2: Lägg till en ny mapp med namnet CL och en klass med namnet ProductsCL.vb

Klassen ProductsCL bör innehålla samma uppsättning dataåtkomst- och ändringsmetoder som i motsvarande Business Logic Layer-klass (ProductsBLL). I stället för att skapa alla dessa metoder, låt oss bara bygga ett par här för att få en känsla för de mönster som används av CL. I synnerhet kommer vi att lägga till metoderna GetProducts() och GetProductsByCategoryID(categoryID) i steg 3 och en UpdateProduct överbelastning i steg 4. Du kan lägga till återstående ProductsCL metoder och CategoriesCL, EmployeesCL och SuppliersCL klasser på fritiden.

Steg 2: Läsa och skriva till datacachen

Cachelagringsfunktionen ObjectDataSource som utforskades i föregående självstudie använder internt ASP.NET datacache för att lagra data som hämtats från BLL. Datacachen kan också nås programmatiskt från ASP.NET sidor med kod bakom klasser eller från klasserna i webbprogrammets arkitektur. För att läsa och skriva till cachen för data från kod-behind-klassen för en ASP.NET-sida, använd följande mönster:

' 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)

Cache klassensInsert metod har ett antal överlagringar. Cache("key") = value och Cache.Insert(key, value) är synonyma och båda lägger till ett objekt i cachen med den angivna nyckeln utan en definierad utgång. Vanligtvis vill vi ange ett förfallodatum när du lägger till ett objekt i cacheminnet, antingen som ett beroende, en tidsbaserad förfallotid eller både och. Använd någon av de andra Insert metodernas överbelastningar för att tillhandahålla beroende- eller tidsbaserad utgångsinformation.

Metoderna för cachelagringslager måste först kontrollera om begärda data finns i cacheminnet och i så fall returnera dem därifrån. Om begärda data inte finns i cacheminnet måste lämplig BLL-metod anropas. Dess returvärde ska cachelagras och sedan returneras, som följande sekvensdiagram illustrerar.

Bild 3: Cachelagringslagrets metoder returnerar data från cacheminnet om de är tillgängliga

Sekvensen som visas i bild 3 utförs i CL-klasserna med hjälp av följande mönster:

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

Här är Typ den typ av data som lagras i cacheminnet Northwind.ProductsDataTable, till exempel när nyckeln är nyckeln som unikt identifierar cacheobjektet. Om objektet med den angivna nyckeln inte finns i cacheminnet kommer instansen att vara Nothing och data hämtas från lämplig BLL-metod och läggas till i cacheminnet. När Return instance har nåtts innehåller instansen en referens till data, antingen från cachen eller från BLL.

Se till att använda mönstret ovan när du kommer åt data från cacheminnet. Följande mönster, som vid första anblicken ser likvärdigt ut, innehåller en subtil skillnad som skapar ett tävlingsvillkor. Rasförhållanden är svåra att felsöka eftersom de avslöjar sig sporadiskt och är svåra att reproducera.

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

Skillnaden i det här andra, felaktiga kodfragmentet är att i stället för att lagra en referens till det cachelagrade objektet i en lokal variabel, nås datacachen direkt i villkorssatsen och i Return. Tänk dig att när den här koden nås är Cache("key") inte Nothing, men innan Return-instruktionen nås, rensar systemet nyckeln från cacheminnet. I det här sällsynta fallet kommer koden att returnera Nothing i stället för ett objekt av den förväntade typen.

Ett objekt kan tas bort programmatiskt från datacachen med hjälp av metodenRemove så här:

Cache.Remove(key)

Steg 3: Returnera produktinformation frånProductsCLklassen

I den här självstudien ska vi implementera två metoder för att returnera produktinformation från ProductsCL klassen: GetProducts() och GetProductsByCategoryID(categoryID). Precis som med ProductsBL klassen i affärslogiklagret GetProducts() returnerar metoden i CL information om alla produkter som ett Northwind.ProductsDataTable objekt, medan GetProductsByCategoryID(categoryID) returnerar alla produkter från en angiven kategori.

Följande kod visar en del av metoderna i ProductsCL klassen:

<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

Observera först attributen DataObject och DataObjectMethodAttribute som tillämpas på klassen och metoderna. Dessa attribut ger information till guiden ObjectDataSource s som anger vilka klasser och metoder som ska visas i guidens steg. Eftersom CL-klasserna och metoderna kommer att nås från en ObjectDataSource i presentationslagret har jag lagt till dessa attribut för att förbättra designtidsupplevelsen. Gå tillbaka till självstudiekursen Skapa ett affärslogiklager för en mer ingående beskrivning av dessa attribut och deras effekter.

I GetProducts()- och GetProductsByCategoryID(categoryID)-metoderna tilldelas data som returneras från GetCacheItem(key)-metoden till en lokal variabel. Metoden GetCacheItem(key) , som vi kommer att undersöka inom kort, returnerar ett visst objekt från cacheminnet baserat på den angivna nyckeln. Om inga sådana data hittas i cacheminnet hämtas de från motsvarande ProductsBLL klassmetod och läggs sedan till i cacheminnet med hjälp av AddCacheItem(key, value) metoden .

Metoderna GetCacheItem(key) och AddCacheItem(key, value) använder gränssnitt för att hantera datacachen, läser respektive skriver värden. Metoden GetCacheItem(key) är den enklare av de två. Det returnerar helt enkelt värdet från cacheklassen med hjälp av den skickade nyckeln:

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) använder inte nyckelvärdet som angetts, utan anropar GetCacheKey(key) i stället metoden, som returnerar nyckeln som är förberedd med ProductsCache-. MasterCacheKeyArray, som innehåller strängen ProductsCache, används också av AddCacheItem(key, value)-metoden, som vi strax kommer att se.

Från en ASP.NET-sidas code-behind-klass kan datacachen nås med hjälp av Page-klassens Cacheegenskap och tillåter syntax som Cache("key") = value, enligt beskrivningen i steg 2. Från en klass i arkitekturen kan datacachen nås med antingen HttpRuntime.Cache eller HttpContext.Current.Cache. Peter Johnsons blogginlägg HttpRuntime.Cache jämfört med HttpContext.Current.Cache noterar den lilla prestandafördelen med att använda HttpRuntime i stället för HttpContext.Current, och använder ProductsCLdärför HttpRuntime .

Om objektet inte hittas i cacheminnet, hämtar metoderna i ProductsCL-klassen data från BLL och lägger till dem i cacheminnet med hjälp av AddCacheItem(key, value)-metoden. För att lägga till värde i cacheminnet kan vi använda följande kod, som använder en 60 sekunders förfallotid:

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) anger den tidsbaserade förfallotiden 60 sekunder i framtiden, medan System.Web.Caching.Cache.NoSlidingExpiration anger att det inte finns någon glidande förfallotid. Även om den här Insert överlagrade metod har indataparametrar för både ett absolut och ett relativt förfallodatum, kan du bara ange ett av dem. Om du försöker ange både en absolut tid och ett tidsintervall utlöser Insert metoden ett ArgumentException undantag.

Steg 4: Ogiltigförklara cacheminnet när data ändras via arkitekturen

Tillsammans med datahämtningsmetoder måste cachelagringslagret tillhandahålla samma metoder som BLL för att infoga, uppdatera och ta bort data. CL:s datamodifieringsmetoder ändrar inte cachelagrade data, utan anropar i stället BLL:ns motsvarande datamodifieringsmetod och ogiltigförklarar sedan cacheminnet. Som vi såg i föregående självstudiekurs är detta samma beteende som ObjectDataSource gäller när dess cachelagringsfunktioner är aktiverade och dess Insert, Updateeller Delete -metoder anropas.

Följande UpdateProduct överbelastning illustrerar hur man implementerar datamodifieringsmetoderna i 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

Lämplig metod för dataändring Business Logic Layer anropas, men innan dess svar returneras måste cacheminnet ogiltigförklaras. Tyvärr är det inte enkelt att ogiltigförklara cacheminnet eftersom ProductsCL klasserna GetProducts() och GetProductsByCategoryID(categoryID) metoderna lägger till objekt i cacheminnet med olika nycklar, och GetProductsByCategoryID(categoryID) metoden lägger till ett annat cacheobjekt för varje unikt categoryID.

När cacheminnet ogiltigförklaras måste vi ta bort alla objekt som kan ha lagts till av ProductsCL klassen. Detta kan åstadkommas genom att associera ett cacheberoende med varje objekt som läggs till i cacheminnet i AddCacheItem(key, value) -metoden. I allmänhet kan ett cacheberoende vara ett annat objekt i cacheminnet, en fil i filsystemet eller data från en Microsoft SQL Server-databas. När beroendet ändras eller tas bort från cacheminnet tas de cacheobjekt som det är associerat med automatiskt bort från cacheminnet. I den här självstudien vill vi skapa ytterligare ett objekt i cacheminnet som fungerar som ett cacheberoende för alla objekt som läggs till via ProductsCL klassen. På så sätt kan alla dessa objekt tas bort från cachen genom att helt enkelt ta bort cacheberoendet.

Låt oss uppdatera AddCacheItem(key, value) metoden så att varje objekt som läggs till i cachen via den här metoden är associerat med ett enda cacheberoende:

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 är en strängmatris som innehåller ett enda värde, ProductsCache. Först läggs ett cacheobjekt till i cacheminnet och tilldelas aktuellt datum och tid. Om cacheobjektet redan finns uppdateras det. Därefter skapas ett cacheberoende. KlassensCacheDependency konstruktor har ett antal överlagringar, men den som används här förväntar sig två String matrisindata. Den första anger vilken uppsättning filer som ska användas som beroenden. Eftersom vi inte vill använda filbaserade beroenden används värdet Nothing för den första indataparametern. Den andra indataparametern anger vilken uppsättning cachenycklar som ska användas som beroenden. Här anger vi vårt enda beroende, MasterCacheKeyArray. CacheDependency Skickas sedan till Insert metoden.

Med denna ändring av AddCacheItem(key, value) är det lika enkelt att ogiltigförklara cachen som att ta bort beroendet.

<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

Steg 5: Anropa cachelagringsskiktet från presentationsskiktet

Cachelagringslagrets klasser och metoder kan användas för att arbeta med data med hjälp av de tekniker som vi har undersökt under de här handledningarna. Om du vill illustrera hur du arbetar med cachelagrade data sparar du ändringarna i ProductsCL klassen och öppnar FromTheArchitecture.aspx sedan sidan i Caching mappen och lägger till en GridView. Skapa en ny ObjectDataSource från GridViews smarta tagg. I guidens första steg bör du se ProductsCL klassen som ett av alternativen i listrutan.

Bild 4: Klassen ProductsCL ingår i Drop-Down-listan för affärsobjekt (klicka om du vill visa en bild i full storlek)

När du har ProductsCLvalt klickar du på Nästa. Listrutan på fliken SELECT innehåller två objekt – GetProducts() och GetProductsByCategoryID(categoryID) och fliken UPPDATERA har den enda UpdateProduct överlagringen. Välj metoden GetProducts() på fliken SELECT och UpdateProducts metoden på fliken UPPDATERA och klicka på Slutför.

Bild 5: Klassmetoderna ProductsCL visas i Drop-Down-listorna (Klicka om du vill visa en bild i full storlek)

När du har slutfört guiden ställer Visual Studio in egenskapen ObjectDataSource till OldValuesParameterFormatString och lägger till original_{0} lämpliga fält i GridView. Ändra tillbaka egenskapen OldValuesParameterFormatString till sitt standardvärde {0} och konfigurera GridView så att den stödjer bladvisning, sortering och redigering. Eftersom överlagringen UploadProducts som används av CL endast accepterar den redigerade produktens namn och pris begränsar du GridView så att endast dessa fält kan redigeras.

I den föregående självstudien definierade vi ett GridView för att inkludera fält för fälten ProductName, CategoryNameoch UnitPrice . Replikera gärna den här formateringen och strukturen, i så fall bör din GridView- och ObjectDataSource-deklarativa markering se ut ungefär så här:

<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>

Nu har vi en sida som använder cachelagringsskiktet. Om du vill se cachen i praktiken anger du brytpunkter i ProductsCL klasserna och GetProducts()UpdateProduct metoderna. Besök sidan i en webbläsare och stegvis gå igenom koden vid sortering och sidindelning för att se de data som hämtas från cacheminnet. Uppdatera sedan en post och observera att cachen är ogiltig och därför hämtas den från BLL när data återställs till GridView.

Sammanfattning

Cachelagring kan tillämpas på presentationsskiktet med ASP.NET 2.0 s SqlDataSource- och ObjectDataSource-kontroller, men helst delegeras cachelagringsansvaret till ett separat lager i arkitekturen. I den här självstudien skapade vi ett cachelagringslager som finns mellan presentationsskiktet och affärslogiklagret. Cachelagringslagret måste tillhandahålla samma uppsättning klasser och metoder som finns i BLL:n och anropas från presentationslagret.

Exemplen på cachelagringslager som vi utforskade i detta och de föregående handledningarna visade reaktiv inläsning. Vid reaktiv inläsning läses data endast in i cacheminnet när en begäran om data görs och att data saknas i cacheminnet. Data kan också läsas in proaktivt i cacheminnet , en teknik som läser in data i cacheminnet innan de faktiskt behövs. I nästa självstudie får vi se ett exempel på proaktiv inläsning när vi tittar på hur du lagrar statiska värden i cacheminnet vid programstart.

Lycka till med programmerandet!

Om författaren

Scott Mitchell, författare till sju ASP/ASP.NET-böcker och grundare av 4GuysFromRolla.com, har arbetat med Microsofts webbtekniker sedan 1998. Scott arbetar som oberoende konsult, tränare och författare. Hans senaste bok är Sams Teach Yourself ASP.NET 2.0 på 24 timmar. Han kan nås på mitchell@4GuysFromRolla.com.

Särskilt tack till

Den här självstudieserien granskades av många användbara granskare. Ansvarig granskare för den här självstudien var Teresa Murphy. Vill du granska mina kommande MSDN-artiklar? Om så är fallet, hör av dig på mitchell@4GuysFromRolla.com.