Makale Özeti

Bu makalede ASP.NET 2.0 ile birlikte gelen ve web uygulamalarının performans yönetiminde kullanabileceğimiz yeniliklere değiniyor olacağız.

Makale

Bir web uygulaması geliştirilirken göz önüne alınacak en önemli unsurlardan birisi de uygulamanın performansıdır. ASP.NET'in ilk sürümleri  ile birlikte gelen yeniliklerde özellikle uygulamanın performansını arttırma işlemlerini oldukça kolay, pratik ve gerçekten etkili bir şekilde gerçekleştirebilmekteydik. En temel performans bakımı tekniklerimiz olan OutputCache ile sayfa çıktısını, Cache nesnesi ile de sayfa içerisindeki bir nesneyi belirli bir süre bellekte saklayabilmekte ve sonraki erişimlerde sayfanın çok daha hızlı bir şekilde çalışabilmesini sağlayabilmekteyiz. ASP.NET 2.0 ile birlikte birçok alanda gelen yenilikler arasında performans yönetimi konusunda da bazı yeni teknikler ve kullanım kolaylıkları getirilmiştir. Bu yazımızda da ASP.NET 2.0 ile birlikte gelen bu yenilikleri inceliyor olacağız.

ASP.NET 2.0 ile gelen yenilikleri şu başlıklar altında toplayabiliriz:

1. Cache Profilleri (Cache Profiles) ile OutputCache mekanizmasının daha kolay şekilde yönetilebilmesi
2. Post-Caching ve Substitution kontrolü önbelleklenen sayfada dinamik alanlar kullanabilme
3. SqlCacheDependency ile veritabanındaki değişikliklere göre veri önbellekleme
4. DataSource kontrolleri ile önbellekteki veriler ile çalışmak
5. Custom Dependency'ler oluşturabilme

Dilerseniz yukarıdaki başlıkları bizlere ne gibi yenilikler getirdiği ve uygulamalarda nasıl kullanacabileceğimiz hususunda detaylı bir şekilde ele alalım.


1. Cache Profilleri (Cache Profiles) 

ASP.NET'in ilk sürümünden beri bir sayfanın tamamının veya belirli bir kısmının HTML çıktısının önbelleğe alınmasını ve sayfanın çok daha hızlı bir şekilde çalışmasını sağlayabilmekteyiz. Sayfa veya user control içerisine ekleyeceğimiz <%@ OutputCache ... %> direktifi ile sayfanın önbelleğe alınma şeklini belirleyebiliyorduk. ASP.NET 2.0 ile birlikte gelen Cache Profilleri ile birlikte sayfalarımızda ortak olarak kullanabileceğimiz OutputCache ayarlamalarını artık web.config içerisinde düzenli bir şekilde saklayabilmekte ve sayfa içerisinde OutputCache direktifinin bu profillerden birini kullanabilmesini sağlayabilmekteyiz. Dilerseniz önce OutputCache direktifini sayfa içerisinde nasıl kullanabiliyorduk bir hatırlayalım. Aşağıdaki kod parçasını bir .aspx sayfasındaki Page direktifinin alt kısmına ekleyecek olursak; sayfa QueryString bilgisini dikkate almaksızın 60 saniye süre ile önbelleğe alınacaktır.

<%@ OutputCache Duration="60" VaryByParam="None" %>

Cache profillerin bize ne gibi bir noktada fayda sağladığını görebilmek için şöyle bir senaryo üzerinde duralım. Varsayalım ki uygulamamız çok sayıda sayfadan oluşuyor ve bu sayfaların bir grubunu farklı şekilde, diğer grubunu farklı şekilde önbelleğe alma işlemini gerçekleştirmek istiyoruz. Şöyle ki;

     Grup 1: A, B, C, D, E, F ve G sayfalarını 600 saniye süre ile, QueryString verilerini dikkate almadan
     Grup 2: K, L, M, N, O ve P sayfalarınıda 300 saniye süre ile UrunID QueryString değerine göre

