Adatok gyorsítótárazása az architektúrában (C#)

által Scott Mitchell

PDF letöltése

Az előző oktatóanyagban megtanultuk, hogyan alkalmazható a gyorsítótárazás a bemutatórétegen. Ebben az oktatóanyagban megtanuljuk, hogyan használhatja ki a rétegzett architektúrát az adatok gyorsítótárazásához az üzleti logikai rétegben. Ezt úgy hajtjuk végre, hogy kibővítjük az architektúrát egy gyorsítótárazási réteggel.

Bevezetés

Ahogy az előző oktatóanyagban láttuk, az ObjectDataSource adatainak gyorsítótárazása olyan egyszerű, mint néhány tulajdonság beállítása. Sajnos az ObjectDataSource gyorsítótárazást alkalmaz a bemutatórétegen, amely szorosan összekapcsolja a gyorsítótárazási szabályzatokat a ASP.NET oldallal. A rétegzett architektúra létrehozásának egyik oka, hogy lehetővé teszi az ilyen összekapcsolások megszakadását. Az üzleti logikai réteg például leválasztja az üzleti logikát a ASP.NET lapokról, míg az Adatelérési réteg leválasztja az adathozzáférési adatokat. Az üzleti logika és az adathozzáférés részleteinek elkülönítése részben azért előnyös, mert olvashatóbbá, karbantarthatóbbá és rugalmasabbá teszi a rendszert a változáshoz. Emellett lehetővé teszi a tartományi ismereteket és a munkamegosztást, ha a bemutató rétegen dolgozó fejlesztőnek nem kell ismernie az adatbázis adatait ahhoz, hogy elvégezhesse a munkáját. A gyorsítótár-kezelési szabály leválasztása a bemutatórétegről hasonló előnyökkel jár.

Ebben az oktatóanyagban kibővítjük az architektúrát, hogy tartalmazzon egy gyorsítótárazási réteget (vagy röviden CL-t), amely a gyorsítótárazási szabályzatot alkalmazza. A gyorsítótárazási réteg tartalmaz egy osztályt ProductsCL , amely hozzáférést biztosít a termékinformációkhoz olyan metódusokkal, mint a GetProducts(), GetProductsByCategoryID(categoryID)és így tovább, amelyek meghíváskor először megpróbálják lekérni az adatokat a gyorsítótárból. Ha a gyorsítótár üres, ezek a metódusok meghívják a megfelelő ProductsBLL metódust a BLL-ben, ami viszont lekéri az adatokat a DAL-ból. A ProductsCL metódusok a BLL-ből lekért adatokat gyorsítótárazzák, mielőtt visszaadják azokat.

Az 1. ábrán látható, hogy a CL a bemutató és az üzleti logikai rétegek között található.

1. ábra: A cache réteg (CL) egy további réteg az architektúránkban

1. lépés: A gyorsítótárazási rétegosztályok létrehozása

Ebben az oktatóanyagban egy nagyon egyszerű CL-t hozunk létre egyetlen osztálysal ProductsCL , amely csak néhány metódussal rendelkezik. A teljes alkalmazás gyorsítótárazási rétegének létrehozásához a CategoriesCL, EmployeesCL, és SuppliersCL osztályokat kell létrehozni, és metódust kell biztosítani ezekben a gyorsítótárazási rétegosztályokban a BLL minden adathozzáférési vagy módosítási módszeréhez. A BLL-hez és a DAL-hoz hasonlóan a gyorsítótárazási réteget is ideális esetben külön Osztálytár-projektként kell megvalósítani; azonban a mappában App_Code osztályként fogjuk implementálni.

A CL-osztályok és a DAL és a BLL osztályok pontosabb elkülönítéséhez hozzunk létre egy új almappát a App_Code mappában. Kattintson a jobb gombbal a App_Code megoldáskezelő mappájára, válassza az Új mappa lehetőséget, és nevezze el az új mappát CL. A mappa létrehozása után adjon hozzá egy új osztályt.ProductsCL.cs

2. ábra: Új névvel ellátott CL mappa és elnevezett osztály hozzáadása ProductsCL.cs

Az ProductsCL osztálynak ugyanazokat az adathozzáférési és -módosítási módszereket kell tartalmaznia, mint a megfelelő Üzleti logikai réteg osztályban (ProductsBLL). Ahelyett, hogy minden módszert létrehoznánk, készítsünk itt egy párat, hogy megtapasztaljuk a CL által használt mintákat. Különösen, a 3. lépésben hozzáadjuk a GetProducts() és GetProductsByCategoryID(categoryID) metódusokat, a 4. lépésben pedig egy UpdateProduct túlterhelést. Hozzáadhatja a fennmaradó ProductsCL metódusokat és CategoriesCL, EmployeesCL, valamint SuppliersCL osztályokat, amikor megfelelőnek érzi.

2. lépés: Olvasás és írás az adatgyorsítótárba

Az előző oktatóanyagban megismert ObjectDataSource gyorsítótárazási funkció belsőleg a ASP.NET adatgyorsítótárat használja a BLL-ből lekért adatok tárolására. Az adatgyorsítótár programozott módon is elérhető ASP.NET lapok mögötti osztályokból vagy a webalkalmazás architektúrájának osztályaiból. Ha egy ASP.NET lap kódjának háttérosztályából szeretne olvasni és írni az adatgyorsítótárba, használja az alábbi mintát:

// 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);

Az Cache sInsert osztály metódusa számos túlterheléssel rendelkezik. Cache["key"] = value és Cache.Insert(key, value) szinonimák, és mindkettő egy elemet ad a gyorsítótárhoz a megadott kulccsal, meghatározott lejárati idő nélkül. Általában lejárati időt szeretnénk megadni, amikor elemet adunk hozzá a gyorsítótárhoz függőségként, időalapú lejáratként vagy mindkettőként. A másik Insert metódus túlterhelésének egyikével függőségi vagy időalapú lejárati információkat adhat meg.

A gyorsítótárazási réteg metódusainak először ellenőriznie kell, hogy a kért adatok a gyorsítótárban vannak-e, és ha igen, onnan kell visszaadni. Ha a kért adatok nincsenek a gyorsítótárban, a megfelelő BLL-metódust kell meghívni. A visszatérési értéket először gyorsítótárazza, majd adja vissza, ahogy az alábbi szekvenciadiagram szemlélteti.

3. ábra: A gyorsítótárazási réteg metódusai adatokat adnak vissza a gyorsítótárból, ha elérhető

A 3. ábrán ábrázolt sorozat a CL-osztályokban a következő mintával valósul meg:

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

Itt a Típus a gyorsítótárban Northwind.ProductsDataTabletárolt adatok típusa, például a kulcs az a kulcs, amely egyedileg azonosítja a gyorsítótár-elemet. Ha a megadott kulccsal rendelkező elem nincs a gyorsítótárban, akkor a példány lesz null , és az adatok a megfelelő BLL-metódusból lesznek lekérve, és hozzáadva a gyorsítótárhoz. Amikor return instance elérésre kerül, a példány tartalmaz egy hivatkozást az adatokra, akár a gyorsítótárból, akár a BLL-ből lekérve.

Ügyeljen arra, hogy a fenti mintát használja a gyorsítótárból származó adatok elérésekor. Az alábbi minta, amely első pillantásra egyenértékűnek tűnik, finom különbséget tartalmaz, amely versenyhelyzetet vezet be. A versenyhelyzeteket nehéz hibakeresni, mert ritkán mutatkoznak meg, és nehezen reprodukálhatók.

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

Ebben a második, helytelen kódrészletben az a különbség, hogy ahelyett, hogy a gyorsítótárazott elemre mutató hivatkozást tárolna egy helyi változóban, az adatgyorsítótár közvetlenül elérhető a feltételes utasításban és a return-ben. Tegyük fel, hogy amikor a Cache["key"] kódot elérjük, a rendszer nem null, de mielőtt elérnénk az return utasítást, a rendszer kiüríti a kulcsot a gyorsítótárból. Ebben a ritka esetben a kód a várt típusú objektum helyett egy null értéket ad vissza.

Megjegyzés:

Az adatgyorsítótár szálbiztos, így nem kell szinkronizálnia a szálhozzáférést az egyszerű olvasásokhoz vagy írásokhoz. Ha azonban több olyan műveletet kell végrehajtania a gyorsítótárban lévő adatokon, amelyek atomizáltnak kell lenniük, akkor Ön felelős egy zárolás vagy más mechanizmus implementálásáért a szálbiztonság biztosítása érdekében. További információt a ASP.NET Cache hozzáférésének szinkronizálása című témakörben talál.

Az elemek programozott módon kiüríthetők az adatgyorsítótárból a Remove következő módszerrel :

Cache.Remove(key);

3. lépés: Termékadatok visszaadása azProductsCLosztályból

Ebben az oktatóanyagban implementáljunk két módszert a termékinformációk osztályból ProductsCL való visszaadására: GetProducts() és GetProductsByCategoryID(categoryID). Az üzleti logikai réteg osztályához ProductsBL hasonlóan a GetProducts() CL metódus az összes termékre vonatkozó információt adja vissza objektumként Northwind.ProductsDataTable , míg GetProductsByCategoryID(categoryID) egy adott kategóriából származó összes terméket.

Az alábbi kód az osztály metódusainak ProductsCL egy részét mutatja be:

[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;
        }
    }
}

