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

 Kayıt ol  Topluluk
Yeni Konu aç Cevapla
Sayfa 3 Toplam 3 Sayfadan 12 3
 
LinkBack Seçenekler Stil
Alt 16 Mart 2009, 23:10   #21
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 - II
Yöntemler ve Alanlar - II

Kapsam – Görünürlük – Ömür (Scope – Visibility – Lifetime)

Şimdi biraz da değişkenleri inceleyelim.
Bir çok programcı bir yöntemden dönen değeri yöntemin adını çağrıştıracak şekilde isimlendirir. Hipotenus yönteminden dönen değeri dHipotenus isimli değişkende tuttuk, başındaki d de double türünde olduğunu gösterdi. Tabi ki bu bir zorunluluk değildir. Farklı isimler de verilebilir. Hatta Main yöntemindeki Hipotenus yöntemine geçtiğimiz değişkenlerin isimleri Hipotenus yönteminin parametreleri ile aynı olabilir. Çünkü her biri ayrı yöntemler içerisinde tanımlanmışlardır ve görünürlükleri de ait oldukları yöntemle sınırlıdır. .net kütüphanesinde birçok hazır sınıf var ve bu sınıfların birçok yöntemi var. Biz bu yöntemlere argüman geçerken acaba yöntemin içinde bizim gönderdiklerimizle aynı ya da farklı isimlerde değişkenler var mıdır ya da bizim Main içerisinde tanımladığımız değişkenlerle aynı isimde bulunup karışabilecek değişken var mıdır diye hiç düşünmeyiz. Çünkü aynı ya da farklı olması hiçbir karışıklık meydana getirmez.
Yerel değişkenler, yani bir yöntemin içinde tanımlanan değişkenler sadece o yöntemin içinde geçerlidir. Başka bir yöntemin içinden erişilemezler. Örneğin dSonuc değişkenine biz hiçbir zaman Main yöntemi içinden ulaşamayız. Bu duruma yerel değişkenin kapsamı ya da görünürlüğü kendisini içeren yöntemle sınırlıdır deriz. Yöntem aynı zamanda değişkenlerin ömürlerinin ne kadar olacağına da karar verir. Yöntemin çalışması sona erdiğinde, yerel değişkenleri tutan stack bölgesi de serbest bırakılır.
Dikkat ederseniz hipotenüs hesabı yapan programımızda Hipotenus isimli yöntem içinde dSonuc diye bir yerel değişken var. Ama d1 ve d2 için değişken değil de parametre ifadesini kullandık. Parametreler değişken değildirler. Ama yine de kapsamları, görünürlükleri ya da ömürleri yine ait oldukları yöntemle sınırlıdır.
argüman – parametre (argument – parameter)

Argüman ve parametre terimlerini biraz daha açıklayıp aralarındaki nüansı belirtmeye çalışalım. Çoğu zaman birbirinin yerine yanlışlıkla kullanılırlar ve zaten çok yakın anlamlıdırlar. Biz bir yönteme argümanlar geçeriz, yöntem de o gelen argümanların değerlerini kendi parametreleri ile eşleştirir ve yöntemin parametreleri bu değerleri alır.
Yerel değişkenler gibi, parametreler de yöntemin içinde görünürlük sahibidir, dışarıdan erişilemez. En önemlisi de parametrelerle argümanlar aynı isimde olmak zorunda değildirler. Yukarıdaki örnekte de zaten ayrı isimler verdik.
Bir yöntemin tanımlanmasında eğer dönen değer için bir tip yazılmışsa, return ifadesi ile bunu mutlaka yapmalıyız. Main yöntemi return ifadesine ihtiyaç duymaz çünkü döndüreceği bir değer yok. Bunu da yöntem tanımlamasında void yazarak belirttik.
Ama yine de dönüş tipi void olan bir yöntemin içinde return kullanmak istersek yöntem gövdesinde en son satıra
return;

yazarak bunu yapabiliriz. Basitçe söylemek gerekirse return ifadesi yöntemin çalışmasını sonlandırır.
Eğer hata ayıklama yapıyorsak, programın bir bölümünde kesmemiz gerekiyorsa aşağıda kalan kısmı yorum cümleleri haline getirebiliriz ya da istediğimiz yere
return;

yazarak Main yöntemini o şekilde çalıştırabiliriz.
Bu durumda derleyici erişilemeyen bir kısım program kodu var anlamına gelen
Unreachable code detected
uyarısını gösterir. Çünkü return ifadesinden sonraki kod çalıştırılmaz.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Çoğu programcı bir yöntemin döndürdüğü değeri yazarken
return (dSonuc);

şeklinde parantezler kullanır ama bunu kullanma zorunluluğu yoktur. Yukarıda yazdığımız programda dSonuc yerel değişkenini devreden çıkarabiliriz.
// -----------------------------------------------------------------
// HipotenusHesaplama2 projesinin kaynak kod dosyası Program.cs
// -----------------------------------------------------------------
using System;
class HipotenusHesaplama2
{
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)
{
return Math.Sqrt(d1 * d1 + d2 * d2);
}
}

Kapsülleme – Genelleme – İzole Etme (Encapsulate – Generalize – Isolate)

Program yazarken, bazen yazdığımız bir kod öbeğinin başka zaman da kullanılabileceğini düşünürüz. Bu kod öbeğini bir yöntem içerisine alarak kasülleyebiliriz. Daha sonra bu yöntemi genelleyip bir kapalı kutu içerisinde izole edebiliriz. Bu işi yapmamızın sebebi tekrar kullanılabilir kod yazmak ve tekrar tekrar kod yazmaktansa yazılmış olanı kullanmaktır. Ne kadar az kod yazarsak o kadar az hata yaparız.
Başka bir programda Hipotenus hesabı yapan kod öbeğini kullanmak istersek, onu bir yöntem içerisinde izole ettiğimiz için, yöntemi kopyala yapıştır yaparak kolayca başka programda kullanılır hale getirebiliriz.
Tekrar kullanacağımız kod öbeğini bir yöntemin içerisinde izole edip kapsülledik. Test edip hatasız hale getirdik. İyi bir şekilde dokümantasyonunu yapıp içerisinde yapılan işleri kolayca anlaşılır hale getirdik. Daha sonra böyle bir hesap yapan yöntem lazım olduğunda içerisinde işlerin nasıl halledildiğini önemsemeksizin yöntemimizi kopyala yapıştır yaparak diğer programa taşır ve kullanırız.
Ama daha iyi yaklaşımlar da var. Aşağıda adım adım Hipotenus yönteminin diğer programlarda kullanılabilir olması için yapmamız gereken işlemler var. Öncelikle Hipotenus yöntemi için ayrı bir sınıf oluşturacağız daha sonra da her yöntem için ayrı bir kaynak kod dosyası oluşturacağız.
Bir program aşağıdaki genel yapıda olur.
using System;
class BenimSinif
{
// Main ya da diğer yöntemler
}

Bu konuya kadar yapılan çalışmalarda bir program bir tane sınıftan oluştu. Bu sınıf da sadece Main adlı bir tek yöntemden oluştu.
Bir sınıf birden çok yöntemden oluşabileceği gibi bir C# kod dosyası da birden çok sınıf içerebilir. Ayrıca yeni sınıfın diğer sınıfa göre nerede bulunduğu da önemli değildir.
using System;
//Yeni sınıf buraya gelebilir.
class BenimSinif
{
// Main ya da diğer yöntemler
}
//Yeni sınıf buraya da gelebilir

Eğer bir kod dosyası birden çok sınıf barındırıyorsa, Main yöntemine sahip olan temel sınıfı en üste, diğerlerini de sırasıyla onun altına koymayı tercih ediyorum.
Yeni eklediğimiz sınıfla birlikte kod dosyamız şu hale gelecektir.
ing System;
class BenimSınıf
{
// Main ve diğer yöntemler buraya gelir.
}
class YeniSınıf
{
// Sınıfın içindeki yöntemler
}

Şimdi yukarıda bahsedilen şeyleri birleştirip hipotenüs hesabı yapan programı yeniden yazalım.
// -----------------------------------------------------------------
// HipotenusHesaplama3 projesinin kaynak kod dosyası Program.cs
// -----------------------------------------------------------------
using System;
class HipotenusHesaplama3
{
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 = Hesaplamalar.Hipotenus(dKenar1, dKenar2);
Console.WriteLine("Hipotenüs uzunluğu " + dHipotenus);
Console.ReadLine();
}
}
class Hesaplamalar
{
public static double Hipotenus(double d1, double d2)
{
return Math.Sqrt(d1 * d1 + d2 * d2);
}
}

Programın sınıf diyagramı (class diagram) aşağıdaki şekildedir. Diyagram programın anlaşılmasını kolaylaştıracaktır.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Yeni sınıfa Hesaplamalar ismini verdik. İçinde şu anda bir tane yöntem var ama daha sonra gerektikçe başka yöntemler de eklenebilir.
Hipotenus yönteminin diğer sınıf içerisinden de ulaşılabilir olması için başına public anahtar kelimesini ekledik.
public static double Hipotenus(double d1, double d2)

public ve static anahtar kelimelerinin hangisinin diğerinden önce yazıldığı önemli değildir ve bunlara yöntem niteleyicileri (method modifier) denir. Ama yöntemin dönüş tipi olan double muhakkak bu ikisinden sonra yazılmalıdır.
public anahtar kelimesi, erişim niteleyicileri (Access modifier) adı verilen niteleyicilerdendir. Bunlar public, private, protected, internal ve protected internal kelimeleridir. Yeri gelmişken public kelimesinden kısaca bahsedelim ama diğerlerini zaten başka bir yazıda anlatacağız.
Eğer hiç erişim niteleyicisi yazmazsak, varsayılan erişim niteleyicisi private niteleyicisidir, yazmasak da private niteleyicisinin özellikleri geçerli olur. Bu durumda bu niteleyiciye sahip olan yöntem sadece kendisini barındıran sınıfın içinden erişilebilir ama başka bir sınıftan erişilemez. Eğer public niteleyicisi kullanırsak, diğer sınıflar içerisinden de çağrılıp kullanılabilir.
Programımızdaki diğer değişiklik ise Hipotenus yönteminin kullanılmasında oldu. Daha önce kendisini çağıran Main yöntemi aynı sınıfın içinde bulundukları için aşağıdaki şekilde kullanmıştık.
double dHipotenus = Hipotenus(dKenar1, dKenar2);

Ama şimdi farklı sınıfların içinde olduklarından kullanımı aşağıdaki gibi değişti.
double dHipotenus = Hesaplamalar.Hipotenus(dKenar1, dKenar2);

Şimdi diğer static yöntemlerin kullanımına benzedi.
İsim uzayı meselesine de değinelim. .net Framework içerisindeki bütün sınıflar bir isim uzayının içerisinde organize olmuştur. Mesela System isim uzayı çok gerekli olan birçok sınıfı barındırır.
Eğer bir isim uzayı belirtmezsek çalışma esnasında yazdığımız sınıflar geçici bir isim uzayı oluşturularak onun parçası haline gelir. Ama tabiî ki bu sınıfların gerçekte dâhil olduğu bir isim uzayı yoktur.
Visual Studio 2005 ile bir proje oluşturduğumuz zaman, Visual Studio 2005 otomatik olarak proje ismi ile aynı isimde bir isim uzayı kendiliğinden oluşturur. Biz istediğimiz isimle değiştirebiliriz ya da silip isim uzayına dâhil olmayan bir sınıf da yazabiliriz.
Şimdi Hipotenus yöntemini izole etmeye diğer adımla devam edelim. Hesaplamalar sınıfını ayrı bir kod sayfasının içerisine koyalım.
Bir sınıfı kendi dosyasında izole ettiğimiz zaman, bu sınıfa ihtiyacı olan başka programlarda da kullanımı kolaylaşır.
Java programlama dilinde ilginç bir kural var. Her bir sınıf ayrı bir kod dosyasında bulunmak zorundadır ve bu dosyaların isimleri içerisindeki sınıfın ismi ile aynı olmak zorundadır. C#’ta böyle bir zorunluluk yok ama eğer kullanmak isterseniz tabiî ki bu çok güzel bir yoldur.
Şimdi Visual Studio 2005 ile AyriDosyalarlaHesaplama adlı bir Konsol Uygulaması projesi oluşturalım.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Projenin Progam.cs isimli kod sayfası aşağıdaki gibi olsun.
// -----------------------------------------------------------------
// AyriDosyalarlaHesaplama projesinin kaynak kod dosyası Program.cs
// -----------------------------------------------------------------
using System;
class AyriDosyalarlaHesaplama
{
static void Main()
{
Console.Write("İlk kenarı gir: ");
double d1 = Convert.ToDouble(Console.ReadLine());
Console.Write("İkinci kenarı gir: ");
double d2 = Convert.ToDouble(Console.ReadLine());
double dHipotenus = Hesaplamalar.Hipotenus(d1, d2);
Console.WriteLine("Hipotenüs uzunluğu: " + dHipotenus);
Console.ReadLine();
}
}

Bu program daha önce yazdığımız HipotenusHesaplama3 projesinin Main yöntemini içeren HipotenusHesaplama3 isimli sınıfının aynısı. Projeyi bu şekilde derleyemeyiz, çünkü Hesaplamalar isimli sınıfı projeye dâhil etmedik.
Şimdi projemize yeni bir dosya ekleyelim. Solution Explorer (Çözüm Gezgini) penceresinde Proje isminin üzerine sağ tıklayıp oradan Add (Ekle), oradan da New Item (Yeni Öğe) seçelim. Yeni kod dosyasının adını Hesaplamalar.cs olarak belirleyelim ve Add butonuna basalım.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Daha sonra aşağıdaki kodu içine ekleyelim.
// ---------------------------------------------------------------------
// AyriDosyalarlaHesaplama projesinin kaynak kod dosyası Hesaplamalar.cs
// ---------------------------------------------------------------------
using System;
class Hesaplamalar
{
public static double Hipotenus(double dKenar1, double dKenar2)
{
return Math.Sqrt(dKenar1 * dKenar1 + dKenar2 * dKenar2);
}
}

