Duracellko.NET : LINQ

LINQ 2 SQL a DataLoadOptions

duracellko — Thu, 09 Oct 2008 16:04:00 GMT

Už som si myslel, že som objavil nejakú chybu v LINQ 2 SQL, ale zase to bol skôr problém medzi klávesnicou a stoličkou. Mám nasledovný dátový model.

Zároveň som pri načítavaní kontaktov nastavil, aby sa spolu s nimi načítali aj EmailType a TelephoneType. Proste aby sa nepoužil lazy-loading. Zabezpečil som to nasledovným kódom.

partial void OnCreated()

{

var dlo = new DataLoadOptions();

dlo.LoadWith<EmailContact>(ec => ec.EmailType);

dlo.LoadWith<TelephoneContact>(tc => tc.PhoneType);

LoadOptions = dlo;

}

Táto OnCreated metóda je priamo v triede odvodenej od DataContext.

Lenže som sa veľmi čudoval, keď pri načítaní kontaktov sa mi vrátil prázdny zoznam, aj keď samozrejme nejaké dáta v DB boli. Ešte že debbuger zobrazuje SQL príkaz, ktorý sa posiela na SQL Server. A ten bol nasledovný.

SELECT [t0].[ContactType]

FROM [Customer].[vContact] AS [t0]

INNER JOIN [Customer].[vTelephoneType] AS [t1] ON [t1].[Id] = [t0].[PhoneTypeId]

INNER JOIN [Customer].[vEmailType] AS [t2] ON [t2].[Id] = [t0].[EmailTypeId]

WHERE [t0].[CustomerId] = @p0

A je jasné, že tento príkaz musí zakaždým vrátiť prázdny zoznam. Ak je v riadku uložený EmailContact, tak stĺpec PhoneTypeId je NULL, a teda vďaka operátoru INNER JOIN na view vTelephoneType sa tento riadok do výsledku nedostane. A naopak, ak je v riadku uložený TelephoneContact, tak stĺpec EmailTypeId je NULL, a zase vďaka operátoru INNER JOIN na view vEmailType sa tento riadok do výsledku nedostane. A prípad pre PostAddressContact ani netreba rozpisovať, pretože tam sú obidva stĺpce NULL.

Najprv som si myslel, že programátori z MS spravili škôlkarskú chybu a dávajú INNER JOIN aj tam kde má byť LEFT JOIN. Ale začal som pátrať hlbšie, a tak som si otvoril .NET Reflector. Ešte raz vďaka za tento najdôležitejší nástroj .NET developera. A tam som po dlhšom pátraní zistil, že predsa len sa niekedy používa LEFT JOIN a niekedy INNER JOIN. Ak stĺpec, ktorý obsahuje referenciu na nejakú entitu, nie je nullable a je na ňom definovaný foreign key, tak použije INNER JOIN, inak sa použije LEFT JOIN. Čo je celkom logické, pretože ak sú splnené tie dve podmienky, tak sa nám v SQL databáze nepodarí vložiť do daného stĺpca inú hodnotu, ako sa nachádza v referencovanej tabuľke. Takže INNER JOIN má za daných podmienok zmysel, pretože vždy bude existovať záznam v referencovanej tabuľke. Nezistil som síce ako zisťuje, či je nad daným stĺpcom fereign key, pretože táto možnosť sa nikde v LINQ 2 SQL designery nezadáva.

Ale to nie je dôležite. Dôležite je, že mne stačilo zmeniť vlastnosti EmailTypeId a PhoneTypeId z int na Nullable<int> a všetko funguje tak, ako má. Samozrejme, že v databáze tieto stĺpce boli NULL, ale v Class modely neboli, pretože z business pohlady EmailContact musí mať uvedený EmailType a TelephoneContact musí mať uvedený TelephoneType. Takže, ak nikto nepokazí dáta v databáze, tak v Class modely dané vlastnosti nemuseli byť nullable.

Nájdite všetkých zákazníkov, ktorí si objednali všetky produkty z katalógu

duracellko — Thu, 03 Apr 2008 11:30:26 GMT

Trochu dlhý nadpis. Dnes som si spomenul na klasickú úlohu zo skúšky z databáz. Jej presné znenie je nadpis tohoto blogu. Pravdepodobne cieľom tohoto cvičenia je ukázať, že SQL je strášný jazyk a že sa toto ľahšie napíše v relačnej algebre.

A pri diskusii o stored procedures ma napadlo, že či sa dá tento dopyt napísať v LINQ. Dá sa a je to ešte krajšie ako v SQL.

var customersAllProducts = os.Customers.Where(

c => !os.Products.Any(

p => !c.Orders.Any(o => o.Product == p)));

A vygenerovaný SQL príkaz je nasledovný.

SELECT [t0].[CustomerId]

FROM [dbo].[Customer] AS [t0]

