Ukládání dat do mezipaměti v architektuře (C#)

Scott Mitchell

Stáhnout PDF

V předchozím kurzu jsme se dozvěděli, jak použít ukládání do mezipaměti na prezentační vrstvě. V tomto kurzu se dozvíte, jak využít výhod naší vrstvené architektury k ukládání dat do mezipaměti ve vrstvě obchodní logiky. Provedeme to rozšířením architektury tak, aby zahrnovala vrstvu ukládání do mezipaměti.

Úvod

Jak jsme viděli v předchozím kurzu, ukládání dat ObjectDataSource do mezipaměti je stejně jednoduché jako nastavení několika vlastností. ObjectDataSource bohužel používá ukládání do mezipaměti na prezentační vrstvě, která těsně spojuje zásady ukládání do mezipaměti se stránkou ASP.NET. Jedním z důvodů pro vytvoření vrstvené architektury je umožnit přerušení těchto propojení. Například vrstva obchodní logiky odděluje obchodní logiku od ASP.NET stránek, zatímco vrstva přístupu k datům odděluje podrobnosti o přístupu k datům. Toto oddělení obchodní logiky a podrobností o přístupu k datům se upřednostňuje částečně proto, že systém je čitelnější, lépe udržovatelný a flexibilnější při změnách. Umožňuje také znalost domény a dělbu práce, kterou vývojář pracující na prezentační vrstvě nemusí znát s podrobnostmi databáze, aby mohl dělat svou práci. Oddělení zásad ukládání do mezipaměti od prezentační vrstvy nabízí podobné výhody.

V tomto kurzu rozšíříme naši architekturu o vrstvu ukládání do mezipaměti (zkráceně CL), která využívá naše zásady ukládání do mezipaměti. Vrstva ukládání do mezipaměti bude obsahovat ProductsCL třídu, která poskytuje přístup k informacím o produktu pomocí metod, jako GetProducts()jsou , GetProductsByCategoryID(categoryID)a tak dále, které se při vyvolání nejprve pokusí načíst data z mezipaměti. Pokud je mezipaměť prázdná, tyto metody vyvolají příslušnou ProductsBLL metodu v BLL, která by pak získala data z DAL. Metody ProductsCL ukládají data načtená z BLL před vrácením do mezipaměti.

Jak ukazuje obrázek 1, cl se nachází mezi vrstvami prezentace a obchodní logiky.

Obrázek 1: Vrstva ukládání do mezipaměti (CL) je další vrstvou v naší architektuře

Krok 1: Vytvoření tříd vrstev ukládání do mezipaměti

V tomto kurzu vytvoříme velmi jednoduchý cl s jednou třídou ProductsCL , která má jen několik metod. Vytvoření úplné vrstvy ukládání do mezipaměti pro celou aplikaci by vyžadovalo vytvoření CategoriesCLtříd , EmployeesCLa SuppliersCL a poskytnutí metody v těchto třídách vrstvy ukládání do mezipaměti pro každou metodu přístupu k datům nebo úpravu v BLL. Stejně jako u BLL a DAL, vrstva ukládání do mezipaměti by měla být v ideálním případě implementována jako samostatný projekt knihovny tříd; implementujeme ji však jako třídu ve App_Code složce.

Pokud chcete přesněji oddělit třídy CL od tříd DAL a BLL, vytvořte ve App_Code složce novou podsložku. Klikněte pravým tlačítkem na App_Code složku v Průzkumník řešení, zvolte Nová složka a pojmenujte novou složku CL. Po vytvoření této složky do ní přidejte novou třídu s názvem ProductsCL.cs.

Obrázek 2: Přidání nové složky s názvem a třídy s názvem CLProductsCL.cs

Třída ProductsCL by měla obsahovat stejnou sadu metod přístupu k datům a metod úprav, které najdete v odpovídající třídě vrstvy obchodní logiky (ProductsBLL). Nevytvořme všechny tyto metody, pojďme zde vytvořit pár, abyste získali přehled o vzorech používaných clem. Konkrétně přidáme GetProducts() metody a GetProductsByCategoryID(categoryID) v kroku 3 a UpdateProduct přetížení v kroku 4. Zbývající ProductsCL metody a třídy , EmployeesCLa CategoriesCLSuppliersCL můžete přidat podle svého volna.

Krok 2: Čtení a zápis do mezipaměti dat

Funkce ukládání do mezipaměti ObjectDataSource prozkoumáná v předchozím kurzu interně používá ASP.NET mezipaměť dat k ukládání dat načtených z BLL. K mezipaměti dat lze přistupovat také programově z tříd kódu ASP.NET stránek nebo z tříd v architektuře webových aplikací. Pokud chcete číst a zapisovat do mezipaměti dat z třídy kódu na pozadí ASP.NET stránky, použijte následující vzor:

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

Metoda Cache třídy s Insert má řadu přetížení. Cache["key"] = value a Cache.Insert(key, value) jsou synonyma a oba přidají položku do mezipaměti pomocí zadaného klíče bez definovaného vypršení platnosti. Obvykle chceme určit vypršení platnosti při přidávání položky do mezipaměti, a to buď jako závislost, vypršení platnosti na základě času, nebo obojí. K poskytnutí informací o vypršení platnosti na základě závislosti nebo času použijte jedno z přetížení Insert metody.

Metody vrstvy ukládání do mezipaměti musí nejprve zkontrolovat, jestli jsou požadovaná data v mezipaměti, a pokud ano, vrátit je odtud. Pokud požadovaná data nejsou v mezipaměti, je nutné vyvolat příslušnou metodu BLL. Její návratová hodnota by měla být uložena do mezipaměti a pak vrácena, jak znázorňuje následující sekvenční diagram.

Obrázek 3: Metody vrstvy ukládání do mezipaměti vracejí data z mezipaměti, pokud jsou k dispozici

Pořadí znázorněné na obrázku 3 se provádí ve třídách CL pomocí následujícího vzoru:

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

Typ je typ dat uložených v mezipaměti Northwind.ProductsDataTable, například klíč je klíč, který jedinečně identifikuje položku mezipaměti. Pokud položka se zadaným klíčem není v mezipaměti, instance bude null a data se načtou z příslušné metody BLL a přidají se do mezipaměti. V době return instancedosažení instance obsahuje odkaz na data, a to buď z mezipaměti, nebo z BLL.

Při přístupu k datům z mezipaměti nezapomeňte použít výše uvedený vzor. Následující vzor, který na první pohled vypadá stejně, obsahuje drobný rozdíl, který představuje konflikt časování. Podmínky časování se obtížně ladí, protože se zobrazují jen občas a obtížně se reprodukují.

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

Rozdíl v tomto druhém, nesprávném fragmentu kódu spočívá v tom, že místo uložení odkazu na položku v mezipaměti do místní proměnné se k mezipaměti dat přistupuje přímo v podmíněném příkazu a v return. Představte si, Cache["key"] že při dosažení tohoto kódu není-null, ale před dosažením return příkazu systém vyřadí klíč z mezipaměti. V tomto vzácném případě vrátí kód null místo objektu očekávaného typu hodnotu.

Poznámka

Mezipaměť dat je bezpečná pro přístup z více vláken, takže nemusíte synchronizovat přístup z vlákna pro jednoduché čtení nebo zápisy. Pokud ale potřebujete s daty v mezipaměti provést více operací, které musí být atomické, zodpovídáte za implementaci zámku nebo jiného mechanismu, který zajistí bezpečnost vláken. Další informace najdete v tématu Synchronizace přístupu k mezipaměti ASP.NET .

Položku je možné programově vyřadit z mezipaměti dat pomocí Remove metody takto:

Cache.Remove(key);

Krok 3: Vrácení informací o produktu zProductsCLtřídy

V tomto kurzu implementujme dvě metody pro vrácení informací o produktu z ProductsCL třídy: GetProducts() a GetProductsByCategoryID(categoryID). ProductsBL Stejně jako u třídy ve vrstvě obchodní logiky GetProducts() vrátí metoda v CL informace o všech produktech jako Northwind.ProductsDataTable objekt, zatímco GetProductsByCategoryID(categoryID) vrátí všechny produkty ze zadané kategorie.

Následující kód ukazuje část metod ve ProductsCL třídě:

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

Nejprve si všimněte DataObject atributů a DataObjectMethodAttribute použitých na třídu a metody. Tyto atributy poskytují informace do průvodce ObjectDataSource s, které označují, jaké třídy a metody by se měly zobrazit v krocích průvodce s. Vzhledem k tomu, že třídy a metody CL budou přístupné z ObjectDataSource v prezentační vrstvě, přidal jsem tyto atributy pro zlepšení návrhu prostředí. Podrobnější popis těchto atributů a jejich účinků najdete v kurzu Vytvoření vrstvy obchodní logiky .

V metodách GetProducts() a GetProductsByCategoryID(categoryID) jsou data vrácená GetCacheItem(key) z metody přiřazena k místní proměnné. Metoda GetCacheItem(key) , kterou za chvíli prozkoumáme, vrátí konkrétní položku z mezipaměti na základě zadaného klíče. Pokud se v mezipaměti nenajdou žádná taková data, načtou se z odpovídající ProductsBLL metody třídy a pak se do mezipaměti přidají pomocí AddCacheItem(key, value) metody .

Metody GetCacheItem(key) a AddCacheItem(key, value) jsou v rozhraní s datovou mezipamětí, čtením a zápisem hodnot. Metoda GetCacheItem(key) je jednodušší z těchto dvou. Jednoduše vrátí hodnotu z třídy Cache pomocí předaného klíče:

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) nepoužívá hodnotu klíče , jak bylo zadáno, ale místo toho volá metodu GetCacheKey(key) , která vrátí klíč předem s ProductsCache-. Metoda MasterCacheKeyArraypoužívá také AddCacheItem(key, value) řetězec , který obsahuje řetězec ProductsCache, jak uvidíme na chvíli.

