C# Programlama Dili: 15.Olaylar ve Delegeler

C# programlama dilinde olaylar (events) ve delegeler (delegates), nesne yönelimli programlamanın temel taşlarından biridir. Bu yapılar, bir nesnenin durumundaki değişiklikleri diğer nesnelere bildirmesini sağlayarak, gevşek bağlı (loosely coupled) sistemlerin oluşturulmasına olanak tanır. Bu makalede, C# dilindeki olaylar ve delegeleri detaylı bir şekilde inceleyeceğiz.

Delegeler (Delegates)

Delegeler, fonksiyon işaretçilerine benzer ve metotları değişkenler gibi kullanmamızı sağlayan yapılardır. Bir delege, belirli bir imza (signature) ile tanımlanır ve aynı imzaya sahip herhangi bir metodu referans edebilir. Bu, delegelerin, metotları parametre olarak geçirmemize, metotları bir koleksiyonda saklamamıza veya çalışma zamanında hangi metodun çağrılacağını belirlememize olanak tanır.

Delege Tanımlama

Bir delege tanımlamak için delegate anahtar kelimesi kullanılır. Delege tanımı, referans edeceği metodun dönüş tipini ve parametre listesini belirtir.

 // Basit bir delege tanımı
 public delegate void MesajYaz(string mesaj);

Bu örnekte, MesajYaz adında bir delege tanımlanmıştır. Bu delege, string türünde bir parametre alan ve void (geri dönüş değeri olmayan) bir metodu referans edebilir.

Delege Örneği

Aşağıdaki örnek, bir delegenin nasıl kullanılacağını göstermektedir:

 using System;

 public class Program
 {
   public delegate void MesajYaz(string mesaj);

   public static void SelamVer(string mesaj)
   {
     Console.WriteLine("Selam: " + mesaj);
   }

   public static void GuleGule(string mesaj)
   {
     Console.WriteLine("Güle Güle: " + mesaj);
   }

   public static void Main(string[] args)
   {
     MesajYaz delege1 = new MesajYaz(SelamVer);
     MesajYaz delege2 = new MesajYaz(GuleGule);
  
     delege1("Dünya"); // Output: Selam: Dünya
     delege2("Yine Bekleriz"); // Output: Güle Güle: Yine Bekleriz
  
     // Çoklu delege (Multicast Delegate)
     MesajYaz cokluDelege = delege1 + delege2;
     cokluDelege("Herkese");
     // Output:
     // Selam: Herkese
     // Güle Güle: Herkese
   }
 }
  

Bu örnekte, SelamVer ve GuleGule adlı iki metot tanımlanmıştır. Her iki metot da MesajYaz delege türüyle uyumludur. Main metodunda, bu metotlar delegelere atanır ve delegeler aracılığıyla çağrılır. Ayrıca, iki delege birleştirilerek çoklu bir delege (multicast delegate) oluşturulur ve bu delege çağrıldığında her iki metot da çalıştırılır.

Olaylar (Events)

Olaylar, bir sınıfın veya nesnenin, durumundaki bir değişiklik hakkında diğer sınıfları veya nesneleri bilgilendirmesini sağlayan mekanizmalardır. Olaylar, delegeleri temel alır ve yayıncı (publisher) ile abone (subscriber) arasında bir iletişim kurar. Yayıncı, olayı tetiklerken, aboneler bu olayı dinler ve olay gerçekleştiğinde belirlenen metotları çalıştırır.

Olay Tanımlama

Bir olay tanımlamak için event anahtar kelimesi kullanılır. Olay tanımı, bir delege türü belirtir ve bu delege türü, olayın tetiklendiğinde çağrılacak metotların imzasını tanımlar.

 public delegate void VeriDegistiEventHandler(object sender, EventArgs e);

 public class VeriKaynagi
 {
   public event VeriDegistiEventHandler VeriDegisti;

   protected virtual void OnVeriDegisti(EventArgs e)
   {
     VeriDegisti?.Invoke(this, e);
   }

   public void VeriyiDegistir()
   {
     // Veriyi değiştir
     OnVeriDegisti(EventArgs.Empty);
   }
 }

Bu örnekte, VeriDegistiEventHandler adında bir delege tanımlanmıştır. Bu delege, object türünde bir sender (olayı başlatan nesne) ve EventArgs türünde bir e (olay argümanları) parametresi alır. VeriKaynagi sınıfında, VeriDegisti adında bir olay tanımlanmıştır ve bu olay, VeriDegistiEventHandler delege türünü kullanır. OnVeriDegisti metodu, olayı tetiklemek için kullanılır. VeriDegistir metodu, veriyi değiştirdikten sonra OnVeriDegisti metodunu çağırarak olayı tetikler.

Olay Aboneliği

Bir olaya abone olmak için, += operatörü kullanılır. Bu operatör, bir metodu olayın olay işleyicisine ekler. Olay tetiklendiğinde, bu metot otomatik olarak çağrılır.

 using System;

 public class Program
 {
   public delegate void VeriDegistiEventHandler(object sender, EventArgs e);
  
   public class VeriKaynagi
   {
     public event VeriDegistiEventHandler VeriDegisti;
  
     protected virtual void OnVeriDegisti(EventArgs e)
     {
       VeriDegisti?.Invoke(this, e);
     }
  
     public void VeriyiDegistir()
     {
     // Veriyi değiştir
       OnVeriDegisti(EventArgs.Empty);
     }
   }
  
   public class VeriDinleyici
   {
     public void VeriDegistiHandler(object sender, EventArgs e)
     {
       Console.WriteLine("Veri değişti!");
     }  
   }
  
   public static void Main(string[] args)
   {
     VeriKaynagi kaynak = new VeriKaynagi();
     VeriDinleyici dinleyici = new VeriDinleyici();
    
     kaynak.VeriDegisti += dinleyici.VeriDegistiHandler;
    
     kaynak.VeriyiDegistir(); // Output: Veri değişti!
   }
}

Bu örnekte, VeriDinleyici sınıfında VeriDegistiHandler adında bir metot tanımlanmıştır. Bu metot, VeriDegistiEventHandler delege türüyle uyumludur. Main metodunda, VeriKaynagi ve VeriDinleyici nesneleri oluşturulur. VeriDegistiHandler metodu, VeriKaynagi nesnesinin VeriDegisti olayına abone olur. VeriKaynagi.VeriyiDegistir() çağrıldığında, VeriDegisti olayı tetiklenir ve VeriDinleyici.VeriDegistiHandler() metodu otomatik olarak çalışır.

Neden Olaylar?

Olaylar, delegelerin daha kontrollü bir şekilde kullanılmasını sağlar. Olaylar, dış sınıfların bir delegenin içeriğini değiştirmesini engeller. Bir olay sadece tanımlandığı sınıf içinde tetiklenebilir. Bu, olayların daha güvenli ve öngörülebilir olmasını sağlar.

Delegeler ve Olayların Kullanım Alanları

• GUI Uygulamaları: Buton tıklamaları, menü seçimleri gibi kullanıcı etkileşimlerini yönetmek için kullanılır.
• Asenkron Programlama: Bir işlemin tamamlandığını bildirmek için kullanılır.
• Observer Pattern: Bir nesnenin durumundaki değişiklikleri diğer nesnelere bildirmek için kullanılır.
• Middleware: Uygulama bileşenleri arasında iletişim kurmak için kullanılır.

Sonuç

Olaylar ve delegeler, C# programlama dilinin güçlü ve esnek özelliklerindendir. Bu yapılar, gevşek bağlı sistemlerin oluşturulmasına, kodun yeniden kullanılabilirliğinin artırılmasına ve uygulamanın genel tasarımının iyileştirilmesine yardımcı olur. Olaylar ve delegeleri doğru bir şekilde kullanarak, daha modüler, test edilebilir ve sürdürülebilir uygulamalar geliştirebilirsiniz.

15. Olaylar ve Delegeler yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

14. Sınıf ve Nesne Kavramı (OOP Temelleri)

C# programlama dilinin en temel ve güçlü özelliklerinden biri, Nesne Yönelimli Programlama (OOP) paradigmasıdır. OOP, yazılım geliştirme sürecini daha düzenli, modüler ve yeniden kullanılabilir hale getirmeyi amaçlar. Bu yaklaşımın merkezinde ise sınıf ve nesne kavramları yer alır. Bu yazıda, C# dilinde sınıf ve nesne kavramlarını detaylı bir şekilde inceleyeceğiz.

Sınıf (Class) Nedir?

Sınıf, bir nesnenin şablonu veya planıdır. Başka bir deyişle, bir nesnenin hangi özelliklere (alanlar veya değişkenler) ve davranışlara (metotlar) sahip olacağını tanımlar. Sınıf, gerçek dünyadaki nesnelerin veya kavramların soyut bir temsilidir.

C# dilinde bir sınıf tanımlamak için `class` anahtar kelimesi kullanılır. Sınıfın içinde, o sınıfa ait alanlar (fields) ve metotlar (methods) tanımlanır.

Sınıf Tanımlama Sözdizimi

Bir sınıfın temel yapısı aşağıdaki gibidir:

class SinifAdi
{
    // Alanlar (Fields)
    // Metotlar (Methods)
}

Örnek:

Bir `Araba` sınıfı tanımlayalım. Bu sınıfın `Marka`, `Model`, `Renk` gibi alanları ve `Hizlan`, `Yavasla` gibi metotları olsun.

class Araba
{
    public string Marka;
    public string Model;
    public string Renk;

    public void Hizlan()
    {
        Console.WriteLine("Araba hızlanıyor!");
    }

    public void Yavasla()
    {
        Console.WriteLine("Araba yavaşlıyor!");
    }
}

Bu örnekte, `Araba` sınıfının temel özelliklerini ve davranışlarını tanımladık. Ancak, bu sınıf henüz somut bir araba değildir. Somut bir araba yaratmak için, bu sınıftan bir nesne (instance) oluşturmamız gerekir.

