XAML ve Embedded Kod

Haziran 18, 2007 at 7:19 Cavusoglu

XAML teknolojisi ASP.NET üzerinde olduğu gibi Embedded kod teknolojisini desteklemektedir. XAML derlenme aşamasında x:Code ile belirlenen kod alanını *.g.cs dosyasının içerisinde aktarır. CDATA aslında gerekli değildir. Fakat XML parse aşamasında burda ortaya çıkabileçek bazı karakter sorunlarını '&' gibi, bu alanı işlem dışı tutarak giderir. Embedded kod kullanımı UI ile kod yazımını ayırma mantığına ters düşsede yeni bir özellik olarak sisteme eklenmiştir.

Posted in: WPF & Silverlight

Tags: , ,

ROMA

Mart 8, 2007 at 8:50 Cavusoglu
..

Posted in: Yaşama Dair

Tags: ,

MEDA Regional Project - 2nd Regional Workshop of Component 4 eLearning

Şubat 28, 2007 at 8:23 Cavusoglu
MEDA-ETE projesinin 2. bölgesel toplantısını Sestri Levante kasabasında gerçekleştirdik. Mükemmel havası ve güzelliğiyle tekrar bu güzel akdeniz sahil kasabasında bulunmak, beni gerçekten mutlu etti.

Posted in: E-Learning

Tags:

ETE- MEDA Regional Project - Regional Workshop of Component 4

Eylül 20, 2006 at 8:14 Cavusoglu

Projenin ilk bölgesel toplantısı 18-19 Kasım 2006 tarihlerinde İtalya'nın güzel kasabalarından Sestri Levante'de gerçekleştirildi. Toplantıda katılımcı diğer ülkeler ve ETF yetikilileri ile tanışma ve fikir alışverişi gerçekleştirildi.

 

Posted in: E-Learning

Tags:

MEDA Projesi için ilk Türkiye toplantısı

Nisan 25, 2006 at 8:09 Cavusoglu
Angela Maria Sugliano katılım ile MEDA-ETE projesinin 4. Bileşenine ait ilk toplantı İstanbulda gerçekleştirildi. Toplantıda ülke koordinatörlüğü ve yapılacaklarla ilgili karar alındı. Bende ülke koordinatörü olarak projede görev almaya başladım.

Posted in: E-Learning

Tags:

Mısır Seyahati

Ağustos 8, 2004 at 8:46 Cavusoglu

Çok uzun zamandır gitmek istediğim ama bir türlü fırsat bulup gidemediğim Mısır'a gittim. Tarihi eserleri ve Kızıl Deniz'i ile gerçekten görülmesi gereken bir yer. Kızıl Deniz bir akvaryumu andırıyor. Pramitler ve diğer eserlerle sizi bin yıllar öncesine götüren bir ülke. Hediyelik eşya için bir cennet ama pazarlığa dikkat edin. Kahire'de bulunan El halil çarşısını tercih etmeniz ve pazarlık etmeniz yararınıza olacaktır.

Posted in: Yaşama Dair

Tags: ,

Exception ( İstisnalar ) 2

Haziran 11, 2004 at 4:37 Cavusoglu
  

Net platformu üzerinde istisna yönetimi ile ilgili daha önce bir makale yayınlamıştık. Şimdi ki makalemizde kendi istisnalarımızı oluşturmayı, Exception nesnesinden yeni istisna sınıfları türetmeyi ve istisnaları fırlatmayı göreceğiz Programcılara çoğunlukla yazılım geliştirme aracının ( Visual Studio.NET) sunmuş olduğu istisna sınıfları yeterli gelmektedir. Bununla birlikte özel bir bileşen geliştirme aşamasında bazen özel istisnalara ihtiyaç duyarız. Bu bileşen içerisinde meydana gelen hataları kendimiz yönetmek isteriz. Öncelikle istisnaları isteğimize bağlı ortaya çıkartmayı göreceğiz.

THROW ifadesini kullanma :

Throw ifadesi istisnaları istediğimiz anda ortaya çıkartmamıza imkan vermektedir. Throw ifadesi Exception sınıf veya bu sınıftan türetilmiş herhangi bir istisna sınıfı için kullanılır. Throw ifadesinin kullanıldığı noktada program durarak; istenilen istisnayı üretir. Bu istisna daha önceki makalemizde anlattığımız gibi yönetilebileceği gibi, hata mesajından da yararlanılabilir. Aşağıda throw kullanımına ait bir kaç örnek bulunmaktadır.

 

using System;
namespace Exception2
{
      class Istisnalar
      {
           [STAThread]
           static void Main(string[] args)
           {
                  throw new Exception();
           }
       }
}

Yukarıda ki örnekte istisna temel sınıf olan Excepition nesnesinden oluşturulmuştur. Bu hata try catch, finally blokları ile yakalanabilir. Exception nesnesinin 3 çeşit yapıcısı bulunmaktadır. Farklı yapıcıların kullanıldığı bir örnek aşağıda bulunmaktadır.

