daryaL

Language Integrated Query kelimelerinin baş harflerinden oluşan LinQ, Framework 3 ile gelen bir yenilik. LinQ kullanarak SQL veritabanları ve XML verileri herhangi bir SQL cümleciği kullanmadan sorgulamak mümkün hale geliyor.

Bu sayede daha önce yazılım geliştiricilerin başını çok ağrıtan SQL sorgular ortadan kalkıyor ve işlemler nesneler üzerinden yürümeye başlıyor. Aslında bu sistem daha önce LLBLGen gibi birçok tool'da da bulunmaktaydı, bununla beraber veritabanında yapılan her değişiklik için kodun yeniden üretilmesi zorunluluğu özellikle büyük projeler için bir sorun teşkil etmekteydi. LinQ ise sınıfları yazmak veya üretmek gibi iki seçenekle yazılım geliştiricilerin karşısına çıkıyor.

Şimdi LinQ'ya giriş amacıyla küçük bir “console application” yapalım. Bu örnekte X firmasına ait bir alışveriş sitesi yazılıyor, veritabanındaki tablolardan birinin adı ise Order, ani sipariş;

class Orders
{
    private int _OrderID;
    private int _CustomerID;
    private double _Cost;    

    public int OrderID
    {
        get { return _OrderID; }
        set { _OrderID = value; }
    }

     public int CustomerID
    {
        get { return _CustomerID; }
        set { _CustomerID = value; }
    }    

    public double Cost
    {
        get { return _Cost; }
        set { _Cost = value; }
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Test amacıyla burada veritabanından çekilen veriler değil aşağıda oluşturduğumuz veriler kullanılıyor.
        var Orders = new List {
                         new Orders {
                             OrderID = 1,
                             CustomerID = 84,
                             Cost = 159.12
                         },
                         new Orders {
                             OrderID = 2,
                             CustomerID = 7,
                             Cost = 18.50
                         },
                         new Orders {
                             OrderID = 3,
                             CustomerID = 84,
                             Cost = 2.89
                         }
                     };

        // Linq sorgusu
        var Found = from o in Orders
                    where o.CustomerID == 84
                    select o.Cost;        

        // sonuçları gösterelim.
        foreach (var Result in Found)
            Console.WriteLine("Cost: " + Result.ToString());
    }
}

Programın çıktısı şöyle olacaktır:
Cost: 159.12
Cost: 2.89

Şimdi satır satır LinQ sorgusunu inceleyelim:

from o in Orders

Buradaki yapıyı foreach gibi düşünebiliriz, bununla beraber Microsoft'un neden from ifadesini kullandığını çok kimse anlamamış gözüküyor. Bu cümleden Orders tablosunda bir sorgu yapacağımızı ve sorgu yaparken kullanacağımız nesnenin adının "o" olduğunu anlayabiliriz.

Bundan sonra gelen Where cümleciği;

where o.CustomerID == 84

Burada ise o nesnesine, yani Order tablomuzda CustomerId 84 olan satırları seçmemiz gerektiği belirtiliyor.

En sonda ise "select" cümleciğimiz var;

select o.Cost

Burada tablodan hangi sütunları geri döndürüleceğini seçiyoruz.

İşte ilk Linq Sorgunuzu yazdınız...

Gelelim daha ayrıntılı sorgulara, sorgumuzu aşağıdaki şekilde değiştirirsek;

 var Found = from o in Orders
                    where o.CustomerID == 84
                    select new{o.Cost,o.OrderId};

Bu şekilde hem Cost hem de OrderId'yi alabilmiş olduk.
Unutmayın, LinQ içerisinde istediğiniz matematiksel işlemleri de gerçekleştirebilirsiniz;

var Found = from o in Orders
            where o.CustomerID == 84
            select new {
                       o.OrderID,
                       o.Cost,
                       CostWithTax = o.Cost * 1.1
                   };

Gördüğünüz gibi burada CostWithTax değerini Cost değerinin 1.1 katı 
olarak tanımladık, bunu yaparken de anonymous type'lardan yararlandık
 ve herhangi bir tip tanımı yapmadık.

Linq ile daha kompleks sorgularda yazabiliriz;

var Found = from o in Orders
            where o.CustomerID == 84 && o.Cost > 100
            select new {
                       o.OrderID,
                       o.Cost,
                       CostWithTax = o.Cost * 1.1
                   };

LinQ'da sıralama yapmak için tıpkı SQL'dei gibi orderby kelimesini kullanıyoruz;

var Found = from o in Orders
            where o.CustomerID == 84
            orderby o.Cost ascending
            select new { o.OrderID, o.Cost }; 

Benzer şekilde gruplama için "group" "by" kelimelerini kullanıyoruz;

var Found = from o in Orders
            where o.CustomerID == 84
            group o by o.Cost
            select new { o.OrderID, o.Cost };

Son olarak "Join" işlemi için bir örnek verelim, bu örnekde ikinci bir sınıf eklenmiş olsun. Bu yeni sınıfımızın adı Customer, özellikleri ise CustomerId, Name ve EMail.
Şimdi basit bir join sorgusu yazalım;

var Found = from o in Orders
            join c in Customers on o.CustomerID equals c.CustomerID
            select new { c.Name, o.OrderID, o.Cost };

Yazıyı "insert " işleminin nasıl yapılacağını göstererek bitirmek istiyorum, önce insert edeceğimiz nesneyi yaratalım;

Orders ord = new Orders(){

            CustomerId = 20;

            Cost = 10;

           }

db.Orders.InsertOnSubmit(ord);

db.SubmitChanges();

 

Önce bir nesne yarattık, sonra bu nesneyi insert edilecek nesneler arasına ekledik ve en sonda da işlemi bitirdik; hepsi bu kadar...

 

LinQ'ya basit ama ayrıntılı bir giriş yapmış olduk, konuyla ilgili her türlü sorunuza açığım...

Happy Coding...