object

public class NesneListesi
{
    private object[] _elemanlar;
    private int _sayac;

    public NesneListesi()
    {
        _elemanlar = new object[10];
        _sayac = 0;
    }

    public void Ekle(object eleman)
    {
        if (_sayac < _elemanlar.Length)
        {
            _elemanlar[_sayac++] = eleman;
        }
    }

    public object Al(int indeks)
    {
        if (indeks >= 0 && indeks < _sayac)
        {
            return _elemanlar[indeks];
        }
        throw new IndexOutOfRangeException();
    }
}

• Tip Güvenliği Eksikliği:
  Kod:

  object

  tipi, her şeyi tutabildiği için, bir
  Kod:

  NesneListesi

  'ne farklı tiplerde elemanlar eklenebilir. Örneğin, bir string listesine yanlışlıkla bir integer ekleyebilirsiniz. Daha sonra bu elemanı çekerken, doğru tipe
  Kod:

  cast

  etmek zorunda kalırdınız ve yanlış bir
  Kod:

  cast

  işlemi
  Kod:

  InvalidCastException

  hatasına yol açabilirdi. Bu hatalar genellikle çalışma zamanında ortaya çıktığı için tespit edilmesi daha zordur.
  
  Kod:

  NesneListesi liste = new NesneListesi();
  liste.Ekle("Merhaba"); // String ekledik
  liste.Ekle(123);      // Int ekledik
  
  string ilkEleman = (string)liste.Al(0); // OK
  int ikinciEleman = (int)liste.Al(1);   // OK
  
  // int ucuncuEleman = (int)liste.Al(0); // Hata! Çalışma zamanında InvalidCastException

• Performans Kaybı (Boxing/Unboxing): Değer tipleri (int, bool, struct vb.) bir
  Kod:

  object

  olarak ele alındığında, yığın bellekteki (stack) verinin yığın belleğe (heap) kopyalanması işlemine "boxing" denir. Tekrar orijinal değer tipine dönüştürülürken ise "unboxing" işlemi yapılır. Bu işlemler, bellekte ek tahsisat ve kopyalama gerektirdiği için performans maliyeti oluşturur. Özellikle büyük veri setleriyle çalışıldığında bu durum belirgin bir performans düşüşüne yol açabilir.

System.Collections.Generic

List<T>

Dictionary<TKey, TValue>

List<T>

// Sadece string tutabilen bir liste
List<string> isimler = new List<string>();
isimler.Add("Ali");
isimler.Add("Ayşe");
// isimler.Add(123); // Hata! Derleme zamanında tip hatası verir.

string ilkIsim = isimler[0]; // Doğrudan string olarak alabiliriz, cast işlemine gerek yok.

// Sadece int tutabilen bir liste
List<int> sayilar = new List<int>();
sayilar.Add(10);
sayilar.Add(20);
int ilkSayi = sayilar[0];

Dictionary<TKey, TValue>

// Anahtarı string, değeri int olan bir sözlük
Dictionary<string, int> ogrenciNotlari = new Dictionary<string, int>();
ogrenciNotlari.Add("Ahmet", 85);
ogrenciNotlari.Add("Zeynep", 92);
// ogrenciNotlari.Add(123, "Can"); // Hata! Yanlış tipte anahtar veya değer.

int ahmetinNotu = ogrenciNotlari["Ahmet"];

<T>

<TKey, TValue>

string

int

public class GenericDepo<T>
{
    private T _icerik;

    public GenericDepo(T icerik)
    {
        _icerik = icerik;
    }

    public T IcerikAl()
    {
        return _icerik;
    }

    public void IcerikBelirle(T yeniIcerik)
    {
        _icerik = yeniIcerik;
    }
}

GenericDepo<T>

// String tutan bir depo
GenericDepo<string> metinDeposu = new GenericDepo<string>("Merhaba Dünya");
Console.WriteLine(metinDeposu.IcerikAl()); // Çıktı: Merhaba Dünya
metinDeposu.IcerikBelirle("Genericler Harika!");
Console.WriteLine(metinDeposu.IcerikAl()); // Çıktı: Genericler Harika!
// metinDeposu.IcerikBelirle(123); // Hata! String yerine int atanamaz.