Nesne (Object) Nedir?

Nesne, bir sınıfın somut bir örneğidir. Sınıf bir plan veya şablon iken, nesne bu planın hayata geçirilmiş halidir. Bir sınıftan birden fazla nesne oluşturulabilir. Her nesne, sınıfın tanımladığı özelliklere ve davranışlara sahiptir, ancak her nesnenin özellikleri farklı değerlere sahip olabilir.

Nesne Oluşturma

C# dilinde bir nesne oluşturmak için `new` anahtar kelimesi kullanılır. `new` anahtar kelimesi, bellekte nesne için yer ayırır ve sınıfın kurucu metodunu (constructor) çağırır.

Örnek:

`Araba` sınıfından bir nesne oluşturalım:

Araba benimArabam = new Araba();
benimArabam.Marka = "Mercedes";
benimArabam.Model = "C180";
benimArabam.Renk = "Beyaz";

Console.WriteLine("Arabanın markası: " + benimArabam.Marka);
benimArabam.Hizlan();

Bu örnekte, `benimArabam` adında bir `Araba` nesnesi oluşturduk ve bu nesnenin `Marka`, `Model` ve `Renk` özelliklerine değerler atadık. Ardından, nesnenin `Hizlan` metodunu çağırdık.

OOP’nin Temel Prensipleri

Sınıf ve nesne kavramları, Nesne Yönelimli Programlama’nın temelini oluşturur. OOP’nin diğer önemli prensipleri şunlardır:

• Kapsülleme (Encapsulation): Verileri ve metotları bir arada tutarak, verilerin dışarıdan doğrudan erişilmesini engeller. Bu, veri güvenliğini artırır ve kodun daha modüler olmasını sağlar.
• Miras (Inheritance): Bir sınıfın (alt sınıf veya türetilmiş sınıf) başka bir sınıftan (üst sınıf veya temel sınıf) özelliklerini ve davranışlarını devralmasını sağlar. Bu, kodun yeniden kullanılabilirliğini artırır ve hiyerarşik bir yapı oluşturmayı kolaylaştırır.
• Çok Biçimlilik (Polymorphism): Bir nesnenin farklı şekillerde davranabilmesini sağlar. Bu, kodun daha esnek ve genişletilebilir olmasını sağlar.
• Soyutlama (Abstraction): Karmaşık sistemlerin temel özelliklerini ortaya çıkararak, gereksiz detayları gizler. Bu, kodun daha anlaşılır ve yönetilebilir olmasını sağlar.

Sınıf ve Nesne Kullanımının Avantajları

C# dilinde sınıf ve nesne kavramlarını kullanarak program yazmanın birçok avantajı vardır:

• Modülerlik: Kodun daha küçük ve yönetilebilir parçalara ayrılmasını sağlar.
• Yeniden Kullanılabilirlik: Sınıflar ve nesneler, farklı projelerde tekrar tekrar kullanılabilir.
• Bakım Kolaylığı: Kodun daha düzenli ve anlaşılır olmasını sağlar, bu da hataları bulmayı ve düzeltmeyi kolaylaştırır.
• Genişletilebilirlik: Yeni özellikler eklemek veya mevcut özellikleri değiştirmek daha kolaydır.

Sonuç

C# programlama dilinde sınıf ve nesne kavramları, modern yazılım geliştirme için vazgeçilmezdir. Bu kavramları anlamak ve doğru bir şekilde kullanmak, daha sağlam, ölçeklenebilir ve bakımı kolay uygulamalar geliştirmemizi sağlar. Nesne Yönelimli Programlama prensiplerini özümseyerek, yazılım geliştirme sürecini daha verimli ve keyifli hale getirebiliriz.

Umarım bu makale, C# dilinde sınıf ve nesne kavramlarını anlamanıza yardımcı olmuştur. Başarılar dilerim!

14. Sınıf ve Nesne Kavramı (OOP Temelleri) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

13. Dosya İşlemleri (File I/O) – Temel Seviye

C# programlama dilinde dosya işlemleri (File I/O), uygulamalarımızın kalıcı veri saklaması ve dış kaynaklardan veri alması için hayati öneme sahiptir. Bu makalede, C# ile temel dosya okuma ve yazma işlemlerini detaylı bir şekilde inceleyeceğiz. Dosya oluşturma, okuma, yazma, silme gibi temel operasyonları örnek kodlarla açıklayacağız.

Dosya İşlemlerine Giriş

Dosya işlemleri, bir programın disk üzerindeki dosyalarla etkileşim kurmasını sağlar. Bu etkileşim, veri saklama, yapılandırma dosyalarını okuma, loglama gibi birçok farklı amaç için kullanılabilir. C#’ta System.IO namespace’i, dosya işlemlerini gerçekleştirmek için gerekli olan sınıfları ve metotları içerir.

System.IO Namespace’i

System.IO namespace’i, dosya ve dizinlerle çalışmak için gereken temel sınıfları sağlar. Başlıca sınıflar şunlardır:

• File: Dosyalar üzerinde işlem yapmak için statik metotlar içerir (oluşturma, silme, kopyalama, vb.).
• Directory: Dizinler üzerinde işlem yapmak için statik metotlar içerir (oluşturma, silme, taşıma, vb.).
• FileInfo: Bir dosyayı temsil eder ve dosya özelliklerine erişim sağlar (boyut, oluşturulma tarihi, vb.).
• DirectoryInfo: Bir dizini temsil eder ve dizin özelliklerine erişim sağlar.
• Stream: Veri akışlarını temsil eder (dosyadan okuma, dosyaya yazma, vb.).
• StreamReader: Bir dosyadan metin okumak için kullanılır.
• StreamWriter: Bir dosyaya metin yazmak için kullanılır.

Dosya Oluşturma ve Silme

C#’ta dosya oluşturmak ve silmek için File sınıfının statik metotları kullanılır.

Dosya Oluşturma

Yeni bir dosya oluşturmak için File.Create() metodu kullanılır. Bu metot, belirtilen yolda yeni bir dosya oluşturur ve bir FileStream nesnesi döndürür. Bu nesne, dosyaya veri yazmak için kullanılabilir.

using System;
using System.IO;

public class DosyaIslemleri
{
 public static void Main(string[] args)
 {
   string dosyaYolu = "ornek.txt";
  
   try
   {
     using (FileStream fs = File.Create(dosyaYolu))
     {
       Console.WriteLine("Dosya oluşturuldu: " + dosyaYolu);
     }
   }
   catch (Exception e)
   {
     Console.WriteLine("Hata oluştu: " + e.Message);
   }
 }
}

Bu örnekte, ornek.txt adında bir dosya oluşturulur. using bloğu, FileStream nesnesinin otomatik olarak kapatılmasını sağlar, böylece kaynakların serbest bırakılması garanti edilir.

Dosya Silme

Bir dosyayı silmek için File.Delete() metodu kullanılır. Bu metot, belirtilen yoldaki dosyayı siler.

using System;
using System.IO;

public class DosyaIslemleri
{
 public static void Main(string[] args)
 {
   string dosyaYolu = "ornek.txt";
  
   try
   {
     File.Delete(dosyaYolu);
     Console.WriteLine("Dosya silindi: " + dosyaYolu);
   }
   catch (Exception e)
   {
     Console.WriteLine("Hata oluştu: " + e.Message);
   }
 }
}

Bu örnekte, ornek.txt adlı dosya silinir. Dosya silinirken bir hata oluşursa (örneğin, dosya bulunamazsa), bir istisna yakalanır ve hata mesajı görüntülenir.

Dosyaya Yazma

C#’ta bir dosyaya veri yazmak için StreamWriter sınıfı kullanılır. Bu sınıf, bir dosyaya metin yazmak için gerekli olan metotları sağlar.

StreamWriter Kullanımı

StreamWriter sınıfı, bir dosyaya metin yazmak için kullanılan temel sınıflardan biridir. Aşağıdaki örnek, StreamWriter kullanarak bir dosyaya nasıl veri yazılacağını gösterir:

using System;
using System.IO;

public class DosyaIslemleri
{
 public static void Main(string[] args)
 {
   string dosyaYolu = "ornek.txt";
  
   try
   {
     using (StreamWriter sw = new StreamWriter(dosyaYolu))
     {
       sw.WriteLine("Merhaba, Dünya!");
       sw.WriteLine("Bu bir örnek dosyadır.");
     }
     Console.WriteLine("Dosyaya yazıldı: " + dosyaYolu);
   }
   catch (Exception e)
   {
     Console.WriteLine("Hata oluştu: " + e.Message);
   }
 }
}

Bu örnekte, ornek.txt dosyasına iki satır metin yazılır. using bloğu, StreamWriter nesnesinin otomatik olarak kapatılmasını sağlar.

Dosyadan Okuma

C#’ta bir dosyadan veri okumak için StreamReader sınıfı kullanılır. Bu sınıf, bir dosyadan metin okumak için gerekli olan metotları sağlar.

StreamReader Kullanımı

StreamReader sınıfı, bir dosyadan metin okumak için kullanılan temel sınıflardan biridir. Aşağıdaki örnek, StreamReader kullanarak bir dosyadan nasıl veri okunacağını gösterir:

using System;
using System.IO;

public class DosyaIslemleri
{
 public static void Main(string[] args)
 {
   string dosyaYolu = "ornek.txt";
  
   try
   {
     using (StreamReader sr = new StreamReader(dosyaYolu))
     {
       string satir;
       while ((satir = sr.ReadLine()) != null)
       {
       Console.WriteLine(satir);
       }
     }
     Console.WriteLine("Dosyadan okundu: " + dosyaYolu);
   }
   catch (Exception e)
   {
     Console.WriteLine("Hata oluştu: " + e.Message);
   }
 }
}

