Bilgisayar ile insan iletişimi genelde yazı ile oluyor. Bilgisayarın çıktıları genellikle yazı olarak vermesini isteriz. Eğer sayıları göstermesi gerekiyorsa ekranda, göstereceği sayıyı yazıya dönüştürerek yapar.
Meselâ, 45 sayısını 32-bit tamsayı olarak saklar. Bellekteki bitler aşağıdaki gibidir.
0000-0000-0000-0000-0000-0000-0010-1101
Buna sayının ikili gösterimi denir. Bir sayının ekranda gösterilebilmesi için onun Unicode karaktere dönüşmüş olması gerekir. Unicode karakterin gerçek değeri sayının genliğine eşittir. Meselâ 45 sayısı 4 ve 5 karakterlerinden oluşur. Yani iki tane 16-bit koddan oluşur.
0000-0000-0011-0100 ve 0000-0000-0011-0101
Bildiğiniz gibi, Console.Write ve Console.WriteLine yöntemleri ekranda gösterebilmek için otomatik olarak tamsayıları string haline dönüştürürler. Bazen string veriyi tamsayıya, tamsayıyı stringe dönüştürmek istersiniz. Bir string ifadeyi tamsayıya dönüştürmek için string ifade sadece rakamlardan oluşmalıdır, eksi işareti de içerebilir.
Şimdi bir tane tamsayı bir tane de string değişken tanımlayarak işe başlayalım.
int I = 45;
string S;
Basit bir şekilde bir tamsayıyı string ifadeye dönüştüremezsiniz.
S = I; // Bu şekilde olmaz.
Eğer yukarıdaki ifadeyi denerseniz aşağıdaki gibi bir hata mesajı alırsınız.
Cannot implicitly convert type ‘int’ to ‘string’
(int türünde bir sayıyı string türüne kapalı dönüşümle dönüştüremezsiniz.)
Aşağıdaki gibi casting yapmak da mümkün değildir.
S = (string)I; // Bu şekilde de olmaz.
Eğer yukarıdaki ifadeyi denerseniz aşağıdaki gibi bir hata mesajı alırsınız.
Cannot convert type ‘int’ to ‘string’
(int türünü string türüne dönüştüremedi.)
C# tip güvenli bir dildir yani farklı türlerin kapalı dönüşüm ya da açık dönüşüm ile dönüştürülmesinde bir takım kurallar ve kısıtlamalar söz konusudur.
Ama buna rağmen bazı durumlarda tamsayı bir türün string bir türe dönüştürülmesi sahne arkasında meydana gelir, meselâ Console.WriteLine yöntemi böyledir.
Bir tamsayıyı string ifadeye dönüştürmenin bir yolu, onu boş bir string ile birleştirmektir.
S = "" + I;
ya da
S = I + "";
Her iki durumda da C# tamsayıları string bir ifade ile birleştirebilmek için dönüştürme işlemini yapar. Tamsayı ile birleştirilmek istenen string boş olduğuna göre sonucu etkilemez, neticede tamsayı bir ifade string bir ifadeye dönüşmüş olur. Mesela I değişkeni 45 sayısına eşit olsa dönüştürme işleminden sonra ‘4’ ve ‘5’ karakterlerinden meydana gelen bir yazı olur. Hala dönüştürme işlemi sahne arkasında yapıldı. Biraz da hile yaptık. Ama açık bir şekilde bir tamsayıyı string ifadeye dönüştürmek için ToString isminde bir yöntem kullanabiliriz. Herhangi bir değişkeni string ifadeye dönüştürür.
S = I.ToString(); // Dönüştürme işlemi başarılı.
Bu işlem sonucunda S string ifadesi “45” olan iki karakterli bir yazı oldu.
ToString bir yöntemdir. her zaman yöntemleri isminin sonunda parantez aç ve parantez kapa işaretleri ile birlikte kullanırız. Yöntemi tanımlarken de, kullanırken de bu böyledir. Yukarıdaki ifadede geçen ToString yöntemi hiç argümana sahip değildir ama dönen değeri bir string ifadedir.
Console ve WriteLine arasında noktaya ihityaç duyduğumuz gibi, tamsayı değişkenimiz ve ToString arasında da noktaya ihtiyaç duyduk. Hatta ToString yöntemini bir tamsayı ifadenin önünde kullanabilirsiniz.
S = 279.ToString();
Fark ettiğiniz gibi ToString yöntemi çok sık ihtiyaç duyulan bir yöntemdir. Bu yöntemi her nesne ve tür ile kullanırsınız ve nesnelerin yazıya dönüşmüş hallerini elde edersiniz.
Şimdi string bir ifadeyi tamsayıya dönüştürelim. Önce string bir değişken tanımlayalım ve rakamlardan oluşan bir değer atayalım.
S = "57";
Şimdi bu string ifadeyi tamsayıya dönüştürmek istiyoruz. Şansımıza, string ifademiz de sadece rakamlardan oluşuyor. Burada da söylemek gerekirse atama işlemini yine kullanamayız.
int I = S; // İşe yaramaz.
Hemen derleme hatasını görürsünüz.
Cannot implicitly convert type ‘string’ to ‘int’
(string ifadeyi tamsayı bir ifadeye kapalı dönüştürme ile dönüştüremezsiniz.)
Şimdi casting yapalım.
int I = (int)S; // Hala işe yaramadı.
Aşağıdaki derleme hatası oluştu.
Cannot convert type ‘string’ to ‘int’
(string türünü int türüne dönüştüremezsiniz.)
Hemen aklımıza bir yöntem olabileceği geliyor. ToString bi bir yöntem olsa da dönüştürme işlemini yapsak.
I = S.ToInt(); // Ama böyle bir yöntem yok.
Yok ama doğru yoldasınız. int Türü System.Int32 yapısının bir aliasıdır. Bu yapının Parse diye bir dönüşüm işi yapan bir yöntemi var.
I = Int32.Parse(S);
Int32.Parse yönteminin dönen değeri bir tamsayıdır. Parse yöntemine geçeceğimiz string rakamlardan oluşmalıdır ama eksi işaretine sahip olabilir. Sağında solunda boşluk olabilir. Mesela aşağıda doğru yazılmış bir ifade var.
I = Int32.Parse(" -572 ");
Eğer string, sayısal olmayan karakterler içeriyorsa ya da eksi işareti ile sayı arasında boşluk varsa Parse yöntemi bir istisna ortaya çıkaracaktır. Sayının int sınırlarının dışında olması da Parse yönteminin istisna ortaya çıkarmasına neden olur.
Şimdi her iki dönüşümü yapan yöntemleri bir karşılaştıralım, benzer ya da farklı yanlarına bakalım.
S = I.ToString();
I = Int32.Parse(S);
Her iki yöntem de System.Int32 yapısının elemanıdır. Aralarında temel bir fark var. ToString yönteminin sol tarafına bakalım. Bir tamsayı değişken var. ToString yöntemi belirli bir tamsayı var ve ona uygulanıyor. Fakat Parse yönteminin sol tarafında bir değişken yok. Int32 yapısının ismi var. Parse yöntemi belirli bir tamsayıya uygulanmıyor. Bir tamsayı oluşturuyor.
Aralarındaki temel fark ise ToString bir instance (örnek) yöntemdir, Parse ise static (durağan) bir yöntemdir. ToString bir örnek yöntemdir, dolayısıyla belirli bir tamsayıya uygulanır, diğer bir deyişle Int32 yapısının bir örneğine uygulanır. Bir tamsayıya ya bir tamsayı değişkene ya da Int32 yapısının bir örneğini yani tamsayı döndüren bir yönteme sahip olasınız ki ToString kullanabilesiniz.
Int32.Parse static bir yöntemdir. Yöntemin soluna Int32 yapısının adını yazdıktan sonra kullanırsınız. Int32.Parse yöntemini çağıracak belirli bir tamsayıya sahip olmanıza gerek yok. Yöntemin kendisi bir tamsayı oluşturur.
Başka durağan yöntemler de biliyoruz. Console.Write ve Console.WriteLine yöntemleri, Main yöntemi de durağan yöntemlerdir. MinValue ve MaxValue (field) alanları ise Int32 yapısının durağan alanlarıdır. Bu yöntemlerin önüne yapıların adını yazmak gerekiyor. String sınıfının Length yöntemi bir örnek alandır. Belirli bir string ifadeye uygulayabilirsiniz.
Bildiğiniz gibi int veri türü System.Int32 yapısının bir aliasıdır. Bu durumda System.Int32 yerine int yazabilirsiniz hatta using direktifi ile System isim uzayını deklare etmişseniz sadece Int32 de yazabilirsiniz.
I = Int32.Parse(S);
Ya da aşağıdaki gibi olabilir.
I = int.Parse(S);
Her iki kullanım da aynı işi yapar ama gerçek sınıfın ya da yapının adını kullanmayı tercih edebilirsiniz. Bütün tamsayı türleri ToString ve Parse yöntemine sahiptirler. Meselâ:
ushort US = UInt16.Parse(S);
ya da
ushort US = ushort.Parse(S);
Parse yöntemini işaretsiz tamsayılarla kullanırken eksi işareti kullanmak bir istisna ortaya çıkaracaktır. Yöntem çağrılarının işlem önceliği vardır. Peki aynı ifade içerisinde 2 tane yöntemi yan yana çağırırsak ne olacak?
string S2 = Int32.Parse(S).ToString();
Aynı önceliğe sahip 2 tane yöntem var. Bu tür durumlarda öncelik sırası soldan sağa doğrudur. Öncelikle Int32.Parse yöntemi çalışır. Bu durağan yöntemin çalışması sonucunda bir tamsayı oluşur. O zaman ifade aşağıdaki şekle dönüşür.
string S2 = 45.ToString();
Artık kolay. ToString yöntemi örnek yöntemdir. 45 sayısını ‘4’ ve ‘5’ şeklinde 2 tane karakterden oluşan S2 string ifadesine dönüştürür.
Şimdi tersini yapalım. Önce bir tamsayıyı string ifadeye dönüştürelim, sonra bu string ifadeyi tekrar tamsayıya dönüştürelim ve tamsayı bir değişkende tutalım.
int I2 = Int32.Parse(I.ToString());
Bu iç içe yöntem çağırmadır. Bir yöntem diğer bir yönteme argüman olarak yazılmış. Bu durumda görünüşe bakılırsa Parse yöntemi önce çalışacak gibi ama değil. Öncelikle argüman gerekiyor. Bunun için de ToString yönteminin çalışması gerekiyor. Çalışınca ifade aşağıdaki şekle dönüşür.
int I2 = Int32.Parse("45");
Daha sonrası zaten kolay. Parse yöntemi çalışır ve bir tamsayı döndürür.
System isim uzayı Covert diye de bir sınıf barındırır. Çok güzel bir sınıftır. Bütün temel türleri diğerlerine dönüştürebilecek durağan yöntemlere sahiptir. Şimdi aşağıda gördüğünüz örnek bir string ifadeyi tamsayıya dönüştürmek için alternatif yol sunar.
I = Convert.ToInt32(S);
Covert sınıfının dokümanları incelendiğinde Int32.Parse kullandığı görülür. Onun için olan bütün kurallar ve kısıtlamalar Convert için de geçerlidir.
Aşağıdaki örnek de ToString örnek yöntemine durağan bir alternatiftir.
S = Convert.ToString(I);
Convert sınıfı aynı zamanda bu yöntemlerin aşırı yüklenmiş şekillerine de sahiptir. Sayı tabanları ile çalışmaya da izin verir. Bu aşırı yüklenmiş yöntemler virgülle ayrılmış 2 tane argümana ihtiyaç duyarlar. Meselâ:
I = Convert.ToInt32(S, 16);
Bu örnekte S değişkenindeki string ifadenin hexadesimal rakamlar içerdiğini varsayar. Yöntemin ikinci argümanı sadece 16 değil 2, 8, 10, 16 olabilir. Her durumda ilgili string ifade o tabanda geçerli olacak rakamlara sahip olmalıdır. Meselâ eğer ikinci argman 2 ise string ifade sadece 0 ve 1 rakamlarını içermelidir.
Benzer şekilde aşağıdaki ifade de tamsayıyı hexadesimale çevirir. Aşağıdaki gibi bir ifadede de yine ikinci argüman 2, 8, 10, 16 olabilir.
S = Convert.ToString(I, 16);
Parse yönteminin de aşırı yüklenmiş sürümleri var. Yöntemlerin aşırı yüklenmesi meselesini de başka bir yazıda ele alacağız.

