C# ile örneklerle derinlemesine LINQ sorgu işlemleri

Merhabalar,

Bu yazıda LINQ üzerinden yapabileceğimiz çeşitli sorgu yapılarını anlatacağım. Bir önceki yazıda sadece lambda ifadelerine değinmiştim. Bu lambda ifadelerinin nereden geldikleriyle ilgili ayrıntı bilgi vermiştim. Ben genellikle lambda ifadelerini kulanarak, LINQ üzerinde tanımlı extension metodlar ile işlemler yaparım. Ancak LINQ’in kullanımı sadece bu şekilde değildir. C# üzerinden, tıpkı sql sorgusu yazar gibi (tabi ki biraz değişiklikleri var) LINQ sorgusu da yazabiliriz. Temel olarak anahtar kelimeler ile extension metodlarının isimleri hemen hemen aynı. Eğer sql biliyorsanız da pek yabancılık çekeceğinizi sanmıyorum.

Konuya bir örnekle başlayalım ve bu örnekle bir önceki yazıda nelerden bahsettiğimizi hatırlarken nelerden bahsetmediğimiz hakkındaki ön bilgiyi örnek üzerinde inceleyelim.

sade gorunum kopyala yazdir ?

using System;
using System.Linq;
using System.Collections.Generic;
namespace helvacikoylu
{
internal class Program
{
private static void Main(string[] args)
{
List<string> liste = new List<string>
{
“helvacıköylü”,
“mehmet”,
“ertuğrul”,
“C#”,
“Framework”,
“dot Net”
};
IEnumerable<string> sonuc1 = liste.Where(x => x.Contains(“a”));
IEnumerable<string> sonuc2 = from x in liste where x.Contains(“a”) select x;
Console.WriteLine(“# sonuç 1 #”);
foreach (string s in sonuc1)
Console.WriteLine(“-> ” + s);
Console.WriteLine(“\n# sonuç 2 #”);
foreach (string s in sonuc2)
Console.WriteLine(“-> ” + s);
Console.ReadLine();
}
}
}

Örneğimizdeki dizimiz (koleksiyonumuz) 6 elemana sahip bir string dizi. Dizimiz üzerinde iki LINQ sorgu işlemi yaptık. İlkine bir önceki yazıdan aşinasınız Where metodu ile yaptığımız bu sorgu, dizi elemanları içinde, içinde “a” geçen elemanları IEnumerable olarak döndürüyor. Zaten kodun ilerleyen kısımlarında ekrana “# sonuç 1 #” başlığı altında bu sorgudan gelen sonuçları ekrana yazdırıyoruz. Ikinci sorgumuz ise bu yazıda ele alacağımız sorgu tipi. Daha önceden böyle bir şey görmediyseniz, C#’da böyle bir yapının çalışacağından, syntax’ın nasıl tanınabileceğinden dolayı şaşırmış olabilirsiniz. Örnekteki iki sorgu da aynı işi yapar. Programı çalıştırıp kendiniz görün.

Genelde ilk sorgudaki, yani daha önceden de bahsettiğim direkt olarak extension metoda ulaşma şekli kullanılır. Zaten bu söz dizimi C# ‘a daha aşinadır. Örneğimizdeki kullanımı da diğerine göre daha kısa ve pratiktir. Ancak birden fazla tablonun birbirine bağlanacağı, tablolardan belirli verilerin çekileceği, diğerlerinin çekilmeyeceği gibi yapılarda 1. sorgu tipi, yani lambda ifadeli sorgu tipinde sıkıntı yaşama ihtimaliniz daha yüksektir. Metod’dan dönen değeri başka bir metoda, ondan döneni başka bir metoda şeklinde, union, join, where gibi metodların arka arkaya sıralanması hem okunabilirlik açısından hem de yazılabilirlik açısından epeyce zorlaşır. Yazının sonlarına doğru böyle karışık sorgulara örnekler vereceğim. O zaman daha iyi anlayacaksınız. Ancak öncesinde LINQ üzerinde kullanılan bazı yapılardan bahsedelim.

LINQ Metodları

Min, dizideki en küçük elemanın değerini döndürür, elemanın IComparable arayüzünden implement edilmiş olması gereklidir.
Max, dizideki en büyük elemanın değerini döndürür. Min ile aynı kullanımı sahiptir.
Sum, dizideki tüm elemanların toplamını döndürür.
Count, dizideki eleman sayısını verir. Toplam eleman sayısını verebileceği gibi, belirli kriterlerin uygulandığı eleman sayısının toplamını da verebilir.
FirstOrDefault, kritere uyan ilk elemanı döndürür. Herhangi bir kriter belirlenmezse dizideki ilk elemanı döndürür.
Any, dizide kritere uygun eleman olup olmadığını bool cinsinden döndürür, kriter girilmezse dizide eleman olup olmadığını kontrol eder.
Skip, girilen parametre kadar (int) dizinin başından o kadar elemanı atlar.
Take, girilen parametre kadar (int) diziden o kadar elemanı seçer.
OrderBy, dizideki elemanları girilen kritere göre A’dan Z’ye sıralar
OrderByDescending, dizideki elemanları girilen kritere göre Z’den A’ya sıralar.
Distinct, dizideki elemanları seçer ancak aynı değere sahip elemanları tek alır, dizide 5 adet elemanın değeri 2 ise, 1 adet 2 döner.
Select, her bir dizi elemanı içinden sadece belirli tipleri seçmeyi sağlar, “new” anahtar kelimesi altında çoklu alan seçilirse dönen değer anonimdir ve “var” olarak tanımlanmalıdır.
ToDictionary, çift parametreli olarak diziyi Dictionary tipine aktarır.
ToArray, IEnumerable<tip> olarak dönen diziyi tip[] şeklinde diziye çevirir.
ToList, IEnumerable<tip> olarak dönen diziyi List<tip> şeklinde diziye çevirir.
Except, dizinin, parametre olarak girilen 2. dizide olmayan elemanlarını listeler.
Union, diziye, parametre olarak girilen 2. dizinin elemanlarını ekler.
Intersect, dizinin, paramatre olarak girilen 2. dizi ile olan ortak elemanlarını listeler.

Yukarıdaki kullanımlardaki yapılan genel olarak koleksiyonlardır ancak ben hepsini dizi olarak anlatıyorum. Bu açıdan sıkıntı çıkacağını düşünmüyorum, dizi demeye devam 🙂

Şimdi tüm bunları geniş bir örnekle görelim. Örneğin kodlarını kopyalayıp yapıştırın ve çalıştırarak inceleyin. Daha iyi anlarsınız.

Örneğin daha opsiyonel olması açısından ve veritabanı işlemlerine benzerlik teşkil etmesi açısından dizi elemanlarını “Eleman” isimli bir sınıf olarak atadım. Ayrıca elemanları teker teker yukarıda tanımladıktan sonra diziye ekledim. Intersect, Union gibi işlemler için bunu böyle yapmam gerekiyordu. Çünkü iki elemanın eşitliği karşılaştırmasında iki sınıfın da heap bellekte aynı yerde bulunması önemliydi. Neyse kafanızı fazla karıştırmayım, örneği inceleyin 🙂

sade gorunum kopyala yazdir ?

using System;
using System.Linq;
using System.Collections.Generic;
namespace helvacikoylu
{
public class Eleman
{
public int Id { get; set; }
public string Isim { get; set; }
public byte Tip { get; set; }
}
internal class Program
{
static void Main(string[] args)
{
Eleman a1 = new Eleman {Id = 1, Isim = “C”, Tip = 1};
Eleman a2 = new Eleman {Id = 2, Isim = “C++”, Tip = 1};
Eleman a3 = new Eleman {Id = 3, Isim = “C#”, Tip = 1};
Eleman a4 = new Eleman {Id = 4, Isim = “Visual Basic”, Tip = 2};
Eleman a5 = new Eleman {Id = 5, Isim = “VB.NET”, Tip = 2};
Eleman a6 = new Eleman {Id = 6, Isim = “F#”, Tip = 3};
Eleman a7 = new Eleman {Id = 7, Isim = “ASP.NET”, Tip = 4};
Eleman a8 = new Eleman {Id = 8, Isim = “MVC”, Tip = 4};
Eleman b1 = new Eleman {Id = 11, Isim = “Pascal”, Tip = 1};
Eleman b2 = new Eleman {Id = 12, Isim = “Delphi”, Tip = 1};
Eleman b3 = new Eleman {Id = 13, Isim = “Java”, Tip = 2};
Eleman b4 = new Eleman {Id = 14, Isim = “Quick Basic”, Tip = 4};
List<Eleman> liste = new List<Eleman> {a1, a2, a3, a4, a5, a6, a7, a8};
List<Eleman> liste2 = new List<Eleman> {a1, a2, a5, a8};
List<Eleman> liste3 = new List<Eleman> {b1, b2, b3, b4};
//Min, Max, Sum, Count
Console.WriteLine(“-> en küçük Tip değeri : ” + liste.Min(x => x.Tip));
Console.WriteLine(“-> en büyük Tip değeri : ” + liste.Max(x => x.Tip));
Console.WriteLine(“-> Id değerlerinin toplamı : ” + liste.Sum(x => x.Id));
Console.WriteLine(“-> eleman sayısı : ” + liste.Count());
Console.WriteLine(“-> Tip değeri 1 olan eleman sayısı : ” + liste.Count(x => x.Tip == 1));
//FirstOrDefault, (First)
Console.WriteLine(“-> Tip değeri 2’den büyük elemanlardan ilkinin adı : ” + liste.FirstOrDefault(x => x.Tip > 2).Isim);
//Any
Console.WriteLine(“-> dizide Tip’i 4’ten büyük eleman var mı : ” + liste.Any(x => x.Tip > 4));
//Skip
Console.WriteLine(“-> ilk 4 eleman atlandıktan sonraki ilk elemanın adı : ” + liste.Skip(4).FirstOrDefault().Isim);
//OrderBy ve OrderByDescending
Console.WriteLine(“-> Isime göre A->Z ilk eleman : ” + liste.OrderBy(x => x.Isim).FirstOrDefault().Isim);
Console.WriteLine(“-> Isime göre Z->A ilk eleman : ” + liste.OrderByDescending(x => x.Isim).FirstOrDefault().Isim);
//Distinct
Console.WriteLine(“-> dizide kaç farklı tip değeri var : ” + liste.Select(x => x.Tip).Distinct().Count());
//Select
var e0 = liste.Select(x => new {Ad = x.Isim, IslemTip = x.Tip});
foreach (var e in e0)
Console.WriteLine(“x-> Isim : ” + e.Ad + ” ve Tip : ” + e.IslemTip);
//ToDictionary
Dictionary<int, string> dict = liste.ToDictionary(x => x.Id, x => x.Isim);
Console.WriteLine(“-> Id’si 3 olan elemanın adı : ” + dict[3]);
//ToArray
Eleman[] a = liste.ToArray();
Console.WriteLine(“-> 5. elemanın adı : ” + a[5].Isim);
//Take
Console.WriteLine(“\n### dizideki ilk 4 elemanın isimleri:”);
IEnumerable<Eleman> e1 = liste.Take(4);
foreach (Eleman e in e1)
Console.WriteLine(“-> eleman adı : ” + e.Isim);
Console.WriteLine(“#\n”);
//Except
Console.WriteLine(“\n### dizinin liste2’de olmayan elemanları:”);
IEnumerable<Eleman> e2 = liste.Except(liste2);
foreach (Eleman e in e2)
Console.WriteLine(“-> eleman adı : ” + e.Isim);
Console.WriteLine(“#\n”);
//Union
Console.WriteLine(“-> liste ve liste3’ün birleşimindeki elemanlar:”);
IEnumerable<Eleman> e3 = liste.Union(liste3);
foreach(Eleman e in e3)
Console.WriteLine(“-> eleman adı : ” + e.Isim);
Console.WriteLine(“#\n”);
//Intersect
Console.WriteLine(“-> liste ve liste2’nin kesişim elemanları:”);
IEnumerable<Eleman> e4 = liste.Intersect(liste2);
foreach(Eleman e in e4)
Console.WriteLine(“-> eleman adı : ” + e.Isim);
Console.WriteLine(“#\n”);
Console.ReadLine();
}
}
}

LINQ Sorguları

Yukarıdaki açıklama ve örneklerle artık LINQ üzerinde birçok metodun nasıl kullanıldığını ne ne işe yaradığını görmüş oldunuz. Dikkatinizi çekmek istediğim nokta, Select kullanımındaki örnektir. Select kullanımının sonucunda elimize dönen değer yine bir IEnumerable arayüzünü implement almış bir dizi evet, ancak dizideki her bir eleman Ad ve IslemTip isimli değişkenlere sahip. Fakat biz böyle değişkenlere sahip herhangi bir sınıf tanımlamadık. Zaten bu yüzden IEnumerable<Eleman> benzeri bir tanımlama yerine “var” tanımamasını kullandık. Yani anonim tipli bir yapı oldu bu. Bununla ilgli ayrıntılı bilgi başka bir yazının konusudur. Burada sadece bu kadarını görün yeter.

LINQ üzerindeki sorgular, bir cümle gibi okunaklığı bakımından daha iyidir. Ancak C# genel söz diziminden biraz daha uzaktır. Bunun yanısıra, bazı yerlerde kullanılması daha uzun ve karmaşık olurken, bazı kompleks sorgularda lambda ifadelerle içinden çıkamayacağınız sorguları çok rahat yapmanıza olanak sağlar. LINQ sorgularında, “Select” metodunu içinde kullanmak zorunda olmanız, size sadece gerekli alanları çekmenizi sağlamada bir uyarıcı etkendir. Çünkü lambda ifadeler ile çalışırken genellikle Select metodu çok nadir çağrılır ve kullanılmayan gereksiz bazı alanların da çekilmesine neden olan sorgular gerçekleştirilir.

Şimdi basit birkaç LINQ sorgusuna örneğimiz üzerinde göz atalım.

sade gorunum kopyala yazdir ?

using System;
using System.Linq;
using System.Collections.Generic;
namespace helvacikoylu
{
public class Eleman
{
public int Id { get; set; }
public string Isim { get; set; }
public byte Tip { get; set; }
}
internal class Program
{
static void Main(string[] args)
{
Eleman a1 = new Eleman {Id = 1, Isim = “C”, Tip = 1};
Eleman a2 = new Eleman {Id = 2, Isim = “C++”, Tip = 1};
Eleman a3 = new Eleman {Id = 3, Isim = “C#”, Tip = 1};
Eleman a4 = new Eleman {Id = 4, Isim = “Visual Basic”, Tip = 2};
Eleman a5 = new Eleman {Id = 5, Isim = “VB.NET”, Tip = 2};
Eleman a6 = new Eleman {Id = 6, Isim = “F#”, Tip = 3};
Eleman a7 = new Eleman {Id = 7, Isim = “ASP.NET”, Tip = 4};
Eleman a8 = new Eleman {Id = 8, Isim = “MVC”, Tip = 4};
Eleman b1 = new Eleman {Id = 11, Isim = “Pascal”, Tip = 1};
Eleman b2 = new Eleman {Id = 12, Isim = “Delphi”, Tip = 1};
Eleman b3 = new Eleman {Id = 13, Isim = “Java”, Tip = 2};
Eleman b4 = new Eleman {Id = 14, Isim = “Quick Basic”, Tip = 4};
List<Eleman> liste = new List<Eleman> {a1, a2, a3, a4, a5, a6, a7, a8};
List<Eleman> liste2 = new List<Eleman> {a1, a2, a5, a8};
List<Eleman> liste3 = new List<Eleman> {b1, b2, b3, b4};
IEnumerable<Eleman> sorgu1 = from x in liste where x.Tip > 2 select x;
var sorgu2 = from x in liste where x.Id > x.Tip select new {x.Id, x.Isim};
var sorgu3 = from x in liste
from z in liste3
where x.Tip == z.Tip
select new
{
xIsim = x.Isim,
xTip = x.Tip,
zIsim = z.Isim,
zTip = z.Tip
};
Console.WriteLine(“# Sorgu 1 sonuçları :”);
Console.WriteLine(“Id\tIsim\tTip”);
foreach (var x in sorgu1)
Console.WriteLine(x.Id + “\t” + x.Isim + “\t” + x.Tip);
Console.WriteLine(“\n\n\n”);
Console.WriteLine(“# Sorgu 2 sonuçları :”);
Console.WriteLine(“Id\tIsim”);
foreach (var x in sorgu2)
Console.WriteLine(x.Id + “\t” + x.Isim);
Console.WriteLine(“\n\n\n”);
Console.WriteLine(“# Sorgu 3 sonuçları :”);
Console.WriteLine(“xIsim\txTip\tzIsim\tzTip”);
foreach (var x in sorgu3)
Console.WriteLine(x.xIsim + “\t” + x.xTip + “\t” + x.zIsim + “\t” + x.zTip);
Console.ReadLine();
}
}
}

Örneğimizde 3 sorgumuz mevcut. İlk sorgu lambda ifadelerle çok basit şekilde yazılabilecek bir sorgudur. Lambda ifadesi şuna denk gelir:

liste.Where(x => x.Tip > 2);

İkinci sorgumuz where ile seçimi yapıldıktan sonra listeden belirli kayıtların çekildiği sorgudur. Lambda ifadesi iki metodlu olarak yazılabilinir. Şuna benzer bir yapıda olur:

liste.Where(x => x.Id > x.Tip).Select(x => new {x.Id, x.Isim});

Üçüncü sorgumuz çok daha komplike bir sorgudur. Sorguda iki adet dizi birleştirilmiştir ve her bir diziye sırasıyla x,z isimleri atanmıştır. daha sonra where ile koşul olarak birinci dizinin tipiyle ikinci dizinin tipi eşitlenmiştir. Kısacası burada sadece tipleri birbirine eşit olan kayıtlar alınacaktır ve sonuç olarak iki diziden de veriler içeren bir anonim tip döndürülmüştür. Ben bunu lambda ifadelerle yazabilir miyim bilmiyorum. Birkaç dakika uğraştıktan sonra pes ettim. Ne gerek var ki 🙂

İşte LINQ sorgularının, lambda ifadelerine göre daha avantajlı olduğu bir yapıdır bu üçüncü sorgumuz. Genel olarak yazımın üçüncü sorgudaki gibi olmasını tavsiye ederim. İlk iki sorguda koşullar seçimler yanyana geldiğinden uzayan sorgularda okunabilirlik karışabilir. Ancak üçüncü sorgu gayet basittir. Bu sorguyu hemen satır satır inceleyelim.

1. satırda “from x in liste” bildirimi ile, sorgulanacak her kayıttan, x olanları liste dizisinin elemanını temsil edeceği ifade ediliyor.
2. satırda “from z in liste3” bildirimi ile, sorgulanacak her kayıttan, z olanları liste3 dizisinin elemanını temsil edecei ifade ediliyor.
3. satırda “where x.Tip == z.Tip” bildirimi ile, sadece x’lerin Tip değeriyle z’lerin Tip değeri eşit olan kayıtları seçileceği ifade ediliyor.
4. ve diğer satırlarda dönecek anonim tipin içinde hangi değişkenlerin hangi isimlerle olması gerektiği bildiriliyor.

Bu yazıya daha da fazla uzatmayalım, şimdilik hoşçakalın.