Bu örnekte, ornek.txt dosyasındaki tüm satırlar okunur ve konsola yazdırılır. StreamReader.ReadLine() metodu, dosyanın sonuna ulaşılana kadar satır satır okuma yapar. using bloğu, StreamReader nesnesinin otomatik olarak kapatılmasını sağlar.

Dosya Kopyalama ve Taşıma

C#’ta dosyaları kopyalamak ve taşımak için File sınıfının statik metotları kullanılır.

Dosya Kopyalama

Bir dosyayı kopyalamak için File.Copy() metodu kullanılır. Bu metot, belirtilen yoldaki dosyayı belirtilen hedef yola kopyalar.

using System;
using System.IO;

public class DosyaIslemleri
{
 public static void Main(string[] args)
 {
   string kaynakDosya = "ornek.txt";
   string hedefDosya = "kopya.txt";
  
   try
   {
     File.Copy(kaynakDosya, hedefDosya);
     Console.WriteLine("Dosya kopyalandı: " + hedefDosya);
   }
   catch (Exception e)
   {
     Console.WriteLine("Hata oluştu: " + e.Message);
   }
 }
}

Bu örnekte, ornek.txt dosyası kopya.txt olarak kopyalanır. Eğer hedef dosyası zaten varsa, File.Copy() metodu bir istisna fırlatır. Bu durumu önlemek için, metodun ikinci parametresine true değeri verilebilir. Bu durumda, hedef dosya varsa üzerine yazılır.

Dosya Taşıma

Bir dosyayı taşımak için File.Move() metodu kullanılır. Bu metot, belirtilen yoldaki dosyayı belirtilen hedef yola taşır.

using System;
using System.IO;

public class DosyaIslemleri
{
 public static void Main(string[] args)
 {
   string kaynakDosya = "ornek.txt";
   string hedefDosya = "yeni_dizin/ornek.txt";
  
   try
   {
     File.Move(kaynakDosya, hedefDosya);
     Console.WriteLine("Dosya taşındı: " + hedefDosya);
   }
   catch (Exception e)
   {
     Console.WriteLine("Hata oluştu: " + e.Message);
   }
 }
}

Bu örnekte, ornek.txt dosyası yeni_dizin adlı bir dizine taşınır. Eğer hedef dizin yoksa, bir istisna fırlatılır. Bu nedenle, dosya taşınmadan önce hedef dizinin oluşturulduğundan emin olunmalıdır.

Özet

Bu makalede, C# programlama dilinde temel dosya işlemlerini (File I/O) inceledik. Dosya oluşturma, silme, okuma, yazma, kopyalama ve taşıma gibi temel operasyonları örnek kodlarla açıkladık. Dosya işlemlerinin, uygulamalarımızın kalıcı veri saklaması ve dış kaynaklardan veri alması için ne kadar önemli olduğunu vurguladık. C# ile dosya işlemleri yaparken dikkat edilmesi gereken noktaları ve olası hataları ele aldık. System.IO namespace’inin sunduğu zengin araçlarla, dosya işlemlerini kolayca gerçekleştirebilirsiniz.

13. Dosya İşlemleri (File I/O) – Temel Seviye yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

12. Hata Yakalama (Exception Handling) ve Try-Catch-Finally Blokları

C# programlama dilinde, sağlam ve güvenilir uygulamalar geliştirmek için hata yakalama (exception handling) mekanizması hayati bir öneme sahiptir. Hata yakalama, programın çalışma zamanında beklenmedik durumlarla karşılaştığında çökmesini engeller ve uygulamanın kontrollü bir şekilde devam etmesini sağlar. Bu makalede, C# dilindeki hata yakalama mekanizmasını, try-catch-finally bloklarını ve bu blokların nasıl kullanıldığını ayrıntılı olarak inceleyeceğiz.

Hata (Exception) Nedir?

Bir hata (exception), programın normal akışını bozan ve beklenmedik bir durumun ortaya çıkmasıdır. Bu durumlar, sıfıra bölme, geçersiz dosya yolu, bellek yetersizliği veya ağ bağlantısı sorunları gibi çeşitli nedenlerden kaynaklanabilir. C# dilinde, hatalar nesneler olarak temsil edilir ve System.Exception sınıfından türetilirler.

Try-Catch-Finally Blokları

C# dilinde hata yakalama, try-catch-finally blokları kullanılarak gerçekleştirilir. Bu bloklar, programın hatalara karşı korunmasını sağlar ve hataların kontrollü bir şekilde ele alınmasına olanak tanır.

Try Bloğu

try bloğu, hatalara neden olabilecek kodun yerleştirildiği bölümdür. Programın normal akışı içinde çalıştırılması beklenen kod bu blok içinde yer alır. Eğer try bloğu içinde bir hata meydana gelirse, programın akışı hemen catch bloğuna geçer.

try
{
    // Hata oluşabilecek kod
    int sayi1 = 10;
    int sayi2 = 0;
    int sonuc = sayi1 / sayi2; // Sıfıra bölme hatası
    Console.WriteLine("Sonuç: " + sonuc);
}

Catch Bloğu

catch bloğu, try bloğu içinde meydana gelen hataları yakalar ve işler. Her try bloğu için birden fazla catch bloğu tanımlanabilir. Bu, farklı türdeki hataların farklı şekillerde ele alınmasını sağlar. catch bloğu, yakalayacağı hata türünü belirtir. Eğer try bloğu içinde belirtilen türde bir hata meydana gelirse, ilgili catch bloğu çalıştırılır.

catch (DivideByZeroException ex)
{
    // Sıfıra bölme hatası yakalandı
    Console.WriteLine("Hata: Sıfıra bölme hatası oluştu.");
    Console.WriteLine("Hata mesajı: " + ex.Message);
}
catch (Exception ex)
{
    // Genel hata yakalama bloğu
    Console.WriteLine("Bir hata oluştu.");
    Console.WriteLine("Hata mesajı: " + ex.Message);
}

Yukarıdaki örnekte, ilk catch bloğu DivideByZeroException türündeki hataları yakalar. Eğer try bloğu içinde sıfıra bölme hatası oluşursa, bu catch bloğu çalıştırılır. İkinci catch bloğu ise genel bir hata yakalama bloğudur ve Exception sınıfından türetilmiş herhangi bir hatayı yakalar. Bu blok, belirli bir hata türü için catch bloğu tanımlanmamış hataları ele almak için kullanılır.

Finally Bloğu

finally bloğu, try bloğu içinde hata oluşsa da oluşmasa da her zaman çalıştırılan bir bölümdür. Bu blok, genellikle kaynakların serbest bırakılması (örneğin, dosya kapatma, veritabanı bağlantısını sonlandırma) gibi işlemler için kullanılır. finally bloğu, hata oluşsa bile bu işlemlerin mutlaka yapılmasını garanti eder.

finally
{
    // Kaynakları serbest bırakma işlemleri
    Console.WriteLine("Finally bloğu çalıştı.");
}

Try-Catch-Finally Bloklarının Kullanımı

try-catch-finally bloklarının kullanımı, programın güvenilirliğini artırmak için önemlidir. İşte bir örnek:

try
{
    // Dosyayı açma
    StreamReader dosya = new StreamReader("dosya.txt");

    // Dosyadan veri okuma
    string satir = dosya.ReadLine();
    Console.WriteLine("Dosyadan okunan satır: " + satir);

    // Dosyayı kapatma (finally bloğunda da yapılabilir)
    dosya.Close();
}
catch (FileNotFoundException ex)
{
    // Dosya bulunamadı hatası
    Console.WriteLine("Hata: Dosya bulunamadı.");
    Console.WriteLine("Hata mesajı: " + ex.Message);
}
catch (IOException ex)
{
    // Girdi/çıktı hatası
    Console.WriteLine("Hata: Dosya okuma/yazma hatası.");
    Console.WriteLine("Hata mesajı: " + ex.Message);
}
finally
{
    // Dosyayı kapatma (eğer açılmışsa)
    if (dosya != null)
    {
        dosya.Close();
    }
    Console.WriteLine("Finally bloğu çalıştı.");
}

Bu örnekte, try bloğu içinde bir dosya açılır, dosyadan veri okunur ve dosya kapatılır. Eğer dosya bulunamazsa veya dosya okuma/yazma sırasında bir hata oluşursa, ilgili catch bloğu çalıştırılır. finally bloğu ise, dosya açılmış olsun veya olmasın, dosyanın kapatılmasını garanti eder.

Hata Türleri

C# dilinde birçok farklı hata türü bulunmaktadır. En sık karşılaşılan hata türlerinden bazıları şunlardır:

• DivideByZeroException: Sıfıra bölme hatası.
• NullReferenceException: Null referans hatası (bir nesneye atanmamış bir değişkene erişmeye çalışma).
• IndexOutOfRangeException: Dizi sınırlarının dışına çıkma hatası.
• FileNotFoundException: Dosya bulunamadı hatası.
• IOException: Girdi/çıktı hatası.
• FormatException: Yanlış biçimde veri girişi hatası (örneğin, bir metni sayıya dönüştürmeye çalışma).

Özel Hata (Exception) Sınıfları Oluşturma

C# dilinde, kendi özel hata sınıflarınızı da oluşturabilirsiniz. Bu, uygulamanızdaki belirli durumlar için özelleştirilmiş hata mesajları ve davranışlar sağlamanıza olanak tanır. Özel bir hata sınıfı oluşturmak için, Exception sınıfından türetmeniz yeterlidir.

public class BenimOzelHatam : Exception
{
    public BenimOzelHatam(string message) : base(message)
    {
    }
}

Bu örnekte, BenimOzelHatam adında bir özel hata sınıfı oluşturulmuştur. Bu sınıf, Exception sınıfından türetilmiştir ve bir hata mesajı alarak temel sınıfın kurucusunu çağırır.