Şimdi bir sinema bileti programı yazalım. Normal bilet ve öğrenci bileti için ayrı ayrı fiyat seçenekleri olsun. Program sinemaya gidince ödeyeceğimiz toplam tutarı bulsun.
using System;
class SinemaBileti
{
static void Main()
{
int TamBilet = 10, OgrenciBileti = 7;
Console.Write("Kaç tane tam bilet: ");
int TamBiletSayisi = Int32.Parse(Console.ReadLine());
Console.Write("Kaç tane öğrenci bileti: ");
int OgrenciBiletiSayisi = Int32.Parse(Console.ReadLine());
int ToplamTutar = TamBiletSayisi * TamBilet +
OgrenciBiletiSayisi * OgrenciBileti;
Console.WriteLine("Toplam tutar (YTL)" + ToplamTutar);
Console.ReadLine();
}
}
Yukarıdaki programda 5 tane değişken var. 2 tanesi ilk değer almış ve 2 tanesi kullanıcıdan isteniyor ve 1 tanesi de hesaplama sonucu oluşuyor.
İlk değer ataması yaptığımız 2 değişkene bir de başka açıdan bakalım.
Bu 2 değişkeni hiç kullanmasak ve programı aşağıdaki gibi değiştirsek yine aynı işlevi yerine getirir.
using System;
class SinemaBileti
{
static void Main()
{
//int TamBilet = 10, OgrenciBileti = 7;
Console.Write("Kaç tane tam bilet: ");
int TamBiletSayisi = Int32.Parse(Console.ReadLine());
Console.Write("Kaç tane öğrenci bileti: ");
int OgrenciBiletiSayisi = Int32.Parse(Console.ReadLine());
//int ToplamTutar = TamBiletSayisi * TamBilet +
// OgrenciBiletiSayisi * OgrenciBileti;
int ToplamTutar = TamBiletSayisi * 10 + OgrenciBiletiSayisi * 7;
Console.WriteLine("Toplam tutar (YTL)" + ToplamTutar);
Console.ReadLine();
}
}
Aralarında bir fark yok ama bu yeni şekilde 10 ve 7 değerleri birer sayı ve isimleri yok. Belki yorum satırları eklesek yardımcı olur. Eğer yorumlar olmazsa bir vakit sonra birisi sizin yazdığınız koda bakar ve “bu sayılar da ne?” der. Hatta bu kişi siz bile olabilirsiniz. Yazdığımız kodun okunurluğunu ve anlaşılırlığını kaybetmesi çok kötü bir durumdur.
Diğer yandan, kullanıcının bilet fiyatlarını kendisinin girmesine izin de vermek istemiyoruz. Aslında aşağıdaki gibi yapabilirdik.
Console.Write("Tam bilet fiyatını gir: ");
int TamBilet = Int32.Parse(Console.ReadLine());
Bilet fiyatlarının programın kaynak kodunda bulunmasını istiyoruz. Pogramın kodlarının içerisine değerleri yazmak en iyi çözüm değil. Bilet fiyatları değiştikçe kodu açıp değiştirip tekrar derlememiz lazım. Eğer sadece kendimiz kullanacaksak problem yok. Ama kodu değiştirip tekrar derledikten sonra yeni programı bütün kullanıcılara tekrar göndermek, yüklemek büyük problemler.
Kodu yeniden derlemektense, diskte bir dosyada tutmak ve gerektiğinde yeniden programı derlemeden sadece o dosyayı değiştirmek güzel bir çözüm. Bu işlerin nasıl yapılabileceğini başka yazılarda anlatacağız. Şimdilik bu değişkenleri kodun en üstüne koyalım, program açılır açılmaz değiştirilmesi kolay olsun.
Program kodlarının en üstünde aşağıdaki gibi iki ücret tanımlaması var.
int TamBilet = 10, OgrenciBileti = 7;
Ama programın sonlarına doğru aşağıdaki gibi bir kod bloğu gördüğünüz düşünün.
TamBilet = 12;
OgrenciBileti = 9;
Bilet fiyatları değişmiş. Muhtemelen siz değiştirdiniz ama yorum cümlesi eklemeyi unuttunuz.
Bunun gibi bir programda TamBilet ve OgrenciBileti fiyatlarının değişken olmaması gerekiyor. Sadece bir tek değere sahip olmaları ve program boyunca da değiştirilememeleri gerekiyor. Diğer bir deyişleTamBilet ve OgrenciBileti değişken değil de sabit olmalıdır.
Sabitleri başlarına const yazarak tanımlarız.
const int TamBilet = 10;
const int OgrenciBileti = 7;
Bir tanımlama ifadesinde const kullandıktan sonra artık TamBilet ve OgrenciBileti için değişken değil de sabit ifadesini kullanmak daha doğru olacaktır, TamBilet ve OgrenciBileti sabitleri.
Sabitlerin değişkenlerden ne farkı olduğunu inceleyelim. Tanımlama işlemini yaptıktan sonra değerini değiştirmeye çalıştığınız zaman derleme hatası ile karşılaşırsınız.
TamBilet = 12;
Eğer programın bir yerlerinde yukarıdaki gibi bir ifade kullanırsanız C# derleyicisi size aşağıdaki hata mesajını verecektir.
The left-hand side of an assignment must be a variable, property, or indexer.
(Bir atama ifadesinin sol tarafında bir değişken, özellik ya da indeksleyici bulunmalıdır.)
Ve TamBilet yukarıda sayılanlardan hiç birisi değildir. Gerçekte bir değişken değil, sabittir. Böyle bir derleme hatası aldığınız durumda, kendinize sormalısınız: “Acaba programın ilerleyen bölümlerinde değiştirmek isteyeceğim bir şeyi sabit olarak mı tanımladım?” ya da bu örnekte olduğu gibi “Acaba bir sabit tanımladım ama programın ilerleyen bölümlerinde yanlışlıkla değerini mi değiştirmeye çalıştım?” diye.
Bir sabit tanımladığınız zaman ona bir değer ataması da yapmalısınız.
const int TamBilet; // Derleme hatası!
Eğer yapmazsanız aşağıdaki hata mesajını görürsünüz.
A const field requires a value to be provided.
(Sabit bir alan için bir değer tanımlamanız gerekiyor.)
Program boyunca değeri değişmeyecek olan bir değişken sabit olmaya adaydır. Sabit tanımlamak sadece programcının değer değiştirmek suretiyle hata yapmasını önlemez, aynı zamanda programın performansını da artırır. Derleyici sabitlerin sakladığı değerleri stack bölgesinde oluşturmak durumunda kalmaz. Eğer TamBilet ve OgrenciBileti değerlerini saklamak için sabit tanımlarsanız, derleyici ToplamTutar değerini ilk yaptığımz örnekte olduğu gibi değil de ikinci örnekteki gibi hesaplar.
Sabitleri tanımlarken sadece literaller değil ifadeler de kullanabilirsiniz.
const int TamBilet = 10;
const int OgrenciBileti = 3 * TamBilet / 4;
OgrenciBileti, TamBilet değeri ile yapılan bir takım matematiksel hesaplamalardan sonra ortaya çıktı. TamBilet değerini değiştirerek OgrenciBileti değerini de değiştirebilirsiniz. Bu durumda TamBilet, OgrenciBileti’nden önce tanımlanmış olmalıdır. Yukarıdaki örnekte de olduğu gibi, bir sabite değer ataması yaparken başka bir sabitin değeri kullanılabilir ama değişken kullanılmaz.
Yorum Cümleleri adlı yazımızda geçen örneği hatırlarsak eğer, aşağıdaki gibi bir ifade vardı.
haftalikUcret = 80 * GunSayisi;
Bu örnekteki 80 sayısının ne için orada bulunduğunu kestirmek zor. Açıklayıcı bir isimle değiştirilse daha iyi olur. Yorum Cümleleri adlı yazımızda bir değişkenle değiştirmiştik. Fakat sabir kullanmak daha doğru bir karardır.
const int GunlukUcret = 80;
haftalikUcret = GunlukUcret * GunSayisi;
Sabit kullanmak ifadeyi daha anlaşılır yaptı, ama daha da anlaşılır yapabiliriz.
Sabit ifadeyi değerini açık hesaplamalar şeklinde yazarak da tanımlayabiliriz.
const int GunlukUcret = 8 * 10; //Günde 8 saat çalıþıldığını varsaydık.
Yukarıdaki çarma işlemi derleme esnasında yapıalcağı için programnı çalışmasında da bir performans kaybı olmayacaktır.
Bir sabitin değeri program derlenirken belli olmak zorundadır. Meselâ,
const string Prompt = "Adınızı giriniz: ";
Promt bir sabit olduğu için başka bir string ifade ataması yapılamaz. Fakat şu şekilde bir stringi bir sabite atayamazsınız.
const string Response = Console.ReadLine();// Olmaz.
ReadLine çağrısı çalışma esnasında oluşur, derleme esnasında değil. Derleme esnasında değeri belirli olan bir şeyi ancak bir sabite atayabilirsiniz.

