• Tek Tip Sorgulama Söz Dizimi: Veri kaynağı ne olursa olsun (bellek içi koleksiyonlar, SQL veritabanları, XML belgeleri vb.), LINQ aynı sorgulama söz dizimini kullanmanıza olanak tanır. Bu, farklı veri kaynakları için farklı API'ler öğrenme ihtiyacını ortadan kaldırır.
• Derleme Zamanı Kontrolü: Geleneksel SQL sorgularının aksine, LINQ sorguları derleme zamanında kontrol edilir. Bu, yazım hataları veya uyumsuz türler gibi sorunların çalışma zamanı yerine geliştirme aşamasında tespit edilmesini sağlar, böylece uygulamanızın kararlılığı artar.
• Okunabilirlik ve Bakım Kolaylığı: LINQ sorguları, SQL'e oldukça benzer ve doğal dilimize yakın bir yapıya sahiptir. Bu, kodun okunabilirliğini artırır ve uzun vadede bakımını kolaylaştırır. Karmaşık veri işleme mantığını daha anlaşılır bir şekilde ifade edebilirsiniz.
• Gelişmiş IDE Desteği: Visual Studio gibi IDE'ler, LINQ sorguları için intellisense, hata ayıklama ve refactoring gibi kapsamlı destek sunar. Bu da geliştirme sürecini daha verimli hale getirir.
• Çeşitli Veri Kaynakları İçin Geniş Kapsam: LINQ, sadece ilişkisel veritabanlarıyla sınırlı değildir. Bellek içi koleksiyonlardan (LINQ to Objects), XML belgelerine (LINQ to XML), ADO.NET veri kümelerine (LINQ to DataSet) ve hatta özel veri kaynaklarına (LINQ to SQL, LINQ to Entities) kadar geniş bir yelpazedeki verilerle çalışabilir.

• LINQ to Objects: Bellek içi koleksiyonlar (List<T>, Array, Dictionary<TKey, TValue> vb.) üzerinde sorgulama yapmak için kullanılır. En temel LINQ sağlayıcısıdır ve LINQ'in gücünü doğrudan uygulama içindeki nesnelere taşır.
• LINQ to SQL: İlişkisel veritabanları (özellikle SQL Server) ile doğrudan etkileşim kurmak için tasarlanmıştır. Veritabanındaki tabloları C# sınıflarına dönüştürür ve LINQ sorgularını T-SQL'e çevirerek veritabanında yürütür. Artık eski bir teknoloji olarak kabul edilse de, bazı projelerde hala kullanılmaktadır.
• LINQ to XML: XML belgeleriyle çalışmak için kullanılır. XML ağaçlarını sorgulamak, değiştirmek ve oluşturmak için güçlü ve sezgisel bir yol sunar. XDocument, XElement gibi sınıflar aracılığıyla XML yapısını nesne olarak ele almanızı sağlar.
• LINQ to Entities: Entity Framework (EF) ile birlikte kullanılan en yaygın LINQ sağlayıcısıdır. EF, veritabanı ile uygulama arasında bir ORM (Object-Relational Mapper) katmanı sağlar. LINQ to Entities, LINQ sorgularını veritabanı sorgularına (SQL) dönüştürerek Entity Framework üzerinden yürütür. Bu, modern .NET uygulamalarında veritabanı etkileşimi için tercih edilen yöntemdir.
• LINQ to DataSet: ADO.NET DataSet nesneleri üzerinde LINQ sorguları çalıştırmak için kullanılır. Genellikle eski .NET uygulamalarında DataSet kullanımı yaygın olduğunda faydalıdır.

var sayilar = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

// Sorgu söz dizimi
var ciftSayilarQuery = from s in sayilar
                       where s % 2 == 0
                       select s;

Console.WriteLine("Çift Sayılar (Sorgu Söz Dizimi): " + string.Join(", ", ciftSayilarQuery)); // Çıktı: 2, 4, 6, 8, 10

// Metot söz dizimi (Lambda İfadesi ile)
var ciftSayilarMethod = sayilar.Where(s => s % 2 == 0);

Console.WriteLine("Çift Sayılar (Metot Söz Dizimi): " + string.Join(", ", ciftSayilarMethod)); // Çıktı: 2, 4, 6, 8, 10

var isimler = new List<string> { "Ayşe", "Mehmet", "Zeynep", "Can", "Ali" };

// Artan sıralama
var siraliIsimlerArtan = isimler.OrderBy(isim => isim);
Console.WriteLine("Sıralı İsimler (Artan): " + string.Join(", ", siraliIsimlerArtan)); // Çıktı: Ali, Ayşe, Can, Mehmet, Zeynep

