IRCForumları - IRC ve mIRC Kullanıcılarının Buluşma Noktası
  sohbet

 Kayıt ol  Topluluk
Yeni Konu aç Cevapla
Sayfa 2 Toplam 3 Sayfadan 1 2 3
 
LinkBack Seçenekler Stil
Alt 16 Mart 2009, 23:02   #11
Dilara
Guest
Kullanıcıların profil bilgileri misafirlere kapatılmıştır.
IF Ticaret Yüzdesi:(%)
Cevap: C# Hakkında Herşey.



checked – unchecked durumları

Belirtilen sınırların dışında bir sayıyı int türünde bir değişkende tutmak istersek taşma meydana gelir. Eğer -2.147.483.648 sayısından daha küçük bir sayı tutmak istersek underflow, 2.147.483.647 sayısından büyük bir sayı tutmak istersek overflow durumu oluşur. Biz genel olarak her iki durumu da overflow olarak adlandırırız.
Bunu engellemek mümkündür. Eğer program yazmak için key of csharp kullanıyorsak, bunu aşağıdaki resimde görüldüğü gibi compile options menüsünden yapabilirsiniz.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Eğer resimde gördüğünüz Check For Arithmetic Overflow seçeneği işaretli değilse, oluşacak taşmaları dikkate almadan işlemler yapılacaktır ve sonuçların yanlış çıkma ihtimali yükselecektir. Eğer, resimde görülen seçenek işaretli olursa, taşmalar dikkate alınacak ve çalışma sırasında taşma hataları görülecektir.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Belirli bir program bloğunun, aritmetik işlem taşmalarından muaf tutulmasını sağlayabiliriz ya da tam tersi olarak, taşma işlemlerinde hata oluşturacak şekilde işaretleyebiliriz. Bu işi de checked ya da unchecked program blokları oluşturarak yaparız.
Mesela programımız derleme sırasında aritmetik taşma işlemlerini denetleme seçeneği aktifken derlenmiş olsun. Bu durumda programı çalıştırdığımızda aritmetik taşma işlemi olunca program kesilecektir. Bir program bloğunu seçelim ve checked bloğu yapalım. Taşma durumu oluştuğunda checked bloğunun içerisindeki kodlarda oluşan taşmalar dikkate alınmaz. Derleme sırasında aritmetik taşma işlemlerini denetle seçeneği aktif değilken ise unchecked bloğu için tam tersi mümkün oluyor.
Aşağıdaki örneği aritmetik taşma işlemlerinde taşma hatası verecek şekilde ayarlanmış olarak derlerseniz taşma durumu oluşmayacaktır ve sonuç ekrana yazdırılacaktır. Bunu sağlayan ise unchecked bloğudur.
1
using System;
2
class Program
3
{
4
static void Main()
5
{
6
unchecked
7
{
8
int A = 1000000000;
9
int B = A * 20;
10
Console.WriteLine(B);
11
}
12
}
13
}
Buraya kadar olan kısımda tamsayı türü olarak sadece int bahsedildi ama, tamsayılar sadece 32 bitlik işaretli tamsayılar değildir. Ama int C#’ta en çok kullanılan tamsayı türüdür. Mesela bir etkinliğe katılan insan sayısını tutacaksanız, bunu negatif sayılara da izin veren int türü ile yapmak zorunda değilsiniz. İşaretsiz 32 bit tamsayıları tutabilen uint türü bir tamsayı değişkende tutabilirsiniz. uint, 32 bitliktir, tamsayı tutar ama 0 ile 4.294.967.295 arasındaki tamsayıları tutabilir. uint türünde de yine taşma hataları oluşabilir ve bunu yine checked ve unchecked blokları ile muaf tutabiliriz.
Eğer yazdığınız uygulamada, 32-bit sayılar yetmiyorsa, daha büyük ve daha küçük sayıları kullanabilmek için long ve ulong tamsayı türlerini kullanmalısınız. long işaretli 64-bit, ulong ise işaretsiz 64 bit tamsayıdır.
32 bitten daha küçük sayılar tutmak için de tamsayı türleri vardır. short ve ushort tipleri işaretli ve işaretsiz 16-bit tamsayı türleridir. sbyte ve byte ise 8-bit işaretli ve işaretsiz tamsayı türleridir.
System isim uzayının içerisinde Int32, Int16, Int64 gibi yapılar vardır. int, short , long gibi aliaslar yardımıyla da bu yapılara erişebiliriz. Mesela int tamsayı türü aslında Int32 ismiyle System isim uzayında bulunur ama int yazarak ulaşabiliriz. Aşağıdaki tanımlamalardan her ikisi de doğrudur.
int A;
System.Int32 A;
Aşağıdaki tabloda .net tarafından desteklenen tamsayı türleri, .net içindeki yapı isimleri ile alabilecekleri en küçük ve en büyük değerler toplu olarak bulunmaktadır.
C# Tür
.NET Yapısı
En Küçük
En Büyük
sbyte
System.SByte
-128
127
byte
System.Byte
0
255
short
System.Int16
-32,768
32,767
ushort
System.UInt16
0
65,535
int
System.Int32
-2,147,483,648
2,147,483,647
uint
System.UInt32
0
4,294,967,295
long
System.Int64
-9,223,372,036,854,775,808
9,223,372,036,854,775,807
ulong
System.UInt64
0
18,446,744,073,709,551,615
.net ailesinde yer alacak dillerin uyması gereken CLS (Ortak Dil Özellikleri), bütün dillerin bir birleri ile haberleşebilmeleri için oluşturulmuştur. .net aliesine katılacak bir dil, en azından bu özellikleri taşımalıdır.
Yukarıda görülen tablodaki SByte, UInt16, UInt32 ve UInt64 tamsayı veri türleri CLS uyumlu değildir. CLS, Byte, Int16, Int32 ve Int64 veri türlerini gereklilik olarak şart koşar ama diğerlerini değil. Bazı diller (mesela Visual Basic.net); Byte, Int16, Int32 ve Int64 haricindeki tam sayı türlerini desteklemez. Eğer diğer diller tarafından da kullanılacak bir dll yazıyorsanız, sbyte, uint16, uint32 ve uint64 veri türlerini kullanmaktan sakınmalısınız. Yoksa, yazdığınız dll mesela Visual Basic .net tarafından kullanılamaz.
Bir int, 32-bit işaretli tamsayı anlamına gelir ama aynı zamanda int, System.Int32 adlı yapının bir örneğidir. Böyle olmasının getirdiği bir takım avantajlar var. Tamsayı türlerini ifade etmekte kullandığımız yapıların ToString ve Parse diye adlandırılan ve en çok kullanılan yöntemleri vardır. Her birinin, MinValue ve MaxValue adında iki tane de alanı vardır.
Alanlar da yöntemler gibidir. Bir yapının ya da sınıfın üyesi olurlar. Ama alan daha basittir. Bunu bir değişken ya da sabit olarak düşünebilirsiniz. Mesela MinValue ve MaxValue alanları sabit değerlere sahiptirler. Program içerisinde alanları sınıfınismi.alanismi şeklinde kullanabilirsiniz. Aşağıdaki program, int tamsayı türünün alabileceği en küçük ve en büyük sayısal değeri ekrana yazar.
1
using System;
2
class Program
3
{
4
static void Main()
5
{
6
Console.WriteLine(Int32.MinValue);
7
Console.WriteLine(Int32.MaxValue);
8
}
9
}
Aynı şekilde diğer tamsayı türlerinin de alabileceği en küçük ve en büyük sayısal değerleri de ekrana yazdırabilirsiniz.
Integer literalleri, hexadecimal notasyonda da yazabilirsiniz. Hexadecimal sayılar, 0x ya da 0X ile başlar ve devamında 16lı sistemde yazılmış bir sayı gelir.
int A = 0x12A4;
int B = 0X34CA;
Sınırları aşmamak kaydıyla tamsayı veri türlerini aritmetik işlemlerde birlikte kullanabilirsiniz.
ushort US = 45867;
int I = 523;
int S = US + I;
Yukarıdaki örnekte toplama işlemi meydana gelmeden önce, C# otomatik olarak ushort yapıdaki sayıyı 32-bit işaretli tamsayıya dönüştürür. Çünkü toplama gibi aritmetik işlemler ancak aynı tür iki sayı arasında meydana gelebilir. Daha sonra toplama işlemi yapılır ve sonuç yine 32-bit işaretli bir tamsayıdır.
Burada dönüştürme işlemi programcının müdahalesi olmadan C# tarafından yapılmıştır. Bu tür dönüşümlere kapalı dönüştürme denir.
Eğer derleme evresinde sabit kalacak bir tamsayı sabiti tanımlamışsak, ve tamsayı 8-bit ya da 16-bit bir türdeyse, tanımlanan sabit geçerlidir ama C# onu 32-bit işaretli tamsayıya dönüştürerek derler.
byte B = 120;
Birden çok işlemi içine alan karmaşık bir işlem sırasında, adım adım dönüştürme işlemleri yapılır. Bir atama işlemi sırasında operatörün sağındaki ifadenin türü solundaki ifadenin türüne kapalı dönüştürme ile dönüştürülür. Dönüştürme işlemleri asıl işlemden daima önce yapılır.
Eğer bir int ile bir uint sayı arasında işlem yapılacaksa, C# önce her ikisini de long türüne dönüştürür. Çünkü, hem int hem de uint türünü kapsayan tamsayı türü longdur. Bu durumda aşağıdaki örnek çalışmayacaktır:
1
using System;
2
class Program
3
{
4
static void Main()
5
{
6
uint UI = 45867;
7
int I = 523;
8
int A = I + UI; // Bu satırda derleme hatası oluşur!
9
}
10
}
Hatanın nedeni, işlemin sonucununu int türü bir tamsayıya atamaya çalışmamızdır. Çünkü UI, bir uint türü sayıdır; I ise int türündedir. Bu iki türün bir işlemde kullanılması sonucu oluşacak sonuç long türünde olacaktır ve ancak long türü bir değişkene atanabilir. Oysa yukardaki örnekte sonuç , int türünde bir değişkene atanmaktadır.
Bazen, C# derleyicisinin kapalı dönüştürme yapmak istemediği bir işlemi yapma istersiniz. Bu işlemi yapmak güvenlidir ama C# derleyicisi buna müsaade etmez. O zaman, açık dönüştürme işlemi yaparsınız. Aşağıdaki örnekte bu şekilde açık dönüştürme yapılmıştır ve C# derleyicisi, bu örneği derler.
1
using System;
2
class Program
3
{
4
static void Main()
5
{
6
uint UI = 45867;
7
int I = 523;
8
int A = (int) (I + UI);
9
Console.WriteLine(A);
10
}
11
}
Her bir değişkeni tek tek de açık dönüştürme işlemine tabi tutabilirsiniz. Yukarıdaki örneği incelerseniz, UI adlı değişken uint türündedir ve sadece onu dönüştürerek de int türündeki A değişkenine sonucu atayabilirsiniz.
1
using System;
2
class Program
3
{
4
static void Main()
5
{
6
uint UI = 45867;
7
int I = 523;
8
int A = I + (int) UI;
9
Console.WriteLine(A);
10
}
11
}
Toplama işlemi yapılmadan önce UI değişkeni 32-bit işaretli tamsayı türüne dönüştürüldü ve işlem iki tane 32-bit işaretli tamsayı arasında yapıldı.
Bu tür dönüştürmeye daha çok type casting (tür dönüştürme) de denir. Bundan sonraki yazılarda sadece casting olarak kullanacağız.
Casting işlemi sırasında bit kayıpları da oluşabilir. Mesela bir 32-bit işaretli sayıyı 8-bit işaretli sayıya dönüştürecek olursak 8-bit işaretli tamsayı snırılarını aşan kısım ihmal edilecektir. Eğer aritmetik taşma işlemlerini denetleme seçeneği aktifse çalışma evresinde taşma istisnası oluşacaktır.
Casting işlemi birçok kolaylık sağlar ama suiistimale de açıktır. Kullanırken dikkat etmek gerekir. Oluşabilecek istisnaları yakalayacak yordamlar yazmak gerekir ki, bu işlemin nasıl yapacağını başka bir yazıda ele alacağız.

 
Alıntı ile Cevapla

