Diziler ve Koleksiyonlar

C#’ta diziler ve koleksiyonlar, birden fazla veriyi bir arada saklamak için kullanılan yapılardır. Diziler (arrays) sabit boyutluyken, koleksiyonlar (Lists, Dictionaries, Queues, Stacks) dinamik veri yapılarıdır.

1. Diziler (Arrays)

Dizi (array), aynı türde birden fazla veriyi tek bir değişken altında saklamaya yarar.

1.1. Dizi Tanımlama

veri_tipi[] dizi_adı = new veri_tipi[eleman_sayısı];

Örnek:

int[] sayilar = new int[5]; // 5 elemanlı bir dizi
sayilar[0] = 10;
sayilar[1] = 20;
sayilar[2] = 30;

Alternatif olarak, diziyi doğrudan başlatabiliriz:

int[] sayilar = { 10, 20, 30, 40, 50 };

1.2. Dizi Elemanlarına Erişim

Dizi elemanlarına indeks (index) numarası ile ulaşılır. İndeksler 0’dan başlar.

Console.WriteLine(sayilar[0]); // 10
Console.WriteLine(sayilar[2]); // 30

1.3. Dizi Elemanlarını Döngü ile Yazdırma

For döngüsüyle dizi elemanlarını ekrana yazdırma:

int[] sayilar = { 10, 20, 30, 40, 50 };

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

Foreach döngüsüyle daha kısa yazım:

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

1.4. Çok Boyutlu Diziler

Matris (2D Dizi) Tanımlama:

int[,] matris = new int[2, 3] { { 1, 2, 3 }, { 4, 5, 6 } };

Matris Elemanlarına Erişim:

Console.WriteLine(matris[0, 1]); // 2
Console.WriteLine(matris[1, 2]); // 6

Matris Üzerinde Döngü ile Gezinme:

for (int i = 0; i < matris.GetLength(0); i++)
{
    for (int j = 0; j < matris.GetLength(1); j++)
    {
        Console.Write(matris[i, j] + " ");
    }
    Console.WriteLine();
}

1.5. Jagged (Düzensiz) Diziler

Her satırda farklı sayıda eleman barındırabilen dizilerdir.

int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[] { 1, 2 };
jaggedArray[1] = new int[] { 3, 4, 5 };
jaggedArray[2] = new int[] { 6 };

Console.WriteLine(jaggedArray[1][2]); // 5

2. Koleksiyonlar (Collections)

C#’ta System.Collections.Generic namespace’i altında dinamik veri saklamak için kullanılan koleksiyonlar vardır.

Koleksiyon	Açıklama
`List<T>`	Dinamik dizidir, eleman ekleme/çıkarma yapılabilir.
`Dictionary<TKey, TValue>`	Anahtar-değer (key-value) eşleşmesi ile veri tutar.
`Queue<T>`	FIFO (First In, First Out) prensibiyle çalışır.
`Stack<T>`	LIFO (Last In, First Out) prensibiyle çalışır.

2.1. List<T> (Dinamik Dizi)

List<T> dizilere benzer ama dinamik boyutludur.

Liste Tanımlama ve Kullanım:

List<string> isimler = new List<string>();
isimler.Add("Ahmet");
isimler.Add("Mehmet");
isimler.Add("Ayşe");

Console.WriteLine(isimler[1]); // Mehmet

Elemanları Döngüyle Yazdırma:

foreach (var isim in isimler)
{
    Console.WriteLine(isim);
}

Liste Metotları:

isimler.Remove("Ahmet"); // "Ahmet" çıkarılır
isimler.RemoveAt(0); // İlk eleman çıkarılır
isimler.Clear(); // Tüm elemanlar silinir

2.2. Dictionary<TKey, TValue> (Anahtar-Değer Koleksiyonu)

Bir anahtar (key) ile bir değer (value) eşleşmesi sağlar.

Dictionary Tanımlama:

Dictionary<int, string> ogrenciler = new Dictionary<int, string>();
ogrenciler.Add(101, "Ali");
ogrenciler.Add(102, "Veli");

Veriye Erişim:

Console.WriteLine(ogrenciler[101]); // Ali

Döngüyle Elemanları Yazdırma:

foreach (var ogrenci in ogrenciler)
{
    Console.WriteLine($"No: {ogrenci.Key}, Ad: {ogrenci.Value}");
}

Anahtar İçeriyor mu? (ContainsKey)

if (ogrenciler.ContainsKey(103))
{
    Console.WriteLine("Öğrenci var.");
}
else
{
    Console.WriteLine("Öğrenci yok.");
}

2.3. Queue<T> (İlk Giren İlk Çıkar – FIFO)

Queue<T>, ilk giren ilk çıkar (FIFO – First In, First Out) prensibiyle çalışır.

Kuyruk Kullanımı:

Queue<string> bankaKuyrugu = new Queue<string>();
bankaKuyrugu.Enqueue("Ali");
bankaKuyrugu.Enqueue("Veli");
bankaKuyrugu.Enqueue("Ayşe");

Console.WriteLine(bankaKuyrugu.Dequeue()); // Ali (ilk giren çıkar)

2.4. Stack<T> (Son Giren İlk Çıkar – LIFO)

Stack<T>, son giren ilk çıkar (LIFO – Last In, First Out) prensibiyle çalışır.

Yığın (Stack) Kullanımı:

Stack<string> geriAl = new Stack<string>();
geriAl.Push("Sayfa 1");
geriAl.Push("Sayfa 2");
geriAl.Push("Sayfa 3");

Console.WriteLine(geriAl.Pop()); // Sayfa 3 (son eklenen çıkar)

3. Koleksiyon ve Dizi Karşılaştırması

Özellik	Dizi (Array)	List<T>	Dictionary<TKey, TValue>	Queue<T>	Stack<T>
Boyut	Sabit	Dinamik	Dinamik	Dinamik	Dinamik
Erişim	İndeks	İndeks	Anahtar (Key)	FIFO	LIFO
Performans	Daha hızlı	Daha esnek	Anahtar tabanlı erişim	İlk eklenen ilk çıkar	Son eklenen ilk çıkar
Kullanım	Sabit veri setleri için uygundur	Listeleme için uygundur	Anahtar-değer ilişkili veriler için uygundur	Kuyruk işlemleri için uygundur	Geri alma işlemleri için uygundur