Gegevens opslaan in cache in de architectuur (C#)

door Scott Mitchell

PDF downloaden

In de vorige zelfstudie hebt u geleerd hoe u caching toepast op de presentatielaag. In deze zelfstudie leert u hoe u kunt profiteren van onze gelaagde architectuur voor het opslaan van gegevens in de bedrijfslogicalaag. We doen dit door de architectuur uit te breiden naar een cachelaag.

Introductie

Zoals we in de vorige zelfstudie hebben gezien, is het in de cache opslaan van de Gegevens van ObjectDataSource net zo eenvoudig als het instellen van een aantal eigenschappen. De ObjectDataSource past helaas caching toe op de presentatielaag, die het cachebeleid nauw koppelt aan de ASP.NET pagina. Een van de redenen voor het maken van een gelaagde architectuur is het toestaan dat dergelijke koppelingen worden verbroken. De bedrijfslogicalaag koppelt bijvoorbeeld de bedrijfslogica los van de ASP.NET pagina's, terwijl de Gegevenstoegangslaag de details van de gegevenstoegang loskoppelt. Deze ontkoppeling van bedrijfslogica en gegevenstoegangsdetails heeft de voorkeur, deels omdat het systeem beter leesbaar, beter onderhoudbaar en flexibeler wordt om te wijzigen. Het biedt ook domeinkennis en werkverdeling een ontwikkelaar die aan de presentatielaag werkt, hoeft niet vertrouwd te zijn met de gegevens van de database om haar werk te doen. Het loskoppelen van het cachebeleid van de presentatielaag biedt vergelijkbare voordelen.

In deze zelfstudie gaan we onze architectuur uitbreiden met een cachelaag (of CL voor kort) die gebruikmaakt van ons cachebeleid. De cachelaag bevat een ProductsCL klasse die toegang biedt tot productinformatie met methoden zoals GetProducts(), GetProductsByCategoryID(categoryID)enzovoort, die, wanneer deze wordt aangeroepen, eerst probeert de gegevens op te halen uit de cache. Als de cache leeg is, worden met deze methoden de juiste ProductsBLL methode aangeroepen in de BLL, waardoor de gegevens van de DAL worden opgehaald. Met ProductsCL de methoden worden de gegevens die zijn opgehaald uit de BLL in de cache opgeslagen voordat ze worden geretourneerd.

Zoals in afbeelding 1 wordt weergegeven, bevindt de CL zich tussen de lagen Presentatie en Bedrijfslogica.

Afbeelding 1: De cachelaag (CL) is een andere laag in onze architectuur

Stap 1: De cachelaag klassen creëren

In deze zelfstudie maken we een zeer eenvoudige CL met één klasse ProductsCL met slechts een handvol methoden. Voor het bouwen van een volledige cachelaag voor de hele toepassing moeten er klassen worden gemaakt CategoriesCL, EmployeesCL, en SuppliersCL, en moet een methode worden aangeboden in deze cachelaagklassen voor elke methode voor gegevensbenadering of wijziging in de BLL. Net als bij de BLL en DAL moet de cachelaag idealiter worden geïmplementeerd als een afzonderlijk klassebibliotheekproject; we zullen het echter implementeren als een klasse in de App_Code map.

Als u de CL-klassen beter wilt scheiden van de DAL- en BLL-klassen, maakt u een nieuwe submap in de App_Code map. Klik met de rechtermuisknop op de App_Code map in Solution Explorer, kies Nieuwe map en geef de nieuwe map CLeen naam. Voeg na het maken van deze map een nieuwe klasse toe met de naam ProductsCL.cs.

Afbeelding 2: Een nieuwe map met de naam CL en een klasse met de naam toevoegen ProductsCL.cs

De ProductsCL klasse moet dezelfde set gegevenstoegangs- en wijzigingsmethoden bevatten, zoals gevonden in de bijbehorende business logic layer-klasse (ProductsBLL). In plaats van al deze methoden te maken, bouwen we hier een paar om een idee te krijgen van de patronen die door de CL worden gebruikt. In het bijzonder voegen we de GetProducts() en GetProductsByCategoryID(categoryID) methoden toe in stap 3 en een UpdateProduct overbelasting in stap 4. U kunt de resterende ProductsCL methoden en CategoriesCL, EmployeesCLen SuppliersCL klassen op uw gemak toevoegen.

Stap 2: lezen en schrijven naar de gegevenscache

De cachefunctie ObjectDataSource die in de vorige zelfstudie is verkend, maakt intern gebruik van de ASP.NET gegevenscache om de gegevens op te slaan die zijn opgehaald uit de BLL. De gegevenscache kan ook via programmatuur worden geopend vanuit code-behind-klassen van ASP.NET-pagina's of vanuit de klassen in de architectuur van de webtoepassing. Gebruik het volgende patroon als u wilt lezen en schrijven naar de gegevenscache van een ASP.NET-paginacode-achterklasse:

// Read from the cache
object value = 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);

