İlkay İlknur
Just a developer...

.NET Framework Beta 2 - Dynamic Language Runtime Performans İncelemesi

Çarşamba, 27 Ocak 2010 17:26 by ilkayilknur

Merhaba Arkadaşlar,

Bu yazımızda daha önce sürekli bahsettiğimiz ama bir türlü somut verilerle gözlemlemediğimiz Dynamic Language Runtime'ın performansına göz atıyor olacağız. Bildiğiniz gibi DLR içerisinde bulunan Call Site Caching mekanizması bizim yaptığımız dinamik çağrımları içerisinde cacheleyip ileriki çağrımlarda kodun daha hızlı işletilmesini sağlamakta. Biz de bu yazı boyunca DLR'ın içerdiği çeşitli mekanizmalar üzerinde yaptığımız dinamik çağrımları gözlemleyeceğiz ve Call Site Caching'in aslında ne kadar faydalı olduğunu somut veriler ile bir daha anlayacağız.

Object Binder

Object Binder mekanizmasını test ederken karşılaştırma yapacağımız yöntem reflection mekanizması olacak. Arka arkaya hem dinamik hem de reflection kodlarını işleteceğiz ve her bir kodun işletilmesi ne kadar sürüyor bunu gözlemleyeceğiz. 

Test için öncelikle basit bir Foo sınıfı tasarlayacağız ve içerisine bir property bir de bu propertyi ekrana yazan bir metot ekleyeceğiz. Daha sonra ise bu propertyi hem dinamik hem de reflection ile değiştirip sonra yine bu iki farklı mekanizma ile metot çağrımını gerçekleştireceğiz.

Kodlar ise şu şekilde olacak.

class Foo    

{        

   public string MyProperty { get; set; }

   public void Print()

   {

       HttpContext.Current.Response.Write("<br/>MyProperty = " + MyProperty);

   }

}

Daha sonra ise Test metotlarını yazıyoruz.

protected void TestwithReflection()
{
   object obj = new Foo();
   Stopwatch watch = new Stopwatch();
   for (int i = 1; i < 11; i++)
   {
       watch.Restart();
       obj.GetType().GetProperty("MyProperty").SetValue(obj, string.Format("Test with Reflection -{0}", i), null); 
       obj.GetType().GetMethod("Print").Invoke(obj, null);
       watch.Stop();
       Response.Write("&nbsp;&nbsp;&nbsp;Elapsed Time :<strong>" + watch.Elapsed.TotalMilliseconds + "</strong>");
   }
}
protected void TestwithDLR()
{
   dynamic obj = new Foo();
   Stopwatch watch = new Stopwatch();
   for (int i = 1; i < 11; i++)
   {
      watch.Restart();
      obj.MyProperty = string.Format("Test with DLR -{0}", i);
      obj.Print();
      watch.Stop();
      Response.Write("&nbsp;&nbsp;&nbsp;Elapsed Time :<strong>" + watch.Elapsed.TotalMilliseconds + "</strong>");
   }
}

Uygulamamızı çalıştırdığımızda ise aşağıdaki gibi bir sonuçla karşılaşıyoruz.

Gördüğümüz gibi DLR sadece ilk çağrımda çeşitli çözümlemeler yaptığından dolayı fazla zaman harcamaktadır. Ancak yapılan diğer çağrımlarda reflectiona oranla çok daha hızlı bir şekilde kodun işletilmesi söz konusu olmaktadır.

Javascript Binder

Test yapacağımız bir diğer platform ise Silverlight olacak. Bu sefer kodlarımızı hem javascript hem de dinamik olarak C# tarafında yazacağız ve işletim sürelerini inceleyeceğiz. Çalıştıracağımız kodda yine basit olarak result isimli div elementi içerisine 100 kere string değerler ekleyeceğiz. 

Kodlar ise şu şekilde olacak 

Javascript Kodları :

function Test()
{
   for (var i = 0; i < 100; i++)
   {
       document.getElementById("result").innerHTML += "<br/>Call Test from javascript";
   }
}    