// Azalan sıralama
var siraliIsimlerAzalan = isimler.OrderByDescending(isim => isim);
Console.WriteLine("Sıralı İsimler (Azalan): " + string.Join(", ", siraliIsimlerAzalan)); // Çıktı: Zeynep, Mehmet, Can, Ayşe, Ali

// Birden fazla kritere göre sıralama
var urunler = new List<dynamic>
{
    new { Ad = "Kalem", Fiyat = 5, Stok = 100 },
    new { Ad = "Defter", Fiyat = 10, Stok = 50 },
    new { Ad = "Silgi", Fiyat = 2, Stok = 100 },
    new { Ad = "Kalemtraş", Fiyat = 3, Stok = 75 }
};

// Stok ve sonra fiyata göre sıralama
var siraliUrunler = urunler.OrderBy(u => u.Stok).ThenBy(u => u.Fiyat);
Console.WriteLine("Sıralı Ürünler (Stok ve Fiyat):");
foreach (var u in siraliUrunler)
{
    Console.WriteLine($"- {u.Ad} (Stok: {u.Stok}, Fiyat: {u.Fiyat})");
}
/* Çıktı:
- Defter (Stok: 50, Fiyat: 10)
- Kalemtraş (Stok: 75, Fiyat: 3)
- Silgi (Stok: 100, Fiyat: 2)
- Kalem (Stok: 100, Fiyat: 5)
*/

var kisiler = new List<dynamic>
{
    new { Ad = "Ahmet", Soyad = "Yılmaz", Yas = 30 },
    new { Ad = "Ayşe", Soyad = "Demir", Yas = 25 },
    new { Ad = "Mehmet", Soyad = "Can", Yas = 35 }
};

// Sadece ad ve soyadları seçme
var tamAdlar = kisiler.Select(k => $"{k.Ad} {k.Soyad}");
Console.WriteLine("Tam Adlar: " + string.Join(", ", tamAdlar)); // Çıktı: Ahmet Yılmaz, Ayşe Demir, Mehmet Can

// Anonim tip kullanarak yeni nesneler oluşturma
var yeniKisiler = kisiler.Select(k => new { Isim = k.Ad, CiftYas = k.Yas * 2 });
Console.WriteLine("Yeni Kisiler:");
foreach (var k in yeniKisiler)
{
    Console.WriteLine($"- İsim: {k.Isim}, Çift Yas: {k.CiftYas})");
}
/* Çıktı:
- İsim: Ahmet, Çift Yas: 60
- İsim: Ayşe, Çift Yas: 50
- İsim: Mehmet, Çift Yas: 70
*/

var ogrenciler = new List<dynamic>
{
    new { Ad = "Ali", Bolum = "Bilgisayar Mühendisliği", NotOrtalamasi = 3.5 },
    new { Ad = "Veli", Bolum = "Elektrik-Elektronik Mühendisliği", NotOrtalamasi = 3.2 },
    new { Ad = "Ayşe", Bolum = "Bilgisayar Mühendisliği", NotOrtalamasi = 3.8 },
    new { Ad = "Can", Bolum = "İnşaat Mühendisliği", NotOrtalamasi = 2.9 },
    new { Ad = "Ebru", Bolum = "Elektrik-Elektronik Mühendisliği", NotOrtalamasi = 3.0 }
};

// Bölümlere göre gruplama
var bolumlereGoreGrupla = ogrenciler.GroupBy(o => o.Bolum);

Console.WriteLine("Bölümlere Göre Gruplanmış Öğrenciler:");
foreach (var grup in bolumlereGoreGrupla)
{
    Console.WriteLine($"- Bölüm: {grup.Key}");
    foreach (var ogrenci in grup)
    {
        Console.WriteLine($"  -- {ogrenci.Ad} ({ogrenci.NotOrtalamasi})");
    }
}
/* Çıktı:
- Bölüm: Bilgisayar Mühendisliği
  -- Ali (3.5)
  -- Ayşe (3.8)
- Bölüm: Elektrik-Elektronik Mühendisliği
  -- Veli (3.2)
  -- Ebru (3.0)
- Bölüm: İnşaat Mühendisliği
  -- Can (2.9)
*/

var kategoriler = new List<dynamic>
{
    new { Id = 1, Ad = "Elektronik" },
    new { Id = 2, Ad = "Giyim" },
    new { Id = 3, Ad = "Ev Eşyaları" }
};

var urunlerJoin = new List<dynamic>
{
    new { UrunId = 101, UrunAdi = "Akıllı Telefon", KategoriId = 1 },
    new { UrunId = 102, UrunAdi = "T-shirt", KategoriId = 2 },
    new { UrunId = 103, UrunAdi = "Mikrodalga Fırın", KategoriId = 3 },
    new { UrunId = 104, UrunAdi = "Laptop", KategoriId = 1 }
};

