Met de komst van het nieuwe .Net Framework 3.5 kunnen ontwikkelaars nu ook gebruik maken van een nieuwe feature welke schuil gaat onder de naam LINQ.

LINQ is een verzamelnaam voor, momenteel, 3 verschillende onderdelen.

Ten eerste is er LINQ to Objects (L2O).

Met L2O kunnen ontwikkelaars met behulp van LINQ-queries zoeken in verzamelingen van objecten. Een voorbeeld hiervan is een ArrayList. Tot op heden moest men altijd gebruik maken van for-loops om objecten in zo’n verzameling te zoeken, dit is met de komst van L2O verleden tijd. Met een LINQ-query kun je namelijk een selectie maken van de objecten die aan je eisen voldoen.

Ten tweede hebben we LINQ to XML (L2XML).

Net zoals met L2O, is het met L2XML mogelijk om te zoeken naar objecten, elementen of bijvoorbeeld waarden, dit doormiddel van een LINQ-query. Dit heeft ook weer als voordeel dat je niet meer zelf code hoeft te genereren om een XML-document in te lezen in een XMLDocument en hier stap voor stap door te lopen, net zo lang totdat je iets hebt gevonden dat je zocht. Met L2XML schrijf je een query met de LINQ-syntax en .Net zorgt voor de rest. Behalve dat dit vele regels code scheelt, bespaard het ook veel ontwikkel tijd.

Ten derde kunnen we nu gebruik maken van LINQ to SQL (L2SQL).

Zelf vind ik het werken met SQL en databases in het algemeen leuk en interessant werk, vandaar dat L2SQL mij het meest aanspreekt en ik hier ook iets verder over ga uitweiden. Met behulp van L2SQL wordt het mogelijk gemaakt om vanuit je .Net code dynamische queries te genereren welke op de database worden uitgevoerd. De queries zijn het beste te vergelijken met de aloude dynamische SQL statements welke men vroeger vaak ook in de code had staan. De afgelopen jaren is er een trend geweest om dynamische SQL in code niet meer te gebruiken en alleen nog maar gebruik te maken van stored procedures. Deze verschuiving van werkwijze was ook meer dan logisch, aangezien dynamische SQL statements behoorlijk veel veiligheidsrisico’s met zich mee kunnen brengen. In een tijd waar veiligheid hoog in het vaandel staat kun je dat dus niet gebruiken.

Het voordeel van L2SQL is dat je de flexibiliteit van dynamische SQL statements hebt, maar de veiligheid van stored procedures. Wanneer je een LINQ-query maakt, dan wordt deze ‘vertaald’ naar een parameterized query welke wordt uitgevoerd op de database. In figuur 1 is een voorbeeld te zien hoe een LINQ-query wordt vertaald in een SQL-query

Figuur 1

De queries die ik zelf heb gemaakt zijn redelijk eenvoudig en ook goed te bevatten voor een ontwikkelaar die nog niet eerdere een LINQ-query heeft gezien. Een voorbeeld alhier:

var query = from item in dataContext.GetTable<Information.Item>()

select item;

Deze LINQ-query heeft nog behoorlijk veel weg van een ‘normale’ SQL-query, echter zijn de verschillen ook duidelijk zichtbaar.

Als eerste valt op de term var. Dit is een nieuw type dat is geintroduceerd in het .Net Framework 3.5. Heel kort door de bocht is het type var niets anders als een declaratie voor een generic object. Uiteraard zijn er vast wel verschillen op te noemen, maar zelf vind ik het wel een prettige gedachte om het zo te benoemen.

Verder is in deze query te zien dat men nu gebruik kan maken van de termen from en select in Visual Studio, welke we eerder al kenden van SQL-queries. Met LINQ hebben beide termen eigenlijk dezelfde functie behouden, namelijk bij from wordt gekozen uit welk object er een selectie moet plaatsvinden en bij select wordt aangegeven wat er moet worden geretourneerd.

Het bovenstaande is nog redelijk eenvoudig, maar het moge duidelijk zijn dat met de komst van LINQ er behoorlijk veel tijd kan worden bespaard in de ontwikkeltrajecten.

Door L2SQL hoeven er immers niet meer tientallen, danwel honderden, stored procedures te worden gemaakt/gegenereerd voor eenvoudige CRUD-acties. Door L2XML is het niet meer nodig om tientallen regels code te schrijven om een XML-document te doorzoeken en door L2O hoeven ontwikkelaars niet meer tig foreach-loops te maken in de code. Over het algemeen betekend minder code ook dat er minder bugs gemaakt kunnen worden, wat dus automatisch resulteert in stabielere applicaties.

Een goede bron van informatie over LINQ is het weblog van Scott Guthrie. Hier heb ik zelf veel kennis opgedaan van de mogelijkheden over LINQ: http://weblogs.asp.net/scottgu/archive/tags/LINQ/default.aspx