using System;
namespace Exception2
{
       class Istisnalar
      {
           [STAThread]
           static void Main(string[] args)
           {
                  try
                  {
                         throw new Exception(); // İstisna oluşur fakat herhangi bir özel mesaj yoktur.

                        
throw new Exception("Benim istisna mesajım"); // İstisna oluşur ve özel hata mesajı üretirlir.

                  }
                  catch (Exception e)
                  {
                        Console.WriteLine(e.Message);
                        throw new Exception("Hata Meydana Geldi",e); // Hata mesajı ile birlikte dışardan oluşan hata sınıfa gönderilir.
                  }
                  
           }
       }
}

Yukarıda ki örneğimizde Exception temel istisna sınıfı kullanılarak 3 farklı şekilde istisna ortaya çıkartılmıştır. 1. şekilde ortaya çıkan hata ile ilgili herhangi bir mesaj verilmekmektedir. 2. şekilde ise ortaya çıkan istisna ile birlikte bir hata mesajı da mevcuttur. 3. şekilde ise ortaya çıkan genel bir hatadan isteğimize bağlı bir hata üretilmesi sağlanmış ve dışarıda oluşan genel hata kullanılan hata sınıfına bildirilmiştir. Şu an için son yöntem bir şey ifade etmiyor gibi gözüksede ileriki satırlarımızda kendi istisna nesnemizi oluşturduğumuzda innerexception diye adlandırılan bu istisna referansı tarafımızca kullanılabilecektir.

Throw ifadesi Exception sınıfından türetilmiş istisna sınıfları içinde kullanılabilir.

 

using System;
namespace Exception2
{
       class Istisnalar
      {
           [STAThread]
           static void Main(string[] args)
           {
                  try
                  {
                         throw new
DivideByZeroException(); // sıfıra bölünme istisnası isteğe bağlı oluştu.
                  }
                  catch (Exception e)
                  {
                        Console.WriteLine(e.Message);
                        
                  }
                  
           }
       }

}

Yukarıdaki örneğimizde DivideByZeroException istisnasının ortaya çıkmıştır. Bu istisna sonucu olarak ekrana Attampted to divide by zero istisna mesajı gözükecektir.

Exception nesnesinden istisna sınıfları türetme :

İstisna sınıflarının tamamı Exception temel sınıfından yaratılmıştır. Her alanda çeşitli istisna sınıfları olduğunu önceki makalemizde söylemiştik. Peki çok özel bir istisna sınıfına ihtiyacımız olursa ne yapmamız gerekir. Başlığımızdan da anlaşılacağı gibi kendi sınıfımızı türetmemiz yeterlidir. Bu sınıf içerisinde istisna meydana geldiğinde istediklerimizi yapacak kodları bulundurabiliriz.

Temel Exception sınıfı üzerinde çeşitli özellikler ve methodlar bulunmaktadır. Bu özellik ve methodlar ezilerek kullanılabilceği gibi isteklerimiz doğrultusunda yeni özellikler ve methodlarda ekleyebiliriz. Oluşturulan bu istisna sınıf throw ifadesi ile ortaya çıkartılabilir.

Şimdi bilinenlerden farklı ihtiyaçlarımıza bağlı bir istisna sınıfı oluşturalım. Bu istisna sınıfı her kullanıldığında ürettiği hata mesajını bir dosyanın içinde barındırabilsin. Tabiki ihtiyaçlarınız doğrultusunda bu bir veritabanı da olabilir.

using System;
namespace Exception2
{
       class Istisnalar
      {
           [STAThread]
           static void Main(string[] argös)
           {
                  try
                  {
                         throw ResulException("Hata Oluşturuyorum");
                  }
                  catch(ResulException e)
                  {
                        e.LogYaz("c:\hatalar.txt");
                        Console.WriteLine(e.Message);
                  }
                  
           }
       }

       class ResulException : Exception
      
{
          public ResulException():base()
          {
          }
          public ResulException(string tempmessage):base(tempmessage)
          {

          }
          public void LogYaz(string logfile)
          {
                    ......................................
                    ...............................
                    ...............................
          }
       }
}

Örneğimizde Exception sınıfından ResulExcepiton isminde bir sınıf türettik. Bu sınıf Exception sınıfına ait yapıcı methodlara base göndermese yapıyor. Temel olarak Exception sınıfının özelliklerini kullanabiliyor. Bu özelliklere ek olarak belirtilen dosya içine isteğimize bağlı olarak hata mesajlarını yazıyor. Bu şekilde ki istisna sınıfı kullanarak bir hatalar günlüğü tutmamızda mümkün olabilir.

İstisnalar ile ilgili kuralımızı yeniliyoruz. Gerekmedikçe istisna kullanmak program performansını düşürür. Fakat kritik noktalarda istisna kullanmak ve bu istisnaları yakalamak büyük kayıpları engeller. Bir sonraki makalemizde görüşmek üzere.