De Cache klasseInsert-methode heeft een aantal overloads. Cache["key"] = value en Cache.Insert(key, value) zijn synoniem en beide voegen een item toe aan de cache met behulp van de opgegeven sleutel zonder een gedefinieerde vervaldatum. Normaal gesproken willen we een verloopdatum opgeven bij het toevoegen van een item aan de cache, hetzij als een afhankelijkheid, een verloopdatum op basis van tijd of beide. Gebruik een van de andere Insert methode-overbelastingen om afhankelijkheids- of tijdgebaseerde verloopgegevens te bieden.

De methoden van de cachelaag moeten eerst controleren of de aangevraagde gegevens zich in de cache bevinden en, als dat het zo is, deze daar retourneren. Als de aangevraagde gegevens zich niet in de cache bevinden, moet de juiste BLL-methode worden aangeroepen. De retourwaarde moet in de cache worden opgeslagen en vervolgens worden geretourneerd, zoals in het volgende sequentiediagram wordt geïllustreerd.

Afbeelding 3: De methoden voor cachelagen retourneren gegevens uit de cache als deze beschikbaar zijn

De volgorde die in afbeelding 3 wordt weergegeven, wordt uitgevoerd in de CL-klassen met behulp van het volgende patroon:

Type instance = Cache["key"] as Type;
if (instance == null)
{
    instance = BllMethodToGetInstance();
    Cache.Insert(key, instance, ...);
}
return instance;

Hier is type het type gegevens dat wordt opgeslagen in de cache Northwind.ProductsDataTable, bijvoorbeeld terwijl de sleutel de sleutel is die het cache-item uniek identificeert. Als het item met de opgegeven sleutel zich niet in de cache bevindt, wordt het null en worden de gegevens opgehaald uit de juiste BLL-methode en toegevoegd aan de cache. Op het moment dat return instance is bereikt, bevat het exemplaar een verwijzing naar de gegevens, hetzij uit de cache of opgehaald uit de BLL.

Zorg ervoor dat u het bovenstaande patroon gebruikt bij het openen van gegevens uit de cache. Het volgende patroon, dat op het eerste gezicht equivalent lijkt, bevat een subtiel verschil dat een racevoorwaarde introduceert. Race conditions zijn moeilijk te debuggen omdat ze zich sporadisch voordoen en moeilijk te reproduceren zijn.

if (Cache["key"] == null)
{
    Cache.Insert(key, BllMethodToGetInstance(), ...);
}
return Cache["key"];

Het verschil in dit tweede, onjuiste codefragment is dat in plaats van een verwijzing naar het item in de cache op te slaan in een lokale variabele, de gegevenscache rechtstreeks wordt geopend in de voorwaardelijke instructie en in de return. Stel dat wanneer deze code is bereikt, Cache["key"] niet-null is, maar voordat de return opdracht wordt bereikt, de sleutel door het systeem uit de cache wordt verwijderd. In dit zeldzame geval retourneert de code een null waarde in plaats van een object van het verwachte type.

Opmerking

De gegevenscache is thread-veilig, dus u hoeft geen threadtoegang te synchroniseren voor eenvoudige lees- of schrijfbewerkingen. Als u echter meerdere bewerkingen moet uitvoeren op gegevens in de cache die atomisch moeten zijn, bent u verantwoordelijk voor het implementeren van een vergrendeling of een ander mechanisme om de veiligheid van threads te garanderen. Zie Synchronisatie van toegang tot de ASP.NET-cache voor meer informatie.

Een item kan programmatisch worden verwijderd uit de gegevenscache met behulp van de Remove methode als volgt:

Cache.Remove(key);

Stap 3: Productinformatie uit deProductsCLklasse retourneren