Hata Fırlatma (Throwing Exceptions)

Bazen, bir metot içinde bir hata tespit ettiğinizde, bu hatayı çağıran metoda bildirmek isteyebilirsiniz. Bu durumda, throw ifadesini kullanarak bir hata fırlatabilirsiniz.

public void KontrolEt(int sayi)
{
    if (sayi < 0)
    {
        throw new ArgumentException("Sayı negatif olamaz.");
    }
    // Diğer işlemler
}

Bu örnekte, KontrolEt metodu, gelen sayının negatif olup olmadığını kontrol eder. Eğer sayı negatif ise, bir ArgumentException hatası fırlatılır.

Sonuç

C# programlama dilinde hata yakalama (exception handling), sağlam ve güvenilir uygulamalar geliştirmek için kritik bir öneme sahiptir. try-catch-finally blokları, programın hatalara karşı korunmasını sağlar ve hataların kontrollü bir şekilde ele alınmasına olanak tanır. Bu blokları doğru kullanarak, uygulamanızın çalışma zamanında beklenmedik durumlarla başa çıkmasını ve kullanıcı deneyimini iyileştirmesini sağlayabilirsiniz. Ayrıca, özel hata sınıfları oluşturarak ve hata fırlatarak, uygulamanızın hata yönetimi yeteneklerini daha da geliştirebilirsiniz.

12. Hata Yakalama (Exception Handling) ve Try-Catch-Finally Blokları yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

11. DateTime ve Zaman Manipülasyonu

C# programlama dilinde, tarih ve saat bilgileriyle çalışmak oldukça önemlidir. DateTime yapısı, tarih ve zaman değerlerini temsil etmek için kullanılırken, çeşitli metotlar ve özellikler sayesinde bu değerler üzerinde manipülasyonlar yapmak mümkündür. Bu makalede, DateTime yapısını ve zaman manipülasyonlarını ayrıntılı bir şekilde inceleyeceğiz.

DateTime Yapısı

DateTime, .NET Framework tarafından sağlanan bir yapıdır ve tarih (gün, ay, yıl) ve zaman (saat, dakika, saniye, milisaniye) bilgilerini içerir. DateTime yapısı, çeşitli formatlarda tarih ve zaman değerlerini saklayabilir ve bu değerler üzerinde aritmetik işlemler yapılmasına olanak tanır.

DateTime Nesnesi Oluşturma

DateTime nesnesi oluşturmanın birkaç farklı yolu vardır:

• Şu anki tarih ve zamanı almak:

DateTime now = DateTime.Now;
DateTime utcNow = DateTime.UtcNow;

• Belirli bir tarih ve zamanı belirtmek:

DateTime specificDate = new DateTime(2024, 10, 23, 14, 30, 0); // Yıl, ay, gün, saat, dakika, saniye

• String formatından dönüştürmek:

string dateString = "2024-10-23";
DateTime parsedDate = DateTime.Parse(dateString);

string dateStringWithFormat = "10/23/2024 14:30:00";
DateTime parsedDateWithFormat = DateTime.ParseExact(dateStringWithFormat, "MM/dd/yyyy HH:mm:ss", null);

DateTime.Parse metodu, belirtilen string’i DateTime nesnesine dönüştürmeye çalışır. DateTime.ParseExact metodu ise, belirli bir formatta olan string’i dönüştürmek için kullanılır.

DateTime Özellikleri ve Metotları

DateTime yapısının birçok kullanışlı özelliği ve metodu bulunmaktadır. İşte bazıları:

• Year, Month, Day: Yıl, ay ve gün bilgilerini alır.
• Hour, Minute, Second: Saat, dakika ve saniye bilgilerini alır.
• DayOfWeek: Haftanın gününü (Pazartesi, Salı, vb.) alır.
• DayOfYear: Yılın kaçıncı günü olduğunu alır.
• ToLongDateString(), ToShortDateString(): Tarihi uzun veya kısa formatta string olarak döndürür.
• ToLongTimeString(), ToShortTimeString(): Zamanı uzun veya kısa formatta string olarak döndürür.
• AddYears(), AddMonths(), AddDays(), AddHours(), AddMinutes(), AddSeconds(): Belirtilen miktarda yıl, ay, gün, saat, dakika veya saniye ekler.
• Subtract(): İki DateTime nesnesi arasındaki farkı TimeSpan olarak döndürür.
• ToString(): DateTime nesnesini belirtilen formatta string’e dönüştürür.

Örnek Kullanımlar

Aşağıda, DateTime özelliklerinin ve metotlarının kullanımına dair bazı örnekler bulunmaktadır:

DateTime now = DateTime.Now;

Console.WriteLine("Yıl: " + now.Year);
Console.WriteLine("Ay: " + now.Month);
Console.WriteLine("Gün: " + now.Day);
Console.WriteLine("Saat: " + now.Hour);
Console.WriteLine("Dakika: " + now.Minute);
Console.WriteLine("Saniye: " + now.Second);
Console.WriteLine("Haftanın Günü: " + now.DayOfWeek);
Console.WriteLine("Yılın Günü: " + now.DayOfYear);

DateTime futureDate = now.AddDays(10);
Console.WriteLine("10 Gün Sonrası: " + futureDate.ToLongDateString());

TimeSpan difference = futureDate.Subtract(now);
Console.WriteLine("Fark: " + difference.TotalDays + " gün");

string formattedDate = now.ToString("dd/MM/yyyy HH:mm:ss");
Console.WriteLine("Formatlı Tarih: " + formattedDate);

Zaman Manipülasyonu

DateTime yapısı, tarih ve zaman değerleri üzerinde çeşitli manipülasyonlar yapmaya olanak tanır. Bu manipülasyonlar, tarih ekleme, çıkarma, karşılaştırma ve formatlama gibi işlemleri içerir.

Tarih ve Zaman Ekleme

AddYears(), AddMonths(), AddDays(), AddHours(), AddMinutes() ve AddSeconds() metotları, DateTime nesnesine belirtilen miktarda zaman eklemek için kullanılır.

DateTime now = DateTime.Now;
DateTime futureDate = now.AddDays(7); // 7 gün ekle
DateTime futureMonth = now.AddMonths(2); // 2 ay ekle
DateTime futureYear = now.AddYears(1); // 1 yıl ekle

Tarih ve Zaman Çıkarma

Subtract() metodu, iki DateTime nesnesi arasındaki farkı bulmak için kullanılır. Bu metot, TimeSpan türünde bir değer döndürür.

DateTime startDate = new DateTime(2024, 1, 1);
DateTime endDate = DateTime.Now;
TimeSpan difference = endDate.Subtract(startDate);

Console.WriteLine("Gün Farkı: " + difference.TotalDays);
Console.WriteLine("Saat Farkı: " + difference.TotalHours);
Console.WriteLine("Dakika Farkı: " + difference.TotalMinutes);

Tarih ve Zaman Karşılaştırma

DateTime nesneleri, karşılaştırma operatörleri (==, !=, <, >, <=, >=) kullanılarak karşılaştırılabilir. Ayrıca, CompareTo() metodu da kullanılabilir.

DateTime date1 = new DateTime(2024, 10, 23);
DateTime date2 = new DateTime(2024, 11, 15);

if (date1 < date2)
{
 Console.WriteLine("date1, date2'den önce");
}

int comparisonResult = date1.CompareTo(date2);
if (comparisonResult < 0)
{
 Console.WriteLine("date1, date2'den önce");
}
else if (comparisonResult > 0)
{
 Console.WriteLine("date1, date2'den sonra");
}
else
{
 Console.WriteLine("date1 ve date2 aynı");
}

Tarih ve Zaman Formatlama

ToString() metodu, DateTime nesnesini belirtilen formatta bir string’e dönüştürmek için kullanılır. Özel format belirteçleri kullanılarak, tarih ve zamanın nasıl görüntüleneceği kontrol edilebilir.

DateTime now = DateTime.Now;

string formattedDate1 = now.ToString("dd/MM/yyyy"); // Gün/Ay/Yıl
string formattedDate2 = now.ToString("MM/dd/yyyy HH:mm:ss"); // Ay/Gün/Yıl Saat:Dakika:Saniye
string formattedDate3 = now.ToString("yyyy-MM-dd HH:mm:ss.fff"); // Yıl-Ay-Gün Saat:Dakika:Saniye.Milisaniye
string formattedDate4 = now.ToString("dddd, dd MMMM yyyy"); // Haftanın Günü, Gün Ay Yıl

Özel format belirteçleri hakkında daha fazla bilgi için Microsoft’un dokümanlarına göz atabilirsiniz.

Time Zone (Saat Dilimi) İşlemleri

TimeZoneInfo sınıfı, saat dilimi bilgilerini yönetmek için kullanılır. Farklı saat dilimlerindeki tarih ve saatleri dönüştürmek ve işlem yapmak için bu sınıfı kullanabilirsiniz.

TimeZoneInfo est = TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time");
DateTime currentTime = DateTime.Now;
DateTime estTime = TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, est);

Console.WriteLine("Şu Anki Zaman (UTC): " + DateTime.UtcNow);
Console.WriteLine("Şu Anki Zaman (EST): " + estTime);

Sonuç

Bu makalede, C# programlama dilinde DateTime yapısının nasıl kullanılacağını ve zaman manipülasyonlarının nasıl yapılacağını ayrıntılı bir şekilde inceledik. DateTime yapısı, tarih ve zaman bilgileriyle çalışmak için güçlü ve esnek bir araçtır. Bu bilgileri kullanarak, uygulamalarınızda tarih ve zamanla ilgili işlemleri kolayca gerçekleştirebilirsiniz.

“Zaman, her şeyin ilacıdır.” – William Shakespeare

11. DateTime ve Zaman Manipülasyonu yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