Bazı programlama dillerinde değişkenlerin kullanımı veri tiplerine bağlı olmayabilir. Basic dili böyle idi. Bazı dillerde ise türlerin tanımlanması ve doğru karar verilmiş olması gerekir. Bir türün diğer bir türe dönüştürülmesi bizzat programcı tarafından açık olarak yapılmalıdır. Bu yüzden, Basic programlama dilinde veri tipleri üzerindeki kontrollerin artması en önemli gelişmelerden birisi olmuştur.
Programcılarının değişkenler için veri tiplerini seçmesi gerekir. Tamsayı olmayan sayılar için C# programlama dili floating point ve decimal olmak üzere iki ayrı alternatif sunar. Decimal veri tipi diğer dillerde olmayan farklı bir veri tipidir.
Gerçek sayılar için decimal veya floating point türünde değişken kullanmamız gerekir. Bilimsel veya mühendislik uygulamaları için tanımlanacak değişkenler için floating point veri tipi kullanılır. Floating point veri tipi çok büyük ve çok küçük sayılar için kullanılır. Bazı durumlarda, floating point türü kullanıldığında çok küçük hatalı sonuçlar oluşabilir. Decimal veri tipi kesin sonuçlar verdiği için floating point kadar esnek değildir.
Decimal veri tipi, System.Desimal sınıfından türetilir. Kullanımı:
decimal cebimdekiPara;
Eğer cebinizde bozuk para yok ise decimal tipinde değişken kullanabilirsiniz.
cebimdekiPara = 70;
Eğer bozuk paranız da varsa, şu şekilde kullanmak isterseniz:
cebimdekiPara = 70.25; //Problem olabilir.
Karışıklığa mahal vermemek için sonuna M veya m eklemeniz gerekir.
cebimdekiPara = 70.25m; //Düzgün çalışacaktır
Aşağıdaki programı inceleyelim.
//--------------------------------------------------
//biletHesabi.cs
//--------------------------------------------------
using System;
class biletHesabi
{
static void Main()
{
const decimal yuksekFiyat = 12.50m, dusukFiyat = 8.25m;
Console.Write(""Pahaly bilet fiyatını giriniz: "");
int pahaliBiletSayisi = Int32.Parse(Console.ReadLine());
Console.Write(""Ucuz bilet fiyatını giriniz: "");
int ucuzBiletSayisi = Int32.Parse(Console.ReadLine());
decimal toplamFiyat = pahaliBiletSayisi * yuksekFiyat + ucuzBiletSayisi * dusukFiyat;
Console.WriteLine(""Toplam fiyat:"" + toplamFiyat + "" YTL"");
}
}
Gördüğünüz gibi, decimal sayıları ve tamsayıları aynı ifade içinde kullanabiliyoruz. C# herhangi bir tamsayı değişkeni decimal türüne çevirebilir. Decimal değerler ve tamsayı değerler arasındaki hesaplama sonucu decimal değerdir. Fakat C#, decimal tipleri tamsayı tipine dönüştürmez.
decimal toplamPara = 54.25m;
int para = toplamPara; //Derleme Hatası
C# derleyicisi bu şekildeki çevirmeyi önlemektedir. Decimal veri tipinden tamsayı veri tipine çevirmede kayıp oluşabilir.
casting işlemi yaparak decimal tipte bir sayıyı kayıplarla birlikte tamsayı türüne dönüştürmek mümkündür.
int para = (int)toplamPara;
Bir bilme işlemin sonucunun decimal olabilmesi için işlem yapılacak sayılardan en az birisinin decimal olması gerekir, ya da decimal türüne dönüştürülmesi gerekir.
int a = 25, b = 10;
decimal c = a/b; //sonuc 2 çykacaktyr.
Çünkü bir tamsayının diğer bir tamsayıya bölünmesi sonucu bölüm yine bir tamsayıdır. İşleme giren sayılardan birisini açık dönüştürme ile decimal sayıya dönüştürelim.
int a = 25, b = 10;
decimal c = (decimal) a/b; //sonuc 2.5
Çıkan sonucu yuvarlamak isteyebiliriz. Bunu da kaç basamak yuvarlayacağımızı belirterek yapabiliriz.
decimal x = 25.77m;
decimal y = .05m;
decimal sonuc = x * y; // sonuc 1.2885
decimal yuvarlanmis = decimal.Round(sonuc, 2); //yuvarlanmis = 1.29 olur.