A
B
C
Ç
D
E
F
G
Ğ
H
I
İ
J
K
L
M
N
O
P
R
S
Ş
T
U
Ü
V
Y
Z
Q
W
X
+ Ekle
Dynamic LINQ

Dynamic LINQ

Aslında LINQ hakkında yazıp yazmamak konusunda kararsız kaldım. Takip ettiğim bazı blog yazarlarının bu konudaki görüşleri ya da Microsoft’un LINQ to SQL’in geliştirilmesini durdurduğu vs. söyleniyordu ki .NET 4.0 ile gelen yenilikler arasında LINQ to SQL üzerinde yapılan değişiklikler yayınlandı. Buna göre;

* Performansa etki eden parametreler ve sonuç döndüren sorgu yapıları yeniden gözden geçirilmiş,
* LINQDataSource yapısı genişletilmiş, sorgularla dynamic bir data yapısı ön plana çıkarılmış, kullanılabilirlik artmış,
* Daha kararlı bir sorgu yapısı ile güncellemeler daha kolay hale getirilmiş,
* LINQ to SQL class yapısında değişlikler meydana gelmiş, biraz daha esnek bir yapı sağlanmış vs...
 
Ayrıntılı bilgi almak isterseniz a rel="nofollow" href="http://social.msdn.microsoft.com/forums/fr-fr/linqtosqlprerelease/threads" target=_blank>bu
 adresten konuyu inceleyebilirsiniz.



 
Madem LINQ to SQL .NET 4.0’la bir takım değişikliklerle üstelik daha dynamic bir yapı ile yeniden karşımıza çıkacak; o zaman bizde DLINQ hakkında neler öğrenebiliriz biraz bakalım.
 
Öncelikle bilgilerimizi tazeleyelim. .NET 3.5 ve Visual Studio 2008 ile gelen LINQ(Language Integrated Query), C#’da kod yazarken SQL’de sorgu yazıyor gibi sorgu yazmamıza olanak sağladı ve beraberinde bir çok kolaylığı getirdi. LINQ adını verdiğimiz dile entegre sorgularla artık .NET ortamında koleksiyon tabanlı nesneleri sorgulayabiliyoruz.
 
Buraya kadar herşey güzel, LINQ’i az çok tanıyoruz. Normalde LINQ sorgularını syntax operatörleri veya lambda extension metotlar kullanılarak oluşturuyoruz. Peki dynamic LINQ’u nasıl oluşturuluyor ya da dynamic sorgular nasıl yazılır diye düşünmeye başladığımız bir anda Dynamic Expression API diye bir kavram karşımıza çıkıyor. Şimdi dynamic linq’u biraz inceleyelim.
 
DynamicLINQ(DLINQ) nedir?
 
DynamiLINQ, string formatlı ifadeleri yazmamızı sağlayan string tabanlı extension metotlar içeren dynamic sorgu kütüphanesidir. System.Linq.Dynamic namespacesi içerisinde yer alan Dynamic Expression API classlarının sağladığı imkanlar kullanılarak oluşturulan sorgulardır. Amacımız runtime sorgular yazmaktır.
 
Bu classlardan nasıl faydalanabiliriz?
 
Aşağıda Dynamic Expression API’nin, System.Linq.Dynamic.DynamicQueryable sınıfının bir parçası olan IQueryable Extension Metotları içeren sorgu türleri verilmiştir.
 
public static IQueryable Where(this IQueryable source, string predicate, params object[] values);

public static IQueryable<T> Where<T>(this IQueryable<T> source, string predicate, params object[] values);

public static IQueryable Select(this IQueryable source, string selector, params object[] values);

public static IQueryable OrderBy(this IQueryable source, string ordering, params object[] values);

public static IQueryable<T> OrderBy<T>(this IQueryable<T> source, string ordering, params object[] values);

public static IQueryable Take(this IQueryable source, int count);
public static IQueryable Skip(this
IQueryable source, int count);
public static IQueryable GroupBy(this IQueryable source, string keySelector, string elementSelector, params object
[] values);
public static bool Any(this
IQueryable source);
public static int Count(this IQueryable source);

Bu metotlar lambda expression metot yerine IQueryable üzerinden dynamic yapılarla çalışmamızı sağlıyor.
 
Şimdi IQueryable Extension Metotları kullanarak dynamic sorgular yazalım.
 
DataClassesDataContext db = new DataClassesDataContext();
var products = from
p in db.Products
where p.Model == "SD1000" && p.onsale ==
true
select p;


Yukardaki sorguyu bir de IQueryable extension metotlarından biri olan Where() extension metodunu kullanarak yazalım.