IRCForumlari.NET Reklamlar
sohbet odaları sohbet odaları Benimmekan Mobil Sohbet
Alt 16 Mart 2009, 23:03   #12
Dilara
Guest
Kullanıcıların profil bilgileri misafirlere kapatılmıştır.
IF Ticaret Yüzdesi:(%)
Cevap: C# Hakkında Herşey.



C# String Veri Türü
String Veri Türü

Yıllardır bilgisayarlar kullanıcılarla iletişim kurmak için yazıyı kullanırlar. Programlama dillerinde karakter kelimesi, bir harf, sayı, noktalama işareti ya da bir sembol anlamına gelir. String kelimesi ise karakterlerin yan yana gelerek oluşturdukları dizi anlamına gelir. C# Dilinde string bir anahtar kelimedir. String türünde bir değişken tanımlarken aşağıdaki gibi yazarız.
string Yazi;
Burada Yazi adında, string türünde bir değişken tanımlaması yapılmıştır ya da başka bir deyişle, Yazi string bir değişkendir.
C#taki string veri türü .net Framework içerisindeki System.String sınıfının bir aliasıdır yani string yazmakla System.String yazmak aynı şeydir.
Yani aşağıdaki gibi de string değişken tanımlaması yapılabilir.
System.String Yazi;
Eğer programımızın üst kısmında using direktifi ile
using System;
yazmışsak, başındaki System. ifadesini yazmayabiliriz. Bunu zaten daha önceki yazılardan biliyorsunuz.
String Yazi;
Şimdi burada bir karışıklık oldu. Eğer usnig direktifi ile System isim uzayı direktifi yazılmışsa büyük harfle yazılan String yeterlidir ama C#ta bir veri türü olan ve küçük harfle yazılan string kelimesi de kendi başına System.String anlamına gelen bir alias olduğundan aşağıdaki gibi bir ifadeyi yazmak yanlış olur.
System.string Yazi; //Yanlış oldu.
Çünkü string kelimesinin karşılığı olan System.String ifadesini yukarıdaki ifadede yerine yazarsak
System.System.String Yazi; //Yanlış oldu.
yazmış oluruz. Tabi ki böyle bir ifade yoktur, çalışmaz.
Şimdi string türünde bir değişken nasıl tanımlanır öğrendiğimize göre değer ataması yapalım.
Yazi = "C#Türkü çok seviyorum.";
Yukarıdaki ifadenin sağındaki değere string literal denir. Bir string literal sıfır ya da daha fazla karakterden oluşur. Karakterin tanımını yukarıda yaptığımıza göre içinde neler bulunabileceği de açıktır: Harf, rakam, noktalama işareti ayda sembol. Dikkat ederseniz bir string literal çift tırnak arasına yazılır. Bu durumda string literali başlatan ve bitiren çift tırnak işaretleri string ifadenin kendisine dâhil değildir.
Yazı dilinde noktalı virgül, soru işareti gibi işaretler çift tırnakların içine yazılır. Ama C#ta noktalı virgül atama işlemini bitiren işarettir ve en sona yazılır. Karıştırmamak gerekir.
Bir string literal tek satır olmak zorundadır. Aşağıdaki atama işlemi çalışmayacaktır.
Yazi = "C#Türkü çok
seviyorum."; // Yanlış oldu.
Tamsayılar yazısında da anlattığımız gibi, string türü değişkenlere de tanımlama esnasında ilk değer ataması yapabiliriz.
string Yazi = "C#Türkü çok seviyorum.";
Bir stringi ekranda göstermek için daha önceden de bildiğimiz Console.Write ya da Console.WriteLine yöntemlerini kullanabiliriz.
Console.WriteLine(Yazi);
Bu ifade konsolda aşağıdaki gibi bir çıktı verecektir.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Çift tırnak işaretleri, ekranda görünmedi. Çünkü onlar string ifademizin bir parçası değildir. Bir değişken tanımlaması yapmadan da bir string ifadeyi direkt Console.Write ya da Console.WriteLine yöntemlerine geçebilirsiniz.
Console.WriteLine("C#Türkü çok çok seviyorum");
Console.WriteLine ile tamsayıları gösterebildiğimiz öğrenmiştik. Şimdi de string ifadeleri gösterebildiğini öğrendik. Bunu yapması mümkündür, çünkü Console.WriteLine yönteminin aynı isimde birden çok sürümü vardır. Aynı yöntemin birden çok sürümleri olmasına yöntemlerin aşırı yüklenmesi denir. Başka bir yazıda bu meseleyi anlatacağız.
Aşağıdaki ilginç örneği dikkatle inceleyelim.
using System;
class stringler
{
static void Main()
{
string A, B, C;
A = "Merhaba, ";
B = "Dünya";
C = A + B;
Console.WriteLine(C);
Console.ReadLine();
}
}
Ekran çıktısını incelersek çok temel bir örnek, ama programda ilginç bir yer var. 3 tane değişken tanımladık. İlk 2 tanesine değer ataması yapma işlemi daha öncekilerle aynı, sadece sayı değil de yazı kullandık. 3. değişkene değer ataması yapma işlemi biraz ilginç görünüyor. Çünkü iki tane yazı arasında toplama işlemi yapmaya çalışyıoruz.
Bu ne anlama geliyor? Artı işareti iki tane string ifadeyi birleştirir. Programı çalıştırdığımızda aşağıdaki çıktıyı görürüz.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Merhaba dünya cümlesi çok meşhur bir programcı selamıdır. 1978 yılında C Programlama Dili kitabının yazarları Brian W. Kernighan ve Dennis M. Ritchie tarafından ilk defa kullanılan bu ilk yazılan programın dünyaya merhaba demesi olayı gelenek haline geldi.
Ama Kernighan ve Ritchie string birleştirme örneğini yapamadılar, çünkü standart C dilinde string birleştirme yoktur, hatta string yoktur.
Değişik işlemler için aynı operatörün kullanılması, mesela toplama operatörü, operatörlerin aşırı yüklenmesi olarak bilinir. Bu meseyi de yine başka bir yazıda anlatacağız.
Dikkat ederseniz A değişkenine bir string literal ataması yaptık ama virgülden sonra bir boşluk bıraktık. Çünkü 2 tane stringi birleştirdiğimizde arasına kendisi boşluk koymaz bunu bizim belirtmemiz lazım.
Stringlerle de yine artı eşittir operatörünü kullanabilirsiniz.
string Yazi = "Bu bir yazıdır.";
Yazi += "Bu da bir yazıdır.";
Artı eşit operatörü, ilk string ifadenin sonuna ikinci string ifadeyi ekler. Bunlardan başka diğer operatörler stringlerle kullanılmaz.
String birleştirme işlemi, eğer çok uzun bir string ifadeyi bir değişkene atayacaksak çok işlevseldir.
string Kavgam =
"Kader beni, iki Alman devletinin tam sınırları üzerinde bir kasabada," +
"Braunau am Inn'de dünyaya getirdi. Alman olan Avusturya, büyük Alman vatanına" +
"tekrar dönmelidir. Hem bu birleşme, iktisadi sebeplerin sonucu olmamalıdır. " +
"Bu birleşme, iktisadi bakımdan zararlı olsa bile, mutlaka olmalıdır." +
"Aynı kan, aynı imparatorluğa aittir. ";
Aynı zamanda string literaller ile string değişkenlerin bir kombinasyonu olarak string birleştirmeyi kullanabilirsiniz.
string programlama_dili = "C# ";
Console.WriteLine("Ben " + programlama_dili + " programlamayı çok seviyorum." + " Ya sen?");
Yukarıdaki birleştirilmiş ifade aslında aşağıdaki şekilde ayrı ayrı da yazılabilir.
string programlama_dili = "C# ";
Console.Write("Ben");
Console.Write(programlama_dili);
Console.Write(" programlamayı çok seviyorum.");
Console.WriteLine(" Ya sen?");
Dikkat ederseniz ilk dört ifadede Console.Write kullanırken sonuncusunda Console.WriteLine kullandık. Çünkü Console.Write yöntemi imleci alt satıra geçirmez.
Yukarıda yazdığımız her iki örneğin de ekran çıktısı aşağıdaki şekildedir.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
System.String sınıfının Length diye bir özelliği vardır. Yöntem ve alan gibi özellik de bu cümlede teknik terim olarak kullanıldı. Özellikler de alanlar gibidir. Başka bir yazıda alanlar ve özelliklerden bahsedeceğiz. Şimdilik sadece Length özelliğinin ne işe yaradığını bilelim. Bir string ifadenin karakter sayısını bize verir.
Kavgam.Length
ifadesi bize 327 sayısını verir.
C#ta stringleri çift tırnak arasına yazarız. Eğer string literalin kendi içinde çift tırnak varsa onu nası yazabiliriz? Mesela aşağıdaki gibi bir string literali ekranda göstermek istiyoruz.
Atalarımız boşuna söylememiş “sakla samanı, gelir zamanı” diye.
Bu tür özel karakterlerin kullanılması programlama dillerinde her zaman problem olur. C# çözümü C ve C++ dillerinden almıştır. Bir string literal çift tırnak içeriyorsa, çift tırnakların soluna bir ters bölü işareti koymalıyız.
string Yazi = "Atalarımız boşuna söylelemiş \"sakla samanı, gelir zamanı\" diye";
Bu ters bölü işareti burada kaçış karakteri olarak görev yaptı. Kaçış karakteri sağındaki özel işaretin gerçek anlamında kullanılmasını engeller.
Peki, ters bölü işaretinin kendisini yazı içerisinde nasıl kullanırız? Yazı dilinde belki çok fazla kullanılmayan bir işaret ama MS-DOS ya da Windows programlarında dizin isimlerini ayırmada ters bölü işareti kullanılır. Bu ters bölü işaretinin çok acıklı bir hikâyesi var. UNIX işletim sisteminde dizin isimleri normal bölü işareti ile ayrılır, ters bölü işaretiyle değil. C dilinde de kaçış karakteri olarak kullanılma sebebi hiçbir özel anlamı olmamasıdır. MS-DOS 1.0 işletim sisteminde ise UNIX benzeri hiyerarşik bir dizin yapısı olmadığından normal bölü işareti komut satırı argümanı olarak kullanıldı.UNIX işetim sisteminde komut satırı argümanlarının solunda çizgi vardır. MS-DOS 2.0 işletim sisteminde hiyerarşik dosya yapısı gelince, C dilinde problem olacağı hiç akıllarına gelmedi ve dizin isimlerini ayırmakta normal bölü işareti yerine ters bölü işareti kullanıldı.
Bir string literal içerisinde eğer ters bölü işareti varsa yan yana iki tane kullanırız.
string Dizin = "C:\\Makaleler\\String Makalesi\\Metin.doc";
Şimdi bunu ekrana yazdırıp çıktısına bakalım.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Artık MS-DOS ya da Windows programlarında ters bölü işareti kullanma zorunluluğumuz yok, onun yerine normal bölü işareti de kullanabilirsiniz.
string Dizin = "C:/Makaleler/String Makalesi/Metin.doc";
Bilgisayarın içerisinde bir string literalin karakterleri sayılarla ve nihayetinde bitlerle saklanır. Uzun yıllar, bir çok bilgisayar ASCII (American Standard Code for Information Interchange – Bilgi Değişimi İçin Amerikan Kod Standardı) dediğimiz bir karakter kodlaması kullandı. ASCII 7-bit kodlardan oluştuğu için toplam 128 (27) çeşit karakteri gösterebilir.
Eğer standart Amerikan İngilizcesi klavyesi kullanıyorsanız, Üst Karakter Tuşuna (Shift Tuşu) bağlı olarak (harf, sayı ya da sembollerden) 47 tane tuştan 94 tane karakter oluşturabilirsiniz. Boşluk tuşu ayrı bir ASCII karakteri ile temsil edilir. ASCII ayrıca, yazıda gösterilmeyen, yazının nasıl gösterileceğini kontrol eden 33 tane kontrol karakteri sağlar. Bunlardan sadece bazıları günümüzde kullanılıyor. Satır başı tuşu, Sonraki satıra geçme tuşu (Bu ikisi imlecin bir sonraki satırın başına gitmesini sağlar), Geri Al Tuşu, Tab Tuşu, ESC tuşu. Bütün ASCII karakterleri klavyeden Ctrl tuşunu harf ve sembol kombinasyonları ile kullanarak oluşturulabilir. Yani 128 tane ASCII kodunu klavyeden yazabiliriz.
Fonksiyon tuşları (F1,…, F12), yön tuşları ve imleç hareket tuşları biraz farklıdır. Bunlar ASCII kodu üretmezler.
Pratikte kişisel bilgisayarlar ASCII tarafından sağlanan 128 karakteri de içeren yazı karakterlerini göstermek için 8-bit kullanırlar. Bu 8-bit kodlamaya ise genişletilmiş ASCII karakter kodlama seti denir.
Maalesef, genişletilmiş ASCII, tek standart değildir. Orijinal IBM Bilgisayar çizgi çizmek ve basit matematik semboller için ek rarakterler de kullandı. Windows ise Batı Avrupa dillerinde kullanılan sembolleri göstermek için Latin 1 adlı bir kodlamayı da destekler. Bir çok ülkede standart komiteleri kendi karakter kodlamalarını oluşturdular. Tabi ki bunların içinde Latin olmayan Arapça, İbranice, Yunanca, Kiril (Rusça) da var.
Sonuç karışıklık ve belirsizlik oldu. Eğer başka bir ülkeden ya da Apple Machintosh gibi başka platformlardan gelen e-posta mesajları almışsanız ve bunlarda anlamsız karakterler görmüşseniz bunların sebebi iki değişik 8-bit karakter kodlamasıdır.
1980lerin başında bu problemlere bir çözüm bulmak için çalışmalar yapıldı. Sonuç Unicode oldu. Unicode; Çince, Japonca ve Korece gibi şekilsel alfabeler de dâhil, bilgisayar iletişiminde kullanılan bütün dillerin karakterlerini gösterebilecek şekilde 65,536 (216) tane karakter içeriyor, 16-bit kodlama kullanıyor. Unicode karakterlerinin ilk 128 karakteri yine ASCII’nin aynısıdır. İkinci 128 tanesi ise Latin 1 karakterlerinin aynısıdır. Unicode hakkında daha fazla bilgi [Üye Olmadan Linkleri Göremezsiniz. Üye Olmak için TIKLAYIN...] adresinde mevcuttur. Unicode Standart Verison 3.0 adlı kitabın online sürümüne de yine bu siteden ulaşabilirsiniz.
8-bit karakter kodlamalarının yerini 16-bit Unicode karakterlere bırakması için uzun bir yol var. Ama bazı programlama dilleri, mesela C#, stringleri 16-bit Unicode olarak tutuyor. Unicode ile aşağıdaki gibi bir string ifadeyi rahatlıkla yazabilirsiniz.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Hem Yunan alfabesi hem de derece işareti ASCII karakter tablosunda yoktur.
Yunan harflerini Yunanca klavye ile rahatlıkla yazarsınız, ama derece işareti Yunan klavyeside yoktur. Genellikle, bir Unicode karakteri string içerisinde kullanabilmek için karakteri Unicode standardı sürüm 3.0 şekilde yazmak lazım ya da [Üye Olmadan Linkleri Göremezsiniz. Üye Olmak için TIKLAYIN...] adresindeki şekilde ve bir ters bölü şareti daha sonra küçük ya da büyük harflerle U ya da X koyduktan sonra 4-basamak hex karakter kodu yazarak gösterilir.
string Angle = "The angle \u03B1 equals 60\u00B0";
İlginçtir ama \u ve 4-basamak hex karakter kodlarını değişken isimleri diğer belirteçlerde kullanabilirsiniz. bu konuda daha fazla bilgi için C# Language Specification, 2.4.2 özellik dokümanına bakabilirsiniz.
C# ayrıca C dilinden aşağıdaki kaçış durumlarını da miras almıştır.
Kaçış Karakterleri
Unicode Kodlaması
Karakter İsmi
\0
\u0000
Null
\a
\u0007
Uyarı (beep)
\b
\u0008
Geri al Tuşu
\t
\u0009
Tab
\n
\u000A
Yeni Satır
\v
\u000B
Dikey Tab
\f
\u000C
Form besleme
\r
\u000D
Satır başı
\"
\u0022
Çift Tırnak
\’
\u0027
Tek Tırnak
\\
\u005C
Ters Bölü İşareti
Örneğin aşağıdaki ifadede ekrana yazı gösterirken \a karakterine gelince hoparlörden beep sesi çıkar ve devam eder. \a sadece konsolda geçerlidir. \v ve \f ise sadece yazıcıda geçerlidir.
Console.WriteLine("Uyarı sinyali ver \a ve devam et.");
ASCII kodlamasının çıkış kaynağı daktiloda kullnılan karakterlerdir. Mesela \r ve \n işlemini ancak daktilo ile anlayabiliriz. \r Satır başı kodu, yazma kafasını satırın başına getirir. \n ise yazma kafasını bir sonraki satıra geçirir. \n ve \r birlikte kullanıldığında bir sonraki satırın başına gitmiş oluruz. Text dosyalarda bu işlemler olmaz, platform uyumsuzluğu vardır. MS-DOS ve Windows platformlarında text dosyalarda bütün satırlar satır başı ve yeni satır kodlarıyla sonlanır. UNIX platformunda ise sadece yeni satır koduyla sonlanır. Macintosh ortamında ise sadece satır başı kodu satırı sonlandırır.
C# konsol programlamada, sadece yeni satır kodu bir sonraki satırın başına geçmek için yeterlidir.
Aşağıdaki ifadelerden her ikisi de aynı işi yapar.
Console.Write("\n");

 Console.WriteLine();
