Werken met collecties: foreach en LINQ

Wat is LINQ?

LINQ (Language Integrated Query) is een set methoden waarmee je collecties kunt filteren, sorteren en transformeren met leesbare, expressieve code. Het werkt op elke collectie die IEnumerable<T> implementeert: arrays, lijsten, enzovoort.

Voeg bovenaan je bestand toe: using System.Linq; (in .NET 6+ is dit al automatisch beschikbaar).

Where: filteren

List<string> lagen = new List<string> { "Muren", "Deuren", "Ramen", "Maatvoering", "Hulplijnen" };

// Alle lagen waarvan de naam met 'M' begint:
var gefiltreerd = lagen.Where(l => l.StartsWith("M")).ToList();
// [ "Muren", "Maatvoering" ]

Select: transformeren

// Converteer namen naar hoofdletters:
var hoofdletters = lagen.Select(l => l.ToUpper()).ToList();
// [ "MUREN", "DEUREN", "RAMEN", "MAATVOERING", "HULPLIJNEN" ]

OrderBy: sorteren

var gesorteerd = lagen.OrderBy(l => l).ToList();
// alfabetisch gesorteerd

var omgekeerd = lagen.OrderByDescending(l => l.Length).ToList();
// langste naam eerst

FirstOrDefault en Count

string? eersteM = lagen.FirstOrDefault(l => l.StartsWith("M"));
// "Muren"  (of null als niets gevonden)

int aantalKort = lagen.Count(l => l.Length <= 5);
// 2 ("Ramen" = 5, "Deuren" heeft 6 dus niet meegerekend...)

LINQ op objecten

class Onderdeel
{
    public string Naam { get; set; } = "";
    public double Gewicht { get; set; }
    public string Materiaal { get; set; } = "";
}

List<Onderdeel> onderdelen = new List<Onderdeel>
{
    new Onderdeel { Naam = "Bout M8",    Gewicht = 0.02, Materiaal = "Staal" },
    new Onderdeel { Naam = "Moer M8",    Gewicht = 0.01, Materiaal = "Staal" },
    new Onderdeel { Naam = "Schijf M8",  Gewicht = 0.005, Materiaal = "Nylon" },
    new Onderdeel { Naam = "Profiel 40", Gewicht = 2.5,  Materiaal = "Aluminium" },
};

// Alle stalen onderdelen, gesorteerd op gewicht:
var staalOnderdelen = onderdelen
    .Where(o => o.Materiaal == "Staal")
    .OrderBy(o => o.Gewicht)
    .ToList();

// Totaal gewicht:
double totaal = onderdelen.Sum(o => o.Gewicht);
Console.WriteLine($"Totaal gewicht: {totaal} kg");

Lambda-expressies uitgelegd

De notatie l => l.StartsWith("M") heet een lambda. Het is een mini-methode zonder naam:

• l — de parameter (het huidige item in de lijst)
• => — "geeft terug"
• l.StartsWith("M") — de expressie die true of false oplevert

In de volgende post leren we het verschil tussen reference types en value types — cruciaal om bugs te vermijden.

What is LINQ?

LINQ (Language Integrated Query) is a set of methods that lets you filter, sort and transform collections with readable, expressive code. It works on any collection that implements IEnumerable<T>: arrays, lists, and more.

Where: filtering

List<string> layers = new List<string> { "Walls", "Doors", "Windows", "Dimensions", "Guidelines" };

var filtered = layers.Where(l => l.StartsWith("W")).ToList();
// [ "Walls", "Windows" ]

Select: transforming

var upperCase = layers.Select(l => l.ToUpper()).ToList();
// [ "WALLS", "DOORS", ... ]

OrderBy: sorting

var sorted = layers.OrderBy(l => l).ToList();           // alphabetical
var byLength = layers.OrderByDescending(l => l.Length).ToList(); // longest first

FirstOrDefault and Count

string? firstW = layers.FirstOrDefault(l => l.StartsWith("W"));
// "Walls" (or null if not found)

int shortCount = layers.Count(l => l.Length <= 5);
// count of layers with 5 or fewer characters

LINQ on objects

class Part
{
    public string Name { get; set; } = "";
    public double Weight { get; set; }
    public string Material { get; set; } = "";
}

List<Part> parts = new List<Part>
{
    new Part { Name = "Bolt M8",    Weight = 0.02,  Material = "Steel" },
    new Part { Name = "Nut M8",     Weight = 0.01,  Material = "Steel" },
    new Part { Name = "Washer M8",  Weight = 0.005, Material = "Nylon" },
    new Part { Name = "Profile 40", Weight = 2.5,   Material = "Aluminium" },
};

var steelParts = parts
    .Where(p => p.Material == "Steel")
    .OrderBy(p => p.Weight)
    .ToList();

double totalWeight = parts.Sum(p => p.Weight);
Console.WriteLine($"Total weight: {totalWeight} kg");

Lambda expressions explained

The notation l => l.StartsWith("W") is called a lambda. It is a mini-method without a name:

• l — the parameter (the current item in the list)
• => — "returns"
• l.StartsWith("W") — the expression that returns true or false

In the next post we learn the difference between reference types and value types — crucial to avoid bugs.