Z třídy kódu na pozadí ASP.NET stránky je možné přistupovat k mezipaměti dat pomocí Page vlastnosti třídy s Cachea umožňuje syntaxi, jako Cache["key"] = valueje , jak je popsáno v kroku 2. Z třídy v rámci architektury je k mezipaměti dat přístup pomocí nebo HttpRuntime.CacheHttpContext.Current.Cache. Položka blogu Petera JohnsonaHttpRuntime.Cache vs. HttpContext.Current.Cache si všímá mírné výhody výkonu při použití HttpRuntime místo HttpContext.Current; v ProductsCL důsledku toho používá HttpRuntime.

Poznámka

Pokud je vaše architektura implementovaná pomocí projektů knihovny tříd, budete muset přidat odkaz na System.Web sestavení, aby bylo možné používat třídy HttpRuntime a HttpContext .

Pokud položka není nalezena v mezipaměti, ProductsCL metody třídy s načtou data z BLL a přidají je do mezipaměti pomocí AddCacheItem(key, value) metody . K přidání hodnoty do mezipaměti bychom mohli použít následující kód, který používá vypršení platnosti 60 sekund:

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) určuje časový limit 60 sekund v budoucnu, zatímco System.Web.Caching.Cache.NoSlidingExpiration indikuje, že nedochází k žádnému posunu. I když má tato Insert metoda vstupní parametry pro absolutní i posuvné vypršení platnosti, můžete zadat pouze jeden z těchto dvou parametrů. Pokud se pokusíte zadat absolutní čas i časový rozsah, Insert metoda vyvolá ArgumentException výjimku.

