C# Language
Linq naar objecten

Invoering

Hoe LINQ to Object query's uitvoert

LINQ-zoekopdrachten worden niet onmiddellijk uitgevoerd. Wanneer u de query bouwt, slaat u de query eenvoudig op voor toekomstige uitvoering. Alleen wanneer u daadwerkelijk vraagt om de query te herhalen, wordt de query uitgevoerd (bijvoorbeeld in een for-lus, wanneer u ToList, Count, Max, Average, First, etc. aanroept)

Dit wordt beschouwd als uitgestelde uitvoering . Dit stelt u in staat om de query in meerdere stappen op te bouwen, mogelijk te wijzigen op basis van voorwaardelijke instructies en deze later pas uit te voeren als u het resultaat nodig hebt.

Gezien de code:

var query = from n in numbers 
            where n % 2 != 0
            select n;

Het bovenstaande voorbeeld slaat alleen de query in query variabel. Het voert de query zelf niet uit.

De instructie foreach dwingt de zoekopdracht uit te voeren:

foreach(var n in query) {
    Console.WriteLine($"Number selected {n}");
}

Sommige LINQ-methoden activeren ook de uitvoering van de query, Count , First , Max , Average . Ze retourneren enkele waarden. ToList en ToArray verzamelen resultaten en veranderen deze in respectievelijk een lijst of een array.

Houd er rekening mee dat u meerdere query's meerdere keren kunt doorlopen als u meerdere LINQ-functies voor dezelfde query aanroept. Dit kan u verschillende resultaten geven bij elk gesprek. Als u slechts met één gegevensset wilt werken, moet u deze in een lijst of array opslaan.

LINQ gebruiken voor objecten in C #

Een eenvoudige SELECT-zoekopdracht in Linq

static void Main(string[] args)
{
    string[] cars = { "VW Golf", 
                        "Opel Astra", 
                        "Audi A4", 
                        "Ford Focus", 
                        "Seat Leon", 
                        "VW Passat", 
                        "VW Polo", 
                        "Mercedes C-Class" };

    var list = from car in cars
               select car;

    StringBuilder sb = new StringBuilder();

    foreach (string entry in list)
    {
        sb.Append(entry + "\n");
    }

    Console.WriteLine(sb.ToString());
    Console.ReadLine();
}

In het bovenstaande voorbeeld wordt een reeks strings (auto's) gebruikt als een verzameling objecten die met LINQ kunnen worden opgevraagd. In een LINQ-query komt de van-clausule eerst om de gegevensbron (auto's) en de bereikvariabele (auto) te introduceren. Wanneer de query wordt uitgevoerd, dient de bereikvariabele als referentie voor elk opeenvolgend element in auto's. Omdat de compiler het type auto kan afleiden, hoeft u dit niet expliciet op te geven

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op:

SELECTEER met een WHERE-clausule

var list = from car in cars
           where car.Contains("VW")
           select car;

De WHERE-component wordt gebruikt om de stringarray (auto's) te doorzoeken om een subset van een array te vinden en te retourneren die voldoet aan de WHERE-component.

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op:

Een geordende lijst genereren

var list = from car in cars
           orderby car ascending 
           select car;

Soms is het handig om de geretourneerde gegevens te sorteren. De orderby-clausule zorgt ervoor dat de elementen worden gesorteerd volgens de standaardvergelijker voor het type dat wordt gesorteerd.

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op:

Werken met een aangepast type

In dit voorbeeld wordt een getypte lijst gemaakt, ingevuld en vervolgens opgevraagd

public class Car
{
    public String Name { get; private set; }
    public int UnitsSold { get; private set; }

    public Car(string name, int unitsSold)
    {
        Name = name;
        UnitsSold = unitsSold;
    }
}

class Program
{
    static void Main(string[] args)
    {

        var car1 = new Car("VW Golf", 270952);
        var car2 = new Car("Opel Astra", 56079);
        var car3 = new Car("Audi A4", 52493);
        var car4 = new Car("Ford Focus", 51677);
        var car5 = new Car("Seat Leon", 42125);
        var car6 = new Car("VW Passat", 97586);
        var car7 = new Car("VW Polo", 69867);
        var car8 = new Car("Mercedes C-Class", 67549);

        var cars = new List<Car> { 
            car1, car2, car3, car4, car5, car6, car7, car8 };
        var list = from car in cars
                   select car.Name;

        foreach (var entry in list)
        {
            Console.WriteLine(entry);
        }
        Console.ReadLine();
    }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op:

Tot nu toe lijken de voorbeelden niet geweldig, omdat je gewoon door de array kunt bladeren om in wezen hetzelfde te doen. Met de enkele voorbeelden hieronder kunt u echter zien hoe u complexere query's kunt maken met LINQ naar objecten en meer kunt bereiken met veel minder code.

In het onderstaande voorbeeld kunnen we auto's selecteren die meer dan 60000 eenheden hebben verkocht en deze sorteren op het aantal verkochte eenheden:

var list = from car in cars
           where car.UnitsSold > 60000 
           orderby car.UnitsSold descending 
           select car;

StringBuilder sb = new StringBuilder();

foreach (var entry in list)
{
    sb.AppendLine($"{entry.Name} - {entry.UnitsSold}");
}
Console.WriteLine(sb.ToString());

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op:

In het onderstaande voorbeeld kunnen we auto's selecteren die een oneven aantal eenheden hebben verkocht en deze alfabetisch op zijn naam bestellen:

var list = from car in cars
           where car.UnitsSold % 2 != 0 
           orderby car.Name ascending 
           select car;

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op: