LINQ Sorgulama Örnekleri

LINQ (Language Integrated Query - Dile Entegre Edilmiş Sorgulama), .NET Framework 2.0 sürümünde eklenti paketleriyle kullanılabilen .NET Framework 3.5 sürümü ve sonrasında ise tanımlı olarak gelen bir özelliktir.

Linq sorguları aşağıdaki gibi gruplandırılabilir:

• RestrictionOperators (Kısıtlama Operatörleri )
• GroupingOperators (Gruplandırma Operatörleri)
• AggregateOperators (Gruplama Fonksiyonu Operatörleri)
• ProjectionOperators (Seçme Operatörleri)
• Set Operators (Set Operatörleri)
• Conversion Operators (Dönüştürme Operatörleri)
• PartitioningOperators (Bölümleme Operatörleri)
• Element Operators (Eleman Operatörleri)
• MiscellaneousOperators (Çeşitli Operatöler)
• GenerationOperators (Üretim Operatörleri)
• Query Execution (Çalıştırma Operatörleri)
• OrderingOperators (Sıralama Operatörleri)
• Quantifiers (Ölçüm Operatörleri)
• JoinOperators (Birleştirme Operatörleri) 

Aşağıda bu gruplara ilişkin örnekler ve örneklerin oluşturduğu çıktılar verilmiştir.

1.       RestrictionOperators (Kısıtlama Operatörleri)

public void LinqRestriction()
{
    int[] sayilar = { 51, 14, 1, 73, 7, 5, 10, 7, 4, 6 };       
    var KucukSayilar =  from k in sayilar
                                  where k < 5
                                  select k;
        Console.WriteLine("Sayilar< 5:");
        foreach (var x in KucukSayilar)
        {
             Console.WriteLine(x);
        }
}


            

2.       GroupingOperators (Gruplandırma Operatörleri)

public void LinqGrouping()
{ 
     string[] kelimeler = { "kısıtlama", "gruplama", "seçme", "sıralama", "ölçüm","eleman" };
     var KelimeGrup = from s in kelimeler
                               group s by s[0] into k
                               select new { FirstLetter = k.Key, Kelimeler = k };    
    foreach (var k in KelimeGrup)
    {
          Console.WriteLine("İlk harfi '{0}' olan kelimeler:", k.FirstLetter);
          foreach (var s in k.Kelimeler)
         {
               Console.WriteLine(s);
         }
     }
 }

   

3.       AggregateOperators (Gruplama Fonksiyonu Operatörleri)

public void LinqAggregate()
{
      string[] kelimeler = { "kısıtlama", "gruplama", "seçme" };
      int EnKısaKelime = kelimeler.Min(w =>w.Length);
      Console.WriteLine("En kısa kelime {0} karakter uzunluğundadır.", EnKısaKelime);

 }

4.       ProjectionOperators (Seçme Operatörleri)

public void LinqProjection()
{
      string[] Kelimeler = { "kIsItlaMa", "GRUpLama", "SeçME" };
          var BuyukKucukKelimeler = from k in Kelimeler
          select new { BuyukHarf = k.ToUpper(), KucukHarf = k.ToLower() };
               foreach (var bk in BuyukKucukKelimeler)
               {
                     Console.WriteLine("BüyükHarf: {0}, KüçükHarf: {1}", bk.BuyukHarf, bk.KucukHarf);
                }
}

5.       Set Operators (Küme Operatörleri)

public void LinqSet()
{
     int[] SayilarA = { 1, 2, 3, 4, 5, 6, 7 };
     int[] SayilarB = { 1, 3, 5, 7, 9 };
     var OrtakSayilar = SayilarA.Intersect(SayilarB);
     Console.WriteLine("İki dizide ortak olan sayilar:");
     foreach (var o in OrtakSayilar)
     {
          Console.WriteLine(o);
     }
}

6.       Conversion Operators (Dönüştürme Operatörleri)

public void LinqConversion()
{
     string[] kelimeler = { "kısıtlama", "gruplama", "seçme" };
     var SiraliKelimeler =  from k in kelimeler
                                     orderby k
                                     select k;
     var KelimeListesi = SiraliKelimeler.ToList();
     Console.WriteLine("Sıralı kelime listesi:");
     foreach (var k in KelimeListesi)
     {
           Console.WriteLine(k);
     }
}

7.       PartitioningOperators (Bölümleme Operatörleri)

