C# Koleksiyonlar (Collections)

Klasik siyah ekran konsol uygulaması üzerinden koleksiyonları uygulayabilirsiniz. C# .NET kütüphanesinde çeşitli türde koleksiyon mevcuttur. Bunlardan bazıları eski sürümlerden kalma veri modelleri olup kullanılması tavsiye edilmemektedir. (Örneğin, ArrayList)

Koleksiyonlar .NET Framework' un System.Collections isim alanında bulunmaktır. Mevcut dosyanın en üstüne using System.Collections; ile bu isim alanını ekleyebilirsiniz.

ArrayList Koleksiyonu

System.Collections.ArrayList

.NET teknolojisinin eksi sürümlerinden kalma bir koleksiyon çeşididir. List türünde liste tanımlarken ne türde bir liste olacağını da List<Type> şeklinde belirleyebiliyoruz. Ancak ArrayList içerisine her türden nesne konulabilmektedir. Kulağa güzel gibi geliyor olsa da bu durum eklenen her nesnenin object şeklinde referanslanmasına sebep olmaktadır. Boxing/unboxing işlemleri yani bir türün object türüne dönüştürülüp geri kendi türüne dönüştürülmesi programın çalışma hızını yavaşlatan bir yöntemdir.

static void Main(string[] args)
{
    ArrayList arrayList = new ArrayList();
    arrayList.Add("Metin"); // string ekleniyor
    arrayList.Add(12); // int ekleniyor
    arrayList.Add(8f); // float ekleniyor
    arrayList.Add(new string[] 
        { "Ali", "Osman", "Hasan" }); // dizi ekleniyor
    Console.WriteLine(arrayList[0]);
    Console.WriteLine(arrayList[1]);
    Console.WriteLine(arrayList[2]);
    Console.WriteLine((arrayList[3] as string[])[0]);
    Console.WriteLine((arrayList[3] as string[])[1]);
    Console.WriteLine((arrayList[3] as string[])[2]);
    Console.ReadKey();
}

Queue (Kuyruk)

System.Collections.Queue

ArrayList gibi .NET' in eski sürümlerinden kalma bir koleksiyon türüdür. Temel iki adet metodu bulunmaktadır. Enqueue metodu ile içerisine nesne eklenir. Dequeue metodu ile de eklenen nesneler metodun dönüş değeri olarak çıkarılır. İlk eklenen nesne ilk olarak çıkarılır. Ekleme ve çıkarma mantığı tamamen bir kuyruğun ilerleyişi gibidir.

static void Main(string[] args)
{
    Queue queue = new Queue();
    queue.Enqueue("1. Nesne");
    queue.Enqueue("2. Nesne");
    queue.Enqueue("3. Nesne");
    Console.WriteLine("Kuyrukta " + queue.Count + " adet nesne var");
    Console.WriteLine(queue.Dequeue());
    Console.WriteLine("Kuyrukta " + queue.Count + " adet nesne var");
    Console.WriteLine(queue.Dequeue());
    Console.WriteLine(queue.Dequeue());
    Console.ReadKey();
}

Stack (Yığın)

System.Collections.Stack

.NET' in eski sürümlerinden kalan bir başka koleksiyon türü ise Stack yani yığınlardır. Queue yani kuyruklar gibi iki adet temel metodu ile nesne eklenir ve çıkarılır. Push metodu ile nesne eklenir. Pop metodu ise kuyruklarda Dequeue metodunun yaptığı işin birebir aynısını yapar. Ekleme ve çıkarma mantığı kuyrukların tersine bir yığının birikip boşaltılması gibidir. İlk eklenen nesne en son çıkarılır. En son eklenen ise ilk çıkarılır.

static void Main(string[] args)
{
    Stack stack = new Stack();
    stack.Push("1.Nesne");
    stack.Push("2.Nesne");
    stack.Push("3.Nesne");
    Console.WriteLine("Yığında " + stack.Count + " adet nesne var");
    Console.WriteLine(stack.Pop());
    Console.WriteLine("Yığında " + stack.Count + " adet nesne var");
    Console.WriteLine(stack.Pop());
    Console.WriteLine(stack.Pop());
    Console.ReadKey();
}

Eski sürüm .NET koleksiyonlarından birkaçına değindikten sonra System.Collections.Generic sınıfındaki daha güncel koleksiyon türlerine değinebiliriz.

List (Listeler)

System.Collections.Generic.List<T>

Sıkça kullanılan ve başka bir konuda da değinilen listeler, .NET dünyasında vazgeçilmez bir veri modelidir. İçerisinde tuttuğu veriler sabit türde verilerdir. Add metodu ile veri ekleme, Remove ile silme, RemoveAt ile belli bir indisteki veriyi silme, [] operatörü ile indisteki veriye doğrudan ulaşmak mümkündür. Kullanımı oldukça basit bir koleksiyon türüdür.

Aşağıdaki örnek ile List türüne ait metotların çoğunu öğrenebilirsiniz.