Először jegyezze fel az DataObject osztályra és DataObjectMethodAttribute metódusokra alkalmazott attribútumokat. Ezek az attribútumok információt nyújtanak az ObjectDataSource varázslójának, amely jelzi, hogy milyen osztályok és metódusok jelenjenek meg a varázsló lépéseiben. Mivel a CL-osztályok és metódusok a bemutatóréteg egyik ObjectDataSource-jából lesznek elérhetők, ezeket az attribútumokat hozzáadtam a tervezési idő élményének javítása érdekében. Tekintse meg az Üzleti logikai réteg létrehozása oktatóanyagot, amely részletesebb leírást biztosít ezekről az attribútumokról és azok hatásairól.

A GetProducts() és GetProductsByCategoryID(categoryID) metódusokban a GetCacheItem(key) metódusból visszaadott adatokat egy helyi változóhoz rendeljük. A GetCacheItem(key) rövidesen megvizsgálandó metódus egy adott elemet ad vissza a gyorsítótárból a megadott kulcs alapján. Ha nem találhatók ilyen adatok a gyorsítótárban, a rendszer lekéri a megfelelő ProductsBLL osztálymetódusból, majd hozzáadja a gyorsítótárhoz a AddCacheItem(key, value) metódus használatával.

A GetCacheItem(key) és AddCacheItem(key, value) metódusok az adatgyorsítótárral működnek, előbbi olvas, utóbbi pedig értékeket ír. A GetCacheItem(key) módszer a kettő közül az egyszerűbb. Egyszerűen visszaadja a Gyorsítótár osztály értékét az átadott kulccsal:

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) nem használja a megadott kulcsértéket , hanem meghívja a GetCacheKey(key) metódust, amely a ProductsCache-vel előre felerősített kulcsot adja vissza. A MasterCacheKeyArray, amely a ProductsCache sztringet tartalmaz, szintén használatban van a AddCacheItem(key, value) metódus által, amint azt hamarosan látni fogjuk.