Poznámka

Tato implementace metody má AddCacheItem(key, value) v současné době určité nedostatky. Tyto problémy vyřešíme a vyřešíme v kroku 4.

Krok 4: Zneplatnění mezipaměti při úpravě dat prostřednictvím architektury

Spolu s metodami načítání dat musí vrstva ukládání do mezipaměti poskytovat stejné metody jako BLL pro vkládání, aktualizaci a odstraňování dat. Metody úpravy dat CL s neupravují data uložená v mezipaměti, ale spíše volají metodu úpravy dat odpovídající BLL a pak zneplatní mezipaměť. Jak jsme viděli v předchozím kurzu, jedná se o stejné chování, které používá ObjectDataSource, když jsou povoleny funkce ukládání do mezipaměti a jsou vyvolány jeho Insertmetody , Updatenebo Delete .

Následující UpdateProduct přetížení ukazuje, jak implementovat metody úpravy dat v modulu CL:

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

Vyvolá se příslušná úprava dat metoda Vrstva obchodní logiky, ale před vrácením odpovědi musíme zneplatnit mezipaměť. Zneplatnění mezipaměti bohužel není jednoduché, protože ProductsCL třídy s GetProducts() a GetProductsByCategoryID(categoryID) metody přidají do mezipaměti položky s různými klíči a GetProductsByCategoryID(categoryID) metoda přidá jinou položku mezipaměti pro každé jedinečné ID kategorie.

