|
|
|
|
Microsoft C# Dilinin yeni sürümünü çıkarıyor. Öngörülen değişiklikler arasında Generics (Template'ler), Iterator'ler, Partial Classes, Anonymous Methods bulunuyor.
Generics, class tanımlamaları yaparken method'ların veya diğer bileşenlerin 'genel olarak' yani sadece belli bir tip için değil belli bir şablona uyan her türlü tip için çalışmasını sağlıyor. Genercis olmadan programcının type casting yapması gerekiyor. Genel amaçlı yazılması için tasarlanmış method'lar 'object' gibi bir base class'a göre yazıldığından porgramcının yanlışlıkla bir tip yerine başka bir tipi verme riski bulunuyor. Generics geliştirme kolaylığı yanısırısa tip güvenliği sağlayacak.
Generics olmadan List diye bir class'a add ve get diye method yapıldığında
class List{
...
void add(object o){
...
}
object get(int i){
...
}
}
şeklinde bir yapı kurulmalı. Kullanımda da
MyClass m1=.new MyClass(); List l=new List(); l.add(m1); MyClass m2=(MyClass)l.get(i);
biçiminde olur. Burada MyClass'a cast etme zorunluluğu var. Ayrıca bu listeye MyClass koyup yanlışlıkla başka bir class tipine almaya çalışma riskide ver.
YourClass m2=(YourClass)l.get(i);
şeklinde de kod yazılabilir. Bu hatayı derleyici anlayamaz. Çünkü List class'ı nın get() methodu genel bir object döndürecek şekilde tanımlanmış; YourClass da bir object. Programcının önünde iki olasılık kalıyor. Yeni, genel bir class yapmak, buna karşın tip hatalarına dikkat etmek ve gerectiğinde cast yapmak. Ya da her tip için yarı class yapmak
Generics programlama bir class'ın hem generic hem de typesafe olmasını sağlar. Class'ın tanımı
class List<MyType>{
void add(MyType o){
...
}
MyType get(int i){
...
}
}
şeklinde olur. Kullanımı da
MyClass m1=.new MyClass(); List<MyClass> l=new List<MyClass>(); l.add(ml); m2=l.get(i);
biçimde olur. Son satırda cast yapmak zorunda kalmadık. Burada
List<MyClass> l=new List<MyClass>(); YourClass y1=new YourClass(); l.add(ye); // HATA!
diye yazılırsa compiler hata verir.
Collection'lara erişim için kullanılan Iterator'lerle ilgili bazı değişiklikler var. C#'da bir collection veya bir diziye
forach(Type item in list){
..
}
şeklinde eriilebiliyor. Bu yöntem
IEnumerator e=list.GetEnumerator();
while(e.MoveNext){
Type item=(e.Current)
..
}
biçimindeki ifadeden çok daha kısa va okunaklı. Iterator'ler kullanmak için bulunan kolaylık onları yaratmak için yok. Onun için
public class List : IEnumerable{
internal class ListEnumerator : IEnumerator{
List theList;
int pos = -1;
ListEnumerator (List l){
theList = l;
}
public object Current{
get { return theList[pos]); }
}
public bool MoveNext{
pos++;
return pos < theList.Length;
}
public void Reset (){
pos = -1;
}
}
public IEnumerator GetEnumerator () {
return new ListEnumerator (this);
}
...
}
şeklinde bir yapı gerekiyor. Oysa C#'a getirilmesi düşünülen yenilikte
public class List{
public object foreach () {
int i=0;
while (i < theList.Length ())
yield theList[i++];
}
..
}
şekinde bir yapı yeterli olacak. Yani bir 'foreach' operator'ü tanımlanıyor. Döngünün her adımda döndürülecek değerler de 'yield' keyword'üyle belirtiliyor.
Java'da bulunan anonymous class'ların işlevini görmek üzere C#'ta delegate'ler düşünülmüş. Delegate'ler sadece method tanımlamaları içeriyor ve bir class tanımlamayı gereksiz kılıyor. Ancak anonymous class'ların delegate'lere karşı bir üstünlüğü var. Bir delegate, tanımında olmayan bir parametre aktarmak mümkün olmuyor. Özellikle delegate'in deklarasyonunda bilinmesi gereken değer property değilse bu önemli bir sorun çıkarıyor. Bir method'un içerisinde tanımlı bir değişkeni delegate içerisinde kullanmak mümkün olmuyor. Delegate kullanımı
private void anyMethod(){
button.Click += new EventHandler (this.bClick);
}
private void bClick (object sender, EventArgs e){
MessageBox.Show ("click");
}
şeklinde. Burada bClick method'una üçüncü bir parametre eklemek, tanımı bozacağından mümkün değil. Oysa yeni C# specification'unda
EventHandler clickHandler = new EventHandler(sender, e){
MessageBox.Show("Click");
};
yazmak yeterli olacak. Ayrı bir method yazmaya gerek yok.
int i=0;
EventHandler clickHandler = new EventHandler(sender, e){
MessageBox.Show("Integer : "+i);
};
yazmak da mümkün olacak.
Partial (parçalı) class'lar, bir class'ın tanımının iki ayrı dosyada olabilmesine olanak tanıyor. Büyük class'ları bölmek için kullanılabilir. Daha önemlisi herhangi bir program (örneğin bir editör) tarafından üretilen kısımlarla geliştiricinin kendi yazdığı kısımları ayrımaya yarayabiliyor. Bir tanesi değiştiğinde diğeri ezilmemesi sağlanmış oluyor. Örneğin
public partial class Form1{
private void InitializeComponent (){
..
}
}
public partial class Form1{
public void Method (){
..
}
}
İlk kısmı IDE üretirken diğerini programcı yazabilmektedir. İki kısmın ayrılması ayrıca kod okunaklılığını arttırmaktadır.
Bu değişiklikler C#'ın giderek gelişeğini gösteriyor. Değişikliklerden bazılarının benzerlerinin Java'da bulunması (örneğin Anonymous Methods), bazılarının da Java'nın bir sonraki versiyonunda konulmasının planlanması (Generics) giderek bu iki dilin birbilirne yakınlaşacağını gösteriyor. Zira Java'nın 1.5 versiyonunda C#'da şu anda bulunan (enum, foreach ve auto boxing gibi) bazı özelliklerin benzerlerin konulması bunu kanıtlar nitelikte. C++'ın yıllar süren evrimiyle birlikte bu 3 dil, birbirinden çok şey alacağa, vereceğe benziyor. Elbette bu dillerin giderek gelişmesi object oriented-programlamanın dillere özgü yaklaşım farklarına rağmen daha da ilerleyeceğini gösteriyor.
Microsoft'un C# 2.0 yaptığı geliştirmeler, diğer .NET dillerinden çok C#'a güvendiğini, ancak C#'ın C++ ve Java'ya rakip olabileceğini görmesinden kaynaklanıyor. Hatta Microsoft'un kendi gözdesi Visual Basic'i ihmal ettiği, VB.NET'i sadece VB'den .NET geçiş yolu olarak düşündüğü söylentileri var. Her ne olursa olsun Microsoft'un C#'ı geliştireceği, giderek hem kolay hem güçlü bir programlama dili haline getireceği kesin. C#'ın 2.0 versiyonuna hazırlanması bunu kanıtlıyor.
|
|