Posted in:

Tags: , ,

Exception ( İstisnalar ) 1

Haziran 2, 2004 at 4:35 Cavusoglu
 

İstisna (Exception)kavramı programlama açısında büyük bir önem taşımaktadır. Bütün gelişmiş programlama dillerinde istisnaları yönetmek için çeşitli yöntemler ortaya konulmuştur. Bu yöntemler birçok açıdan benzerlikler gösterse de, çeşitli farklılıklar da bulunmaktadır. Öncelikle istisna kavramını bir inceleyelim.

İstisnalar, programımızın çalışma zamanında yani program çalışırken ortaya çıkan olağan dışı durumlardır. Programcılık dilinde "programın kırılması" ile adlandırılan olaylarda aslında bir istisnanın meydana geldiğini göstermektedir. Örneğin bir sayının sıfıra bölünmesi "DivisionDivideByZeroException" istisnasının ortaya çıkmasına sebep olmaktadır. Başka bir istisna örneği ise uyumsuz tipler arasında değer aktarımı gerçekleştirmeye çalışmaktır. Bir programcı olarak kod üzerinde her ne kadar detaylı çalışma yapsakta kullanıcı faktörü göz önüne alındığında çalışma zamanı hatalarının ( Runtime Error ) ortaya çıkması olasıdır. Aşağıdaki örneğimiz, çalışma zamanında ortaya çıkabilecek bazı istisnaları göstermektedir.

using System;
namespace Exception1
{
       class Istisnalar
      {
           [STAThread]
           static void Main(string[] args)
           {
                  int sayi1 = 25;
                  int sayi2 = 0;
                  int sonuc = 0; sonuc = sayi1 / sayi2;   // Sıfıra bölünme hatası
                  sonuc = int.Parse("selam");                // Tür dönüşüm hatası
                  myobj.ToString();                            // Null referance hatası
           }
       }
}

Bu ve benzeri bir çok hata .NET platformu tarafından izlenmekte ve gerekli istisnalar ortaya çıkartılmaktadır. İstisnalar iki şekilde ortaya çıkar.

1. Yazılım geliştirici "throw" ifadesini kullanarak kendi istisnası ortaya çıkartabilir.
2. Yukarıdaki örneklerimizde de ortaya çıkan ve programımızın normal olarak devamını sürdürmesini engelleyecek hatalardır.

Bu makalemizde programımızın normal işleyişini bozan istisnaları yönetmeyi inceleyeceğiz. Bu noktada unutulmaması gereken ilk nokta istisna yönetimi performans açısından pahalı bir seçenektir. Bu nedenle programcılıkta ilk seçeneğimiz programımıza giriş yapan bütün değerleri maskeleme, büyüklük ölçümü, tip uyum denetimlerini gibi mekanizmalarla denetlemektir. Gereksiz yere kullanılacak istisna yönetimi büyük performans kayıplarına neden olmaktadır. .NET ortamında her şey gibi istisnalarda sınıflar kullanılarak oluşturulmakta ve tüm istisnalar temel System.Exception nesnesinden türetilmektedir. Farklı istisnalar için farklı sınıflar bulunmaktadır. Bu istisna sınıfları veritabanı istisnalarından bellek istisnalarına kadar her alanda bulunmaktadır. Her istisna sınıfı kendine özgü bazı bileşenleri bünyesinde barındırmaktadır.

İstisnaları ortaya çıkartmak ve bu istisnaları yakalayıp yönetmek ayrı işlerdir. Bu makalemizde ortaya çıkmış olan istisnaları yakalamayı ve yönetmeyi işleyeceğiz. Bir istisnayı yakalamak için öncelikle istisnanın ortaya çıkabileceği kod aralığını tespit etmek gerekir. Bu işlem gerçekleştirildikten sonra aşağıdaki ifadelerden birini kullanarak istisna yakalama işlemi gerçekleştirilir.

1. try catch

2. try finally

3. try catch finally

try catch:

using System;
namespace Exception1
{
       class Istisnalar
      {
           [STAThread]
           static void Main(string[] args)
           {
                  int sayi1 = 25;
                  int sayi2 = 0;
                  try
                  {
                         int sonuc = 0; sonuc = sayi1 / sayi2;   // Sıfıra bölünme hatası

                         Console.WriteLine("Hiç Bir Hata Oluşmadı");
                  }
                  catch (Exception e)
                  {
                        Console.WriteLine(e.Message);
                  }
                  
           }
       }
}

