C# readonly ve const ifadeleri

readonly anahtar sözcüğü

Birçok yerde readonly ifadesini görmüşsünüzdür. readonly olarak tanımlanan bir değişken yalnızca okunmak üzere tanımlanır ve yalnızca 2 şekilde değer ataması yapılabilir.

1. İlk tanımlandığında değer ataması yapılarak
2. Bir constructor içinde değer ataması yapılarak

Yukardaki 2 durum hariç readonly değişkenine değer ataması yapılamaz.

Bu durum, aslında sadece bir yapılandırıcı tarafından değer ataması yapılması gerektiği durumlarda kullanışlıdır. Böylece daha sonra değer değiştirmesi önlenmiş olur. Kullanım alanı oldukça fazladır.

Aşağıdaki örneği inceleyelim:

class DenemeClass { readonly double x = 30; public DenemeClass(int _x) { x = _x; //İlk değer ataması yapıldı x = x * 5; //Burda değeri değiştiriliyor. Doğru ifade çünkü constructor içindeyiz. } public DenemeClass(double _x) { x = _x; } public void Show() { Console.WriteLine(x); } static void Main() { DenemeClass dc = new DenemeClass(10); dc.Show(); DenemeClass dc2 = new DenemeClass(10.2); dc2.Show(); dc2.x = 10.3;//HATA!! Burada "A readonly field cannot be assigned to
(except in a constructor or a variable initializer)" hatası alacaksınız. Console.Read(); } }

Yukardaki örnekte dc2.x = 10.3; ataması yapıldığında program kızacaktır. Çünkü bir readonly değişken, hata açıklamasında yazdığı üzere sadece ilk değer atamasında ya da bir constructor'da set edilebilir.

const anahtar sözcüğü

Yukarda readonly ifadesini açıkladık. const da aslında readonly'e benzer özellikler gösterir. Aralarındaki fark, const ifadesi yalnızca ilk değer atamasında değer verilip daha sonra program boyunca tekrar değiştirilemeyecektir. Ayrıca ilk değer ataması zorunludur.

const int a; //HATA!! Değer ataması yapılmalıdır const int a = 10; //Doğru ifade. . . . a = 20; //HATA!! const bir değişken daha sonra değiştirilemez.

readonly ile const arasındaki farkı da bu şekilde açıklamış olduk.

Bir sonraki yazıda görüşmek üzere...

İyi kodlamalar dilerim..

Devamını Oku...

C# Dynamic Tipler

C# bilindiği üzere sıkı tip denetimli bir dildir. Bu şu demek oluyor: Eğer bir tip derleme sırasında atandığı bir tip ile uyuşmuyorsa derleme başarısız olacak (hata verecek) demektir. Bazen derleme zamanında da değişken tipli tanımlamalara ihtiyaç olabilir. C# 4.0 bu esnekliği sağlamak için yeni bir tip eklemiştir: dynamic tipi. dynamic tipi tabiri caizse kılıktan kılığa girebilir, bukalemun gibi renk değiştirebilir :) dynamic tipi bütün tiplere dönüştürülebilir. Eee C#1.0'la gelen object tipi de bize bu esnekliği sağlıyordu ne gerek vardı derseniz onu da birazdan anlatacağım.

Aşağıdaki örnekle başlayalım:

class DynamicTypes { static void Main() { dynamic i; dynamic s; i = 10; s = "Bu bir string'tir"; Console.WriteLine("i'nin tipi: " + i.GetType()); Console.WriteLine("i'nin değeri: " + i); //i'ye int tipiymiş gibi davranalım. i = i * 10; Console.WriteLine("i'nin yeni değeri: " + i); Console.WriteLine("str'nin tipi: " + s.GetType()); Console.WriteLine("str'nin değeri: " + s); //s'ye string tipiymiş gibi davranalım. s = s.ToUpper(); Console.WriteLine("s'nin yeni değeri: " + s); i = "i'nin tipi değişti";//Bu atamayla i'nin tipi otomatik olarak değişti Console.WriteLine("i'nin değeri: " + i); Console.WriteLine("i'nin yeni tipi: " + i.GetType()); } }

Bu ekranın çıktısı aşağıdaki gibi olacaktır:

i'nin tipi: System.Int32
i'nin değeri: 10
i'nin yeni değeri: 100

str'nin tipi: System.String
str'nin değeri: Bu bir string'tir
s'nin yeni değeri: BU BİR STRİNG'TİR

i'nin değeri: i'nin tipi değişti
i'nin yeni tipi: System.String

Bu programı biraz yakından inceleyelim:

Öncelikle; dynamic i; diye bir değişken tanımladık. i'ye 10 değerini atadık. Derleyici bunun tipini otomatik olarak int olarak algıladı (int olduğunu i.GetType() ile yazdırınca gördük). Çünkü 10 int tipindedir. Aynı şey dynamic s için de geçerli. Atanan değer karakter katarı olduğundan otomatik olarak string tip algılaması yapıldı. Fakat şu noktaya özellikle dikkat edelim: ilerleyen satırlarda int tipinde olan i değişkenine string bir değer ataması yapılıyor. Derleyici bunu derlemekle birlikte, üstelik çalışma zamanında da hata vermedi. i'nin bundan sonraki tipi string oldu.

dynamic tipi, tip uyumsuzluğu derleme sırasında anlaşılamaz. Ancak çalışma zamanında tip uyumsuzluğu ortaya çıkarsa exception fırlatır. Örneğin aşağıdaki kod derleme zamanında hata almaz ama çalışma zamanında tip uyumsuzluğu hatası fırlatır.

dynamic s; s = "karakter katarı"; s = s * 2; //Çalışma zamanı hatası!! string ile int çarpılamaz!!

Önce dynamic tip string tipine dönüşüyor. Sonra 2 ile çarpılmaya çalışıyor. string ile int haliyle çarpılamaz ve hata fırlatır.

Buraya kadar dynamic tipin ne olduğunu az çok anladık. Şimdi gelelim dynamic ile object arasındaki farklara..

dynamic ile object Tipleri Arasındaki Fark

dynamic ile object arasındaki en temel fark, derleme zamanındaki tip uyumsuzluğu kontrolüdür. Bildiğiniz üzere object tipini kullanabilmemiz için unboxing (kutudan çıkarma) yapmamız gerekiyor. Yani bir tip object olarak tanımlanmışsa, karşı tarafta bunun tipinin ne olacağını belirtmeliyiz.

Console.WriteLine(obj.GetType());//int yazar obj = obj + 1; //Derleme hatası!!! obj'nin tipini belirtmeliyiz obj = (int)obj + 1; //Şimdi çalıştı...

Fakat dynamic tipi için böyle bir işleme gerek yok. dynamic tipler derleme sırasında hata almazken, object tipler için ise unboxing yapmalı, tipini açıkça belirtmeliyiz. Kısaca dynamic tipler bizi derleme hataları zahmetinden kurtarmaktadır. Fakat dynamic tipler her zaman güvenli bir program sunmayabilirler. Dikkatli kullanılmadığında çalışma zamanı hatalarına yol açabilirler. Bundan dynamic tipleri kullanmaktan kaçınmalıyız anlamı çıkarılmamalıdır. Tam tersine dynamic tip kullanımı bazen oldukça elverişli ve gerekli olabilmektedir.

var Anahtar Sözcüğü

dynamic tipleri anlatıp var tipinden bahsetmemek olmazdı. var tipi de tıpkı dynamic tipler gibi herhangi bir tipte bir değişken değeri olabilir. Temel düzeyde javascript biliyorsanız javascriptteki var tanımlayıcısıyla çok benzerlik gösterir. Peki aralarında ne gibi farklar var?

var ile dynamic Tipler Arasındaki Farklar

Yukarda var tipinin de değişken tiplerde değer alabildiğini ifade etmiştik. dynamic tiplerden bazı farklarla ayrılır. dynamic tipler null olabiliyorken var tipleri mutlaka bir başlangıç değerine sahip olmalıdır. Ayrıca ilk atanan tip neyse program sonlanana kadar aynı tipte olmak zorundadır. Bunu bir örnekle açıklayalım.

dynamic x = null; x = 10; //x int tipinde x = x + 10; //x yine int tipinde x = "string değer"; //Geçerli ifade: x burda string tipine dönüştü. var y = null; //Hata!! null değer ataması yapılamaz! var y = 10; //y değişkeni int tipinde bir ilk değer almıştır. y = "string değer"; //Hata!! y yukarda ilk değeri int almıştı. string değer ataması yapılamaz

Buraya kadar object, dynamic ve var gibi dinamik tiplerden bahsetttik. Aşağıda bu üç dinamik tip arasındaki farkları tablo halinde bulabilirsiniz.

object, dynamic ve var Arasındaki Farklar

object	dynamic	var
object .NET Framework içindeki herhangi bir tipte bir değişken olabilir.	Herhangi bir tipte bir değişken olabilir	Herhangi bir tipte bir değişken olabilir fakat bir başlangıç değerine sahip olmalıdır.
Derleyici nesne hakkında bilgi sahibidir.	Derleyici nesne hakkında bilgi sahibi değildir. Intellisense ile "." dan sonra herhangi bir seçenek çıkmaz.	Derleyici nesne hakkında bilgi sahibidir. nesne hangi tipteyse ona göre intellisense ile bilgi edinmek mümkündür.
Bir metoda parametre olarak gönderilebilir veya bir metodun dönüş tipi olabilir.	Bir metoda parametre olarak gönderilebilir veya bir metodun dönüş tipi olabilir.	Bir metoda parametre olarak geçilemez ya da bir metodun dönüş tipi olamaz.
Tip ataması yapıldığında boxing - unboxing yapılmak zorundadır.	Tip dönüşümü (boxing - unboxing) gerekmemektedir.	Tip dönüşümü (boxing - unboxing) gerekmemektedir.
unboxing sırasında tip dönüştürülemezse hata fırlatır.	Tip dönüşümü hataları derleme zamanında anlaşılmaz ancak çalışma zamanında tip dönüştürülemezse hata fırlatır.	Tip dönüşümü derleme sırasında gerçekleşir. Hata varsa derleme yapılmaz.

Genel hatlarıyla dynamic tipleri anlatmaya çalıştım.

Umarım faydalı olabilmişimdir...

Hepinize iyi kodlamalar dilerim :)

Devamını Oku...

Visual Basic 6.0 Türkçe Karakter Sorunu (ı-ý, İ-Ý, ş-þ, Ş-Þ, ğ-ð, Ğ-Ð)

Hala Visual Basic 6.0 kullanan var mı bilmiyorum ama bir vesileyle bu aralar kullanmak zorunda kaldım :) Modern programlama dilleri ve IDE'lerini kullandıktan sonra bu tarz eski teknolojilere alışmak bir hayli zaman alıyor.

Neyse gelelim konumuza.. Karşılaştığım bu karakter sorununu belki başkaları da karşılaşmıştır diye belki bir faydam olur diye paylaşmak istedim.

Efsane Visual Basic 6.0 kodunu açtım birşeyler değiştirmem gerekiyor fakat kod sayfasında özellikle ı, ğ, ş harflerinde sorun olduğunu gördüm. Comment bile yazmak istesem abuk sabuk harfler çıkıyor. Region ayarlarından dil ayarlarını kaldırıp tekrar yükledim, klavye ayarlarını kaldırıp tekrar yükledim, server ı restart ettim ama yine düzelmemişti. Çıkan harfler ise aşağıdaki gibiydi.

ı  yerine  ý
İ  yerine  Ý
ş  yerine  þ
Ş  yerine  Þ
ğ  yerine  ð
Ğ  yerine  Ð

Eğer sizde de harfler yukardaki gibi çıkıyorsa o zaman doğru yerdesiniz. Çözümünü ise biraz zor bulmakla birlikte çok kolay olduğunu gördüm. Aşağıdaki yolu izleyip kodun font familysini aşağıdaki gibi değiştiriyorsunuz ve sorun düzeliyor. Açıkçası benim çok zor aklıma geldi font kaynaklı olabileceği.

Visual Basic 6.0 > Tools > Options > Text Editor > Normal Text > Courier New TUR 

Kolay gelsin..

Devamını Oku...

C# Kısmi Tipler ve Kısmi Metotlar (Partial Class, Partial Methods)

Merhaba,

Bu yazıda, kısmi tiplerden bahsedeceğim.

Büyük boyutlu programlarda bazen aynı amaçlar için kullanılan çok uzun olabilecek cs dosyalarını bölmek mümkündür. Böylece takibi daha da kolaylaştırmış oluruz. 100'lerce satır arasında kaybolmaktansa bazen birbiriyle bağlantılı 3-5 metot için ayrı cs dosyaları oluşturmamız mümkün olabilir.

Kısmi tipleri belirtmek için partial anahtar sözcüğünü kullanacağız.

Öncelikle 3 ayrı dosyayı ayrı ayrı cs dosyası olarak kaydedelim.

--Bunu PartialClassX.cs olarak kaydedin

partial class PartialClassXY { public int X { get; set; } }

--Bunu PartialClassY.cs olarak kaydedin

partial class PartialClassXY { public int Y { get; set; } 

}

--Bunu PartialClassXY.cs olarak kaydedin

using System; partial class PartialClassXY { public PartialClassXY(int x, int y) { this.X = x; this.Y = y; } static void Main() { PartialClassXY xy = new PartialClassXY(10, 20); Console.WriteLine("X: " + xy.X + " Y: " + xy.Y); } 

}

Programı çalıştırdığınızda aşağıdaki çıktıyı alacaksınız:

X: 10 Y: 20

Örnekte görüldüğü gibi, aynı namespace içinde olmak kaydıyla herhangi bir yerde partial class anahtar sözcüğü ile ortak bir sınıf oluşturmamız mümkündür. Dikkat edildiğinde PartialClassXY.cs dosyasında this.X ve this.Y elemanlarına (PartialClassXY.cs'de tanımlı olmadığı halde) sınıfın elemanlarıymış gibi erişebiliyoruz. Sonuç olarak partial class sayesinde PartialClassX.cs, PartialClassY.cs ve PartialClassXY.cs dosyalarını tek bir çatı altında toplamış olduk.

Kısmi tipler tanımlanabildiği gibi Kısmi Metotlar da tanımlanabilir. Aşağıdaki örnek kısmi metotlara örnektir.

using System; partial class PartialClassXY { public int X { get; set; } partial void Show() { Console.WriteLine("X: " + X + " Y: " + Y); } } partial class PartialClassXY { public int Y { get; set; } public void ShowXY() { Show(); } } partial class PartialClassXY { public PartialClassXY(int x, int y) { this.X = x; this.Y = y; } partial void Show(); } class Test { static void Main() { PartialClassXY xy = new PartialClassXY(10, 20); xy.ShowXY(); Console.Read(); } 

}

Kısmi metodun tanım şekline dikkat ediniz: partial void Show(); 

Diğer parçada ise bu metodun içi doldurulmuştur.

partial void Show() { Console.WriteLine("X: " + X + " Y: " + Y); 

}

Artık bu metot diğer parçalarda çağrılırsa çalışacaktır. Diğer parçada ise bu metot çağrılmıştır.

public void ShowXY() { Show(); 

}

Diyelim ki Show() metodunu derlemeye dahil etmezsek ShowXY() boş çalışacaktır. Kısmi metodun asıl faydası da burda yatmaktadır.

Umarım faydalı olabilmişimdir.

Bir sonraki makalede görüşünceye dek hoşçakalın...

Devamını Oku...

C# ?? Operatörü

Bir önceki makalemizde boş bırakılabilen tiplerden bahsetmiştik. O yazıdan hatırlanacağı üzere ? operatörü boş bırakılabilen (nullable types) tipler deklare etmemizi sağlıyordu. ?? operatörü de boş bırakılabilen tiplerle ilgilidir.

Aşağıdaki if else yapısını bilmeyen yoktur:

bool b = true; string str = b ? "true" : "false"; //Burada str = "true" değerini alacaktır

?? operatörü de aslında yukardaki ifadeyi nullable tipler için gerçekler. Daha açık ifadeyle; nullable bir tip nullable olmayan bir tipe atanmak istendiğinde hata fırlatmanın önüne geçmek için bu ifade kullanılabilir.

Aşağıdaki örneği inceleyelim:

using System; class NullableTypesDemo { static void Main() { int? x = null; int y; y = x ?? 0; Console.WriteLine("x boş iken y'nin değeri: " + y); x = 10; y = x ?? 0; Console.WriteLine("x'e atama yapıldıktan sonra y'nin değeri: " + y); } }

Bu kodun çıktısı aşağıdaki gibi olacaktır:

x boş iken y'nin değeri: 0
x'e atama yapıldıktan sonra y'nin değeri: 10

Görüldüğü üzere ?? operatörü aslında nullable bir tipin null değer içerip içermediğini, eğer null ise default bir değer atayabilmeyi sağlar. Değer mevcut ise nullable değişkenin değeri, değer mevcut değilse ?? operatörünün sağındaki değer (default) ataması yapılır.

Umarım faydalı olabilmişimdir..

Bir sonraki makalede görüşmek üzere, sağlıcaklakalın..

Devamını Oku...

C# Boş Bırakılabilen Tipler (Nullable Types)

Merhaba,

Bu yazıda sizlere C#'ta boş bırakılabilen tiplerden (Nullable Types) bahsedeceğim.

Program yazarken içeriği boş olabilecek değişkenlere sıklıkla ihtiyaç duyacaksınız. Örneğin; bir okul programında öğrenci bilgilerini kaydettiğimizi düşünelim. Ad, soyad, numara, adres, boy, kilo gibi alanlarımız olsun. Bir öğrencinin her zaman bütün bilgileri dolu olmayabilir. Örneğin boy, kilo gibi bilgileri o anda verilmemiş olabilir. Dolayısıyla bu alanlar boş bırakılacaktır. Daha önceleri boş bırakılamayan tipler sebebiyle bunu yönetmek zahmetli bir işti ama C# 2.0 ile birlikte bu konu zarif bir biçimde çözümlenmiştir. Boş bırakılabilen (Nullable Types) sayesinde bu sorun kolayca yönetilebilmektedir.

Normalde aşağıdaki kod parçası derlenmeyecektir

int i = null; //Hata!! i boş olamaz. (Boş bırakılamayan tip) bool b = null; //Hata!! b boş olamaz. (Boş bırakılamayan tip)

Fakat aşağıda bu tipleri nasıl boş bırakabileceğimizi göreceğiz.

Boş bırakılabilen tipler System.Nullable < T > nesnesidir. T bir değer tipi olmak zorundadır. İki şekilde deklarasyon olabilir

System.Nullable< int > i = null; System.Nullable< bool > b = null veya int? i = null; //Boş bırakılabilen tip bool? b = null; //Boş bırakılabilen tip

Genellikle ikinci deklarasyon daha çok tercih edilir. Program şimdi derlenecektir.

Boş bırakılabilen tiplerin boş bırakılabilmesi özelliği dışında bütün özellikleri boş bırakılamayan tiplerle aynıdır. Boş bırakılabilen bir tipin değer atanmış olup olmadığını iki şekilde anlayabiliriz. Birincisi null kontrolü yapılarak, ikincisi HasValue özelliğini kullanarak. HasValue kontrolü daha yaygın kullanılmakla birlikte daha şık bir kullanımdır.

Alın size bir örnek:

using System; class NullableTypesDemo { static void Main() { int? i = null; if (i.HasValue) Console.WriteLine("i bir değere sahip: " + i.Value); else Console.WriteLine("i boş"); i = 10; if (i.HasValue) Console.WriteLine("i bir değere sahip: " + i.Value); else Console.WriteLine("i boş"); } }

Bu programın çıktısı aşağıdaki gibi olacaktır:

i boş 
i bir değere sahip: 10

Bir nullable değişken ile normal değer değişkeni toplandığında değer yine null olacaktır.

Aşağıda bunu gösteren bir örnek vardır:

using System; class NullableTypesDemo { static void Main() { int? a = null; int? sonuc = null; int b = 10;//Dikkat!! Burası nullable değil sonuc = a + b; if (sonuc.HasValue) Console.WriteLine("Sonuc: " + sonuc.Value); else Console.WriteLine("Değer boş!"); a = 100; sonuc = a + b; if (sonuc.HasValue) Console.WriteLine("Sonuc: " + sonuc.Value); else Console.WriteLine("Değer boş!"); Console.Read(); } }

Bu programın çıktısı aşağıdaki gibi olacaktır:

Değer boş!
Sonuc: 110

Görüldüğü gibi değeri null olan bir nullable değişken ile değeri null olmayan int tipinde bir değişken toplandığında değer yine null olmaktadır.

Boş bırakılabilen tipler yalnızca değer tiplerine uygulanabilir.

Aşağıdaki ifade geçerli değildir:

class A {} static void Main(){ A? a = null; //Hata!! A nesnesi nullable olamaz }

Umarım faydalı olabilmişimdir..

Bir sonraki makalede görüşmek üzere..

Devamını Oku...