Při zneplatnění mezipaměti musíme odebrat všechny položky, které mohly být přidány ProductsCL třídou. Toho lze dosáhnout přidružením závislosti mezipaměti s každou položkou přidanou do mezipaměti v AddCacheItem(key, value) metodě. Obecně platí, že závislost mezipamětí může být jiná položka v mezipaměti, soubor v systému souborů nebo data z databáze Microsoft SQL Server. Když se závislost změní nebo odebere z mezipaměti, položky mezipaměti, ke kterým je přidružená, se z mezipaměti automaticky vyřadí. Pro účely tohoto kurzu chceme v mezipaměti vytvořit další položku, která slouží jako závislost mezipaměti pro všechny položky přidané prostřednictvím ProductsCL třídy. Tímto způsobem lze všechny tyto položky z mezipaměti odebrat jednoduše odebráním závislosti mezipaměti.

Pojďme aktualizovat metodu AddCacheItem(key, value) tak, aby každá položka přidaná do mezipaměti prostřednictvím této metody byla přidružená k jedné závislosti mezipaměti:

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 je pole řetězců, které obsahuje jednu hodnotu, ProductsCache. Nejprve se do mezipaměti přidá položka mezipaměti a přiřadí se aktuální datum a čas. Pokud položka mezipaměti již existuje, aktualizuje se. Dále se vytvoří závislost mezipaměti. Konstruktor CacheDependency třídy s má řadu přetížení, ale ten, který se zde používá, očekává dva string vstupy pole. První z nich určuje sadu souborů, které se mají použít jako závislosti. Vzhledem k tomu, že nechceme použít žádné závislosti založené na souborech, použije se pro první vstupní parametr hodnota .null Druhý vstupní parametr určuje sadu klíčů mezipaměti, které se mají použít jako závislosti. Zde určíme naši jedinou závislost, MasterCacheKeyArray. Potom CacheDependency se předá metodě Insert .

Při této úpravě AddCacheItem(key, value)je zneplatnění mezipaměti stejně jednoduché jako odebrání závislosti.

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

Krok 5: Volání vrstvy ukládání do mezipaměti z prezentační vrstvy

Třídy a metody vrstvy ukládání do mezipaměti je možné použít k práci s daty pomocí technik, které jsme prozkoumali v těchto kurzech. Pokud chcete ilustrovat práci s daty uloženými v mezipaměti, uložte změny do ProductsCL třídy a pak otevřete FromTheArchitecture.aspx stránku ve Caching složce a přidejte GridView. Z inteligentní značky GridView vytvořte nový ObjectDataSource. V prvním kroku průvodce byste měli vidět ProductsCL třídu jako jednu z možností z rozevíracího seznamu.

Obrázek 4: Třída ProductsCL je zahrnutá v seznamu Drop-Down obchodních objektů (kliknutím zobrazíte obrázek v plné velikosti)

Po výběru ProductsCLklikněte na Další. Rozevírací seznam na kartě SELECT obsahuje dvě položky – GetProducts() a GetProductsByCategoryID(categoryID) karta UPDATE má jediné UpdateProduct přetížení. Zvolte metodu na GetProducts() kartě SELECT a metodu UpdateProducts na kartě UPDATE a klikněte na Dokončit.

Obrázek 5: Metody ProductsCL třídy jsou uvedené v Drop-Down Seznamy (kliknutím zobrazíte obrázek v plné velikosti)