public void LinqPartitioning()
{
     int[] sayilar = { 3, 4, 2, 3, 9, 4, 5, 8, 2, 8 };
     var BestenKucukIlkSayilar = sayilar.TakeWhile(n => n < 5);
     Console.WriteLine("5'ten küçük ilk sayilar:"); 
     foreach (var n in BestenKucukIlkSayilar)
     { 
           Console.WriteLine(n);
     } 

}

8.       Element Operators (Eleman Operatörleri)

public void LinqElement()
{
     string[] kelimeler = { "kısıtlama", "gruplama", "seçme", "sıralama", "ölçüm","eleman"};
     string kIleBaslayan = kelimeler.First(s => s[0] == 'k'); 
     Console.WriteLine("'k' ile başlayan kelime: {0}", kIleBaslayan);
}

9.       MiscellaneousOperators (Çeşitli Operatöler)

public void LinqMiscellaneous()
{
     int[] SayilarA = { 1, 2, 3, 4, 5, 6, 7 };
     int[] SayilarB = { 1, 3, 5, 7, 9 };
     var TumSayilar = SayilarA.Concat(SayilarB);
     Console.WriteLine("Bütün dizilerdeki tüm sayilar:");
     foreach (var n in TumSayilar)
     {
           Console.WriteLine(n);
     }
}

10.   GenerationOperators (Üretim Operatörleri)

public void LinqGeneration()
{
     var Sayilar = Enumerable.Repeat(5, 15); 
     foreach (var n in Sayilar)
     {
          Console.WriteLine(n);
     }
}

11.   Query Execution (Çalıştırma Operatörleri)

public void LinqQuery()
{  
     int[] sayilar = new int[] { 6, 4, 2, 3, 9, 4, 5, 8, 2, 8 };
     int i = 0;
     var q = (from n in sayilar
                 select ++i) .ToList();
     foreach (var v in q)
     {
          Console.WriteLine("v = {0}, i = {1}", v, i);
     }
}

12.   OrderingOperators (Sıralama Operatörleri)

public void LinqOrdering()
{
     string[] kelimeler = { "kısıtlama", "gruplama", "seçme" };
     var SiraliKelimeler = from w in kelimeler
                                    orderby w.Length
                                    select w;
     Console.WriteLine("Uzunluğuna göre sıralı kelime listesi:");
     foreach (var w in SiraliKelimeler)
     {
          Console.WriteLine(w);
      }
}

13.   Quantifiers (Ölçüm Operatörleri)

public void LinqQuantifiers()
{
     int[] sayilar = { 6, 4, 2, 4, 8, 2, 8 };
     bool SadeceCift = sayilar.All(n => n % 2 == 0);
     Console.WriteLine("Liste sadece çift sayılardan oluşur: {0}", SadeceCift);
}

14.   JoinOperators (Birleştirme Operatörleri)

class Program
{
     static void Main(string[] args)
     {
          List<Kitap>KitapList = new List<Kitap>
          {
               new Kitap{KitapId=1, KitapAdi="Suc ve Ceza"},
               new Kitap{KitapId=2, KitapAdi="Savas ve Baris"},
               new Kitap{KitapId=3, KitapAdi="Dirilis"},
               new Kitap{KitapId=4, KitapAdi="Sinekli Bakkal"},
               new Kitap{KitapId=5, KitapAdi="Calikusu"}
          };
          List<Siparis>KitapSiparis = new List<Siparis>
          {
               new Siparis{SiparisId=1, KitapId=1, OdemeSekli="Cek"},
               new Siparis{SiparisId=2, KitapId=5, OdemeSekli="Kredi"},
               new Siparis{SiparisId=3, KitapId=1, OdemeSekli="Nakit"},
               new Siparis{SiparisId=4, KitapId=3, OdemeSekli="Cek"},
               new Siparis{SiparisId=5, KitapId=3, OdemeSekli="Cek"},
               new Siparis{SiparisId=6, KitapId=4, OdemeSekli="Nakit"}
          };
          var KitapSiparisler = from kt in KitapList
                                         join spr in KitapSiparis
                                         on kt.KitapId equals spr.KitapId
           select new
          {
               kt.KitapId,
               spr.SiparisId,
               kt.KitapAdi,
               spr.OdemeSekli
          };
          foreach (var item in KitapSiparisler)
          Console.WriteLine(item);
     }
}
public class Kitap
{
     public int KitapId { get; set; }
     public string KitapAdi { get; set; }
}
public class Siparis
{
     public int SiparisId { get; set; }
     public int KitapId { get; set; }
     public string OdemeSekli { get; set; }
}
}