// Integer tutan bir depo
GenericDepo<int> sayiDeposu = new GenericDepo<int>(100);
Console.WriteLine(sayiDeposu.IcerikAl()); // Çıktı: 100
sayiDeposu.IcerikBelirle(200);
Console.WriteLine(sayiDeposu.IcerikAl()); // Çıktı: 200

// Kendi oluşturduğumuz bir sınıfı tutan depo
public class Ogrenci
{
    public string Ad { get; set; }
    public int Numara { get; set; }
}

GenericDepo<Ogrenci> ogrenciDeposu = new GenericDepo<Ogrenci>(new Ogrenci { Ad = "Fatma", Numara = 101 });
Console.WriteLine($"Öğrenci Adı: {ogrenciDeposu.IcerikAl().Ad}, Numarası: {ogrenciDeposu.IcerikAl().Numara}");

GenericDepo

public class MetotOrnekleri
{
    public static void Takas<T>(ref T a, ref T b)
    {
        T temp = a;
        a = b;
        b = temp;
    }

    public static void Main(string[] args)
    {
        int x = 10, y = 20;
        Console.WriteLine($"Takas öncesi: x = {x}, y = {y}");
        Takas<int>(ref x, ref y); // int tipleri için Takas
        Console.WriteLine($"Takas sonrası: x = {x}, y = {y}");

        string s1 = "Merhaba", s2 = "Dünya";
        Console.WriteLine($"Takas öncesi: s1 = {s1}, s2 = {s2}");
        Takas<string>(ref s1, ref s2); // string tipleri için Takas
        Console.WriteLine($"Takas sonrası: s1 = {s1}, s2 = {s2}");

        // Tip argümanını açıkça belirtmeye gerek kalmadan compiler çoğu zaman çıkarım yapabilir.
        double d1 = 1.1, d2 = 2.2;
        Console.WriteLine($"Takas öncesi: d1 = {d1}, d2 = {d2}");
        Takas(ref d1, ref d2); // double tipleri için Takas (compiler çıkarım yaptı)
        Console.WriteLine($"Takas sonrası: d1 = {d1}, d2 = {d2}");
    }
}

where

• Kod:

  where T : class

  : T'nin bir referans tipi olması gerektiğini belirtir (sınıflar, arayüzler, diziler, temsilciler).
  
  Kod:

      public class ReferansTipiIsleyici<T> where T : class
      {
          public void IslemYap(T eleman) { /* ... */ }
      }

• Kod:

  where T : struct

  : T'nin bir değer tipi olması gerektiğini belirtir (yapılar, enumlar).
  Kod:

  Nullable<T>

  dışında
  Kod:

  null

  olamaz.
  
  Kod:

      public class DegerTipiIsleyici<T> where T : struct
      {
          public void IslemYap(T eleman) { /* ... */ }
      }

• Kod:

  where T : new()

  : T'nin parametresiz bir kurucu metoda sahip olması gerektiğini belirtir. Bu kısıtlama, sınıf içerisinde
  Kod:

  new T()

  şeklinde yeni bir örnek oluşturulmasına izin verir. Bu kısıtlama her zaman son kısıtlama olmalıdır.
  
  Kod:

      public class Fabrika<T> where T : new()
      {
          public T YeniUret()
          {
              return new T(); // Parametresiz kurucu metot çağrılabilir.
          }
      }

• Kod:

  where T : TemelSınıf

  : T'nin belirtilen temel sınıftan türemiş olması veya temel sınıfın kendisi olması gerektiğini belirtir. Sadece bir temel sınıf kısıtlaması olabilir.
  
  Kod:

      public class Raporleyici<T> where T : Musteri
      {
          public void RaporOlustur(T musteri) { /* ... */ }
      }
  
      public class Musteri { /* ... */ }
      public class KurumsalMusteri : Musteri { /* ... */ }