Try Catch ifadelerinde örneğimizde de gördüğümüz gibi istisnanın ortaya çıkması muhtemel olan kod alanı try{......}catch parantezleri arasına alınmıştır. Bu kod artık izlenmektedir. Peki bir istisna ortaya çıktığı zaman nasıl bir olay meydana gelecektir. Parantez içerisinde bir hata meydana geldiğinde; hatanın ortaya çıktığı noktadan sonraki kodlar işleme konulmaz ve parantezden sonraki kod işleme alınır. Yukarıdaki örneğimizde Console.WriteLine("Hiç Bir Hata Oluşmadı"); kod satırı işleme konulmadan catch ifadesine atlanır. catch ifadesi adındanda anlaşılacağı gibi istisnaların yakalanıp seviyelendirildiği alandır. Daha öncede bahsettiğimiz gibi bütün istisna nesneleri Exception sınıfından türetilmiştir. Bu nedenle bütün hatalar Exception nesnesi tarafından yakalanabilmektedir. Exception sınıfı bünyesinde çeşitli özellik ve metotlar barındırmaktadır. Bu özelliklerden en önemlisi Message özelliğidir. String tipinde olan bu özellik istisna sonucu üretilen bilgi mesajını içermektedir. Yukarıda ki örneğimizde Attempted Divide by Zero bilgi mesajı ortaya çıkmaktadır. Peki bu try {..} bloğu içinde bir kaç çeşit hata meydana gelse ve bu hatalardan istediğimizi yakalamak istersek ne yapmamız gerekir.

using System;
namespace Exception1
{
       class Istisnalar
      {
           [STAThread]
           static void Main(string[] args)
           {
                  int sayi1 = 25;
                  int sayi2 = 0;
                  string txt;
                  try
                  {
                         txt = Console.ReadLine();
                         sayi2 = int.Parse(txt);
                         i
nt sonuc = 0;
                         sonuc = sayi1 / sayi2;   // Sıfıra bölünme hatası

                         Console.WriteLine("Hiç Bir Hata Oluşmadı");
                  }
                  catch (DivideByZeroException e)
                  {
                        Console.WriteLine(e.Message);
                  }
                  catch (FormatException e)
                  {
                        Console.WriteLine(e.Message);
                  } 
                  
           }
       }
}

Yukarıdaki örneğimizde try{} bloğu içinde 2 çeşit hata ortaya çıkma ihtimali vardır. Bunlardan birincisi klavyeden girilen değerin int.Parse(txt) metodu ile stringten integer türüne dönüşümünde alfanümerik karakterlerden dolayı FormatException istisnanıs ve ikincisi girilen değerin 0 olması durumunda DivideByZeroException istisnasının ortaya çıkmasıdır. Örneğimizde de görüldüğü gibi programımız farklı hatalar için farklı davranmasını istiyorsak hata yakalama işini bir kaç seviyede gerçekleştirerek amacımıza ulaşabiliriz. Burda dikkat edilmesi gereken nokta özel olarak seçilen istisna sınıfları dışında örneğin yukarıda bir nullreferance gibi bir hata oluştuğu taktirde yakalanamayacak olduğudur. Bütün hataları yakalamak gereken durumlarda Exception temel sınıfını kullanmak gereklidir.

try finally:

İstisna takibinde Try finally bloğunun özelliği; hata ortaya çıksa da çıkmasa da bu finally bloğunun çalışıyor olmasıdır. Try{} bloğu içerisinde bir istisna ortaya çıktığında kodumuz aynen try catch ifadesinde olduğu gibi hatanın ortaya çıkmış olduğu noktadan sonraki kodlar çalışmadan finally bloğuna geçilir. Catch ifadesinden farklı olarak hatanın çeşidinin tespiti mümkün değildir. Finally bloğu programlarımızda kullanım sebebi try {} içerisinde yaratmış olduğumuz nesnelerin sonlandırılması veya değişkenlerin son değerlerinin belirlenmesi gereken durumlarda kullanılır.

using System;
namespace Exception1
{
       class Istisnalar
      {
           [STAThread]
           static void Main(string[] argös)
           {
                  int sayi1 = 25;
                  int sayi2 = 0;
                  try
                  {
                         int sonuc = 0; sonuc = sayi1 / sayi2;   // Sıfıra bölünme hatası

                         Console.WriteLine("Hiç Bir Hata Oluşmadı");
                  }
                  finally
                  {
                        Console.WriteLine(e.Message);
                  }
                  
           }
       }
}

Bu kullanıma bir örnek vermemiz gerekirse bir veritabanı bağlantısı yapıp geriye bazı değerler döndüren bir fonksiyon olsun. Bu fonksiyon içerisinde veritabanı bağlantısı gerçekleştirilip gerekli data çekim işlemleri meydana geldikten sonra bağlantının kesilmesi gerçekleştirilecektir.

using System;
namespace Exception1
{
       class Istisnalar
      {
           [STAThread]
           static void Main(string[] argös)
           {
               DataAl();
                     
           }
           public string DataAl()
           {
                  string bilgi;
                  Baglan();
                  try
                  {
                        bilgi = getdata();
                  }
                  finally
                  {
                        baglantiyikes();
                        return bilgi;
                  }

           }

       }
}

Örneğimizde benzer bir yapı bulunmaktadır. Yukarıdaki gibi bir yapı veritabanı bağlantısının kesilecek olması kesindir. Bu yöntemle fazla kaynak kullanımı gibi etkilerden kurtulmamız mümkündür.