önbellekte saklama işlemi gerçekleştirelim. Böyle bir durumda yukarıdaki Grup 1 sayfalarına <%@ OutputCache Duration="600" VaryByParam="None" %> ifadesini, Grup 2 sayfalarına da <%@ OutputCache Duration="300" VaryByParam="UrunID" %>  ifadelerini eklememiz gerekecekti. Varsayalım ki belirli bir süre sonra Grup 1'deki sayfaların çok uzun süre ile önbellekte tutulduğunu ve kullanıcının güncel bilgiye erişemediğini gördük. Yine Grup 2'deki sayfalarında sadece UrunID QueryString bilgilesine göre değil de, UrunID ve Renk QueryString bilgilerine göre önbellekte saklanmasını istiyoruz; yani sayfalardaki OutputCache direktiflerini değiştirme ihtiyacımız var. Bu durum yukarıdaki 12-13 tane sayfanın tek tek açılarak kod kısımlarında değişiklik yapılması anlamına geliyor. Sayfa sayısının 30-40 olduğunu düşünürsek durum biraz daha vahim hale geliyor:) İşte bu noktada gruplanan iki OutputCache niteliğini web.config içerisinde saklayacak ve sayfalarımızda da web.config'deki bu ayarları kullanacak olursak artık bilgileri tek bir noktada toplamış ve dolayısıyla da bu değişiklikleri de çok basit bir şekilde sayfalara uygulamış olacağız. Peki Cache profillerini web.config içerisinde ne şekilde saklayacağız. Aşağıdaki kod parçaları ile birlikte web uygulamasına CacheProfil_A ve CacheProfil_B adında iki tane Cache profili eklemiş oluyoruz.

<system.web>
   ..... 
   ..... 
   <caching>
        <outputCacheSettings>
             <outputCacheProfiles>
                  <add name="CacheProfil_A" duration="600" varyByParam="None" />
                  <add name="CacheProfil_B" duration="300" varyByControl="UrunID"/>
             </outputCacheProfiles>
        </outputCacheSettings>
   </caching>
</system.web>

Oluşturulan bu profilleri sayfalarda kullanabilmek için yapmamız gereken OutputCache direktifi içerisindeki CacheProfile özelliğini uygun profile name değerine atamak olacaktır. Aşağıda CacheProfile_B profilini kullanan bir sayfaya yazılacak OutputCache direktifi görülmektedir.

<%@ OutputCache CacheProfile="CacheProfil_B" %>

Böylece Cache profillerini kullanarak sayfalar içerisinde kullandığımız OutputCache direktifi bilgilerini web.config dosyasından okuyor ve daha yönetilebilir hale getirmiş oluyoruz.


2. Post-Caching ve Substitution kontrolü önbelleklenen sayfada dinamik alanlar kullanabilme

ASP.NET'in önceki sürümlerinde sayfanın tamamını veya sadece belirli bir alanını önbelleğe alabiliyorduk. Fragment Caching adı verilen bir teknikte sayfa içerisinde bir user-control (ascx) dosyası ekleyerek sadece bu alanın HTML çıktısını önbelleğe saklayabiliyor ve sayfanın diğer alanlarının dinamik oluşmasını sağlayabiliyorduk. Fakat sayfanın tamamını önbellekten getirilirken sadece belirli bir alanını dinamik oluşturma işlemini gerçekleştiremiyorduk. ASP.NET 2.0 ile birlikte gelen yeniliklerle birlikte artık bu tip bir önbellekleme işlemini de gerçekleştirebilmekteyiz.


Resim: Substitution kontrolü ile önbelleklenen sayfadaki parçaların işleyişi