• Kod:

  where T : IArayuz

  : T'nin belirtilen arayüzü uygulaması gerektiğini belirtir. Birden fazla arayüz kısıtlaması olabilir.
  
  Kod:

      public class Isleyici<T> where T : ILogger, IDisposable
      {
          public void IslemBaslat(T nesne)
          {
              nesne.Log("İşlem başlatıldı.");
              // ...
          }
      }
  
      public interface ILogger { void Log(string message); }
      public interface IDisposable { void Dispose(); }

• Birden Fazla Kısıtlama: Bir tip parametresine birden fazla kısıtlama uygulanabilir. Kısıtlamalar virgülle ayrılır ve sırası önemlidir (
  Kod:

  class/struct

  başta,
  Kod:

  new()

  sonda).
  
  Kod:

      public class GelişmişFabrika<T> where T : Musteri, ILogger, new()
      {
          public T UretVeKaydet()
          {
              T yeniNesne = new T();
              yeniNesne.Log("Yeni nesne oluşturuldu.");
              return yeniNesne;
          }
      }

• Tip Güvenliği: Generics, yanlış tiplerin kullanılmasına derleme zamanında engel olarak, çalışma zamanı hatalarını büyük ölçüde azaltır. Bu, özellikle büyük ve karmaşık uygulamalarda hata ayıklama süresini kısaltır.
• Kod Tekrar Kullanımı (Reusability): Aynı mantıkla çalışan ancak farklı veri tipleriyle iş yapan kodları tekrar tekrar yazmak yerine, tek bir generic sınıf veya metot tanımıyla farklı tipleri destekleyebilirsiniz. Bu, kod tabanını daha sade, okunabilir ve bakımı kolay hale getirir.
• Performans: Değer tipleri için boxing ve unboxing işlemlerini ortadan kaldırarak performansı artırır. Generic yapılar, derleme sırasında belirtilen tip argümanıyla özelleştirildiği için,
  Kod:

  object

  kullanımına kıyasla daha verimlidir.
• Daha Okunabilir ve Anlaşılır Kod: Kodun ne tür verilerle çalıştığı daha açık bir şekilde ifade edilir, bu da kodun okunabilirliğini artırır.

• Karmaşıklık: Özellikle birden fazla tip parametresi ve karmaşık kısıtlamalar kullanıldığında, generic kod başlangıçta anlaşılması zor olabilir. Ancak doğru tasarım ve dokümantasyon ile bu durum yönetilebilir.
• Sınırlamalar: Generic tipler üzerinde her işlemi yapamazsınız. Örneğin, bir generic tip parametresinin matematiksel operatörler (
  Kod:

  +

  ,
  Kod:

  -

  gibi) üzerinde doğrudan çalışması mümkün değildir çünkü bu operatörler tiplere özgüdür. Bu tür durumlar için genellikle
  Kod:

  IComparable<T>

  gibi arayüzler veya yansıma (reflection) kullanılabilir, ancak bu, performansı olumsuz etkileyebilir.

• LINQ (Language Integrated Query):
  Kod:

  IEnumerable<T>

  ,
  Kod:

  IQueryable<T>

  gibi arayüzler ve LINQ sorgu metotları tamamen generics üzerine kuruludur. Bu sayede, herhangi bir veri kaynağını (listeler, diziler, veritabanları vb.) tip güvenli bir şekilde sorgulayabilirsiniz.
• ASP.NET Core (MVC/API): Kontrolcü eylemlerinden gelen modeller, veri transfer nesneleri (DTO'lar) ve hatta bağımlılık enjeksiyonu (dependency injection) süreçlerinde generic tipler sıkça kullanılır.
• Entity Framework Core: Veritabanı tablolarını temsil eden
  Kod:

  DbSet<TEntity>

  gibi yapılar, veritabanı işlemlerini generic bir şekilde yönetir.
• Tasarım Desenleri: Fabrika (Factory), Builder, Repository gibi birçok tasarım deseninin generic versiyonları, daha esnek ve tip güvenli çözümler sunar.

object

"Generic programlama, aynı algoritmaların veya veri yapılarının farklı veri tipleri üzerinde çalışmasına izin veren bir programlama stilidir. Bu, kodu daha genel, yeniden kullanılabilir ve tip-güvenli hale getirir." - Wikipedia (Generic Programming)

Genişletmek için tıkla ...