try catch finally:

try catch ve try finally ifadelerinin ve kullanım yeteneklerinin birleşerek ortak bir ifade halini aldığı kullanıma try catch finally diyoruz. Bu yöntem kullanılarak hatalar izlenip ayıklanabilmekte; bununla birlikte finally bloğunu yetenekleri kullanılarak kaynak kullanımı denetim altında alınabilmektedir.

using System;
namespace Exception1
{
       class Istisnalar
      {
           [STAThread]
           static void Main(string[] argös)
           {
               DataAl();
                     
           }
           public string DataAl()
           {
                  string bilgi;
                  Baglan();
                  try
                  {
                        bilgi = getdata();
                  }
                  catch(Exception e)
                  {
                        bilgi = e.Message +" Hatası Oluştu";

                  }

                  finally
                  {
                        baglantiyikes();
                        return bilgi;
                  }

           }

       }
}

Gelecek makalemizde Exception sınıfı ve bu sınıftan türetilmiş sınıflar hakkında bilgi vereceğiz. Bununla birlikte isteğimize bağlı kendi istisnalarımızı nasıl ortaya çıkartacağımızı göreceğiz.

Posted in:

Tags: , ,

Generic Sınıflara Giriş

Nisan 8, 2004 at 4:32 Cavusoglu
 

Generic kavramı C#2,0 ile beraber artık hayatımıza girmeye başlamıştır. Performans konusunda büyük avantajlar sağlayan generic sınıfların temel özelliklerinden daha önce sitemizde bahsetmiştik. Bu makalemizde generic sınıfların oluşturulması, türetilmesi, metotların tanımlanması vb konuları aydınlatmaya çalışacağız. Generic Sınıflar temel olarak normal sınıflar ile aynı özellikleri göstermektedir. Generic sınıfların normal sınıflardan farkı,  kullanılacak olan tiplerin sınıf tanımlama aşamasında belirtilmesidir. Aşağıda normal bir sınıf ile generic sınıf arasındaki tanımlama farkını görebilirsiniz

using System;

namespace GenericDeneme
{
         class myclass                 // Normal Sınıf
         {
         }

         class mygenclass1<tip1>  // Generic Sınıf
         {
         }

         class mygenclass2<tip1,tip2,tip3>  // Birden çok tipli generic sınıf
         {
         }
}

Generic sınıflarda 1 adet tip tanımlana bileceği gibi yukarıdaki örneğimizde mygenclass2 sınıfında da olduğu gibi ihtiyaçlar doğrultusunda birden çok tip tanımlanabilir. Generic sınıfların tanımında bir aşırı yükleme (overloading) gerçekleştirmek mümkün değildir. Generic sınıflardaki tanımlanmış tiplerdeki değişim isimlerinin değiştiğini göstermez. Aşağıdaki örneği incelersek aynı isme fakat farklı türde ve sayıda tiplere sahip sınıfların hata verdiğini göreceksiniz.

using System;

namespace GenericOverload
{
         class mygenclass<tip1>{    }              // 

         class mygenclass<tip1,tip2,tip3>{     } // Hata Çift Tanımlama
}

Generic sınıflarda normal sınıflarda olduğu gibi sınıf içinde sınıf tanımlamak mümkündür. Bu tanımlamalar aşamasında dıştaki sınıfta kullanılan tip içteki sınıfta da kullanılabilir. Burada dikkat edilmesi gereken konu içteki sınıfları örneklerken dıştaki sınıfa ait generic tanımlamalar gerçekleştirilmelidir.

using System;
namespace GenericClass
{

        class MyClass<ItemType>
       {
           public ItemType field1;
           public void deneme(ItemType tmp){}
           public MyClass(){}
          
           public class MyClass2<ItemType>{}
       }

       class MainClass
      {
           [STAThread]
           static void Main(string[] args)
           {
                  MyClass<string> myclass = new MyClass<string>();
                  MyClass<int>.MyClass2<int> myclass2 = new MyClass<int>.MyClass2<int>();
           }
       }
}

Generic Sınıflarda Türeme:

Generic sınıflarda türeme konusunda dikkat edilmesi gereken en önemli nokta bir generic sınıfı türetmiş olduğumuz sınıfın veya arayüzün adı ile generic sınıfımızda kullanmış olduğumuz parametre aynı isimde olamaz. class Extend<V>: V {} şeklindeki bir tanımlama hataya neden olacaktır. Bununla birlikte generic sınıfımızın başka bir generic sınıftan türetilmesi durumunda temel sınıfımızda veya arayüzümüzde aynı parametreyi kullanmak bir hataya sebep olmamaktadır. Aşağıda değişik şekillerde türetilmiş generic sınıflar bulunmaktadır.

class C<U,V> {}

interface I1<V> {}

class D: C<string,int>, I1<string> {}

class E<T>: C<int,T>, I1<T> {}

Generic Sınıflarda Methodlar:

Generic sınıflarda kullanılan metotlar 2 şekilde incelenebilir. Bunlar Generic Metotlar ve Generic Olmayan Metotlar. Peki bir metodun generic veya non-generic olması arasındaki değişiklik nedir. Bir metodun içerisinde sınıf başlığında tanımlanmış generic tiplerin kullanılması bu metodun generic bir metod olduğunu göstermez. Şimdi aşağıdaki örneğimizi inceleyelim.

using System;
namespace GenericClass
{

        class MyClass<ItemType1,ItemType2>
       {
           public ItemType1 field1;

           public MyClass(){}

           public void deneme(ItemType1 tmp){}
           
       }

       ..................
       ..................
}

Yukarıda ki örneğimizde sınıfta tanımlanmış olan generic tipler deneme metodu içerisinde kullanılmıştır. Bu metot generic sınıfta tanımlanmış ama generic olmayan bir metottur.

Generic metodlar metot adından sonra parametrelerden önce kullanılacak olan generic tiplerin tanımlanmasından oluşur. Bu tanımlanan tipler sınıfta tanımlanan generic tiplerle aynı ada sahip olabileceği gibi başka bir isimle de bulunabilirler.  Aşağıda generic bir metodun tanımlanması ve daha sonra kullanımını gösteren bir örnek bulunmaktadır.

using System;
namespace GenericClass
{

        class MyClass<ItemType1,ItemType2>
       {
           public ItemType1 field1;

           public MyClass(){}

           public void deneme<ItemType3,ItemType1>()
           {
               ItemType3 myfiled;
               Console.WriteLine(myfield.ToString());
           }
           
       }

       class MainClass
       {

           MyClass C1 = new MyClass<int,string>();
           C1.deneme<double>();          
       }

}

Generic Metotlarda kullanılan Generic tipler içinde bulunduğu Generic sınıfa ait tiplerle aynı isimde olabilir. Yukarıdaki örneğimizde Deneme metodumuzda kullanılan ItemType1 MyClass üzerinde de kullanılmıştır.

Generic sınıflarda static alan ve metot kullanımında hiç bir farklılık bulunmamaktadır. Static alan tanımlanırken sınıf üzerinde tanımlanmış olan Generic tiplerde tür olarak kullanılabilir.

Microsoft Firmasının Whidbey’nin piyasaya sürülmesi ile ilgili planlarını ileriye ötelemesi nedeniyle C#2.0 üzerinde bulunan generic sınıflarla ilgili konuya detaylı bir yazı yazmaktan kaçındım. İlerleyen zamanlarda generic kavramı daha detaylı olarak ta işlenecektir.

Posted in:

Tags: , ,

Visual Studio.NET Whidbey'in Refactoring Özellikleri

Mart 2, 2004 at 4:40 Cavusoglu
 

Microsoft Whidbey kod adı ile çıkartmış olduğu Visual Studio yeni sürümünde bir çok yeniliğe imza atmış durumda. .NET teknolojisi ile yazılım dünyasında bir çığır açan Microsoft firması Visual Studio editöründe yapmış olduğu değişikliklerle programcılara hızlı yazılım geliştirme için gerekli tüm imkanı sağlamıştır. Gelecek makalelerimizde Whidbey ile beraber gelen yenilikleri sizlere tanıtmaya çalışacağız. Bu gün editöre eklenmiş olan yeni bir seçenekten bahsedeceğiz. Bu seçenek REFACTOR  olarak adlandırılmıştır.

Şekil 1 : Refractor Menüsü

Refactor yazılım geliştirme sürecinde kod yazımı gerçekleştirildikten sonra kod üzerinde hızlı ve verimli değişiklik yapılabilmesi için geliştirilmiş bir işlemler bütününün genel adıdır. Refactor aşağıdaki bölümlerden oluşmaktadır. Şimdi bu bölümleri sırayla inceleyelim.           

  • Extract Metot

  • Encapsulate Field

  • Extract Interface

  • Surround With

  • Insert Expansion

  • Rename

  • Change Metot Signature

Extract Metot :

Extract Metot uzun ve okunurluğunda ve kullanımında zorluklar olan kodları metotlar vasıtası ile parçalara bölmek için çok iyi bir yöntem ortaya koymaktadır. Visual Studio editörü kodu izlemekte ve en uygun alt metodu üretmektedir. Bu üretilen alt yordamlar sayesinde şematik açıdan kodumuz açık bir hal almaktadır.

Bu yöntemi kullanmak için alt yordamlara bölecek olduğumuz kodu seçmemiz ve sağ tuş menüsü ile Refactor -> Extract Metot veya CTRL+ALT+M tuş kombinasyonu ve ardından M tuşuna yeniden basarak  Extract Metot iletişim penceresine ulaşılarak (Şekil 2) alt yordamın adı seçilir ve işleme konur.
 