WHERE NOT (EXISTS(

SELECT NULL AS [EMPTY]

FROM [dbo].[Product] AS [t1]

WHERE NOT (EXISTS(

SELECT NULL AS [EMPTY]

FROM [dbo].[Order] AS [t2]

WHERE ([t2].[ProductId] = [t1].[ProductId]) AND ([t2].[CustomerId] = [t0].[CustomerId])

))

Ale celkom zaujímavá vec je dávať do SELECTu v EXISTS stĺpec NULL. Ja som tam vždy dával primárny kľúč.

ADO.NET Entity Framework Beta 3

duracellko — Thu, 13 Dec 2007 07:11:00 GMT

Asi ste si všimli, že serial o LINQ sa akosi zastavil. Pokračovaním by malo byť využitie LINQ na prístup k relačným databázam. Pre tento účel vyvýja Microsoft až dva frameworky LINQ 2 SQL a ADO.NET Entity Framework. Toto rozdvojenie sa mi nezdá šťastný krok, ale to už asi neovplyvním. LINQ 2 SQL je súčasťou .NET 3.5, to znamená že v dnešnej dobe existuje finálna verzia. Predpokladáte správne, že oproti ADO.NET Entity Framework má oveľa slabšie možnosti mapovania. ADO.NET Entity Framework je ešte stále vo vývoji a nedávno vyšla verzia Beta 3. Asi najpodstatnejšia feature, ktorá pribudla je, že existujúci model sa dá obnoviť z databázy. To bol aj dôvod zastavenia seriálu o LINQ. Rozhodol som sa, že nebudem písať o LINQ 2 SQL, ale prejdem rovno na ADO.NET EF. Lenže Beta 2 nebola prakticky použiteľná. Teda hlavne myslím Add-In do Visual Studio 2008. Občas to padalo. Ale hlavne, ak som z databázy vytvoril model, tak to fungovalo. Ale problém nastal, ak som niečo zmenil v databáze. Nástroj už neumožňoval obnovenie modelu z databázy. Jediná možnosť bola priamo editovať XML súbor s definíciou modelu. Keďže sa zdá, že verzia Beta 3 je celkom použiteľná, tak sa vynasnažím čo najskôr pokračovať v tomto seriáli. Ale žiaľ asi až po sviatkoch.

No a teraz k inštaláci ADO.NET EF. Je potrebné nainštalovať dve časti.

ADO.NET Entity Framework Runtime Beta 3: http://www.microsoft.com/downloads/details.aspx?FamilyId=15DB9989-1621-444D-9B18-D1A04A21B519

ADO.NET Entity Framework Tools December CTP: http://www.microsoft.com/downloads/details.aspx?FamilyId=D8AE4404-8E05-41FC-94C8-C73D9E238F82

Avšak pred inštaláciou nástrojov je potrebné nainštalovať aj nejaký XML Editor QFE. Je to nejaký patch na Visual Studio 2008 vedený pod KB945282. Jediné čo som o tomto KB našiel na jednom blogu je, že to je tak nový patch, že ešte k nemu ani neexistuje článok v databáze KB. No je to celkom zaujímavé, že VS 2008 nie je vonku ani mesiac a už k nemu existuje záplata.

LINQ part 3 - LINQ nad IEnumerable

duracellko — Thu, 08 Nov 2007 19:50:00 GMT

Ďalší diel seríalu o LINQ. Predchádzajúce diely:

Language Integrated Query je rozšírenie jazyka pre podporu operácií spomínaných v predchádzajúcom diely. Tieto rozšírenia sa týkajú jazyka C# aj Visual Basic. To znamená, že do jazyka pribudli konštrukcie napodobňujúce syntax SQL. Tieto špeciálne príkazy sa ale nakoniec vždy preložia ako operácie nad množinami. Pokiaľ pracujeme s objektom IEnumerable, tak sa LINQ príkazy preložia ako volania rozširujúcich metód nad IEnumerable. Pokiaľ pracujeme s IQueryable, tak sa LINQ príkazy preložia do konštrukcie Expression objektu. To znamená, že všetko, čo môžeme zapísať pomocou LINQ vieme zapísať aj pomocou klasických volaní metód. Avšak použitie LINQ je väčšinou prehľadnejšie. V tomto diely ukážem viac príkladov a operácii ako v predchádzajúcom, ale všetky tieto príklady sa dajú napísať aj bez použitia LINQ. Môžete si to vyskúšať.

Však poďme sa pozrieť na jednotlivé príkazy. Ako som povedal, tak syntax LINQ sa snaží napodobňovať jazyk SQL. Pravdepodobne preto, že oba jazyky majú rovnaký cieľ a jazyk SQL pozná každý, kto serióznejšie programoval. Takže základom každého LINQ výrazu sú slová from a select. Teda select môže byť nahradený slovom group, ale o tom neskôr. Najlepšie je to ukázať na príklade.

var list1 = from c in Customers select c.Name;

Každý LINQ výraz začína operátorom from, ktorý vracia objekt typu IEnumerable alebo IQueryable. Za týmto operátorom nasleduje konštrukcia známa z príkazu foreach. Teda iterujúca premenná in kolekcia. Iterujúcu premennú definujeme len pre to, aby sme sa v ďalších častiach mohli na ňu odkazovať. Je to niečo podobné ako alias tabuľky v SQL.

Select

Operátor select slúži na projekciu. To znamená, že transformuje prvky pôvodnej kolekcie na nové prvky. V predchádzajúcom príklade nám vráti kolekciu mien zákazníkov. Operátor select je najjednoduchší operátor LINQ. Určuje vlastne pravú stranu lambda výrazu pri projekcii. Takže okrem mena tam môže byť nový anonymný objekt, ktorý má vlastnosti Id a Name. Alebo to môže byť samotná iterujúca premenná. To má samozrejme skôr zmysel pri spojení so selekciou, teda where. V tomto prípade by časť select ani nemusela byť v LINQ výraze, ale táto časť je povinná.

Asi ste si všimli rozdiel medzi SQL a LINQ. V LINQ je prvý operátor from a select je posledný. Dôvod je jednoduchý. V časti from zadefinujete iterujúcu premennú a v časti select (prípadne v ďalších častiach) túto premennú používame s plnou podporou Intellisense. Nakoniec ja keď píšem SQL príkaz, tak najprv napíšem časť FROM, pretože si tam zadefinujem tabuľky a aliasy, a potom napíšem časť SELECT. Autori SQL sa pre toto trochu divné (aj keď dnes zažité) poradie rozhodli preto, že celý príkaz potom vyzerá ako rozkazovacia veta. Práve preto podľa mňa autori LINQ mohli upustiť od slovíčok from a select a mohli ich nahradiť inými, prípadne nejakými konštrukciami špeciálnych znakov. Ja osobne by som si vedel časť from predstaviť uzatvorenú do hranatých zátvoriek. Ale asi marketingoví špecialisti sa rozhodli, že to musí čo najviac pripomínať SQL, aby programátori mali pocit, že to vlastne už dávno ovládajú.

From

Už sme si ukázali, ako pomocou from vybrať prvky z jednej kolekcie. Ďalšia možná operácia je kartézky súčin. Dosť nezmyselný, ale názorný príklad.

var list2 = from c1 in Customers

from c2 in Customers

select new { Name1 = c1.Name, Name2 = c2.Name };

Na rozdiel od SQL sa tu nepoužíva čiarka alebo CROSS JOIN, ale druhé from. Niekde na nete som videl aj príklady, kde bola použitá čiarka, ale to asi bolo ešte za čias Beta 1, pretože mne to v Beta 2 funguje len s from. Nakoniec druhý operátor from dokáže viac ako kartézky súčin. A je to vidieť na nasledovnom príklade.

var list3 = from o in Orders

from ol in o.Lines

select ol;

Tento príklad vylistuje všetky riadky vo všetkých objednávkach. Tu je teda možné vidieť, čo from operátor presne robí. Spraví zjednotenie kolekcií, pričom zoznam kolekcií je definovaný prvým from. Dokonca medzi dve from časti je možné vložiť napríklad where alebo order by časť. Síce ešte som nespomínal where časť, ale predpokladám že ju poznáte z SQL.

A teraz si zoberme dva veľmi podobné príklady.

Príklad 1:

var list4 = from o in Orders

where o.Id == 1

from ol in o.Lines

select ol;

Príklad 2:

var list5 = from o in Orders

from ol in o.Lines

where o.Id == 1

select ol;

V obidvoch príkladoch výrazy vrátia ten istý výsledok. Rozdiel je ale v spôsobe výpočtu. V prvom prípade sa prechádza kolekcia objednávok, pričom sa berú do úvahy len prvky, kde Id = 1. A len pre tieto prvky sa prechádzajú kolekcie riadkov. Čiže výpočet prebieha optimálne tak, ako by ho každý (alebo väčšina) programátor napísal. V druhom príklade sa ale prechádzajú všetky objednávky a všetky riadky. A až potom sa kontroluje, či Id = 1. Čiže výpočet nie je optimálny.

Druhý rozdiel je v tom, že v druhom príklade sa vytvára anonymný typ, aj keď ho nepotrebujeme. Druhé from sa prekladá ako metóda SelectMany. V prvom príklade je za druhým from len select časť. To znamená, že táto časť je zároveň pravou stranou lambda výrazu, ktorý je argument funkcie SelectMany. A keďže sa vyberá priamo objekt typu OrderLine, tak nie je potrebné vytvoriť anonymný typ. V druhom príklade SelectMany vracia kolekciu nasledovných anonymných objektov:

new { o, ol }

Nakoniec sa z týchto anonymných objektov vyberú len tie, kde o.Id = 1, a do výsledku ide len ol.

Tu je teda vidieť rozdiel medzi SQL a LINQ nad IEnumerable. SQL je skutočne deklaratívny jazyk, kde sa príkaz najprv z optimalizuje a až potom vyhodnocuje. Takže rovnaký výsledok sa vypočíta rovnakým spôsobom, bez ohľadu na to, ako príkaz napíšeme. Teda aspoň väčšinou databázové servery zvládajú. LINQ nad IEnumerable sa vyhodnocuje iteratívne, a preto je potrebné si dávať pozor na to, ako LINQ výraz napíšeme. Práve preto som v predchádzajúcom diely písal funkciách, ktoré sa volajú na pozadí LINQ, aby si každý programátor uvedomil, čo sa deje, a či kód píše správne. Prípadne, ak je výkon aplikácie skutočne dôležitý, tak je asi vhodné LINQ úplne vynechať a mať algoritmy pod kontrolou.

Samozrejme toto sa netýka LINQ nad IQueryable. Pretože v tomto prípade výpočet neprebieha v .NET, ale sa vyskladá Expression, ktorá sa pošle zdroju. A či ju zdroj výpočet optimalizuje alebo nie, tak to zo C# neovplyvníme. Ale asi najčastejšie zdroj bude relačná databáza, takže výpočet sa väčšinou optimalizuje.

Where

Operátor where je veľmi jednoduchý operátor na selekciu. Za týmto operátorom nasleduje predikát, teda výraz s výsledkom typu boolean. No a výsledok operácie je kolekcia prvkov, ktoré spĺňajú danú podmienku.

Nasledovný príklad vyberie objednávky, ktoré majú viac ako jednu položku.

var list1 = from o in Orders

where o.Lines.Count > 1

select o;

Order By

Operátor orderby slúži na triedenie prvkov v kolekcii. Za operátorom nasleduje zoznam kľúčov, podľa ktorých sa má triediť. Kľúč je výraz, ktorého výsledkom je typ implementujúci rozhranie IComparable. Porovnanie je potrebné práve kvôli tomu, že sa využíva pri triedení. Jednotlivé kľúče sú oddelené čiarkou. Za každým kľúčom je možné určiť ascending alebo descending. Samozrejme, že ak nič neuvedieme, tak sa triedi vzostupne.

Nasledovný príklad zotriedi zákazníkov podľa mena, ale dopredu dá VIP zákazníkov.

var list1 = from c in Customers

orderby c.VIP descending, c.Name

select c;

Group By

Operátor group je opak funkcie SelectMany, čiže druhého from. Je to jediný operátor, ktorý môže byť na konci výrazu namiesto operátora select. Výsledkom operácie je kolekcia prvkov typu IGrouping. Rozhranie IGrouping je odvodené od IEnumerable a na viac má vlastnosť Key. Jeden IGrouping prvok teda predstavuje kolekciu prvkov s rovnakým kľúčom.

Operátor group má dva operandy oddelené slovom by. Prvý operand je výraz, ktorý transformuje zdrojový prvok na výsledný podobne ako select. Druhý operand je výraz, ktorý vyberá kľúč, podľa ktorého sa má výsledok zoskupiť.

Nasledovný príklad zoskupí zákazníkov podľa toho, čí sú VIP alebo nie.

var list1 = from c in Customers group c by c.VIP;

foreach (var vip in list1)

{

Console.WriteLine("VIP: {0}", vip.Key);

vip.Print(i => i.Name);

}

Väčšinou prvý operand nerobí žiadnu transformáciu, len vráti prvok pôvodnej kolekcie. Ale nemusí to byť vždy pravda. Nasledovný príklad zoskupí ceny položiek objednávok podľa produktov.

var orderLines = from o in Orders from ol in o.Lines select ol;

Console.WriteLine("Group by product");

var list2 = from ol in orderLines

group ol.Price by ol.Product;

foreach (var product in list2)

{

Console.WriteLine(product.Key);

product.Print(i => i.ToString());

}

Operátor group má voliteľnú časť into. Táto časť slúži na to, aby sme s výsledkom operácie mohli ďalej pracovať. Napríklad triediť alebo selektovať. Nasledovný príklad nám navyše zoskupené produkty utriedi podľa názvu.

var list3 = from ol in orderLines

group ol.Price by ol.Product into p

orderby p.Key

select p;

Toto je zase názorný príklad kedy záleží na poradí operácií. Ak by sme triedili kolekciu pred zoskupovaním, tak by sme triedili kolekciu, ktorá má v mojom príklade asi 20 prvkov. Avšak, keďže sme triedili až po zoskupení, tak triedime len kolekciu skupín (teda produktov), ktorá má v mojom príklade len 5 prvkov. Takže triedenie je menej náročné.

Join

Operácia join je známa z relačných databáz. V objektovom programovaní však nemá veľký význam, pretože objekty sú viazané pomocou vlastností. Takže asociovaný objekt je prístupný cez vlastnosť a nie je potrebné definovať väzbu. Napríklad nasledovný príklad vylistuje všetky objednávky a ich naviazaných zákazníkov.

var list1 = from o in Orders select new { o.Id, o.Customer.Name };

Avšak môže sa stať, že potrebujeme spojiť dva zoznamy, medzi ktorými nie je priama asociácia, ale objekty sa dajú pospájať pomocou zhodných kľúčov. Tak ako v relačnej databáze aj v LINQ je join binárny operátor nad dvoma zoznamami. Jeden zoznam je definovaný na ľavo od operátora join a druhý na pravo. Potom nasleduje slovo on a za ním kľúče oboch zoznamov, ktoré sa majú zhodovať. Kľúče sú oddelené slovom equals. Taktiež za slovom on, nemôže nasledovať ľubovoľná podmienka, tak ako v SQL, ale len porovnanie dvoch kľúčov na zhodu.

Nasledovný príklad spojí riadky objednávky s produktmi.

var list1 = from ol in lastOrder.Lines

join p in Products on ol.Product equals p.Name

select new { ol.Product, p.Category, ol.Price };

Pokiaľ za operátorom join nasleduje niečo iné ako select, tak výsledkom operácie je kolekcia prvkov anonymného typu. Každý prvok reprezentuje dvojicu prvkov z oboch zoznamov, ktoré majú rovnaký kľúč. Avšak v LINQ výraze nevidíme tento anonymný typ, ale sú prístupne priamo iterujúce premenné z oboch zoznamov. Nasledovný príklad ukazuje použitie selekcie za joinom.

var list2 = from o in Orders

from ol in o.Lines

join p in Products on ol.Product equals p.Name

where p.Category == "Processor"

select new { ol.Product, p.Category, ol.Price };

Na pravo od join nie je kolekcia definovaná slovom from, ale priamo iterujúcou premennou a kolekciou. To však neznamená, že kolekcia na pravo musí byť dopredu zadefinovaná. V podstate za slovom in môže nasledovať v zátvorkách ďalší LINQ výraz. Ukazuje to nasledovný príklad, ktorý vráti rovnaký výsledok ako predchádzajúci príklad.

var list3 = from o in Orders

from ol in o.Lines

join p in (from prod in Products

where prod.Category == "Processor"

select prod)

on ol.Product equals p.Name

select new { ol.Product, p.Category, ol.Price };

Operácia join sa dá použiť aj na kolekcie, ktoré nemajú unikátny kľúč. Nasledovný príklad spája zákazníka s kategóriou cez VIP atribút. V tomto prípade sú VIP zákazníci vylistovaný viackrát, pretože existujú dve VIP kategórie.

var list1 = from c in Customers

join cc in CustomerCategories on c.VIP equals cc.Vip

select new { c.Name, cc.Category };

Všetky doterajšie operácie join boli typu INNER JOIN. To znamená, že sa vylistovali iba tie prvky z prvého zoznamu, pre ktoré existuje spárovaný prvok z druhého zoznamu, a naopak. LINQ podporuje join operáciu so zoskupovaním. Výsledkom operácie je zoznam prevej kolekcie, ale ku každému prvku je možné pridať vlastnosť, ktorá obsahuje kolekciu spárovaných prvkov.

Nasledovný príklad vylistuje zoznam zákazníkov a pre každého zákazníka vylistuje zoznam priradených kategórií.

var list2 = from c in Customers

join cc in CustomerCategories on c.VIP equals cc.Vip into cat

select new { c.Name, cat };

Je tu pridaná časť into premenná. Práve táto premenná obsahuje kolekciu spárovaných prvkov (v tomto prípade kategórií). Keďže je prístupná celá kolekcia, tak nie je prístupná iterujúca premenná na pravo od join. Táto iterujúca premenná sa dá použiť iba za equals.

Mne osobne tento zoskupujúci join nepripadá veľmi využiteľný. Hlavne preto, že sa zoskupuje podľa prvkov druhej kolekcie. Na jednej strane je pekné, že to vlastne vracia prvú kolekciu (rozšírenú o podkolekcie). Na druhej strane normálna požiadavka „zoznam zákazníkov zoskupených podľa kategórie“, by sa mala transformovať na príkaz „from c in customers...“ a nie začínať výberom kategórie tak, ako nás to núti tento join. Nakoniec, keby kategória bola nejaká vlastnosť objektu zákazník, tak príkaz začína výberom zákazníkov a potom ich zoskupíme pomocou groupby.

Ale ako som spomínal, tak táto forma joinu sa dá využiť na LEFT JOIN, pretože ak ku zákazníkovi neexistuje žiadna kategória, tak sa mu priradí prázdna kolekcia kategórií. V tomto prípade je zase výber z druhej kolekcie do premennej into úplne na mieste.

Príkaz Let

Príkaz let slúži na to, aby sme si v rámci iterácie uložili niečo do premennej. Typický neduh jazyka SQL je napríklad, ak máme SELECT, kde je nejaký vypočítavaný stĺpec. A keď máme tento stĺpec aj v podmienke a chceme podľa neho aj triediť, tak ten vzorec musíme vypísať 3-krát. Našťastie dobrý databázový stroj to optimalizuje a vzorec vypočíta len raz a potom výsledok použije pri podmienke, triedení aj vo výsledku. Problém je ale v tom, že to musíme písať 3-krát a hlavne keď sa vzorec zmení, tak si musíme dávať pozor na to, aby sme to 3-krát zmenili. No a ako sme spomínali, tak LINQ nad IEnumerable neoptimalizuje výpočet, takže v tomto prípade sa vzorec naozaj bude aj 3-krát počítať.

Nasledovný príklad zobrazuje priezviská zákazníkov a zároveň ich zotriedi.

var list1 = from c in Customers

let lastName = c.Name.Split(' ')[1]

orderby lastName

select new { lastName, c.VIP };

To sú teda všetky príkazy rozšírenia LINQ pre C#. Ako som spomínal, tak všetky príkazy sa dajú nahradiť použitím rozširujúcich metód rozhrania IEnumerable, pomocou ktorých sa dá dosiahnúť dokonca oveľa viac. Rovnako funguje LINQ aj nad rozhraním IQueryable.

Stiahnúť: Zdrojový kód

LINQ part 2 - IEnumerable a IQueryable

duracellko — Fri, 02 Nov 2007 09:07:00 GMT

Ďalší diel seríalu o LINQ. Predchádzajúce diely:

LINQ part 1 - Nové prvky v C#

Rozšírenia IEnumerable

V .NET 3.5 pribudla assembly System.Core, ktorá obsahuje statickú triedu Enumerable. Táto trieda obsahuje rozširujúce metódy, ktoré rozširujú interface IEnumerable. Sú tu funkcie na projekciu, selekciu, agregáciu a triedenie na IEnumerable.

Selekcia

Selekcia je operácia, pri ktorej sa vyberie podmnožina prvkov pôvodnej množiny. Na toto slúži funkcia Where, ktorá má jediný parameter. Tento parameter je funkcia, ktorá zoberie prvok a vráti true, ak sa má dostať do výberu, inak false.

Nasledovný príklad ukazuje selekciu všetkých VIP zákazníkov. Je tu možné vidieť efektívne použitie Lambda funkcie.

var vipCustomers = Customers.Where(c => c.VIP);

Nasledovný príklad ukazuje použitie porovnania.

var newOrders = Orders.Where(o => o.Id >= 3);

Nasledovný príklad ukazuje použitie referencovaných objektov. Vyberie len objednávky od VIP zákazníkov.

var vipOrders = Orders.Where(o => o.Customer.VIP);

Nasledovný príklad ukazuje zloženú podmienku. Vyberie nové objednávky od VIP zákazníkov.

var newVipOrders = Orders.Where(o => o.Id >= 3 && o.Customer.VIP);

Nasledovný príklad ukazuje použitie funkcie vo Where. Vyberú sa objednávky, ktoré obsahujú produkt od ATI.

var atiOrders = Orders.Where(o => o.Lines.Exists(ol => ol.Product.Contains("ATI")));

Projekcia

Projekcia je operácia, pri ktorej sa všetky prvky množiny transformujú na iné prvky. Napríklad v SQL sa pod projekciou chápe vybratie len konkrétnych stĺpcov zo všetkých možných. Na projekciu slúži funkcia Select, ktorá ma jeden parameter. Tento parameter je funkcia, ktorá konvertuje starý prvok na nový.

Nasledovný príklad skonvertuje množinu zákazníkov na množinu mien.

var customerNames = Customers.Select(c => c.Name);

Pri projekcii je výhodné použiť anonymné triedy, kde jednotlivé vlastnosti reprezentujú vypraté stĺpce. Nasledovný príklad vytvorí kolekciu riadkov, ktoré obsahujú číslo objednávky, názov zákazníka, počet riadkov.

var orderDetails = Orders.Select(o => new { o.Id, o.Customer.Name, LinesCount = o.Lines.Count });

Funkcia Select sa dá použiť aj na zmenu vlastností objektov v kolekcii. Nasledovný príklad zväčší ID objednávok o 1 a vráti kolekciu nových ID.

Console.WriteLine("Change IDs");

Console.WriteLine("Original IDs");

foreach (var i in Orders.Select(o => o.Id))

Console.WriteLine(i);

var newIds = Orders.Select(o => o.Id += 1);

Console.WriteLine("First update");

foreach (var i in newIds)

Console.WriteLine(i);

Console.WriteLine("Second update");

foreach (var i in newIds)

Console.WriteLine(i);

Tento príklad zároveň ukazuje, ako fungujú rozšírenia nad IEnumerable. Keď tento kód spustíte, tak sa vždy vypíše iná množina IDčiek. To znamená, že nová kolekcia sa nevytvorí pri volaní funkcie Select, ale až pri samotnom prechádzaní prvkami kolekcie, teda pri foreach. Preto sa IDčka objednávok zmenia dvakrát.

Ďalšia zaujímavá funkcia je SelectMany. Táto funkcia slúži na výber z podkolekcií. Napríklad máme zoznam objednávok a každá objednávka obsahuje zoznam riadkov objednávky. Ak chceme vybrať všetky riadky zo všetkých objednávok, tak môžeme použiť funkciu SelectMany. Nasledovný príklad vyberie zo všetkých riadkov objednávok ID objednávky, názov produktu a cenu.

var lines = Orders.SelectMany(o => o.Lines, (o, ol) => new { o.Id, ol.Product, ol.TotalPrice });

Triedenie

Triedenie je užitočné, ak potrebujeme prechádzať prvky v určitom poradí. Na to slúžia funkcie OrderBy a OrderByDescending. Obidve fungujú rovnako, len tá druha triedi v opačnom poradí. Samozrejme, že parametrom funkcie je funkcia. Táto funkcia konvertuje prvok kolekcie na kľúč, podľa ktorého sa má triediť. Voliteľný parameter je IComparer objekt, ktorý dokáže porovnávať kľúče.

Nasledovný príklad zotriedi zákazníkov podľa mena.

var orderedCustomers = Customers.OrderBy(c => c.Name);

Agregácia

Agregácia vytvorí jeden nový prvok na základe množiny prvkov. Príkladom agregácie sú suma, priemer, minimum alebo maximum. Na toto slúžia funkcie Sum, Average, Min a Max. Ako parameter sa odovzdá funkcia, ktorá skonvertuje prvok na číslo. Pri Min a Max je povolena aj konverzia na IComparable.

Nasledovný príklad vypočíta celkovú sumu poslednej objednávky.

var priceSum = Orders[5].Lines.Sum(ol => ol.TotalPrice);

Je možné vykonať aj vlastné agregácie pomocou funkcie Aggregate. Táto funkcia bola spomenutá v predchádzajúcej kapitole.

Iné zaujímavé rozšírenia

Ako sme si povedali, tak selekcie, projekcie a všetko ostatné sa vyhodnocuje pri každom prechádzaní kolekcie. To môže byť problém, ak je výpočet zložitý a potrebujeme kolekciu prechádzať viackrát. Práve tu nám pomôže funkcia ToList. Táto funkcia spustí výpočet a uloží výsledok do zoznamu. Takže pri prechádzaní prvkov v tomto zozname sa nespustí výpočet, ale použije sa uložená kolekcia.

Teraz modifikujme príklad z projekcie a vložme tam funkciu ToList. Môžeme vidieť, že IDčka sa zmenili len raz.

Console.WriteLine("Change IDs");

Console.WriteLine("Original IDs");

foreach (var i in Orders.Select(o => o.Id))

Console.WriteLine(i);

var newIds = Orders.Select(o => o.Id += 1).ToList();

Console.WriteLine("First update");

foreach (var i in newIds)

Console.WriteLine(i);

Console.WriteLine("Second update");

foreach (var i in newIds)

Console.WriteLine(i);

Ďalšie zaujímavé funkcie sú:

· First – vráti prvý prvok z kolekcie.

· Last – vráti posledný prvok z kolekcie.

· Union – vráti zjednotenie dvoch kolekcií.

· Intersect – prienik dvoch kolekcií.

· Concat – spojí dve kolekcie za sebou.

· Except – rozdiel dvoch kolekcií.

· All – vráti true, ak je podmienka splnená pre všetky prvky.

· Any – vráti true, ak je podmienka splnená pre aspoň jeden prvok.

· ToDictionary – skonvertuje kolekciu na slovník, pričom sa zadá funkcia, ktorá vyberá kľúč z prvku.

IQueryable

.NET 3.5 nám ponúka veľmi slušné operácie nad objektmi typu IEnumerable. Sú tu implementované štandardné operácie ako zjednotenie, prienik, selekcia, projekcia, join, agregácie, zoskupovanie, triedenie a iné, teda všetky operácie relačnej algebry. Všetky tieto operácie sú implementované a na ich použitie je potrebné len doplniť príslušné predikátové alebo transformačné funkcie. Tieto funkcie môžu byť ľubovoľné funkcie napísané v nejakom .NET jazyku, ktoré majú potrebnú signatúru. V predchádzajúcich príkladoch sme použili lambda výrazy. Ale tieto výrazy sa prekladajú ako anonymné funkcie. Rovnako môžeme použiť aj delegátov na neanonymné funkcie. Takže nakoniec operácie nad IEnumerable vždy využívajú kód preložený do MSIL. Toto ale môže byť problém, ak chceme robiť tieto operácie nad prvkami, ktoré sa nenachádzajú v našej Application Domain. Príkladom takýchto množín môže byť SQL databáza, OLAP databáza, web service, vyhľadávací stroj a podobne. V tomto prípade nie je možné na operácie využiť MSIL funkcie, ale je potrebné vytvoriť požiadavku pre externý zdroj, na základe ktorej sa nám vráti výsledok. Práve túto úlohu plní interface IQueryable. IQueryable je odvodené od IEnumerable. Rozšírené je o 2 hlavné vlastnosti:

· Expression – je objekt typu System.Linq.Expressions.Expression. Tento objekt reprezentuje operáciu, ktorú chceme vykonať nad externým zdrojom. Z matematického hľadiska Expression reprezentuje vyhodnocovací strom. Uzly v tomto strome sú jednotlivé operácie (napríklad sčítanie, zápor, porovnanie). Každý uzol je reprezentovaný samostatným objektom Expression (napríklad BinaryExpression, UnaryExpression, ConstatntExpression). Hraný v tomto strome znamenajú, že výsledok z jedného uzla sa použije ako operand v inom uzly. Hrany sú reprezentované vlastnosťami jednotlivých typov Expression.

· Provider – je objekt typu IQueryProvider. Tento objekt zoberie Expression a dokáže vytvoriť požiadavku pre externý zdroj a spustiť ju.

Nasledovný príklad vytvorí Expression, ktorá sčíta konštanty 3 a 4.

var const1 = Expression.Constant(3);

var const2 = Expression.Constant(4);

var add = Expression.AddChecked(const1, const2);

Console.WriteLine(add.ToString());

Na obrazovku sa vypíše:

(3 + 4)

Tým že je IQueryable odvodené od IEnumerable, tak podporuje prechádzanie prvkov. To funguje tak, že vytvoríme IQueryable objekt s nastavenou Expression. Keď začneme prechádzať prvky napríklad pomocou foreach, tak Provider vytvorí z Expression požiadavku na zdroj a spustí ju. Zdroj vráti nejaký výsledok. Provider ho transformuje na IEnumerator a posunie objektu IQueryable. A ten to vráti ako výsledok, pomocou ktorého sa prechádzajú prvky.

IQueryable rozšírenia

V statickej triede System.Linq.Queryable existujú tie isté rozšírenia ako pre IEnumerable. Teda napríklad funkcie Select, Where, Union, Sum a podobne. Na rozdiel od rozšírení pre IEnumerable tieto funkcie nemajú na vstupe predikátové a transformačné funkcie, ale Expression objekty. To znamená, že je možné vytvoriť nový IQueryable objekt, kde sa pridá ďalšia operácia.

Stiahnúť: Zdrojový kód

LINQ part 1 - Nové prvky v C#

duracellko — Wed, 31 Oct 2007 15:32:00 GMT

Týmto chcem začať seriál o C# 3.5 a LINQ. Myslím si, že článkov, blogov o LINQ je na webe viac než dosť (aj keď toto je možno prvý v slovenčine), tak nebudem sa zapájať do reklamnej kampane Microsoftu a nezačnem tu písať tutorialy na LINQ krok za krokom. Skôr ide o to, že táto technológia sa mi celkom zapáčila a chcem sa podeliť o skúsenosti, ako sa s touto technológiou hrám.

Aj práve preto príklady nemusia mať vždy reálny význam, ale môžu obsahovať triedy a funkcie so slovom Test.

Nové prvky v C#

Automatic properties

Automatické vlastnosti umožňujú definovať vlastnosť rovnako jednoducho ako pole. Ak máme vlastnosť, ktorá nerobí nič iné, len číta a nastavuje hodnotu pola, tak toto pole nemusíme definovať a ani telo vlastnosti. Stačí iba určiť, či má byť vlastnosť len read-only, alebo nie. Takže nasledovný kód v C# 2.0

private int id;

public int Id

{

get { return id; }

set { id = value; }

}

sa dá v C# 3.5 napísať takto:

public int Id { get; set; }

Implicitné určenie typu

Ak premennú inicializujeme priamo v jej definícii, tak nie je potrebné určiť typ premennej. Ten sa odvodí so vzorca, ktorý premennej priradíme. Na to slúži kľúčové slovíčko var.

var test = "Hello, World!";

Inicializácia objektov

Objekty sa dajú inicializovať podobným spôsobom ako polia. Čiže za volaním konštruktoru napíšeme do množinových zátvoriek priradenie vlastností.

var t = new TestData() { Id = 1, Text = "A" };

Rovnakým spôsobom môžeme inicializovať aj kolekcie.

var l = new List<int>() { 2, 4, 8, 16, 32 };

Extension methods

Rozšírujúce metódy dokážu rozšíriť už existujúcu triedu alebo interface o nové metódy. Rozširujúca metóda musí byť statická a musí byť v statickej triede. Musí mať minimálne jeden parameter a jeho typ určuje, ktorú typ sa rozširuje. Tento prvý parameter musí byť označený slovom this.

Napríklad nasledovná metóda rozširuje string o funkcie Left a Right, ktoré sú známe z Visual Basic.

public static class StringExtension

{

public static string Left(this string source, int count)

{

if (count >= source.Length)

return source;

else

return source.Substring(0, count);

}

public static string Right(this string source, int count)

{

if (count >= source.Length)

return source;

else

return source.Substring(source.Length - count, count);

}

Potom sa dajú tieto metódy použiť nasledovne.

var test = "Hello, World!";

for (int i = 0; i < 15; i++)

{

Console.WriteLine(test.Left(i));

}

Rozšírujúce metódy ponúka Inellisense. Vyhľadávajú sa metódy vo všetkých statických triedach v použitých namespaceoch s using. Ak sú dve rozširujúce metódy s rovnakým názvom v dvoch rôznych triedach, tak to kompilátor označí za chybu.

Rozširujúce metódy majú význam pri interfacoch. Je možné rozšíriť interface o rôzne metódy, pričom implementačné triedy nemusia implementovať tieto metódy. Napríklad v .NET 3.5 je množstvo rozširujúcich metód pre interface IEnumerable.

Lambda výrazy

Lambda výraz je iný zápis anonymnej metódy. Je to výraz skladajúci sa z ľavej a pravej strany oddelenej =>. Ľavá strana obsahuje jeden alebo viac parametrov. Jeden parameter sa uvádza iba názvom parametru. Viac parametrov sa uzatvorí do zátvoriek a oddeľuje čiarkou. Typ parametra sa odvodí z typu delegáta. Ak toto nie je možné, tak sa môže typ parametra určiť aj explicitne. Pravá strana obsahuje telo anonymnej metódy. Môže to byť jednoduchý výraz, ktorý vracia nejakú hodnotu. V tomto prípade nie je nutne použiť slovo return ani množinové zátvorky. Pri zložitejších funkciách je ale možné použiť blokovú konvenciu.

Lambda výrazy si ukážeme na rozšírených metódach typu IEnumerable. Takže najprv vytvoríme nasledovný List.

var l = new List<TestData>();

l.Add(new TestData() { Id = 1 });

l.Add(new TestData() { Id = -3, Text = "T" });

l.Add(new TestData() { Id = 9 });

Funkcia Sum spočíta všetky prvky zoznamu, pričom ako vstupný parameter je funkcia, ktorá skonvertuje prvok zoznamu na číslo. Nasledovný príklad ukazuje lambda výraz, ktorý prvok typu TestData zmení na číslo, ktoré je vo vlastnosti Id. Toto je najjednoduchšie, ale zaroveň najelegantnejšie použitie lambda výrazu.

var sum1 = l.Sum(td => td.Id);

Nasledovný príklad ukazuje lambda funkciu, ktorá ma zložitejšie telo s podmienkou. Tento príklad spočíta Idčka, ak nie je nastavený Text.

var sum2 = l.Sum(td => { if (td.Text == null) return td.Id; else return 0; });

Funkcia Select vráti nový objekt typu IEnumerable, pričom ako parameter je funkcia, ktorá konvertuje staré prvky na nové. Teda nasledovný príklad skonvertuje zoznam TestData na zoznam Idčiek.

var idList = l.Select(td => td.Id);

Nasledovný príklad ukazuje lambda výraz s dvoma parametrami. Zároveň ukazuje explicitné určenie typu, aj keď to v tomto prípade nie je nutné. Funkcia Aggregate zlúči všetky prvky zoznamu do jedného prvku, pričom sa využije funkcia, ktorá zlúči dva prvky do jedného. Nasledovný príklad spočíta absolútne hodnoty čísel.

var sum3 = idList.Aggregate((int i1, int i2) => Math.Abs(i1) + Math.Abs(i2));

Anonymné triedy

Anonymné triedy sú podobne ako anonymné metódy definované pri inicializácii. To znamená, že premennej priradíme objekt, ktorého typ nie je definovany, ale na mieste určíme vlastnosti a ich hodnoty. Vlastnosti sú len na čítanie a žiadne iné veci trieda nemôže obsahovať. Anonymnú triedy vytvoríme pomocou slova new a v množinových zátvorkách zadefinujeme vlastnosti a hodnoty rovnako ako pri inicializácii objektu.

Nasledovný príklad vytvorí anonymnú triedu s dvoma vlastnosťami FirstName a LastName.

var name = new { FirstName = "Rasto", LastName = "Novotny" };

Console.WriteLine("{0} {1}", name.FirstName, name.LastName);

Stiahnúť: Zdrojový kód