Ders 3 - Tür Dönüşümleri , Checked, Unchecked
Tür Dönüşümü Nedir?
Bazı durumlarda değişkenlerde tür dönüşümüne ihtiyacımız olur. Tanımladığımız bazı değişkenlerin farklı bir tür ile kullanılmasına tür dönüşümü denmektedir. Kısacası, değişkenin farklı bir türdeki halinin başka bir değişkene atanması haline denir.
Örneklendirecek olursak, büyük çaplı bir projeyi yazdığımızı varsayalım ve biz bu proje için çok fazla değişken kullanabiliriz ve diğer farklı bir türle ortak işlemler yapmasını isteyebiliriz. İşte tam da bu esnada tür değişimi dediğimiz olayı kullanırız. Int türü bir değişken ile Byte türü bir değişkenin toplama, çıkarma ya da farklı bir hesaplama işlemlerini yapması gibi.
Yalnız tür dönüşümlerinde dikkat edilmesi gereken bir noktamız vardır. Mantıksal olarak düşündüğümüzde bir Byte türü ile bir Int türü makine dilinde farklı işler için algılanmaktadır. (5 Byte + 3 Int) gibi bir ifade bilgisayar dilinde mantıksız bir işlemdir. Burada yapmamız gereken farklı türlerden değişkenleri aynı ifade içerisinde kullanıp işlem yapabilmektir. Bunun için tür dönüşümüne başvurmalıyız.
Tür dönüşümleri,
Bilinçli (Explicit) Tür Dönüşümü ve
Bilinçsiz (Implicit) Tür Dönüşümü olmak üzere ikiye ayrılır.
Bilinçsiz (Implicit) Tür DönüşümüBir değişkenin derleyici tarafından kullanılması ve kendi türü dışında geçici olarak başka bir türe çevirilmesine bilinçsiz tür dönüşümü denir.
😊rnek;
Kod:
namespace TurDonusumu1
{
class Program
{
static void Main(string[] args)
{
int s = 10;
float a;
a = s;
Console.WriteLine(a);
Console.ReadLine();
}
} }
( Bu örnekte int türündeki bir değişken float türündeki bir değişkene atanmıştır. Bu örneğimizde a değişkeni float tipinde olup , a değişkenine int tipinde olan s değişkenini atadık. Bu işlemi sağlayan derleyecimizin tür dönüşümü yapmasıdır. Kısacası s değişkenimiz geçici bir şekilde float tipine çeviriliyor ve sonrasında a değişkenine atanıyor. )
Bilinçsiz tür dönüşümlerini iki biçimde yapabiliriz. Birincisi Küçük Türün Büyük Türe Dönüştürülmesi ikincisi ise Büyük Türün Küçük Türe Dönüştürülmesi şeklinde yapılmaktadır.
Genel olarak tür dönüşümlerinde büyük türler, küçük türlere göre daha fazla bilgi içermektedirler bu yüzden küçük türler büyük olan türlere dönüştürülürler. Yalnız büyük olan türler, küçük türlere dönüştürülemezler çünkü dönüştürme sırasında veri kayıpları olur. Bu iki tür dönüşümünü inceleyelim.
Küçük Türün Büyük Türe DönüştürülmesiBu dönüşüm biçimi şu şekilde gerçekleşmektedir;
Küçük türü büyük türe dönüştüreceğimiz zaman fazla olan bitler, yani büyük türden dolayı eklenecek olan bitler sıfırla beslenir.
Yani burada küçük olan bir türün yüksek bitlerinin sıfır (0) ile beslenmesi değişkendeki değeri değiştirmez bu yüzden tür dönüşümünde herhangi bir veri kaybı yaşanmaz. Aşağıdaki örneğimiz bu tür dönüşümü ile ilişkindir.
😊rnek;
Kod:
namespace TurDonusumu2
{
class Program
{
static void Main(string[] args)
{
byte a = 20;
int b;
b = a;
Console.WriteLine(b);
float f = 20f;
double d;
d = f;
Console.WriteLine(d);
char c = 'a';
decimal m;
m = c;
Console.WriteLine(m);
Console.ReadLine();
}
}
}
( Bu örnekte char türünde olan c değişkeni decimal türüne çevrilmiştir. Atama kısmında m değişkenini ekrana yazdırdığımızda ‘a’ karakterinin Unicode karşılığını görürüz.)
Ekran Çıktısı:
Yine farklı bir örnek deneyelim.
😊rnek;
Kod:
namespace TurDonusumu3
{
class Program
{
static void Main(string[] args)
{
int a = 10;
byte b = 20;
short s = 30;
double d;
d = a + b + s;
Console.WriteLine(d);
Console.ReadLine();
}
}
}
( Bu örneğimizde farklı türlerden nesnelerin aynı ifade içerisinde nasıl kullanıldığını göstermektedir. Örnekte int, byte ,short, double türleri kullanılmıştır. Int,byte ve short tipleriyle tanımlanmış olan değerler toplama işlemini gerçekleştirip sonuç değerini, double türününe atamaktadır. Ekranda karşımıza sonuç olarak (60) değerini yazacaktır.)
Bu yapmış olduğumuz örnekte byte türünden tanımlanan değişkenler toplanırken sonuç olarak int tipinden nesneler üretilir. Kısacası iki ve daha fazla byte türünden aritmetik işlem yapılacak ise sonucu mutlaka int ya da daha büyük bir tür ve değişkene atamalıyız.
😊rnek;
Kod:
namespace TurDonusumu4
{
class Program
{
static void Main(string[] args)
{
byte a = 5;
byte b = 10;
byte c = a + b;
Console.WriteLine(c);
Console.ReadLine();
}
}
}
(Bu örneği yazıp çalıştırmak istediğimizde şu hatayla karşılaşırız;
( Cannot implicitly convert type ‘int’ to ‘byte’ ) yani Türkçe karşılığı
( ‘int‘ türü ‘byte‘ türüne bilinçsiz olarak dönüştürülemez. )Bu hatayı gidermek için programımızda yer alan şu kısımlarda değişiklik yapmalıyız;
“ byte c =a+b; “ yazan satırın yerine “ int c=a+b; “şeklinde yazmalıyız.
Byte türünden sayılar toplandığında int türünden sayılar üretilir ve bu şekilde yapıldığında herhangi bir tür dönüşümüne uğramayacaktır.
Çünkü byte türü alabileceği en büyük değer aralığı 0-255’tir. Byte türüyle bir işlem yapmak istediğimizde bu sınırı aşma ihtimalini göz önünde bulundurmalıyız. C# dili için böyle bir kullanım kuralı uygulanmıştır.
Eğer bu şekilde kullanmamış olsaydık aşağıda yer alan örnekteki gibi byte tipiyle tanımlanmış iki değişkenin çarpımı byte tipinin değer aralığını aştığından programımız derlenemeyecekti.
😊rnek;
Kod:
namespace TurDonusumu5
{
class Program
{
static void Main(string[] args)
{
byte a = 16;
byte b = 200;
byte c = a * b;
Console.WriteLine(c);
Console.ReadLine();
}
}
}
Bilinçsiz tür dönüşümleri değişkenler de kullanıldığı gibi, sabitler içinde aynı şekilde kullanılır.
Double c = 16.5f;
(Bir float sabiti olan 16.5 sayısı double türünden bir değişkene atanmıştır.)
int c = 'a';
(Bir char türünden sabit olan ‘a’ karakteri int türünden bir değişkene atanmıştır.)
C# dilinde bilinçsiz olarak tür dönüşümü yapabileceğimiz bütün veri türleri aşağıdaki tabloda mevcuttur.
Not !! : Bazı veri türleri arasında tür dönüşümü yapmak mümkün değildir. Bunlar;
- Bool , decimal ve double türünden herhangi bir türe ,
- Herhangi bir türden char türüne ,
- Float ve decimal türünden herhangi bir türe (float türünden double türüne dönüşüm hariç)
Yukarıdaki istisnai bazı durumları anlatan bir örnek;
😊rnek;
Kod:
namespace TurDonusumu6
{
class Program
{
static void Main(string[] args)
{
short b1 = 50;
char c1 = b1;
bool b2 = true;
int i1 = b2;
double d1 = 10.2;
int i2 = d1;
decimal m1 = 25.4M;
double d2 = m1;
byte bt1 = 65;
char c2 = bt1;
float f1 = 25.74F;
decimal d3 = f1;
}
}
}
( Bu örnek yazıldığında tür dönüştürülemez hatası ile karşılaşırız . Dikkat edilmesi gereken nokta short ve char türünün aralarında yapmak istedikleri dönüşüme izin verilmemesidir. Her iki veri türü 16 bitlik veri tutmaktadır. Söz konusu olan bu durum için bu dönüşüme tür güvenliği açısından izin vermemektedir. Programımızın vermiş olduğu hata görüntüsü aşağıda yer almaktadır. )
Büyük Türün Küçük Türe DönüştürülmesiBüyük türün küçük türlere dönüşümü ancak tür dönüştürme operatörleri ile gerçekleşmektedir. C# bu şekilde bir dönüşüme izin vermemektedir. Eğer izin verilmiş olsaydı bilinçsiz olarak yapacağımız tür dönüşümlerinde çeşitli veri kayıpları olacağını daha öncede belitmiştik.
😊rnek;
Kod:
namespace TurDonusumu7
{
class Program
{
static void Main(string[] args)
{
decimal c = 10;
byte b = c;
Console.WriteLine(b);
Console.ReadLine();
}
}
}
(Burada bir decimal türünden bir nesne, kendinden küçük bir tür olan byte türüne dönüştürülmüş , ancak sonuç olarak programımız derlenemeyecektir. Çünkü,aşağıda yer alan hatayla karşılaşacağız. (
Cannot implicitly convert type ‘decimal’ to ‘byte’ ) yani
(‘decimal ’ türü bilinçsiz olarak ‘ byte’ türüne dönüştürülemez ) hatası verecektir.
Bilinçli(Explicit) Tür DönüşümüBu tür dönüşümü genellikle derleyicimizin izin verdiği süreçte yapılmaktadır. Bilinçli(explicit) tür dönüşümü veri kayıplarına sebebiyet verdiğinden bu durum göz önünde bulundurularak kullanılmalıdır. Bu tür bir dönüşüm genellikle iki şekilde yapılmaktadır. Birincisi küçük türün büyük türe dönüşümü ve ikincisi büyük türün küçük türe dönüşümü şeklinde yapılmaktadır.
Yine bu tür dönüşümünde de tıpkı bilinçsiz yapılan tür dönüşümünde olduğu gibi küçük türün , büyük türe dönüşümüyle aynı şekilde yapılır.
Tür Dönüştürme OperatörüTür dönüştürme operatörü kullanımı açılıp kapanan parantezler ile yapılır. Aşağıdaki tanımlama da olduğu gibi;
(dönüştürülecek tür) değişken_ya_da_sabit
😊rnek
Kod:
namespace TurDonusumu8
{
class Program
{
static void Main(string[] args)
{
byte b = 10;
int i = (byte)b;
Console.WriteLine(i);
Console.ReadLine();
}
}
}
( Burada byte türünden bir değişken int türüne dönüştülmüştür. Programımızı çalıştırdığımızda sonuç olarak 10 yazacaktır. Byte türü , int türünden küçüktür bu yüzden operatör kullanmadan da yapılabilir. Burada operatörün görevi okunabilirlik işlevini yapmasıdır. Yani bu iki kullanımı anlayan birisi operatör ve tür dönüşümünü zamanla kavrayacaktır ve bu tür durumlarda operatör kullanmanızı tavsiye ederim. Gittikçe çoğalan kaynak kodlarımız zamanla karışıklığa yol açabilmektedir. Bu nedenle daha anlaşılır ve okunur şekilde yazmak bizim yararımızadır. )
Bilinçli Tür Dönüşümünün SakıncalarıTür dönüşümünde yapılmasında sakıncalı olunan , büyük türün küçük türe dönüşümüdür. Bu sakıncalı durumu gidermek sadece operatör kullanmakla mümkün. Aşağıda yer alan programımız bu durumu anlamamızı sağlayacak basit bir örnektir.
😊rnek;
Kod:
namespace TurDonusumu9
{
class Program
{
static void Main(string[] args)
{
int i = 10;
byte b = (byte)i;
Console.WriteLine(i);
Console.ReadLine();
}
}
}
( Yukarıdaki programda daha büyük olan int türü, byte türünden bir nesneye atanmıştır ve derlenme esnasında bir hata ile karşılaşmayız. Sonuç değeri 10 olarak ekrana çıkar ve bir veri kaybı yaşanmaz. Nedeni ise değişkenimiz int türünden tanımlanmış ve 10 sayısı i değişkenine atanmıştır.Int türü 4 bytelık bir alan kaplar ve i değişkeninin bellekteki tutulma şekli şu şekildedir;
i değişkeni-> 00000000 00000000 00000000 00001010
BYTE BYTE BYTE BYTE
Burada byte türü sekizli sayı bloğununda bir byte türünü göstermektedir. i değişkeninde yer alan 10 değeri, son sekizli blokla ilişkilidir.
Programımızda byte türünden bu değişkeni dönüştürmeye çalıştığımızda byte türü bir bytelık veri tutumaktadır. Geri kalan 3 blok ise (yüksek anlamlı 3 byte ) i değişkeninde işlevsel olmadığından herhangi bir veri kaybı yaşanmadan tür dönüşümü mümkün olabilmektedir. Fakat i değişkenine atanan değerin son blokta ki bitler ile ifade edilemiyorsa yani kısacası 255 değerini aşıyorsa dönüşüm esnasında veri kaybı olmuş demektir. )
😊rnek;
Kod:
namespace TurDonusumu10
{
class Program
{
static void Main(string[] args)
{
int i = 256;
byte b = (byte)i;
Console.WriteLine(b);
Console.ReadLine();
}
}
}
( i değişkenine atanan 10 değeri yerine 256 değerini atadık ve ekrana ne yazdığını çalıştırıp görelim.)
Ekran Çıktısı :
( Programımız derleme sonucunda ekrana 0 sayısını yazdı. Normal şartlarda ekrana 256 değeri yazması gerekir. Derleme esnasında herhangi bir hata ile de karşılaşmadık ve programımız çalıştı fakat biz burada veri kaybetmiş olduk. )
Tür dönüştürme operatörü ile yapılan bilinçli tür dönüştürme işlemi veri kaybına neden olduğundan bizlere bazı sıkıntılar çıkardığı kadar, hız ve kod organizasyonu gibi bazı durumlarda ise bizlere kolaylıklar sağlamaktadır. Bu yüzden her iki durum için dikkatle kullanılmalıdır.
Değişkenler üzerinde tür dönüşümünü uyguladığımız gibi sabitler üzerinde de tür dönüştürme operatörünü kullanabiliriz. Örneğin , float türünde olan bir sabiti, double türünden bir nesneye atamak istersek şu şekilde yaparız:
double b = (float)25.36;
Checked ve Unchecked Anahtar SözcükleriBilinçli olarak yani tür dönüştürme anahtar kelimelerini kullandığımız durumlarda herhangi bir derleyici hatası almayız. Atama işlemi yapılırken verilerimizin kaybolduğunu görebiliriz ve bu durum dışında istenmeyen bazı sorun yaratacak hatalar da olabilir. En önemli sorunumuz veri kayıplarının yaşanmasıdır.
Veri kayıplarını önlemek için checked(kontrol) dediğimiz anahtar sözcüğünü kullanırız.
Programımızın çalışması esnasında veri kaybının olacağı zaman checked anahtar sözcüğü kullanarak hata vermesini sağlarız. Çünkü hata vermeden programımız derlenirse veri kaybı meydana gelebilir ve biz bu kaybı tüm kod bloğunda aramaya kalktığımızda özellikle de çok uzun programlarda bulmak ise daha da zorlaşır.
Yani burada anlatılmak istenen kısacası şudur , kod yazımı sırasında oluşabilecek hatayı bize checked kavramı bulur ve derleme aşamasında hatanın nerede olduğunu ve hatanın niçin kaynaklandığını bize gösterir.
Aşağıdaki Checked kullanımına bir örnektir.
😊rnek;
Kod:
namespace TurDonusumu11
{
class Program
{
static void Main(string[] args)
{
int i = 256;
byte b;
checked
{
b= (byte)i;
}
Console.WriteLine(b);
Console.ReadLine();
}
}
}
( Programımızı derledikten sonra aşağıda yer alan bir görüntüyle karşılaşırız.)
Ekran Çıktısı :
( Burada hata ile atama işleminde bir taşmanının olduğunu göstermektedir. Dikkat edilmesi gereken noktamız Exception kısmıdır. Exception istisnai durumlarda hata yakalamaya yarar. Yani hatanın nedenini bize anlatmaya çalışır.)
Not !! : Checked kullanımında önemli olan bir diğer durumumuz ise checked bloklarının içerisinde tanımlanan değişkenlerin blok dışında tanınmamasıdır.
Örneğin , aşağıdaki programımızı çalıştırdığımızda derlenemeyecektir.
😊rnek;
Kod:
namespace TurDonusumu12
{
class Program
{
static void Main(string[] args)
{
int i = 256;
checked
{
byte b = (byte)i;
}
Console.WriteLine(b);
Console.ReadLine();
}
}
}
Programımız çalışmayıp şu hatayı verecektir;
The name 'b' does not exist in the current context ( 'b' adı mevcut bağlamda (isim alanında) mevcut değil. ))
Unchecked (kontrolsüz) ise bir diğer anahtar sözcüğümüzdür. Bu anahtar sözcüğü checked anahtar sözcüğünün tam tersidir. Yani kısacası tüm kodlar varsayılan bir durumda yer alır ve görevi hatalarının gözardı edilmesini istediğimiz durumlarda ise unchecked ifadesinin kullanımıyla sağlanır.
Unchecked ifadesini anlatan bir örnek;
😊rnek;
Kod:
namespace TurDonusumu13
{
class Program
{
static void Main(string[] args)
{
int i = 256;
int a = 300;
byte b, c;
checked
{
b = (byte)i;
unchecked
{
c = (byte)a;
}
Console.WriteLine(b);
Console.ReadLine();
}
}
}
}
(Burada checked bloklar içinde ki uzun kod bölümünde bazı yerleri unchecked durumuna getirdik. )
Referans Ve Değer Türleri Arasındaki DönüşümC#’ ta değer tipindeki verilerin referans tipine çevrilmesi en hassas durumlardan biridir. Değer tipleri ve referans tipleri bellekte farklı bölgelerde tutulur. Bu yüzden bu iki veri tipinin dönüşümleri de farklı olmaktadır.
Bu tip dönüşümlerinde bazı kavramlar vardır bunlardan bazılarının kullanımlarının nasıl olduğuna hep birlikte bakalım.
Object Türü ve ToString() MetoduC# dili %100 nesne yönelimlidir ve her şey bir nesne olmalıdır kuralı ile işlenen bir dildir. Bu yüzden C# dilinde her şey bir nesnedir. Temel veri tiplerimiz dahil tüm veri tipleri object denilen referans türünden türetilmiştir.
Türeme durumu ise nesneden nesneye yapılmaktadır. Bu türeme sırasında var olan tüm özellikler korunur. Örneğin, object nesnesine ait olan ToString() metodu tüm temel veri türleri için, hem de referans türleri içinde kullanılmaktadır.
😊rnek;
Kod:
namespace TurDonusumu14
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine(3.ToString());
Console.ReadLine();
}
}
}
(Burada ToString kullanarak 3 tam sayı sabitini ekrana yazdırdık. Yani ToString kullanmak değişkeni ya da sabiti string tipine dönüştürür.)
Not!!: Şu şekilde de kullanımı da mevcuttur ;
String str =36.6f.ToString();
Şimdi de ToString() metodunu farklı bir örnekle deneyelim.
😊rnek;
Kod:
namespace TurDonusumu15
{
class Program
{
static void Main(string[] args)
{
int a = 5;
int b = 7;
string a1 = a.ToString();
string b1 = b.ToString();
Console.WriteLine(a + b);
Console.WriteLine(a1+b1);
Console.ReadLine();
}
}
}
( Bu örneğimizde int tipini kullanarak toplama işlemi yaptırdık. Burada dikkat edilmesi gereken ve hatırlatılması önem arz eden bir durum olan + operatörünün farklı türlerde farklı şekillerde kullanımıdır. + operatörü int türünde kullanıldığında aritmetik işlem anlamına gelmektedir string türünde kullanıldığında arka arkaya ekleme(birleştirme) yapmak anlamına gelmektedir.)
Ekran çıktısı:
Boxing Kavramı“ Box ” kelimesinin Türkçe karşılığı kutu anlamına gelmektedir. Boxing ise kutulama demektir. C# dilinde ise bir nesnenin object türüne bilinçli ya da bilinçsiz olarak dönüştürülmesi olarak da tanımlanabilir. Object nesneleri referans tipi sınıfında yer aldığından , heap bellek bölgesinde tutulurlar. Değer tipi nesneleri ise stack(yığın) denilen bellek alanında tutulurlar.
Değer tipinden birini referans tipinden bir nesneye atamak istediğimizde stack alanında tutulan verimiz , heap alanına bit olarak kopyalar. Bu işlem sonrası stack alanında tutulan verimiz object türünden bir değişkeni heap alanında göstermek için ayarlar. İşte bu işlemin gerçekleşmesini sağlayan boxing dediğimiz kavram üstlenir.
Kullanım Şekli;
int i= 50;
object o= i;
Diğer bir kullanımı da bilinçsiz tür dönüştürme operatörü kullanarak da yapılabilir.
int i=50;
object o =(object)i;
Unboxing KavramıUnboxing , boxing ‘in yaptığı görevin tam tersini yapmaktadır. Burada da stack olayı vardır. Yani kullandığımız nesnelerin değeri bit olarak stack bölgesinde kopyalanır. Referans türlerin değer türlerine dönüşümü bu sayede yapılmaktadır.
Yazdığımız programın çalışma anında bir sorunla karşılaşmaması için şu kısımlara özellikle dikkat edilmesinde fayda vardır. Bunlardan ilki,
Unboxing yapacağımız bir işlemin, daha önceden boxing işleminden geçmiş olması lazım,
İkincisi ise ,
Dönüşüm anında boxing işleminden unboxing’e dönüştürürken nesnemizin doğru türe çevirildiğinden emin olmamız lazım.
Not !! : Unboxing işlemi bilinçsiz bir şekilde yapılmamaktadır.
😊rnek;
Kod:
namespace TurDonusumu16
{
class Program
{
static void Main(string[] args)
{
int i = 10;
object O = i;
int j = (int)O;
Console.WriteLine(i);
Console.WriteLine(j);
Console.ReadLine();
}
}
}
Ekran Çıktısı:
int j = (int)O; satırını şu şekilde değiştirdiğimizde int j = (byte)O; derleme sırasında tür dönüşümü (InvalidCastException) hatası alırız.
System.Convert Sınıfı ile Tür DönüşümüC# dilinin yanı sıra .NET sınıf kütüphanesinde yer alan bir kısım sınıflar tür dönüştürme işlemi yaparlar. Klasik kullanımız olan çoğu kullanıcın en çok tercih ettiği System isim alanında bulunan Convert sınıfıdır.
Bu sınıfın neredeyse tüm türlere dönüşümünü gerçekleştiren metotoları mevcuttur.
Bir türün kendi türüne dönüşümünde aynı tür tekrar üretilmiş olur. Tıpkı aşağıdaki örnekte yer aldığı gibi;
😊rnek;
int a = 50;
int b = Convert.ToInt32(a);
Aşağıda yer alan tablomuzda Convert sınıfının farklı türlere göre metotları yer almaktadır. Parametreleri string türü olarak verilmiştir. Bu zorunlu değildir Sadece daha sık kullanılan bir tür olduğundan string olarak örnek verilmiştir.
Şimdi de Console.Readline() metotunun Convert sınıfı ile dönüşümünü gösteren bir örnek yapalım.
😊rnek;
Kod:
namespace TurDonusumu18
{
class Program
{
static void Main(string[] args)
{
string s1, s2;
int sayi1, sayi2;
int Toplam;
Console.WriteLine("İLK SAYIYI GİR:");
s1 = Console.ReadLine();
Console.WriteLine("İKİNCİ SAYIYI GİR:");
s2 = Console.ReadLine();
sayi1 = Convert.ToInt32(s1);
sayi2 = Convert.ToInt32(s2);
Toplam = sayi1 + sayi2;
Console.WriteLine("Toplam=" + Toplam.ToString());
Console.ReadLine();
}
}
}
(Burada iki string tür alınmakta ve Convert.ToInt32() metodu ile bu string ler int türüne dönüştürülüp toplamları alınmıştır.)
Ekran Çıktısı:
Düzenle Kullanıcı Tarafından 20 Ekim 2017 Cuma 14:05:01(UTC)
| Sebep: Sebep Bildirilmesi