C# Programlama Dilinde String İşlemleri ve StringBuilder Kullanımı

C# programlama dilinde, metinlerle çalışmak oldukça yaygın bir ihtiyaçtır. Bu ihtiyacı karşılamak için C#, zengin string işleme yetenekleri sunar. Bu makalede, C# dilinde stringlerle nasıl çalışılacağını ve performans açısından kritik olan StringBuilder sınıfının nasıl kullanılacağını detaylı bir şekilde inceleyeceğiz.

String Veri Tipi

C# dilinde string veri tipi, metinsel verileri temsil etmek için kullanılır. string aslında bir System.String sınıfının bir takma adıdır. Stringler, Unicode karakter dizileridir ve değiştirilemez (immutable) yapıdadırlar. Bu, bir string oluşturulduktan sonra içeriğinin değiştirilemeyeceği anlamına gelir. String üzerinde yapılan her değişiklik, aslında yeni bir string nesnesi oluşturur.

String Tanımlama ve Başlatma:

String tanımlamak ve başlatmak oldukça basittir:

string message = "Merhaba, Dünya!";
string name = "Ahmet";
string emptyString = string.Empty; // Boş bir string

Temel String İşlemleri

C#, stringlerle çalışmak için birçok yerleşik metot sunar. İşte en sık kullanılanlardan bazıları:

String Birleştirme (Concatenation)

Stringleri birleştirmenin birkaç yolu vardır:

• + operatörü ile birleştirme
• string.Concat() metodu ile birleştirme
• string.Format() metodu ile biçimlendirme

Örnekler:

string firstName = "Ayşe";
string lastName = "Yılmaz";

// + operatörü ile birleştirme
string fullName = firstName + " " + lastName; // Ayşe Yılmaz

// string.Concat() ile birleştirme
string fullName2 = string.Concat(firstName, " ", lastName); // Ayşe Yılmaz

// string.Format() ile biçimlendirme
string fullName3 = string.Format("{0} {1}", firstName, lastName); // Ayşe Yılmaz

Console.WriteLine(fullName);
Console.WriteLine(fullName2);
Console.WriteLine(fullName3);

String Uzunluğunu Bulma

Bir stringin uzunluğunu (karakter sayısını) bulmak için Length özelliğini kullanırız.

string text = "C# Programlama";
int length = text.Length; // 14
Console.WriteLine("Metnin uzunluğu: " + length);

String İçinde Arama Yapma

Bir stringin içinde belirli bir alt stringin olup olmadığını kontrol etmek veya konumunu bulmak için aşağıdaki metotlar kullanılabilir:

• Contains(): Belirli bir alt stringin içerilip içerilmediğini kontrol eder.
• IndexOf(): Belirli bir alt stringin ilk görüldüğü indeksi döndürür. Bulunamazsa -1 döndürür.
• LastIndexOf(): Belirli bir alt stringin son görüldüğü indeksi döndürür. Bulunamazsa -1 döndürür.
• StartsWith(): Stringin belirli bir alt string ile başlayıp başlamadığını kontrol eder.
• EndsWith(): Stringin belirli bir alt string ile bitip bitmediğini kontrol eder.

Örnekler:

string sentence = "C# programlama dili çok güçlüdür.";

bool containsCSharp = sentence.Contains("C#"); // true
int indexOfDili = sentence.IndexOf("dili"); // 15
int lastIndexOfA = sentence.LastIndexOf("a"); // 28
bool startsWithCSharp = sentence.StartsWith("C#"); // true
bool endsWithNokta = sentence.EndsWith("."); // true

Console.WriteLine("C# içeriyor mu: " + containsCSharp);
Console.WriteLine("\"dili\" kelimesinin indeksi: " + indexOfDili);
Console.WriteLine("\"a\" harfinin son indeksi: " + lastIndexOfA);
Console.WriteLine("C# ile başlıyor mu: " + startsWithCSharp);
Console.WriteLine(". ile bitiyor mu: " + endsWithNokta);

String Değiştirme

Bir string içindeki belirli bir alt stringi başka bir alt string ile değiştirmek için Replace() metodu kullanılır.

string text = "Merhaba Dünya";
string newText = text.Replace("Dünya", "Mars"); // Merhaba Mars
Console.WriteLine(newText);

String Bölme

Bir stringi belirli bir ayraç (delimiter) kullanarak parçalara ayırmak için Split() metodu kullanılır. Bu metot, bir string dizisi döndürür.

string names = "Ali,Veli,Ayşe";
string[] nameArray = names.Split(','); // ["Ali", "Veli", "Ayşe"]

foreach (string name in nameArray)
{
    Console.WriteLine(name);
}

String Kırpma

Bir stringin başındaki ve sonundaki boşlukları veya belirtilen karakterleri temizlemek için Trim(), TrimStart() ve TrimEnd() metotları kullanılır.

string text = "   Merhaba Dünya   ";
string trimmedText = text.Trim(); // "Merhaba Dünya"
string trimmedStart = text.TrimStart(); // "Merhaba Dünya   "
string trimmedEnd = text.TrimEnd(); // "   Merhaba Dünya"

Console.WriteLine("Kırpılmış metin: " + trimmedText);
Console.WriteLine("Baştan kırpılmış metin: " + trimmedStart);
Console.WriteLine("Sondan kırpılmış metin: " + trimmedEnd);

String Alt String Alma

Bir stringin belirli bir bölümünü almak için Substring() metodu kullanılır. Bu metot, başlangıç indeksi ve isteğe bağlı olarak uzunluk parametrelerini alır.

string text = "C# Programlama Dili";
string subString = text.Substring(3); // " Programlama Dili"
string subString2 = text.Substring(3, 10); // " Programlam"

Console.WriteLine("Alt metin: " + subString);
Console.WriteLine("Alt metin 2: " + subString2);

StringBuilder Sınıfı

string veri tipinin değiştirilemez (immutable) yapıda olması, sık sık string manipülasyonu gerektiren durumlarda performans sorunlarına yol açabilir. Çünkü her değişiklik yeni bir string nesnesi oluşturur ve bu da bellek tüketimini artırır. Bu tür durumlar için C#, System.Text.StringBuilder sınıfını sunar. StringBuilder, değiştirilebilir (mutable) bir string sınıfıdır. Yani, içeriği değiştirildiğinde yeni bir nesne oluşturmak yerine mevcut nesne üzerinde değişiklik yapar. Bu, performans açısından önemli bir avantaj sağlar.

StringBuilder Kullanımı

StringBuilder sınıfını kullanmak için öncelikle bir örnek oluşturmanız gerekir:

using System.Text;

StringBuilder sb = new StringBuilder();

StringBuilder Metotları

StringBuilder sınıfı, string manipülasyonu için çeşitli metotlar sunar:

• Append(): Stringin sonuna yeni bir string ekler.
• Insert(): Belirli bir konuma bir string ekler.
• Remove(): Belirli bir aralıktaki karakterleri siler.
• Replace(): Belirli bir alt stringi başka bir alt string ile değiştirir.
• ToString(): StringBuilder nesnesini string veri tipine dönüştürür.

Örnekler:

using System;
using System.Text;

public class Example
{
    public static void Main(string[] args)
    {
        StringBuilder sb = new StringBuilder("Merhaba");

        sb.Append(", Dünya!"); // Merhaba, Dünya!
        sb.Insert(7, " Sevgili"); // Merhaba Sevgili, Dünya!
        sb.Remove(7, 9); // Merhaba, Dünya!
        sb.Replace("Dünya", "Mars"); // Merhaba, Mars!

        string result = sb.ToString();
        Console.WriteLine(result); // Merhaba, Mars!
    }
}

StringBuilder ve String Karşılaştırması

Aşağıdaki örnek, string ve StringBuilder arasındaki performans farkını göstermektedir. Bir döngü içinde sürekli string birleştirme işlemi yapıldığında, StringBuilder‘ın performansı string‘e göre çok daha iyidir.

using System;
using System.Diagnostics;
using System.Text;

public class PerformanceExample
{
    public static void Main(string[] args)
    {
        int iterations = 10000;

        // String ile performans testi
        Stopwatch stringStopwatch = Stopwatch.StartNew();
        string text = "";
        for (int i = 0; i < iterations; i++)
        {
            text += i.ToString();
        }
        stringStopwatch.Stop();
        Console.WriteLine("String süresi: " + stringStopwatch.ElapsedMilliseconds + " ms");

        // StringBuilder ile performans testi
        Stopwatch stringBuilderStopwatch = Stopwatch.StartNew();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < iterations; i++)
        {
            sb.Append(i.ToString());
        }
        stringBuilderStopwatch.Stop();
        Console.WriteLine("StringBuilder süresi: " + stringBuilderStopwatch.ElapsedMilliseconds + " ms");
    }
}

Bu örnekte, 10000 yineleme yapıldığında StringBuilder‘ın çok daha hızlı olduğu görülecektir.

Sonuç

C# dilinde stringlerle çalışmak, programlama sürecinin önemli bir parçasıdır. string veri tipi temel metin işleme ihtiyaçlarını karşılarken, performansın kritik olduğu durumlarda StringBuilder sınıfı önemli bir avantaj sağlar. Bu makalede, string işleme metotlarını ve StringBuilder sınıfının kullanımını detaylı bir şekilde inceledik. Doğru araçları doğru yerde kullanarak, daha verimli ve performanslı C# uygulamaları geliştirebilirsiniz.

Unutmayın, string değiştirilemez (immutable) bir veri tipidir, bu yüzden sık sık string manipülasyonu yapmanız gerekiyorsa StringBuilder kullanmak daha iyi bir seçenektir.

10. C# Programlama Dilinde String İşlemleri ve StringBuilder Kullanımı yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

9. Diziler ve Koleksiyonlar (Array, List, Dictionary, vb.)