Fragment caching ile sayfanın belirli bir alanını önbelleğe alma işlemi oldukça pratik bir işlemdi. Fakat burada yapılacak işlemin biraz daha zor olacağını söyleyebiliriz. Zira sayfanın dinamik olarak oluşturulacak kısmını her ne kadar bir kontrol aracılığıyla hazırlıyor olsakta, bu kontrolün içerisinde yazdırılacak HTML kodlarını tamamen bizlerin yazması gerekecek. Post-Cache Substitution ile yapılacak işlemde Response.WriteSubstitution metodu ile HttpResponseSubstitutionCallback delegate'i (temsilci) aracılığıyla static bir metodu işaretlememiz gerekir. Substitution kontrolü ile yapılacak işlemde ise bu kontrolün MethodName isimli özelliğin yine static olarak yazılmış özel bir metodun adını vermeliyiz. Tahmin edeceğiniz üzere sayfaya dinamik olarak gelecek HTML içerikler burada bahsetmiş olduğumuz metotlardan getirilecektir. Dilerseniz bahsettiğimiz iki yolu sayfamıza nasıl uygulayabileceğimiz bir bakalım.

- Post-Cache Substitution
Bu yolu seçtiğimizde sayfamızın source kısmında dinamik içeriğin geleceği kısma Response.WriteSubstitution metodu ile static metot çağrımında bulunmamız gerekir. İsterseniz öncelikle burada bize gerekli olan metodu yazarak üzerinde biraz konuşalım. Zira bu metot ile ilgili konuşulması gereken birkaç noktamız var.

protected static string DinamikIcerik(HttpContext ctx)
{
      return "<b>" + DateTime.Now.ToLongTimeString() + "</b>";
}

Yazacağımız metot dinamik içeriğimizi oluşturacak; yani HTML kodlarımızı bize getirecek bir metot olmalıdır. Bundan dolayı metodumuzun geri dönüş tipi string'dir ve return edilen HTML kodları dinamik içeriğimizi oluşturacaktır. Bu sayfamıza bir istek geldiğinde sayfa içeriği (dinamik alan dışındaki içerikler) önbellekten getirilecektir; yani sayfamızın tekrar çalıştırılmasına, dolayısıyla da nesne örneğini oluşturulmasına gerek yoktur. Bundan dolayı static bir metot yazacak olursak uygulamamız sayfanın nesne örneğine ihtiyaç duymadan bu metodu çağırabilecektir. Metodumuz HttpResponseSubstitutionCallback  delegate'inin işaretleyebileceği bir metot olmak zorunda olduğu için burada bir de HttpContext tipinden bir metot parametresine ihtiyacımız vardır. Bu parametre gelen istek ile ilgili bilgilerin taşınmasını sağlar fakat pek kullanmaz. Böylece yazılacak metodun detaylarını irdelemiş olduk. Peki metodu nasıl çağıracağız. Aşağıdaki kodlarda görüldüğü gibi bir sayfa tasarlayalım.

......
<%@ OutputCache Duration="30" VaryByParam="none" %>
......
......
<form id="form1" runat="server">
     <div>
          Önbellekten gelen zaman: <%= DateTime.Now.ToLongTimeString() %>
          <br /><br />
          Dinamik zaman: <% Response.WriteSubstitution(new HttpResponseSubstitutionCallback(DinamikIcerik)); %>
     </div>
</form>
.....


Resim: Post-Cache Substitution yolunu kullandığımızda sadece belirli bir alanın dinamik oluşmasını sağlayabiliriz.

Response.WriteSubstitution metodu ile sayfanın HTML kısmına DinamikIcerik isimli metodun geriye döndürdüğü string ifade yazılmıştır. Burada çalışma zamanı esnasında bir metodu işaretlemek söz konusu olduğu için new HttpResponseSubstitutionCallback(DinamikIcerik) şeklinde delegate nesnesi oluşturup DinamikIcerik isimli metodu işaretlememiz gerekir. Bu teknikte gerek metodun yazımında gerekse metodun çağrımında biraz zorlukla karşılaşabileceğizi söyleyebiliriz.