// Kategori ve ürünleri birleştirme
var birlesikVeri = from u in urunlerJoin
                   join k in kategoriler on u.KategoriId equals k.Id
                   select new { UrunAdi = u.UrunAdi, KategoriAdi = k.Ad };

Console.WriteLine("Birleştirilmiş Ürün ve Kategoriler:");
foreach (var item in birlesikVeri)
{
    Console.WriteLine($"- Ürün: {item.UrunAdi}, Kategori: {item.KategoriAdi}");
}
/* Çıktı:
- Ürün: Akıllı Telefon, Kategori: Elektronik
- Ürün: T-shirt, Kategori: Giyim
- Ürün: Mikrodalga Fırın, Kategori: Ev Eşyaları
- Ürün: Laptop, Kategori: Elektronik
*/

• Aggregate Metotları: Koleksiyondaki değerleri tek bir değere indirgemek için kullanılır. Örnekler: `Sum()`, `Average()`, `Count()`, `Min()`, `Max()`.
• Partitioning Metotları: Bir koleksiyonun belirli bir bölümünü almak için kullanılır. Örnekler: `Take` (ilk n öğe), `Skip` (ilk n öğeyi atla).
• Element Metotları: Bir koleksiyondan tek bir öğe almak için kullanılır. Örnekler: `First()`, `FirstOrDefault()`, `Single()`, `SingleOrDefault()`. Bu metotların hata fırlatma davranışları farklılık gösterir, bu yüzden dikkatli kullanılmalıdır.
• Quantifier Metotları: Koleksiyonun belirli bir koşulu karşılayıp karşılamadığını kontrol etmek için kullanılır. Örnekler: `Any()` (herhangi biri koşulu sağlıyor mu?), `All()` (tümü koşulu sağlıyor mu?), `Contains()` (belirli bir öğe var mı?).

• Sorguların Ertelemesi (Deferred Execution): LINQ sorguları, sonuçlar üzerinde gerçekten iterasyon yapılana kadar yürütülmez. Bu, sorguları birleştirme ve optimize etme fırsatı sunar ancak bazen beklenmeyen davranışlara yol açabilir. Sorguyu hemen yürütmek için `ToList()`, `ToArray()` veya `Count()` gibi metotları kullanabilirsiniz.
• Veritabanı İndeksleri: LINQ to Entities veya LINQ to SQL kullanırken, sorgularınızın performansını artırmak için veritabanındaki uygun sütunlarda indeksler oluşturduğunuzdan emin olun. İndeksler, `WHERE` ve `ORDER BY` clause'larının performansını önemli ölçüde etkiler.
• Seçici Veri Çekimi (Projection): Yalnızca ihtiyacınız olan sütunları seçin. Örneğin, `Select(x => new { x.Id, x.Ad })` kullanarak tüm tabloyu çekmek yerine sadece gerekli veriyi çekmek, ağ trafiğini ve bellek kullanımını azaltır. Entity Framework'te `Select` kullanarak anonim tipler veya DTO'lar (Data Transfer Objects) oluşturmak yaygın bir yaklaşımdır.
• Eager Loading vs. Lazy Loading: İlişkisel verileri çekerken, Entity Framework varsayılan olarak "Lazy Loading" kullanır. Bu, ilişkili verilerin yalnızca ihtiyaç duyulduğunda yüklenmesi anlamına gelir ve ek sorgulara neden olabilir (N+1 problemi). Performans kritik senaryolarda `Include()` metodu ile "Eager Loading" (tüm ilişkili veriyi tek bir sorguda yükleme) kullanmak daha iyi olabilir.
• AsNoTracking(): Eğer çekilen verileri sadece okuyacak ve değiştirmeyecekseniz, Entity Framework'te `AsNoTracking()` metodunu kullanın. Bu metot, Entity Framework'ün çekilen nesneleri takip etmesini engeller, bu da bellek ve performans açısından iyileşme sağlar.
• Karmaşık Sorguları Parçalama: Çok karmaşık LINQ sorgularını daha küçük, yönetilebilir parçalara ayırmak hem okunabilirliği artırır hem de hata ayıklamayı kolaylaştırır.
• SQL Sorgusu Önizlemesi: LINQ to Entities kullanırken, DbContext'in `ToQueryString()` metodunu veya bir SQL profiler kullanarak LINQ sorgularınızın veritabanında nasıl bir SQL sorgusuna dönüştüğünü kontrol edin. Bu, performans darboğazlarını tespit etmenize yardımcı olabilir.

"Performans odaklı uygulamalar geliştirirken, LINQ sorgularınızın veritabanı tarafında nasıl SQL'e dönüştürüldüğünü anlamak kritik öneme sahiptir. Yanlış tasarlanmış bir LINQ sorgusu, veritabanında beklenenden çok daha pahalı bir SQL sorgusuna dönüşebilir."

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