Mellékelt példa kipróbálásához szükséges egy CacheTableTest nevű virtuális könyvtár létrehozása, mely arra a könyvtárra mutat, amelybe másolta a példát. Ehhez legegyszerűbb út az adott mappa tulajdonság ablakában lévő Webmegosztás lapon található, ahol is engedélyezzük a megosztást.
Futtatás előtt szükséges még a szintén mellékelt CacheTest.sql futtatása, hogy létrejöjjön a példához szükséges SQL adatbázis.
Végső lépésként a WebForm2.aspx.cs forráskód 40. sorában lévő connStr változó értékét módosítsuk úgy, hogy programunk képes legyen az adatbázishoz kapcsolódni.
A példában két WebForm-ot használunk. Az első lapon lehet kiválasztani, hogy melyik sort is szeretnénk látni az öt meglévő közül. Választás után ez a második WebForm-on kerül megjelenítésre. Itt tájékoztatást kapunk arról is, hogy az adat SQL lekérdezés útján jött-e létre, vagy már elérhető volt a Cache-ből is.
Az első megjelenítéskor biztos, hogy lekérdezés útján jön az adat. Ha ilyenkor a Frissít gombra kattintunk, akkor megjelenik ugyanaz a tartalom, de látható lesz, hogy most már a Cache-ből jött az adat.
Ha a Változtat gombra kattintunk, akkor egy véletlenszerű értékre megválatozik a sor egyik adata. Ilyenkor ismét lekérdezés útján kapjuk az adatokat és nem a Cache-ből, így nem fordulhat elő, hogy adatváltozás esetén a régi adat jelenjen meg.
A Vissza gombot választva ismét a WebForm1-re kerülünk, itt új sort választhatunk megjelenítésre, vagy ha már van a Cache-en adat, akkor ezekről is megjelenik egy lista, melynek segítségével törölhetjük is a sorokat a Cache-ről. Ez utóbbinak az lesz a hatása, hogy a következő megjelenítéskor ismét lekérdezés útján fogjuk megkapni az adatokat.
Nézzük most minként valósíthatók meg ezek a funkciók.
WebForm1
Ha a ListBox-ból választunk egy sort, akkor az adattáblából az ezzel a számmál egyező ID értékű sort kell megjelenítenünk. Ehhez a kérést a WebForm2-höz továbbítjuk egy id=x paraméterrel, ahol x az adott sor száma lesz.
private void Button1_Click(object sender, System.EventArgs e)
{
Response.Redirect("WebForm2.aspx?id=" + ListBox1.SelectedItem.Value.ToString());
}
Ha már van adat a Cache-en, akkor kell készítenünk egy listát, melynél meg kell oldanunk a törlés lehetőségét. Ehhez azt a megoldást válasszuk, hogy nyomógombokat hozunk létre. Mindegyiknek feliratán látható lesz, hogy melyik adatról is van és a gombra történő kattintással elvégezhető a törlés is.
A Cache elemeinek az eléréséhez a GetEnumerator függvény hívásával kérünk egy IDictionaryEnumerator osztályt.
private void Page_Load(object sender, System.EventArgs e)
{
IDictionaryEnumerator de = Cache.GetEnumerator();
Ezt felhasználva egy while ciklussal végig mehetünk a Cache-en tárolt összes elemen. A következő elemre való léptetést a MoveNext végzi és egyben tájékoztat is arról, hogy kell-e még folytatnunk a ciklust.
Következőlépésben lekérdezzük a Cache-en tárolt adat megnevezését, amit ellenőriznünk kell, mivel a Cache-en nem csak a mi általunk tárolt adatok lehetnek. Mivel az adatokat úgy tároljuk, hogy Row1, Row2, stb. neveket adunk, így ezt felhasználva ki tudjuk szűrni a más alkalmazás által tárolt adatokat.
s = de.Key.ToString();
if (s.IndexOf("Row")==0)
{
Ha találtunk egy olyan adatot, mely e feladatunkhoz tartozik, akkor létrehozunk egy új nyomógombot és beillesztjük a WebForm-on lévő Panel-re. Megadunk a Command eseményéhez egy kezelőt is. Ez akkor fog aktivizálódni, amikor a gombra kattint a felhasználó. Mivel a CommandArgument-be eltároltuk
b = new Button();
b.Text = s + " törlése a Cache-ből";
b.Style.Add("top", y.ToString());
b.CommandArgument = s;
b.Command += new CommandEventHandler(ButtonClick);
Panel1.Controls.Add(b);
y+=24;
}
}
}
Amikor tehát fut a ButtonClick nevű eseményünk, akkor paraméterként megkapjuk a gomb CommandArgument property-ébe beállított értéket, mely a Cache-en lévő adat megnevezés lesz. Így nincs más dolgunk, mint eltávolítani ezt a Cache-ről és újra betölteni a WebForm1-et, melyen ehhez az elemhez most már nem fog gomb tartozni.
private void ButtonClick(object sender, System.Web.UI.WebControls.CommandEventArgs e)
{
Cache.Remove(e.CommandArgument.ToString());
Response.Redirect("WebForm1.aspx");
}
WebForm2
Amikor betöltésre kerül a lap, akkor először is el kell döntenünk, hogy a kért adat megtalálható-e a Cache-en vagy még nem. Ehhez persze tudnunk kell, hogy melyik sorról is van szó.
Ezt az ID paraméterből meghatározhatjuk, majd megpróbáljuk a kért adatot lekérni a Cache-ből. Mivel a Cache-en DataRow osztály típusban tároljuk egy-egy sor minden adatát, így egy ilyen típusú változóba tároljuk is el.
private void Page_Load(object sender, System.EventArgs e)
{
string sid = Request.QueryString["id"];
dr = (DataRow)Cache["Row" + sid];
Ha a Cache-ről visszaadott adat null értékű, akkor még nem áll rendelkezésre a Cache-en a kért sor. Ez esetben futtatjuk az SQL lekérdezést.
if (dr == null)
{
SqlConnection connection = new SqlConnection(connStr);
connection.Open();
SqlDataAdapter da = new SqlDataAdapter("select * from testtable where id=" + sid, connection);
DataSet ds = new DataSet();
da.Fill(ds);
A lekérdezés eredményét ugyanabba a DataRow típusú változóba helyezzük el. Mivel példánkból következik, hogy minden lekérdezés csak egy sort ad vissza, így nyugodtan használhatjuk a Rows-nál a nulladik elemet.
dr = ds.Tables[0].Rows[0];
connection.Close();
A lekérdezés után tároljuk is a sort a Cache-en, hogy a következő kéréskor már onnan legyen elérhető.
Cache["Row" + sid] = dr;
Label1.Text = "Az adatok lekérdezés útján érhetők el.";
}
else
{
Label1.Text = "Az adatok a cache-ből érhetők el.";
}
Ezen a ponton, akár a Cache-ből, akár az SQL lekérdezés útján, de valahogy biztosan rendelkezésre állnak már az adatok a DataRow osztályban, így nincs más teendőnk, mint ezeket megjeleníteni.
Label2.Text = dr["id"].ToString();
Label3.Text = dr["value1"].ToString();
...
}
Nézzük most mit kell tennünk akkor, ha változik egy-egy sor valamely eleme.
private void Button2_Click(object sender, System.EventArgs e)
{
...
SqlCommand c = new SqlCommand("UPDATE TestTable SET value4 = " + r.Next(Int32.MaxValue).ToString() + "WHERE id = " + sid, connection);
c.ExecuteNonQuery();
Miután a szükséges módon elvégeztük az adatmódosítást a tábla megfelelő során, nincs más tennivalónk, mint törölni a Cache-en esetlegesen már tárolt adatot. Ez biztosítani fogja azt, hogy amikor a következő elérésre kerül a sor, akkor egy újabb SQL lekérdezés útján lesz csak elérhető az adat, ez pedig azt garantálja, hogy a Cache-en tárolt régebbi adat már nem kerülhet megjelenítésre.
Cache.Remove("Row" + sid);
Response.Redirect("WebForm2.aspx?id="+sid);
}