Egy ASP.NET lap kód mögötti osztályából az adatgyorsítótár az osztály PageCache tulajdonságával érhető el, és lehetővé teszi az olyan szintaxis használatát, mint Cache["key"] = value, ahogyan azt a 2. lépés tárgyalja. A struktúrában lévő osztályból az adatgyorsítótár elérhető a HttpRuntime.Cache vagy a HttpContext.Current.Cache használatával. Peter Johnson blogbejegyzése HttpRuntime.Cache vs. HttpContext.Current.Cache megjegyzi a kis teljesítménybeli előnyt, ha HttpRuntime helyett HttpContext.Current-t használunk; ennek következtében ProductsCL használja a HttpRuntime-t.

Megjegyzés:

Ha az architektúra osztálytár-projektek használatával van implementálva, akkor a System.Web- és HttpContext-osztályok használatához hozzá kell adnia egy hivatkozást a szerelvényhez.

Ha az elem nem található a gyorsítótárban, az s osztály metódusai ProductsCL lekérik az adatokat a BLL-ből, és hozzáadják a gyorsítótárhoz a AddCacheItem(key, value) metódus használatával. Ha értéket szeretne hozzáadni a gyorsítótárhoz, a következő kódot használhatjuk, amely 60 másodperces lejárati időt használ:

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) az időalapú lejáratot adja meg 60 másodperccel a jövőben, miközben System.Web.Caching.Cache.NoSlidingExpiration azt jelzi, hogy nincs csúszó lejárat. Bár a Insert metódus túlterhelése rendelkezik bemeneti paraméterekkel mind az abszolút, mind a csúszó lejárathoz, a kettő közül csak az egyiket adhatja meg. Ha megkísérli megadni az abszolút időt és az időtartományt is, a Insert metódus kivételt ArgumentException fog eredményezni.