Her iki kod dosyasına da using System direktifini ekledik, çünkü ayrı kod dosyaları oldukarından ve her ikisinde de System isim uzayına ait sınıflar kullandığımızdan her ikisine de eklemek gerekiyor.
Projeye yeni bir kod dosyası eklediğimizde Visual Studio 2005, sık kullanılan isim uzayları için using direktiflerini, projenin adıyla aynı olan isim uzayı tanımlamasını, ve kod dosyası ile aynı isimde bir sınıf tanımlamasını kendiliğinden dahil etti. Biz bunları aynı bırakabildiğimiz gibi, kendi isteğimize göre değiştirebiliriz.
Şimdi projemizi derleyip çalıştırabiliriz.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Şimdi, Hesaplamalar sınıfını kullanan başka bir proje oluşturalım. Projenin Program.cs isimli kod sayfası AyriDosyalarlaHesaplama projesinin Program.cs isimli kod sayfası ile aynı oldu.
// -----------------------------------------------------------------
// BaskaProgram projesinin kaynak kod dosyası Program.cs
// -----------------------------------------------------------------
using System;
class BaskaProgram
{
static void Main()
{
Console.Write("İlk kenarı gir: ");
double d1 = Convert.ToDouble(Console.ReadLine());
Console.Write("İkinci kenarı gir: ");
double d2 = Convert.ToDouble(Console.ReadLine());
double dHipotenus = Hesaplamalar.Hipotenus(d1, d2);
Console.WriteLine("Hipotenüs uzunluğu " + dHipotenus);
}
}

Şimdi projeye Hesaplamalar sınıfını dâhil etmek istiyoruz, ama yeni bir kod sayfası oluşturmak istemiyoruz. Daha önce yazdığımız kod sayfasını kullanmasını istiyoruz. Solution Explorer penceresinde projenin üzerine sağ tıklayın Add -> Existing Item (Varolan Öğe) seçtikten sonra AyriDosyalarlaHesaplama projesinin bulunduğu klasörden Hesaplamalar.cs dosyasını seçiyoruz ama Add (Ekle) butonuna basmadan yanındaki küçük oka basıp Add as Link (Bağ Olarak Ekle) seçeneğini seçiyoruz ve kod dosyamız projeye dâhil oluyor. Ama diğerlerinden farklı olarak dosya simgesinin sol tarafında küçük bir ok beliriyor. Bu simge bağlı öğe olduğunu belirtiyor.

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

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Şimdi Hesaplamalar sınıfını kullanan iki tane programımız oldu. Bu dosya üzerinde bir hatayı düzelttiğimizde ya da yeni yöntemler eklediğimizde sadece 1 tane dosyada değişiklik yapmış oluruz. Ama bu durumda Hesaplamalar sınıfını kullanan bütün projeleri yeniden derlememiz gerekir.
Tabi ki, sadece Add (Ekle) butonuna basmış olsaydık kod sayfasını BaskaProgram projesinin klasörüne taşıyacak ve projeye ekleyecekti. Böyle olunca projedeki diğer kod sayfalarından farkı olmayacak ve projenin kendisine ait bir parçası olacaktı. Bu durumda bir dosyadaki değişiklik diğer projedeki dosyayı etkilemeyecekti.
Aslında başladığımız işlem basamaklarını takip edersek bir adım daha kaldı, Hesaplamalar sınıfını ayrı bir dynamic-link library (Devingen bağlı kütüphane) yani DLL içerisine koymak. Bu durumda Hesaplamalar sınıfımız da .net Framework içerisindeki diğer sınıflar gibi olurdu. DLL içerisine alınmış bir sınıf önceden derlendiği için artık başka bir projeye onun kodunu ekleyemeyiz, yani içindeki kod da başkaları tarafından görülmez. Bu adımdaki işlemlerin nasıl yapılacağını başka bir yazıda inceleyeceğiz.
 
Alıntı ile Cevapla

IRCForumlari.NET Reklamlar
sohbet odaları sohbet odaları Benimmekan Mobil Sohbet
Alt 16 Mart 2009, 23:11   #22
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 - III
Yöntemler ve Alanlar - III


Şimdi bir projede birçok trigonometri hesabı yapacağımızı düşünelim. Bu projede sinüs, kosinüs ve tanjant hesapları kullanacağız. System isim uzayı içerisindeki Math sınıfı bu hesaplamaları yapmaya yarayan Sin, Cos ve Tan isimli yöntemlere sahiptir. Ama bu yöntemler derece cinsinden değil de radyan cinsinden değerlerle çalışır. Bizim projemizde de derece cinsinden değerlerle çalışılacak olsun. Gerekli dönüşümleri yaparak yeni Sin, Cos ve Tan yöntemlerini yeniden yazalım.
2Pi radyan 360 derecedir. Dönüşüm işlemine bir örnek yazalım. dDerece değişkeni kullanıcıdan alınan derece cinsinden değeri tutuyor olsun. Bu açının sinüsünü hesaplayan ifade aşağıdaki gibi olacaktır.
dSonuc = Math.Sin(Math.PI * dDerece / 180);
Her hesaplama işleminde bu ifadeleri teker teker yazmak istemeyiz. Şimdi bu dönüşümleri içerisinde izole eden Sin, Cos ve Tan yöntemlerini yazmalıyız.
Şimdi Trig1 isimli yeni bir sınıf yazalım ve içerisinde bu yöntemler bulunsun. Yeri gelmişken yaygın bir teknikten de bahsedelim. Bu sınıfı normalde başka bir projenin parçası olsun diye yazdığımız ve kendi başına kullanmayacağımız için bir Main yöntemine sahip olmayacaktır, ama test amaçlı olarak bir Main yöntemi ilave edelim. Daha sonra gerekli hata ayıklama işlemleri ve testleri yaptıktan sonra bu yöntemi silebiliriz.
Trig1 isimli projenin kodları aşağıdaki gibidir.
using System;
class Trig1
{
static void Main()
{
Console.WriteLine("45 derecenin sinüsü: " + Trig1.Sin(45));
Console.WriteLine("45 derecenin kosinüsü: " + Trig1.Cos(45));
Console.WriteLine("45 derecenin tanjantı: " + Trig1.Tan(45));
Console.ReadLine();
}
public static double Sin(double dAci)
{
return Math.Sin(Math.PI * dAci / 180);
}
public static double Cos(double dAci)
{
return Math.Cos(Math.PI * dAci / 180);
}
public static double Tan(double dAci)
{
return Math.Tan(Math.PI * dAci / 180);
}
}

Bu yöntemler daha henüz başka bir programdan çağrılmadığı halde, başlarına erişim niteleyicisi olarak public ekledik. Bu sınıfı daha büyük bir projede kullanacağımız zaman için hazır hale geldi. Main yöntemi içerisinde bu yöntemleri kullanırken, aynı sınıf içerisinde olmalarına rağmen sınıf ismi ile birlikte yazdık. İleride bu yöntemi de hiçbir şeyi değiştirmeden proje içerisindeki başka bir sınıfın içerisine taşıyabiliriz.
Dikkat ederseniz her üç yöntem de aynı dönüşüm ifadelerini içeriyor. Her birinde tekrar tekrar yazdık. İyi bir programcı tekrarlayan kodları bir yere toplar ve tekrar yazmadan kullanır.
Çözümlerden bir tanesi ayrı bir yöntem yazmaktır.
static double DerecedenRadyana(double dDerece)
{
return Math.PI * dDerece / 180;
}

Bu durumda programın tamamı şu şekilde olacaktır.
using System;
class Trig2
{
static void Main(string[] args)
{
Console.WriteLine("45 derecenin sinüsü: " + Trig2.Sin(45));
Console.WriteLine("45 derecenin kosinüsü: " + Trig2.Cos(45));
Console.WriteLine("45 derecenin tanjantı: " + Trig2.Tan(45));
Console.ReadLine();
}
static double DerecedenRadyana(double dDerece)
{
return Math.PI * dDerece / 180;
}
public static double Sin(double dAci)
{
return Math.Sin(DerecedenRadyana(dAci));
}
public static double Cos(double dAci)
{
return Math.Cos(DerecedenRadyana(dAci));
}
public static double Tan(double dAci)
{
return Math.Tan(DerecedenRadyana(dAci));
}
}

DerecedenRadyana yöntemine dikkat etti iseniz, başında public niteleyicisi yok. Yazmadığımız için private kullanılmış gibi oldu, çünkü private varsaylan değerdir. Başka sınıflar içerisinden ulaşılmasını istediğimiz yöntemleri public, sadece sınıf içerisinde kullanılacak olan yöntemleri private yaptık.
Ama ayrı bir yöntem kullanmak ve onu çağırmak programımıza fazladan yük getireceği için çok anlamlı olmadı. Bunun yerine bir dönüşüm faktörü yazıp kullanmak daha anlamlı olur.
double dDonusturucu = Math.PI / 180;

Sin yönteminin kullanımı da aşağıdaki hale gelecektir.
return Math.Sin(dDonusturucu * dAci);