C# kaçış karakteri olarak ters bölü kullnmaya bir alternatif sunar. Eğer bir string literalin önüne @ işareti koyarsak kaçış karakteri kullanmaya gerek kalmaz.
string Dizin = @"C:\Makaleler\\String Makalesi\Metin.doc";
Buna verbatim string (harfi harfine – aynısı) de denir. Ters bölü işareti de normal diğer karakterlerden biri olarak algılanır.
Tabi bu durumda çift tırnak için iki tane çift tırnak kullanmak gerekiyor.
string Yazi = @"Atalarımız boşuna söylelemiş ""sakla samanı, gelir zamanı"" diye";
Daha önce &nbsp
Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
ı işaretinin string ifadeleri birleştirmek için kullanıldığını göstermiştik. Artı işaretini string ifadeleri sayılarla birlikte yazmak için de kullanabiliriz.
int toplamTutar = 100;
 Console.WriteLine("Toplam tutar :" + toplamTutar + " YTL dir.");
Burada kural oldukça basittir. Eğer artı operandının bir tarafındaki ifade string ise diğer tarafındaki ifade de string ifadeye dönüştürülür ve daha sonra da string birleştirme işlemi gerçekleşir.
Aşağıdaki ilginç durumu inceleyelim.
int A = 12;
int B = 20;
Console.WriteLine(A + B + " toplamlarıdır.");
Console.WriteLine("Toplamları " + A + B);
Yukarıdaki program kodunun çıktısı aşağıdaki gibi olacaktır.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Peki neden ikisi farklı çıktı. Operatör önceliği kavramından tamsayılar yazısında bahsetmiştik. Operatör önceliği kurallarına göre toplama işlemlerinde öncelik soldan sağa doğrudur. İlk ifadede soldan itibaren başlandığından önce A + B işlemi yapıldı daha sonra da string ifadeye dönüştürülerek sonraki string ifade ile birleştirildi. İkinci WriteLine çağrısında ise “Toplamları” string ifadesi 12 ile birleştirildi. Daha sonra “Toplamları 12” string literali 20 ile birleştirildi. “Toplamları 1220” ifadesi oluştu.
Bu problemi çözmek için aşağıdaki gibi bir çözüm bulabiliriz.
int A = 12;
int B = 20;
Console.WriteLine(A + B + " toplamlarıdır.");
Console.WriteLine("Toplamları " + (A + B));
Parantezlerin toplama işlemine göre önceliği olduğundan ilk önce parantez içindeki işlem gerçekleşir ve sonuç aşağıdaki gibi olur.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Tamsayılar yazısında da ifade edildiği gibi bütün tamsayı türler .net Framework içerisindeki yapılardan türetilir. string veri tipi ise System.String sınıfından türetilir.
Sınıflar ve yapılar birbirlerine benzerler. Ama çok temel bir farklılıkları var, yapılar değer tiptirler, sınıflar referans tip. Daha fazla bilgiyi Değer Tip & Referans Tip adlı yazımızdan öğrenebilirsiniz.
 
Alıntı ile Cevapla

Alt 16 Mart 2009, 23:04   #13
Dilara
Guest
Kullanıcıların profil bilgileri misafirlere kapatılmıştır.
IF Ticaret Yüzdesi:(%)
Cevap: C# Hakkında Herşey.



C# Değer Tip & Referans Tip
Değer Tip & Referans Tip


Değer-Tip & Referans-Tip (Value-Type & reference-Type)

Yüksek seviye dillerin bir iyi tarafı da, bilgisayarın arka planda nasıl çalıştığı konusunda programcının bilgi sahibi olmasına gerek kalmamasıdır. Ama bazen bilmekte de yarar var. Mesela bellekte değişkenlerin nasıl saklandığını bilmek isteyebilirsiniz. Program çalışırken değişken için bellekte değişkenin türüne göre yer ayrılır ve değişkene ihtiyacımız kalmadığında ise belleğin o bölgesi serbest bırakılır.
Bir yöntem çalışmaya başladığı zaman, içerisindeki bütün değişkenler için bellekte yer ayrılır. Bu yere stack denir. Yöntemin kullanımı sona erdiği zaman ise belleğin o bölgesi serbest bırakılır.
Şöyle bir örnek düşünelim :
int A,B;
long C;
string D;
Stack bölgesinde A ve B için 4’er byte, C için 8 byte yer ayrıldı. Peki D için ne kadar yer lazım? Bu miktar, string türündeki D değişkeninin ne kadar uzun olacağına bağlıdır. Bir string ifade çok kısa da olabilir, çok uzun da. Bu yüzden string değişkenlerin boyutu değişkendir.
Eğer string türü bir değişkene sabit bir ifade atanmışsa, boyut sabit olarak düşünülebilir. Eğer değişkenin içeriği kullanıcıdan istenen bir değer ise, veya dosyadan okunan ya da internetten alınan bir ifade ise boyutunu program çalışana kadar bilemeyiz.
Bu yüzden, string ifadeler, stack bölgesinde saklanmaz. Program çalışırken, string ifade için gereken yer heap adı verilen bölgede oluşturulur. Heap bölgesi, program çalışırken, ayırma ve serbest bırakma işlemleri yapmayı olanaklı kılan genel amaçlı bir bölgedir.
Yalnız stack ve heap bölgeleri hakkında bilinmesi gereken diğer bir gerçek var. Yukarıdaki kod bloğundaki D değişkeninin kendisi stack bölgesinde saklanır, heap bölgesinde bir alana referans içerir. D değişkeninde tutacağımız string ifadenin kendisi ise ilgili referansın gösterdiği heap bölgesindedir. Heap bölgesindeki string ifade programın akışı sırasında küçülebilir ya da büyüyeblir ama stack bölgesindeki referansı barındıran alan sabittir.
Referans derken neyi kastettiğimize biraz bakalım. Belleğin her bir hücresi numaralandırılımıştır ve bu numaralara bellek adresi denir. Program, bir bellek bölgesine erişmek isterse bu numaralardan yararlanır. Bir bellek bölgesine referans içermek demek o bölgenin adresini tutumak demektir. Yapısal programlama ile uğraşmış olanlar bunun işaretçi (pointer) demek olduğunu bilirler. Peki, içinde referans tutan bir değişken stack bölgesinde ne kadar yer kaplar? Günümüz yaygın işletim sistemleri 32-bit olduğuna göre 32 bit yani 4 byte yer kaplar.
Şimdi string ifade tutan bir değişken bellekte ne kadar yer kaplar sorusunun cevabını da bulmuş olduk. Değişkenin kendisi stack bölgesinde 4 byte yer kaplar ama string ifadenin kendisi heap bölgesinde değişken bir yere sahiptir. Kapladığı alan içeridği ifadenin boyutuna göre değişir.
Değer-Tip & Referans-Tip (Value-Type & Reference-Type)

