Delen via

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 converteert de compiler de querysyntaxis 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 neemt een array van strings, groepeert deze op basis van het eerste teken in de string en ordent 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 zijn sterk getypt, net zoals variabelen waarvan u het type expliciet opgeeft. Met deze var functie kunt u anonieme typen maken, maar alleen voor lokale variabelen. Zie Impliciet getypte lokale variabelen voor meer informatie.

Initialisatiefuncties voor objecten en verzamelingen

Met initialisatiefuncties voor objecten en verzamelingen kunt u objecten initialiseren zonder expliciet een constructor voor het object aan te roepen. Normaal gesproken gebruikt u initialisaties in query-expressies wanneer ze de brongegevens projecteren in een nieuw gegevenstype. Uitgaande van een klasse genaamd Customer met publieke eigenschappen Name en Phone, kunt u de objectinitializer gebruiken zoals in de volgende code:

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

Als u doorgaat met uw Customer klasse, gaat u ervan uit dat er een gegevensbron is genaamd IncomingOrders, en dat u voor elke order met een grote OrderSize, een nieuwe Customer op basis van die order wilt maken. U kunt een LINQ-query uitvoeren 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 wilde. U kunt ook het voorgaande voorbeeld schrijven 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.

Voor meer informatie, zie:

Anonieme typen

De compiler maakt een anoniem type. Alleen de compiler heeft toegang tot de typenaam. 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. U initialiseert anonieme typen 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.

Uitbreidingsleden

Een uitbreidingslid is een statisch lid van een statische klasse die is gekoppeld aan een type dat het ontvangertype wordt genoemd. U kunt een extensielid aanroepen alsof het een lid is van het ontvangertype. Met deze functie kunt u nieuwe leden toevoegen aan bestaande typen zonder ze daadwerkelijk te wijzigen. De standaardqueryoperators zijn een set extensiemethoden die LINQ-queryfunctionaliteit bieden voor elk type dat `IEnumerable<T>` implementeert.

Lambda-expressies

Een lambda-expressie 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 zijn samenstelbaar, wat betekent dat u een query uit een methode kunt teruggeven. 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 op basis van methoden is dat u ze verder kunt opstellen of wijzigen. 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. U kunt nog steeds een queryvariabele opstellen of wijzigen die wordt geretourneerd door een methode.

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);

Met de volgende foreach lus wordt een query myQuery1uitgevoerd.

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

Plaats de muiscursor boven myQuery1 om het type te zien.

U kunt de query die QueryMethod1 retourneert ook direct uitvoeren, zonder gebruik te maken van myQuery1.

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

Plaats de muisaanwijzer op de oproep naar QueryMethod1 om het retourtype te zien.

QueryMethod2 retourneert een query als waarde van zijn out 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);
}
  • Last updated on