- Substitution Kontrolü
Post-Cache Substitution yolu yazılan metodu işaretlemede biraz zorlayıcı olduğu için bu tip durumlarda Substitution kontrolünü kullanmak daha kolay bir çözüm olabilir. Aslında bu iki yolda da yapılan işlemler aynıdır, sadece kontrol üzerinde çalıştığımızda metodu işaretlememiz daha pratik olacaktır. Aşağıdaki kodlarda Substitution kontrolünün sayfaya nasıl uygulanabileceğini görebiliriz.

......
<%@ OutputCache Duration="30" VaryByParam="none" %>
......
......
<form id="form1" runat="server">
     <div>
          Önbellekten gelen zaman: <%= DateTime.Now.ToLongTimeString() %>
          <br /><br />
          Dinamik zaman: <asp:Substitution ID="Substitution1" runat="server" MethodName="DinamikIcerik" />
     </div>
</form>
.....

Görüldüğü gibi Substitution kontrolünin MethodName özelliğini metodun adı olarak belirlemek yeterli olacaktır. Böylece sayfadaki Substitution kontrolünün içeriği dinamik şekilde oluşturulacaktır. Substitution kontrolünün içeriği dışında kalan bölgelerin içerikleri ise önbellekten getirilecektir.


3. SqlCacheDependency ile veritabanındaki değişikliklere göre veri önbellekleme

ASP.NET 2.0'dan önceki sürümlerde önbellekleme işlemleri CacheDependency sınıfı ile zamana bağımlı kalmadan, bir dosyanın veya klasörün değişim durumuna göre gerçekleştirilebilmekteydi. Yine bu sınıf aracılığıyla veritabanında bir tablodaki değişimlere bağımlı kalarak önbellekleme işlemleri yapılabilmekteydi. Fakat bu işlemleri yapabilmek için gerek vertiabanında oluşturulacak nesneler(tablo, trigger ve stored procedure gibi) gerekse uygulamada yapılacak işlemler programcı için oldukça zor işlemlerdi. ASP.NET 2.0'da gelen yeni SqlCacheDependency class'ı ve aspnet_regsql.exe aracının SqlCacheDependency seçenekleri ile gerek veritabanında oluşturulacak nesneler, gerekse uygulama içerisinde yapılacak işlemler artık çok daha kolay bir hale geldi.

SqlCacheDependency çok detaylı bir mevzu olduğu için başlı başına bir makale olarak ele almakta fayda olabilir. Biz burada olabildiğince kısa bir şekilde bu mekanizmayı incelemeye ve uygulamalarda nasıl kullanabileceğimizi göreceğiz. Öncelikli olarak SqlCacheDependency'nin uygulama ve veritabanı tarafındaki bileşenlerini inceleyelim. Veritabanındaki bir tablonun değişimine göre önbellekleme işlemleri yapabilmek için mutlaka veritabanı ile bütünleşik şekilde çalışmak, yani veritabanı içerisinde bazı nesneleri kullanmak gerekecektir. Burada esas alınacak durum verilerin asıl getirildiği tablonun verilerini kontrol etmek yerine bizim aracı bir tablo üzerinden asıl verilerin saklandığı tablonun kontrolünü yapmaktır. Zira verilerin saklandığı tablomuzda binlerce kayıt bile olabilir. Böyle bir tablonun değişip değişmediğini trigger'lar aracılığıyla başka bir tabloya aktarmak ve kontrollerin bu tablo üzerinden gerçekleştirmek çok daha hızlı olacaktır. Uygulama içerisinde kullanacağımız SqlCacheDependency tipindeki nesnemiz tablonun değişip değişmediğini belirli aralıklarla veritabanından kontrolünü yapacak ve eğer tabloda değişiklik olmuşsa Cache'de saklanacak verinin değiştirilmesini sağlayacak. Bu işleyişi daha iyi anlamak için aşağıdaki şekil üzerinden konuşmaya devam edelim.


Resim: SqlCacheDependency mekanizmasının çalışma şekli