Voor deze zelfstudie gaan we twee methoden implementeren voor het retourneren van productinformatie uit de ProductsCL klasse: GetProducts() en GetProductsByCategoryID(categoryID). Net als bij de ProductsBL klasse in de bedrijfslogicalaag retourneert de GetProducts() methode in de CL informatie over alle producten als een Northwind.ProductsDataTable object, terwijl GetProductsByCategoryID(categoryID) alle producten uit een opgegeven categorie worden geretourneerd.

De volgende code toont een deel van de methoden in de ProductsCL klasse:

[System.ComponentModel.DataObject]
public class ProductsCL
{
    private ProductsBLL _productsAPI = null;
    protected ProductsBLL API
    {
        get
        {
            if (_productsAPI == null)
                _productsAPI = new ProductsBLL();
            return _productsAPI;
        }
    }
    
   [System.ComponentModel.DataObjectMethodAttribute(DataObjectMethodType.Select, true)]
    public Northwind.ProductsDataTable GetProducts()
    {
        const string rawKey = "Products";
        // See if the item is in the cache
        Northwind.ProductsDataTable products = _
            GetCacheItem(rawKey) as Northwind.ProductsDataTable;
        if (products == null)
        {
            // Item not found in cache - retrieve it and insert it into the cache
            products = API.GetProducts();
            AddCacheItem(rawKey, products);
        }
        return products;
    }
    
    [System.ComponentModel.DataObjectMethodAttribute(DataObjectMethodType.Select, false)]
    public Northwind.ProductsDataTable GetProductsByCategoryID(int categoryID)
    {
        if (categoryID < 0)
            return GetProducts();
        else
        {
            string rawKey = string.Concat("ProductsByCategory-", categoryID);
            // See if the item is in the cache
            Northwind.ProductsDataTable products = _
                GetCacheItem(rawKey) as Northwind.ProductsDataTable;
            if (products == null)
            {
                // Item not found in cache - retrieve it and insert it into the cache
                products = API.GetProductsByCategoryID(categoryID);
                AddCacheItem(rawKey, products);
            }
            return products;
        }
    }
}

Noteer eerst de DataObject en DataObjectMethodAttribute kenmerken die zijn toegepast op de klasse en methoden. Deze kenmerken bieden informatie aan de wizard ObjectDataSources, waarmee wordt aangegeven welke klassen en methoden moeten worden weergegeven in de stappen van de wizard. Omdat de CL-klassen en -methoden worden geopend vanuit een ObjectDataSource in de presentatielaag, heb ik deze kenmerken toegevoegd om de ontwerptijd te verbeteren. Raadpleeg de zelfstudie Een bedrijfslogicalaag maken voor een uitgebreidere beschrijving van deze kenmerken en de bijbehorende effecten.

In de GetProducts() en GetProductsByCategoryID(categoryID) methoden worden de gegevens die worden geretourneerd uit de GetCacheItem(key) methode toegewezen aan een lokale variabele. De GetCacheItem(key) methode die we binnenkort gaan onderzoeken, retourneert een bepaald item uit de cache op basis van de opgegeven sleutel. Als dergelijke gegevens niet in de cache worden gevonden, worden deze opgehaald uit de bijbehorende ProductsBLL klassemethode en vervolgens aan de cache toegevoegd met behulp van de AddCacheItem(key, value) methode.

De GetCacheItem(key)- en AddCacheItem(key, value)-methoden werken met de gegevenscache en lezen respectievelijk schrijven zij waarden. De GetCacheItem(key) methode is de eenvoudigere van de twee. De waarde van de Cache-klasse wordt gewoon geretourneerd met behulp van de doorgegeven sleutel:

private object GetCacheItem(string rawKey)
{
    return HttpRuntime.Cache[GetCacheKey(rawKey)];
}
private readonly string[] MasterCacheKeyArray = {"ProductsCache"};
private string GetCacheKey(string cacheKey)
{
    return string.Concat(MasterCacheKeyArray[0], "-", cacheKey);
}

GetCacheItem(key) gebruikt geen sleutelwaarde zoals opgegeven, maar roept in plaats daarvan de GetCacheKey(key) methode aan, die de sleutel retourneert die is voorafgegaan door ProductsCache-. De MasterCacheKeyArray, die de tekenreeks ProductsCache bevat, wordt ook gebruikt door de AddCacheItem(key, value) methode, zoals we zo meteen zullen zien.