Megjegyzés:

A módszer ezen implementációja AddCacheItem(key, value) jelenleg hiányosságokat fedez fel. A problémákat a 4. lépésben fogjuk megoldani.

4. lépés: A gyorsítótár érvénytelenítése az adatok architektúrán keresztüli módosításakor

Az adatlekérési módszerek mellett a gyorsítótárazási rétegnek ugyanazokat a módszereket kell biztosítania, mint a BLL-nek az adatok beszúrásához, frissítéséhez és törléséhez. A CL adatmódosítási módszerei nem módosítják a gyorsítótárazott adatokat, hanem meghívják a BLL megfelelő adatmódosítási módszerét, majd érvényteleníti a gyorsítótárat. Ahogy az előző oktatóanyagban láttuk, ez ugyanaz a viselkedés, mint az ObjectDataSource esetében, amikor a gyorsítótárazási funkciók engedélyezve vannak, és a rendszer meghívja annak Insert, Updatevagy Delete metódusait.

Az alábbi UpdateProduct túlterhelés bemutatja, hogyan implementálható az adatmódosítási módszerek a CL-ben:

[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;
}

A rendszer meghívja a megfelelő adatmódosítási üzleti logikai réteg metódust, de a válasz visszaadása előtt érvényteleníteni kell a gyorsítótárat. A gyorsítótár érvénytelenítésének sajnos nem egyszerű, mert az ProductsCL egyes GetProducts() osztályok és GetProductsByCategoryID(categoryID) metódusok különböző kulcsokkal adnak hozzá elemeket a gyorsítótárhoz, és a GetProductsByCategoryID(categoryID) metódus minden egyes egyedi kategóriaazonosítóhoz más-más gyorsítótár-elemet ad hozzá.