C# programlama dilinde, verileri düzenli bir şekilde saklamak ve yönetmek için çeşitli yapılar bulunur. Bunlar arasında diziler (arrays) ve koleksiyonlar (collections) öne çıkar. Bu yapılar, aynı türden veya farklı türden verileri bir arada tutarak, programın daha verimli ve düzenli çalışmasını sağlar. Bu makalede, C# dilindeki dizileri, koleksiyonları ve en sık kullanılan koleksiyon türlerini detaylı bir şekilde inceleyeceğiz.

Diziler (Arrays)

Diziler, aynı türden verilerin sıralı bir şekilde saklandığı veri yapılarıdır. Dizilerin boyutu tanımlanırken belirtilir ve daha sonra değiştirilemez. Bu, dizilerin bellekte sabit bir alana sahip olmasını sağlar, bu da performansı artırır. Ancak, boyutun sabit olması, esneklik açısından bazı sınırlamalar getirebilir.

Dizi Tanımlama ve Kullanımı

C# dilinde bir dizi tanımlamak için aşağıdaki sözdizimi kullanılır:

tür[] diziAdı = new tür[boyut];

Örneğin, 5 elemanlı bir integer dizisi tanımlamak için:

int[] sayilar = new int[5];

Dizinin elemanlarına erişmek için indeksler kullanılır. İndeksler 0’dan başlar:

sayilar[0] = 10;
sayilar[1] = 20;
// ...

Dizi Örneği

Aşağıdaki örnek, bir integer dizisi oluşturur, elemanlarına değer atar ve ekrana yazdırır:

using System;

public class DiziOrnek
{
    public static void Main(string[] args)
    {
        int[] sayilar = new int[5];
        sayilar[0] = 10;
        sayilar[1] = 20;
        sayilar[2] = 30;
        sayilar[3] = 40;
        sayilar[4] = 50;

        for (int i = 0; i < sayilar.Length; i++)
        {
            Console.WriteLine("sayilar[" + i + "] = " + sayilar[i]);
        }
    }
}

Bu kodun çıktısı:

sayilar[0] = 10
sayilar[1] = 20
sayilar[2] = 30
sayilar[3] = 40
sayilar[4] = 50

Koleksiyonlar (Collections)

Koleksiyonlar, dizilere göre daha esnek ve dinamik veri yapılarıdır. Koleksiyonların boyutu, eleman ekleme veya çıkarma işlemlerine göre otomatik olarak ayarlanabilir. C# dilinde, System.Collections ve System.Collections.Generic isim alanlarında birçok farklı koleksiyon türü bulunur.

ArrayList

ArrayList, farklı türden nesneleri saklayabilen, dinamik boyutlu bir koleksiyondur. Ancak, ArrayList‘e değer eklerken ve değer okurken boxing ve unboxing işlemleri yapılması gerektiği için performans sorunlarına yol açabilir. Bu nedenle, mümkünse generic koleksiyonlar tercih edilmelidir.

using System.Collections;

ArrayList liste = new ArrayList();
liste.Add(10);
liste.Add("Merhaba");
liste.Add(true);

List<T>

List<T>, generic bir koleksiyon türüdür. Yani, belirli bir türdeki (T) nesneleri saklar. Bu, boxing ve unboxing işlemlerini ortadan kaldırarak performansı artırır. List<T>, en sık kullanılan koleksiyon türlerinden biridir.

using System.Collections.Generic;

List sayilar = new List();
sayilar.Add(10);
sayilar.Add(20);

Dictionary<TKey, TValue>

Dictionary<TKey, TValue>, anahtar-değer çiftlerini saklayan bir koleksiyondur. Her anahtar benzersiz olmalıdır. Dictionary, verilere hızlı bir şekilde erişmek için idealdir. Örneğin, bir öğrenci numarasını anahtar, öğrenci adını değer olarak saklayabilirsiniz.

using System.Collections.Generic;

Dictionary<int, string> ogrenciler = new Dictionary<int, string>();
ogrenciler.Add(1, "Ahmet");
ogrenciler.Add(2, "Ayşe");

HashSet<T>

HashSet<T>, benzersiz elemanları saklayan bir koleksiyondur. Bir elemanı birden fazla kez eklemeye çalışırsanız, sadece bir tanesi saklanır. HashSet, bir listede tekrar eden elemanları bulmak veya benzersiz elemanlardan oluşan bir küme oluşturmak için kullanışlıdır.

using System.Collections.Generic;

HashSet sayilar = new HashSet();
sayilar.Add(10);
sayilar.Add(20);
sayilar.Add(10); // Tekrar eklemeye çalışsak bile sadece bir tane 10 saklanır.

Queue<T>

Queue<T>, FIFO (First-In-First-Out – İlk Giren İlk Çıkar) prensibine göre çalışan bir koleksiyondur. Elemanlar sırayla eklenir ve sırayla çıkarılır. Kuyruk yapısı, görevleri veya işlemleri sıraya koymak için kullanışlıdır.

using System.Collections.Generic;

Queue mesajlar = new Queue();
mesajlar.Enqueue("Merhaba");
mesajlar.Enqueue("Dünya");

string ilkMesaj = mesajlar.Dequeue(); // İlk mesajı (Merhaba) alır ve kuyruktan çıkarır.

Stack<T>

Stack<T>, LIFO (Last-In-First-Out – Son Giren İlk Çıkar) prensibine göre çalışan bir koleksiyondur. Elemanlar sırayla eklenir ve en son eklenen eleman ilk çıkarılır. Yığın yapısı, geri alma (undo) işlemleri veya fonksiyon çağrılarını takip etmek için kullanışlıdır.

using System.Collections.Generic;

Stack sayilar = new Stack();
sayilar.Push(10);
sayilar.Push(20);

int sonSayi = sayilar.Pop(); // Son sayıyı (20) alır ve yığından çıkarır.

Koleksiyon Metotları ve Özellikleri

Koleksiyonların birçoğu ortak metot ve özelliklere sahiptir. İşte bazıları:

• Add(T item): Koleksiyona bir eleman ekler.
• Remove(T item): Koleksiyondan bir eleman siler.
• Contains(T item): Koleksiyonda belirli bir elemanın olup olmadığını kontrol eder.
• Count: Koleksiyondaki eleman sayısını döndürür.
• Clear(): Koleksiyondaki tüm elemanları siler.

Dizi ve Koleksiyon Seçimi

Dizi mi yoksa koleksiyon mu kullanacağınız, uygulamanızın gereksinimlerine bağlıdır. Eğer boyutun önceden bilindiği ve değişmeyeceği durumlarda diziler daha performanslı olabilir. Ancak, boyutun dinamik olarak değiştiği ve daha fazla esneklik gerektiği durumlarda koleksiyonlar daha uygun olacaktır.

Örneğin, bir sınavdaki öğrenci sayısının sabit olduğu durumlarda bir dizi kullanılabilirken, bir sosyal medya uygulamasındaki kullanıcıların listesi sürekli değiştiği için bir koleksiyon kullanmak daha mantıklıdır.

Sonuç

C# dilindeki diziler ve koleksiyonlar, verileri düzenli bir şekilde saklamak ve yönetmek için güçlü araçlardır. Diziler, sabit boyutlu ve aynı türden veriler için idealdirken, koleksiyonlar dinamik boyutlu ve farklı türden veriler için daha fazla esneklik sunar. Uygulamanızın gereksinimlerine uygun olarak, dizileri veya koleksiyonları kullanarak daha verimli ve düzenli kod yazabilirsiniz. Özellikle List<T> ve Dictionary<TKey, TValue> gibi generic koleksiyonlar, performansı artırmak ve kodun okunabilirliğini sağlamak için sıklıkla tercih edilmelidir.

9. Diziler ve Koleksiyonlar (Array, List, Dictionary, vb.) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

8. Metotlar (Fonksiyonlar) ve Parametreler

C# programlama dilinde, metotlar (veya fonksiyonlar), belirli bir görevi yerine getiren kod bloklarıdır. Programlarımızın modüler, tekrar kullanılabilir ve okunabilir olmasını sağlarlar. Bu makalede, C# dilinde metotların nasıl tanımlandığını, kullanıldığını ve parametrelerin nasıl işlendiğini ayrıntılı olarak inceleyeceğiz.

Metot Tanımlama

Bir metot, genel olarak aşağıdaki yapıya sahiptir:

döndürülecek_tip metot_adı(parametre_listesi)
{
    // Metot gövdesi - yapılacak işlemler
    return döndürülecek_değer; // Eğer döndürülecek_tip void değilse
}

• döndürülecek_tip: Metodun geriye döndüreceği veri tipini belirtir. Eğer metot herhangi bir değer döndürmüyorsa, void olarak tanımlanır.
• metot_adı: Metoda verdiğimiz isimdir. Anlamlı ve açıklayıcı bir isim seçmek, kodun okunabilirliğini artırır.
• parametre_listesi: Metoda gönderilecek olan parametrelerin listesidir. Parametreler, metodun çalışması için gerekli olan girdileri sağlar. Parametreler veri tipi ve isimleriyle birlikte tanımlanır. Eğer metot parametre almıyorsa, parantezler boş bırakılır.
• Metot gövdesi: Metodun içindeki kod bloğudur. Burada, metodun gerçekleştireceği işlemler yer alır.
• return: Metodun geriye bir değer döndürmesini sağlar. Eğer metodun döndürülecek tipi void değilse, return ifadesi ile uygun tipte bir değer döndürülmelidir.

Örnek Metot Tanımları

İşte birkaç örnek metot tanımı:

// İki sayıyı toplayıp sonucu döndüren metot
int Topla(int sayi1, int sayi2)
{
    int toplam = sayi1 + sayi2;
    return toplam;
}

// Ekrana bir mesaj yazdıran metot (geriye değer döndürmüyor)
void MesajYaz(string mesaj)
{
    Console.WriteLine(mesaj);
}