static void Main(string[] args)
{
    List<string> ulkeler = new List<string>();
    ulkeler.Add("Türkiye"); // Türkiye ülkesini ekle
    EkranaYaz(ulkeler);
    ulkeler.Add("Azerbaycan"); // Azerbaycan ülkesini ekle
    EkranaYaz(ulkeler);
    ulkeler.Add("Fransa"); // Fransa ülkesini ekle
    EkranaYaz(ulkeler);
    ulkeler.Add("Almanya"); // Almanya ülkesini ekle
    EkranaYaz(ulkeler);
    ulkeler.Add("Hollanda"); // Hollanda ülkesini ekle
    EkranaYaz(ulkeler);
    ulkeler.Add("İspanya"); // İspanya ülkesini ekle
    EkranaYaz(ulkeler);
    ulkeler.Add("Şili"); // Şili ülkesini ekle
    EkranaYaz(ulkeler);
    ulkeler.Remove("Almanya"); // Almanya ülkesini sil
    EkranaYaz(ulkeler);
    ulkeler.RemoveAt(4); // 4. indisteki ülkeyi sil
    EkranaYaz(ulkeler);
    ulkeler.Reverse(); // Tüm listeyi ters çevir
    EkranaYaz(ulkeler);
    ulkeler.AddRange(new string[5]
    {
        "Irak", "İran", "Pakistan", "Hindistan", "Çin"
    }); // Toplu halde diziyi ekler
    EkranaYaz(ulkeler);
    ulkeler.Insert(3, "Rusya"); // Rusya ülkesini 3. indisten ekler
    EkranaYaz(ulkeler);
    string[] yeni_ulkeler = new string[]
        { "Norveç", "İsveç", "Danimarka" };
    // yeni_ulkeler dizisini toplu halde 5. indisten ekler
    ulkeler.InsertRange(5, yeni_ulkeler);
    EkranaYaz(ulkeler);
    // Türkiye' nin listedeki indisini verir
    Console.WriteLine(ulkeler.IndexOf("Türkiye"));
    Console.ReadKey();
}

// parametresi string listesi türünden bir metot tanımla
static void EkranaYaz(List<string> ulkeler)
{
    Console.Clear(); // Her seferinde ekranı temizle
    foreach (var ulke in ulkeler)
        Console.WriteLine(ulke);
    Console.ReadKey();
}

Dictionary (Sözlükler)

System.Collections.Generic.Dictionary<T1, T2>

Sözlükler belli bir anahtar değerine karşılık başka bir değeri içerisinde bulunduran koleksiyon modelleridir. Aşağıdaki örnekte kullanım şeklini inceleyebilirsiniz.

static void Main(string[] args)
{
    // anahtar türü string değer türü string dizisi olan bir sözlük tanımlanır
    Dictionary<string, string[]> departmanlar = new Dictionary<string, string[]>();
    string[] muhasebe_personeli = new string[]
        { "Ahmet", "Mehmet", "Işıl" };
    departmanlar.Add("Muhasebe", muhasebe_personeli);
    departmanlar.Add("Tasarım", new string[] {
        "Emre", "Kaan", "Songül", "Gülcan"
    }); // Add metoduyla sözlüğe anahtar ve değer eklenebilir
    departmanlar["Bilişim"] = new string[2]
    {
        "Yusuf", "Tarık"
    }; // atama suretiyle sözlüğe anahtar ve değer eklenebilir
    while (true)
    {
        Console.Write("Departman: ");
        string anahtar = Console.ReadLine();
        if (departmanlar.ContainsKey(anahtar))
            EkranaYaz(departmanlar[anahtar]);
        else
            Console.WriteLine("Departman bulunamadı");
    }
}

static void EkranaYaz(string[] kisiler)
{
    Console.Clear(); // Her seferinde ekranı temizle
    foreach (var kisi in kisiler)
        Console.WriteLine(kisi);
    Console.ReadKey();
}

Sözlüklerin (Dictionary) yapı olarak içerisindeki her elemanı KeyValuePair türünde öğelerdir. Eğer foreach döngüsü ile bu öğeleri tarayacak olursanız her öğenin böyle olduğunu görebilirsiniz.

static void Main(string[] args)
{
    Dictionary<string, List<int>> dictionary = new Dictionary<string, List<int>>();
    dictionary.Add("1. sayılar listesi", new List<int>());
    //dictionary["1. sayılar listesi"] öğesi List<int> türü bir listedir
    dictionary["1. sayılar listesi"].Add(5);
    dictionary["1. sayılar listesi"].Add(15);
    dictionary["1. sayılar listesi"].Add(25);
    dictionary.Add("asal sayılar", new List<int>()
    {
        2, 3, 5, 7, 11, 13, 15, 17
    });
    // 15 asal sayı olmadığı için silinsin
    dictionary["asal sayılar"].Remove(15);
    dictionary["kare sayılar"] = new List<int>() {
        1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144
    };
    // her pair değişkeni KeyValuePair<string, List<int>> türündedir
    foreach (var pair in dictionary)
    {
        // pair.Key anahtarları verir
        Console.Write(pair.Key + ": ");
        // pair.Value ise anahtarlara karşılık gelen değerleri verir
        foreach (var number in pair.Value)
        {
            Console.Write(number + "  ");
        }
        Console.WriteLine("\n"); // İki satır atla
    }
    Console.ReadKey();
}