Görüldüğü gibi Cache nesnesinde saklanan veriler SqlCacheDependency nesnesi ile bütünleşik şekilde veritabanındaki tabloya bağımlı bir biçimde tutulmaktadır. Cache'de saklanan veriler istenildiğinde SqlCacheDependency nesnesi veritabanındaki değişim olup olmadığını kontrol etmek için haber veren tabloya (notification table) bakacak ve değişim yoksa Cache'de saklanan veri aynen kullanılacaktır. Eğer SqlCacheDependency nesnesi notification table'da ilgili kaydın değiştiğini görürse (ki bu Urunler tablosunda bir değişiklik yapıldığı anlamına gelir) Cache'deki nesnenin kaldırılmasını sağlar. Bu noktadan sonra programcı uygulamada yazdığı kodlar ile Cache'den kaldırılmış nesneyi tekrar doldurarak uygulamaya güncel verilerin aktarılmasını sağlayacaktır.

Bir projede SqlCacheDependency tekniğini uygulamak biraz zor bir yoldur. Gelin adım adım bu işlemi nasıl gerçekleştirebileceğimize bakalım.

Adım-1
SQL Server'da ilgili notification table, trigger ve stored procedure'ların kurulması gereklidir. aspnet_regsql.exe aracı ile bu işlemi kolay bir şekilde gerçekleştirebileceğiz. aspnet_regsql.exe .NET Framework SDK v2.0 ile birlikte gelen araçlardan biridir. SDK Command Prompt'ta yazılacak komutlarla önce ilgili tablonun bulunduğu veritabanına ilgili notification table, trigger ve stored procedure'ların kurulması gerekecektir. Başlat > Programlar > Microsoft .NET Framework SDK v2.0 > SDK Command Prompt seçeneğinden komut satırını açtıktan sonra aşağıdaki resimlerde görülen komutları yazarak bu işlemi gerçekleştirelim.

Not: Komutlarda yazılan parametrelerden 
   -S localhost: localhost isimli sunucu 
   -E: Windows Authentication ile bağlan 
   -d AdventureWorks -ed: AdventureWorks veritabanını aktif hale getir
   -t Urunler -et: Urunler isimli tabloyu aktif hale getir
anlamına gelmektedir. Farklı durumlarda kullanılabilecek parametreler için Command Prompt'ta aspnet_regsql -? komutunu yazarak yardım alabilirsiniz.



Resim: AdventureWorks veritabanında SqlCacheDependency nesneleri kuruldu ve veritabanı aktif hale geldi

Veritabanı aktif hale geldi. Bu işlem sonunda AdventureWorks veritabanına notification table ve stored procedure'lar kuruldu. Bir sonraki adımda ise artık ilgili tabloyu aktif hale getirmemiz gerekecek. Aşağıdaki resimde gördüğümüz komutla da Urunler adındaki tabloyu aktif hale getireceğiz.


Resim: Urunler isimli tablo veritabanında aktif hale geldi

Bu komut ile de Urunler adındaki tabloya gerekli trigger ve notification table'a da Urunler tablosunun kaydı yeni bir satır olarak eklendi. Artık bu tablo üzerinde gerçekleşen değişiklikleri SqlCacheDependency nesnesi ile takibini yapabilecek ve Cache nesnesinde saklanan verileri bu değişime göre güncelleyebileceğiz.

Adım-2
Uygulamanın SqlCacheDependency nesnesi ile veritabanına bağımlı işlemleri sağlıklı bir şekilde gerçekleştirebilmek için web.config dosyasında bu işlemi uygulama bazında aktif hale getirmek gerekecektir. Bu işlem için öncelikli olarak web.config dosyası içerisine bir connectionString eklemek, ardından da SqlCacheDependency tanımlamasını yapmak gerekecektir. Aşağıdaki kodlarda yapılması gereken tanımlamalar görülmektedir.


Resim: web.config dosyasına connectionString ekleme ve SqlCacheDependency ayarlamalarını yapmak