Vanaf een ASP.NET code-behind-klasse van een pagina kan de gegevenscache worden geopend met behulp van de Page eigenschap klasse Cacheen kan de syntaxis, zoals Cache["key"] = valuebeschreven in stap 2, worden gebruikt. Vanuit een klasse in de architectuur kan de gegevenscache worden geopend met behulp van HttpRuntime.Cache of HttpContext.Current.Cache. Peter Johnson's blogbericht HttpRuntime.Cache vs. HttpContext.Current.Cache noteert het lichte prestatievoordeel in het gebruik HttpRuntime in plaats van HttpContext.Current; dus ProductsCL gebruikt HttpRuntime.

Opmerking

Als uw architectuur is geïmplementeerd met behulp van klassebibliotheekprojecten, moet u een verwijzing naar de System.Web assembly toevoegen om de klassen HttpRuntime en HttpContext te kunnen gebruiken.

Als het item niet in de cache wordt gevonden, haalt de ProductsCL klassemethode de gegevens op uit de BLL en voegt u het toe aan de cache met behulp van de AddCacheItem(key, value) methode. Als u waarde wilt toevoegen aan de cache, kunnen we de volgende code gebruiken, die een verlooptijd van 60 seconden gebruikt:

const double CacheDuration = 60.0;
private void AddCacheItem(string rawKey, object value)
{
    HttpRuntime.Cache.Insert(GetCacheKey(rawKey), value, null, 
        DateTime.Now.AddSeconds(CacheDuration), Caching.Cache.NoSlidingExpiration);
}

DateTime.Now.AddSeconds(CacheDuration) geeft de op tijd gebaseerde verlooptijd 60 seconden in de toekomst aan, terwijl System.Web.Caching.Cache.NoSlidingExpiration wordt aangegeven dat er geen verschuivende vervaldatum is. Hoewel deze overbelasting van de Insert methode invoerparameters bevat voor zowel een absolute als een verschuivende vervaldatum, kunt u slechts een van de twee opgeven. Als u zowel een absolute tijd als een tijdspanne probeert op te geven, genereert de Insert methode een ArgumentException uitzondering.

Opmerking

Deze implementatie van de AddCacheItem(key, value) methode heeft momenteel enkele tekortkomingen. Deze problemen worden in Stap 4 aangepakt en opgelost.

Stap 4: de cache ongeldig maken wanneer de gegevens worden gewijzigd via de architectuur

Naast methoden voor het ophalen van gegevens moet de cachelaag dezelfde methoden bieden als de BLL voor het invoegen, bijwerken en verwijderen van gegevens. De methoden voor het wijzigen van CL-gegevens wijzigen de gegevens in de cache niet, maar roepen de bijbehorende methode voor gegevenswijziging van de BLL aan en maken vervolgens de cache ongeldig. Zoals we in de vorige zelfstudie hebben gezien, is dit hetzelfde gedrag dat de ObjectDataSource toepast wanneer de cachefuncties zijn ingeschakeld en Insertde bijbehorende , Updateof Delete methoden worden aangeroepen.

De volgende UpdateProduct overbelasting laat zien hoe u de methoden voor het wijzigen van gegevens in de CL implementeert:

[System.ComponentModel.DataObjectMethodAttribute(DataObjectMethodType.Update, false)]
public bool UpdateProduct(string productName, decimal? unitPrice, int productID)
{
    bool result = API.UpdateProduct(productName, unitPrice, productID);
    // TODO: Invalidate the cache
    return result;
}

De juiste methode voor het wijzigen van bedrijfslogicalaag wordt aangeroepen, maar voordat het antwoord wordt geretourneerd, moeten we de cache ongeldig maken. Het ongeldig maken van de cache is helaas niet eenvoudig omdat de ProductsCL klassen GetProducts() en GetProductsByCategoryID(categoryID) methoden elk items met verschillende sleutels toevoegen aan de cache en de GetProductsByCategoryID(categoryID) methode een ander cache-item toevoegt voor elke unieke categorie-id.