Queue (Kuyruklar)

System.Collections.Generic.Queue<T>

Yukarıdaki eski .NET sürümünden kalma ve herhangi bir türe bağlı olmaksızın tanımlanan Queue türünün aksine yeni Queue türünde belli bir veri türüne göre tanımlama yapılabilmektedir. Metotlar aynı olup parametre ve geri dönüş değerleri tanımlanan T türü ile aynı olur.

static void Main(string[] args)
{
    Queue<string> queue = new Queue<string>();
    // önceki örnekteki aynı metotları kullanabilirsiniz
    // ancak sadece string türünde değerleri ekleyip çıkarabilirsiniz
    // Queue koleksiyonunu başka bir türe bağlı da tanımlayabilirsiniz
    Console.ReadKey();
}

Stack (Yığınlar)

System.Collections.Generic.Stack<T>

Yukarıdaki eski .NET sürümünden kalma ve herhangi bir türe bağlı olmaksızın tanımlanan Stack türünün aksine yeni Stack türünde belli bir veri türüne göre tanımlama yapılabilmektedir. Metotlar aynı olup parametre ve geri dönüş değerleri tanımlanan T türü ile aynı olur.

static void Main(string[] args)
{
    Stack<string> queue = new Stack<string>();
    // önceki örnekteki aynı metotları kullanabilirsiniz
    // ancak sadece string türünde değerleri ekleyip çıkarabilirsiniz
    // Stack koleksiyonunu başka bir türe bağlı da tanımlayabilirsiniz
    Console.ReadKey();
}

HashSet

System.Collections.Generic.HashSet<T>

HashSet tanımlandığı türde veri alan ve aynı veriden sadece 1 tane barındırabilen bir koleksiyondur. HashSet kullanımı kendisini tekrarlamaması gereken veri listeleri için ideal bir depolama yöntemidir. Çalışma mantığını anlamak için aşağıdaki kodu uygulayabilirsiniz.

static void Main(string[] args)
{
    HashSet<string> hashSet = new HashSet<string>();
    hashSet.Add("Ali"); // eklenecektir
    EkranaYaz(hashSet);
    hashSet.Add("Samet"); // eklenecektir
    EkranaYaz(hashSet);
    hashSet.Add("Ali"); // eklenmeyecektir
    EkranaYaz(hashSet);
    hashSet.Add("Mustafa"); // eklenecektir
    EkranaYaz(hashSet);
    hashSet.Add("Yasin"); // eklenmeyecektir
    EkranaYaz(hashSet);
    // eklenme_durumu false değerini alacaktır
    bool eklenme_durumu = hashSet.Add("Ali");
    Console.WriteLine(eklenme_durumu);
    Console.ReadKey();
}

static void EkranaYaz(HashSet<string> kisiler)
{
    Console.Clear(); // Her seferinde ekranı temizle
    foreach (var kisi in kisiler)
        Console.WriteLine(kisi);
    Console.ReadKey();
}

SortedSet

System.Collections.Generic.SortedSet<T>

SortedSet tanımlandığı türde veri alan ve aynı veriden sadece 1 tane barındırabilen bir koleksiyondur. Aldığı verileri içerisinde sıralanmış bir biçimde tutmaktadır. SortedSet kullanımı kendisini tekrarlamaması gereken sıralı veri listeleri için ideal bir depolama yöntemidir. Çalışma mantığını anlamak için aşağıdaki kodu uygulayabilirsiniz.

static void Main(string[] args)
{
    SortedSet<string> sortedSet = new SortedSet<string>();
    sortedSet.Add("Ali"); // eklenecektir
    EkranaYaz(sortedSet);
    sortedSet.Add("Samet"); // eklenecektir
    EkranaYaz(sortedSet);
    sortedSet.Add("Ali"); // eklenmeyecektir
    EkranaYaz(sortedSet);
    sortedSet.Add("Mustafa"); // eklenecektir
    EkranaYaz(sortedSet);
    sortedSet.Add("Yasin"); // eklenmeyecektir
    EkranaYaz(sortedSet);
    sortedSet.Add("Ahmet"); // eklenecektir
    EkranaYaz(sortedSet);
    // eklenme_durumu false değerini alacaktır
    bool eklenme_durumu = sortedSet.Add("Ali");
    Console.WriteLine(eklenme_durumu);
    Console.ReadKey();
}

static void EkranaYaz(SortedSet<string> kisiler)
{
    Console.Clear(); // Her seferinde ekranı temizle
    foreach (var kisi in kisiler)
        Console.WriteLine(kisi);
    Console.ReadKey();
}