<system.web> düğümü içerisine eklenen <sqlCacheDependency> düğümünün niteliklerinden enabled="true" ifadesi SqlCacheDependency'i uygulamada aktif hale getirir. poolTime="3000" ise notification table'a ne kadarlık sürede bir bakılacağını; yani tablonun güncellenip güncellenmediğinin ne kadar sürede bir kontrol edileceğini belirler. (3000 değeri 3 saniye anlamına gelir) <databases> alt düğümünde ise hangi veritabanlarının kaydedileceği belirlenir. <add> ile eklenen veritabanında name="advConnDepend" ifadesi kaydedilen veritabanının adını, connectionStringName="advConn" ise hangi bağlantı cümlesinin kullanılacağını belirler. Buradaki advConn isimli bağlantı cümlesinin <connectionStrings> düğümünde olması gereklidir.

Adım-3
Uygulamada SqlCacheDependency ile veritabanına bağımlı şekilde Cache'de veri saklama  işlemlerini gerçekleştirmeden önce gerekli altyapıyı hazırladık. Şimdi ise uygulamada Cache'e atacağımız nesnenin SqlCacheDependency ile tablodaki değişimlere göre nasıl güncellenebileceğine bakalım. Bu işlem için Cache.Insert metodunun aşırı yüklenmiş versiyonlarından birini kullanmamız gerekecek.

public void Insert(string key, object value, CacheDependency dependencies);

Metodun parametrelerine bakacak olursak ilk parametre Cache'de saklanacak verinin çağrılacak adı, ikinci parametre Cache'de saklanacak veri, üçüncü parametre ise CacheDependency tipinden saklanacak verinin dosya veya veritabanına bağımlı kalmasını sağlayan nesnemiz olacaktır. Bizim üçüncü parametre olarak kullanacağımız CacheDependency sınıfından kalıtılan SqlCacheDependency sınıfından bir nesne olacaktır. İsterseniz şöyle bir senaryo üzerinden SqlCacheDependency nesnesinin kullanımına bakalım. Bir sayfada bulunan GridView kontrolünde veritabanından getirilen ürünleri listeleyelim. Burada getirilen veriler performans açısından her defasından veritabanında değil de Cache'den getirilsin istiyoruz. Yine SqlCacheDependency ile Cache'de sakladığımız verileri tabloda güncelleme olduğu sürece güncellenmesini istiyoruz. Aşağıdaki kodlar böyle bir işlemi nasıl gerçekleştirebileceğimizi göstermektedir.

protected void Page_Load(object sender, EventArgs e)
{
    // Cache'de saklanan nesnenin null olup olmadığını kontrol ediyoruz. Eğer veritabanında 
    // değişim olursa nesne bellekten kaldırılır; yani null olur. Böylece if bloğu çalışır 
    // ve güncel veriler tekrar alınıp Cache'e aktarılabilir. 

    if (Cache["veriler"] == null) 
    { 
        string baglanti = "data source=.; initial catalog=AdventureWorks; integrated security=true"; 
        string sorgu = "SELECT * FROM Urunler"; 
        SqlDataAdapter da = new SqlDataAdapter(sorgu, baglanti); 
        DataTable dt = new DataTable(); 
        da.Fill(dt); 

        // SqlCacheDependency nesnesini oluşturuyoruz. İlk parametre web.config'de tanımlanan 
        // SqlCacheDependency database'i. İkinci parametre ise veritabanında kontrol edilecek 
        // olan tablonun adı olacaktır. 
        SqlCacheDependency tabloyaBaglan = new SqlCacheDependency("advConnDepend", "Urunler"); 

        // dt isimli DataTable nesnesini Cache'e atıyoruz. İlk parametremiz Cache nesnesinin adı, 
        // ikinci parametre Cache'de saklanacak nesne; yani DataTable nesnesi, üçücü parametre 
        // ise tabloyaBaglan isimli SqlCacheDependency nesnesi olacaktır. Artık Cache'de saklanan 
        // veri Urunler tablosundaki değişimlere bağımlı olacaktır. Değişim olmadığı sürece 
        // değerler şu an oluşturulan nesneden alınacaktır.  Tabloda değişim olduğunda bu kod bloğu
        // tekrar çalışacağı için Cache'de saklanan verileri güncellenmesi otomatikmen gerçekleşir.
        Cache.Insert("veriler", dt, tabloyaBaglan); 
    } 

    // GridView kontrolünün DataSource değeri Cache'den getiriliyor. Gelen değer object tipinde olduğu
    // için DataTable'a cast işlemi gerçekleştiriyoruz.

    GridView1.DataSource = (DataTable)Cache["veriler"]; 
    GridView1.DataBind();
}