A gyorsítótár érvénytelenítéséhez el kell távolítanunk az osztály által esetleg hozzáadott ProductsCL elemet. Ez úgy érhető el, hogy társít egy gyorsítótár-függőséget a metódusban AddCacheItem(key, value) a gyorsítótárhoz hozzáadott egyes elemekkel. A gyorsítótárfüggőség általában lehet a gyorsítótár egy másik eleme, egy fájlrendszerbeli fájl vagy egy Microsoft SQL Server-adatbázis adatai. Amikor a függőség megváltozik, vagy eltávolítják a gyorsítótárból, a rendszer automatikusan kizárja a gyorsítótárból azokat a gyorsítótárelemeket, amelyekhez társítva van. Ebben az oktatóanyagban egy további elemet szeretnénk létrehozni a gyorsítótárban, amely gyorsítótárfüggőségként szolgál az ProductsCL osztályon keresztül hozzáadott összes elemhez. Így ezek az elemek egyszerűen eltávolíthatók a gyorsítótárból a gyorsítótár függőségének eltávolításával.

Frissítse a AddCacheItem(key, value) metódust úgy, hogy a gyorsítótárba ezzel a módszerrel hozzáadott elemek egyetlen gyorsítótár-függőséghez lesznek társítva:

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 Egy sztringtömb, amely egyetlen értéket ( ProductsCache) tartalmaz. Először hozzáad egy gyorsítótár-elemet a gyorsítótárhoz, és hozzárendeli az aktuális dátumot és időpontot. Ha a gyorsítótárelem már létezik, az frissül. Ezután létrejön egy gyorsítótár-függőség. Az CacheDependency osztálykonstruktor számos túlterheléssel rendelkezik, de az itt használt két tömbbemenetre számítstring. Az első megadja a függőségként használandó fájlok készletét. Mivel nem szeretnénk fájlalapú függőségeket használni, a rendszer az első bemeneti paraméter értékét null használja. A második bemeneti paraméter megadja a függőségként használandó gyorsítótárkulcsok készletét. Itt határozzuk meg az egyetlen függőséget, MasterCacheKeyArray. A CacheDependency metódus ezután átkerül a Insert metódusba.

Ezzel a módosítással AddCacheItem(key, value), a gyorsítótár érvénytelenítése tényleg olyan egyszerű, mint a függőség eltávolítása.

[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]);
}

5. lépés: A gyorsítótár réteg hívása a prezentációs rétegből

A gyorsítótárazási réteg osztályai és módszerei a teljes oktatóanyagban megvizsgált technikák segítségével használhatók az adatok kezelésére. A gyorsítótárazott adatokkal végzett munka szemléltetéséhez mentse az ProductsCL osztály módosításait, majd nyissa meg a FromTheArchitecture.aspx lapot a Caching mappában, és adjon hozzá egy GridView-t. A GridView intelligens címkéje alapján hozzon létre egy új ObjectDataSource-t. A varázsló első lépésében látnia kell a ProductsCL osztályt a legördülő lista egyik lehetőségeként.

4. ábra: Az ProductsCL osztály szerepel az üzleti objektum Drop-Down listájában (ide kattintva megtekintheti a teljes méretű képet)

A ProductsCL kijelölése után kattintson a Tovább gombra. A SELECT lapon található legördülő lista két elemet tartalmaz - GetProducts() és GetProductsByCategoryID(categoryID), az UPDATE lap pedig csak a UpdateProduct elemet tartalmazza. Válassza ki a metódust GetProducts() a SELECT lapról és a UpdateProducts metódust az UPDATE lapról, és kattintson a Befejezés gombra.

5. ábra: Az ProductsCL osztály metódusai szerepelnek a Drop-Down listákban (ide kattintva megtekintheti a teljes méretű képet)

A varázsló befejezése után a Visual Studio beállítja az ObjectDataSource OldValuesParameterFormatString tulajdonságotoriginal_{0}, és hozzáadja a megfelelő mezőket a GridView-hoz. Módosítsa a tulajdonságot az OldValuesParameterFormatString alapértelmezett értékre, {0}és konfigurálja a GridView-t a lapozás, a rendezés és a szerkesztés támogatására. Mivel a UploadProducts CL által használt túlterhelés csak a szerkesztett termék nevét és árát fogadja el, korlátozza a GridView-t, hogy csak ezek a mezők szerkeszthetők legyenek.