sealed class MyClass
{
       public int x, y;
}
class MainClass
{
     public static void Main()
     {
            MyClass mC = new MyClass();

            mC.x = 110;
            mC.y = 150;
            Console.WriteLine("x = {0}", mC.x);
            Console.WriteLine("y = {0}", mC.y);
    }
}


Şekil 2: Extract Metot İletişim Penceresi

Kodumuz içerisinde bir alt yordam olabileceğine inandığınız kod alanını fare yardımı ile seçtikten sonra Extract Metot seçeneğini devreye koyduğumuzda aşağıdaki koda ulaşmış oluruz. Bu koda ulaşmak için yukarıda ki kodumuzu 2 parçaya bölerek işleme tabi tuttuk. Bunlardan 1.si mC nesnesinin tanımlanması ve değer aktarımları 2.si bu bilgilerin ekrana yazılması. 
 

public static void Main ()
{
        MyClass mC = define_mC ();
        display_mC (mC);
}
private static void display_mC (MyClass mC)
{
       Console.WriteLine ("x = {0}", mC.x);
       Console.WriteLine ("y = {0}", mC.y);
}
private static MyClass define_mC ()
{
      MyClass mC = new MyClass ();
      mC.x = 110;
      mC.y = 150;
      return mC;
}

Encapsulate Field :

Encapsulate Field özelliği kod yazımı gerçekleştirildikten sonra programımız üzerinde Public olarak bulunan Alanları OOP için temel şartlardan olan Encapsulate ( Hiç bir genele açık değişkene direkt ulaşıma izin verme)  kuralına uygun bir hale getirmek için kolay bir yol sunmaktadır. Tüm OOP programcılarının bildiği gibi public bir değişkene doğrudan ulaşmak bir çok yönden sakıncalara yol açmaktadır. Bu sakıncaları ortadan kaldırmak için C# dili içerisinde Property kullanılarak bilgi girişi ve çıkışı fonksiyonlar vasıtası ile kontrol altına alınmıştır. Aşağıdaki kodu incelediğimizde public string mystrfield encapsulate açısından sakıncalı olduğu açıktır. Bu satırda mystrfield alanı üzerinde sağ tuş refactor menüsü üzerinden Refactor-> Encapsulate Field veya CTRL+ALT+M;E tuş kombinasyonu ile şekil 3 deki pencereye ulaşılır.
 

using System;

namespace Refactor
{

            class MainClass
           {
                 public string mystrfield;

                 [STAThread]
                 static void Main(string[] args)
                {

                }
           }
}

Şekil 3: Encapsulate Field İletişim Penceresi

Bu pencere üzerinde Property Name ve erişim seçenekleri gerçekleştirildikten sonra karşımıza preview changes seçeneği seçili ise Preview Changes iletişim kutusu gelir ve kodumuz üzerinde yapılacak değişiklikleri görmemize izin vermektedir. Encapsulate Field işlemi gerçekleştirildikten sonra kodumuz aşağıdaki hali almaktadır.
 

using System;
namespace Refactor
{
        class MainClass
       {
             private string mystrfield;
             public string Mystrfield
            {
                 get
                {
                      return mystrfield;
                }
                set
               {
                     mystrfield = value;
                }
            }
            [STAThread]
            static void Main(string[] args)
           {
            }
       }
}


Extract Interface :

Normal şartlarda arayüzlerimizi nesnelerimizden önce oluştururuz ve nesnelerimizi arayüzlerden türeterek bir standart oluşturmaya çalışırız. OOP standartları içinde arayüzler çalışmamızı geliştirmek için çok önemli bir yer tutar. Peki olduya nesnemizi oluşturduk ve arayüz oluşturmayı unuttuk ve daha sonra bunu farkına vardık ve ihtiyacımızı hissettik ne yapacağız. nesnemizi baştan sona inceleyip arayüzümüzü oluşturmamız gerekir. Extract Arayüz seçeneği bizlere bu işi bir kaç tıklama ile yapabileceğimiz imkanı sunmaktadır. Bir sınıftan Arayüz üretebilmemiz için en önemli şart bu sınıf içerisinde public metotların bulunması gereğidir.
 

class myclass
{
         public void mymetot()
         {

         }
}

Yukarıdaki örneğimizde basit bir sınıf bulunmaktadır. Burada myclass üzerinde sağ tuş Refactor->Extract Interface veya CTRL+ALT+M;I tuş kombinasyonu ile iletişim penceremize ulaşabiliriz. Bu pencere üzerinde (Şekil 4) oluşturulacak olan arayüzün adı, bulunacağı dosya adı ve arayüzde bulunacak olan metotların seçimi gerçekleştirilebilir.

Şekil 4 : Extract Interface iletişim penceresi

İşlem gerçekleştirildikten sonra Imycalss.cs dosyası içerisinde Arayüzümüzü Imyclass adı ile oluşturulur ve myclass üzerinde şu değişiklik otomatik olarak meydana gelir.
 

class myclass : Imyclass
{
         public void mymetot()
         {

         }
}

Surround With :