// Parametre almayan ve geriye sabit bir değer döndüren metot
int SabitDegerDondur()
{
    return 42;
}

Metot Çağırma (Kullanma)

Bir metodu kullanmak için, metodun adını ve gerekli parametreleri (varsa) belirtmeniz gerekir. Metot çağrıldığında, metot içindeki kod bloğu çalıştırılır ve (eğer varsa) geriye bir değer döndürülür.

int sonuc = Topla(5, 3); // Topla metodunu çağır ve sonucu 'sonuc' değişkenine ata
MesajYaz("Merhaba Dünya!"); // MesajYaz metodunu çağır ve ekrana mesaj yazdır
int sabit = SabitDegerDondur(); // SabitDegerDondur metodunu çağır ve sabit değeri 'sabit' değişkenine ata

Parametreler

Metotlar, dışarıdan bilgi almak için parametreler kullanır. Parametreler, metodun daha esnek ve tekrar kullanılabilir olmasını sağlar. C# dilinde farklı parametre türleri bulunmaktadır.

Değer Parametreler (Value Parameters)

Değer parametreler, metodun çağrıldığı yerden metoda bir değerin kopyasını gönderir. Metot içinde yapılan değişiklikler, çağıran yerdeki değişkeni etkilemez.

void DegerParametre(int sayi)
{
    sayi = sayi * 2;
    Console.WriteLine("Metot içinde sayi: " + sayi); // Metot içinde sayi: 20
}

int anaSayi = 10;
DegerParametre(anaSayi);
Console.WriteLine("Ana metot içinde anaSayi: " + anaSayi); // Ana metot içinde anaSayi: 10

Referans Parametreler (Reference Parameters)

Referans parametreler, metoda bir değişkenin bellekteki adresini (referansını) gönderir. Metot içinde yapılan değişiklikler, çağıran yerdeki değişkeni doğrudan etkiler. Referans parametreler ref anahtar kelimesi ile belirtilir.

void ReferansParametre(ref int sayi)
{
    sayi = sayi * 2;
    Console.WriteLine("Metot içinde sayi: " + sayi); // Metot içinde sayi: 20
}

int anaSayi = 10;
ReferansParametre(ref anaSayi);
Console.WriteLine("Ana metot içinde anaSayi: " + anaSayi); // Ana metot içinde anaSayi: 20

Çıkış Parametreleri (Output Parameters)

Çıkış parametreleri, metottan birden fazla değer döndürmek için kullanılır. Çıkış parametreleri de referans gibi çalışır, ancak metoda gönderilmeden önce değer atanması zorunlu değildir. Çıkış parametreler out anahtar kelimesi ile belirtilir.

void CikisParametre(int sayi, out int kare, out int kup)
{
    kare = sayi * sayi;
    kup = sayi * sayi * sayi;
}

int anaSayi = 5;
int kareSonucu, kupSonucu;
CikisParametre(anaSayi, out kareSonucu, out kupSonucu);
Console.WriteLine("Karesi: " + kareSonucu + ", Küpü: " + kupSonucu); // Karesi: 25, Küpü: 125

Parametre Dizileri (Parameter Arrays)

Parametre dizileri, bir metoda değişken sayıda aynı tipte parametre göndermek için kullanılır. Parametre dizileri params anahtar kelimesi ile belirtilir ve metodun parametre listesinde son parametre olmalıdır.

int ToplaParams(params int[] sayilar)
{
    int toplam = 0;
    foreach (int sayi in sayilar)
    {
        toplam += sayi;
    }
    return toplam;
}

int toplam1 = ToplaParams(1, 2, 3); // toplam1 = 6
int toplam2 = ToplaParams(1, 2, 3, 4, 5); // toplam2 = 15
Console.WriteLine("Toplam 1: " + toplam1 + ", Toplam 2: " + toplam2);

Metot Aşırı Yüklemesi (Method Overloading)

C# dilinde, aynı isimde birden fazla metot tanımlanabilir. Bu duruma metot aşırı yüklemesi denir. Metotların aynı isme sahip olabilmesi için, parametre listelerinin farklı olması gerekir (parametre sayısı, veri tipi veya sırası farklı olabilir).

int Topla(int sayi1, int sayi2)
{
    return sayi1 + sayi2;
}

double Topla(double sayi1, double sayi2)
{
    return sayi1 + sayi2;
}

int toplamInt = Topla(5, 3); // int Topla metodu çağrılır
double toplamDouble = Topla(5.5, 3.2); // double Topla metodu çağrılır
Console.WriteLine("Integer Toplam: " + toplamInt + ", Double Toplam: " + toplamDouble);

Sonuç

Metotlar, C# programlama dilinde kodun modülerliğini, tekrar kullanılabilirliğini ve okunabilirliğini artıran temel yapı taşlarıdır. Farklı parametre türleri ve metot aşırı yüklemesi gibi özellikler, metotların esnekliğini ve gücünü artırır. Bu makalede öğrendiğiniz bilgilerle, C# projelerinizde daha etkili ve düzenli metotlar oluşturabilirsiniz.

8. Metotlar (Fonksiyonlar) ve Parametreler yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

7. Döngüler (for, while, do-while, foreach)

C# programlama dilinde döngüler, belirli bir kod bloğunu tekrar tekrar çalıştırmak için kullanılan temel kontrol yapılarıdır. Bu yapılar, bir koşul sağlandığı sürece veya bir koleksiyonun tüm elemanları üzerinde işlem yapılana kadar kodun tekrarlanmasını sağlar. C#, geliştiricilere farklı ihtiyaçlara uygun çeşitli döngü türleri sunar: for, while, do-while ve foreach.

Döngülerin Önemi

Döngüler, programlamada tekrar eden işlemleri otomatikleştirmek ve karmaşık algoritmaları uygulamak için vazgeçilmezdir. Veri işleme, hesaplama, kullanıcı arayüzü oluşturma gibi birçok alanda kullanılırlar. Döngüler sayesinde, aynı kodu birden çok kez yazmak yerine, döngü mekanizması sayesinde bu işlemler otomatik olarak gerçekleştirilir. Bu da kodun daha okunabilir, sürdürülebilir ve hatasız olmasını sağlar.

for Döngüsü

for döngüsü, belirli bir sayıda tekrar yapılması gereken durumlarda kullanılır. Genellikle bir sayaç değişkeni ile birlikte kullanılır ve döngünün kaç kez çalışacağını önceden belirlemek için idealdir.

for Döngüsünün Yapısı

for döngüsünün genel yapısı aşağıdaki gibidir:

for (başlangıç; koşul; artış/azalış) {
    // Tekrarlanacak kod bloğu
}

• Başlangıç: Döngü başlamadan önce bir sayaç değişkeni tanımlanır ve ilk değeri atanır.
• Koşul: Döngünün devam edip etmeyeceğini belirleyen bir mantıksal ifadedir. Koşul doğru (true) olduğu sürece döngü çalışmaya devam eder.
• Artış/Azalış: Her döngü adımında sayaç değişkeninin değeri artırılır veya azaltılır. Bu, döngünün sonlanmasını sağlar.

for Döngüsü Örneği

Aşağıdaki örnek, 1’den 10’a kadar olan sayıları ekrana yazdırır:

for (int i = 1; i <= 10; i++) {
    Console.WriteLine(i);
}

Bu kodda, i değişkeni 1’den başlar ve her adımda 1 artar. Döngü, i değeri 10’dan küçük veya eşit olduğu sürece devam eder. Her adımda i değeri ekrana yazdırılır.

while Döngüsü

while döngüsü, belirli bir koşul sağlandığı sürece bir kod bloğunu tekrar tekrar çalıştırmak için kullanılır. Koşul, döngünün başında kontrol edilir. Eğer koşul başlangıçta yanlış (false) ise, döngü hiç çalışmaz.

while Döngüsünün Yapısı

while döngüsünün genel yapısı aşağıdaki gibidir:

while (koşul) {
    // Tekrarlanacak kod bloğu
}

• Koşul: Döngünün devam edip etmeyeceğini belirleyen bir mantıksal ifadedir. Koşul doğru (true) olduğu sürece döngü çalışmaya devam eder.

while Döngüsü Örneği

Aşağıdaki örnek, kullanıcının girdiği sayı 0’dan farklı olduğu sürece sayıları toplamaya devam eder:

int toplam = 0;
int sayi = 1;

while (sayi != 0) {
    Console.Write("Bir sayı girin (0 çıkış): ");
    sayi = int.Parse(Console.ReadLine());
    toplam += sayi;
}

Console.WriteLine("Toplam: " + toplam);

Bu kodda, döngü sayi değişkeni 0’dan farklı olduğu sürece devam eder. Kullanıcıdan bir sayı alınır ve toplam değişkenine eklenir. Kullanıcı 0 girdiğinde döngü sona erer ve toplam ekrana yazdırılır.

do-while Döngüsü

do-while döngüsü, while döngüsüne benzer, ancak koşul döngünün sonunda kontrol edilir. Bu, döngünün en az bir kez çalışmasını garanti eder.

do-while Döngüsünün Yapısı

do-while döngüsünün genel yapısı aşağıdaki gibidir:

do {
    // Tekrarlanacak kod bloğu
} while (koşul);

• Koşul: Döngünün devam edip etmeyeceğini belirleyen bir mantıksal ifadedir. Koşul doğru (true) olduğu sürece döngü çalışmaya devam eder.

do-while Döngüsü Örneği

Aşağıdaki örnek, kullanıcıdan geçerli bir şifre girmesini ister ve şifre doğru olana kadar tekrar sorar:

string sifre;
do {
    Console.Write("Şifreyi girin: ");
    sifre = Console.ReadLine();
} while (sifre != "gizli");

Console.WriteLine("Şifre doğru!");