Yeri gelmişken referans-tip nedir, değer-tip nedir sorusuna da cevap arayalım. C#’ta yapılar değer-tiptirler. Sınıflar ise referans-tip. Bunun ne anlama geldğini anlamak için, biraz açalım.
Aslında bir çok değer tipi daha önce kullandık. Bütün tamsayı türler .Net Framework içerisindeki yapıların aliaslarıdır. Tamsayı türdeki bir sayının gerçek değeri stack bölgesinde saklanır.
Sınıflar ise referans-tiplerdir. string veri tipi, Syste.String sınıfının bir aliasıdır. Yani bir sınıftır. Sınıf da referans-tiptir. Bir referans tip, heap bölgesinde bir alanı gösteren bir referans olarak stack bölgesinde saklanır.
Yapılar değer-tiptirler. Sınıflar referans-tiptirler. Bir yöntemin aşağıdaki tanımlamayı içerdiğini düşünün şimdi.
string Ad;
Yöntem çalışmaya başladığında, stack bölgesinden 4 byte’lık yer ayrılır. Bu yerde, heap bölgesinden bir alana referans barındırılabilir. Ama Ad değişkenine bir değer ataması yapılmadığı müddetçe heap bölgesinden bir alan tahsisi yapılmaz.
Şimdi bir değer atayalım.
Ad = "Ali";
Heap bölgesinde string ifade sığacak kadar yer ayrıldı ve artık stack bölgesindeki yerimiz heap bölgesinde string ifadeyi barındıran alanın adresini tutuyor, yani o bölgeye referans tutuyor.
Bir string değişkene aşağıdaki gibi hiçbir şey atamak istemezsek ne olur, inceleyelim.
Ad = " ";
Şu anda hiçbir karakter içermiyor ama bir atama işlemi söz konusu olduğu için heap bölgesinden yer tahsisi yapılır.
Ad.Length ifadesinin değerini ekrana yazdırırsak 0 göreceksiniz. bu da heap bölgesinde yer içeriği boş olan bir yer ayrıldığını gösteriyor.
Çöp Toplama (Garbage Collection)

Bir string türü değişkenin değerini değiştirip heap bölgesinde bir yere referans içermemesini sağlayabiliriz. Bunu da
Ad = null;
atamasıya yaparız. Biz bunu yaptığımız zaman ya da
Ad = "Veli";
gibi başka bir değer ataması yaptığımız zaman, ilk atadığımız “Ali” ifadesi hala heap bölgesinde mevcuttur ama hiçbir referans onu göstermediği için ulaşılamaz haldedir. Bu şekilde artık kullanımı biten verileri heap bölgesinden temizleyen ve o bölgeleri kullanılabilir hale getiren çok güzel bir yapı barındırır C# ve CLR (Ortak Dil Çalışma Zamanı) : Çöp toplama (Garbage Collection). Programcı işi biten bölgeleri temizleme derdinden kurtulmuştur. Çöp Toplayıcı bunu programcının yerine yapar.
Heap bölgesinde hiçbir yere referans içermeyen yani null bir string değişkenin uzunluğunu bulmak için
Ad.Length
ifadesinin değerini öğrenmeye çalışırsak aşağıdaki istisna oluşur.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.

Yukarıda anlatıldığı gibi, null string ile boş bir string aynı gibi görünse de aynı değildir. Bir string null’a eşitse, stack bölgesinde saklanan değer 0’a eşittir ve heap bölgesinde hiçbir yere referans içermez. Eğer bir string, boş bir string’e eşitse stack bölgesinde saklanan değer heap bölgesinde bir bölgeye referans ifade eder. Heap bölgesinde de uzunluğu 0 olan bir string için yer ayırma işlemi yapılmıştır.
 
Alıntı ile Cevapla

Alt 16 Mart 2009, 23:05   #14
Dilara
Guest
Kullanıcıların profil bilgileri misafirlere kapatılmıştır.
IF Ticaret Yüzdesi:(%)
Cevap: C# Hakkında Herşey.



C# String Dönüşümleri
String Dönüşümleri


STRING DÖNÜŞÜMLERİ

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.
 
Alıntı ile Cevapla

Alt 16 Mart 2009, 23:05   #15
Dilara
Guest
Kullanıcıların profil bilgileri misafirlere kapatılmıştır.
IF Ticaret Yüzdesi:(%)
Cevap: C# Hakkında Herşey.



C# Konsoldan Veri Girmek
Konsoldan Veri Girmek

11 Mayıs 2007
KONSOLDAN VERİ GİRMEK

Programlar çoğu zaman bizim girdiğimiz verilere göre işlemlerini yürütürler. Daha önce, görsel programlarda fare hareketleri ile, butonlara tıklamalarla veya yazı kutularına klavyeden bir şeyler yazarak veri girişi yaptık. Veri girişlerinin klavye veya fare ile yapıldığını bu nedenle biliyoruz zaten.
C# konsol uygulamalarında veri girişi daima klavyeden yazı yazma ile gerçekleşir. Genellikle konsol uygulamalarında program kullanıcıdan bir şeyler girmesini ister ve kullanıcının verdiği yanıta göre kullanıcının ne demek istediğini anlamaya çalışır.
İşte bizim konsolda klavyeden giriş yapmamızı sağlayan Console sınıfının Read ve ReadLine yöntemleridir. Console.WriteLine ve Console.Write yöntemlerini kullanırken giriş argümanlarını yazmamız gerekiyordu. Ve bu yöntemlerden dönen bir argüman yoktu. Console.Read ve Console.ReadLine yöntemlerinde ise giriş argümanı yok ama bu yöntemlerden dönen dönüş argümanları mevcut. Biz bu iki yöntemi içeren bir program yazdığımızda ve bu yöntemleri çağırdığımızda kontrol biz Enter tuşuna basana kadar programa tekrar geçmeyecektir. Buradan da bu iki yöntemin ve dolayısı ile programın çalışmaya devam edebilmesi için bu yöntemlerin çağrıları yapıldıktan sonra Enter tuşuna basmamız gerektiğini anlıyoruz. Bu arada Console.ReadLine yönteminin bu iki yöntem içinde kullanımı kolay olan yöntem olduğunu söyleyebiliriz. Şimdi konsoldan string girişi yapan ilk programı yazalım.
1
string yazi;
2
yazi = Console.ReadLine();
Yukarıda görüldüğü gibi 1. satırda string tipinde bir değişken tanımlandı ve ikinci satırda Console.ReadLine() yöntemi çağrılarak yazı adlı stirng değişkene bu yöntemden dönen ( kullanıcının konsol ekranında yazdıkları ) değerler atandı. Burada dikkati çeken bir noktada Console.ReadLine yönteminden dönen değerin string bir değişken herhangi bir işleme tabi tutulmadan direkt olarak atanabildiğidir.
Burada iki satırda yaptığımız işlemi tek satırda da gerçekleştirebilmemizin mümkün olduğunu biliyoruz.
1
string yazi = Console.ReadLine();
Şimdi kullanıcıdan bir şeyler alan bir program yazalım.
1
using System;
2
class KonsoldanVeriGirisi
3
{
4
static void Main()
5
{
6
Console.Write("Bir şeyler yaz ve Enter tuşuna bas:");
7
string yazi = Console.ReadLine();
8
Console.WriteLine("Klavyeden yazdığınız yazı:" + yazi );
9
}
10
}
Yukarıdaki programda kullanıcıdan bir şeyler yazmasını istedik ve bu yazdıklarını bir string değişkene Console.ReadLine yöntemi ile atayarak daha sonra bu değişkeni Console.WriteLine yöntemi ile konsolda görüntüledik. Burada dikkat edilirse ilk satırda Write yöntemi kullanıldı çünkü kullanıcının yazdıklarının bizim Console.Write yöntemi ile konsola yazdırdığımız yazıların yanına yazılmasını istedik. Kullanıcı bir şeyler yazıp Enter tuşuna bastığında Console.ReadLine yöntemi imlecin aşağı satıra düşmesini sağlıyor. Tam bu sırada Console.ReadLine yöntemi değer döndürme işlemini gerçekleştiriyor.
Console.WriteLine ve Console.Write yöntemleri bir integer değişkeni kapalı bir şekilde string tipine dönüştürerek konsola yazdırıyordu. Ama Console.ReadLine yönteminin böyle bir özelliği mevcut değil. Yani biz klavyeden bir integer okumak istediğimizde bunu Int32.Parse yöntemini kullanarak integer tipine çevirmemiz gerkiyor.
1
using System;
2
class KonsoldanVeriGirisi
3
{
4
static void Main()
5
{
6
string S;
7
int I;
8
Console.Write("Bir sayı yaz ve Enter tuşuna bas:");
9
S = Console.ReadLine();
10
I = Int32.Parse( S );
11
Console.WriteLine(“Girdiğin numara:” + I );
12
}
13
}
Yukarıdaki programda iki durumdan söz edebiliriz. Birincisi; Console.ReadLine yönteminden dönen değerin bir string olması ve string değişkene doğrudan atanabilmesi. İkincisi ise; bu string değişkenin Int32.Parse yöntemi ile integer bir değişkene aktarılması.
Ayrıca buradaki S string değişkenini Console.ReadLine ve Int32.Parse yöntemlerini birleştirerek ortadan kaldırabiliriz.
1
I = Int32.Parse(Console.ReadLine());
Bu satırda ilk olarak Console.ReadLine yöntemi çağrılıyor ve konsoldan girilen yazıları okuyor. Daha sonra okuduğu değerleri Int32.Parse yöntemine aktarıyor.
Şimdi kullanıcıdan sayı almayı bildiğimize göre gerçek hayata yakın bir program yazabiliriz.
1
using System;
2
class Bilet
3
{
4
static void Main()
5
{
6
int YetiskinUcreti = 10 , CocukUcreti =7 ;
7
8
Console.Write("Yetişkin bilet adedini giriniz:");
9
int YetiskinBiletSayisi = Int32.Parse(Console.ReadLine());
10
11
Console.Write("Cocuk bilet adedini giriniz:");
12
int CocukBiletSayisi = Int32.Parse(Console.ReadLine());
13
14
int ToplamMaliyet = YetiskinUcreti * YetiskinBiletSayisi + CocukUcreti*CocukBiletSayisi;
15
16
Console.WriteLine("Toplam bilet ücreti=" + ToplamMaliyet);
17
}
18
}
Program kullanıcıdan yetişkin ve çocuk bilet adedini alıyor. Daha sonra, önceden bildiği bilet ücretleri ile adetleri çarpıp toplam ücreti bize söylüyor.
Konsoldan veri girişi yapmak konsol çıktısı almaktan daha zordur. Veri girişlerinde kontrol her zaman zordur. Kullanıcı konsoldan istediğimiz şartlara uymayan veriler de girebilir.
Mesela program aşağıdaki konsol çıktısını verir.
1–100 arasında bir sayı giriniz:
Ve kullanıcı aşağıdaki ifadeyi girer.
10A
Burada yanlış yazılma ihtimali var. Ama başka programlarda olduğu gibi yanlış yazıları düzelten bir durum söz konusu değil. Bazı programlar bu tür yanlışlar için doğrulama ve kontrol etme işlemleri gerçekleştirirler. Mesela yanlış yazılan “A” harfini ekrana yazmamak veya bir beep sesi ile uyarmak gibi. Ama maalesef. Net konsolu bu tür tekniklere izin vermez. Konsol kullanıcının satır boyunca yazmasını ve Enter tuşuna basmasını bekler ve kullanıcının yazdığını işlemeye başlar. Eğer uygun giriş yapılmamışsa sonuç elde edilemez. Ama kullanıcıdan tekrar giriş yapması istenebilir.
Kullanıcı girişlerini kontrol eden ve oluşan istisnaları anlaşılır bir şekilde kullanıcıya gösteren kontrol yapıları daha sonraki yazılarda bahsedilecek.
 
