.NET Framework
LINQ

ASP.NET asp.net-mvc C# Language Entity Framework JavaScript Regular Expressions SQL Microsoft SQL Server Visual Basic .NET Language wpf
Zoeken…


Invoering

LINQ (Language Integrated Query) is een uitdrukking die gegevens ophaalt uit een gegevensbron. LINQ vereenvoudigt deze situatie door een consistent model aan te bieden voor het werken met gegevens in verschillende soorten gegevensbronnen en -indelingen. In een LINQ-query werkt u altijd met objecten. U gebruikt dezelfde basiscoderingspatronen om gegevens op te vragen en te transformeren in XML-documenten, SQL-databases, ADO.NET-gegevenssets, .NET-collecties en elk ander formaat waarvoor een provider beschikbaar is. LINQ kan worden gebruikt in C # en VB.

Syntaxis

  • public static TSource Aggregate <TSource> (deze IEnumerable <TSource> bron, Func <TSource, TSource, TSource> func)
  • public static TAccumulate Aggregate <TSource, TAccumulate> (deze IEnumerable <TSource> source, TAccumulate seed, Func <TAccumulate, TSource, TAccumulate> func)
  • public static TResult Aggregate <TSource, TAccumulate, TResult> (deze IEnumerable <TSource> source, TAccumulate seed, Func <TAccumulate, TSource, TAccumulate> func, Func <TAccumulate, TResult> resultSelector)
  • public static Boolean All <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Boolean> predicaat)
  • public static Boolean Any <TSource> (deze IEnumerable <TSource> bron)
  • public static Boolean Elke <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Boolean> predicaat)
  • public static IEnumerable <TSource> AsEnumerable <TSource> (deze IEnumerable <TSource> bron)
  • public static Decimal Average (deze IEnumerable <Decimal> bron)
  • public static Double Average (deze IEnumerable <Double> bron)
  • public static Double Average (deze IEnumerable <Int32> bron)
  • public static Double Average (deze IEnumerable <Int64> bron)
  • public static Nullable <Decimal> Gemiddeld (deze IEnumerable <Nullable <Decimal>> bron)
  • public static Nullable <Double> Gemiddeld (deze IEnumerable <Nullable <Double>> bron)
  • public static Nullable <Dubbel> Gemiddeld (deze IEnumerable <Nullable <Int32>> bron)
  • public static Nullable <Dubbel> Gemiddeld (deze IEnumerable <Nullable <Int64>> bron)
  • public static Nullable <Single> Gemiddeld (deze IEnumerable <Nullable <Single>> bron)
  • public static Single Average (this IEnumerable <Single> source)
  • public static Decimal Average <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Decimal> selector)
  • public static Double Average <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Double> selector)
  • public static Double Average <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Int32> selector)
  • public static Double Average <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Int64> selector)
  • public static Nullable <Decimal> Gemiddelde <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Nullable <Decimal>> selector)
  • public static Nullable <Double> Gemiddelde <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Nullable <Double>> selector)
  • public static Nullable <Double> Gemiddelde <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Nullable <Int32>> selector)
  • public static Nullable <Double> Gemiddeld <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Nullable <Int64>> selector)
  • public static Nullable <Single> Gemiddelde <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Nullable <Single>> selector)
  • public static Single Average <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Single> selector)
  • public static IEnumerable <TResult> Cast <TResult> (deze IEnumerable bron)
  • public static IEnumerable <TSource> Concat <TSource> (deze IEnumerable <TSource> first, IEnumerable <TSource> second)
  • public static Boolean Bevat <TSource> (deze IEnumerable <TSource> bron, TSource-waarde)
  • public static Boolean Bevat <TSource> (deze IEnumerable <TSource> -bron, TSource-waarde, IEqualityComparer <TSource> -vergelijker)
  • public static Int32 Count <TSource> (deze IEnumerable <TSource> bron)
  • public static Int32 Count <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Boolean> predicaat)
  • public static IEnumerable <TSource> DefaultIfEmpty <TSource> (deze IEnumerable <TSource> bron)
  • public static IEnumerable <TSource> DefaultIfEmpty <TSource> (deze IEnumerable <TSource> bron, TSource defaultValue)
  • public static IEnumerable <TSource> Distinct <TSource> (deze IEnumerable <TSource> bron)
  • public static IEnumerable <TSource> Distinct <TSource> (deze IEnumerable <TSource> -bron, IEqualityComparer <TSource> -vergelijker)
  • public static TSource ElementAt <TSource> (deze IEnumerable <TSource> bron, Int32 index)
  • public static TSource ElementAtOrDefault <TSource> (deze IEnumerable <TSource> -bron, Int32-index)
  • public static IEnumerable <TResult> Empty <TResult> ()
  • public static IEnumerable <TSource> Behalve <TSource> (eerst deze IEnumerable <TSource>, IEnumerable <TSource> second)
  • public static IEnumerable <TSource> Behalve <TSource> (eerst deze IEnumerable <TSource>, IEnumerable <TSource> second, IEqualityComparer <TSource> comparer)
  • public static TSource First <TSource> (deze IEnumerable <TSource> -bron)
  • public static TSource First <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Boolean> predicaat)
  • public static TSource FirstOrDefault <TSource> (deze IEnumerable <TSource> bron)
  • public static TSource FirstOrDefault <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Boolean> predicaat)
  • public static IEnumerable <IGrouping <TKey, TSource >> GroupBy <TSource, TKey> (deze IEnumerable <TSource> source, Func <TSource, TKey> keySelector)
  • public static IEnumerable <IGrouping <TKey, TSource >> GroupBy <TSource, TKey> (deze IEnumerable <TSource> source, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> comparer)
  • public static IEnumerable <IGrouping <TKey, TElement >> GroupBy <TSource, TKey, TElement> (deze IEnumerable <TSource> bron, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • public static IEnumerable <IGrouping <TKey, TElement >> GroupBy <TSource, TKey, TElement> (deze IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> comparer)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TResult> (deze IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TKey, IEnumerable <TSource>, TResult> resultSelector)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TResult> (this IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TKey, IEnumerable <TSource>, TResult> resultSelector, IEqualityComparer <TKey> vergelijker)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TElement, TResult> (this IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <TKey, IEnumerable <TElement>, TResult > resultSelector)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TElement, TResult> (this IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <TKey, IEnumerable <TElement>, TResult > resultSelector, IEqualityComparer <TKey> comparer)
  • public static IEnumerable <TResult> GroupJoin <TOuter, TInner, TKey, TResult> (this IEnumerable <TOuter> outer, IEnumerable <TInner> inner, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, IEnumer <TInner>, TResult> resultSelector)
  • public static IEnumerable <TResult> GroupJoin <TOuter, TInner, TKey, TResult> (this IEnumerable <TOuter> outer, IEnumerable <TInner> inner, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, IEnumer <TInner>, TResult> resultSelector, IEqualityComparer <TKey> comparer)
  • public static IEnumerable <TSource> Snijd <TSource> in (eerst deze IEnumerable <TSource>, IEnumerable <TSource> second)
  • public static IEnumerable <TSource> Snijd <TSource> in (eerst deze IEnumerable <TSource>, IEnumerable <TSource> second, IEqualityComparer <TSource> comparer)
  • public static IEnumerable <TResult> Word lid van <TOuter, TInner, TKey, TResult> (deze IEnumerable <TOuter> outer, IEnumerable <TInner> inner, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, TInner, TResult> resultSelector)
  • public static IEnumerable <TResult> Word lid van <TOuter, TInner, TKey, TResult> (deze IEnumerable <TOuter> outer, IEnumerable <TInner> inner, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, TInner, TResult> resultSelector, IEqualityComparer <TKey> comparer)
  • public static TSource Laatste <TSource> (deze IEnumerable <TSource> bron)
  • public static TSource Laatste <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Boolean> predicaat)
  • public static TSource LastOrDefault <TSource> (deze IEnumerable <TSource> -bron)
  • public static TSource LastOrDefault <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Boolean> predicaat)
  • public static Int64 LongCount <TSource> (deze IEnumerable <TSource> bron)
  • public static Int64 LongCount <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Boolean> predicaat)
  • public static Decimal Max (deze IEnumerable <Decimal> bron)
  • public static Double Max (deze IEnumerable <Double> -bron)
  • public static Int32 Max (deze IEnumerable <Int32> bron)
  • public static Int64 Max (deze IEnumerable <Int64> bron)
  • public static Nullable <Decimal> Max (deze IEnumerable <Nullable <Decimal>> bron)
  • public static Nullable <Double> Max (deze IEnumerable <Nullable <Double>> bron)
  • public static Nullable <Int32> Max (deze IEnumerable <Nullable <Int32>> bron)
  • public static Nullable <Int64> Max (deze IEnumerable <Nullable <Int64>> bron)
  • public static Nullable <Single> Max (deze IEnumerable <Nullable <Single>> bron)
  • public static Single Max (deze IEnumerable <Single> bron)
  • public static TSource Max <TSource> (deze IEnumerable <TSource> -bron)
  • public static Decimal Max <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Decimal> selector)
  • public static Double Max <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Double> selector)
  • public static Int32 Max <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Int32> selector)
  • public static Int64 Max <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Int64> selector)
  • public static Nullable <Decimal> Max <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Nullable <Decimal>> selector)
  • public static Nullable <Double> Max <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Nullable <Double>> selector)
  • public static Nullable <Int32> Max <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Nullable <Int32>> selector)
  • public static Nullable <Int64> Max <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Nullable <Int64>> selector)
  • public static Nullable <Single> Max <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Nullable <Single>> selector)
  • public static Single Max <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Single> selector)
  • public static TResult Max <TSource, TResult> (deze IEnumerable <TSource> bron, Func <TSource, TResult> selector)
  • public static Decimal Min (deze IEnumerable <Decimal> bron)
  • public static Double Min (deze IEnumerable <Double> -bron)
  • public static Int32 Min (deze IEnumerable <Int32> bron)
  • public static Int64 Min (deze IEnumerable <Int64> bron)
  • public static Nullable <Decimal> Min (deze IEnumerable <Nullable <Decimal>> bron)
  • public static Nullable <Double> Min (deze IEnumerable <Nullable <Double>> bron)
  • public static Nullable <Int32> Min (deze IEnumerable <Nullable <Int32>> bron)
  • public static Nullable <Int64> Min (deze IEnumerable <Nullable <Int64>> bron)
  • public static Nullable <Single> Min (deze IEnumerable <Nullable <Single>> bron)
  • public static Single Min (deze IEnumerable <Single> bron)
  • public static TSource Min <TSource> (deze IEnumerable <TSource> bron)
  • public static Decimal Min <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Decimal> selector)
  • public static Double Min <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Double> selector)
  • public static Int32 Min <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Int32> selector)
  • public static Int64 Min <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Int64> selector)
  • public static Nullable <Decimal> Min <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Nullable <Decimal>> selector)
  • public static Nullable <Double> Min <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Nullable <Double>> selector)
  • public static Nullable <Int32> Min <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Nullable <Int32>> selector)
  • public static Nullable <Int64> Min <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Nullable <Int64>> selector)
  • public static Nullable <Single> Min <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Nullable <Single>> selector)
  • public static Single Min <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Single> selector)
  • public static TResult Min <TSource, TResult> (deze IEnumerable <TSource> bron, Func <TSource, TResult> selector)
  • public static IEnumerable <TResult> OfType <TResult> (this IEnumerable source)
  • public static IOrderedEnumerable <TSource> OrderBy <TSource, TKey> (deze IEnumerable <TSource> source, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> OrderBy <TSource, TKey> (deze IEnumerable <TSource> source, Func <TSource, TKey> keySelector, IComparer <TKey> comparer)
  • public static IOrderedEnumerable <TSource> OrderByDescending <TSource, TKey> (deze IEnumerable <TSource> -bron, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> OrderByDescending <TSource, TKey> (deze IEnumerable <TSource> source, Func <TSource, TKey> keySelector, IComparer <TKey> comparer)
  • public static IEnumerable <Int32> Range (Int32 start, Int32 count)
  • public static IEnumerable <TResult> Repeat <TResult> (TResult element, Int32 count)
  • public static IEnumerable <TSource> Reverse <TSource> (deze IEnumerable <TSource> -bron)
  • public static IEnumerable <TResult> Selecteer <TSource, TResult> (deze IEnumerable <TSource> source, Func <TSource, TResult> selector)
  • public static IEnumerable <TResult> Selecteer <TSource, TResult> (deze IEnumerable <TSource> source, Func <TSource, Int32, TResult> selector)
  • public static IEnumerable <TResult> SelectMany <TSource, TResult> (deze IEnumerable <TSource> source, Func <TSource, IEnumerable <TResult>> selector)
  • public static IEnumerable <TResult> SelectMany <TSource, TResult> (deze IEnumerable <TSource> source, Func <TSource, Int32, IEnumerable <TResult>> selector)
  • public static IEnumerable <TResult> SelectMany <TSource, TCollection, TResult> (this IEnumerable <TSource> source, Func <TSource, IEnumerable <TCollection>> collectionSelector, Func <TSource, TCollection, TResult> resultSelector)
  • public static IEnumerable <TResult> SelectMany <TSource, TCollection, TResult> (this IEnumerable <TSource> source, Func <TSource, Int32, IEnumerable <TCollection>> collectionSelector, Func <TSource, TCollection, TResult> resultSelector)
  • public static Boolean SequenceEqual <TSource> (eerst deze IEnumerable <TSource>, IEnumerable <TSource> second)
  • public static Boolean SequenceEqual <TSource> (deze IEnumerable <TSource> first, IEnumerable <TSource> second, IEqualityComparer <TSource> comparer)
  • public static TSource Single <TSource> (deze IEnumerable <TSource> bron)
  • public static TSource Single <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Boolean> predicaat)
  • public static TSource SingleOrDefault <TSource> (deze IEnumerable <TSource> -bron)
  • public static TSource SingleOrDefault <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Boolean> predicaat)
  • public static IEnumerable <TSource> Skip <TSource> (deze IEnumerable <TSource> bron, Int32-telling)
  • public static IEnumerable <TSource> SkipWhile <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Boolean> predicaat)
  • public static IEnumerable <TSource> SkipWhile <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Int32, Boolean> predicaat)
  • openbare statische decimale som (deze IEnumerable <Decimal> -bron)
  • openbare statische Double Sum (deze IEnumerable <Double> -bron)
  • public static Int32 Sum (deze IEnumerable <Int32> bron)
  • public static Int64 Sum (deze IEnumerable <Int64> bron)
  • public static Nullable <Decimal> Sum (deze IEnumerable <Nullable <Decimal>> bron)
  • public static Nullable <Double> Sum (deze IEnumerable <Nullable <Double>> bron)
  • public static Nullable <Int32> Som (deze IEnumerable <Nullable <Int32>> bron)
  • public static Nullable <Int64> Som (deze IEnumerable <Nullable <Int64>> bron)
  • public static Nullable <Single> Sum (deze IEnumerable <Nullable <Single>> bron)
  • public static Single Sum (deze IEnumerable <Single> bron)
  • public static Decimal Sum <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Decimal> selector)
  • public static Double Sum <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Double> selector)
  • public static Int32 Sum <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Int32> selector)
  • public static Int64 Sum <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Int64> selector)
  • public static Nullable <Decimal> Sum <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Nullable <Decimal>> selector)
  • public static Nullable <Double> Sum <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Nullable <Double>> selector)
  • public static Nullable <Int32> Sum <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Nullable <Int32>> selector)
  • public static Nullable <Int64> Sum <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Nullable <Int64>> selector)
  • public static Nullable <Single> Sum <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Nullable <Single>> selector)
  • public static Single Sum <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Single> selector)
  • public static IEnumerable <TSource> Neem <TSource> (deze IEnumerable <TSource> bron, Int32-telling)
  • public static IEnumerable <TSource> TakeWhile <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Boolean> predicaat)
  • public static IEnumerable <TSource> TakeWhile <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Int32, Boolean> predicaat)
  • public static IOrderedEnumerable <TSource> ThenBy <TSource, TKey> (deze IOrderedEnumerable <TSource> bron, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> ThenBy <TSource, TKey> (deze IOrderedEnumerable <TSource> bron, Func <TSource, TKey> keySelector, IComparer <TKey> comparer)
  • public static IOrderedEnumerable <TSource> ThenByDescending <TSource, TKey> (deze IOrderedEnumerable <TSource> bron, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> ThenByDescending <TSource, TKey> (deze IOrderedEnumerable <TSource> bron, Func <TSource, TKey> keySelector, IComparer <TKey> comparer)
  • openbare statische TSource [] ToArray <TSource> (deze IEnumerable <TSource> bron)
  • public static Dictionary <TKey, TSource> ToDictionary <TSource, TKey> (deze IEnumerable <TSource> -bron, Func <TSource, TKey> keySelector)
  • public static Dictionary <TKey, TSource> ToDictionary <TSource, TKey> (deze IEnumerable <TSource> -bron, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> -vergelijker)
  • public static Dictionary <TKey, TElement> ToDictionary <TSource, TKey, TElement> (deze IEnumerable <TSource> bron, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • public static Dictionary <TKey, TElement> ToDictionary <TSource, TKey, TElement> (deze IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> comparer)
  • public static List <TSource> ToList <TSource> (deze IEnumerable <TSource> bron)
  • public static ILookup <TKey, TSource> ToLookup <TSource, TKey> (deze IEnumerable <TSource> source, Func <TSource, TKey> keySelector)
  • public static ILookup <TKey, TSource> ToLookup <TSource, TKey> (deze IEnumerable <TSource> source, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> comparer)
  • public static ILookup <TKey, TElement> ToLookup <TSource, TKey, TElement> (deze IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • public static ILookup <TKey, TElement> ToLookup <TSource, TKey, TElement> (deze IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> comparer)
  • public static IEnumerable <TSource> Union <TSource> (deze IEnumerable <TSource> first, IEnumerable <TSource> second)
  • public static IEnumerable <TSource> Union <TSource> (deze IEnumerable <TSource> first, IEnumerable <TSource> second, IEqualityComparer <TSource> comparer)
  • public static IEnumerable <TSource> Where <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Boolean> predicaat)
  • public static IEnumerable <TSource> Where <TSource> (deze IEnumerable <TSource> bron, Func <TSource, Int32, Boolean> predicaat)
  • public static IEnumerable <TResult> Zip <TFirst, TSecond, TResult> (deze IEnumerable <TFirst> first, IEnumerable <TSecond> second, Func <TFirst, TSecond, TResult> resultSelector)

Opmerkingen

De ingebouwde LINQ-methoden zijn uitbreidingsmethoden voor de IEnumerable<T> -interface die in de klasse System.Linq.Enumerable in de System.Core assembly aanwezig zijn. Ze zijn beschikbaar in .NET Framework 3.5 en hoger.

LINQ maakt eenvoudige aanpassing, transformatie en combinatie van verschillende IEnumerable s mogelijk met behulp van een query-achtige of functionele syntaxis.

Hoewel de standaard LINQ-methoden kunnen werken op elke IEnumerable<T> , inclusief de eenvoudige arrays en List<T> s, kunnen ze ook worden gebruikt voor databaseobjecten, waar de set LINQ-expressies in veel gevallen kan worden omgezet naar SQL als de data-object ondersteunt het. Zie LINQ naar SQL .

Voor de methoden die objecten vergelijken (zoals Contains en Except ), wordt IEquatable<T>.Equals gebruikt als het type T van de verzameling die interface implementeert. Anders is de standaard Equals en GetHashCode van het type (eventueel overschreven van de standaard Object implementaties) worden gebruikt. Er zijn ook overbelastingen voor deze methoden waarmee u een aangepaste IEqualityComparer<T> kunt opgeven.

Voor de ...OrDefault methoden wordt default(T) gebruikt om standaardwaarden te genereren.

Officiële referentie: opsombare klasse

Luie evaluatie

Vrijwel elke query die een IEnumerable<T> retourneert, wordt niet onmiddellijk geëvalueerd; in plaats daarvan wordt de logica vertraagd totdat de query wordt herhaald. Een implicatie is dat elke keer dat iemand een IEnumerable<T> herhaalt die is gemaakt op basis van een van deze query's, bijvoorbeeld .Where() , de volledige .Where() wordt herhaald. Als het predicaat lang aanhoudt, kan dit een oorzaak zijn voor prestatieproblemen.

Een eenvoudige oplossing (als u de geschatte grootte van de resulterende reeks weet of kunt bepalen) is om de resultaten volledig te bufferen met .ToArray() of .ToList() . .ToDictionary() of .ToLookup() kunnen dezelfde rol vervullen. Je kunt natuurlijk ook de hele reeks herhalen en de elementen bufferen volgens andere aangepaste logica.

ToArray() of ToList() ?

Zowel .ToArray() als .ToList() doorlopen alle elementen van een IEnumerable<T> -reeks en slaan de resultaten op in een verzameling die in het geheugen is opgeslagen. Gebruik de volgende richtlijnen om te bepalen welke te kiezen:

  • Sommige API's vereisen mogelijk een T[] of een List<T> .
  • .ToList() doorgaans sneller uitgevoerd en genereert minder afval dan .ToArray() , omdat de laatste alle elementen een keer meer dan één keer naar de nieuwe verzameling met een vaste grootte moet kopiëren, in bijna alle gevallen.
  • Elementen kunnen worden toegevoegd aan of verwijderd uit de List<T> geretourneerd door .ToList() , terwijl de T[] geretourneerd door .ToArray() gedurende de hele levensduur een vaste grootte blijft. Met andere woorden, List<T> is veranderlijk en T[] is onveranderlijk.
  • De T[] geretourneerd door .ToArray() gebruikt minder geheugen dan de List<T> geretourneerd door .ToList() , dus als het resultaat voor langere tijd wordt opgeslagen, geeft u de voorkeur aan .ToArray() . List<T>.TrimExcess() zou het geheugenverschil strikt academisch maken, ten koste van het elimineren van het relatieve snelheidsvoordeel van .ToList() .

Selecteer (kaart)

var persons = new[] 
{
    new {Id = 1, Name = "Foo"},
    new {Id = 2, Name = "Bar"},
    new {Id = 3, Name = "Fizz"},
    new {Id = 4, Name = "Buzz"}
};

var names = persons.Select(p => p.Name);
Console.WriteLine(string.Join(",", names.ToArray()));

//Foo,Bar,Fizz,Buzz

Dit type functie wordt meestal map in functionele programmeertalen.

Waar (filter)

Deze methode retourneert een IEnumerable met alle elementen die voldoen aan de lambda-expressie

Voorbeeld 

var personNames = new[] 
{
    "Foo", "Bar", "Fizz", "Buzz"
};

var namesStartingWithF = personNames.Where(p => p.StartsWith("F"));
Console.WriteLine(string.Join(",", namesStartingWithF));

Output:

Foo, Fizz

Demo bekijken

OrderBy

var persons = new[] 
{
    new {Id = 1, Name = "Foo"},
    new {Id = 2, Name = "Bar"},
    new {Id = 3, Name = "Fizz"},
    new {Id = 4, Name = "Buzz"}
};

var personsSortedByName = persons.OrderBy(p => p.Name);

Console.WriteLine(string.Join(",", personsSortedByName.Select(p => p.Id).ToArray()));

//2,4,3,1

OrderByDescending

var persons = new[] 
{
    new {Id = 1, Name = "Foo"},
    new {Id = 2, Name = "Bar"},
    new {Id = 3, Name = "Fizz"},
    new {Id = 4, Name = "Buzz"}
};

var personsSortedByNameDescending = persons.OrderByDescending(p => p.Name);

Console.WriteLine(string.Join(",", personsSortedByNameDescending.Select(p => p.Id).ToArray()));

//1,3,4,2

bevat

var numbers = new[] {1,2,3,4,5};
Console.WriteLine(numbers.Contains(3)); //True
Console.WriteLine(numbers.Contains(34)); //False

Behalve

var numbers = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var evenNumbersBetweenSixAndFourteen = new[] { 6, 8, 10, 12 };

var result = numbers.Except(evenNumbersBetweenSixAndFourteen);

Console.WriteLine(string.Join(",", result));

//1, 2, 3, 4, 5, 7, 9

Snijden

var numbers1to10 = new[] {1,2,3,4,5,6,7,8,9,10};
var numbers5to15 = new[] {5,6,7,8,9,10,11,12,13,14,15};

var numbers5to10 = numbers1to10.Intersect(numbers5to15);

Console.WriteLine(string.Join(",", numbers5to10));

//5,6,7,8,9,10

concat

var numbers1to5 = new[] {1, 2, 3, 4, 5};
var numbers4to8 = new[] {4, 5, 6, 7, 8};

var numbers1to8 = numbers1to5.Concat(numbers4to8);

Console.WriteLine(string.Join(",", numbers1to8));

//1,2,3,4,5,4,5,6,7,8

Merk op dat duplicaten in het resultaat worden bewaard. Gebruik in plaats daarvan Union als dit ongewenst is.

Eerst (vinden)

var numbers = new[] {1,2,3,4,5};

var firstNumber = numbers.First();
Console.WriteLine(firstNumber); //1

var firstEvenNumber = numbers.First(n => (n & 1) == 0);
Console.WriteLine(firstEvenNumber); //2

De volgende worpen InvalidOperationException met bericht "Volgorde bevat geen overeenkomend element": 

var firstNegativeNumber = numbers.First(n => n < 0);

single

var oneNumber = new[] {5};
var theOnlyNumber = oneNumber.Single();
Console.WriteLine(theOnlyNumber);  //5

var numbers = new[] {1,2,3,4,5};

var theOnlyNumberSmallerThanTwo = numbers.Single(n => n < 2);
Console.WriteLine(theOnlyNumberSmallerThanTwo);  //1

Het volgende gooit InvalidOperationException omdat er meer dan één element in de reeks is: 

var theOnlyNumberInNumbers = numbers.Single();
var theOnlyNegativeNumber = numbers.Single(n => n < 0);

Laatste

var numbers = new[] {1,2,3,4,5};

var lastNumber = numbers.Last();
Console.WriteLine(lastNumber); //5

var lastEvenNumber = numbers.Last(n => (n & 1) == 0);
Console.WriteLine(lastEvenNumber); //4

De volgende gooit InvalidOperationException : 

var lastNegativeNumber = numbers.Last(n => n < 0);

LastOrDefault

var numbers = new[] {1,2,3,4,5};

var lastNumber = numbers.LastOrDefault();
Console.WriteLine(lastNumber); //5

var lastEvenNumber = numbers.LastOrDefault(n => (n & 1) == 0);
Console.WriteLine(lastEvenNumber); //4

var lastNegativeNumber = numbers.LastOrDefault(n => n < 0);
Console.WriteLine(lastNegativeNumber); //0

var words = new[] { "one", "two", "three", "four", "five" };

var lastWord = words.LastOrDefault();
Console.WriteLine(lastWord); // five

var lastLongWord = words.LastOrDefault(w => w.Length > 4);
Console.WriteLine(lastLongWord); // three

var lastMissingWord = words.LastOrDefault(w => w.Length > 5);
Console.WriteLine(lastMissingWord); // null

SingleOrDefault

var oneNumber = new[] {5};
var theOnlyNumber = oneNumber.SingleOrDefault();
Console.WriteLine(theOnlyNumber);  //5

var numbers = new[] {1,2,3,4,5};

var theOnlyNumberSmallerThanTwo = numbers.SingleOrDefault(n => n < 2);
Console.WriteLine(theOnlyNumberSmallerThanTwo);  //1

var theOnlyNegativeNumber = numbers.SingleOrDefault(n => n < 0);
Console.WriteLine(theOnlyNegativeNumber);  //0

De volgende gooit InvalidOperationException : 

var theOnlyNumberInNumbers = numbers.SingleOrDefault();

FirstOrDefault

var numbers = new[] {1,2,3,4,5};

var firstNumber = numbers.FirstOrDefault();
Console.WriteLine(firstNumber); //1

var firstEvenNumber = numbers.FirstOrDefault(n => (n & 1) == 0);
Console.WriteLine(firstEvenNumber); //2

var firstNegativeNumber = numbers.FirstOrDefault(n => n < 0);
Console.WriteLine(firstNegativeNumber); //0

var words = new[] { "one", "two", "three", "four", "five" };

var firstWord = words.FirstOrDefault();
Console.WriteLine(firstWord); // one

var firstLongWord = words.FirstOrDefault(w => w.Length > 3);
Console.WriteLine(firstLongWord); // three

var firstMissingWord = words.FirstOrDefault(w => w.Length > 5);
Console.WriteLine(firstMissingWord); // null

Ieder

Retourneert true als de verzameling elementen bevat die voldoen aan de voorwaarde in de lambda-expressie: 

var numbers = new[] {1,2,3,4,5};

var isNotEmpty = numbers.Any();
Console.WriteLine(isNotEmpty); //True

var anyNumberIsOne = numbers.Any(n => n == 1);
Console.WriteLine(anyNumberIsOne); //True

var anyNumberIsSix = numbers.Any(n => n == 6);
Console.WriteLine(anyNumberIsSix); //False    

var anyNumberIsOdd = numbers.Any(n => (n & 1) == 1);
Console.WriteLine(anyNumberIsOdd); //True

var anyNumberIsNegative = numbers.Any(n => n < 0);
Console.WriteLine(anyNumberIsNegative); //False

Allemaal

var numbers = new[] {1,2,3,4,5};

var allNumbersAreOdd = numbers.All(n => (n & 1) == 1);
Console.WriteLine(allNumbersAreOdd); //False

var allNumbersArePositive = numbers.All(n => n > 0);
Console.WriteLine(allNumbersArePositive); //True

Merk op dat de methode All werkt door te controleren of het eerste element volgens het predicaat als false geëvalueerd. Daarom retourneert de methode true voor elk predicaat in het geval dat de set leeg is: 

var numbers = new int[0];
var allNumbersArePositive = numbers.All(n => n > 0);
Console.WriteLine(allNumbersArePositive); //True

SelectMany (vlakke kaart)

Enumerable.Select retourneert een uitvoerelement voor elk Enumerable.Select . Terwijl Enumerable.SelectMany produceert een variabel aantal uitvoerelementen voor elk Enumerable.SelectMany . Dit betekent dat de uitvoerreeks meer of minder elementen kan bevatten dan in de invoerreeks.

Lambda expressions doorgegeven aan Enumerable.Select moeten één item retourneren. Lambda-expressies die zijn doorgegeven aan Enumerable.SelectMany moeten een onderliggende reeks produceren. Deze onderliggende reeks kan een variërend aantal elementen bevatten voor elk element in de invoersequentie.

Voorbeeld 

class Invoice
{
    public int Id { get; set; }
}

class Customer
{
    public Invoice[] Invoices {get;set;}
}

var customers = new[] {
    new Customer {
        Invoices = new[] {
            new Invoice {Id=1},
            new Invoice {Id=2},
        }
    },
    new Customer {
        Invoices = new[] {
            new Invoice {Id=3},
            new Invoice {Id=4},
        }
    },
    new Customer {
        Invoices = new[] {
            new Invoice {Id=5},
            new Invoice {Id=6},
        }
    }
};

var allInvoicesFromAllCustomers = customers.SelectMany(c => c.Invoices);

Console.WriteLine(
    string.Join(",", allInvoicesFromAllCustomers.Select(i => i.Id).ToArray()));

Output:

1,2,3,4,5,6

Demo bekijken

Enumerable.SelectMany kan ook worden bereikt met een syntax-gebaseerde query met twee opeenvolgende from clausules: 

var allInvoicesFromAllCustomers
    = from customer in customers
      from invoice in customer.Invoices
      select invoice;

Som

var numbers = new[] {1,2,3,4};

var sumOfAllNumbers = numbers.Sum();
Console.WriteLine(sumOfAllNumbers); //10

var cities = new[] {
    new {Population = 1000},
    new {Population = 2500},
    new {Population = 4000}
};

var totalPopulation = cities.Sum(c => c.Population);
Console.WriteLine(totalPopulation); //7500

Overspringen

Overslaan somt de eerste N items op zonder ze te retourneren. Zodra itemnummer N + 1 is bereikt, begint Skip met het retourneren van elk opgesomd item: 

var numbers = new[] {1,2,3,4,5};

var allNumbersExceptFirstTwo = numbers.Skip(2);
Console.WriteLine(string.Join(",", allNumbersExceptFirstTwo.ToArray()));

//3,4,5

Nemen

Deze methode neemt de eerste n elementen uit een opsomming. 

var numbers = new[] {1,2,3,4,5};

var threeFirstNumbers = numbers.Take(3);
Console.WriteLine(string.Join(",", threeFirstNumbers.ToArray()));

//1,2,3

SequenceEqual

var numbers = new[] {1,2,3,4,5};
var sameNumbers = new[] {1,2,3,4,5};
var sameNumbersInDifferentOrder = new[] {5,1,4,2,3};

var equalIfSameOrder = numbers.SequenceEqual(sameNumbers);
Console.WriteLine(equalIfSameOrder); //True

var equalIfDifferentOrder = numbers.SequenceEqual(sameNumbersInDifferentOrder);
Console.WriteLine(equalIfDifferentOrder); //False

Omgekeerde

var numbers = new[] {1,2,3,4,5};
var reversed = numbers.Reverse();

Console.WriteLine(string.Join(",", reversed.ToArray()));

//5,4,3,2,1

OfType

var mixed = new object[] {1,"Foo",2,"Bar",3,"Fizz",4,"Buzz"};
var numbers = mixed.OfType<int>();

Console.WriteLine(string.Join(",", numbers.ToArray()));

//1,2,3,4

Max

var numbers = new[] {1,2,3,4};

var maxNumber = numbers.Max();
Console.WriteLine(maxNumber); //4

var cities = new[] {
    new {Population = 1000},
    new {Population = 2500},
    new {Population = 4000}
};

var maxPopulation = cities.Max(c => c.Population);
Console.WriteLine(maxPopulation); //4000

min

var numbers = new[] {1,2,3,4};

var minNumber = numbers.Min();
Console.WriteLine(minNumber); //1

var cities = new[] {
    new {Population = 1000},
    new {Population = 2500},
    new {Population = 4000}
};

var minPopulation = cities.Min(c => c.Population);
Console.WriteLine(minPopulation); //1000

Gemiddelde

var numbers = new[] {1,2,3,4};

var averageNumber = numbers.Average();
Console.WriteLine(averageNumber); 
// 2,5

Deze methode berekent het gemiddelde van de telling van getallen. 

var cities = new[] {
    new {Population = 1000},
    new {Population = 2000},
    new {Population = 4000}
};

var averagePopulation = cities.Average(c => c.Population);
Console.WriteLine(averagePopulation);
// 2333,33

Deze methode berekent het gemiddelde van de telling met behulp van de gedelegeerde functie.

ritssluiting

.NET 4.0 
var tens = new[] {10,20,30,40,50};
var units = new[] {1,2,3,4,5};

var sums = tens.Zip(units, (first, second) => first + second);

Console.WriteLine(string.Join(",", sums));

//11,22,33,44,55

onderscheiden

var numbers = new[] {1, 1, 2, 2, 3, 3, 4, 4, 5, 5};
var distinctNumbers = numbers.Distinct();

Console.WriteLine(string.Join(",", distinctNumbers));

//1,2,3,4,5

GroupBy

var persons = new[] {
    new { Name="Fizz", Job="Developer"},
    new { Name="Buzz", Job="Developer"},
    new { Name="Foo", Job="Astronaut"},
    new { Name="Bar", Job="Astronaut"},
};

var groupedByJob = persons.GroupBy(p => p.Job);

foreach(var theGroup in groupedByJob)
{
    Console.WriteLine(
        "{0} are {1}s", 
        string.Join(",", theGroup.Select(g => g.Name).ToArray()),
        theGroup.Key);
}

//Fizz,Buzz are Developers
//Foo,Bar are Astronauts

Groepsfacturen per land, genereert een nieuw object met het aantal records, totaal betaald en gemiddeld betaald 

var a = db.Invoices.GroupBy(i => i.Country)
          .Select(g => new { Country = g.Key,
                             Count = g.Count(),
                             Total = g.Sum(i => i.Paid),
                             Average = g.Average(i => i.Paid) });

Als we alleen de totalen willen, geen groep 

var a = db.Invoices.GroupBy(i => 1)
          .Select(g => new { Count = g.Count(),
                             Total = g.Sum(i => i.Paid),
                             Average = g.Average(i => i.Paid) });

Als we meerdere tellingen nodig hebben 

var a = db.Invoices.GroupBy(g => 1)
          .Select(g => new { High = g.Count(i => i.Paid >= 1000),
                             Low = g.Count(i => i.Paid < 1000),
                             Sum = g.Sum(i => i.Paid) });

ToDictionary

Retourneert een nieuw woordenboek van de bron IEnumerable met behulp van de meegeleverde keySelector-functie om sleutels te bepalen. Zal een ArgumentException genereren als keySelector niet injectief is (retourneert een unieke waarde voor elk lid van de broncollectie.) Er zijn overbelastingen die het mogelijk maken om zowel de te bewaren waarde als de sleutel op te geven. 

var persons = new[] {
    new { Name="Fizz", Id=1},
    new { Name="Buzz", Id=2},
    new { Name="Foo", Id=3},
    new { Name="Bar", Id=4},
};

Als u alleen een sleutelkiezerfunctie Dictionary<TKey,TVal> wordt een Dictionary<TKey,TVal> met TKey het TKey van de sleutelkiezer, TVal het oorspronkelijke objecttype en het oorspronkelijke object als de opgeslagen waarde. 

var personsById = persons.ToDictionary(p => p.Id);
// personsById is a Dictionary<int,object>

Console.WriteLine(personsById[1].Name); //Fizz
Console.WriteLine(personsById[2].Name); //Buzz

Als u ook een Dictionary<TKey,TVal> wordt een Dictionary<TKey,TVal> met TKey nog steeds het TKey van de sleutelkiezer, maar TVal nu het TVal de TVal en de geretourneerde waarde als de opgeslagen waarde. 

var namesById = persons.ToDictionary(p => p.Id, p => p.Name);
//namesById is a Dictionary<int,string>

Console.WriteLine(namesById[3]); //Foo
Console.WriteLine(namesById[4]); //Bar

Zoals hierboven vermeld, moeten de sleutels die door de sleutelkiezer worden geretourneerd uniek zijn. Het volgende zal een uitzondering veroorzaken. 

var persons = new[] {
    new { Name="Fizz", Id=1},
    new { Name="Buzz", Id=2},
    new { Name="Foo", Id=3},
    new { Name="Bar", Id=4},
    new { Name="Oops", Id=4}
};

var willThrowException = persons.ToDictionary(p => p.Id)

Als u geen unieke sleutel kunt opgeven voor de bronverzameling, kunt u overwegen om ToLookup te gebruiken. Aan de oppervlakte gedraagt ToLookup zich op dezelfde manier als ToDictionary, maar in de resulterende Lookup wordt elke sleutel gekoppeld aan een verzameling waarden met overeenkomende sleutels.

Unie

var numbers1to5 = new[] {1,2,3,4,5};
var numbers4to8 = new[] {4,5,6,7,8};

var numbers1to8 = numbers1to5.Union(numbers4to8);

Console.WriteLine(string.Join(",", numbers1to8));

//1,2,3,4,5,6,7,8

Merk op dat duplicaten uit het resultaat worden verwijderd. Gebruik Concat als dit ongewenst is.

ToArray

var numbers = new[] {1,2,3,4,5,6,7,8,9,10};
var someNumbers = numbers.Where(n => n < 6);

Console.WriteLine(someNumbers.GetType().Name);
//WhereArrayIterator`1

var someNumbersArray = someNumbers.ToArray();

Console.WriteLine(someNumbersArray.GetType().Name);
//Int32[]

ToList

var numbers = new[] {1,2,3,4,5,6,7,8,9,10};
var someNumbers = numbers.Where(n => n < 6);

Console.WriteLine(someNumbers.GetType().Name);
//WhereArrayIterator`1

var someNumbersList = someNumbers.ToList();

Console.WriteLine(
    someNumbersList.GetType().Name + " - " +
    someNumbersList.GetType().GetGenericArguments()[0].Name);
//List`1 - Int32

tellen

IEnumerable<int> numbers = new[] {1,2,3,4,5,6,7,8,9,10};

var numbersCount = numbers.Count();
Console.WriteLine(numbersCount); //10

var evenNumbersCount = numbers.Count(n => (n & 1) == 0);
Console.WriteLine(evenNumbersCount); //5

ElementAt

var names = new[] {"Foo","Bar","Fizz","Buzz"};

var thirdName = names.ElementAt(2);
Console.WriteLine(thirdName); //Fizz

//The following throws ArgumentOutOfRangeException

var minusOnethName = names.ElementAt(-1);
var fifthName = names.ElementAt(4);

ElementAtOrDefault

var names = new[] {"Foo","Bar","Fizz","Buzz"};

var thirdName = names.ElementAtOrDefault(2);
Console.WriteLine(thirdName); //Fizz

var minusOnethName = names.ElementAtOrDefault(-1);
Console.WriteLine(minusOnethName); //null

var fifthName = names.ElementAtOrDefault(4);
Console.WriteLine(fifthName); //null

SkipWhile

var numbers = new[] {2,4,6,8,1,3,5,7};

var oddNumbers = numbers.SkipWhile(n => (n & 1) == 0);

Console.WriteLine(string.Join(",", oddNumbers.ToArray()));

//1,3,5,7

takeWhile

var numbers = new[] {2,4,6,1,3,5,7,8};

var evenNumbers = numbers.TakeWhile(n => (n & 1) == 0);

Console.WriteLine(string.Join(",", evenNumbers.ToArray()));

//2,4,6

DefaultIfEmpty

var numbers = new[] {2,4,6,8,1,3,5,7};

var numbersOrDefault = numbers.DefaultIfEmpty();
Console.WriteLine(numbers.SequenceEqual(numbersOrDefault)); //True

var noNumbers = new int[0];

var noNumbersOrDefault = noNumbers.DefaultIfEmpty();
Console.WriteLine(noNumbersOrDefault.Count()); //1
Console.WriteLine(noNumbersOrDefault.Single()); //0

var noNumbersOrExplicitDefault = noNumbers.DefaultIfEmpty(34);
Console.WriteLine(noNumbersOrExplicitDefault.Count()); //1
Console.WriteLine(noNumbersOrExplicitDefault.Single()); //34

Aggregeren (vouwen)

Bij elke stap een nieuw object genereren: 

var elements = new[] {1,2,3,4,5};

var commaSeparatedElements = elements.Aggregate(
    seed: "",
    func: (aggregate, element) => $"{aggregate}{element},");
    
Console.WriteLine(commaSeparatedElements);  //1,2,3,4,5,

In alle stappen hetzelfde object gebruiken: 

var commaSeparatedElements2 = elements.Aggregate(
    seed: new StringBuilder(),
    func: (seed, element) => seed.Append($"{element},"));
    
Console.WriteLine(commaSeparatedElements2.ToString());  //1,2,3,4,5,

Met behulp van een resultaatkiezer: 

var commaSeparatedElements3 = elements.Aggregate(
    seed: new StringBuilder(),
    func: (seed, element) => seed.Append($"{element},"),
    resultSelector: (seed) => seed.ToString());
Console.WriteLine(commaSeparatedElements3);  //1,2,3,4,5,

Als een zaad wordt weggelaten, wordt het eerste element het zaad: 

var seedAndElements = elements.Select(n=>n.ToString());
var commaSeparatedElements4 = seedAndElements.Aggregate(
    func: (aggregate, element) => $"{aggregate}{element},");

Console.WriteLine(commaSeparatedElements4);  //12,3,4,5,

Opkijken

var persons = new[] {
    new { Name="Fizz", Job="Developer"},
    new { Name="Buzz", Job="Developer"},
    new { Name="Foo", Job="Astronaut"},
    new { Name="Bar", Job="Astronaut"},
};

var groupedByJob = persons.ToLookup(p => p.Job);

foreach(var theGroup in groupedByJob)
{
    Console.WriteLine(
        "{0} are {1}s", 
        string.Join(",", theGroup.Select(g => g.Name).ToArray()),
        theGroup.Key);
}

//Fizz,Buzz are Developers
//Foo,Bar are Astronauts

toetreden

class Developer
{
    public int Id { get; set; }
    public string Name { get; set; }
}

class Project
{
    public int DeveloperId { get; set; }
    public string Name { get; set; }
}

var developers = new[] {
    new Developer {
        Id = 1,
        Name = "Foobuzz"
    },
    new Developer {
        Id = 2,
        Name = "Barfizz"
    }
};

var projects = new[] {
    new Project {
        DeveloperId = 1,
        Name = "Hello World 3D"
    },
    new Project {
        DeveloperId = 1,
        Name = "Super Fizzbuzz Maker"
    },
    new Project {
        DeveloperId = 2,
        Name = "Citizen Kane - The action game"
    },
    new Project {
        DeveloperId = 2,
        Name = "Pro Pong 2016"
    }
};

var denormalized = developers.Join(
    inner: projects,
    outerKeySelector: dev => dev.Id,
    innerKeySelector: proj => proj.DeveloperId,
    resultSelector: 
        (dev, proj) => new {
            ProjectName = proj.Name,
            DeveloperName = dev.Name});
    
foreach(var item in denormalized)
{
    Console.WriteLine("{0} by {1}", item.ProjectName, item.DeveloperName);
}

//Hello World 3D by Foobuzz
//Super Fizzbuzz Maker by Foobuzz
//Citizen Kane - The action game by Barfizz
//Pro Pong 2016 by Barfizz

GroupJoin

class Developer
{
    public int Id { get; set; }
    public string Name { get; set; }
}

class Project
{
    public int DeveloperId { get; set; }
    public string Name { get; set; }
}

var developers = new[] {
    new Developer {
        Id = 1,
        Name = "Foobuzz"
    },
    new Developer {
        Id = 2,
        Name = "Barfizz"
    }
};

var projects = new[] {
    new Project {
        DeveloperId = 1,
        Name = "Hello World 3D"
    },
    new Project {
        DeveloperId = 1,
        Name = "Super Fizzbuzz Maker"
    },
    new Project {
        DeveloperId = 2,
        Name = "Citizen Kane - The action game"
    },
    new Project {
        DeveloperId = 2,
        Name = "Pro Pong 2016"
    }
};

var grouped = developers.GroupJoin(
    inner: projects,
    outerKeySelector: dev => dev.Id,
    innerKeySelector: proj => proj.DeveloperId,
    resultSelector: 
        (dev, projs) => new {
            DeveloperName = dev.Name, 
            ProjectNames = projs.Select(p => p.Name).ToArray()});
    
foreach(var item in grouped)
{
    Console.WriteLine(
        "{0}'s projects: {1}", 
        item.DeveloperName,
        string.Join(", ", item.ProjectNames));
}

//Foobuzz's projects: Hello World 3D, Super Fizzbuzz Maker
//Barfizz's projects: Citizen Kane - The action game, Pro Pong 2016

Gips

Cast verschilt van de andere methoden van Enumerable omdat het een uitbreidingsmethode is voor IEnumerable , niet voor IEnumerable<T> . Het kan dus worden gebruikt om instanties van de eerste om te zetten in instanties van de latere.

Dit compileert niet omdat ArrayList geen IEnumerable<T> implementeert: 

var numbers = new ArrayList() {1,2,3,4,5};
Console.WriteLine(numbers.First());

Dit werkt zoals verwacht: 

var numbers = new ArrayList() {1,2,3,4,5};
Console.WriteLine(numbers.Cast<int>().First()); //1

Cast voert geen conversiecasts uit. Het volgende compileert maar gooit InvalidCastException tijdens runtime: 

var numbers = new int[] {1,2,3,4,5};
decimal[] numbersAsDecimal = numbers.Cast<decimal>().ToArray();

De juiste manier om een conversie cast naar een verzameling uit te voeren is als volgt: 

var numbers= new int[] {1,2,3,4,5};
decimal[] numbersAsDecimal = numbers.Select(n => (decimal)n).ToArray();

Leeg

Om een lege IEnumerable van int te maken: 

IEnumerable<int> emptyList = Enumerable.Empty<int>();

Deze lege IEnumerable wordt in de cache opgeslagen voor elke Type T, zodat: 

Enumerable.Empty<decimal>() == Enumerable.Empty<decimal>(); // This is True
Enumerable.Empty<int>() == Enumerable.Empty<decimal>();     // This is False

ThenBy

ThenBy kan alleen worden gebruikt na een OrderBy clausule die het mogelijk maakt om met meerdere criteria te bestellen 

var persons = new[] 
{
    new {Id = 1, Name = "Foo", Order = 1},
    new {Id = 1, Name = "FooTwo", Order = 2},
    new {Id = 2, Name = "Bar", Order = 2},
    new {Id = 2, Name = "BarTwo", Order = 1},
    new {Id = 3, Name = "Fizz", Order = 2},
    new {Id = 3, Name = "FizzTwo", Order = 1},  
};

var personsSortedByName = persons.OrderBy(p => p.Id).ThenBy(p => p.Order);

Console.WriteLine(string.Join(",", personsSortedByName.Select(p => p.Name)));
//This will display : 
//Foo,FooTwo,BarTwo,Bar,FizzTwo,Fizz

reeks

De twee parameters voor Range zijn het eerste getal en het aantal te produceren elementen (niet het laatste getal). 

// prints 1,2,3,4,5,6,7,8,9,10
Console.WriteLine(string.Join(",", Enumerable.Range(1, 10)));

// prints 10,11,12,13,14
Console.WriteLine(string.Join(",", Enumerable.Range(10, 5)));

Linker buitenaansluiting

class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

class Pet
{
    public string Name { get; set; }
    public Person Owner { get; set; }
}

public static void Main(string[] args)
{
    var magnus = new Person { FirstName = "Magnus", LastName = "Hedlund" };
    var terry = new Person { FirstName = "Terry", LastName = "Adams" };

    var barley = new Pet { Name = "Barley", Owner = terry };

    var people = new[] { magnus, terry };
    var pets = new[] { barley };

    var query =
        from person in people
        join pet in pets on person equals pet.Owner into gj
        from subpet in gj.DefaultIfEmpty()
        select new
        {
            person.FirstName,
            PetName = subpet?.Name ?? "-" // Use - if he has no pet
        };

    foreach (var p in query)
        Console.WriteLine($"{p.FirstName}: {p.PetName}");
}

Herhaling

Enumerable.Repeat genereert een reeks van een herhaalde waarde. In dit voorbeeld genereert het 4 keer "Hallo". 

var repeats = Enumerable.Repeat("Hello", 4);
   
foreach (var item in repeats)
{
    Console.WriteLine(item);
}

/* output:
    Hello
    Hello
    Hello
    Hello
*/


Modified text is an extract of the original Stack Overflow Documentation
Licentie onder CC BY-SA 3.0
Niet aangesloten bij Stack Overflow