Yazılım geliştirme sürecinde kodları yazdıktan sonra bazen bu kodların bir bölümünü döngü içerisinde veya bir hata kontrol mekanizması içerisine almamız gerekir. Bu aşamada normal şartlarda araya satır ekleyerek işlemimizi gerçekleştiririz. Whidbey ile beraber gelen Refactor seçenekleri bünyesinde bulunan Surround With özelliği sayesinde bir ifade içine almak istediğimiz kodu mouse ve klavye yardımı ile seçtikten sonra Refactor-> Surround With->(Seçilecek İfade) menüsü üzerinden işlemimizi gerçekleştirebiliriz. Whidbey editörü bize kullanabilecek olduğumuz ifadeleri otomatik olarak sunmaktadır.

Insert Expansion:

Programcılar olarak yazıma ait ifadeleri yazmaktan hep sıkıntı duymuşuzdur. Bir sınıf oluşturmak istediğimizde birisi genel tanımlamaları bizim yerimize yapsa ne kadar güzel olurdu değil mi?

Hızlı yazılım geliştirmede en önemli şey tekrar eden ve angarya kodlardan kaçınmaktır. Bu amaçla Whidbey editöründe yazmaktan üşendiğimiz genel ifadeleri bir hamlede eklememize izin verecek Insert Expansion seçeneği bulunmaktadır. Bu seçenek sayesinde if,for,class,interface,checked vb.. bir çok ifadeye bir tuş ile ulaşabiliriz. Bu işlemi gerçekleştirebilmek için Refactor->Insert Expansion veya CTRL+ALT+M;X yapmamız yeterlidir.

Rename:

Visual Studio üzerinde yazılım geliştirirken en çok problem yaşamış olduğum konu bir nesnenin veya alanın adını belli bir noktadan sonra değiştirmek olmuştur. Belli bir kod yazdıktan sonra bir isimde yapmış olduğum değişiklik bana bir çok hata olarak hep geri dönmüştür. Bu hata mesajlarını izleyerek programındaki isim değişikliğini uzun bir süreçte gerçekleştirirdim.

Microsoft Whidbey ile programcılara bu konuda da büyük bir kolaylık sağlayarak bir isim değişikliğini en kısa sürede ve en esnek şekilde yapmamızı sağlamıştır. Bu isim değişikliği bir namespace,class,interface,field,property vb.. olabilir. Rename işlemini gerçekleştirebilmek için isim değişikliği yapacak olduğumuz alan üzerinde sağ tuş vasıtası ile Refactor->Rename veya CTRL+ALT+M;R tuş kombinasyonu ile Rename iletişim kutusuna ulaşmamız mümkündür. Bu iletişim kutusunda yeni ismi girdikten sonra karşımıza (Şekil 5) hangi değişiklikleri uygulayacağımızı ve bunların nerelerde olduğunu bize gösteren bir doğrulama penceresi ile karşılaşırız.

Şekil 5 : Rename Ön Görünüş İletişim Penceresi

Örneğin yukarda mystrfield değişkeni mystrfield1 ismiyle değiştirilecektir. Penceremizde bu değişikliklerin nerelerde hangi dosya içinde ve hangi satırda olduğunu gösteren bilgiler bulunmaktadır. Değişmesini istediğimiz noktalara işaret bıraktıktan sonra Çalıştır iconu ile değişikliği çalıştırabilirsiniz. Bu isim değişikliği projemize bağlı tüm dosyalarda gerçekleştirilebilmektedir.

Change Metot Signature:

Yazılım geliştirme sürecinde bazen tanımlamış olduğumuz metotlar içerisinde ihtiyaca bağlı olarak bazı parametre değişikliklerine gitmemiz gerekebilir. Bu değişiklikleri de gerçekleştirmek büyük zaman kayıplarına neden olmaktadır. Whidbey ile birlikte Refactor menüsü altında Change Metot Signature seçeneği ile artık bu işlemde çok kısa bir sürede gerçekleştirilebilmektedir. Metotumuzun tanımlandığı referans noktası üzerinde sağ tuş Refactor->Change Metot Signature veya CTRL+ALT+M;S   tuş kombinasyonu ile Change Metot iletişim penceresine ulaşabiliriz. Bu pencere üzerinden Parametre Ekleme,Parametre Çıkarma ve Parametre Düzenleme işlemlerimizi gerçekleştirebiliriz. Bu noktada unutmamamız gereken konu şu ki arayüzlerden türetilen sınıflar içerisindeki metotlarda yaptığımız değişiklikler kökteki arayüz etkilememektedir.

Tüm bu anlattıklarımızdan da anlaşılabileceği gibi Microsoft firması Whidbey kod adlı yeni Visual Studio yazılım geliştirme aracında editörlük açısından programcılara büyük kolaylıklar sağlamaktadır. Gelecek Makalelerimizde bu yenilikleri tanıtmaya devam edeceğiz.

Posted in: Visual Studio

Tags: , ,