LINQ: Query Syntaxis vs. Method syntaxis

In het vorige artikel vingen we een glimp op van beide LINQ syntaxen, maar laten we ze nu even naast elkaar op tafel leggen, zodat we er zeker van zijn waarover we in dit artikel praten.

 var listOfNames = new List<string>()
{
    "John Doe",
    "Jane Doe",
    "Jenna Doe",
    "Joe Doe"
};

// Query syntax
var qNames = from name in listOfNames where name.Length <= 8 select name;
// Method syntax
var mNames = listOfNames.Where(name => name.Length <= 8);

Terwijl beide regels precies hetzelfde opleveren, is het verschil in syntaxis duidelijk: De query syntax lijkt meer op andere query talen, bv. SQL en minder op een gewoon C# statement. De method syntax echter, lijkt meer op de C# code die je in dit tutorial hebt gezien.

Dus het grootste verschil is echt de syntaxis. Daarom zie je dat beide variaties gebruikt worden wanneer je C# artikelen leest en antwoorden vindt op jouw vragen. Het schijnt dat de query syntaxis enigszins populairder is dan de method syntaxis omdat sommigen die gemakkelijker vinden om te lezen. Dit zouden wel eens mensen kunnen zijn die gewoon zijn om gegevens op te halen met SQL. Anderzijds zou je de method syntaxis gemakkelijker kunnen vinden om te lezen wanneer je wél ervaring hebt met C# maar je nog nooit eerder een query taal als SQL hebt gebruikt. Dus voor op zijn minst een aantal operaties, zoals het tellen van de items in het resultaat van de query, zul je de method syntaxis moeten gebruiken.

Lambda Expressies

In het voorbeeld van de method syntaxis zou je iets kunnen zien dat je nog niet eerder hebt gezien, zoals de Where() method. Zo ziet dat er uit:

name => name.Length <= 8

Dit heet een Lambda Expressie en hoewel het niet een specifiek onderdeel is van de LINQ functionaliteit, wordt het VEEL gebruikt in de wereld van LINQ. Daarom zul je het ook vaak zien in de volgende artikelen. Terwijl ik in een ander artikel dieper inga op Lambda expressies, is dit een goed moment om een zeer basale indruk te krijgen van hoe ze werken.

In feite is het heel eenvoudig. Een Lambda Expressie heeft een linkerkant en een rechterkant, verdeeld door de => operator (niet te verwarren met de "groter dan of gelijk aan" operator, die er zo uit ziet: >=).

Aan de linkerkant hebben we de input parameter(s), (dat kunnen er verscheidene zijn, maar hier slechts één) die de name variabele is.

Aan de rechterkant hebben we het expressie/statement gedeelte. Hier genereren we het verwachte resultaat, in dit geval een boolean waarde die de Where() method vertelt of de naam in kwestie moet worden toegevoegd of niet. We beantwoorden dat met een expressie, waarbij we zeggen dat we naam willen toevoegen als hij 8 letters (of minder) lang is. We kunnen (maar dat is geen vereiste) de input (links) gebruiken om dat te bepalen. We refereren ernaar als "name", maar we zouden het ook "x" kunnen noemen. In dat geval zou het statement er zo uitzien:

var mNames = listOfNames.Where(x => x.Length <= 8);

Lambda Expressies zijn wat meer dan alleen maar LINQ queries, maar ze worden belangrijk als je LINQ gebruikt. Dat zul je zien in de volgende artikelen. Als je meer wilt weten over Lambda Expressies in het algemeen, kijk dan elders in dit tutorial waar het onderwerp zal worden behandeld

Samenvatting

LINQ komt met twee syntactische smaken. De Query en de Method syntaxis. Ze doen bijna hetzelfde, maar waar de query syntaxis bijna een nieuwe taal is binnen C#, lijkt de method syntaxis op reguliere C# methods. In dit tutorial gebruiken we vooral de method syntax, wanneer we alle mogelijke operaties die binnen LINQ beschikbaar zijn, gaan bespreken.