Bu kodda, döngü en az bir kez çalışır ve kullanıcıdan bir şifre girmesi istenir. Girilen şifre “gizli” değilse, döngü tekrar başlar ve kullanıcıdan tekrar şifre girmesi istenir. Şifre doğru girildiğinde döngü sona erer.

foreach Döngüsü

foreach döngüsü, bir koleksiyonun (dizi, liste, vb.) tüm elemanları üzerinde işlem yapmak için kullanılır. Bu döngü, koleksiyonun her bir elemanı için kod bloğunu otomatik olarak çalıştırır.

foreach Döngüsünün Yapısı

foreach döngüsünün genel yapısı aşağıdaki gibidir:

foreach (veri_tipi değişken in koleksiyon) {
    // Tekrarlanacak kod bloğu
}

• Veri Tipi: Koleksiyondaki elemanların veri tipini belirtir.
• Değişken: Koleksiyondaki her bir elemanı temsil eden bir değişkendir.
• Koleksiyon: Üzerinde işlem yapılacak olan koleksiyon (dizi, liste, vb.).

foreach Döngüsü Örneği

Aşağıdaki örnek, bir dizideki tüm sayıları ekrana yazdırır:

int[] sayilar = { 1, 2, 3, 4, 5 };

foreach (int sayi in sayilar) {
    Console.WriteLine(sayi);
}

Bu kodda, sayilar dizisindeki her bir sayı sayi değişkenine atanır ve ekrana yazdırılır. Döngü, dizinin tüm elemanları üzerinde işlem yapana kadar devam eder.

Döngülerde Dikkat Edilmesi Gerekenler

• Sonsuz Döngülerden Kaçının: Döngü koşulunun hiçbir zaman false olmaması durumunda, döngü sonsuza kadar çalışır. Bu durumu önlemek için koşulun doğru bir şekilde tanımlandığından ve döngü içinde koşulu etkileyen bir değişiklik yapıldığından emin olun.
• Performansı Göz Önünde Bulundurun: Özellikle büyük veri kümeleri üzerinde çalışan döngülerde, performans önemlidir. Gereksiz işlemleri döngü dışına taşıyarak ve uygun veri yapılarını kullanarak performansı artırabilirsiniz.
• Okunabilirliği Artırın: Döngülerin içindeki kodun okunabilir ve anlaşılır olması, kodun bakımını ve hataların giderilmesini kolaylaştırır. Anlamlı değişken isimleri kullanın ve karmaşık işlemleri daha küçük parçalara ayırın.

“Döngüler, programlamanın temel yapı taşlarından biridir. İyi tasarlanmış döngüler, karmaşık problemleri çözmek ve verimli çözümler üretmek için güçlü bir araçtır.” – Bilgisayar Bilimi Uzmanı

Sonuç

C# programlama dilinde for, while, do-while ve foreach döngüleri, farklı ihtiyaçlara uygun esnek ve güçlü araçlar sunar. Bu döngülerin doğru kullanımı, kodun daha verimli, okunabilir ve sürdürülebilir olmasını sağlar. Döngülerin yapısını ve kullanım senaryolarını iyi anlamak, başarılı bir C# geliştiricisi olmak için önemlidir.

7. Döngüler (for, while, do-while, foreach) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

C# Programlama Dilinde Koşullu İfadeler (if-else, switch-case)

C# programlama dilinde, programların akışını kontrol etmek ve farklı durumlara göre farklı işlemler gerçekleştirmek için koşullu ifadeler kullanılır. Bu ifadeler, programın karar verme yeteneğini artırır ve daha karmaşık ve esnek uygulamalar geliştirmeyi mümkün kılar. En sık kullanılan koşullu ifadeler if-else ve switch-case yapısıdır. Bu makalede, bu yapıları detaylı bir şekilde inceleyeceğiz.

if-else İfadeleri

if-else ifadesi, bir koşulun doğru (true) veya yanlış (false) olmasına göre farklı kod bloklarını çalıştırmak için kullanılır. Temel sözdizimi şu şekildedir:

if (koşul)
{
    // Koşul doğru ise çalışacak kod bloğu
}
else
{
    // Koşul yanlış ise çalışacak kod bloğu
}

Burada koşul, bir boolean ifade olmalıdır. Eğer koşul doğru ise, if bloğu içindeki kod çalışır; aksi takdirde, eğer varsa else bloğu içindeki kod çalışır.

if İfadesi

Sadece bir koşulun doğruluğunu kontrol etmek ve eğer doğruysa bir kod bloğunu çalıştırmak istiyorsak, sadece if ifadesini kullanabiliriz. Örneğin:

int sayi = 10;
if (sayi > 0)
{
    Console.WriteLine("Sayı pozitiftir.");
}

Bu örnekte, sayi değişkeninin değeri 0’dan büyükse, ekrana “Sayı pozitiftir.” yazdırılır.

else İfadesi

Bir koşulun yanlış olması durumunda da bir işlem yapmak istiyorsak, else ifadesini kullanırız. Örneğin:

int sayi = -5;
if (sayi > 0)
{
    Console.WriteLine("Sayı pozitiftir.");
}
else
{
    Console.WriteLine("Sayı negatif veya sıfırdır.");
}

Bu örnekte, sayi değişkeninin değeri 0’dan büyük değilse, ekrana “Sayı negatif veya sıfırdır.” yazdırılır.

else if İfadesi

Birden fazla koşulu kontrol etmek ve farklı koşullara göre farklı işlemler yapmak istiyorsak, else if ifadesini kullanırız. Örneğin:

int not = 75;

if (not >= 90)
{
    Console.WriteLine("A");
}
else if (not >= 80)
{
    Console.WriteLine("B");
}
else if (not >= 70)
{
    Console.WriteLine("C");
}
else if (not >= 60)
{
    Console.WriteLine("D");
}
else
{
    Console.WriteLine("F");
}

Bu örnekte, not değişkeninin değerine göre farklı notlar (A, B, C, D, F) ekrana yazdırılır. else if zinciri, yukarıdan aşağıya doğru koşulları kontrol eder ve ilk doğru olan koşulun bloğunu çalıştırır. Eğer hiçbir koşul doğru değilse, en sondaki else bloğu çalışır.

switch-case İfadesi

switch-case ifadesi, bir değişkenin değerine göre farklı kod bloklarını çalıştırmak için kullanılır. Özellikle, bir değişkenin birden fazla olası değeri olduğunda ve her bir değer için farklı bir işlem yapmak gerektiğinde kullanışlıdır. Temel sözdizimi şu şekildedir:

switch (değişken)
{
    case değer1:
        // değişken değeri değer1 ise çalışacak kod bloğu
        break;
    case değer2:
        // değişken değeri değer2 ise çalışacak kod bloğu
        break;
    ...
    default:
        // değişken değeri hiçbir case ile eşleşmezse çalışacak kod bloğu
        break;
}

Burada değişken, bir ifade veya değişken olabilir. case etiketleri, değişkenin olası değerlerini temsil eder. Eğer değişkenin değeri bir case etiketiyle eşleşirse, o case bloğu içindeki kod çalışır. break ifadesi, switch ifadesinden çıkılmasını sağlar. Eğer break ifadesi kullanılmazsa, eşleşen case bloğundan sonraki case blokları da çalıştırılır (fall-through). default etiketi, değişkenin değeri hiçbir case etiketiyle eşleşmezse çalışacak olan kod bloğunu belirtir.

Örneğin:

int gun = 3;
string gunAdi;

switch (gun)
{
    case 1:
        gunAdi = "Pazartesi";
        break;
    case 2:
        gunAdi = "Salı";
        break;
    case 3:
        gunAdi = "Çarşamba";
        break;
    case 4:
        gunAdi = "Perşembe";
        break;
    case 5:
        gunAdi = "Cuma";
        break;
    case 6:
        gunAdi = "Cumartesi";
        break;
    case 7:
        gunAdi = "Pazar";
        break;
    default:
        gunAdi = "Geçersiz gün numarası";
        break;
}

Console.WriteLine("Gün: " + gunAdi);

Bu örnekte, gun değişkeninin değerine göre haftanın gün adı belirlenir ve ekrana yazdırılır. Eğer gun değişkeninin değeri 1 ile 7 arasında değilse, default bloğu çalışır ve ekrana “Geçersiz gün numarası” yazdırılır.

Koşullu İfadelerin Önemi

Koşullu ifadeler, programlama dillerinin temel yapı taşlarından biridir ve programların karar verme yeteneğini sağlar. Bu sayede, programlar farklı durumlara uyum sağlayabilir, kullanıcı girdilerine göre farklı işlemler gerçekleştirebilir ve daha karmaşık algoritmalar uygulayabilir. if-else ve switch-case ifadeleri, C# programlama dilinde en sık kullanılan koşullu ifadelerdir ve programların akışını kontrol etmek için vazgeçilmez araçlardır.

Doğru ve etkili koşullu ifadeler kullanarak, daha okunabilir, bakımı kolay ve hatasız kodlar yazabilirsiniz. Bu nedenle, koşullu ifadelerin kullanımını iyi anlamak ve pratik yapmak, başarılı bir C# programcısı olmak için önemlidir.

Sonuç

Bu makalede, C# programlama dilinde kullanılan koşullu ifadelerden if-else ve switch-case yapılarını detaylı bir şekilde inceledik. Bu yapıların nasıl kullanıldığını, ne zaman tercih edildiğini ve programların akışını nasıl kontrol ettiğini öğrendik. Koşullu ifadeler, programlama becerilerinizi geliştirmenize ve daha karmaşık uygulamalar oluşturmanıza yardımcı olacaktır.

“Koşullu ifadeler, programların karar verme mekanizmalarını oluşturur ve onları daha akıllı hale getirir.” – Bilge Programcı

6. Koşullu İfadeler (if-else, switch-case) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.