Böylece DataTable nesnesini artık Urunler tablosundaki değişimlere bağımlı kılarak Cache'de saklayabiliriz. Urunler tablosunda değişiklik olmadığı sürece veriler aynen Cache'de saklanacak, ne zaman ki tabloda değişiklik olursa o zaman veriler Cache'den kaldırılacak ve sayfanın bu esnadan sonraki ilk çalışmasında da Cache'e güncel veriler atılacaktır. Böylece zamana bağımlı bir kontrol söz konusu olmadan verinin değişimine bağımlı bir işlem gerçekleştirilebilecektir.


4. DataSource kontrolleri ile önbellekteki verilerle çalışmak

ASP.NET 2.0 öncesinde bir sayfada bulunan veri kontrollerini DataSet vb. veri kontrollerine bağlayarak veri işlemleri gerçekleştiriyorduk. ASP.NET 2.0 ile birlikte gelen SqlDataSource, AccessDataSource, ObjectDataSource gibi DataSource kontrolleri ile birlikte veri bağlama işlemlerini artık daha kolay ve pratik bir şekilde gerçekleştirebilmekteyiz. Bu yeni ASP.NET kontrollerinin önbellekleme işlemlerini kolay bir şekilde gerçekleştirmemizi sağlayan özelliklerinden biri de önbellekteki verilerle çalışabilmesidir.. EnableCaching özelliğinin true olarak ayarlanması ve CacheDuration özelliğinin saniye cinsinden bir değere atanması durumunda bağlanan veriler belirli bir süre boyunca önbelleğe alınacak ve buradan okunacaktır. Yine SqlCacheDependency özelliği ile bir SqlDataSource veri kaynağının SQL Server'daki tablonun değişim durumuna göre önbellekte saklanması sağlanabilmektedir. Aşağıdaki örnek kodlarda SqlDataSource kontrolünün SqlCacheDependency özelliği ile veriyi önbellekte saklayabilmesi sağlanmaktadır. Burada SqlCacheDependency özelliğinin aldığı değer advConnDepend:Urunler şeklindedir. advConnDepend web.config dosyasında tanımlanan SqlCacheDependecy veritabanının adı, Urunler ise tablonun adıdır.

<asp:SqlDataSource ID="SqlDataSource1" runat="server" ConnectionString="<%$ ConnectionStrings:advConn %>"
        SelectCommand="SELECT * FROM [Urunler]" EnableCaching="true" SqlCacheDependency="advConnDepend:Urunler">
</asp:SqlDataSource>


5. Custom Dependency'ler oluşturabilme

Cache işlemlerinde kullanılan CacheDependency sınıfı ASP.NET 1.1 sürümünde sealded bir sınıftı ve kalıtımda kullanılamıyordu. ASP.NET 2.0 ile birlikte artık normal bir sınıf olarak tanımlanan CacheDependency sınıfı sayesinde kendi sınıflarımızı CacheDependency sınıfından kalıtabilir ve Cache'de veri saklama  işlemlerinde kullanabiliriz. Böylece sadece dosya ve klasör değişimlerine bağımlı olmaksızın, kendi özel durumlarımıza göre sınıfımızı düzenleyip Cache'de saklanacak verilerin bağımlılık durumlarını belirleyebiliriz.

Böylece ASP.NET 2.0 ile birlikte performans yönetiminden gelen yenilikleri beş farklı başlık altında incelemiş olduk. Bir başka makalede görüşmek dileğiyle.

Uğur UMUTLUOĞLU
www.umutluoglu.com
www.nedirtv.com