Po dokončení průvodce sada Visual Studio nastaví vlastnost original_{0} ObjectDataSource na OldValuesParameterFormatString a přidá příslušná pole do objektu GridView. OldValuesParameterFormatString Změňte vlastnost zpět na výchozí hodnotu {0}a nakonfigurujte GridView tak, aby podporoval stránkování, řazení a úpravy. Vzhledem k tomu, UploadProducts že přetížení používané cl přijímá pouze upravený název produktu a cenu, omezte GridView tak, aby bylo možné upravovat pouze tato pole.

V předchozím kurzu jsme definovali Objekt GridView tak, aby zahrnoval pole pro ProductNamepole , CategoryNamea UnitPrice . Nebojte se replikovat toto formátování a strukturu. V takovém případě by deklarativní značky GridView a ObjectDataSource měly vypadat nějak takto:

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

V tuto chvíli máme stránku, která používá vrstvu ukládání do mezipaměti. Pokud chcete zobrazit mezipaměť v akci, nastavte zarážky ve třídách ProductsCL s GetProducts() a UpdateProduct metodách. Navštivte stránku v prohlížeči a projděte si kód při řazení a stránkování, abyste viděli data získaná z mezipaměti. Potom aktualizujte záznam a všimněte si, že mezipaměť je neplatná a v důsledku toho se načte z BLL, když se data znovu doskočí do objektu GridView.

Poznámka

Vrstva ukládání do mezipaměti uvedená v souboru ke stažení připojeném k tomuto článku není dokončená. Obsahuje pouze jednu třídu, ProductsCL, která sportuje pouze několik metod. Kromě toho pouze jedna ASP.NET stránka používá cl (~/Caching/FromTheArchitecture.aspx), všechny ostatní stále odkazují na BLL přímo. Pokud plánujete používat cl ve vaší aplikaci, všechna volání z prezentační vrstvy by měla přejít na CL, což by vyžadovalo, aby třídy a metody CL s pokrývaly tyto třídy a metody v BLL aktuálně používané prezentační vrstvou.

Souhrn

Ukládání do mezipaměti lze použít na prezentační vrstvě s ovládacími prvky SqlDataSource a ObjectDataSource ASP.NET 2.0 s, v ideálním případě by se odpovědnosti za ukládání do mezipaměti delegovaly na samostatnou vrstvu v architektuře. V tomto kurzu jsme vytvořili vrstvu ukládání do mezipaměti, která se nachází mezi prezentační vrstvou a vrstvou obchodní logiky. Vrstva ukládání do mezipaměti musí poskytovat stejnou sadu tříd a metod, které existují v BLL a jsou volána z prezentační vrstvy.

Příklady vrstvy ukládání do mezipaměti, které jsme prozkoumali v tomto a předchozích kurzech, vykazovaly reaktivní načítání. Při reaktivním načítání se data načtou do mezipaměti pouze v případě, že je proveden požadavek na data a tato data v mezipaměti chybí. Data je také možné proaktivně načítat do mezipaměti, a to je technika, která načte data do mezipaměti dříve, než je skutečně potřeba. V dalším kurzu uvidíme příklad proaktivního načítání, když se podíváme, jak ukládat statické hodnoty do mezipaměti při spuštění aplikace.

Šťastné programování!

O autorovi

Scott Mitchell, autor sedmi knih o ASP/ASP.NET a zakladatel 4GuysFromRolla.com, pracuje s webovými technologiemi Microsoftu od roku 1998. Scott pracuje jako nezávislý konzultant, školitel a spisovatel. Jeho nejnovější kniha je Sams Teach Yourself ASP.NET 2.0 in 24 Hours. Můžete ho najít na mitchell@4GuysFromRolla.comadrese . nebo prostřednictvím jeho blogu, který najdete na http://ScottOnWriting.NETadrese .

Zvláštní poděkování

Tato série kurzů byla zkontrolována mnoha užitečnými recenzenty. Hlavní revidující pro tento kurz byla Teresa Murph. Chcete si projít moje nadcházející články na WEBU MSDN? Pokud ano, dejte mi čáru na mitchell@4GuysFromRolla.comadresu .

PředchozíDalší