C#-functies die LINQ ondersteunen

Query-expressies

Query-expressies gebruiken een declaratieve syntaxis die vergelijkbaar is met SQL of XQuery om query's uit te voeren op System.Collections.Generic.IEnumerable<T> verzamelingen. Tijdens het compileren wordt de querysyntaxis geconverteerd naar methode-aanroepen naar de implementatie van de standaardquerymethoden van een LINQ-provider. Toepassingen bepalen de standaardqueryoperators die binnen het bereik vallen door de juiste naamruimte met een using instructie op te geven. De volgende query-expressie gebruikt een matrix met tekenreeksen, groepeert deze op basis van het eerste teken in de tekenreeks en ordet de groepen.

var query = from str in stringArray
            group str by str[0] into stringGroup
            orderby stringGroup.Key
            select stringGroup;

Impliciet getypte variabelen (var)

U kunt de var modifier gebruiken om de compiler te instrueren om het type af te stellen en toe te wijzen, zoals hier wordt weergegeven:

var number = 5;
var name = "Virginia";
var query = from str in stringArray
            where str[0] == 'm'
            select str;

Variabelen die zijn gedeclareerd als var sterk zijn getypt, net zoals variabelen waarvan u het type expliciet opgeeft. Het gebruik van var maakt het mogelijk om anonieme typen te maken, maar alleen voor lokale variabelen. Zie Impliciet getypte lokale variabelen voor meer informatie.

Initializers voor objecten en verzamelingen

Met initialisatiefuncties voor objecten en verzamelingen kunt u objecten initialiseren zonder expliciet een constructor voor het object aan te roepen. Initializers worden doorgaans gebruikt in query-expressies wanneer ze de brongegevens projecteren in een nieuw gegevenstype. Ervan uitgaande dat een klasse met de naam Customer openbaar Name en Phone eigenschappen, kan de objectinitiitiator worden gebruikt zoals in de volgende code:

var cust = new Customer { Name = "Mike", Phone = "555-1212" };

Als u doorgaat met uw Customer klas, gaat u ervan uit dat er een gegevensbron is aangeroepen IncomingOrdersen dat u voor elke order met een grote OrderSizeorder een nieuwe Customer op basis van die order wilt maken. Een LINQ-query kan worden uitgevoerd op deze gegevensbron en object initialisatie gebruiken om een verzameling te vullen:

var newLargeOrderCustomers = from o in IncomingOrders
                            where o.OrderSize > 5
                            select new Customer { Name = o.Name, Phone = o.Phone };

De gegevensbron heeft mogelijk meer eigenschappen gedefinieerd dan de Customer klasse, OrderSizemaar met objectinitialisatie worden de gegevens die door de query worden geretourneerd, in het gewenste gegevenstype ingedeeld. U kiest de gegevens die relevant zijn voor uw klasse. Als gevolg hiervan hebt u nu een System.Collections.Generic.IEnumerable<T> gevuld met de nieuwe Customers die u wilt hebben. Het voorgaande voorbeeld kan ook worden geschreven in de syntaxis van de methode LINQ:

var newLargeOrderCustomers = IncomingOrders.Where(x => x.OrderSize > 5).Select(y => new Customer { Name = y.Name, Phone = y.Phone });

Vanaf C# 12 kunt u een verzamelingsexpressie gebruiken om een verzameling te initialiseren.

Zie voor meer informatie:

• Initializers voor objecten en verzamelingen
• Syntaxis van query-expressie voor standaardqueryoperators

Anonieme typen

De compiler maakt een anoniem type. De typenaam is alleen beschikbaar voor de compiler. Anonieme typen bieden een handige manier om een set eigenschappen tijdelijk in een queryresultaat te groeperen zonder dat u een afzonderlijk benoemd type hoeft te definiëren. Anonieme typen worden geïnitialiseerd met een nieuwe expressie en een object-initialisatiefunctie, zoals hier wordt weergegeven:

select new {name = cust.Name, phone = cust.Phone};

Vanaf C# 7 kunt u tuples gebruiken om niet-benoemde typen te maken.

Extensiemethoden

Een extensiemethode is een statische methode die kan worden gekoppeld aan een type, zodat deze kan worden aangeroepen alsof het een instantiemethode voor het type is. Met deze functie kunt u in feite nieuwe methoden toevoegen aan bestaande typen zonder ze daadwerkelijk te wijzigen. De standaardqueryoperators zijn een set extensiemethoden die LINQ-queryfunctionaliteit bieden voor elk type dat wordt geïmplementeerd IEnumerable<T>.

Lambda-expressies

Een lambda-expressies is een inlinefunctie die de => operator gebruikt om invoerparameters van de hoofdtekst van de functie te scheiden en kan tijdens het compileren worden geconverteerd naar een gemachtigde of een expressiestructuur. In LINQ-programmering worden lambda-expressies aangeroepen wanneer u directe methodeaanroepen uitvoert naar de standaardqueryoperators.

Expressies als gegevens

Queryobjecten kunnen worden composeerbaar, wat betekent dat u een query uit een methode kunt retourneren. Objecten die query's vertegenwoordigen, slaan de resulterende verzameling niet op, maar in plaats daarvan de stappen om de resultaten te produceren wanneer dat nodig is. Het voordeel van het retourneren van queryobjecten van methoden is dat ze verder kunnen worden samengesteld of gewijzigd. Daarom moet elke retourwaarde of out parameter van een methode die een query retourneert, ook dat type hebben. Als een methode een query in een concreet List<T> of Array type materialiseert, worden de queryresultaten geretourneerd in plaats van de query zelf. Een queryvariabele die wordt geretourneerd vanuit een methode, kan nog steeds worden samengesteld of gewijzigd.

In het volgende voorbeeld retourneert de eerste methode QueryMethod1 een query als retourwaarde en retourneert de tweede methode QueryMethod2 een query als een out parameter (returnQ in het voorbeeld). In beide gevallen is het een query die wordt geretourneerd, niet queryresultaten.

IEnumerable<string> QueryMethod1(int[] ints) =>
    from i in ints
    where i > 4
    select i.ToString();

void QueryMethod2(int[] ints, out IEnumerable<string> returnQ) =>
    returnQ = from i in ints
              where i < 4
              select i.ToString();

int[] nums = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ];

var myQuery1 = QueryMethod1(nums);

De query myQuery1 wordt uitgevoerd in de volgende foreach-lus.

foreach (var s in myQuery1)
{
    Console.WriteLine(s);
}

Plaats de muis aanwijzer om myQuery1 het type te zien.

U kunt ook de query uitvoeren die rechtstreeks wordt QueryMethod1 geretourneerd, zonder gebruik te maken van myQuery1.

foreach (var s in QueryMethod1(nums))
{
    Console.WriteLine(s);
}

Plaats de muis aanwijzer op de aanroep om het retourtype te QueryMethod1 zien.

QueryMethod2 retourneert een query als de waarde van out de parameter:

QueryMethod2(nums, out IEnumerable<string> myQuery2);

// Execute the returned query.
foreach (var s in myQuery2)
{
    Console.WriteLine(s);
}

U kunt een query wijzigen met behulp van querysamenstelling. In dit geval wordt het vorige queryobject gebruikt om een nieuw queryobject te maken. Dit nieuwe object retourneert andere resultaten dan het oorspronkelijke queryobject.

myQuery1 = from item in myQuery1
           orderby item descending
           select item;

// Execute the modified query.
Console.WriteLine("\nResults of executing modified myQuery1:");
foreach (var s in myQuery1)
{
    Console.WriteLine(s);
}