Alıntı ile Cevapla

Alt 16 Mart 2009, 23:06   #16
Dilara
Guest
Kullanıcıların profil bilgileri misafirlere kapatılmıştır.
IF Ticaret Yüzdesi:(%)
Cevap: C# Hakkında Herşey.



C# Sabitler
Sabitler


Ş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;

classSinemaBileti
{
staticvoid 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;

classSinemaBileti
{
staticvoid 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.
constint TamBilet = 10;
constint 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.
constint 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.
constint TamBilet = 10;
constint 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.
constint 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.
constint 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â,
conststring 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.
conststring 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.
 
Alıntı ile Cevapla

Alt 16 Mart 2009, 23:07   #17
Dilara
Guest
Kullanıcıların profil bilgileri misafirlere kapatılmıştır.
IF Ticaret Yüzdesi:(%)
Cevap: C# Hakkında Herşey.



C# Decimal Veri Tipi
Decimal Veri Tipi

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.
 
Alıntı ile Cevapla

Alt 16 Mart 2009, 23:08   #18
Dilara
Guest
Kullanıcıların profil bilgileri misafirlere kapatılmıştır.
IF Ticaret Yüzdesi:(%)
Cevap: C# Hakkında Herşey.



C# Kayar Nokta Veri Türleri
Kayar Nokta Veri Türleri

Bilimsel ve mühendislik uygulamalarda, genellikle çok küçük ve çok büyük sayılarla çalışmak ve daha fazla esnek olmak istersiniz. C#taki decimal veri türü sadece ondalık kısmın sağında ve solunda 28 basamağa kadar izin verir. Bu sınırlamalardan dolayı esnek değildir. Mesela güneşin ağırlığı yaklaşık 2*1030 kilogramdır. Elektronun ağırlığı ise yaklaşık 9*10-31 kilogramdır.
Uzun yıllar, bilim adamları 3 ya da 4 hassasiyetli sayılarla işlemlerini kaydırma kuralları ile yaptılar. Günümüzde, kayar nokta veri türlerini kullanarak bilimsel gösterime yakın bir biçimde sayıları gösterip bilimsel hesaplamalarını yapıyorlar. C#ta 2 tane kayar nokta türü vardır, float ve double.
1985 yılında IEEE kayar nokta türleri ile ilgili standartları belirledi. İki tane tür belirlendi. 4 byte gerektirene tek hassasiyet 8 byte gerektirene de çift hassasiyet denildi.
.net Framework içerisinde, bu iki kavramı karşılayan System.Single ve System.Double adında iki tane yapı vardır. Fakat C# double ve float isimlerini C dinliden miras aldı. Aşağıdaki tablo double ve float hakkında bilinmesi gerekenleri özetlemektedir.
C# Türü
.NET Türü
Anlamlı Kısım
Üssel Kısım
float
System.Single
23 bits (7 basamak)
8 bits (-45 to 38)
double
System.Double
52 bits (15–16 basamak)
11 bits (-324 to 308)
Sağ taraftaki iki sütun float türünün 32 bitinin ve double türünün 64 bitinin, anlamlı kısımla üssel kısım arasında nasıl paylaşıldığını göstermektedir. Ek bir bit ise anlamlı kısmın işaretini tutar. Aşağıdaki sayıyı inceleyelim.
8.364 10-24
Anlamlı kısmı 8.364 olan kısmıdır. Float veri türünde 23 bit anlamlı kısım için ayrıldığına göre bu kısım yaklaşık 7 basamağa kadar olabilir. Üssel kısım için ise 8 bit ayrılmıştır.
float ve double veri türlerini gösterirken Macar gösterimi kullanalım. float için f önekini, double için de d önekini kullanalım.
float f;
Tabi ki virgülden sonraki kısmı olmayan bir sayıyı yani bir tamsayıyı da float bir değişkende tutmak mümkündür.
f = 123456789;
Tamsayının kayar nokta türüne dönüşümü sırasında tamsayı hassasiyet kaybına uğrar. Eğer bu sayıyı ekranda görmek istersek aşağıdaki kodu yazıp çıktısını görelim.
float f;
f = 123456789;
Console.WriteLine(f);
Console.ReadLine();


Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Aslında aynı sayıdır. Sayının genliği değişmez ama 7 basamaktan yukarısını float ile gösteremediğimiz için hassasiyet kaybı olur.
float bir değişkene ondalık kısmı olan bir sayı ataması yapılabilir.
f = 45.384f;
Bilimsel gösterimde bir sayıyı da float bir değişkene atayabiliriz.
f = -34.78e-14f;
Yukarıdaki örneklerde de görüldüğü gibi eğer tamsayı değil de ondalık kısmı olan ya da bilimsel gösterimdeki bir sayıyı float bir değişkende tutmak istersek sayının sonuna küçük harfle ya da büyük harfle F yazmak gerekiyor. Ayrıca bilimsel gösterimdeki e harfini de büyük ya da küçük yazmak fark etmez.
Şimdi de bir double değişken tanımlayalım.
double d = 456.374584;
Double bir sayı tanımlarken herhangi bir sonek koymaya gerek yok ama gene de küçük ya da büyük harfle d harfi koyulabilir. Diğer bir ifadeyle ondalık kısmı olan ya da bilimsel gösterime sahip olan sayılar varsayılan olarak double kabul edilir.
Bir çok programcı sadece double kullanır ve float ile ilgilenmez. Çünkü kayar nokta işlemleri işlemcinin matematik işlemler bölümünde özel bir kısımda ele alınır, bu yüzden double yerine float kullanmanın performans üzerinde bir etkisi yoktur. Günümüz uygulamalarında çoğu zaman belleğin verimli kullanımı ihmal edilebilir.
Gerekli durumlarda C# tamsayı türünden bir sayıyı kapalı olarak float ya da double türüne dönüştürebilir. Biraz hassasiyet kaybı olur ama genliğinde bir kayıp söz konusu olmaz. Hatta C# float türünü de aynı şekilde double türüne kapalı olarak dönüştürebilir.
C# kapalı olarak herhangi bir tamsayı türünü float ya da double türüne dönüştürmez. Eğer dönüştürme yapacaksak casting yapmak gerekiyor. Hangi türün hangi türe kapalı olarak dönüştürülebileceği aşağıdaki şekilde görülmektedir.


Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
IEEE kayar nokta türleri (float, double) için standart tanımlarken diğer sayısal veri türlerine göre çok farklı tanımlamıştır. Mesela kayar nokta hesapları yapılırken asla istisna oluşmaz. Aşağıda tam sayılar için sıfıra bölme istisnası oluşturabilecek bir örnek var.
double dPay = 124;
double dPayda = 0;
double dBolum = dPay / dPayda;
Console.WriteLine(dBolum);
Console.ReadLine();
İşlemin sonucunda dBolum adlı değişkene çok özel bir değer dönüyor. Bu özel değerler IEEE tarafından belirlenmiştir. Infinity (sonsuz) değeri de bunlardan biridir.


Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Eğer dPay değişkenini -124 diye değiştirirsek o zaman da –Infinity (- Sonsuz) sonucunu göreceksiniz.
Eğer dPay değerini de 0 olarak değiştirirseniz NaN göreceksiniz. NaN (Not a Number – Sayı Değil) anlamına gelmektedir. Eğer kayar nokta hesabında aşağı taşma ya da yukarı taşma durumu meydana gelirse o zaman da NaN değeri görüntülenecektir.
float ve double yapıları PositiveInfinity, NegativeInfinity, ve NaN olan üç adet alana sahiptir. Bu alanlar açık olarak değer ataması yapabilmek içindir. Mesela, eğer double tanımlanmış 1 sayısını Positive Infinity değerine bölerseniz 0 sonucunu alırsınız ama PositiveInfinity değerini PositiveInfinity değerine bölerseniz 1 yerine NaN sonucunu alırsınız.
Başka bir yazıda bu özel değerlerle nasıl çalışılacağını anlatacağız. Şimdilik kayar nokta veri türleri ile çalışırken bu tür sonuçların görülebileceğini bilsek yeter.
Kayar nokta türlerini, çok büyük ya da çok küçük sayıların bölme ve çarpma gibi işlemlerini yaparken doğal olarak tercih etmeniz gerekiyor. Çünkü bu tür bir işlemde hiçbir zaman taşma meydana gelmeyecektir.
Eğer C# kullanarak bilimsel ya da mühendislik hesaplamalar yapmak isterseniz üssel, logaritmik ve trigonometrik fonksiyonlarla hesaplamalar yapmak isteyeceksiniz. Bütün bunlar System isim uzayındaki Math sınıfının içerisinde statik yöntemler olarak mevcuttur.
Meselâ, üs alma işlemini Pow yöntemini kullanarak yapabilirsiniz.
dSonuc = Math.Pow(dTaban, dUs);
Bu yönteme virgülle ayrılmış 2 tane argüman geçeriz. double olmayan argümanlar kapalı olarak double türüne çevrilir.
double dSonuc = Math.Pow(3, 4);
Console.WriteLine(dSonuc);
Console.ReadLine();


Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Ama decimal veri türü hiçbir türe kapalı olarak çevrilemeyeceğinden ötürü decimal sayıları bu yönteme geçmek için açık dönüşüm yapmak gerekiyor.
Karekök almak için Pow yöntemini ilgili sayının 0.5 kuvvetini almak suretiyle kullanabilirsiniz.
dSonuc = Math.Pow(dSayi, 0.5);
Ya da karekök almak için olan Sqrt yöntemini kullanabilirsiniz.
dSonuc = Math.Sqrt(dSayi);
Şimdi bir dik üçgenin hipotenüsünü hesaplayabileceğimiz küçük bir örnek yazalım. Pisagor teoremine göre dik üçgenin hipotenüs uzunluğu dik kenarlar uzunluklarının kareleri toplamının kareköküne eşittir. Math.Sqrt yöntemine argüman olarak iki tane Math.Pow işleminin sonuçlarının toplamlarını geçeceğiz.
using System;
class Program
{
static void Main()
{
Console.Write("İlk Kenar: ");
double dKenar1 = Double.Parse(Console.ReadLine());
Console.Write("İkinci Kenar: ");
double dKenar2 = Double.Parse(Console.ReadLine());
double dSonuc = Math.Sqrt(Math.Pow(dKenar1, 2) + Math.Pow(dKenar2, 2));
Console.WriteLine("Hipotenüs hesaplandı: {0}", dSonuc);
Console.ReadLine();
}
}


Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Math sınıfının ayrıca iki tane sabit alanı vardır, matematik hesaplarda sık kullanılan iki tane sabit değerli sayı.
pi sayısını Math.PI, e sayısını da Math.E alanları bize verir.
Bazı uygulamalarda kayar nokta vazgeçilmezdir ama her yerde değil. Gereksiz kullanımlarda bir takım sıkıntılar da meydana getirir. Klasik BASIC programlama dili bütün sayısal verileri kayar nokta şekilde tutar. Daha sonraki programla dilleri her sayı türü için ayrı değişken türü tanımlamaya olanak tanısa da programcılar çoğunlukla kayar nokta türleri tercih ederler. Çünkü alt taşma yok, üst taşma yok, daha kolay gelir.
Kayar nokta türlerle uzun süre haşır neşir olmuş programcılar sıkıntılarını da iyi bilirler. Mesela 23.5 gibi bir sayı 23.50001 ya da 23.49999 olarak saklanmış olabiliyor. İkincisi büyük bir problemdir. Çünkü en yakın tamsayıya yuvarlamak istersek 23.49999 sayısı 23 sayısına 24 sayısından daha yakındır.
Yeni programlama dillerinde kayar nokta türler çok fazla problem olmuyor. Sürekli birileri daha sağlıklı hesaplamalar yapmaya izin verecek çalışmalar yapıyor. Ama hala sıkıntılar var. Aşağıdaki örneği inceleyelim.
Console.WriteLine(9.666e-7f);


Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Gördüğünüz gibi WriteLine bize aynı sayıyı göstermedi.
Şimdi de aşağıdaki örneğe bakalım.
using System;
class Program
{
static void Main()
{
float f1 = 1234567;
float f2 = 0.1234567f;
float f3 = f1 + f2;
Console.WriteLine(f3);
Console.ReadLine();
}
}


Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
float veri türü sadece 7 basamak gösterebiliyor, işlemin sonucunu da görüyorsunuz. f2 değişkeninin değeri kayıp. Eğer 7 basamaktan daha büyük sayılar gösterecekseniz double ver türünü kullanabilirsiniz. Ama double veri türünün de 16 basamaktan fazlasını tutamayacağını bilmeniz gerekiyor.
Çok az denk gelse de IEEE standardı bizim istediğimiz sayıyı tutmaya yetmiyor. Bu genellikle anlamlı kısmın hassasiyetinden kaynaklanıyor. 16,777.216 ile 16,777.217 float sayıları arasındaki fark ihmal ediliyor. Çok küçük ve çok büyük sayılarda yakınsama söz konusudur. Meselâ, 12.34 sayısı float olarak saklandığı zaman 12,939,428 tamsayısının 220 ile bölümü olarak saklanır. Bu sayı yaklaşık olarak 12.34 ediyor. Eğer double olarak saklanırsa 6,946,802,425,218,990 tamsayısının 249 ile bölümü olarak saklanır. Bu sayı 12.34 sayısına çok çok yakındır, ama aynısı değildir.
Aynı sayıyı decimal olarak saklarsak 1234 sayısının 102 ile bölümü olarak saklanır. Bu sayı tam olarak 12.34 eder. Bu durum decimal veri türünün ne kadar güçlü olduğunu gösteriyor. Bunun yanında şu gerçeği de göz önünde bulundurmak gerekiyor, kayar nokta türler bilimsel ve mühendislik hesaplarda kullanılsın diye var. Bilimsel ve mühendislik hesaplarda da her zaman yakınsama ve yuvarlama söz konusudur. Kesinlik gerektiren ama ondalık kısmı olan işlemler için zaten C# decimal diye bir tür içeriyor ve oldukça güçlü.

 
Alıntı ile Cevapla

Alt 16 Mart 2009, 23:08   #19
Dilara
Guest
Kullanıcıların profil bilgileri misafirlere kapatılmıştır.
IF Ticaret Yüzdesi:(%)
Cevap: C# Hakkında Herşey.



C# Yazı Biçimlendirme
Yazı Biçimlendirme


Bildiğiniz gibi C# dilinde decimal tipte bir m değişkeni şu şekilde yazıya dönüştürülür.
using System;
classYaziBicimlendirme
{
staticvoid Main()
{

double d = 23.45;
string s = d.ToString();
Console.WriteLine(s);

}
}

ToString metodunun kullanımı burada göründüğünden biraz fazla esnektir. .net Framework, sayısal türleri yazıya dönüştürürken istediğimiz biçimde biçimlendirip gösterme imkânı sunar. Meselâ:
using System;
classYaziBicimlendirme
{
staticvoid Main()
{

double d = 23.45;
//string s = d.ToString();
string s = d.ToString("G");
Console.WriteLine(s);

}
}

Buradaki G’nin anlamı (General) Genel formatlamadır. Varsayılan değer zaten G olduğu için yazmayabilirsiniz. Bu durumda yukarıdaki her iki örneğin de yapığı iş aynıdır. Farklı bir formatlama için tablodaki harfleri kullanabilirsiniz. Tablodaki harfleri büyük ya da küçük harfle yazmak fark etmiyor.
Harf
Anlamı
Açıklama
C
Currency
Para birimleri ile birlikte kullanılır. Üçer basamak ayırır.
D
Decimal
Sadece integer değerler için.
E
Exponential
Bilimsel gösterim için kullanılır.
F
Fixed Point
Sayının bilimsel olmayan gösterimde gösterilmesini sağlar.
G
General
Üstel ve noktalı değerlerin çok küçük olduğu yerlerde.
N
Number
F ile aynıdır. Üçer basamak ayırır.
P
Percent
Yüzde ifadeleri için kullanılır. Sayı 100’e bölünür, üçer basamak ayırır ve % işareti gösterilir.
R
Roundtrip
Kayar nokta türler için kullanılır. Parse yöntemi ile geri dönüştürülebilecek bir string oluşturur.
X
Hexadecimal
Tamsayı değerleri hexadecimal olarak gösterir.
Burada dokuz tane formatlama biçimi var. Bir tanesi için örnek verelim. m 0,123 değerini tutuyorsa aşağıdaki programın çıktısı %12,30 olacaktır.
using System;
classYaziBicimlendirme
{
staticvoid Main()
{

double d = 0.123;
string s = d.ToString("P");
Console.WriteLine(s);

}
}

C formatlama özelliği para sembolü göstermek için kullanılır. Bu sembol mutlaka dolar işareti olmak zorunda değildir. Bölge ve dil seçeneklerine göre değişir. Ama biz özellikle bir para birimin göstermek istiyorsak, meselâ dolar işareti göstermek istiyorsak aşağıdaki gibi yazmalıyız.
m.ToString (“N”) + “$”
İsterseniz harften sonra rakamda kullanabilirsiniz. Meselâ;
m.ToString (“P5”)
Buradaki rakamın anlamı yanındaki harfe göre değişiklik gösterebilir. Aşağıdaki tabloda ToString metodu ile sayıların nasıl kullanıldığı gösteriliyor.
Harf
Anlamı
Yazılacak Sayının Sonuca Etkisi
C
Currency
Virgülden sonra gösterilecek basamak sayısı (Varsayılan değer 2)
D
Decimal
Gösterilecek basamak sayısı (Eğer eksik olursa başına 0 eklenir.)
E
Exponential
Virgülden sonra gösterilecek basamak sayısı (Varsayılan değer 6)
F
Fixed Point
Virgülden sonra gösterilecek basamak sayısı (Varsayılan değer 2)
G
General
Gösterilecek basamak sayısı.
N
Number
Virgülden sonra gösterilecek basamak sayısı (Varsayılan değer 2)
P
Percent
Virgülden sonra gösterilecek basamak sayısı (Varsayılan değer 2)
R
Roundtrip
Kullanılmaz
X
Hexadecimal
Gösterilecek basamak sayısı (Eğer eksik olursa başına 0 eklenir)
Bir örnekle decimal tipteki bir değişkenin bütün formatlama çeşitlerini inceleyelim.
using System;

classNumerikFormatlama
{
staticvoid Main()
{
decimal m = 12345.345m;

Console.WriteLine("Para formatında: " + m.ToString("C2"));
Console.WriteLine("Üstel formatta: " + m.ToString("E2"));
Console.WriteLine("Sabit noktalı formatta: " + m.ToString("F2"));
Console.WriteLine("Genel formatta: " + m.ToString("G2"));
Console.WriteLine("Sayı formatında: " + m.ToString("N2"));
Console.WriteLine("Yüzde formatında: " + m.ToString("P2"));
}
}

ToString yöntemi bölge ve dil seçeneklerine göre farklı sonuçlar verebilen esnek parametrelere sahiptir. Programınız hiçbir değişiklik yapmadan seçili bölge ve dil seçenekleri doğrultusunda uygun sonuçlar üretebilmektedir. Türkiye için seçili ayarlar doğrultusunda programın sonucu aşağıdaki gibi olacaktır.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Yukarıda görülen ekran çıktısı incelenirse yuvarlama işlemleri var. Ama bu yuvarlama işlemleri Round yönteminin kurallarından daha farklı yapılmıştır. İki sayı arasındaki bir değer yuvarlanacaksa yukarı yuvarlanmıştır. 12345.345 sayısı 12345.34 olarak yuvarlanması gerekirken yukarı yuvarlanmış ve 12345.35 olarak yuvarlanmıştır. Eğer bu sizin işinizi görmüyorsa ToString işleminden önce Round ile yuvarlayınız.
Aşağıdaki örnekte 12345 tamsayısı sayısı hexadecimal sayıya dönüştürülmektedir.
using System;

classNumerikFormatlama
{
staticvoid Main()
{
int i = 12345;
string s = i.ToString("X8");
Console.WriteLine(s);
}
}

Burada 00003039 sayısı üretilir ve kısaltma sözkonusu değildir, 8 basamağa tamamlamak için başına dört tane 0 eklenmiştir. Ama aşağıdaki örnekte virgülden sonrası için 2 basamak belirtildiği için duyarlılık kaybı olacaktır.
using System;

classNumerikFormatlama
{
staticvoid Main()
{
int i = 12345;
string s = i.ToString("E2");
Console.WriteLine(s);
}
}

Ekranda Console.WriteLine ile birden çok sayı gösterecekseniz bu durumda string birleştirme işleminden yararlanabilirsiniz. String birleştirme işlemini string veri türü yazısında daha önce örneklerle görmüştük.
using System;
classNumerikFormatlama
{
staticvoid Main()
{
int A = 3, B = 4;
Console.WriteLine(A + " ve " + B + " sayıları toplamı "
 + (A + B) + " eder.");
}
}

Yukarıdaki örnekte gördüğünüz gibi karmaşık bir yazı şekli oldu. Bunun daha güzel bir şekli vardır. Bu da yer belirtme yöntemidir.
using System;
classNumerikFormatlama
{
staticvoid Main()
{
int A = 3, B = 4;
Console.WriteLine("{0} ve {1} sayıları toplamı {2} eder",
A, B, A + B);
}
}

Yukarıdaki örnekte WriteLine yöntemi dört tane parametre almıştır. İlk parametre ekranda gösterilecek olan string ifadedir. Bu string ifade içersinde yer tutucular var ve dizilerde olduğu gibi 0 ile başlamıştır, küme parantezleri arasında belirtilmiştir. Bu yer tutucular gösterilecek olan string ifadeyi takip eden virgülle ayrılmış diğer üç tane parametre için yer belirtmektedir. {0} ile belirtilen yere A değişkeninin değeri, {1} ile belirtilen yere B değişkeninin değeri, {2} ile belirtilen yere de A+B işleminin sonucu gelecektir. İlk parametreden sonra belirtilecek parametreler sayısal ifadeler olabileceği gibi string ifadeler, string literaller de olabilir.
Eğer yazının içerisinde küme parantezi geçecekse bunu ardı ardına iki tane kullanarak yapmalıyız.
Bu yer tutucuları yazı içerisinde sıra ile yazmak zorunda değiliz. Nerede bulunmaları gerekiyorsa oraya koyabiliriz. Aşağıdaki örnekte yer tutucular {0} {1} {2} sırasıyla yazılmamıştır.
using System;
classNumerikFormatlama
{
staticvoid Main()
{
int A = 3, B = 4;
Console.WriteLine("{2} değeri {0} ve {1} sayılarının toplamıdır.",
A, B, A + B);
}
}


İlk parametre olan string ifadeden sonra yazacağımız parametre sayısı yer tutuculardan fazla olabilir. Bir parametreyi yazmışsak ve onun için yer tutucu belirtmemişsek problem olmaz.
Aşağıdaki örnekte yazılan C parametresi hiç kullanılmamıştır ama programın çalışması için bir engel teşkil etmez.
using System;
classNumerikFormatlama
{
staticvoid Main()
{
int A = 3, B = 4, C = 20;
Console.WriteLine("{2} değeri {0} ve {1} sayılarının toplamıdır.",
A, B, A + B, C);
}
}

Aşağıdaki örnekte olduğu gibi 4 tane parametre düşünelim. 0, 1 ve 3 numaralı parametreleri kullanacağız ve 2 numaralı parametre hiç kullanılmayacak. Böyle bir kullanım da mümkündür. Kullanılmayacak olan parametrenin en son yazılma zorunluluğu da yoktur.
using System;
classNumerikFormatlama
{
staticvoid Main()
{
int A = 3, B = 4, C = 20;
Console.WriteLine("{3} değeri {0} ve {1} sayılarının toplamıdır.",
A, B, C, A + B);
}
}

Bir yer tutucuyu tekrar tekrar kullanmak da mümkündür.
using System;
classNumerikFormatlama
{
staticvoid Main()
{
int A = 3, B = 4, C=20;
Console.WriteLine("{3} değeri {0} ve {1} sayılarının toplamıdır.
 Sonu\u231 ? {3} değeridir.",
A, B, C, A + B);
}
}

Ama olmayan bir parametre için yer tutucu yazmak doğaldır ki yanlıştır ve bir istisna ortaya çıkacaktır.
using System;
classNumerikFormatlama
{
staticvoid Main()
{
int A = 3, B = 4, C = 20;
Console.WriteLine("{0} ve {1} sayıları toplamı {3} eder",
A, B, A + B);
}
}


Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Yukarıda string birleştirme işlemi ile yazdığımız örneği bir defa daha yazalım ama açık ToString yöntem çağruları ile biçimlendirme de yapalım.
using System;
classNumerikFormatlama
{
staticvoid Main()
{
int A = 3, B = 4;
Console.WriteLine(A.ToString("E4") + " ve " +
B.ToString("E4") + " sayıları toplamı "
 + (A + B).ToString("E4") + " eder.");
}
}

Karmaşık oldu, yer tutucular kullanarak yazalım.
using System;
classNumerikFormatlama
{
staticvoid Main()
{
int A = 3, B = 4;
Console.WriteLine("{0} ve {1} sayıları toplamı {2} eder",
A.ToString("E4"), B.ToString("E4"), (A + B).ToString("E4"));
}
}

Ama gene karmaşık oldu. Daha güzel bir yöntem var. Sayısal biçimlendirme parametrelerini yer tutucularla birlikte yazabiliriz. Açık ToString yöntem çağrılarına da gerek kalmaz.
using System;
classNumerikFormatlama
{
staticvoid Main()
{
int A = 3, B = 4;
Console.WriteLine("{0:E4} ve {1:E4} sayıları toplamı {2:E4} eder",
A, B, A + B);
}
}

Yer tutucu numarası bir iki nokta işareti ve ardından biçimlendirme parametresi geliyor. Bu parametreler normalde ToString yöntemine geçiliyor, ama bu şekilde kullanım çok daha pratik olduğu için daha çok tercih ediliyor.
Çoğu durumda bir ifadenin karakter olarak ne kadar yer kaplayacağını bilmek imkânsızdır, meselâ tamsayılar 10 karaktere kadar, eğer negatif değer alabiliyorlarsa 11 karaktere kadar, üçer basamak ayrılıyorsa 4 karaktere kadar yer kaplayabilirler. Aşağıdaki örnekte sayılar iç içe geçmektedir.
Console.WriteLine("{0}{1}{2}{3}", A, B, C, D);
Bunu kolaylıkla aralarına boşluklar bırakarak ayırabiliriz.
Console.WriteLine("{0} {1} {2} {3}", A, B, C, D);
Alt alta birden çok WriteLine değeri yazdığımızı düşünürseniz belirli yerler kaplayarak sütunlar halinde alt alta yazılmasını isteyebiliriz. Alan genişliği denilen sayılar yazarak ne kadar yer kaplayacaklarını belirtebiliriz, bunu da yer tutucu numaraların yanına virgül koyup akabinde alan genişliği değerini giriyoruz.
using System;
classNumerikFormatlama
{
staticvoid Main()
{
decimal mA = 123.45m;
string strB = "Kitap";
int iC = 12;
decimal mD = 456678m;
Console.WriteLine("{0,10}{1,15}{2,10}{3,20}", mA, strB, iC, mD);
}
}

mA sayısı sağa dayalı olarak 10 karakter, strB değeri yine sağa dayalı olarak 15 karakter, iC değeri yine sağa dayalı olarak 10 karakter, mD değeri yine sağa dayalı olarak 20 karakter yer kullanılarak gösterildi.
Çıktısı da aşağıdaki şekildedir.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Konsolda bir satırda gösterebileceğimiz karakter sınırı da yine IBM punch kartlarındaki sınır olan 80 karakterdir.
Biçimleme parametreleri ile alan genişliği parametrelerini birlikte kullanabilirsiniz.
using System;
classNumerikFormatlama
{
staticvoid Main()
{
decimal mA = 123.45m;
string strB = "Kitap";
int iC = 12;
decimal mD = 456678m;
Console.WriteLine("{0,-15}{1,10:C2}{2,10:X5}{3,20:E3}", strB, mA, iC, mD);
}
}

Yukarıdaki örnekte {0} yer tutucusunun gösterdiği değer dikkat ederseniz alan genişliği olarak -15 değerini almıştır. Bu da 15 karakterlik alanda soldan hizalama yapılacağı anlamına gelmektedir. Hem biçimlendirme hem de alan belirleme parametreleri birlikte kullanıldı.
 
Alıntı ile Cevapla

Alt 16 Mart 2009, 23:09   #20
Dilara
Guest
Kullanıcıların profil bilgileri misafirlere kapatılmıştır.
IF Ticaret Yüzdesi:(%)
Cevap: C# Hakkında Herşey.



C# Yöntemler ve Alanlar - I
Yöntemler ve Alanlar - I


.net Framework içerisinde mevcut olmayan bir yönteme ihtiyaç duyduğumuz zamanlar olur. Kendi ihtiyacımız doğrultusunda özel bir yöntem hazırlamamız gerekir.
Mesela, dik üçgende hipotenüz hesabı yapan bir yöntem .net Framework içerisinde mevcut değildir. Biz pisagor teoremi ile hipotenüsün nasıl hesaplanacağını biliriz. Bunun için bir program yazmamız gerekiyor. Kısa kenarların her birinin kareleri toplamının karekökünü alırsak bu bize hipotenüs uzunluğunu verir.
Karekök hesabı yapabilen ve herhangi bir sayının karesini hesaplayabilen yöntemler System.Math sınıfı içerisinde mevcuttur. Program aşağıdaki şekildedir.
// -----------------------------------------------------------------
// Hipotenus projesinin kaynak kod dosyası Hipotenus.cs
// -----------------------------------------------------------------
using System;
class Hipotenus
{
static void Main()
{
Console.Write("Birinci kenarı giriniz: ");
double dKenar1 = Double.Parse(Console.ReadLine());
Console.Write("İkinci kenarı giriniz: ");
double dKenar2 = Double.Parse(Console.ReadLine());
double dSonuc = Math.Sqrt(Math.Pow(dKenar1, 2) + Math.Pow(dKenar2, 2));
Console.WriteLine("Hipotenüs: {0}", dSonuc);
Console.ReadLine();
}
}

Eğer programımız birkaç tane hipotenüs hesabı yapacaksa kopyala yapıştır işlemleriyle bu ifadeyi çoğaltabiliriz. Ama bu etkin bir yol değildir. Üçgenin hipotenüsünü bulurken kısa kenarlar yerine taban ve yükseklik bilgilerini kullanmamız gerekirse hesap yapan ifadelerin tamamını değiştirmek gerekir. Bu çözüm hiç de esnek bir çözüm olmaz. Bir de ileride daha etkin bir hesaplama yolu bulduğumuzu düşünürsek o zaman kopyala yapıştır yaparak çoğalttığımız hesaplama satırları içinden çıkılmaz bir hal alır.
Aslında Hipotenus.cs programını daha etkin bir şekilde yapmak da mümkündür. Mesela
Math.Pow(dKenar1, 2)

şeklinde Math sınıfının Pow yöntemini kullanmak yerine
dKenar * dKenar

yazarsak daha az bellek ve işlemci gücü kullanmış oluruz.
Dışarıdan baktığımızda bu iki hesaplama şekli aynı gibi görünüyor. Ama Math sınıfı ve onun double türündeki her sayının istenilen kuvvetini alabilen Pow yöntemine göre çarpma işlemi yapmak daha az işlemci ve bellek kullanımı sağlayarak daha etkin bir yol sunar. Pow yönteminde genelleştirilmiş bir kuvvet alma algoritması kullanılmaktadır, oysa çarpma işlemi çok basittir ve kullanacağı bellek bölgesi çok küçüktür.
Program kodu yazmaktan zevk alan bir programcı iseniz bile kopyala yapıştır yapmak yerine daha az kod kullanarak aynı işi yapmanın yolunu aramanız gerekiyor. Genellikle daha az kod daha az hata demektir.
Defalarca hipotenüs hesabı yapacaksanız, bunu özel bir yöntem yazarak yapmak güzel bir yoldur.
Yöntem

Yöntem, küçük bir algoritmik mekanizmadır, işlenmemiş materyalleri içine gönderip ürün olarak geriye aldığımız bir fabrika gibi düşünebilirsiniz. Eğer bir yöntem yeteri kadar iyi tasarlanmış ve programlanmışsa, yöntemi kapalı bir kutu olarak görebiliriz. Yöntem doğru sonuçlar ürettiği ve anlamsız hatalar vermediği sürece hiç kimse nasıl tasarlandığı ve içerisindeki mekanizmanın nasıl işlediği ile ilgilenmez.
Bir yöntem oluşturulurken izlenecek iki önemli aşama vardır. Bu aşamalardan en önemlisi yöntemin algoritmasını tasarlamak ve yapacağı işi gerçekleştirmektir ama daha önce karar verilmesi gereken diğer aşama ise yöntemin ara yüzüdür. Yöntemin ara yüzünü tasarlama işlemi, yöntemin içine neler gireceğini ve sonuçta dışarıya ne çıkacağını tanımlama işlemidir.
Daha önce incelediğimiz yöntemlerde dikkat etti iseniz bir yönteme birden çok argüman girer ama geriye sadece bir tek şey döner, o da yöntemin dönen değeri olarak adlandırılır.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Bir yöntemin birden çok parametresi olabilir, hiç parametresi olmayan yöntem de olabilir. Ama muhakkak bir değer dönmesi gerekir. Eğer hiç değer dönmeyecekse, dönen değer olarak hiç değer dönmeyecek anlamına gelen void yazılır.
Hipotenus yöntemi için giren ve çıkan değerler oldukça basittir. Yöntem üçgenin iki kenarını parametre olarak alacak ve yöntemden geriye hipotenus değeri dönecektir.
Math.Pow yöntemini aşağıdaki gibi çağırabiliriz.
double dSonuc = System.Math.Pow(dTaban, dUs);

>
Eğer using direktifiyle System isim uzayı programa dahil edilmişse, Pow yöntemini aşağıdaki şekilde çağırabiliriz.
double
 dSonuc = Math.Pow(dTaban, dUs);
Kendi yazdığımız Hipotenus yöntemini de aşağıdaki şekilde çağırırız.
double dHipotenus = Hipotenus(dKenar1, dKenar2);

Birden çok yönteme sahip olan, belki de birkaç tane ayrı sınıftan oluşan bir program yazdığımızı varsayalım. Hipotenus yöntemini birçok farklı yere yerleştirebiliriz. Şimdi bunlara farklı sürümler diyelim. Yöntemimizin ilk sürümü Main yöntemi ile aynı sınıfın içinde olacak ve ayrı bir sınıf ile isim uzayına ihtiyaç duymayacaktır.
Aşağıda tipik bir sınıf tanımlaması var.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
class BenimSinif
{
static void Main()
{
// Main isimli yöntemin gövdesi
}
}

Eğer bu sınıfın içine başka bir yöntem eklemek istiyorsak sınıfı başlatan ve bitiren küme parantezlerinin arasına eklemeliyiz, Main yöntemini başlatan ve bitiren küme parantezlerinin arasına değil. Yeni yöntemin eklenebileceği yer olarak iki seçeneğimiz var. Bu seçenekler aşağıda gösterilmiştir.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
class BenimSinif
{
// Yeni yöntem buraya eklenebilir
static void Main()
{
// Main isimli yöntemin gövdesi
}
// Yeni yöntem buraya eklenebilir
}

Bir yöntem, sınıf ile aynı isme sahip olamaz. (Aslında olabilir. Ama o zaman özel bir yöntem türü olur. Bu özel yöntemi başka bir yazıda anlatacağız.)
C#, yeni yöntemin Main yönteminden önce ya da sonra tanımlanmasıyla ilgilenmez. Ama Main yöntemini en başta ya da en sonda yazmış olmamız bizim programlamaya yaklaşımımızı ortaya koyar.
Bazı programcılar önce daha temel işlemleri yapan yöntemleri yazarlar. Daha sonra onlarla bağlantılı olan diğerlerini ve en sonunda hepsini kullanacak olan Main yöntemini. Buna tabandan tavana programlama ya da tümevaran programlama diyebilirsiniz. Bu yöntem daha çok pascal programlama dili ile ilişkilidir. Çünkü pascal dilinde bir yöntem ya da fonksiyon tanımlanmadan kullanılamaz, doğal olarak da en son ana program vardır.
Bazı programcılar ise önce Main yöntemini yazarlar ve daha sonra sırasıyla diğerlerini. Buna da tavandan tabana programlama ya da tümdengelen programlama diyebilirsiniz. Bu sanki C geleneğinden gelen dillere daha yakın gibi görünüyor. Biz de bundan sonraki yazacağımız programlarda bu biçimi kullanacağız.
Şimdi Hipotenus yöntemini tanımlayalım. Yöntemi Main yöntemindeki gibi static anahtar kelimesiyle tanımlamaya başlarız.
static

Daha sonra yöntemden geri dönen değerin tipini yazarız. Aşağıdaki örnekte Hipotenus yönteminden geriye double tipinde bir değer döner.
static double

Yönteme bir isim veririz. Yöntem isminden sonra parantez açarız.
static double Hipotenus(

Hipotenus yöntemi de aynı Main yöntemi gibi tanımlandı. Main yönteminden geriye bir değer dönmez, bu yüzden dönüş tipi void olarak tanımlandı. Aynı zamanda Main yönteminde parantezlerin içinde hiçbir şey kullanmayız. Çünkü dışardan aldığı bir değer yok.
Aslında Main yöntemine de dışardan değer gelebilir ama bu çok özel bir durumdur. Bu özel durumu başka bir yazıda anlatacağız. Visual Studio 2005 ile bir konsol projesi oluşturduğumuz zaman otomatik oluşan Main yönteminin parantezleri arasında bir takım değerler yazılı olur. Biz şu anda ilgilenmiyoruz. Bizim şu anda yaptığımız gibi hiçbir şey yazmazsak da olur.
Biz Hipotenus yöntemine iki tane argüman geçmek istiyoruz.
Parametre ve argüman kelimeleri birbirinin yerine kullanılıyor gibi olsalar da aralarında bir nüans var. Bizim açımızdan yönteme gönderdiğimiz değerler argümadır, biz yönteme argüman geçeriz. Yöntem açısından bakıldığında ise bu değerler parametredir, yöntem dışardan parametre alır.
Hipotenus yöntemine geçeceğimiz ilk parametre, d1’dir. Açtığımız parantezin içine ilk olarak bu parametrenin tipini ve adını yazarız.
static double Hipotenus(double d1

Hipotenus yöntemine geçeceğimiz ikinci parametre, d2’dir. Aralarına virgül koyarak ayırırız. Parametrelerimiz bittiğine göre parantezi kapatırız.
static double Hipotenus(double d1, double d2)

Şimdi Main yöntemindeki gibi yöntemin gövde kısmını oluşturmak için bir çift küme parantezi eklememiz gerekiyor.
static double Hipotenus(double d1, double d2)
{
//Yöntemin gövdesi buraya gelecek.
}

Yöntemlerde kullanacağımız değişkenler daha çok kendi içlerinde tanımlanır. Bu sebeple dSonuc olarak adlandırdığımız üçgenin hipotenüs uzunluğunu tutacağımız değişkeni tanımlamak istiyoruz. dSonuc’un hesaplanması dışardan aldığı iki parametre kullanılarak gerçekleştirilir.
static double Hipotenus(double d1, double d2)
{
double dSonuc = Math.Sqrt(d1 * d1 + d2 * d2);
return dSonuc;
//Yöntem gövdesinin kalan kısmı buraya gelecek.
}

dSonuc isminde double türünde bir değişken tanımladık ve yaptığımız işlemin sonucunu bu değişkende tutuyoruz. Bu iki ifadeyi aslında birlikte yazabiliriz. Atama ve ilk değer işlemlerini birlikte yapabilmeyi daha önce atama işlemleri yazısında örneklerle açıklamıştık. Şimdi bu işlemi yapalım.
Bu arada dönen değer kavramını biraz açalım. Yazının başlarında da söz ettiğimiz dönen değer kavramını hatırlayalım. Yöntemi tanımlarken zaten ilk olarak yöntemin dış dünyaya göndereceği dönen değerin tipini tanımlamıştık. Bu dönecek olan değer yöntem içerisinde return anahtar kelimesi ile belirtilir.
return ifadesi aynı zamanda yöntemin çalışmasını sona erdirir. Bu yüzden return kelimesini yöntemin son ifadesi olarak kullanırız. Bununla beraber daha karmaşık durumlarda yöntem çoklu return ifadesine sahip olabilir.
Aşağıda Hipotenus yönteminin tamamı ve Main yöntemi içinde kullanılmış şekli gösterilmiştir.
// -----------------------------------------------------------------
// HipotenusHesaplama projesinin kaynak kod dosyası HipotenusHesaplama.cs
// -----------------------------------------------------------------
using System;
class HipotenusHesaplama
{
static void Main()
{
Console.Write("Birinci kenarı giriniz: ");
double dKenar1 = Double.Parse(Console.ReadLine());
Console.Write("İkinci kenarı giriniz: ");
double dKenar2 = Double.Parse(Console.ReadLine());
double dHipotenus = Hipotenus(dKenar1, dKenar2);
Console.WriteLine("Hipotenüs uzunluğu " + dHipotenus);
Console.ReadLine();
}
static double Hipotenus(double d1, double d2)
{
double dSonuc = Math.Sqrt(d1 * d1 + d2 * d2);
return dSonuc;
}
}

Sınıf bildirimine, iki ayrı yöntemin tanımlanmasına ve programın yapısında tanımlanan küme parantezlerinin nasıl kullanıldığına dikkat edelim. Her iki yöntem de aynı sınıfın içinde yer alıyor. Bunun için sınıfın başlangıcını ve bitişini belirten küme parantezlerinin arasında bulunuyor. Her ikisi de kendi gövdelerini başlatan ve bitiren küme parantezlerine sahip.
Bir yöntemi kullanırken önce onun ait olduğu isim uzayını ve o isim uzayında yöntemi barındıran sınıfın ismini yazarız. Eğer programın başında isim uzayı deklarasyonu yapılmışsa o zaman sadece sınıf adı ile birlikte yazarız. Bizim Hipotenus ve Main yöntemlerimizde olduğu gibi her ikisi de aynı sınıfın içerisinde ise sadece yöntemin adını kullanarak çağırabiliriz.
Hipotenus, Main ile aynı sınıfın içinde olduğu için, Main içinde sadece yöntemin adını (Hipotenus) kullanılarak kolayca çağırdık.
double dHipotenus = Hipotenus(dKenar1, dKenar2);

İsterseniz Hipotenus isimli yöntemi sınıf ismini kullanarak da çağırabilirsiniz.
double dHipotenus = HipotenusHesabi.Hipotenus(dKenar1, dKenar2);

Şimdi adım adım programın çalışmasını inceleyelim.
dHipotenus değişkeninin değer ataması işlemine kadar her şey normal işler. dHipotenus değişkenine ilk değer ataması yapılırken Hipotenus isimli yöntem çağrılır. Bunu yaparken de Hipotenus yöntemine dKenar1 ve dKenar2 adlı iki argüman geçilir.
Bu noktada, artık programın işleyişi Hipotenus yöntemine geçer. Hipotenus yöntemine dışarıdan gelen dKenar1 ve dKenar2 değişkenlerini d1 ve d2 parametreleri karşılar. Yani dKenar1 ve dKenar2’nin değerleri artık d1 ve d2 parametrelerine aktarılmıştır. Hipotenus yöntemi gerekli işlemi yapar.
return ifadesi Hipotenus yönteminin işleyişini durdurur. Main yöntemine işlemin sonucu return ifadesi vasıtasıyla gönderilir ve programın işleyişi Main yöntemine geçer. dHipotenus değişkeni de Hipotenus yönteminden dönen değeri karşılar, artık işlemin sonucu dHipotenus değişkeninde tutulmaktadır.
Anlatılanları daha iyi kavramak için aşağıdaki şekil yardımcı olacaktır.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
 
Alıntı ile Cevapla

Cevapla
Sayfa 2 Toplam 3 Sayfadan 1 2 3

Etiketler
c#, hakkinda, hakkında, hersey, herşey

« önceki Konu | sonraki Konu »

Konuyu Toplam 1 Üye okuyor. (0 Kayıtlı üye ve 1 Misafir)
 

Yetkileriniz
Konu Acma Yetkiniz Yok
Cevap Yazma Yetkiniz Yok
Eklenti Yükleme Yetkiniz Yok
Mesajınızı Değiştirme Yetkiniz Yok
BB code is Açık
Smileler Açık
[IMG] Kodları Açık
HTML-Kodu Kapalı
Trackbacks are Kapalı
Pingbacks are Açık
Refbacks are Açık

Benzer Konular
Konu Konuyu Başlatan Forum Cevaplar Son Mesaj
Lösemi Hakkında Herşey... Kralice Aile Evlilik ve Çocuklar 2 08 Aralık 2012 14:33
İRC Hakkında herşey!! aLLeN34 mIRC Scripting Sorunları 0 26 Mart 2007 00:40




Sitemiz bir " paylaşım " sitesidir. Bu yüzden sitemize kayıt olan herkes kontrol edilmeksizin mesaj/konu/resim paylaşabilmektedir.
Bu sebepten ötürü, sitemiz üzerinden paylaşılan mesajlar, konular ve resimlerden doğabilecek olan yasal sorumluluklar paylaşan kullanıcıya aittir. IRCForumlari.Net hiçbir yasal sorumluluk kabul etmemektedir. İllegal herhangi bir faaliyet görülmesi durumunda İletişim sayfası üzerinden ulaşıldığı taktirde mesaj, konu ya da resim en fazla 24 saat içerisinde silinecektir.
5846 sayılı Fikir ve Sanat Eserleri Kanunu gereğince sitemizde telif hakkı bulunan mp3,video v.b. eserlerin paylaşımı yasaktır. Yasal işlem olması halinde paylaşan kişi yada kişilerin bilgileri gerekli kuruma verilecektir.
İletişim Arşiv Gizlilik Sözleşmesi Yukarı git
yavru köpek sohbet sohbet teması yetişkin sohbet
Powered by vBulletin® Version 3.8.8 Beta 3
Copyright ©2000 - 2024, vBulletin Solutions, Inc.
Search Engine Friendly URLs by vBSEO
Copyright ©2004 - 2024 IRCForumlari.Net

mimarsinanokullari.com mjsanaokulu.com eburke.org