Adatok gyorsítótárazása az ObjectDataSource -nal (C#)

által Scott Mitchell

PDF letöltése

A gyorsítótárazás jelentheti a lassú és a gyors webalkalmazások közötti különbséget. Ez az oktatóanyag a négy közül az első, amely részletesen áttekinti ASP.NET gyorsítótárazását. Ismerje meg a gyorsítótárazás fő fogalmait, és hogy hogyan alkalmazhat gyorsítótárazást a bemutatórétegre az ObjectDataSource vezérlőn keresztül.

Bevezetés

Az informatikában a gyorsítótárazás az a folyamat, amikor az elérésére költséges adatokat vagy információkat lemásoljuk és egy gyorsabban hozzáférhető helyen tároljuk. Az adatvezérelt alkalmazások esetében a nagy és összetett lekérdezések általában az alkalmazás végrehajtási idejének többségét fogyasztják. Az ilyen alkalmazások teljesítménye gyakran javítható a költséges adatbázis-lekérdezések eredményeinek az alkalmazás memóriájában való tárolásával.

ASP.NET 2.0 számos gyorsítótárazási lehetőséget kínál. A teljes weblap vagy a felhasználóvezérlő által renderelt korrektúra gyorsítótárazható a kimeneti gyorsítótárazással. Az ObjectDataSource és az SqlDataSource vezérlők gyorsítótárazási képességeket is biztosítanak, így lehetővé teszik az adatok gyorsítótárazását a vezérlés szintjén. ASP.NET adatgyorsítótár pedig gazdag gyorsítótárazási API-t biztosít, amely lehetővé teszi a lapfejlesztők számára az objektumok programozott gyorsítótárazását. Ebben az oktatóanyagban és a következő háromban megvizsgáljuk az ObjectDataSource gyorsítótárazási funkcióinak és az adatgyorsítótárnak a használatát. Azt is bemutatjuk, hogyan gyorsítótárazhatók az alkalmazásszintű adatok az indításkor, és hogyan tarthatók frissek a gyorsítótárazott adatok az SQL Cache-függőségek használatával. Ezek az oktatóanyagok nem foglalkoznak a kimeneti gyorsítótárazással. A részletes tartalomért tekintse meg a 2.0-s ASP.NET kimeneti gyorsítótárazása című témakört.

A gyorsítótárazás az architektúra bármely helyére alkalmazható az adatelérési rétegtől a bemutatórétegen keresztül. Ebben az oktatóanyagban megvizsgáljuk a gyorsítótárazás alkalmazását a prezentációs rétegre az ObjectDataSource vezérlő segítségével. A következő oktatóanyagban az üzleti logikai réteg gyorsítótárazási adatait vizsgáljuk meg.

Alapvető gyorsítótárazási fogalmak

A gyorsítótárazás jelentősen javíthatja egy alkalmazás általános teljesítményét és méretezhetőségét azáltal, hogy költségesen előállítható adatokat egy hatékonyabban elérhető helyen tárol. Mivel a gyorsítótár csak a tényleges, mögöttes adatok másolatát tárolja, elavulttá vagy elavulttá válhat, ha az alapul szolgáló adatok megváltoznak. Ennek leküzdése érdekében az oldal fejlesztője megjelölheti azokat a feltételeket, amelyek alapján a gyorsítótárelem ki lesz távolítva a gyorsítótárból a következő módon:

• Időalapú feltételek szerint egy elemet hozzá lehet adni a gyorsítótárhoz abszolút vagy csúszó időtartamra. Egy lapfejlesztő például 60 másodperces időtartamot jelezhet. Abszolút időtartam esetén a gyorsítótárazott elem 60 másodperccel azután törlődik, hogy hozzáadták a gyorsítótárhoz, függetlenül attól, hogy milyen gyakran fértek hozzá. A gyorsítótárazott elemet a rendszer a legutóbbi hozzáférés után 60 másodperccel kiüríti.
• A függőségalapú feltételek egy elemhez társíthatók, amikor hozzáadják a gyorsítótárhoz. Amikor az elem függősége megváltozik, a rendszer kizárja azt a gyorsítótárból. A függőség lehet egy fájl, egy másik gyorsítótárelem vagy a kettő kombinációja. ASP.NET 2.0 lehetővé teszi az SQL Cache-függőségeket is, amelyek lehetővé teszik a fejlesztők számára, hogy hozzáadjanak egy elemet a gyorsítótárhoz, és kizárják azt a mögöttes adatbázis adatainak változásakor. Az SQL-cache függőségeit megvizsgáljuk a közelgő SQL Cache Dependencies oktatóanyagban.

A megadott kiürítési feltételektől függetlenül előfordulhat , hogy a gyorsítótár egy eleme még az időalapú vagy függőségalapú feltételek teljesülése előtt törlődik. Ha a gyorsítótár elérte a kapacitását, a meglévő elemeket el kell távolítani az új elemek hozzáadása előtt. Következésképpen a gyorsítótárazott adatokkal való programozott munka során elengedhetetlen, hogy mindig azt feltételezze, hogy a gyorsítótárazott adatok nem feltétlenül vannak jelen. A gyorsítótárból való adatok programozott elérésekor használandó mintát a következő oktatóanyagunkban, az Adatok gyorsítótárazása az architektúrában című oktatóanyagban tekintjük meg.

A gyorsítótárazás gazdaságos módot biztosít az alkalmazás teljesítményének növelésére. Ahogy Steven Smith kifejti a cikkében, ASP.NET gyorsítótárazás: Technikák és ajánlott eljárások,

A gyorsítótárazás jó módszer lehet a megfelelő teljesítmény eléréséhez anélkül, hogy sok időt és elemzést kellene igényelnie. A memória olcsó, ezért ha a szükséges teljesítményt úgy érheti el, hogy a kimenetet 30 másodpercig gyorsítótárazhatja ahelyett, hogy egy napot vagy egy hetet töltene a kód vagy az adatbázis optimalizálásával, végezze el a gyorsítótárazási megoldást (feltételezve, hogy a 30 másodperces régi adatok rendben vannak), és lépjen tovább. Végül a rossz kialakítás valószínűleg felzárkózni fog Önhöz, ezért természetesen érdemes megpróbálni az alkalmazásokat helyesen megtervezni. De ha csak ma kell biztosítani elég jó teljesítményt, a gyorsítótárazás kiváló megközelítés lehet, mellyel időt nyerhet az alkalmazás átdolgozásához egy későbbi időpontban, amikor már több ideje lesz rá.

Bár a gyorsítótárazás jelentős teljesítménybeli fejlesztéseket biztosít, nem minden esetben alkalmazható, például valós idejű, gyakran frissített adatokat használó alkalmazások esetében, vagy olyan esetekben, ahol még a rövid élettartamú elavult adatok is elfogadhatatlanok. Az alkalmazások többségéhez azonban a gyorsítótárazás használata ajánlott. A ASP.NET 2.0-s verziójának gyorsítótárazásával kapcsolatos további háttérért tekintse meg a ASP.NET 2.0 gyorsútmutató-oktatóanyagokGyorsítótárazás teljesítményhez című szakaszát.

1. lépés: Gyorsítótáras weblapok létrehozása

Mielőtt elkezdenénk feltárni az ObjectDataSource gyorsítótárazási funkcióit, először szánjunk egy kis időt arra, hogy létrehozzuk a webhelyprojekt ASP.NET lapjait, amelyekre szükségünk lesz ehhez az oktatóanyaghoz és a következő háromhoz. Első lépésként adjon hozzá egy új mappát.Caching Ezután adja hozzá a következő ASP.NET lapokat a mappához, és mindenképpen társítsa az egyes lapokat a Site.master mesterlaphoz:

• Default.aspx
• ObjectDataSource.aspx
• FromTheArchitecture.aspx
• AtApplicationStartup.aspx
• SqlCacheDependencies.aspx

1. ábra: A Caching-Related oktatóanyagok ASP.NET lapjainak hozzáadása

A többi mappához Default.aspx hasonlóan a Caching mappában is a szakasz oktatóanyagai jelennek meg. Ne feledje, hogy a SectionLevelTutorialListing.ascx Felhasználói vezérlő biztosítja ezt a funkciót. Ezért húzza ezt a felhasználói vezérlőt a Megoldáskezelőből a lap tervezési nézetébe.

2. ábra: 2. ábra: A felhasználói vezérlő SectionLevelTutorialListing.ascx hozzáadása Default.aspx (ide kattintva megtekintheti a teljes méretű képet)

Végül adja hozzá ezeket a lapokat bejegyzésként a Web.sitemap fájlhoz. Pontosabban, adja hozzá a következő jelölést a Bináris adatokkal való munka <siteMapNode> után:

<siteMapNode title="Caching" url="~/Caching/Default.aspx" 
    description="Learn how to use the caching features of ASP.NET 2.0.">
    <siteMapNode url="~/Caching/ObjectDataSource.aspx" 
        title="ObjectDataSource Caching" 
        description="Explore how to cache data directly from the 
            ObjectDataSource control." />
    <siteMapNode url="~/Caching/FromTheArchitecture.aspx" 
        title="Caching in the Architecture" 
        description="See how to cache data from within the 
            architecture." />
    <siteMapNode url="~/Caching/AtApplicationStartup.aspx" 
        title="Caching Data at Application Startup" 
        description="Learn how to cache expensive or infrequently-changing 
            queries at the start of the application." />
    <siteMapNode url="~/Caching/SqlCacheDependencies.aspx" 
        title="Using SQL Cache Dependencies" 
        description="Examine how to have data automatically expire from the 
            cache when its underlying database data is modified." />
</siteMapNode>

A frissítés Web.sitemapután szánjon egy kis időt az oktatóanyagok webhelyének megtekintésére egy böngészőben. A bal oldali menü mostantól tartalmazza a gyorsítótárazási oktatóanyagok elemeit.

3. ábra: A webhelytérkép mostantól tartalmaz bejegyzéseket a cache útmutatóhoz

2. lépés: Termékek listájának megjelenítése weblapon

Ez az oktatóanyag bemutatja, hogyan használhatja az ObjectDataSource vezérlő beépített gyorsítótárazási funkcióit. Mielőtt azonban megvizsgálhatnánk ezeket a funkciókat, először szükségünk van egy lapra, amelyből dolgozhatunk. Hozzunk létre egy olyan weblapot, amely GridView-t használ az ObjectDataSource által az osztályból ProductsBLL lekért termékadatok listázására.

Először nyissa meg a ObjectDataSource.aspx lapot a Caching mappában. Húzzon egy GridView-t az eszközkészletből a Tervezőre, állítsa a ID tulajdonságát Products értékre, majd az intelligens címkéből válassza ki, hogy egy új, ProductsDataSource nevű ObjectDataSource-vezérlőhöz köti. Konfigurálja az ObjectDataSource-t az ProductsBLL osztály használatához.

4. ábra: Az ObjectDataSource konfigurálása az ProductsBLL osztály használatára (kattintson ide a teljes méretű kép megtekintéséhez)

Ezen a lapon hozzunk létre egy szerkeszthető GridView-t, hogy megvizsgálhassuk, mi történik, ha az ObjectDataSource-ban gyorsítótárazott adatok módosulnak a GridView felületén. Hagyja a SELECT lapon a legördülő listát az alapértelmezett értékre, GetProducts(), de módosítsa az UPDATE lap kijelölt elemét az UpdateProduct túlterhelésre, amely elfogadja a productName, unitPrice és productID bemeneti paramétereket.

5. ábra: Állítsa a FRISSÍTÉS lap Drop-Down listát a megfelelő UpdateProduct túlterhelésre (kattintson ide a teljes méretű kép megtekintéséhez)

Végül állítsa az INSERT és a DELETE lap legördülő listáit a (Nincs) értékre, és kattintson a Befejezés gombra. Az Adatforrás konfigurálása varázsló befejezése után a Visual Studio az ObjectDataSource OldValuesParameterFormatString tulajdonságát original_{0} értékre állítja. Az adatok beszúrásának, frissítésének és törlésének áttekintésével kapcsolatos oktatóanyagban leírtak szerint ezt a tulajdonságot el kell távolítani a deklaratív szintaxisból, vagy vissza kell állítani az alapértelmezett értékre ahhoz, {0}hogy a frissítési munkafolyamat hiba nélkül haladjon tovább.

Ezenkívül a varázsló befejezésekor a Visual Studio minden termékadatmezőhöz hozzáad egy mezőt a GridView-hoz. Tartsa meg csak a ProductName, CategoryName, és UnitPrice BoundFields, a többit távolítsa el. Ezután frissítse az HeaderText egyes BoundFields tulajdonságait a termékre, a kategóriára és az árra. Mivel a ProductName mező szükséges, konvertálja a BoundFieldet sablonmezővé, és adjon hozzá egy RequiredFieldValidatort a EditItemTemplate. Hasonlóképpen konvertálja a UnitPrice BoundFieldet sablonmezővé, és adjon hozzá egy CompareValidatort, hogy a felhasználó által megadott érték érvényes pénznemérték legyen, amely nagyobb vagy egyenlő nullánál. Ezen módosítások mellett nyugodtan végezhet bármilyen esztétikai változtatást, például az UnitPrice érték jobb igazítását, vagy megadhatja a UnitPrice szöveg formázását az írásvédett és a szerkesztési felületeken.

A GridView-t szerkeszthetővé teheti a GridView intelligens címkéjében található Szerkesztés engedélyezése jelölőnégyzet bejelölésével. Jelölje be a Lapozás engedélyezése és a Rendezés engedélyezése jelölőnégyzetet is.

Megjegyzés:

Szeretné áttekinteni, hogyan szabhatja testre a GridView szerkesztőfelületét? Ha igen, tekintse meg az Adatmódosítási felület testreszabása oktatóanyagot.

6. ábra: A GridView támogatásának engedélyezése szerkesztéshez, rendezéshez és lapozáshoz (kattintson ide a teljes méretű kép megtekintéséhez)

A GridView módosításainak elvégzése után a GridView és az ObjectDataSource deklaratív korrektúrája a következőhöz 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:TextBox>
                <asp:RequiredFieldValidator 
                    ID="RequiredFieldValidator1" Display="Dynamic" 
                    ControlToValidate="ProductName" SetFocusOnError="True"
                    ErrorMessage="You must provide a name for the product."
                    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"
                    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" runat="server" 
                    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="ProductsBLL" UpdateMethod="UpdateProduct">
    <UpdateParameters>
        <asp:Parameter Name="productName" Type="String" />
        <asp:Parameter Name="unitPrice" Type="Decimal" />
        <asp:Parameter Name="productID" Type="Int32" />
    </UpdateParameters>
</asp:ObjectDataSource>

A 7. ábrán látható, hogy a szerkeszthető GridView az adatbázisban található termékek nevét, kategóriáját és árát sorolja fel. Szánjon egy kis időt arra, hogy tesztelje a lap funkcióit, rendezze az eredményeket, lapozza át őket, és szerkessze a rekordot.

7. ábra: Minden termék neve, kategóriája és ára rendezhető, lapozható, szerkeszthető GridView listában szerepel (ide kattintva megtekintheti a teljes méretű képet)

3. lépés: Annak vizsgálata, hogy az ObjectDataSource mikor kér adatokat

A Products GridView az ObjectDataSource metódusának meghívásával lekéri a SelectProductsDataSource megjelenítendő adatokat. Ez az ObjectDataSource létrehozza a Business Logic Layer s ProductsBLL osztály egy példányát, és meghívja annak metódusát GetProducts() , amely az Adatelérési réteg s ProductsTableAdapterGetProducts() metódusát hívja meg. A DAL metódus csatlakozik a Northwind-adatbázishoz, és kiadja a konfigurált lekérdezést SELECT . Ezek az adatok ezután visszakerülnek a DAL-ba, amely becsomagolja őket egy NorthwindDataTable-be. A DataTable objektum visszakerül a BLL-be, amely visszaadja az ObjectDataSource-nak, amely visszaadja a GridView-nak. A GridView ezután létrehoz egy GridViewRow objektumot mindegyik DataRow számára a DataTable-ban, és az egyes GridViewRow végül az ügyfélnek visszaadott és a látogató böngészőjében megjelenő HTML-be kerül.

Ez az eseménysorozat minden alkalommal megtörténik, amikor a GridView-nak csatlakoznia kell a mögöttes adatokhoz. Ez akkor fordul elő, ha az oldalt először megtekintik, amikor az egyik adatoldalról a másikra lépnek, a GridView rendezésekor vagy a GridView adatainak módosításakor a beépített szerkesztési vagy törlési felületeken keresztül. Ha a GridView nézetállapota le van tiltva, a GridView minden egyes utólagos visszavételkor is újra le lesz kapcsolva. A GridView expliciten is újraköthető az adataihoz a DataBind() metódus meghívásával.

Az adatok adatbázisból való lekérésének gyakoriságának teljes körű kiértékeléséhez jelenítsünk meg egy üzenetet, amely jelzi az adatok újbóli lekérését. Címke webvezérlő hozzáadása a GridView neve ODSEventsfölött. Törölje a Text tulajdonságát, és állítsa a EnableViewState tulajdonságát a következőre: false. A Címke alatt vegyen fel egy gomb webvezérlőt, és állítsa a tulajdonságát Text Postback értékre.

8. ábra: Címke és gomb hozzáadása a Rácsnézet feletti laphoz (kattintson ide a teljes méretű kép megtekintéséhez)

Az adatelérési munkafolyamat során az ObjectDataSource eseménye Selecting a mögöttes objektum létrehozása és a konfigurált metódus meghívása előtt aktiválódik. Hozzon létre egy eseménykezelőt az eseményhez, és adja hozzá a következő kódot:

protected void ProductsDataSource_Selecting(object sender, 
    ObjectDataSourceSelectingEventArgs e)
{
    ODSEvents.Text = "-- Selecting event fired";
}

Minden alkalommal, amikor az ObjectDataSource kérést küld az architektúra adataira, a Label megjeleníti a "kiválasztási esemény aktiválódott" szöveget.

Látogasson el erre a lapra egy böngészőben. Amikor a lapot először megnyitja, megjelenik a kiválasztási esemény aktiválódott szöveg. Kattintson a Postback gombra, és figyelje meg, hogy a szöveg eltűnik (feltéve, hogy a GridView tulajdonság EnableViewStatetrueértéke az alapértelmezett érték). Ennek az az oka, hogy postback során a GridView rekonstruálódik a nézetállapotából, és ezért nem fordul az ObjectDataSource-hoz a dátainak forrásáért. Az adatok rendezése, lapozása vagy szerkesztése azonban azt eredményezi, hogy a GridView újracsatlakozik az adatforráshoz, ezért a kiválasztási esemény indítószövege ismét megjelenik.

9. ábra: Amikor a GridView visszapattan az adatforrására, megjelenik az aktivált esemény kiválasztása (ide kattintva megtekintheti a teljes méretű képet)

10. ábra: A Postback gombra kattintva a GridView rekonstruálva lesz a nézetállapotából (ide kattintva megtekintheti a teljes méretű képet)

Feleslegesnek tűnhet az adatbázis adatainak lekérése minden egyes alkalommal, amikor az adatokat átlapozza vagy rendezi. Végül is, mivel az alapértelmezett lapozást használjuk, az ObjectDataSource lekérte az összes rekordot az első oldal megjelenítésekor. Még akkor is, ha a GridView nem nyújt rendezési és lapozási támogatást, az adatokat minden alkalommal le kell kérni az adatbázisból, amikor a lapot először bármely felhasználó megtekinti (és minden utólagos visszavételkor, ha a nézet állapota le van tiltva). Ha azonban a GridView ugyanazokat az adatokat jeleníti meg az összes felhasználó számára, ezek a további adatbázis-kérések feleslegesek. Miért nem gyorsítótárazza a metódus által GetProducts() visszaadott eredményeket, és kösse a GridView-t ezekhez a gyorsítótárazott eredményekhez?

4. lépés: Az adatok gyorsítótárazása az ObjectDataSource használatával

Néhány tulajdonság beállításával az ObjectDataSource konfigurálható úgy, hogy automatikusan gyorsítótárazza a beolvasott adatokat a ASP.NET adatgyorsítótárban. Az alábbi lista az ObjectDataSource gyorsítótárral kapcsolatos tulajdonságait foglalja össze:

• Az EnableCaching paramétert true-re kell állítani a gyorsítótárazás engedélyezéséhez. Az alapértelmezett érték a false.
• GyorsítótárAz adatok gyorsítótárazásának időtartama másodpercben. Az alapértelmezett érték 0. Az ObjectDataSource csak akkor gyorsítótárazza az adatokat, ha EnableCaching és true, valamint CacheDuration nullánál nagyobb értékre van beállítva.
• A CacheExpirationPolicy értéke beállítható Absolute vagy Sliding értékekre. Ha Absoluteaz ObjectDataSource másodpercekig CacheDuration gyorsítótárazza a lekért adatokat, ha Slidingaz adatok csak azután járnak le, hogy másodpercekig CacheDuration nem fértek hozzá. Az alapértelmezett érték a Absolute.
• A CacheKeyDependency ezzel a tulajdonsággal társítja az ObjectDataSource gyorsítótár-bejegyzéseit egy meglévő gyorsítótár-függőséghez. Az ObjectDataSource adatbejegyzései idő előtt eltávolíthatók a gyorsítótárból azáltal, hogy a társított CacheKeyDependency lejár. Ezt a tulajdonságot leggyakrabban arra használják, hogy sql-gyorsítótár-függőséget társítsunk az ObjectDataSource gyorsítótárához. Ezt a témakört a jövőben az SQL Cache függőségei című oktatóanyagban ismertetjük.

Konfiguráljuk az ProductsDataSource ObjectDataSource-t, hogy 30 másodpercig gyorsítótárazza az adatokat abszolút skálán. Állítsa az ObjectDataSource tulajdonságát EnableCaching 30-ra true , a tulajdonságát CacheDuration pedig 30-ra. Hagyja meg a CacheExpirationPolicy tulajdonság alapértelmezett értékét. Absolute

11. ábra: Az ObjectDataSource konfigurálása az adatok gyorsítótárazásához 30 másodpercig (kattintson ide a teljes méretű kép megtekintéséhez)

Mentse a módosításokat, és tekintse meg újra ezt a lapot egy böngészőben. A kiválasztási esemény aktivált szövege a lap első megnyitásakor jelenik meg, mivel az adatok kezdetben nem szerepelnek a gyorsítótárban. A Postback gombra, rendezésre, lapozásra vagy a Szerkesztés vagy a Mégse gombra kattintással aktivált utólagos visszavételek azonban nem jelenítik meg újra a Kijelölés esemény által aktivált szöveget. Ennek az az oka, hogy az Selecting esemény csak akkor aktiválódik, ha az ObjectDataSource lekéri az adatokat a mögöttes objektumból; az Selecting esemény nem aktiválódik, ha az adatokat az adatgyorsítótárból kéri le.

30 másodperc elteltével az adatok ki lesznek távolítva a gyorsítótárból. Az adatok is törlődnek a gyorsítótárból, ha az ObjectDataSource s Insert, Updatevagy Delete metódusok meghívása történik. Következésképpen, miután 30 másodperc eltelt, vagy a Frissítés gombra kattintottak, a rendezés, lapozás, illetve a Szerkesztés vagy Mégse gomb megnyomása esetén az ObjectDataSource lekéri az adatokat a mögöttes objektumból, és megjeleníti a Kiválasztás esemény aktiváláskor megjelent szöveget, amikor az Selecting esemény bekövetkezik. Ezek a visszaadott eredmények visszakerülnek a gyorsítótárba.

Megjegyzés:

Ha gyakran látja a Kiválasztás esemény által aktivált szöveget, még akkor is, ha azt várja, hogy az ObjectDataSource gyorsítótárazott adatokkal dolgozik, az memóriakorlátok miatt lehet. Ha nincs elég szabad memória, előfordulhat, hogy az ObjectDataSource által a gyorsítótárba hozzáadott adatok ki lettek fúrva. Ha úgy tűnik, hogy az ObjectDataSource nem megfelelően gyorsítótárazza az adatokat, vagy csak szórványosan gyorsítótárazza az adatokat, zárjon be néhány alkalmazást a memória felszabadításához, és próbálkozzon újra.

A 12. ábra az ObjectDataSource gyorsítótárazási munkafolyamatát szemlélteti. Amikor megjelenik a kiválasztási esemény által aktivált szöveg a képernyőn, az azért van, mert az adatok nem voltak a gyorsítótárban, és az alapul szolgáló objektumból kellett lekérni. Ha azonban ez a szöveg hiányzik, az azért van, mert az adatok elérhetők a gyorsítótárból. Amikor az adatok visszakerülnek a gyorsítótárból, nincs hívás a mögöttes objektumra, ezért nem lesz végrehajtva adatbázis-lekérdezés.

12. ábra: Az ObjectDataSource az adatokat az adat gyorsítótárban tárolja és onnét kéri le.

Minden ASP.NET alkalmazásnak saját adatgyorsítótár-példánya van, amelyet minden oldalon és látogatóban megosztanak. Ez azt jelenti, hogy az ObjectDataSource által az adatgyorsítótárban tárolt adatok hasonlóképpen meg lesznek osztva a lapot meglátogató összes felhasználó között. Ennek ellenőrzéséhez nyissa meg a ObjectDataSource.aspx lapot egy böngészőben. Az oldal első megnyitásakor megjelenik a Kiválasztás esemény aktivált szövege (feltéve, hogy a korábbi tesztek által a gyorsítótárba felvett adatok mára ki lettek véve). Nyisson meg egy második böngészőpéldányt, és másolja és illessze be az URL-címet az első böngészőpéldányból a másodikba. A második böngészőpéldányban a Kiválasztási esemény szövege nem jelenik meg, mert ugyanazt a gyorsítótárban lévő adatot használja, mint az első.

Amikor beszúrja a beolvasott adatokat a gyorsítótárba, az ObjectDataSource egy gyorsítótárkulcs-értéket használ, amely a következőket tartalmazza: a CacheDuration tulajdonság és CacheExpirationPolicy a tulajdonságértékek; az ObjectDataSource által használt mögöttes üzleti objektum típusa, amely a tulajdonságon keresztülTypeName van megadva (ProductsBLLebben a példában); a tulajdonság értékeSelectMethod, valamint a SelectParameters gyűjteményben lévő paraméterek neve és értékei, valamint annak StartRowIndex és MaximumRows tulajdonságainak értéke, amelyeket az egyéni lapozás implementálásakor használnak.

A gyorsítótárkulcs értékének ezen tulajdonságok kombinációjaként történő létrehozása biztosítja a gyorsítótár egyedi bejegyzését, ahogy ezek az értékek változnak. A korábbi oktatóanyagokban például az ProductsBLL s GetProductsByCategoryID(categoryID)osztályt használtuk, amely egy adott kategóriához tartozó összes terméket visszaadja. Lehet, hogy egy felhasználó megnézi az oldalt, ahol az italok száma CategoryID értékkel szerepel. Ha az ObjectDataSource az értékek figyelmen kívül hagyása nélkül gyorsítótárazza az SelectParameters eredményeket, amikor egy másik felhasználó azért jött az oldalra, hogy megtekintse a fűszereket, miközben az italtermékek a gyorsítótárban voltak, a gyorsítótárban lévő italtermékeket látják, nem pedig a fűszereket. Ha a gyorsítótárkulcsot ezen tulajdonságok alapján változtatja meg, amelyek tartalmazzák az SelectParametersértékek értékét, az ObjectDataSource külön gyorsítótár-bejegyzést tart fenn az italok és a fűszerek számára.

Elavult adatproblémák

Az ObjectDataSource automatikusan kiüríti az elemeket a gyorsítótárból, amikor a rendszer meghívja Insertvalamelyik , Updatevagy Delete metódusát. Ez segít védelmet nyújtani az elavult adatok ellen azáltal, hogy törli a gyorsítótár bejegyzéseit, amikor az adatok az oldalon keresztül módosulnak. Előfordulhat azonban, hogy egy ObjectDataSource gyorsítótárazással továbbra is elavult adatokat jelenít meg. A legegyszerűbb esetben annak lehet az oka, hogy az adatok közvetlenül az adatbázisban változnak. Lehet, hogy egy adatbázis-rendszergazda most futtatott egy szkriptet, amely módosítja az adatbázis egyes rekordjait.

Ez a forgatókönyv is finomabb módon bontakozhat ki. Bár az ObjectDataSource az egyik adatmódosítási metódus meghívásakor kiüríti az elemeket a gyorsítótárból, az eltávolított gyorsítótárazott elemek az ObjectDataSource tulajdonságértékek adott kombinációjához (CacheDuration, TypeNamestb SelectMethod.) tartoznak. Ha van két ObjectDataSource, amelyek különböző SelectMethods vagy SelectParameters használnak, de mégis képesek ugyanazokat az adatokat frissíteni, akkor az egyik ObjectDataSource frissíthet egy sort és érvénytelenítheti a saját gyorsítótárbejegyzéseit, de a második ObjectDataSource megfelelő sorát továbbra is a gyorsítótárból szolgálják ki. Javaslom, hogy hozzon létre oldalakat, hogy bemutassa ezt a funkciót. Olyan lap létrehozása, amely egy szerkeszthető GridView-t jelenít meg, amely lekéri az adatokat egy gyorsítótárazást használó ObjectDataSource-ból, és úgy van konfigurálva, hogy az adatokat az ProductsBLL osztály GetProducts() metódusából kapja. Adjon hozzá egy másik szerkeszthető GridView-t és ObjectDataSource-t ehhez a laphoz (vagy egy másikhoz), de ehhez a második ObjectDataSource-hoz használja a metódust GetProductsByCategoryID(categoryID) . Mivel a két ObjectDataSources SelectMethod tulajdonság eltérő, mindegyiknek saját gyorsítótárazott értékei lesznek. Ha egy terméket az egyik rácsban szerkeszt, a következő alkalommal, amikor visszaköti az adatokat a másik rácshoz (lapozással, rendezéssel és így tovább), az továbbra is a régi, gyorsítótárazott adatokat fogja kiszolgálni, és nem tükrözi a másik rácson végzett módosítást.

Röviden, csak akkor használjon időalapú lejáratokat, ha hajlandó kihasználni az elavult adatokban rejlő lehetőségeket, és használjon rövidebb lejáratokat olyan helyzetekben, ahol fontos az adatok frissessége. Ha az elavult adatok nem elfogadhatóak, akkor vagy ne használjon gyorsítótárazást, vagy alkalmazzon SQL cache-függőségeket (feltéve, hogy az adatbázis-adatokat tárolja gyorsítótárban). Az SQL Cache-függőségeket egy későbbi oktatóanyagban ismertetjük.

Összefoglalás

Ebben az oktatóanyagban az ObjectDataSource beépített gyorsítótárazási képességeit vizsgáltuk meg. Néhány tulajdonság beállításával utasíthatjuk az ObjectDataSource-t, hogy gyorsítótárazza a megadott SelectMethod adatokból visszaadott eredményeket a ASP.NET adatgyorsítótárba. A CacheDuration és CacheExpirationPolicy tulajdonságok jelzik az elem gyorsítótárazási időtartamát, valamint azt, hogy abszolút vagy csúszó lejáratot használ-e. A CacheKeyDependency tulajdonság társítja az ObjectDataSource összes gyorsítótár-bejegyzését egy meglévő gyorsítótár-függőséggel. Ez arra használható, hogy az ObjectDataSource bejegyzéseit az időalapú lejárat elérése előtt kiürítse a gyorsítótárból, és általában SQL Cache-függőségekkel használják.

Mivel az ObjectDataSource egyszerűen gyorsítótárazza az értékeit az adatgyorsítótárban, programozott módon replikálhatjuk az ObjectDataSource beépített funkcióit. Ezt a prezentációs rétegben nincs értelme elvégezni, mivel az ObjectDataSource alapértelmezetten ezt a funkciót biztosítja, de a gyorsítótárazási képességeket megvalósíthatjuk az architektúra egy önálló rétegében. Ehhez meg kell ismételnünk az ObjectDataSource által használt logikát. A következő oktatóanyagban bemutatjuk, hogyan használható programozott módon az adatgyorsítótár az architektúrán belülről.

Boldog programozást!

További olvasás

Az oktatóanyagban tárgyalt témakörökről az alábbi forrásokban talál további információt:

• ASP.NET gyorsítótárazás: Technikák és ajánlott eljárások
• Gyorsítótárazási architektúra útmutató .NET-keretrendszer alkalmazásokhoz

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 Murphy volt. Szeretné áttekinteni a közelgő MSDN-cikkeimet? Ha igen, írj egy sort a mitchell@4GuysFromRolla.com-ra.

Következő