DataClassesDataContext db = new DataClassesDataContext();
var products = db.Products.Where("Model==@0 && onsale==@1","SD1000", true) ;


Şimdi de string bir girdi kullanarak aşağıdaki gibi değiştirelim.

DataClassesDataContext db =
new DataClassesDataContext();
string condition = "Model==\\"SD1000\\" && onsale==true "
;
var products = db.Products.Where(condition );

Yukarıdaki örnek Dynamic Expression API’nin nimetlerinden yararlanılarak son şeklini aldı.


 

DataClassesDataContext db = new DataClassesDataContext();
var product = from
p in db.Products
where p.Model == "SD1000" && p.onsale ==
true
orderby
p.Name
select new { p.ItemId, p.Name, p.Model1, p.onsale };

Şimdi yukarıdaki where, orderby ve select kullanılmış olan sorguyu Dynamic Expression API kullanarak dynamic bir yapıya dönüştürelim.

DataClassesDataContext db = new DataClassesDataContext();
string condition = "Model==\\"SD1000\\" && onsale==true "
;
var products = db.Products.Where(condition).OrderBy("Name").Select(" new (ItemId,Name,Model,onsale)");

 
Örneklerden aradaki farkı görmekteyiz.
 
Peki dynamic linq’da hata kontrollerini nasıl yapacağız?
 
LINQ’da hata yaptığınızda SQL’deki gibi farkına varmak kolaydır, bunu hemen anlarsınız fakat DLINQ’da durum biraz farklı. Hatırlarsanız DLINQ’da amacımız runtime sorgular yazmak demiştik. Yani DLINQ’da hata yaptığımızda ancak kod çalıştığı zaman farkına varabiliriz. Ancak bunun içinde DLINQ için bir kolaylık sağlanmış ve Parse Expression sınıfı oluşturulmuştur.
 
Hemen bir örnekle nasıl kullanıldığını gösterelim.
 
try
{
DataClassesDataContext db=new
DataClassesDataContext();
string condition = "Model==\\"SD1000\\" && onsale==true "
;
var products = db.Products.Where(condition).OrderBy("Name").Select(" new (ItemId,Name,Model,onsale)"
);
}

catch (ParseException ex)
{
Response.Write(ex.Position + ex.Message);
}

şeklindedir. Hata çıktısını görebilmek için de Take() ve Skip() extension metotlarının kullanımını bir örnekle gösterelim.
 
DataClassesDataContext db = new DataClassesDataContext();
string condition = "Model==\\"SD1000\\" && onsale==true "
;
var product2 = db.Products.Where(condition).OrderBy("Name").Select(" new (ItemId,Name,Model,onsale)").Skip(2).Take(3);

 
İstenilen kayda ait bilgiye erişilemediğinde o kaydı atla(Skip()), sonrasında belirtilen kaydı göster(Take()).

Bir başka örneğimizde ise istenilen şartlara uygun ne kadar kayıt olduğunu görebilmek için Count() extension metodunun kullanımına bir göz atalım.
 
DataClassesDataContext db = new DataClassesDataContext();
string condition = "Model==\\"SD1000\\" && onsale==true "
;
var count = db.Products.Where(condition).Count();


Bu örnekle de GroupBy() extension metodunun kullanımını gösterelim. 
 
DataClassesDataContext db = new DataClassesDataContext();
var Models= db.Products.GroupBy("Model", "new (Model)");


Son olarakta JOIN kullanımına bir örnek verelim.
 
DataClassesDataContext db = new DataClassesDataContext();
string condition = "Model==\\"SD1000\\" && onsale==true "
;
var products = from m in (db.Models.Where("Model1==@0", "SD1000"))join p in (db.Products.Where(condition).OrderBy("Name"
))
on m.Model1 equals
p.Model
select new { p.ItemId, p.Name, p.Model, m.company, p.Price, p.onsale, p.discount, p.Description, m.features };

 
 
Referanslar :
 
1 - Great ‘LINQ To Sql’ Tutorial Series From ScottGu’s Blog
2 - Dynamic Expressions and Queries in LINQ - Joseph Albahari 
3 - LINQ to SQL changes in .NET 4.0


  • diline pelesenk olmak ne demek
  • dillere pelesenk olmuş ne demek
  • pelesenk
  • pelesenk ne demek
  • Pelesenk Ne Demek – Pelesenk Sözlük Anlamı
  • pelesenk olmak ne demek
  • pelesenk olmak ne demektir
  • pelesenk olmuş ne demek
  • Yüksek Yüksek Tepelere sözleri