Daha sonra bu kodu C# tarafından hem dinamik olarak hem de window.Invoke yardımcı metoduyla çağırıyoruz. 

Çıkan sonuçlar ise şu şekilde


      

Herşey ortada Wink

Not : Javascript tarafında hassas bir ölçüm yapamadığımdan dolayı aynı javascript kodunun dinamik olarak C# tarafında implemente edemedim. Javascript tarafında hassas ölçüm yöntemini araştırdıktan sonra RC sürümünde bu kullanımı da test edeceğim.

Sonuçlara baktığımızda Call Site Caching yapısının DLR içerisinde ne kadar da önemli bir görev üstlendiğini görüyoruz. Böylece yaptığımız dinamik işlemler ilk çağrım haricinde yine hızlı bir şekilde yürütülmekte. 

Not : .NET Framework 4.0  şuanda Beta sürümünde olduğundan dolayı performanstan çok istenilen işlemlerin yapılmasına odaklanılmış durumda. Ancak Beta'dan sonra çıkacak olan sürümlerin performans açısından çok daha iyi olacaktır. Zaten .NET Framework 4.0 release tarihi de performans çalışmalarından dolayı 12 Nisan'a ertelenmiş durumda. RC sürümün çıkmasıyla yukarıdaki testleri yeniden yapacağım ve sonuçları sizinle paylaşacağım.

Yaptığım örnekleri siz de buradan indirip test edebilirsiniz.

Test Projects.rar (626,08 kb)

Herkese bol .NET'li günler... 

 

Categories:  
Actions:   E-mail | del.icio.us | Permalink | Yorumlar (0) | Yorumlar RSSRSS Yorum Takibi
Share

Dynamic Language Runtime - Silverlight Javascript Binder Mekanizması

Cuma, 22 Ocak 2010 21:08 by ilkayilknur

Merhabalar,

Bu yazımda Dynamic Language Runtime içerisinde bulunan ve Silverlight platformu ile beraber kullanılan Javascript Binder mekanizmasından bahsedeceğim. Bir önceki yazımda da bahsettiğim gibi Dynamic Language Runtime içerisinde birçok farklı binder mekanizmaları bulunmakta. Binderlar, yapılan dinamik çağrımların altlarındaki platformlarda çalışması için gereken bilgiye sahipler ve bu bilgileri kullanarak bu dinamik çağırımları gerçekleştirirler.

Javascript Binder ne iş yapar ?

Javascript Binder kısaca Silverlight tarafında yapılabilecek olan Javascript işlemlerini C# tarafında yapabilmemize olanak sağlar.

Javascript Binder'dan önce ne yapıyorduk ?

DLR olmadan önce Silverlight tarafından javascript tarafında bulunan herhangi bir metodu çağıracağımız zaman çeşitli yardımcı metotlar kullanmaktaydık. Bunun nedeni Javascript'in dinamik bir dil olması ve herşeyin çalışma zamanında gerçekleşmesiydi. Bu nedenle bizler de yardımcı metotlara çalıştıracağımız metodun adını vererek çalışma zamanında bu metotları çağırabiliyorduk. Öncelikle gelin isterseniz geleneksel yöntemlerle çalışan bir Silverlight uygulaması geliştirelim ve daha sonra bu uygulamayı DLR'ı kullanacak şekilde değiştirelim.

Yazacağımız uygulama basit olarak Silverlight tarafından alacağı enlem ve boylam bilgileri ile Bing Maps'i kullanarak bize o enlem ve boylama sahip olan bölgeyi Bing Maps'i kullanarak gösterecek.

Uygulamamıza öncelikle Silverlight tarafındaki arayüzü tasarlayarak başlayalım ve enlem,boylam bilgilerini alacak şekilde arayüzümüzü tasarlayalım. 

 

Arayüzü hazırladıktan sonra yapmamız gereken ise Silverlight tarafından çağıracağımız Javascript kodlarını yazmak. Bunun için öncelikle ilgili javascript kütüphanesini html dosyasından referans olarak alıyoruz.