Bij het ongeldig maken van de cache moeten we alle items verwijderen die mogelijk door de ProductsCL klasse zijn toegevoegd. Dit kan worden bereikt door een cacheafhankelijkheid te koppelen aan het item dat aan de cache is toegevoegd in de AddCacheItem(key, value) methode. Over het algemeen kan een cacheafhankelijkheid een ander item in de cache, een bestand op het bestandssysteem of gegevens uit een Microsoft SQL Server-database zijn. Wanneer de afhankelijkheid wordt gewijzigd of uit de cache wordt verwijderd, worden de cache-items die eraan zijn gekoppeld, automatisch uit de cache verwijderd. Voor deze zelfstudie willen we een extra item in de cache maken dat fungeert als een cacheafhankelijkheid voor alle items die via de ProductsCL klasse worden toegevoegd. Op die manier kunnen al deze items uit de cache worden verwijderd door simpelweg de afhankelijkheid van de cache te verwijderen.

We gaan de AddCacheItem(key, value) methode bijwerken zodat elk item dat via deze methode aan de cache is toegevoegd, is gekoppeld aan één cacheafhankelijkheid:

private void AddCacheItem(string rawKey, object value)
{
    System.Web.Caching.Cache DataCache = HttpRuntime.Cache;
    // Make sure MasterCacheKeyArray[0] is in the cache - if not, add it
    if (DataCache[MasterCacheKeyArray[0]] == null)
        DataCache[MasterCacheKeyArray[0]] = DateTime.Now;
    // Add a CacheDependency
    System.Web.Caching.CacheDependency dependency = 
        new CacheDependency(null, MasterCacheKeyArray);
    DataCache.Insert(GetCacheKey(rawKey), value, dependency, 
        DateTime.Now.AddSeconds(CacheDuration), 
        System.Web.Caching.Cache.NoSlidingExpiration);
}

MasterCacheKeyArray is een tekenreeksmatrix die één waarde bevat, ProductsCache. Eerst wordt een cache-item toegevoegd aan de cache en wordt de huidige datum en tijd toegewezen. Als het cache-item al bestaat, wordt het bijgewerkt. Vervolgens wordt er een cacheafhankelijkheid gemaakt. De CacheDependency klasseconstructor heeft een aantal overbelastingen, maar de klasse waarin hier wordt gebruikt, verwacht twee string matrixinvoer. De eerste geeft de set bestanden op die moeten worden gebruikt als afhankelijkheden. Omdat we geen afhankelijkheden op basis van bestanden willen gebruiken, wordt een waarde gebruikt null voor de eerste invoerparameter. De tweede invoerparameter geeft de set cachesleutels op die moeten worden gebruikt voor afhankelijkheden. Hier geven we onze individuele afhankelijkheid op. MasterCacheKeyArray De CacheDependency methode wordt vervolgens doorgegeven aan de Insert methode.

Wanneer deze wijziging aan AddCacheItem(key, value) is aangebracht, is het ongeldig maken van de cache net zo eenvoudig als het verwijderen van de afhankelijkheid.

[System.ComponentModel.DataObjectMethodAttribute(DataObjectMethodType.Update, false)]
public bool UpdateProduct(string productName, decimal? unitPrice, int productID)
{
    bool result = API.UpdateProduct(productName, unitPrice, productID);
    // Invalidate the cache
    InvalidateCache();
    return result;
}
public void InvalidateCache()
{
    // Remove the cache dependency
    HttpRuntime.Cache.Remove(MasterCacheKeyArray[0]);
}

Stap 5: de cachelaag aanroepen vanuit de presentatielaag

De klassen en methoden van de cachelaag kunnen worden gebruikt om met gegevens te werken met behulp van de technieken die we in deze zelfstudies hebben onderzocht. Als u wilt illustreren hoe u met gegevens in de cache werkt, slaat u de wijzigingen in de ProductsCL klasse op en opent u de FromTheArchitecture.aspx pagina in de Caching map en voegt u een GridView toe. Maak vanuit de infotag van GridView een nieuwe ObjectDataSource. In de eerste stap van de wizard ziet u de ProductsCL klasse als een van de opties in de vervolgkeuzelijst.

Afbeelding 4: De ProductsCL klasse is opgenomen in de lijst met zakelijke objecten Drop-Down (klik hier om de volledige afbeelding weer te geven)

Klik na het ProductsCLselecteren op Volgende. De vervolgkeuzelijst in het tabblad SELECT bevat twee items - GetProducts() en GetProductsByCategoryID(categoryID) - en het tabblad BIJWERKEN heeft de enige UpdateProduct overload. Kies de GetProducts() methode op het tabblad SELECT en de UpdateProducts methode op het tabblad UPDATE en klik op Voltooien.