Dönüşüm faktörünün nerede tanımlanacağına karar verelim. Sin yönteminin içinde tanımlarsak sadece Sin yöntemi içinde yerel olarak kullanılır diğer yöntemlerden ulaşılamaz. Diğerleri içerisinde de ayrı ayrı tanımlamak gerekiyor. Aynı ifadeleri tekrar tekrar yazmak ise bizim amacımıza terstir.
Çözüm, dDonusturucu faktörünü alan olarak tanımlamaktır. Farkında olmasak da alan kavramı ile daha önce karşılaştık. Math sınıfı, PI ve E olmak üzere iki tane alana sahiptir. PI ve E, önemli sabit değerler olan pi ve e sayılarının değerlerini tutan özel değişkenlerdir. Bütün yöntemlerin dışında ama sınıfın içerisinde bir yerde alanlar tanımlanır. Daha sonra, tanımladığımız alan bütün yöntemler tarafından erişilebilen genel bir değişken olur.
Alan içeren bir sınıf aşağıdaki gibi başlayabilir.
class Trig3
{
static double dDonusturucu = Math.PI / 180;

Genellikle alan tanımlamaları sınıfın en üst kısmında olur ama tabi ki bu da bir zorunluluk değildir.
Diğer yöntemler gibi alan da static anahtar kelimesi ile tanımlandı, yöntemin kopyası ile değil de sadece kendisi ile çalışabilir. Bu meseleyi de daha sonra bir yazıda anlatacağız.
public niteleyicisini kullanmadık, çünkü sadece bu sınıf içerisinde ulaşılabilir olmasını istiyoruz. Şu hali ile diğer sınıflardan ulaşılamaz olsa bile alanımız sınıf içerisindeki yöntemler tarafından ulaşılabilir ve değiştirilebilir. static kelimesini const ile değiştirerek alanımızı sadece okunabilir hale getirebiliriz. Herhangi bir alan const olarak tanımlanmışsa aynı zamanda da kapalı olarak static olarak tanımlanmış demektir.
class Trig3
{
const double dDonusturucu = Math.PI / 180;

Şimdi çık sık karşılaşılan bir soruna da çözüm bulalım. Math sınıfındaki public tanımlanmış PI alanını Pi şeklinde mi PI şeklinde mi yazacağımızı unutabiliriz. Trig3 sınıfımızın içerisine hem PI hem de Pi şeklinde iki tane public alan tanımlayalım ve istediğimiz zaman projenin her hangi bir yerinde kullanılır hale getirelim.
public const double PI = Math.PI;
public const double Pi = PI;

Bu arada programda yapacağımız değişiklikler bittiğine göre son halini tekrar yazalım.
using System;
class Trig3
{
public const double PI = Math.PI;
public const double Pi = PI;
const double dDonusturucu = Math.PI / 180;
static void Main()
{
Console.WriteLine("45 derecenin sinüsü: " + Trig3.Sin(45));
Console.WriteLine("45 derecenin kosinüsü: " + Trig3.Cos(45));
Console.WriteLine("45 derecenin tanjantı: " + Trig3.Tan(45));
Console.ReadLine();
}
public static double Sin(double dAci)
{
return Math.Sin(dDonusturucu * dAci);
}
public static double Cos(double dAci)
{
return Math.Cos(dDonusturucu * dAci);
}
public static double Tan(double dAci)
{
return Math.Tan(dDonusturucu * dAci);
}
}

Trig3 projesinin sınıf diyagramı aşağıdaki gibidir.

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

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



C# Mantıksal veri türü (Boolean)
Mantıksal veri türü (Boolean)

Gerçek hayattaki doğruların çoğu anlaşılması güç kavramlardır. Oysaki bilgisayar programlarında doğruların anlaşılması çok daha kolaydır. Örneğin bilinen bir tamsayının 100’den daha büyük olup olmadığını veya bilinen bir string ifadenin “kitap” kelimesiyle özdeş olup olmadığını bilmek son derece kolaydır.
C#’ta mantıksal bir veri tipi aşağıdaki gibi tanımlanır:
bool buyuk;
C#’ta bool anahtar kelimesini kullanarak bir değişkeni mantıksal bir değişken olarak tanımlayabilirsiniz. Nasıl int kelimesi System.Int32 sınıfının bir aliası , string de System.String sınıfının bir aliası ise, bool da System.Boolean sınıfının bir aliasıdır.
Mantıksal türlerin 0 ve 1 değerlerinden oluştuğunu düşünebilirsiniz. Aşağıdaki atama işlemi yanlıştır.
buyuk=0; //Çalışmaz
Bir tamsayıyı mantıksal bir değişkene atamaya çalışıyorsunuz. 0 ya da 1 yerine true ve false anahtar kelimelerini kullanmanız gerekiyor.
buyuk=true;
Yine tamsayılarda olduğu gibi mantıksal türde bir değişken tanımlanırken ilk değer ataması da yapılabilir.
bool buyuk=true;
true ve false anahtar kelimeleri küçük harfle yazılmalıdır.
Yine sayısal türlerde olduğu gibi mantıksal türde de sabit tanımlamak mümkündür.
const bool buyuk=true;
Bu durumda buyuk isimli değişkenin değeri programın ilerleyen kısımlarında false olarak değiştirilemez.
Sayısal ifadeler yalnızca rakamlardan oluşurlar. Mantıksal ifadeler de mantıksal değerlerden oluşurlar (true ve false). Mantıksal değişkenler ile normal aritmetik operatörleri (+, -, %, /) kullanamazsınız. Bunların yerine C#’ta üç tane mantıksal operatör kullanılır. Bunlar: AND,OR ve XOR operatörleri.
C#, mantıksal operatörleri de C’den miras almıştır. AND işlemi için ampersand işareti (&) ya da kısaca söyleyecek olursak “ve” işareti kullanılır.
İngilizce kısaltmada genel olarak VE olarak bilinen mantıksal AND’i kullanmak için ampersand (&) kullanılır. Boolean ifade:
Yagmurlu & Karli;
Yukarıdaki ifadenin sonucu hem Yagmurlu hem de Karli değerli true olduğu zaman true olur.
bool KarlaKarisikYagmur = Yagmurlu & Karli;
Mantıksal ifadeler arasında yapılan AND işleminin sonuç tablosu aşağıdaki gibidir:
Mantıksal İfade 1
Mantıksal İfade 2
AND İşlemi Sonucu
false
false
false
false
true
false
true
false
false
true
true
true
İkinci mantıksal operatör ise OR (veya) operatörüdür. Bu operatör klavyedeki dikey bar çubuğu (|) işareti ile gösterilir.
Yagmurlu | Karli
Yukarıdaki ifadenin sonucu, herhangi birisinin değeri true olduğu zaman true olur.
bool Yagislimi = Yagmurlu | Karli
Mantıksal ifadeler arasında yapılan OR işlemin sonuç tablosu aşağıdaki gibidir:
Mantıksal İfade 1
Mantıksal İfade 2
OR İşlemi Sonucu
false
false
false
false
true
true
true
false
true
true
true
true
Üçüncü mantıksal operatör Exclusive OR (Özel Veya) operatörüdür. Kısaca XOR olarak kullanılır. Bütün C temelli dillerde şapka işareti ya da inceltme işareti olarak bilinen (^) işareti ile gösterilir. Bir XOR işleminin sonucunun true olabilmesi için sadece bir tanesinin true olması gerekir, her ikisi de true ya da her ikisi de false olursa sonuç false olur. Şimdi bu ifadeyi daha iyi anlamak için aşağıdaki tabloyu inceleyelim.
Mantıksal İfade 1
Mantıksal İfade 2
XOR İşlemi Sonucu
false
false
false
false
true
true
true
false
true
true
true
false
Aklımızda kalması için şu şekilde de düşünebilirsiniz: Eğer mantıksal ifadelerin ikisi birbirinden farklı ise sonuç true olur, aynı iseler false olur.
Şimdi iki tane atom düşünelim. Birisi negatif diğeri pozitif olan iki atom birbirini çeker, her ikisinin de işareti aynı ise birbirini iterler. Bunun için Cekim diye bir değişken tanımlayalım. Atomlarımızın değerlerine bakarak birbirlerini çekip çekmeyeceklerini inceleyelim.
bool Cekim = Atom1 ^ Atom2;
AND, OR ve XOR operatörlerinin her üçü de ikili operatörlerdir, şimdi de tekli operatörleri inceleyelim. NOT (Değil) operatörü tekli bir operatördür. Mantıksal tersleme operatörü de diyebilirsiniz. Ünlem işareti ile temsil edilir.
Kisa = !Uzun;
Eğer Uzun değeri true ise Kisa değeri false olacaktır, tersi durumda da Kisa değeri true olacaktır.
XOR işleminin sonucunu diğer operatörleri kullanarak da elde edebilirsiniz.
C = (A - B) & !(A & B);
C = A ^ B;
Yukarıda verilen işlemlerin her ikisi de aynı sonucu verir.
Yukarıda verilen ilk ifadede birkaç tane parantez kullandık. Bu ifadeyi operatörlerin işlem önceliği kurallarına göre inceleyecek olursak, NOT işlemi (! İşareti), tekli operatördür ve yüksek bir önceliğe sahiptir. AND işlemi ise ikili operatördür ve NOT işlemine göre daha düşük bir önceliği vardır. Eğer bu kuralları iyi bilmezseniz gereksiz parantezler kullanmak zorunda kalırsınız. AND işlemi ile NOT işlemi arasındaki işlem önceliğini bilmeseydik, gereksiz bir tane daha parantez kullanacaktık.
AND, OR ve XOR operatörlerini bitişik atama operatörü olarak da kullanmak mümkündür.
bToggle = bToggle ^ true;
bToggle ^= true;
Yukarıdaki her iki işlemin de sonucu aynıdır. Yeri gelmişken bahsedelim, yukarıda verdiğimiz örnek çok özel bir durum örneğidir. bToggle değeri ne ise bu işlemin sonucunda değeri tersi olur. Eğer bToggle true ise false olur, false ise true olur.
Boolean ifadelerin dizisi de yapılabilir.
bool abYagmurluGunler = new bool[31];
Burada önceden bahsettiğimiz bir konuyu da hatırlatmakta yarar var. Diziler daima belleğin heap bölgesinde tutulur. heap bölgesinde tutulan değişkenlerin de daima bir ilk değeri olur. Mesela sayısal ifadeler 0’a eşittir. string ifadeler null değerine sahiptir. Bir bool dizisinde de ilk değerler daima false değerine eşit olacaktır.
.Net Framework içerisindeki bütün yapılar gibi System.Boolean yapısının da bir ToString yöntemi vardır. Ama bu yöntemden True ve False kelimeleri döner. Eğer Console.WriteLine yöntemine bir bool ifadeyi gönderirseniz ekranda True ya da False görünecektir. Bildiğiniz gibi, C# anahtar kelimeleri olan true ve false ise küçük harfle başlarlar.
bool b = Boolean.Parse(str);
System.Boolean yapısının static olan bir de Parse yöntemi vardır. Bir string argüman alır. Büyük küçük harf duyarlılığı olmaksızın true ya da True, false ya da False geçebilirsiniz argüman olarak.
Çok güçlü bir sınıf olan Convert sınıfı bütün türleri birbirine dönüştürebildiği için, bir sayısal ifadeyi bool bir ifadeye dönüştürebilir.
bool b = Convert.ToBoolean(mValue);
0 değeri false ifadesine dönüşür, 0 olmayan ifadeler ise true ifadesine dönüşür. Bir boolean değeri sayıya dönüştürürsek, true ifadesi 1 değerine, false ifadesi de 0 değerine dönüşür.
decimal mValue = Convert.ToDecimal(b);
Şimdi sadece bool değişkenlerden oluşan bir program yazalım. Kedi satan bir evcil hayvan satıcısına gittiğinizi düşünün. Kısırlaştırılmış, beyaz ya da kahverengi bir erkek kedi istiyorsunuz; ya da kısırlaştırılmış, beyaz haricinde herhangi bir renkte olan bir dişi kedi istiyorsunuz ya da bir kedi istiyorsunuz sadece siyah renkli olması yeterli. Şimdi programı yazmaya başlayalım.
using System;

classKediSecimi
{
staticvoid Main()
{
bool bErkek, bKisir, bSiyah, bBeyaz, bKahverengi, bUygun;

Console.Write("Kedi erkek mi? true ya da false: ");
bErkek = Boolean.Parse(Console.ReadLine());

Console.Write("Kedi kısırlaştırılış mı? true ya da false: ");
bKisir = Boolean.Parse(Console.ReadLine());

Console.Write("Kedi siyah mı? true ya da false: ");
bSiyah = Boolean.Parse(Console.ReadLine());

Console.Write("Kedi beyaz mı? true ya da false: ");
bBeyaz = Boolean.Parse(Console.ReadLine());

Console.Write("Kedi kahverengi mi true ya da false: ");
bKahverengi = Boolean.Parse(Console.ReadLine());

bUygun = (bErkek & bKisir & (bBeyaz | bKahverengi)) |
(!bErkek & bKisir & !bBeyaz) |
bSiyah;

Console.WriteLine("Uygunluk Durumu: " + bUygun);
}
}

Programda kullanıcıya bir dizi soru soruluyor ve true ya da false olarak cevap bekleniyor. Kullanıcının girdiği string değerleri Boolean.Parse yöntemi yardımıyla bool değerlere dönüştürüyoruz. bUygun ifadesi de girdiğimiz kriterlere göre sonucu bulup bize bildiriyor.
Programda renklerle ilgili bir problem var aslında. Kullanıcı sadece bir tane renk içni true demesi gerekirken birden çok renk için true diyebilir, bunu engelleyebiliriz ama detaya girmeyelim, kullanıcıya doğru bilgiler gireceği konusunda güvenelim şimdilik.
Boolean cebirinde bazı kolaylıklar sağlayan De Morgan kuralları diye bir dizi kural var. İngiliz matematikçi Augustus De Morgan adı aynı zamanda ADA programlama dili ve ilk bilgisayar programı ifadeleri ile de birlikte anılır.
De Morgan der ki, “OR işleminin olumsuzu her bir değerin olumsuzunun alınıp AND işlemine tabi tutulmasına eşittir.” ve “AND işleminin olumsuzu, her bir değerin olumsuzunun alınıp OR işlemine tabi tutulmasına eşittir.”
!(A| B) eşittir !A & !B
!(A & B) eşittir !A | !B
bool YagisliHava = Yagmurlu | Karli
Şimdi AcikHava durumunu düşünelim, YagisliHava durumunun olumsuzudur.
bool AcikHava = !(Yagmurlu | Karli)
Şimdi De Morgan kuralı ile yazalım bu ifadeyi daha açıklayıcı olur.
bool AcikHava = !Yagmurlu & !Karli
Cümle olarak yazarsak “Hava yağmurlu değilse ve karlı da değilse açıktır.” Gayet anlaşılır oldu.



 
Alıntı ile Cevapla

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



C# Char ve String Veri Türleri
Char ve String Veri Türleri

C programlama dilinde string adında bir veri türü yoktur. C dili string veri türü yerine char adında bir veri türüne sahiptir. char veri türü ile meselâ B, x veya * gibi tek karakter ifade edilir. Eğer bir yazıyı değişkende saklamak gerekirse char türünden bir dizi oluşturmak gerekir. Karakterlerin bir dizisi olarak yazı ifade edilir.
C# programlama dilinde de char veri türü vardır ( .net Framework içerisindeki String.Char yapısının bir aliası olarak ). Fakat C dilindeki char ile C# dilindeki char arasındaki benzerlik sadece isim benzerliğidir. İşlevleri ve yapıları farklıdır. C# dilinde bir karakter dizisini string ifadeye, string ifadeyi de karakter dizisine dönüştürmek mümkündür; fakat “string veri türü yalnızca bir karakter dizisidir” demek doğru değil, çünkü string kendi başına bir veri türüdür.
Diğer bir farklılık: Tüm programlama dilleri karakterleri temsil etmek için sayıları kullanırlar, fakat C dilinde char veri tipi int, long ve short gibi nümerik bir veri tipidir. Ayrıca C dilinde karakter türü değişkenleri, signed char (işaretli karakter) veya unsigned char (işaretsiz karakter) olarak bildirebiliriz.
C dilinde char türündeki veri 8 bit uzunluğunda ve bir ASCII karakteri temsil etmektedir. C# dilinde ise char türündeki veri 16 bit uzunluğunda ve Unicode karakteri temsil etmektedir.
C# dilinde karakterleri ve sayıları birbirine karşılıklı dönüştürebilmenize rağmen char veri tipindeki değerler sayı değildir.
Unicode karakterler ve nümerik karşılıklarını şu adreste görebilirsiniz: [Üye Olmadan Linkleri Göremezsiniz. Üye Olmak için TIKLAYIN...] /charts
srting bir ifade, çift tırnaklar arasında yazılır, 0 ya da daha fazla karakterden oluşur. Tek bir karakteri ise tek tırnak arasında yazmak gerekir. Aşağıdaki örnekte char türü bir değişken tanımlaması yapılmıştır ve tanımlanırken de ilk değer ataması yapılmıştır.
char ch = 'Z';
C# dilinde karakterden nümerik tiplere dönüştürme işlemini casting yaparak gerçekleştirebilirsiniz.
int i=10;
i = (int) '7';
i değişkeninin yeni değeri 7 değil de 55 olur. Niçin böyle oldu? 7 karakterinin ASCII ve Unicode karşılığı 55 olduğu için casting işlemi sonucu i değişkeni 55 değerini aldı.
Şimdi de casting yaparak bir karakterin ascii değerini ifade eden tamsayıyı karakter türü bir değişkene atayalım.
char ch = ‘y’;
ch = (char) 97;
ch değişkeninin değeri ‘a’ harfi olacaktır. Çünkü a harfinin ascii ve Unicode karşılığı 97’dir.
Eğer, aritmetik işlemde sayı ve karakteri yan yana kullanırsak kapalı dönüşüm de kendiliğinden yapılır.
İnt i;
i = 'a' + 5;
Yukarıdaki işlemin sonucu da 102 olacaktır, çünkü a karakterinin ASCII ve Unicode karşılığı 97 dir. Dolayısıyla C#, karakteri kapalı dönüşüme tabi tutacaktır.
Yine aynı şekilde bir karakter ile bir string ifade birleştirme işlemine tabi tutulursa, karakter kapalı dönüşüm ile string ifadeye dönüşecektir.
string str;
str = "a" + 'b'
Yukarıdaki işlemin sonucu “ab” string ifadesi olacaktır.
Fakat aşağıdaki işlem sonucunda 195 sayısal ifadesi çıkar.
i = 'a' + 'b';
String sınıfının .net framework içerisindeki bir diğer özelliği de Chars özelliğidir. Bu özellik, C# dilindeki String sınıfında indeksleyici olarak temsil edilir. Bunun anlamı, C# dili içerisinde Chars adında bir özellik yoktur fakat dizilerde indislerle dizi elemanlarına ulaşmaya yarayan indeksleyiciler gibi string ifadeyi oluşturan karakterlere ulaşmaya yarayan bir indeksleyici vardır. Bu indeksleyici .net framework içerisinde tanımlı olan Chars özelliğine karşılık gelir.
Örneğin bir string ifade yazalım:
string str = "Csharp Öğreniyorum";
String türündeki str değişkenimizin karakterlerine teker teker indeksleyicilerle ulaşalım.
ch = str[0];
ch değişkenini ekrana yazdırdığımızda ilk harf olan ‘C’ karakterini göreceğiz. Yine aynı şekilde:
ch = str[18];
Şimdi ise ch değişkenimiz ‘m’ harfini içermektedir. Örneğimize göre 0 dan küçük ve 18 den büyük değerler çalışma zamanında hata verecektir. Şu şekilde indeksleyici için yapılan atama işlemi hatalı olacaktır.
str[0] = 'H'; // Derleme hatası..
String veri türü için olan indeksleyici sadece okunabilirdir, string ifadenin bir karakterini değiştirmek için onu kullanamazsınız. C# dilinde string değişkenler aslında değiştrilemez durumdadırlar denilebilir. Çünkü bir takım yöntemler yardımıyla sizin yaptığınız değişikliklerle birlikte yeni bir string ifade oluşur ve sizin değişkeninize atanır.
Bir string literal için de değişkene atamaksızın indeksleyici kullanabilirsiniz.
Char ch = “Csharpturk” [2];
Karakterler arasında döngü yapmak isterseniz şu tür bir ifade kullanabilirsiniz:
(char) ((int) 'A' + i)
Önce A harfinin Unicode değeri olan 65 ifadesi casting yapılarak tamsayıya dönüştü, sonra üzerine i ilave edildi, daha sonra da çıkan ifade karaktere casting yapılarak dönüştürüldü.
String ifadelerden bir dizi de oluşturabilirsiniz. Aşağıdaki örneği inceleyiniz.
string[] astr = { "Golf", "Audi", "Mercedes" };
astr[1] ifadesi bize “Audi” soncunu verecektir. Ayrıca string indeksleme ile astr[1][2] ifadesi ile ikici elemanın üçüncü harfi olan ‘d’ ye ulaşabiliriz. Burada indeksleme ile Length özelliğinin kullanımını karıştırmamalıyız. astr.Length() ifadesi 3 sonucunu verecektir. astr[1].Length ifadesi de 4 sonucunu vercektir çünkü “Audi” kelimesi uzunluğu dört karakterdir.
Bir int ifadeyi parametresiz yapıcı ile tanımlayabilirsiniz.
int i = new int();
Yukarıdaki ifade parametresiz bir yapıcı olduğu için hatasızdır. Ama aşağıda gördüğünüz string yapıcısı hatalıdır.
string str = new string(); // çalışmayacaktır.
Bunun sebebi, String sınıfı parametresiz yapıcıyı desteklememektedir. Değişken alan birkaç yapı var ve bu yapılar sayesinde karakterlerden string değişkenler oluşturabilirsiniz.
String bir değişkenin karakterler dizisine dönüştürülmesini inceleyelim. Karakterler dizisini string’ e dönüştürmek için kullanacağımız string yapıcı ifadesi aşağıdaki şekilde olacaktır.
char[] ach = { 'm', 'e', 'r', 'h', 'a', 'b', 'a' };
string str = new string(ach);
String sınıfı içerisinde, string değişkeni karakterler dizisi haline getiren bir yöntem yer almaktadır.
char[] ach2 = str.ToCharArray();
String türü bir değişken kullanmadan da bir yazıyı karakter dizisine dönüştürebiliriz.
char[] ach = "merhaba".ToCharArray();
Diyelim ki 21 tane ‘@’ sembolünden oluşan bir string değişken tanımlayacaksınız. Dikkatli bir sayım ile aşağıdaki gibi yapmanız gerekiyor.
string str = "@@@@@@@@@@@@@@@@@@@@@";
Aşağıdaki yöntem ise çok daha kolaydır.
string str = new string('@', 21);
Yapıcıların diğer bir avantajı da ikinci parametrenin değişken olarak tanımlanabilmesidir. Aşağıdaki örnek programı inceleyelim:
// ------------------------------------------------------
// PCWorld.cs PCWorld dergisi içerik sayfası örneği.
// ------------------------------------------------------
using System;

classIcindekiler
{
staticstring[] bolumler = { "Teknoloji",
"Donanım", "Yazılım",
"İnternet", "Oyunlar" };
staticint[] sayfaNo = { 3, 10, 16, 24, 29 };

staticvoid Main()
{
Sat\u305 ?r(0);
Sat\u305 ?r(1);
Sat\u305 ?r(2);
Sat\u305 ?r(3);
Sat\u305 ?r(4);
}
staticvoid Sat\u305 ?r(int i)
{
constint genislik = 60;
string noktalar = newstring('.',
genislik - (i + 1).ToString().Length
- bolumler[i].Length
- sayfaNo[i].ToString().Length);

Console.WriteLine("{0}. {1}{2}{3}",
i + 1, bolumler[i], noktalar, sayfaNo[i]);
}
}

Programı çalıştırdığınızda içerik bilgileri ekranda üç kolon halinde görüntülenecektir. 5 bölümün adları, 5 bölümün sayfa numaraları ve ihtiyaç miktarınca noktalar. Buradaki nokta sayısının nasıl belirlendiğine dikkat etmeliyiz. İlk parametre periyot karakteridir. İkinci parametreyi ise gerekli toplam genişlik ile bölüm numaralarının karakter sayısının farkı ile elde ediyoruz. Ekran çıktısı aşağıdadır.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Satır metodu, ekrana yazılacak verilerin formatlanmasını ve yazdırılmasını sağlıyor. Sıfır tabanlı parametre ise bölüm numarası iki dizinin indeksini belirtmekte. Main yöntemi ile Satır metoduna gönderilen indeks ile yazdırma işlemi gerçekleştiriliyor.
Karakter ve string ifadeler insanların haberleşmesinin bir parçası gibidir. Char yapısı ve String sınıfı birçok metoda sahiptir, bunların içinden önemli diyebileceğimiz bazı yöntemleri inceleyelim.
Char yapısı içerisinde bazı static yöntemler Boolean türünde değer döndürerek karakterin kategorisine ulaşmamızı sağlar, Meselâ:
Char.IsDigit(ch)
Eğer dönen değer true ise ‘ch‘ değişkeni ‘0’ dan ‘9’ a kadar bir değerdir. Ayrıca belirli bir karakterin kategorisini de tespit edebiliriz:
Char.IsDigit(str, i)
Eğer dönen değer true ise string str[i] karakteri ‘0’ dan ‘9’ a kadar bir değerdir. IsDigit metodunun dışında IsLetter, IsLetterOrDigit, IsLower (küçük harf için), IsUpper, IsNumber , IsPunctuation, IsWhiteSpace gibi benzer metodlar da bulunmaktadır.
String değişkenini değiştiremezsiniz ancak yeni bir string oluşturup eskisini yerine koyarsınız. Bunun için String sınıfı içersinde birkaç yöntem yer almaktadır.
Meselâ string değişkeninizin tüm harflerini küçük karakterlerden oluşmasını istiyorsanız aşağıdaki yöntemi kullanabilirsiniz.
string str2 = str.ToLower();
ToLower yöntemi, var olan eski string ifadenin harflerini küçük karakterlere çevirir ve str2 içerisine atadığımız yeni bir string döndürür. Ayrıca orijinal değişkenin üstüne de yazdırabilirsiniz:
str = str.ToLower();
Bu kullanım da çalışacaktır. Orijinal string yerine yeni oluşturulan değer yazıldı.
Substring metodu da String sınıfının önemli yöntemlerindendir. Bu yöntem ile bir string’in belirli bir parçasını elde edebiliriz.
string str2 = str.SubString(BaşlangıçIndeksi, KarakterSayısı);
Meselâ str içerisinde “csharpturk” ifadesi olsun:
str.SubString(6, 4)
elde edilen string parçası “turk” ifadesidir.
Ayrıca string içeris,nde büyük küçük harf duyarlı aramalar yapabilirsiniz. AnyIndexOf metodu ile string içerisinde karakter kümesi arayabilirsiniz. Bunun yanında LastIndexOf ve LastIndexOfAny metodları ile de son karaktere ulaşabilirsiniz.
String sınıfının içerisinde iki farklı string’i karşılaştırmanızı sağlayan yöntemler bulunuyor. Bunlardan bazıları durağan diğerleri de türemiş yöntemlerdir. Bazıları bool türünde değer döndürürken bazıları int türünde değer döndürebilir. Bu yöntemleri aşağıdaki tabloda inceleyebilirsiniz.
Yöntem
Durağan / Türemiş
Dönen Değer
Karşılaştırma Türü
Equals
Her ikisi de
bool
Nümerik (Karakter Duyarlı)
Compare
Durağan
int
Metinsel (Seçimlik, Karakter Duyarsız)
CompareTo
Türemiş
int
Metinsel (Karakter Duyarsız)
CompareOrdinal
Durağan
int
Nümerik
Geri dönüş değer tipi int olan yöntemler string ifadeleri sıralamada çok faydalı olacaktır. Meselâ, aşağıdaki ifade basit bir karşılaştırma işini yapıyor.
i = String.Compare(str1, str2);
int tipindeki dönüş değeri:
  • str1 < str2 ise negatif
  • str1 = str2 ise sıfır
  • str1 > str2 ise pozitif değer alır.
Nasıl oluyor da iki string karşılaştırıldığında biri diğerinden büyük yada küçük olabiliyor ? Nümerik karşılaştırma nümerik karakter kodlarının sırasına bağlıdır. Bir örnek ile nümerik sıralamanın nasıl yapıldığını inceleyelim:
D < E < F < d < e < f < È < É < Ê < Ë < è < é < ê < ë
Eğer string’leri alfabetik olarak sıralamak istiyorsanız bu örnek işinize yaramayacak. Bunun için şu karşılaştırma kullanılmalıdır:
d < D < e < E < é < É < è < È < ê < Ê < ë < Ë < f < F
Dikkat ettiyseniz büyük küçük harf duyarlı olarak sıralama yapılıyor. Örneğin “Yeni Araba” string ifadesi “yeni Araba” dan küçüktür.Eğer iki string’in karakter sayısı eşit ise küçük harfle başlayan string diğerinden küçüktür.Örneğin “the” string’i “The” string ifadesinden küçüktür. Buna karşın “Them” ifadesi “then.” ifadesinden küçüktür.
Karşılaştırma işlemi için büyük küçük harf duyarlılığını eklemeyebilirsiniz:
i = String.Compare(str1, str2, true);
Buradaki üçüncü değer duyarlılık özelliğini aktif hale getirmektedir.
String sınıfı içerisindeki bir diğer yöntem ise String.Format yöntemidir. Bildiğiniz gibi bu yöntem ile string ifadelerin istenilen biçimde yazdırılmasını sağlayabiliriz. İlk değer değişken için yer tutucu özelliğini yapılandırmamızı sağlar. Console.Writeline biçimlendirme yapısı ile benzerdir.
str = String.Format("{0} + {1} = {2}", A, B, A + B);
 
Alıntı ile Cevapla

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



C# while Döngüsü
while Döngüsü

Programlama gerçekten de tekrarlamadan ibarettir. Bizler nadiren sadece bir kez çalışan programlar yazarız. Yazdığımız çoğu program bir kez çalışır ve her çalışmasında hemen hemen aynı şeyi tekrarlar. Ancak her çalışmada doğru sonucu oluşturacak kadar ufak farklar vardır. Sıklıkla, bir programın içinde bile tekrarlamalar bulunur. Tabi yine ufak farklarla. Bu da bizim bu makalede inceleyeceğimiz konu. C# dili özellik olarak tekrarlama durumlarını icra eder. Biz bu tekrarlama durumlarına Döngü deriz.
Yeni kiraladığımız bir evin kirasının 1000 YTL olduğunu varsayalım. Ve her yıl kirayı %5 arttıracağımızı düşünelim. Önümüzdeki 10 yıl içinde vereceğimiz kira miktarının ne olacağını hesaplayan bir program yazalım.
using System;

class KiraHesabi
{
static void Main()
{
decimal Kira = 1000, ArtisMiktari = 5.0m;
Console.WriteLine("2006 yılındaki kira={0} YTL", Kira);
Console.WriteLine("2007 yılındaki kira={0} YTL", Kira *= (1 + ArtisMiktari / 100));
Console.WriteLine("2008 yılındaki kira={0} YTL", Kira *= (1 + ArtisMiktari / 100));
Console.WriteLine("2009 yılındaki kira={0} YTL", Kira *= (1 + ArtisMiktari / 100));
Console.WriteLine("2010 yılındaki kira={0} YTL", Kira *= (1 + ArtisMiktari / 100));
Console.WriteLine("2011 yılındaki kira={0} YTL", Kira *= (1 + ArtisMiktari / 100));
Console.WriteLine("2012 yılındaki kira={0} YTL", Kira *= (1 + ArtisMiktari / 100));
Console.WriteLine("2013 yılındaki kira={0} YTL", Kira *= (1 + ArtisMiktari / 100));
Console.WriteLine("2014 yılındaki kira={0} YTL", Kira *= (1 + ArtisMiktari / 100));
Console.WriteLine("2015 yılındaki kira={0} YTL", Kira *= (1 + ArtisMiktari / 100));
Console.WriteLine("2016 yılındaki kira={0} YTL", Kira *= (1 + ArtisMiktari / 100));
}

}
Kopyalama ve yapıştırma mükemmel değil mi? Rakamların alt alta gelmesi için matematik hesabını WriteLine cümlesinin içinde yaptık. Her ifade Kira değişkeninin değerini arttırıyor. 2005 yılı için ifadeyi yazdıktan sonra bu ifadeyi kopyaladım ve 9 kere yapıştırdım ve yılların yazıldığı rakamları değiştirdim. Sonucu aşağıdaki gibi elde ettik.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
decimal değişken kullandığımızdan dolayı oluşan fazla haneleri saymasak iyi çalışmış gibi görünüyor. Fakat eminim ki bu programda güzel bir şeylerin eksik olduğuna benle aynı fikirdesiniz. Sadece birkaç yıl için pek fazla kötü görünmüyor. Fakat daha fazla yıl için bir hesaplama yapacak olsak işler kötüye giderdi. Birbirinin aynı koddan sayfalar dolusu istemezsiniz. Ya bu kodları yazdıktan sonra küçük bir yanlışlığa rastlarsanız ne olacak?
Zorlama ile bazı problemler çözmek işe yarayabilir, genellikle döngü kullanmaktan daha kolaydır. C# ‘ta en basit döngü while ifadesidir. else kısmı olmayan bir if ifadesine çok benziyor. while anahtar kelimesini bir parantezler içerisindeki bir boolean ifade takip eder. Bir çift küme parantezi bir veya birden fazla döngü kodunu takip eder.
while (boolean ifade)
{
// döngünün içindeki diğer ifadeler
}
while ile if arasındaki farklar şunlardır:
if cümlesinde eğerboolean ifade doğru (true) ise küme parantezleri arasındaki ifadeleri sadece bir kez çalıştırır. while ise boolean ifadesi doğru olduğu müddetçe küme parantezleri arasındaki ifadeleri çalıştırmaya devam eder. Çalışma boolean ifade yanlış (false) olana kadara devam eder.
Değeri 55 olan bir i değişkeni olduğunu varsayalım. Şimdi bir if cümlesi yazalım
if ( i < 100 )
{
Console.WriteLine ( i ) ;
}
Sonuç 55 olarak ekrana yazılacaktır.
Aynı ifadeyi while için yazalım.
while ( i < 100 )
{
Console.WriteLine( i ) ;
}
Bu sefer sonuç aşağıdaki gibi olacaktır:
55
55
55
55
...
Sonsuz döngü olarak bilinen bu döngü devamlı çalışmaya devam edecektir. Fakat genellikle program bitmeden bu sonsuz döngüleri bitirmek isteyeceksin. Program sonsuz döngüye girdiğinde konsol penceresini kapatarak veya "Ctrl +C" tuşlarını kullanarak döngüyü durdurabilirsin. Tabiî ki kesinlikle sonsuz döngü içeren uygulamalar var, fakat çoğu durumda küme parantezinin içindeki kodlar boolean ifadenin içindeki değişkeni değiştirirler.
Şimdi 100’e kadar sayan bir program yazalım.
using System;

class CountUntill100 // 100'e kadar say
{
static void Main()
{
int i = 0;
while (i < 100)
{
Console.WriteLine(i);
i++;
}
Console.WriteLine("i'nin son değeri:{0}", i);
}
}
i’nin değeri 100’den küçük olduğundan, işletimin devamında while ifadesine gelindiğinde işletim while ifadesinin küme parantezlerini işleterek ilerleyecek. Küme parantezlerinin içindeki ifade i’nin değerinin yazacak ve değişkeni arttıracak. Ve işletim boolean ifadeye geri dönecek. i hala 100’dem küçük mü? Eğer öyleyse küme parantezinin içindeki ifade tekrar işletilecek. Bu işlemlerin her bir ilerlemesine iteraston (yineleme) adı verilir. Programın çıktısı aşağıdaki gibidir.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
99 gösterildikten sonra i’nin değeri 100 e arttırılır. Programın devamı boolean ifadeye döner. i’nin değeri 100’den küçük mü? Hayır. Programın işletimi while ifadesinden sonraki program kodu ile devam eder. Şimdi i değişkenin değeri 100’e eşit oldu. En son olarak program "i'nin son değeri 100" yazar.
i’nin değeri 100’e ulaştığında ( veya 100 değerinin üzerine ulaştığında ) küme parantezleri içerisindeki ifadeler işletilmeyecek.
Aşağıda bu programda kullandığımız while döngüsünün başka bir varyasyonu gösterilmektedir.
while ( i < 100 )
{
i++;
Console.WriteLine(i);
}
i’nin değeri Console.WriteLine çağrısından önce arttırıldığı için bu döngü 1 den 100 e kadar olan sayıları gösterir. Döngü i değeri 100’e ulaştığında hemen durmaz. WriteLine çağrısından sonra işletim döngünün başına döner ve bundan sonra boolean ifade tekrar kontrol edilir.
Not: Küme parantezleri arasında sadece 1 ifade varsa küme parantezlerini kullanmanıza gerek yoktur.
Şimdi i değişkenin değerini Console.WriteLine çağrısının içinde arttırarak küme parantezlerini kullanma derdinden de kurtulalım.
while ( i < 100 )
Console.WriteLine(i++);
Sonek arttırma operatörü değişkenin değerini ekranda gösterildikten sonra arttırır. Bu örnekte program 0’dan 99’a kadar sayıları ekranda gösterir. Eğer önek arttırma operatörünü kullanırsak;
while ( i < 100 )
Console.WriteLine(++i);
değişken ekranda gösterilmeden önce arttırılacak ve program ekranda 1’den 100’e kadar olan sayıları gösterecek.
Aynı zamanda i değişkenini boolean ifadenin içinde de arttırabiliriz. Örneğin;
while ( i++ < 100 )
Console.WtiteLine(i);
Sonek artırım operatörü i değişkenin değerini boolean ifadede kullanıldıktan sonra, Console.WriteLine çağrısından önce artırıyor. Program ekranda 1’den 100’e kadar sayıları gösteriyor. Aynı ifadenin önekli versiyonu;
while ( ++i < 100 )
Console.WriteLine(i);
Şimdi ise program ekranda 1’den 99’a kadar sayıları görüntülüyor. i değişkenin değeri 100’e artırıldığında boolean ifaden yanlış döner ve programın işletimi while döngüsünden bir sonraki ifadeden devam eder.
while döngü gövdesindeki bu farkları özellikle vurguluyorum. Problem genellikle while döngüsünün başlangıç ve bitiş sınırlarının yönetiminde ortaya çıkar. boolean ifadedeki değişkeni nerede ve nasıl değiştireceğini dikkatlice belirlemen gerekiyor. Boolean ifadede kullanılan < yerine <= ve > yerine >= ifadelerini de kullanarak döngünün sonunda ek bir döngü sağlayabilirsin.
Şimdi kira hesabı yapan programımızı tekrar yazalım.
using System;

class KiraHesabi
{
static void Main()
{
int BaslangicYili = 2006;
int BitisYili = 2016;
decimal Kira = 1000;
decimal ArtisMiktari = 5.0m;

while (BaslangicYili <= BitisYili)
{
Console.WriteLine("{0} {1}", BaslangicYili, Kira);
Kira *= (1 + ArtisMiktari / 100);
Kira = Decimal.Round(Kira, 2);
BaslangicYili++;
}
}
}
Bu hesaplama biraz değişik. Kirayı ve yılı ekrana yazdıktan sonra program gelecek yılın kirasını hesaplıyor ve decimal olarak tanımlanmış kira değerinin virgülden sonraki kısmını 2 basamak kalana kadar yuvarlıyor. Programın çıktısı aşağıdaki gibi olur.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Program 2016 yılındaki son kirası hesapladıktan sonra, Kira ve BaslangicYili değerlerini arttırarak bir sonraki döngüye hazırlıyor. Kirayı hiçbir zaman kullanmayacak olmamıza rağmen hesaplıyor. Bu örnekte çok fazla bir yük oluşturmuyor ama daha büyük programlarda problem olabilir.
Programın çıktısına baktığımızda programın 2006 dan 2011 e kadar olanları kiraları hesaplamak için 11 tane WriteLine çağrısı yaptığını fark ederiz. Fakat program bu yıllar arasındaki kiraları hesaplamak için 10 kez hesap yapmaya ihtiyaç duyar. Bunun için while döngüsünün dışında fazladan bir WriteLine çağrısı yaparak bir çözüm oluşturabiliriz.
using System;

class KiraHesabi
{
static void Main()
{
int BaslangicYili = 2006;
int BitisYili = 2016;
decimal Kira = 1000;
decimal ArtisMiktari = 5.0m;

while (BaslangicYili < BitisYili)
{
Console.WriteLine("{0} {1}", BaslangicYili, Kira);
Kira *= (1 + ArtisMiktari / 100);
Kira = Decimal.Round(Kira, 2);
BaslangicYili++;
}
Console.WriteLine("{0} {1}", BaslangicYili, Kira);

}
}
Yeni program çıktısı aşağıda.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Dikkat ederseniz boolean ifadede ki içindeki <= karşılaştırmasını < olarak değistirdim. Böylelikle döngünün içinde en son olarak 2015 yılı için hesap yapılacak. Döngünün altındaki WriteLine çağrısı döngünün içinde önceden hesaplanan 2016 yılının kirasını ekrana yazdırıyor.
Bir diğer varyasyon ise Console.WriteLine ile döngüden önce ilk yılı ve kirasını ekrana yazdırıp daha sonra bu değerleri döngünün içinde arttırarak yazma işlemi yapmak. Yani hesaplama döngünün başında yapılıyor ve WriteLine çağrısı döngünün en altında yapılıyor.
using System;

class KiraHesabi
{
static void Main()
{
int BaslangicYili = 2006;
int BitisYili = 2016;
decimal Kira = 1000;
decimal ArtisMiktari = 5.0m;

Console.WriteLine("{0} {1}", BaslangicYili, Kira);
while (BaslangicYili < BitisYili)
{
BaslangicYili++;
Kira *= (1 + ArtisMiktari / 100);
Kira = Decimal.Round(Kira, 2);
Console.WriteLine("{0} {1}", BaslangicYili, Kira);

}

}
}
Yine çıktısı aşağıda görülüyor.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Bu iki çözüm de ideal değil çünkü ikisi de birbiri ile aynı WriteLine çağrısı içermektedir. Birini değiştirdiğinde diğerini de değiştirmek zorundasın.
Biz bu örnekte olduğu gibi döngünün içinde 11 WriteLine çağrısı ve 10 kez de hesap yapmak istiyorsak döngünün ortalarında bir yerde döngüden çıkmamız gerekiyor. break olarak adlandırılan ifade ile döngünün ortasında döngüden çıkabilirsin. Bu ifade her zaman aşağıdaki şekilde kullanılır.
break;
break ifadesini noktalı virgül takip eder. Bu ifade kullanıldığında döngüden çıkmaya ve programın döngüden bir sonraki ifadeden devam etmesine neden olur. Genellikle break ifadesi bir if bloğu ile kullanılır.
if ( BaslangicYili == BitisYili )
break;
Kira hesabının bir diğer versiyonu aşağıdaki gibi yazıldığında gereksiz bir hesaplamadan bizi kurtarır.
using System;

class KiraHesabi
{
static void Main()
{
int BaslangicYili = 2006;
int BitisYili = 2016;
decimal Kira = 1000;
decimal ArtisMiktari = 5.0m;

while (BaslangicYili <= BitisYili)
{
Console.WriteLine("{0} {1}", BaslangicYili, Kira);
if (BaslangicYili == BitisYili)
break;

Kira *= (1 + ArtisMiktari / 100);
Kira = Decimal.Round(Kira, 2);
BaslangicYili++;
}
}
}
Şimdi while döngüsündeki boolean ifadeyi true kullanarak programın başka bir versiyonunu yazalım. Unutmayın ki break olmadan bu bir sonsuz döngü olacaktır.
using System;

class KiraHesabi
{
static void Main()
{
int BaslangicYili = 2006;
int BitisYili = 2016;
decimal Kira = 1000;
decimal ArtisMiktari = 5.0m;

while (true)
{
Console.WriteLine("{0} {1}", BaslangicYili, Kira);
if (BaslangicYili == BitisYili)
break;

Kira *= (1 + ArtisMiktari / 100);
Kira = Decimal.Round(Kira, 2);
BaslangicYili++;
}
}
}
break gibi while döngüsü içinde kullanılan bir diğer atlama komutu da continue’dur. Genellikle if karar yapısı ile tetiklenir. Bu ifade döngü içindeki arta kalan ifadenin atlanmasını sağlar. Ve program bir sonraki iterasyondan devam eder.
Örneğin, kira hesabı programımızda sonu 0 ile biten yıllarda kiranın artmamasını yani bir önceki yıl ile aynı kalmasını istediğimizi farz edelim. Yani 2010 yılında ki kiranın 2009’daki kira ile aynı kalmasını istediğimizi düşünelim.
Şimdi bir önceki yazdığımız orijinal koda bir bakalım.
while ( BaslangicYili<=BitisYili )
{
Console.WriteLine("{0} {1}", BaslangicYili,Kira);

if ( BaslangicYili == BitisYili )
break;

Kira *= ( 1 + ArtisMiktari/100);
Kira = Decimal.Round(Kira,2);
BaslangicYili++;
}
Bu kodu sihirli 2010 yılı için if ifadesi ile yazmanın bir yolu aşağıdaki gibi olabilir.
while ( BaslangicYili<=BitisYili )
{
Console.WriteLine("{0} {1}", BaslangicYili,Kira);

if ( BaslangicYili != BitisYili )
{
Kira *= ( 1 + ArtisMiktari/100);
Kira = Decimal.Round(Kira,2);
}
BaslangicYili++;
}
if ifadesi 2009 yılının kirası gösterildikten sonraki artışları engeller. Bu nedenle de 2009 ile 2010 yılları arasıdan kira artışı meydana gelmez. Bu işlemi aynı zamandan if ile birlikte continue
while ( BaslangicYili<=BitisYili )
{
Console.WriteLine("{0} {1}", BaslangicYili,Kira);
BaslangicYili++;


if ( BaslangicYili ==2010 )
continue;

Kira *= ( 1 + ArtisMiktari/100);
Kira = Decimal.Round(Kira,2);
}
BaslangicYili değişkenin artırılmasını döngünün başına aldım ve if ifadesini bunun devamına yazdım. Eğer BaslangicYili değişkeni 2010’a ulaşırsa continue ifadesi döngünün bir sonraki iterasyondan devam etmesini sağlayacak. Döngünün için deki son iki ifade bu şekilde atlanmış oluyor.
while döngüsünün bir diğer çeşidi de do döngüsü. while döngüsünün genel ifadesini bir kez daha hatırlayalım.
while ( boolean ifade )
{
// while döngüsünün gövdesi
}
Şimdide do döngüsünün genel ifadesini tanıyalım. do döngüsü aynı zamanda while komutunu da içeriyor.
do
{
// do döngüsünün gövdesi
{
while ( boolean ifade );
do döngüsün en sonunda noktalı virgül olduğuna dikkat edin. while döngüsünde olduğu gibi do döngüsünde de break ve continue ifadelerini kullanabilirsin.
do döngüsünün yapısı boolean ifadeyi döngünün başında değil de sonunda değerlendirir. do döngüsünde gövde boolean ifadeyi dikkate alınmadan en az kez çalışır.
do döngüsü kullanıcıdan giriş alan programlarda kullanışlıdır. Şimdi toplama yapan basit bir program yazalım.
using System;

class TopamaProgrami
{
static void Main()
{
string Cevap;

do
{
Console.Write("Birinci sayıyı gir: ");
double d1 = Double.Parse(Console.ReadLine());

Console.Write("ikinci sayıyı gir: ");
double d2 = Double.Parse(Console.ReadLine());

Console.WriteLine("Toplam : {0}", d1 + d2);

Console.WriteLine("Başka bir toplama yapmak ister misin?(e/h)");
Cevap = Console.ReadLine().Trim();

} while (Cevap.Length > 0 && Cevap.ToLower()[0] == 'e');
}
}
Buradaki string tipindeki Cevap değişkeni neden while bloğu içinde tanımlanmadı diye düşünebilirsiniz. Bunun nedeni; değişkenin bloğun altındaki while ifadesinin içindeki boolean ifadenin içinde kullanılmasıdır.
Bu programın anahtar kısmı do döngüsünün altına yakın yerde ortaya çıkar. Buradaki bir komut kullanıcıya bir tane daha hesaplama yapıp yapmayacağını sorar ve string tipindeki Cevap değişkeni bu cevabı saklar. while ifadesinin içindeki boolean ifade ilk önce Cevap değişkenin uzunluğunun 0’dan büyük olup olmadığını kontrol eder. Eğer öyleyse Cevap değişkenin büyük harflerle yazılmış olmasına karşın değişken küçük harflere çevriliyor ve ilk harfinin ‘e’ olup olmadığına bakıyor. Eğer ilk karakter ‘e’ ise programın işletimi döngünün en başına dönecek ve oradan devam edecek.
boolean ifadenin içindeki Cevap.Length ifadesi kullanıcın sorulan soruya karşılık olarak basitçe enter tuşuna basıp basmadığını kontrol etmek için kullanılıyor. Eğer kullanıcı cevap için sadece enter’e basmış ise Console.ReadLine boş bir string döndürecektir ve bu string’in ilk karakterine ulamaya çalışmak kural dışı bir durum oluşturacaktır. Kullanıcı ‘Y’ veya ‘y’ ile başlayan bir şeyler yazdığında ki yazdıklarında boşluk bıraksa bile program devam edecek. Kullanıcıdan cevabını istediğimizde kullandığımız Trim() fonksiyonu boşluklardan kurtulmamızı sağlıyor.
Tabiî ki program eğer kullanıcı bizim sorduğumuz iki komuta doğru yanıtları vermez ise yani sayıları istediğimiz ve cevabı istediğimiz komutlara diğer tipler değişkenler yazarsa program hata verecektir. Bu hataları nasıl halledeceğimizi başka bir makalede anlatacağız.
Bazen aşağıdaki gibi hatalar yapabiliriz.
while ( i < 100 )
{
// diğer ifadeler
}
while ( i < 101 )
Bu örnekte ilk önce bir while ifadesi yazıyoruz. Daha sonra do döngüsü oluşturduğumuzu düşünüp döngünün sonuna bir while daha yazıyoruz.
while ( i < 100 )
{
// diğer ifadeler
}
Yukarıdaki kısımda i değişkeni döngü bittiğinde muhtemelen 100 değerini alacak olduğundan ikinci kısımdaki
while ( i < 101 )
ifadesi sonsuz bir döngü olacak. Bu program asılı kalacakmış gibi görünüyor. Ve muhtemelen bir çıktı da görüntülenemeyecek.
Ne zaman bir konsol programı asılı kalırsa ctrl+c tuşlarını kullanarak programı durdurabilirsin. Bundan sonra kaynak kodunu tekrar incelemeli ve sonsuz döngü nerede oluşuyor bulmaya çalışmalısın. Eğer kodunda bununla ilgili bir kanıt bulamıyorsan while döngüsünün başına ve sonuna birkaç tane “Burası döngünün girişi”, “Döngü bitiyor” gibi ifadeler içeren WriteLine çağrısı koyabilirsin. Böylelikle programı çalışırken inceleyebilirsin. Bu şekilde fazladan ihtimalleri sınırlamış olursun.
Döngülerin bir diğer yaygın kullanım alanı da dizilerle birlikte kullanımıdır. Şimdi önceden girilen bir sayı dizisinin sayılarının karelerini ve küplerini bula bir programı while döngüsü ile yapalım.
using System;
class KareKub
{
static void Main()
{
int[] SayiDizisi = {10,11,12,13,14,15};

int i = 0 ;

while ( i < SayiDizisi.Length )
{
Console.WriteLine("{0} {1,6} {2,6} " ,SayiDizisi[i], Math.Pow(SayiDizisi[i],3), Math.Pow(SayiDizisi[i],3));
i++;
}
}
}
Burada girilen sayı dizisin içindeki sayıları karelerini ve küplerini alan bir programı yazdık. Dizinin eleman sayısı kadar dönen bir döngü oluşturduk. Programın çıktısı da aşağıdaki gibi oluşuyor

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

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



C# For ve Foreach Döngüleri
For ve Foreach Döngüleri

for ve foreach döngülerinin kullanımını sırasıyla inceleyelim.
for (i = 0; i < hedef; i++)
{
// i değişkeni ile yapılacak işlemler
}
i döngü değişkenine genellikle başlangıçta 0 atanır. Dolayısıyla bir dizinin indekslenmesi ile ilgili işlemlerde kolaylık sağlar.
Çoğu programcı while-do döngüsü kullanmaktansa for dögüsü kullanmayı tercih eder. Hatta bazı yerlerde while-do döngüsünü kullanmak daha uygun olduğu halde for döngüsü kullanırlar.
For döngüsünün de while döngüsünde olduğu gibi karmaşık kullanım şekilleri mevcuttur. Örneğin break ve exit cümlecikleri while döngüsündeki görevinin aynısını for döngüsünde de üstlenmektedir.
For kelimesinden sonra parantez açılmaldır. Parantez içerisine noktalı virgüller ile ayrılmış üç ifade yazılır. Bu ifadeler sırasıyla başlangıç değeri, koşul ve değişim değeridir.
Parantez içindeki üç ifadeden ilki ile döngünün başlangıç değerini belirtiriz. Genellikle tek bir değişken kullanılır, fakat isterseniz aşağıdaki gibi birden fazla değişken için başlangıç değeri atayabilirsiniz.
for (i = 0, j = 17; …… ; ….)
Parantez içindeki ikinci ifade ile koşul durumunu belirtiriz. Bu bölüm boolean türünde kontrol edilir. Şart sağlanmış ise false değeri dönecek ve döngüden çıkılmış olacaktır. Eğer koşul henüz gerçekleşmemiş ise true değerini alır ve döngü işlemeye devam eder.
for (i = 0; false; i++)
{
// işleme alınmayacaktır.
}
Parantez içindeki üçüncü ifade ile değişim miktarını belirtiriz. Başlangıç değerinde olduğu gibi birden fazla değişkenin değişimi eklenebilir.
for (i = 0, j = 100; i < j; i++, j -= 5)
{
// i ve j değişkenleri kullanılabilir
}
Bu üç ifade belirtilirken kullandığımız değişkenlerin başlangıç değerlerini daha önceden atayabiliriz. Aşağıdaki örnek bir önceki ile aynı sonucu verecektir.
j = 100;

for (i = 0; i < j; i++)
{
// i ve j değişkenleri kullanılabilir

j -= 5;
}
İsterseniz bu üç ifade yerini boş bırakıp sadece noktalı virgülleri parantezle içerisinde bırakabilirsiniz.
for (;
Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.

{
// herhangi bir işlem..
}
Bu şekilde sonsuz döngü oluşturabilirsiniz. While döngüsü ile ise sonsuz döngü aşağıdaki şekilde olacaktır.
while (true)
{
// Herhangi bir işlem.
}
Başlangıç değerini belirtirken kullandığımız i değişkeni program içerisinde daha önceden tanımlamadıysanız döngü içerisinde aşağıdaki şekilde belirtmelisiniz.
for (i = 0; i < hedef; i++)
{
// i değişkeni ile yapılan işlemler
}
Örneğin string bir dizi olan sdizi için döngü aşağıdaki şekilde olacaktır.
for (int i = 0; i < sdizi.Length; i++)
{
Console.WriteLine(sdizi[i]);
}
Bu döngüde tek bir ifade olduğundan süslü parantezleri kullanmayabilirsiniz.
Yukarıdaki örneklerde i değişkeninin değeri, eğer döngü herhangi bir sebeple yarıda sonlandırılmadıysa, döngü sonucunda hedef değerine eşit olur.
Eğer C veya C++ dillerini kullanan deneyimli bir programcıya 1 den 100 ’e kadar olan sayıları C# kodu ile ekrana yazdırmasını isterseniz, aşağıdaki şekilde bir sonuç alırsınız:
for (int i = 0; i < 100; i++)
Console.WriteLine(i + 1);
Bu program bloğunda i değişkeni 0 dan 99 ‘a kadar değerleri alıyor. Fakat ekran çıktımızda 1 den 100 ‘e kadar olan sayıları görüntülüyoruz. Üstad programcılar genellikle bu yöntemi kullanırlar. Daha akıllıca bir yazım şekli de şöyledir:
for (int i = 0; i < 100; Console.WriteLine(++i));
Şimdi de herbirinde 20 karakter olan 3 kolon halinde bir dizinin elemanlarını gösterelim.
for (int i = 0; i < sdizi.Length; i++)
if (i % 3 == 2)
Console.WriteLine("{0,-20}", sdizi[i]);
else
Console.Write("{0,-20}", sdizi[i]);
Döngü içersinde tek bir ifade olduğundan süslü parantezleri kullanmadık. If cümleciği, ilk değerin 3 ‘e bölümünden elde edilen kalanın 2 ye eşit olup olmadığını kontrol ediyor. İ değeri yalnız 2,5,8,11 olduğunda bir sonraki satıra geçiyor ve kolonlarımız oluşuyor.
Genellikle bir dizinin elemanlarını karşılaştırmak için for döngüsü kullanırız. Örneğin 30 kişilik yakın arkadaşlarımızın isimlerinden oluşan bir dizimiz var. Kaç arkadaşımızın isminde E harfi yer aldığını hesaplamak istiyoruz:
char[] harfara = {'e', 'E'};
int eharfliler = 0;

for (int i = 0; i < isimler.Length; i++)
if (isimler[i].IndexOfAny(harfara) != -1)
eharfliler++;
Buradaki harfara dizisi char tipinde olup “E” ve “e” karakterlerini içermektedir. If bloğunda String sınıfının bir metodu olan IndexOfAny ile harfara dizisindeki elemanlar karşılaştırılıyor. Eğer isimde herhangi bir e karakteri yer almıyor ise IndexOfAny metodu -1 değerini döndürecektir. Eğer -1 değeri dönmez ise eharfliler değişkeni 1 arttırılıyor.
Eğer bu isimleri başka bir diziye kopyalamak isterseniz :
using System;

class harfarama
{
static void Main()
{
string[] isimler =
{
"Ömer Faruk Demir","Ali Can","Elima Aydın", "Sefa Filiz", "Ebru Sevim"

};
int eharfiler = 0;
char[] harfara = {'z', 'Z'};

// Öncelikle “e” veya “E” harfi olanların sayısını buluyoruz

for (int i = 0; i < isimler.Length; i++)
if (isimler[i].IndexOfAny(harfara) != -1)
eharfliler++;

// yeni bir string dizi oluşturuyoruz

string[] eisimler = new string[eharfliler];

// Bir diziden diğer diziye kopyalama işlemini yapıyoruz

for (int i = 0, j = 0; i < isimler.Length; i++)
if (isimler[i].IndexOfAny(harfara) != -1)
eisimler[j++] = isimler[i];



// Yeni oluşan dizimizi ekrana yazdırıyoruz

for (int i = 0; i < eisimler.Length; i++)
Console.WriteLine(eisimler[i]);
}
}
Bu programda üç adet for döngüsü yer alıyor. İlk döngü yukarı da incelediğimizin aynısı, isimleri sayıyor. Program isminde E harfi olanların yer aldığı dizinin uzunluğunu hesaplıyor. İkinci döngü ile kopyalama işlemi gerçekleştiriliyor. Son döngü ile de yeni oluşan dizimiz ekrana yazdırmak için kullanılıyor.

Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Bir dizinin tüm elemanlarına erişmek için foreach döngüsü daha pratik olacaktır. Decimal tipte bir dizinin tüm elemanlarını foreach döngüsü kullanarak toplayalım:
decimal mtoplam = 0;

foreach (decimal m in mdizi)
{
mtoplam += m
}
foreach cümleciğinden sonra parantezler içerisine erişeceğimiz dizinin tipinde bir değişken tanımlıyoruz.Daha sonra dizimizin adını yazarak son elemana kadar döngünün sürdürülmesini sağlıyoruz. foreach döngüsünün bazı sınırlılıkları vardır. Örneğin döngü içerisinde dizinin herhangi bir elemanına ulaşamazsınız. foreach döngüsü yalnız döngülerde kullanılmaz. Örneğin string bir değişkenin elemanlarını (karakterlerini) ekrana yazdıralım:
foreach (char karakter in str)
Console.WriteLine(karakter);

 
Alıntı ile Cevapla

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



C# İstisna ve Hata Yakalama
İstisna ve Hata Yakalama

C# ile uğraşmaya başladığımızdan beri bir çok çalışma zamanı hataları ile karşılaşıyoruz. Örneğin bir intereger değişkeni 0’a bölemeye çalıştığımızda karşılaştırdığımız hata. Hatalar sınıflar tarafından tanımlanır. Örneğin DivideByZeroException (Sıfıra bölünme hatası) sınıfı. Temel hata sınıflarının büyük bir kısmı System isim uzayında tanımlanır.
Eğer taşma kontrolü açıksa taşma olduğunda OverflowException (taşma hatası) meydana gelir. Daha öncede anlattığımız bir çok programda klavyeden girilen değerleri bir integer değişkene atarken Parse metodunu kullandık. Eğer klavyeden girilen değerler sayılsal olmayan değerler içeriyorsa o zaman bir FormatException ( Biçim hatası ) meydana gelir. Bir Parse metodu ile string değişkenine bir null değer atanırsa bir ArgumentNullException (Null argüman hatası ) gelişir. Eğer bir dizinin sınırlarının dışında bir indeksleme yapamaya çalışırsanız veya uzunluğunun dışında bir atama yaparsanız IndexOutOfRange hatası meydana getirirsiniz. C# dokümantasyonu her zaman hangi hatanın hangi metot da gelişeceğini belirler.
Biz burada şimdiye kadar hatanın gelişiminden bahsettik. C# dilinde bu olay için aynı zamanda C#’ta bir anahtar kelime olan throw kullanılır.
Kullanıcıya göre bir hata meydana geldiğinde programımız çökmüştür, patlamıştır. Neyse ki Windows’u da yanında götürmemiştir. (Biliyorsunuz 90’larda değiliz) Kullanıcıların programımızın çöktüğünü görmesini istemezsiniz. Aynı zamanda sizin mükemmel olmayan kodlar yazmada kabiliyetli olduğunuzu bilmelerini de istemezsiniz. Bu durumda programımızın en önemli avantajı program tarafından fırlatılan hataları nazikçe geri çevirmesi olur. Bu nazik geri çevirme için programın fırlatılan hataları yakalaması fırlatılan bu hata ile bir şeyler yapması ve sonra programımızın mutlu yoluna devam etmesi gerekiyor.
Hata fırlatma ve yakalama durumları, programın çalışma zamanında meydana gelen problemleri halletmede göz önünde bulundurulan yapısal hata ayıklamanın tamamını oluşturur. Şimdi Decimal.Parse metodunu düşünelim. Bu metot bir string argüman gerktirir ve bir decimal değer döndürür. Fakat ya aldığı bu argüman harfler ve nümerik olmayan karakterler içeriyorsa? Eski gönlerde bu metot nümerik olmayan karakterleri göz ardı edecekti. Ya da iki değer döndürecekti, diğer çevirme işleminin düzgün gidip gitmediğini kontrol belirleyecek boolean olacaktı. Bazı teknikler asla sürekli olarak tamamlanmadı. Fakat yapısal hata ayıklama ile Decimal.Parse bize “Ben bu girdi ile işlem yapamıyorum, ve gerisi senin problemin” diyen bir hat fırlatır.
Programın istisnanın kullanıcıya gösterilmesini veya istisnanın kendi kendine halledilmesini sağlayabilir. Eğer son bahsedilen seçenek yani programın hatayı kendi halletmesi seçeneği sana daha çekici geliyorsa try ifadesini kullan. try ifadesini kullanmanın en kolay yolu try anahtar kelimesi ile başlayıp ardından hata fırlatabilecek ifadeyi kapsayan bir çift süslü parantez kullanmaktır. Bu hatayla uğraşacak diğer blok olan catch ifadesi tarafında takip edilir.
Örneğin programımızın kullanıcı tarafından girilen bir string’i okuduğunu ve bunu aşağıdaki ifadeyi kullanarak double bir ifadeye çevirdiğini düşünelim
Double dDeger = Double.Parse(Console.ReadLine());
Parse metodu tarafından fırlatılan herhangi bir hatayı yakalamak için ifadeyi aşağıdaki ifade ile değiştirebilirsiniz.
Double dDeger;

try
{
dDeger = Double.Parse(Console.ReadLine());
}

catch
{
Console.WriteLine(“Geçerli olmayan bir numara girdiniz”);
dDeger = Double.NaN;
}
İlk önce dDeger değişkenin tanımlanma ve atanma kısımlarının ayrı olduğuna dikakt etmişsinizdir. Eğer dDeger değişkeni try bloğunda tanımlansaydı try bloğunun dışındaki herhangi bir yerde geçerli olmayacak ve catch bloğunda bu değişkene atıfta bulunulamayacaktı.
Eğer Double.Parse metodu girilen string’i double’a çevirme işleminde başarılı olursa program catch bloğundan sonra takip edilen ifadeden çalışmaya devam edecekti. Eğer Parse metodu bir hata fırlatırsa catch bloğu onu yakalar. catch bloğundaki ifade işletilir ve bundan sonra programın normal işletimi catch bloğunu takip eden ifadeden işletilmeye devam eder. Dikkat edersek catch bloğu bir mesaj gösterir ve dDeger değişkenine NaN değerini atar. Muhtemelen catch bloğunu takip eden kod dDeger değişkenini NaN değerine eşitler ve kullanıccan tekrar bir değer girmesini ister.
Kullanıcıdan nümerik değerler okuyan bir programda muhtemelen tyr ve catch bloklarını parse metodunu geçene kadar kullanıcıdan değerleri tekrar girmesini isteyen bir do döngüsünün içine koyarız. Aşağıda tam olarak bunu yapan bir metod içeren bir program görüyorsunuz.
using System;

class DoubleGiris
{
static void Main()
{
double dTaban = DoubleSayiAl("Taban sayıyı Gir:");
double dUst = DoubleSayiAl("Üst sayıyı gir:");
Console.WriteLine("{0} 'nin {1}. kuvveti = {2}",dTaban,dUst,Math.Pow(dUst,dTaban));
Console.ReadLine();

}

static double DoubleSayiAl(string ifade)
{
double dDeger = Double.NaN;

do
{
Console.Write(ifade);
try
{
dDeger = Double.Parse(Console.ReadLine());
}
catch
{
Console.WriteLine();
Console.WriteLine("Geçersiz bir sayı girdiniz");
Console.WriteLine("Lütfen Tekrar Giriniz");
Console.WriteLine();
}
}
while( Double.IsNaN(dDeger) );
return dDeger;

}


}

DoubleSayiAl metodu bir string parametresi alıyor ve bir double değer döndürüyor. Metot dDeger değişkenini tanımlayarak ve NaN degeri atayarak başlıyor. do döngüsü bunu takip ediyor. string parametresini komut gibi görüntüleyerek başlıyor ve girilen string değeri bir double değere çevirme denemeleri yapıyor.
Eğer bir istisna meydana gelirse metot kullanıcıya bir mesaj gösteriyor. do döngüsünün sonunda Double.IsNaN statik metodu true değeri döndürür, bu nedenle programın işletimi do döngüsünün başına dönerek oradan devam ediyor ve komutlar tekrar görüntüleniyor.
Eğer parse başarılı bir şekilde değer döndürürse programın işletimi catch bloğundan sonra gelen ifadelerden devam eder. Double.IsNaN metodu false değeri döndürür ve DobuleSayiAl metodu dDeger değişkenini main metoda döndürür.
Tabiî ki DoubleSayiBul metodu birçok basit Parse çağrısı yapıyor. Bu main metodu daha basit hale getirmek adına ödenmiş bir bedel. Ve tabiî ki kullanıcının programın pike yaptığını görme fırsatı olmuyor.
Parse ifadesinin hata fırlattığında normalde yaptığı işleri yapmayacağını fark etmek önemli. Programın işletimi parse metodunun derinlerine bir yerlerden catch ifadesine doğru devam eder. Eğer dDeger değişkenini NaN ile ilişkilendirmezsen catch ifadesi işletilirken dDeger ilişkilendirilmemiş olacak.
double yerine decimal tipteki değerlerle çalışıyorsan, geçerli bir değer girilemediğinde değişkeni NaN değerine eşitlemek zorunda değilsiniz. Bunun yerine kullanıcının bir sayı değeri girmeye fırsatı olmadığını varsayarak decimal değişkeni mümkün olan minimum değerle ilişkilendirmelisin (Decimal.MinValue) ve bu minimum değeri karşılaştırmalısınız.
while ( mDeger != Decimal.MinValue )

Yada adı bGecerliDegeriAl olan ve false değeri alan sadece try bloğunun içinde Parse metodunun çağrısından sonra true değeri alan bir boolean değişkenle ilişkilendirmelisiniz.
try
{
dValue = Double.Parse(Console.ReadLine() );
bGecerliDegeriAl = true;
}

Sonra da do döngüsünün sonunda bu değeri kullanırsın

while ( ! bGecerliDegeriAl ) ;

DoubleGiriş programının içinde kullanılan catch ifadesi genel catch ifadesi olarak bilinir. try bloğunun içinde herhangi bir istisna meydana gelirse bu ifade yakalayacak. Bunun yerine özel bir tür istisna için bir catch ifadesi belirleyebilirsiniz.
try
{
// denenecek durum ve ya durumlar
}
Catch ( Exception exc )
{
//hata işlemi
}

catch anahtar kelimesini bir metodun parametrelerine benzeyen parantezler bir değişken tanımlaması takip ediyor. Exception System isimuzayı (namespace) içinde tanımlanmış bir sınıf ve exc de ( istediğiniz herhangi bir başka ismide verebilirsiniz ) Exception tipinde bir nesne olmak için tanımlanmış. catch bloğu ile bu Exception nesnesini kullanarak hata hakkında daha fazla bilgi elde edebilirsiniz. Aşağıdaki örnekteki gibi Message özelliğini kullanabilirsiniz.
Console.WriteLine(exc.Message);
Bu yazının başında gösterilen programda bu Message özelliği kullanılırsa aşağıdaki gibi bi uyarı olacaktı.
Girilen String doğru formatta değil
Eğer kullanıcı örneğin numaralar yerine harf girerse uyarı aşağıdaki gibi olacaktı.
Değer Double için çok küçük veya çok büyük
Bu hata eğer bilimsel gösterimlerdeki gibi çok büyük veya çok küçük sayılar girildiğinde ortaya çıkabilir. Bunlar gibi kendiniz mesaj yazmak yerine bu Message özelliğini kullanarak mesajlar yazdırabilirsiniz.
Eğer WriteLine metoduna Exception nesnesini doğrudan gönderirseniz
Console.WriteLine(exc.Message);
gibi
etkin olarak ToString metodunu çağırabilirsiniz. O zaman bütün bir detaylı istisna mesajını görebilirsiniz.
Console.WriteLine(exc.ToString());
Her ne kadar catch bloğu Exception nesnesi ile özel catch ifadesi olarak sınıflandırılsa da, bilinen catch ifadesinin genelleştirilmişidir. Çünkü bütün farklı istisna sınıfları (Sınıfra bölünebilme hatası, Taşma hatası, ve diğerleri ) Exceprion sınıfının başında bir hiyerarşi ile tanımlandı. Diğer bütün istisnalar Exception sınıfından miras alındı. Diğer makalelerde miras hakkında daha fazla bilgi bulabilirsiniz. Şimdilik herhangi bir tip istisnayı temsil eden Exception sınıfını düşünebilirsin. Diğer sınıflar Exception sınıfından alınmış daha özel miraslardır.
Double sınıfmın Parse metodu üç istisnadan birini ortaya çıkarabilir: FormatException (harf yazıldığında), OverflowException (Sayı çok büyük veya çok küçük olduğunda), veya ArgumentNullException (Parse edilen argüman Null Olduğunda). Aşağıda bu üç özel istisnanın üstesinden gelmek için verilmiş bir örnek var.
try
{
dDeger = Double.Parse(Console.ReadLine());
}
catch (FormatException exc)
{
//FormatException hatası ile ilgili kodlar
}
catch (OverflowException exc)
{
//OverFlowException hatası ile ilgili kodlar
}
catch (ArgumentNullException exc)
{
//ArgumentNullException hatası ile ilgili kodlar
}
catch (Exception exc)
{
//Diğer bütün hatalar ile ilgili kodlar
}

Catch ifadeleri hatalarla eşleşme durumlarına göre birincisinden itibaren sıra ile incelendi. Son catch ifadesi hiçbir parametresi olmayan genel bir ifade olabilir. Aynı şekilde eğer özel tip istisnalar ile çalışıyorsan her zaman diğer özel bir şekilde ilgilenilmeyen istisnalar içinde genel bir catch ifadesi yazmalısınız.
Yukarıdaki özel örnekte Double.Parse metodunu kullandığımızda en son catch bloğu hiçbir zaman işletilmeyecek. Çünkü metodundan doğabilecek olan her istisna ile özel olarak halledildi. Üstelik ArgumentNullException hatası bile hiçbir zaman ortaya çıkmayacak çünkü Console.ReadLine metodundan asla Null değeri dönmez. Fonksiyonel olmayan catch ifadelerinden zarar gelmez.
try ifadesinin içinde kullanabileceğin finally olarak cağırılan üçüncü bir ifade daha var. finally ifadesi catch ifadelerinden sonra aşağıda gösterildiği şekli ile gelir.
finally
{
// finally bloğu içerisindeki ifadeler
}
finally bloğunun içindeki ifadeler try ifadesinden sonra ( eğer istisna fırlatılmadıysa ) veya catch ifadesinden sonra çalışması garanti edilmiş ifadelerdir. Finally ifadesi ilk karşılaştığınızda karışık gelebilir. Böyle bir şey neden gerekli sorusu akla gelebilir. Eğer try bloğunda bir istisna meydana gelmediyse programın işletimi catch bloğundan sonraki ifadeden normal bir şekilde devam edecek. Eğer bir istisna meydana gelirse program catch bloğuna gidecek ve ondan sonra catch bloğundan sonra gelen ifadelerden devam edecek. Eğer try ve catch bloklarından sonra iletilecek herhangi bir kod yazmak istiyorsam neden bu kodu catch bloğundan sonraya yerleştirmiyorum? Neden finally bloğunu kullanıyorum diye düşünebilirsiniz.
Bu karmaşıklığın çözümü basit: try ve catch blokları bir controle dönmek için bir return ifadesi içerebilir veya (eğer metot Main metot ise ) programı sonladırablir. Bu durumda try ifdesnin en sonundaki catch ifadesi işletilemeyecek. İşte finally ifadesi bize burada yardımcı oluyor. Eğer try ya catch ifadeleri bir return içeriyorsa her dururumda da finally bloğunun çalışması garanti ediliyor.
Genellikle finally ifadesi temizlik yapmak için kullanabilirsin. Örneğin eğer programında bir dosya yazarken hata meydana geldiyse finally bloğu programı herhangi bir tamamlanmamış durumda bırakmamak için dosyayı kapatabilir ve silebilir.
catch ifdesi olmadan da bir finally ifadesi kullanabilirsin. try ifadesinin üç farklı kullanım şeklini aşağıda görüyoruz.
• try bloğu, bir veya birdan fazla catch bloğu
• try bloğu, bir veya birdan fazla catch bloğu, finally bloğu
• try bloğu, finally bloğu
Son yapılandırma da program her hangi bir hata yakalamaz. Kullanıcı bir mesajla bilgilendirilir ve program sonlandırılır. Fakat program sonlandırılmadan finally bloğu çalıştırılır.
Şimdi hataların nasıl yakalandığını biliyorsun. Nasıl fırlatıldığını da bilmelisin. Eğer çeşitli sıralamalar yapan ve hata meydana getirebilecek bir metot yazıyorsan, genel olarak metodun problemleri meydana getirecek olan kodlar çağırıyor olduğunu fark etmesi için bir hata fırlatmasını istersin. throw ifadesi aşağıdaki kadar basit olabilir.
throw;
fakat throw ifadesinin bu basit formu istisnayı tekrar fırlatması için catch bloğunun içinde kullanılır.
Eğer bir istisnayı tekrar fırlatmıyorsan, throw ifadesinin içine bir argüman yerleştirmelisin. Bu argüman Exception sınıfının bir örneği veya kendi oluşturduğun indirgenmiş bir sınıfıdır.
throw new Exceptinon();
new deyimi Exception sınıfının bir örneği olan bir yapıcıyı içerir. Fakat gerçektende throw değiminde Ecception sınıfının bir örneğini kullanamazsın, çünkü o sana ne çeşit bir hata olduğunu söylemez. Bir veya birden fazla özel istisna kullanmalısınız. Çok sıklıkla System isimuzayının içinde senin ihtiyacın olan ne ise ona daha yakın olan indirgenmiş istisnalar bulacaksınız. Örneğin senin metodun bir string parametre içeriyorsa ve null bir argüman gönderildiğinde çalışmıyorsa muhtemelen aşağıdaki gibi bir kod yazarsınız.
İf ( strGir == null )
Throw new ArgumentNullException;
Bu ArgumentNullException yapıcısına bir string argüman da gönderebilir. Argüman probleme neden olan özel bir metot parametresini gösterebilir:
if (strgir == null )
Throw new ArgumentNullException(“Giriş stringi”);
Yapıcıya gönderdiğin bu string bu istisna ile uğraşan catch ifadesine uygun olan istisna mesajının bir parçasına dönüşecek.
throw ifadesinin işletiminden sonra metodun bittiğini tekrar vurgulayalım. Bundan sonraki kodlar işletilmeyecek. Bu if den sonraki bir else ifadesinin bir anlam ifade etmeyeceğini gösteriyor.
if (strgir == null ) Throw new ArgumentNullException(“Giriş stringi”); else { //istisna fırlatılmazsa bir şeyler yap }
}
Throw ifadesi içeren bir if ifadesinden sonra diğer kodları basitçe devamına yazabilirsiniz.
if (strgir == null )
Throw new ArgumentNullException(“Giriş stringi”);

//istisna fırlatılmazsa bir şeyler yap

interger’lar için bir Parse metodu yazalım. Nispeten basit olması için, negatif değerlere izin verilemesin. Normal Parse metodu gibi MyParse metodu üç tip istisna fırlasın: Eğer argüman null ise ArgumentNullException, eğer girilen değerler satır değil de harfler içeriyorsa FormatException veya eğer bir interger için uygun olmayan sayılar girilmişse OverflowException.
using System;

class HataFirlatma
{
static void Main()
{
int iGir;

Console.WriteLine("İşaretsiz bir sayı gir:");

try
{
iGir = MyParse(Console.ReadLine());
Console.WriteLine("girilen Deger:{0}", iGir);
}
catch (Exception exc)
{
Console.WriteLine(exc.Message);
}
}
static int MyParse(string str)
{
int iSonuc = 0, i = 0;

//eğer argüman null ise bir hata fırlat
if( str == null )
throw new ArgumentNullException();

//girilen degerde boşluklar varsa onları temile
str = str.Trim();

//en az bir karakter girilip girilemdiğini kontrol et
if ( str.Length == 0 )
throw new FormatException();

//stirngin içindeki bütün karakterleri dön
while ( i < str.Length )
{
//eğer karakterler sayı değilse bir hafa fırlat

if( !Char.IsDigit(str,i) )
throw new FormatException();

//bir sonraki haneyi hesapla ( "chacked" e dikkat et)
iSonuc = checked(10 * iSonuc + (int)str[i] - (int)'0');

i++;
}
return iSonuc;
}
}
MyParse metodu ilk önce trim metodu ile girilen değerin başındaki ve sonundaki whitespace denilen boşlukları siliyor. Sonra while döngüsünü kullanarak girilen stirng içindeki bütün karakterleri dönüyor. Eğer karakter IsDigit testini geçerse metot iSonuc değerini 10 ile çarpıyor ve Unicode den nümerik bir değere çevrilmiş yeni bir basamak ile topluyor. MyParse metodu açıkça bir OverflowException fırlatmıyor. Onun yerine normal bir taşma hatası üretmek için chacked ifadesinde bir hesaplama icra ediyor. Main metot MpParse metodu ile fırlatılan bir hatayı yakalamayı tecrübe etmenizi sağlıyor.


 
Alıntı ile Cevapla

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



C# Durumsal Operatörler
Durumsal Operatörler

Şöyle bir program yazdığımızı düşünelim;
Evimize gelen her misafirin üç kurabiye yiyeceğini varsayan ve buna göre misafirlere yetecek kurabiye sayısını hesaplayan bir program. Bu program aşağıdaki gibi bir kod içerebilir.
if (KurabiyeSayisi / MisafirSayisi < 3)
{
DahaFazlaKurabiyeYap();
}
Bu kodu inceledikten sonra DahaFazlaKurabiyeYap metodunun tam olarak ne yaptığını merak edebiliriz. Otomatik olarak misafir sayısına göre kurabiye yapıyor olabilir.
Ama eğer ya hiç misafir gelmesse? O zaman MisafirSayisi değişkenimiz 0 olcak ve bizde sıfıra bölüm hatası alacağız. Bununla beraber eğer hiç misafirimiz gelmesse bloğun içindeki kodun işletilmesini de istemeyiz. İlk yaklaşımımız şu olabilir; if ifadesi içindeki MisafirSayisi değişkenini kontrol ettirebiliriz.
if (MisafirSayisi > 0 & KurabiyeSayisi / MisafirSayisi < 3)
{
DahaFazlaKurabiyeYap();
}
Amacımıza biraz yaklaştık. MisafirSayisi değişkenimizin değeri sıfır olsa bile bölümün hala gerçeleştirileceğine dikkat edin. Ve sıfıra bölüm harasının meydana gelecek. Eğer MisafirSayisi değişkeni sıfır ise bölümü engellemek için ne yapmalıyız? Bir diğer yaklaşımda Boolean ifadeyi iç içe geçmiş iki parçaya ayırmak olabilir.
if (MisafirSayisi > 0)
{
if (KurabiyeSayisi / MisafirSayisi < 3)
{
DahaFazlaKurabiyeYap();
}
}
Bu işe yarayacaktır. Birinci if ifadesinde MisafirSayısı sıfıra eşitse ikinci if ifadesi işletilmeyecektir.
Bir diğer yaklaşım ise Durumsal VE operatörü kullanmaktır. Bu operatör bu gibi durumlarda kullanılmak üzere dizayn edildi. Normal VE operatörünün bir tane “&” işaretinden oluştuğunu biliyoruz. Durumsal VE operatörü ise “&&” ’dir.
if (MisafirSayisi > 0 && KurabiyeSayisi / MisafirSayisi < 3)
{
DahaFazlaKurabiyeYap();
}
Operatörün sağındaki kısım solundaki kısımdan True ifadesi dönmedikçe işletilmeyecektir. Bunun dışında Durumsal VE operatörü normal VE operatörüne benzer. MisafirSayısı değişkeninin sıfır olduğunu düşünelim. MisafirSayisi>0 ifadesinden False değeri dönecektir. False değerinden sonra gelen operatör Durumsal VE operatörü olduğu için operatörün sağındaki kısım her ne olursa olsun asla işletilemeyecektir. Bütün Boolean ifdenin sonucu asla True olmayacaktır. Operandın sağındaki ifadelerin işletilmesine gerek yoktur. Eğer MisafirSayisi 0 ise Bölüm asla gerçekleşmeyecektir.
Şimdi normal VE operatörünü inceleyelim
BooleanIfade1 & BooleanIfade2
Burada ifadelerinin ikisininde herzaman işletileceği unutulmamalıdır.
BooleanIfade1 && BooleanIfade2
Bu kodda ise BooleanIfade1’den false değeri dönerse BooleanIfade2 asla işletilmeyecektir.
Durumsal VE ye benzer olarak Durumsal VEYA iki dik çizgiden oluşur. (||)
if (MisafirSayisi > 0 || KurabiyeSayisi / MisafirSayisi < 3)
{
KurabiyeYapma();
}
Bu kod bloğuda içinden aynı mantığı döndürür. Eğer hiç misafir yoksa veya misafir başına en az 3 kurabiye varsa kurabiye yapılmamalıdır. Eğer Durumsal VEYA operatörünün solundaki ifade true değeri döndürüyorsa sağındaki ifadeye bakmaya gerekyoktur. Çünkü herşeye rağmen bütün ifade true olacaktir.
if ( BooleanIfade1 || BooleanIfade2 )
{
//Kodlar
}
Üsteki kodda BooleanIfade1 true ise BooleanIfade2’den ne döndüğüne bakılmaksızın Kodlar kısmı işletilecektir. BooleanIfade1 false, ve BooleanIfade2 true ise yine kodların işletileceğine dikklat edelim.
C ve C++ dilinden gelen birçok C# programcısı gereksiz kodların işletilmesini engellemek için normal VE ve normal VEYA durumsal operatörleri yerine Durumsal VE ve Durumsal VEYA operatörlerini kullanmaya meyillidirler. Şimdi artık yıl hesabı yapan bir kod parçasını durumsal operatörlerle yazalım. Boolean bir AtikYil değişkenimiz olsun. True için artık yıl olduğunu False için olmadığını temsil edecek. Birde integer bir Yil değişkenimiz olsun. Şimdi kodumuzu yazalım.
ArtikYil = Yil % 4 == 0 && ( Yil % 100 != 0 || Yil % 400 == 0 );
Eğer Yil değişkeni 4’e bölünemiyorsa asla artık yıl olamaz. Ve && operatörünün sağındaki kısım asla işletilmez.
C# C’den kalan adına “Durumsal Operatör” denilen gerip bir mirası da destekler. Tek bir operandı bulunan tekli operatörleri, iki operatörü bulunun çiftli opertörleri biliyoruz. C’deki bu “Durumsal Operatör” C#’daki tek üçlü operatördür. Üç operand bir soru işareti (?) ve ikinokta üstüste (
Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
operatörleri ile ayrılır. Ve ifade aşağıdaki gibi olur
BooleanIfade ? A : B ;
A ve B aynı tipte ifadeler olmalıdır ( yada birbirine çevililebilen ). BooleanIfade değişkeni true ise yukarıdaki ifadenin sonucu A, eğer BooleanIfade değişkeni false ise yukarıdaki ifadenin sonucu B’dir. Bir örnekle açıklayalım. ArtikYil diye bir boolean değişkenimiz olsun.
ArtikYil ? 29 : 28;
Eğer ArtikYil değilkeni true ise bu ifadenin sonucu 29, eğer ArtilYil değişkenin değeri false ise yukarıdaki ifadenin sonucu 28’dir. Şöyle düşünelim. Artık yıllarda Şubat ayında 29 gün vardır. Diğer yıllarda ise 28 gün vardır. Eğer içinde bulunduğumuz yıl artıl yıl ise (ArtikYil=true) Şubat ayı 29 gündür. Eğer içinde bulunduğumuz yıl artık yıl değilse (ArtikYil=false) Şubat ayı 28 gündür. Yukarıda yazdığımız ifadeyi bir atama işleminde de kullanabilir. SubatGunSayisi diye bir integer değerimiz olsun.
SubatGunSayisi = ArtikYil ? 29 : 28;
Burada eğer artık yılda isek SubatGunSayisi değişkenine 29, değilsek 28 değeri atanıyor. Yukarıda anlatılanları bu örnekte daha kolay anlıyor.
Durumsal operatörler alternatiflerine göre oldukça rahatlık sağlıyor
if ( ArtikYil )
SubatGunSayisi = 29;
else
SubatGunSayisi = 28;
Boolean değişkenler yerine boolean ifadeler de kullanılabilir.
Bonus = Satis >= 1000 ? 100 : 50;
Bu ifadede yapılan satıs 1000 YTL den büyükse 100 YTL bonus, eğer satış 1000 YTL’den az ise 50 YTL bonus verileceği gösteriliyor.
Durumsal operatörler atama operatörleri hariç geri kalan operatörlerden daha düsük önceliğe sahiptirler. Yukarıdaki operatörler içinde en yüksek önceliğe sahip olan Satis >= 1000 ifadesidir. Fakat yinede kendimiz daha rahat hissetmek için Durumsal operatörleri parantez içine almak isteyebiliriz.
Bonus = (Satis >= 1000 ? 100 : 50);
Veya iki parantez de kullanabiliriz.
Bonus = ((Satis >= 1000) ? 100 : 50);
Durumsal operatörler kesinlikle koddan kazanmayı sağlarlar. Bu kolayca suistimal edilebilir. Özellikle de iç içe geçmiş durumsal operatörler kullanıldığında. Kaçıncı ayda olduğumuza göre içinde bulunduğumuz ayın gün sayısını döndüren aşağıdaki ifade buna örnektir. Kaçıncı ayda olduğumuzu tutan integer bir iAy değişkeni, Gun sayisini tutan integer bir iGunSayisi değişkeni, Artık yılda oluğ olmadığımızı gösteren boolean bir bArtikYil değiskeni tanımladığımızı varsayalım.
GunSayisi = Ay == 4 || Ay == 6 || Ay == 9 Ay == 11 ? 30 :
Ay != 2 ? 31 : ArtikYil ? 29 : 28 ;
Yukarıdaki kodu gerçekten okumak çok zor. Bu gibi kullanımlardan kaçınmalıyız. Bu daha sonra kodumuzu okumaya çalıştığımızda yada başkaları okumaya çalıştığında başımızı ağrıtabilir.

 
Alıntı ile Cevapla

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



C# Nedir?
C# diline kısa bir bakış:

C#, güçlü, modern, nesne tabanlı ve aynı zaman type-safe(tip-güvenli) bir programlama dilidir.Aynı zamanda C#, C++ dilinin güçlülüğünü ve Visual Basic' in ise kolaylığını sağlar.Büyük olasılıkla C# dilinin çıkması Java dilinin çıkmasından bu yana programcılık adına yapılan en büyük gelişmedir. C#, C++ 'ın gücünden , Visual Basic 'in kolaylığından ve Java 'nın da özelliklerinden faydalanarak tasarlanmış bir dildir. Fakat şunu da söylemeliyiz ki, Delphi ve C++ Builder 'daki bazı özellikler şimdi C# 'da var. Ama Delphi ya da C++ Builder hiçbir zaman Visual C++ ya da Visual Basic 'in popülaritesini yakalayamamıştır.

C ve C++ programcıları için en büyük sorun, sanırım hızlı geliştirememedir. Çünkü C ve C++ programcıları çok alt seviye ile ilgilenirler.Üst seviyeye çıkmak istediklerinde ise zorlanırlar.Ama C# ile artık böyle bir dert kalmadı.Aynı ortamda ister alt seviyede isterseniz de yüksek seviyede program geliştirebilirsiniz.C# dili Microsoft tarafından geliştirilen .NET paltformunun en temel ve resmi dili olarak lanse edilmiştir.C# dili Turbo Pascal derleyicisini ve Delphi 'yi oluşturan takımın lideri olan Anders Heljsberg ve Microsoft'da Visual J++ takımında çalışan Scott Wiltamuth tarafından geliştirilmiştir.

.NET framework'ünde bulunan CLR (Common Language Runtime), JVM (Java Virtual Machine)' ye, garbage collection, güvenilirlik ve JIT (Just in Time Compilation) bakımından çok benzer.

CLR, .NET Framework yapısının servis sağlama ve çalışma zamanının kod organizasyonu yapan ortamıdır. CLR, ECMA standartlarını destekler.

Kısacası C# kullanmak için CLR ve .NET Framework sınıf kütüphanesine ihtiyacmız vardır. Bu da demek oluyor ki C#, JAVA, VB ya da C++ değildir. C,C++ ve JAVA 'nın güzel özelliklerini barındıran yeni bir programlama dilidir. Sonuç olarak C# ile kod yazmak hem daha avantajlı hem daha kolay hem de etkileyicidir.


SanaLBilgisayarKursun'ndan Alıntıdır.
 
Alıntı ile Cevapla

Alt 05 Temmuz 2009, 07:06   #30
Çevrimdışı
Kullanıcıların profil bilgileri misafirlere kapatılmıştır.
IF Ticaret Sayısı: (0)
IF Ticaret Yüzdesi:(%)
Cevap: C# Hakkında Herşey.



sabaha kadar okudum
Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
okumak yetmiyor ama eline sağlık biraz bi kaç şey anladım gibi gibi
Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
güzel paylaşım..

 
Alıntı ile Cevapla

Cevapla
Sayfa 3 Toplam 3 Sayfadan 12 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