<script type="text/javascript" src="http://ecn.dev.virtualearth.net/mapcontrol/mapcontrol.ashx?v=6.2"/>

Daha sonra ise haritayı bize gösterecek olan CreateMap isimli javascript metodumuzu yazıyoruz. Harita idsi map olan div elementinin içerisine yüklenecek. Bunun için Silverlight object taglerinin hemen altına bu div elementini ekliyoruz. Smile (Bing Maps ile ilgili daha detaylı bilgi edinmek isterseniz MSP arkadaşım Mehmet Aydın Bahadır'ın blogunu ziyaret edebilirsiniz.)

<script type="text/javascript">
  var map = null;
  function CreateMap(latitude,longtitude) { // Enlem ve boylam bilgileri alınır.            
           var latlong = new VELatLong(latitude, longtitude);  
           map = new VEMap("map"); // map id si olan div içerisinde harita yaratılır
           map.LoadMap(latlong, 5, 'h', false);  // Harita yüklenir        
  }
</script>

Javascript metodunu yazdıktan sonra gerçekleştireceğimiz son adım ise butona tıklandığı zaman Silverlight kodundan javascript metodunu çağırmak. Bunu gerçekleştirmek için System.Windows.Browser.HtmlPage nesnesinin Window isimli üyesi üzerinden Invoke metodunu çağıracağız. Invoke metodu içerisine öncelikle çağıracağımız javascript metodunun adını daha sonra javascript metoduna gönderilecek olan parametreleri vereceğiz. Tüm kod ise aşağıdaki gibi olacak.

HtmlWindow window = HtmlPage.Window;

private void btnUpdate_Click(object sender, RoutedEventArgs e)
{  
       window.Invoke("CreateMap", textBox1.Text, textBox2.Text);
}

Uygulamayı çalıştırdığımızda en başta ekranda tasarlarken verdiğimiz değerlere yakın bir değer verirsek Türkiye haritasını görebiliriz. Smile

Bu noktaya kadar uygulamayı şuana kadar kullandığımız yöntem olan yardımcı metot yöntemini kullanarak gerçekleştirdik. Şimdi ise gelelim Dynamic Language Runtime ile beraber kullanımına. Gereken değişiklikleri yapmadan önce Javascript Binder'ın çalışması için Microsoft.CSharp kütüphanesini projemize referans etmemiz gerekmekte. Normalde Microsoft.CSharp dll'ini Silverlight projesine referans olarak ekleyemiyoruz. Bunun için C:\Program Files\Microsoft SDKs\Silverlight\v4.0\Libraries\Client klasöründe bulunan Microsoft.CSharp Silverlight dll'ini projemize referans olarak ekliyoruz. Artık yapmamız gereken sadece dinamik programlama.Wink

Öncelikle yukarıda statik bir şekilde olarak tanımladığımız HtmlWindow nesnesini bu sefer dinamik olarak tanımlayoruz. Daha sonra ise sanki C# tarafından bir kod çağırıyormuşuz gibi metot ismini kullanarak çağırımı gerçekleştireceğiz. Değişmiş kodumuz ise şu şekilde olacak.

dynamic window = HtmlPage.Window;
private void btnUpdate_Click(object sender, RoutedEventArgs e)
{     
       window.CreateMap(textBox1.Text, textBox2.Text);
}

Uygulamayı çalıştırdığımızda ise yine aynı şekilde Türkiye haritasını görüyoruz. Peki bu değişikliklerden sonra uygulamanın işleyişi nasıl değişti ? Öncelikle artık HtmlWindow nesnesi dinamik olarak tanımlandı. Yani artık nesnenin tipi ve sahip olduğu tüm metotlar çalışma zamanında belirlenecek ve çalışma zamanına kadar type-checking yapılmayacak. İşte bu nedenden dolayı artık window nesnesi üzerinden doğrudan yazdığımız javascript metodunu çağırabiliyoruz. Çünkü çağırım dinamik olarak yapılıyor.

Şimdi isterseniz işi biraz daha abartalım Laughing ve javascript tarafına yazdığımız metodu tamamen kesip C# tarafına yapıştıralım ve birde bu şekilde çağırım yapmaya çalışalım. Tabi öncelikle yazdığımız metodu javascript metodu yerine C# metodu haline getireceğiz. Bunun için öncelikle var olarak tanımladığımız değişkenleri bu sefer dynamic olarak tanımlayacağız ve böylece javascript tarafındaki işlevselliği C# tarafında da yakalayacağız. Son olarak ise new ile yarattığımız nesne aslında bir javascript nesnesi bu nedenle aynı syntaxı kullanarak C# tarafında javascript nesnesi yaratamıyoruz. Bunun için ise dinamik window nesnesini kullanıyoruz ve window.CreateInstance("Tip adı",Parametreler) şeklinde nesneyi yaratıyoruz. (Fark ettiğiniz gibi aslında burada bir dinamik çağrım yok. Bunun için yeni bir syntax üzerinde çalışılmakta. Final sürüm ile beraber Javascript nesneleri yaratmak için özel bir syntax eklenecek. Wink) Daha sonra ise bu sefer C# tarafında bulunan CreateMap metodunu çağırıyoruz.

dynamic window = HtmlPage.Window;

private void btnUpdate_Click(object sender, RoutedEventArgs e)

{

   CreateMap(textBox1.Text, textBox2.Text);

}

dynamic map = null;

void CreateMap(dynamic latitude, dynamic longtitude)

{ // Enlem ve boylam bilgileri alınır.

   dynamic latlong = window.CreateInstance("VELatLong",latitude, longtitude);

   map = window.CreateInstance("VEMap","map"); // map id si olan div içerisinde harita yaratılır

   map.LoadMap(latlong, 5, 'h', false);  // Harita yüklenir        

}

Gördüğünüz gibi tüm kodları artık C# ile yazdık ve tamamen dinamik bir şekilde kodlar işletildi. Son olarak C# tarafından Html içerisinde bulunan elementlere erişeceğiz. Hepimizin javascript tarafında kullandığı getElementById metodu artık C# tarafında da geçerli. Smile Bunun için HtmlDocument nesnesini dinamik olarak tanımlamamız yeterli. Mesela HTML sayfamıza idsi  message olan bir div elementi ekleyelim ve bu element içerisine harita yüklendikten sonra C# tarafından bir mesaj yazalım.

void CreateMap(dynamic latitude, dynamic longtitude)
{ // Enlem ve boylam bilgileri alınır.            
   dynamic latlong = window.CreateInstance("VELatLong",latitude, longtitude);
   map = window.CreateInstance("VEMap","map"); // map id si olan div içerisinde harita yaratılır
   map.LoadMap(latlong, 5, 'h', false);  // Harita yüklenir
   dynamic document = HtmlPage.Document;
   dynamic messagedivision = document.getElementById("message");
   messagedivision.innerText = "A message comes from C#";
}

Bu makalemizde Dynamic Language Runtime içerisinde bulunan Javascript Binder mekanizmasını inceledik. Özellikle Javascript - Silverlight etkileşiminde Javascript Binder mekanizması yeni bir yaklaşım getirmekte. Ayrıca performans bakımından da herhangi bir handikap olmadan. Hatta caching mekanizması ile klasik yaklaşımdan daha da hızlı işletim elde edebilmekteyiz. Bununla ilgili sayısal bilgileri bir sonraki yazımda paylaşıyor olacağım.

Görüşmek Üzere

Categories:  
Actions:   E-mail | del.icio.us | Permalink | Yorumlar (0) | Yorumlar RSSRSS Yorum Takibi
Share

Dynamic Language Runtime (DLR) Nedir ?

Cuma, 15 Ocak 2010 01:10 by ilkayilknur

Merhaba,

.NET Framework 4.0'ın çıkmasıyla birlikte hayatımıza girecek en büyük yeniliklerden biri de dinamik programlama. Zaten C# programlama dilinin gelecek olan 4.0 versiyonunun teması da "Dinamik Programlama" olarak belirlenmiş durumda.

Günümüzde baktığımızda dinamik programlama paradigması oldukça popüler durumda. Peki bu kadar popüler olmasının nedenleri neler öncelilkle bunlara bir gözatalım. 

  • Herhangi bir tip seçiminin yapılmaması,
  • Derleme yapılmaması, yorumlama ile kodların çalıştırılması,
  • Tüm işlemlerin (tip atamalarının, tip bağlamalarının) çalışma zamanında yapılması,
  • Geliştiriminin kolay olması olarak söyleyebiliriz.
Ayrıca IronPython, IronRuby gibi dinamik programlama dilleri ile .NET altyapısını da kullanarak uygulamalarımızı daha hızlı ve etkin bir şekilde geliştirebilmekteyiz. .NET Framework 4.0 ile beraber ise artık bizler de dinamik işlemler yapabiliyor ve dinamik programlama dilleri ile konuşabiliyor olacağız. Bu yazımızda ise bizlere bu dinamik altyapıyı sunacak olan Dynamic Language Runtime (DLR) yapısını inceliyor olacağız. 

Dynamic Language Runtime (DLR) Nedir ?


DLR

 

Dynamic Language Runtime temel olarak  IronPython,IronRuby gibi dinamik programlama dillerinin Common Language Runtime (CLR) ile iletişim kurmasını sağlayan aynı zamanda da C# ve VB gibi statik programlama dillerine de dinamik özellikler, yetenekler kazandıran bir altyapı sağlamaktadır. Dynamic Language Runtime içerisine baktığımızda ise karşımıza 4 temel yapıtaşı çıkmaktadır.

Bunlar:

  • Expression Trees
  • Dynamic Dispatch
  • Call Site Caching
  • Binders
Bu yapıların hepsini teker teker incelersek,

Expression Trees 

Expression Trees yapısı aslında LINQ ile beraber .NET Framework içerisine eklenen bir yapıdır. Temel olarak yazılan kodların doğrudan direkt olarak MSIL'e çevrilmeden bir ağaç yapısında tutulmasını sağlamaktadır. Daha sonra bu ağaçlarda bulunan kodlar çalışma zamanında derlenerek yazılan kodların dinamik olarak çalıştırılması gerçekleşmektedir. Bu nedenle bu mekanizma DLR içerisinde de yoğun olarak kullanılmaktadır.

Dynamic Dispatch

Dynamic Dispatch yapısı ile çalışma zamanında dinamik metot çağırımlarına imkan sağlanmaktadır. Örneğin derleme zamanında hangi metodun çağırılacağının belli olmadığı durumlarda dynamic dispatch kullanılarak hangi metodun çağırılacağına karar verilmektedir.

Call Site Caching

DLR içerisinde bulunan en önemli yapılardan biri de Call Site Caching mekanizmasıdır. DLR'ın bu kadar etkin ve Reflection'a göre bu kadar hızlı çalışmasının en önemli nedeni olduğunu rahatlıkla söyleyebiliriz. Call Site Caching ile çalışma zamanı sırasında yapılan dinamik çağrımlar Call Site Cache içerisinde saklanmaktadır. Böylece uygulamanın çalışma evresi içerisinde yapılacak olan diğer çağrımlardan önce eğer cache içerisinde tutulmuş bilgi varsa doğrudan bu bilgi kullanılarak kod daha hızlı olarak çalıştırılmaktadır. Oysaki daha önce kullandığımız reflection mekanizmalarında bizim yazdığımız tüm reflection işlemleri kodun her çağrımında defalarca yapılmaktadır. 

Binders

DLR içerisinde DLR'ın iletişim kurabildiği platformlar ile ilgili tüm bilgilere sahip olan Binder yapıları bulunmakta. Binder yapısı üst taraftaki yazılan kodun alt tarafta bulunan platformlarda nasıl çalıştırılacağı (bind edileceği) ile ilgili tüm bilgileri taşımaktadır ve gerektiğinde de ilgili işlemleri gerçekleştirmektedir. 

Yazılan dinamik bir kodun çalışmasını kısaca özetlersek: Dinamik bir çağrım yapılmadan önce bu çağırımla ilgili daha önce yapılıp yapılmadığıyla ilgili bilgi edinmek için Call Site Cache'e bakılır. Eğer bilgi bulunursa direkt olarak buradan kod çalıştırılır. Ancak herhangi bir bilgi bulunamazsa altyapıdaki ilgili binder kullanılarak kod çalıştırılır ve gerekli bilgiler ileride kullanılmak amacıyla Call Site Cache'e eklenir.

Dynamic Language Runtime ile ilgili değinmemiz gereken önemli noktalardan biri de DLR'ın doğrudan ve sadece Microsoft tarafından geliştirilmediği. Aslında DLR Microsoft ve topluluklar ile beraber geliştirilmekte olan bir topluluk projesi. DLR'ın bir kısmının doğrudan .NET Framework içerisine gömülü olmasına rağmen özellikle ileriki yazılarımda bahsedeceğim Script Hosting ile ilgili kütüphaneler IronPython, IronRuby dillerini geliştiren topluluklar tarafından geliştirilmektedir.

DLR'ın alt kısmında ise oldukça heyecan verici mekanizmalar bulunmakta. Özellikle Silverlight tarafında bulunan JavascriptBinder ile yazacağınız Javascript kodlarını artık doğrudan C# içerisinden yazabiliyorsunuz.  JavascriptBinder'ın kullanımından da ilerleyen günlerde bahsediyor olacağım.

İyi geceler Smile

Categories:  
Actions:   E-mail | del.icio.us | Permalink | Yorumlar (0) | Yorumlar RSSRSS Yorum Takibi
Share

Visual Studio 2010 Beta 2 üzerinde CopySourceAsHtml eklentisini çalıştırma

Salı, 12 Ocak 2010 22:11 by ilkayilknur

Merhaba,

Copy Source as HTML Addin'i blog yazarları için hayati bir önem taşımakta. Yazdığımız kodları doğrudan blogumuzda yada gönderdiğimiz maillerde Visual Studio içerisinde göründüğü renklendirme ve formattaki gibi paylaşmamızı sağlıyor. Ancak bu Addin'in Visual Studio 2010 için çıkarılmış bir beta yada preview gibi bir sürümü bulunmamakta. Bu nedenle Visual Studio 2010'da yazdığımız kodları paylaşmak için farklı yollar deniyorduk. Biraz araştırma yaparsak en azından Addin'in Visual Studio 2010 için bir sürümü çıkana kadar 2008 için çıkarılan versiyonunu Visual Studio 2010'a entegre edebildiğimizi görüyoruz. Öncelikle eğer bu Addin sisteminizde yüklü değilse bu adresten yükleyebilirsiniz. Yükleme adımını geçtikten sonra "C:\Users\{Windows Kullanıcı Adı}\Documents\Visual Studio 2008\Addins" dizininde CopySourceAsHtml.AddIn isimli bir dosya oluştuğunu göreceğiz. Bu dosya Addin ile ilgili tanımlamaları içeren bir XML dosyası. Biz de Visual Studio 2010'a Addin'i entegre etmek için bu dosyayı kullanacağız. Bu dosyayı olduğu gibi kopyalayıp  "C:\Users\{Windows Kullanıcı Adı}\Documents\Visual Studio 2010\Addins" klasörüne yapıştırmamız gerekiyor (Addins klasörü bulumuyorsa elinizle oluşturunuz). Daha sonra Visual Studio 2010'u çalıştırdığımızda Addin'in çalışmadığını göreceğiz. Yapmamız gereken tek bir değişiklik kaldı. O da Addin dosyası içerisinde bulunan Visual Studio versiyonunu değiştirmek. CopySourceAsHtml.AddIn dosyasını herhangi bir editör yardımıyla açtıktan sonra Version bilgilerini aşağıda göründüğü gibi 10.0 olarak değiştirmeniz gerekmekte. 

 

<?xml version="1.0" encoding="utf-8" standalone="no"?>
<Extensibility xmlns="http://schemas.microsoft.com/AutomationExtensibility">
   <HostApplication>    
       <Name>Microsoft Visual Studio Macros</Name>
       <Version>10.0</Version>
   </HostApplication>
   <HostApplication>
       <Name>Microsoft Visual Studio</Name>

       <Version>10.0</Version>

   </HostApplication>

Tüm bu değişiklileri yaptıktan sonra Visual Studio 2010'u açarsak Copy Source as HTML Addin'in kodu seçip sağı tıkladığımızda görünür olduğunu göreceğiz. 

 

Addin'in Visual Studio 2010 için bir sürümü çıkana kadar bu şekilde kullanabilirsiniz. Ben şuana kadar herhangi bir sorunla karşılaşmadım. Smile

Herkese kolay gelsin

Categories:  
Actions:   E-mail | del.icio.us | Permalink | Yorumlar (0) | Yorumlar RSSRSS Yorum Takibi
Share

.NET Framework 4.0 - Tuple Sınıfı

Pazartesi, 11 Ocak 2010 20:44 by ilkayilknur

Merhaba,

Blogumun ilk teknik yazısında .NET Framework 4.0 ile beraber gelecek olan Tuple sınıfını inceliyor olacağız. Tuple kavramı aslında F# programlama dili içerisinde kullanılan bir kavram. Bizlere tek bir tip içerisinde birden fazla farklı tipteki verileri saklama olanağı sağlamakta. Baktığımız zaman aslında bizlere bu kavram çok ta yabancı gelmemekte. Biz zaten C# 3.0 ile gelen anonymous type'ları kullanarak tek bir tip içerisinde birden fazla tipteki veriyi saklayabiliyoruz. Ancak anonymous tiplerin kullanımlarında birtakım kısıtlamalar bulunmakta. Bunlardan da yazının sonunda bahsediyor olacağım. Smile   

Öncelikle örneklere geçmeden önce Tuple sınıfının yapısına bir göz atalım.

 

Gördüğümüz System isim uzayı içerisinde 8 adet çeşitli generic tipler alan Tuple sınıfları bulunmakta. Her bir nesne yaratıldığı sırada aldığı tipteki değerleri içerisinde taşımakta. Tuple sınıfına baktığımızda maksimum 8 adet veri taşıyabildiğimizi görüyoruz. Ancak dikkatlice bakarsak T7 tipinden sonraki tip adı T8 değil de TRest olarak isimlendirilmiş. Biz bu parametreye eğer bir Tuple nesnesi verirsek aslında bu tip sayısının limitini kolayca arttırabiliriz. 

Bir Tuple nesnesini yaratmak için ise çeşitli alternatif yollar bulunmakta.

1- new ile yeni bir Tuple nesnesi oluşturma 

Tuple nesnesini oluşturmak için Tuple sınıfını yazdıktan sonra generic parametrelere ihtiyacımız olan tipleri belirttikten sonra yapıcı metot içerisinde ilk değer atamalarını yapabiliriz. 

var data = new Tuple<int, string>(2, "ilkay");
var data1 = new Tuple<double, int, string>(12.3, 34, "Tuple Denemesi");

2- Create static metodunu kullanarak Tuple nesnesi oluşturma

İkinci alternatif yolumuz ise Tuple sınıfı içerisinde bulunan Create adındaki static metodu kullanmak. Aslında kullanımının yukarıdaki kullanımdan hiçbir farkı bulunmamakta. Sadece burada ihtiyacımız olan tipleri Create adındaki generic metotta belirtmekteyiz.

var data = Tuple.Create<int, string>(2, "ilkay");
var data1 = Tuple.Create<double, int, string>(12.3, 34, "Tuple Denemesi");

Tuple nesnemizi başarıyla yarattık. Şimdi gelelim yarattığımız değerlere nasıl ulaşacağımıza. Aslında nesne içerisindeki üyelere baktığımızda zaten üye adları bize oldukça yardımcı olmakta.

Üyelere baktığımızda Item ile başlayan propertyler karşımıza çıkmakta. Bu propertylerin tipleri Tuple nesnesi yaratırken belirttiğimiz tipleri ve değerleri taşımakta.

Yazımın başında Tuple nesnesinin en fazla 8 adet veri taşıyabileceğinden ve 8. parametrenin tipinin TRest olarak adlandırıldığından bahsetmiştim. TRest parametresini kullanarak son tipe eğer yeni bir Tuple nesnesi eklersek bu 8 parametre sınırını rahatça ortadan kaldırabiliriz.

Örneğin,

var data = new Tuple<int, int, int, int, int, int, int, Tuple<int, int, int>>(1, 2, 3, 4, 5, 6, 7, Tuple.Create<int, int, int>(8, 9, 10));

Console.WriteLine(data.Rest.Item3);

Yukarıdaki örnekte 10 elemanlı bir Tuple nesnesi elde etmekteyiz. 7. elemandan sonraki elemanlara ise Rest referansı kullanarak ulaşmaktayız. Örnekte 10. eleman ekrana yazdırılmaktadır.

Gelelim Tuple sınıfını nerelerde kullanabileceğimize. Anonymous tiplerin bir takım kısıtlamaları olduğundan bahsetmiştim. Bunlardan biri anonymous tiplerin metotlara parametre olarak geçirilememesi. Ancak Tuple sınıfı kullanılarak bu kısıtlamanın önüne geçerek parametre olarak Tuple sınıfını geçirebiliriz. Böylece anonymous tiplerde gerçekleştirmek istediğimiz fonksiyonaliteyi gerçekleştirmiş olmaktayız. Bir diğer kısıt ise yine anonymous tiplerin metotlardan geri dönüş tipi olarak ta kullanılamaması. Bu sefer yine dönüş tipi olarak Tuple sınıfını kullandığımızda metottan birden fazla değer döndürebilmekteyiz (out parametreleri kullanmadan). Son olarak bahsedeceğim kullanım alanı ise zorunlu olarak tek bir parametre alan metotlar. Bunlara örnek vermek gerekirse parametre alan Thread metotları sadece tek bir object parametresi almak zorunda. Ancak birden fazla parametre vermek istediğimizde Tuple sınıfını akıllıca ve hızlı bir şekilde kullanabiliriz. 

static void Main(string[] args)        
{            
        var data = new Tuple<int, int>(2, 3);
        ParameterizedThreadStart start = new ParameterizedThreadStart(ThreadTest);
        Thread thread = new Thread(start);
        thread.Start(data);        
}
static void ThreadTest(object obj)
{
        Tuple<int, int> data = obj as Tuple<int, int>;
        Console.WriteLine("Item1 : {0} \nItem2 : {1}", data.Item1, data.Item2);
        Console.ReadLine();
}
  
 

Tuple sınıfını yukarıdaki şekilde kullanarak 2 adet integer tipindeki parametreyi metodumuza kolayca geçirebilmekteyiz. Tuple sınıfının generic parametrelerini dynamic olarak belirleyerek çok daha esnek bir şekilde ve farklı senaryolarla bu sınıfı kullanabiliriz.

.NET Framework 4.0 ile beraber gelecek olan Tuple sınıfı incelememizin sonuna geldik. 

Herkese iyi akşamlar

Categories:   .NET Framework 4.0
Actions:   E-mail | del.icio.us | Permalink | Yorumlar (0) | Yorumlar RSSRSS Yorum Takibi
Share

Yeni Blog

Pazartesi, 11 Ocak 2010 15:40 by ilkayilknur
Merhaba, Uzun süredir aklımda olan kendi adıma ait bir blog kurma adımını gerçekleştirmiş bulunmaktayım. BlogEngine.NET altyapısına geçmenin de verdiği esneklikle ileride blogumu daha da özelleştireceğim. Yeni bloğa geçmemle beraber sıraya koyduğum pekçok konuda yazılarımı yayınlamaya başlayacağım. Herkese bol .NET'li günler...
Categories:  
Actions:   E-mail | del.icio.us | Permalink | Yorumlar (0) | Yorumlar RSSRSS Yorum Takibi
Share