Afbeelding 5: De ProductsCL methoden van de klasse worden vermeld in de Drop-Down-lijsten (klik om de afbeelding op volledige grootte weer te geven)

Nadat de wizard is voltooid, stelt Visual Studio de OldValuesParameterFormatString eigenschap van ObjectDataSource in op original_{0} en voegt het de juiste velden toe aan de GridView. Wijzig de eigenschap weer in de OldValuesParameterFormatString standaardwaarde {0}en configureer de GridView om paging, sortering en bewerking te ondersteunen. Aangezien de UploadProducts overbelasting die door de CL wordt gebruikt alleen de naam en prijs van het bewerkte product accepteert, beperkt u de GridView zodat alleen deze velden kunnen worden bewerkt.

In de voorgaande zelfstudie hebben we een GridView gedefinieerd om velden voor de ProductNameen CategoryNameUnitPrice velden op te nemen. U kunt deze opmaak en structuur repliceren. In dat geval moeten de declaratieve markeringen van GridView en ObjectDataSource er ongeveer als volgt uitzien:

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

Op dit moment hebben we een pagina die gebruikmaakt van de cachelaag. Als u de cache in actie wilt zien, stelt u onderbrekingspunten in de ProductsCL klassen GetProducts() en UpdateProduct methoden in. Ga naar de pagina in een browser en doorloop de code bij het sorteren en pagiëren om de gegevens te zien die uit de cache zijn opgehaald. Werk vervolgens een record bij en houd er rekening mee dat de cache ongeldig is en daarom wordt deze opgehaald uit de BLL wanneer de gegevens terugkeren naar de GridView.

Opmerking

De cachelaag in de download die bij dit artikel hoort, is niet voltooid. Het bevat slechts één klasse, ProductsCL die slechts een handvol methoden bevat. Bovendien gebruikt slechts één ASP.NET pagina de CL (~/Caching/FromTheArchitecture.aspx) alle andere nog steeds rechtstreeks naar de BLL verwijzen. Als u van plan bent om een CL in uw toepassing te gebruiken, moeten alle aanroepen van de presentatielaag naar de CL gaan. Hiervoor moeten de CL-klassen en -methoden alle klassen en methoden in de BLL, die momenteel door de presentatielaag worden gebruikt, omvatten.

Samenvatting

Hoewel caching kan worden toegepast op de Presentatielaag met de ASP.NET 2.0 SqlDataSource- en ObjectDataSource-besturingselementen, zouden de cachingverantwoordelijkheden idealiter worden gedelegeerd aan een afzonderlijke laag binnen de architectuur. In deze zelfstudie hebben we een cachelaag gemaakt die zich bevindt tussen de presentatielaag en de bedrijfslogicalaag. De cachelaag moet dezelfde set klassen en methoden opgeven die aanwezig zijn in de BLL en worden aangeroepen vanuit de presentatielaag.

De voorbeelden van cachelagen die we in deze en de voorgaande zelfstudies hebben bekeken vertonen reactief laden. Bij reactief laden worden de gegevens alleen in de cache geladen wanneer er een aanvraag voor de gegevens wordt gedaan en die gegevens ontbreken in de cache. Gegevens kunnen ook proactief in de cache worden geladen, een techniek waarmee de gegevens in de cache worden geladen voordat deze daadwerkelijk nodig zijn. In de volgende zelfstudie zien we een voorbeeld van proactief laden wanneer we kijken hoe statische waarden worden opgeslagen in de cache bij het opstarten van de toepassing.

Veel plezier met programmeren!

Over de auteur

Scott Mitchell, auteur van zeven ASP/ASP.NET-boeken en oprichter van 4GuysFromRolla.com, werkt sinds 1998 met Microsoft-webtechnologieën. Scott werkt als onafhankelijk consultant, trainer en schrijver. Zijn laatste boek is Sams Teach Yourself ASP.NET 2.0 in 24 uur. Hij kan worden bereikt op mitchell@4GuysFromRolla.com.

Speciale dank aan

Deze tutorialreeks is beoordeeld door veel behulpzame beoordelers. Hoofdbeoordelaar voor deze tutorial was Teresa Murph. Bent u geïnteresseerd in het bekijken van mijn aanstaande MSDN-artikelen? Zo ja, laat iets van je horen via mitchell@4GuysFromRolla.com.

VorigeVolgende