Az előző oktatóanyagban egy GridView-t határoztunk meg, amely tartalmazza a ProductName, CategoryName és UnitPrice mezőket. Nyugodtan replikálhatja ezt a formázást és struktúrát, ebben az esetben a GridView és az ObjectDataSource deklaratív korrektúrája az alábbihoz hasonlóan fog kinézni:

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

Ezen a ponton van egy oldalunk, amely a gyorsítótár rétegét használja. A gyorsítótár működés közbeni megtekintéséhez állítson be töréspontokat az ProductsCL osztályban és a GetProducts() és UpdateProduct metódusokban. Keresse fel a böngészőben a lapot, és rendezéskor és lapozáskor lépkedjen végig a kódon, hogy láthassa a gyorsítótárból lekért adatokat. Ezután frissítsen egy rekordot, és figyelje meg, hogy a gyorsítótár érvénytelen, ezért a rendszer lekéri azt a BLL-ből, amikor az adatok visszaérkeznek a GridView-ba.

Megjegyzés:

Az e cikkhez mellékelt letöltésben található gyorsítótárazási réteg nem teljes. Csak egy osztályt tartalmaz, ProductsCL, amely csak néhány módszerrel rendelkezik. Ezenkívül csak egyetlen ASP.NET oldal használja a CL-t (~/Caching/FromTheArchitecture.aspx) az összes többi továbbra is közvetlenül hivatkozik a BLL-re. Ha CL-t szeretne használni az alkalmazásban, a bemutatóréteg összes hívásának a CL-hez kell mennie, ami megköveteli, hogy a CL-osztályok és metódusok lefedjék a bemutatóréteg által jelenleg használt BLL-osztályokat és metódusokat.

Összefoglalás

Bár a gyorsítótárazást a bemutató rétegben ASP.NET 2.0 s SqlDataSource- és ObjectDataSource-vezérlőkkel lehet alkalmazni, ideális esetben a feladatok gyorsítótárazása az architektúra egy külön rétegére delegálható. Ebben az oktatóanyagban létrehoztunk egy gyorsítótárazási réteget, amely a bemutató réteg és az üzleti logikai réteg között található. A gyorsítótárazási rétegnek ugyanazokat az osztályokat és metódusokat kell biztosítania, amelyek a BLL-ben léteznek, és amelyeket a prezentációs réteg hív meg.

Az ebben és az előző oktatóanyagokban bemutatott gyorsítótárazási rétegbeli példák reaktív betöltést mutattak. Reaktív betöltéssel az adatok csak akkor töltődnek be a gyorsítótárba, ha az adatokra vonatkozó kérést intéznek, és az adatok hiányoznak a gyorsítótárból. Az adatok proaktív módon betölthetők a gyorsítótárba is, amely egy olyan technika, amely betölti az adatokat a gyorsítótárba, mielőtt ténylegesen szükség lenne rá. A következő oktatóanyagban láthatunk egy példát a proaktív betöltésre, amikor megnézzük, hogyan tárolhat statikus értékeket a gyorsítótárban az alkalmazás indításakor.

Boldog programozást!

Tudnivalók a szerzőről

Scott Mitchell, hét ASP/ASP.NET-könyv szerzője és a 4GuysFromRolla.com alapítója, 1998 óta dolgozik a Microsoft webtechnológiáival. Scott független tanácsadóként, edzőként és íróként dolgozik. Legújabb könyve Sams Tanuld meg ASP.NET 2.0 24 óra alatt. Ő itt elérhető mitchell@4GuysFromRolla.com.

Külön köszönet

Ezt az oktatóanyag-sorozatot sok hasznos véleményező áttekintette. Az oktatóanyag vezető véleményezője Teresa Murph volt. Szeretné áttekinteni a közelgő MSDN-cikkeimet? Ha igen, írj egy sort a mitchell@4GuysFromRolla.com-ra.

ElőzőKövetkező