.NET Framework
LINQ

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


Introduktion

LINQ (Language Integrated Query) är ett uttryck som hämtar data från en datakälla. LINQ förenklar denna situation genom att erbjuda en konsekvent modell för att arbeta med data över olika typer av datakällor och format. I en LINQ-fråga arbetar du alltid med objekt. Du använder samma grundläggande kodningsmönster för att fråga och transformera data i XML-dokument, SQL-databaser, ADO.NET-databas, .NET-samlingar och alla andra format som en leverantör är tillgänglig för. LINQ kan användas i C # och VB.

Syntax

  • public static TSource Aggregate <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, TSource, TSource> func)
  • public static TAccumulate Aggregate <TSource, TAccumulate> (denna IEnumerable <TSource> -källa, TAccumulate seed, Func <TAccumulate, TSource, TAccumulate> func)
  • public static TResult Aggregate <TSource, TAccumulate, TResult> (denna IEnumerable <TSource> -källa, TAccumulate seed, Func <TAccumulate, TSource, TAccumulate> func, Func <TAccumulate, TResult> resultSelector)
  • public static Boolean All <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Boolean> predikat)
  • public static Boolean Any <TSource> (denna IEnumerable <TSource> -källa)
  • public static Boolean Any <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Boolean> predikat)
  • public static IEnumerable <TSource> AsEnumerable <TSource> (denna IEnumerable <TSource> -källa)
  • offentligt statiskt decimalt medelvärde (denna IEnumerable <Decimal> källa)
  • offentligt statiskt dubbel genomsnitt (denna IEnumerable <Double> -källa)
  • offentligt statiskt dubbel genomsnitt (denna IEnumerable <Int32> källa)
  • offentligt statiskt dubbel genomsnitt (denna IEnumerable <Int64> källa)
  • public static Nullable <Decimal> Average (denna IEnumerable <Nullable <Decimal>> källa)
  • public static Nullable <Double> Average (denna IEnumerable <Nullable <Double>> källa)
  • public static Nullable <Double> Average (denna IEnumerable <Nullable <Int32>> källa)
  • public static Nullable <Double> Average (denna IEnumerable <Nullable <Int64>> källa)
  • public static Nullable <Single> Average (denna IEnumerable <Nullable <Single>> källa)
  • offentligt statiskt enda genomsnitt (denna IEnumerable <Single> -källa)
  • public static Decimal Average <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Decimal> selector)
  • offentlig statisk dubbel genomsnitt <Källa> (denna IEnumerable <Källa> källa, Func <TSource, Double> selector)
  • offentlig statisk dubbel genomsnitt <Källa> (denna IEnumerable <Källa> källa, Func <TSource, Int32> selector)
  • offentlig statisk dubbel genomsnitt <Källa> (denna IEnumerable <Källa> källa, Func <TSource, Int64> selector)
  • public static Nullable <Decimal> Average <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Nullable <Decimal>> selector)
  • public static Nullable <Double> Average <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Nullable <Double>> -väljare)
  • public static Nullable <Double> Average <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Nullable <Int32>> selector)
  • public static Nullable <Double> Average <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Nullable <Int64>> selector)
  • public static Nullable <Single> Average <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Nullable <Single>> selector)
  • public static Enkel genomsnitt <Källa> (denna IUtalbara <Källa> källa, Func <TSource, Singel> selector)
  • public static IEnumerable <TResult> Cast <TResult> (denna IEnumerable källa)
  • public static IEnumerable <TSource> Concat <TSource> (denna IEnumerable <TSource> först, IEnumerable <TSource> second)
  • public static Boolean Innehåller <TSource> (denna IEnumerable <TSource> -källa, TSource-värde)
  • public static Boolean Innehåller <Source> (denna IEnumerable <TSource> -källa, TSource-värde, IEqualityComparer <Source> jämförare)
  • public static Int32 Count <TSource> (denna IEnumerable <TSource> -källa)
  • public static Int32 Count <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Boolean> predikat)
  • public static IEnumerable <TSource> StandardIfEmpty <TSource> (denna IEnumerable <TSource> -källa)
  • public static IEnumerable <TSource> StandardIfEmpty <TSource> (denna IEnumerable <TSource> -källa, TSource defaultValue)
  • public static IEnumerable <TSource> Distinct <TSource> (denna IEnumerable <TSource> -källa)
  • public static IEnumerable <TSource> Distinct <TSource> (denna IEnumerable <TSource> -källa, IEqualityComparer <Source> jämförare)
  • public static TSource ElementAt <TSource> (denna IEnumerable <TSource> -källa, Int32-index)
  • public static TSource ElementAtOrDefault <TSource> (denna IEnumerable <TSource> -källa, Int32-index)
  • public static IEnumerable <TResult> Tom <TResult> ()
  • public static IEnumerable <TSource> Undantagen <TSource> (denna IEnumerable <TSource> först, IEnumerable <TSource> second)
  • public static IEnumerable <TSource> Undantagen <TSource> (denna IEnumerable <TSource> först, IEnumerable <TSource> second, IEqualityComparer <Source> jämförare)
  • public static TSource First <TSource> (denna IEnumerable <TSource> -källa)
  • public static TSource First <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Boolean> predikat)
  • public static TSource FirstOrDefault <TSource> (denna IEnumerable <TSource> -källa)
  • public static TSource FirstOrDefault <ource> (denna IEnumerable <TSource> -källa, Func <TSource, Boolean> predikat)
  • public static IEnumerable <IGrouping <TKey, TSource >> GroupBy <TSource, TKey> (denna IEnumerable <Source> -källa, Func <TSource, TKey> keySelector)
  • public static IEnumerable <IGrouping <TKey, TSource >> GroupBy <TSource, TKey> (denna IEnumerable <Source> källa, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> jämförare)
  • public static IEnumerable <IGrouping <TKey, TElement >> GroupBy <TSource, TKey, TElement> (denna IEnumerable <Source> -källa, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • public static IEnumerable <IGrouping <TKey, TElement >> GroupBy <TSource, TKey, TElement> (denna IEnumerable <Source> källa, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> jämförare)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TResult> (denna IEnumerable <Source> -källa, Func <TSource, TKey> keySelector, Func <TKey, IEnumerable <TSource>, TResult> resultSelector)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TResult> (denna IEnumerable <Source> -källa, Func <TSource, TKey> keySelector, Func <TKey, IEnumerable <TSource>, TResult> resultSelector, IEqualityComparer <TKey> jämförare)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TElement, TResult> (denna IEnumerable <Source> -källa, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <TKey, IEnumerable <TElement>, TResult > resultSelector)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TElement, TResult> (denna IEnumerable <Source> -källa, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <TKey, IEnumerable <TElement>, TResult > resultatVäljare, IEqualityComparer <TKey> jämförare)
  • public static IEnumerable <TResult> GroupJoin <TOuter, TInner, TKey, TResult> (denna IEnumerable <TOuter> ytre, IEnumerable <Tinner> inner, Func <TOuter, TKey> ytterKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, IEnumerable <Tinner>, TResult> resultSelector)
  • public static IEnumerable <TResult> GroupJoin <TOuter, TInner, TKey, TResult> (denna IEnumerable <TOuter> ytre, IEnumerable <Tinner> inner, Func <TOuter, TKey> ytterKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, IEnumerable <TInner>, TResult> resultSelector, IEqualityComparer <TKey> jämförare)
  • public static IEnumerable <TSource> Crossing <TSource> (denna IEnumerable <TSource> först, IEnumerable <TSource> second)
  • public static IEnumerable <TSource> Crossing <TSource> (denna IEnumerable <TSource> först, IEnumerable <Source> second, IEqualityComparer <Source> jämförare)
  • public static IEnumerable <TResult> Join <TOuter, TInner, TKey, TResult> (denna IEnumerable <TOuter> ytter, IEnumerable <Tinner> inner, Func <TOuter, TKey> ytterKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, TInner, TResult> resultSelector)
  • public static IEnumerable <TResult> Join <TOuter, TInner, TKey, TResult> (denna IEnumerable <TOuter> ytter, IEnumerable <Tinner> inner, Func <TOuter, TKey> ytterKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, TInner, TResult> resultSelector, IEqualityComparer <TKey> jämförare)
  • public static TSource Last <TSource> (denna IEnumerable <TSource> -källa)
  • public static TSource Last <TSource> (denna IEnumerable <ource> -källa, Func <TSource, Boolean> predikat)
  • offentlig statisk TSource LastOrDefault <Källa> (denna IEnumerable <Källa> källa)
  • offentlig statisk TSource LastOrDefault <Källa> (denna IEnumerable <Källa> källa, Func <TSource, Boolean> predikat)
  • public static Int64 LongCount <TSource> (denna IEnumerable <TSource> -källa)
  • public static Int64 LongCount <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Boolean> predikat)
  • public static Decimal Max (denna IEnumerable <Decimal> källa)
  • public static Double Max (denna IEnumerable <Double> -källa)
  • public static Int32 Max (denna IEnumerable <Int32> källa)
  • public static Int64 Max (denna IEnumerable <Int64> källa)
  • public static Nullable <Decimal> Max (denna IEnumerable <Nullable <Decimal>> källa)
  • public static Nullable <Double> Max (denna IEnumerable <Nullable <Double>> källa)
  • public static Nullable <Int32> Max (denna IEnumerable <Nullable <Int32>> källa)
  • public static Nullable <Int64> Max (denna IEnumerable <Nullable <Int64>> källa)
  • public static Nullable <Single> Max (denna IEnumerable <Nullable <Single>> källa)
  • public static Single Max (denna IEnumerable <Single> -källa)
  • public static TSource Max <TSource> (denna IEnumerable <ource> -källa)
  • public static Decimal Max <TSource> (denna IEnumerable <TSource> källa, Func <TSource, Decimal> selector)
  • public static Double Max <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Double> -väljare)
  • public static Int32 Max <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Int32> -väljare)
  • public static Int64 Max <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Int64> -väljare)
  • public static Nullable <Decimal> Max <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Nullable <Decimal>> selector)
  • public static Nullable <Double> Max <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Nullable <Double>> -väljare)
  • public static Nullable <Int32> Max <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Nullable <Int32>> selector)
  • public static Nullable <Int64> Max <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Nullable <Int64>> selector)
  • public static Nullable <Single> Max <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Nullable <Single>> -väljare)
  • public static Single Max <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Single> -väljare)
  • public static TResult Max <TSource, TResult> (denna IEnumerable <TSource> källa, Func <TSource, TResult> selector)
  • public static Decimal Min (denna IEnumerable <Decimal> källa)
  • public static Double Min (denna IEnumerable <Double> -källa)
  • public static Int32 Min (denna IEnumerable <Int32> källa)
  • public static Int64 Min (denna IEnumerable <Int64> källa)
  • public static Nullable <Decimal> Min (denna IEnumerable <Nullable <Decimal>> källa)
  • public static Nullable <Double> Min (denna IEnumerable <Nullable <Double>> källa)
  • public static Nullable <Int32> Min (denna IEnumerable <Nullable <Int32>> källa)
  • public static Nullable <Int64> Min (denna IEnumerable <Nullable <Int64>> källa)
  • public static Nullable <Single> Min (denna IEnumerable <Nullable <Single>> källa)
  • public static Single Min (denna IEnumerable <Single> -källa)
  • public static TSource Min <TSource> (denna IEnumerable <TSource> -källa)
  • public static Decimal Min <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Decimal> selector)
  • public static Double Min <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Double> -väljare)
  • public static Int32 Min <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Int32> -väljare)
  • public static Int64 Min <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Int64> -väljare)
  • public static Nullable <Decimal> Min <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Nullable <Decimal>> selector)
  • public static Nullable <Double> Min <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Nullable <Double>> -väljare)
  • public static Nullable <Int32> Min <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Nullable <Int32>> selector)
  • public static Nullable <Int64> Min <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Nullable <Int64>> selector)
  • public static Nullable <Single> Min <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Nullable <Single>> selector)
  • public static Single Min <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Single> -väljare)
  • public static TResult Min <TSource, TResult> (denna IEnumerable <TSource> källa, Func <TSource, TResult> selector)
  • public static IEnumerable <TResult> OfType <TResult> (denna IEnumerable källa)
  • public static IOrderedEnumerable <TSource> OrderBy <TSource, TKey> (denna IEnumerable <TSource> -källa, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> OrderBy <TSource, TKey> (denna IEnumerable <TSource> -källa, Func <TSource, TKey> keySelector, IComparer <TKey> jämförare)
  • public static IOrderedEnumerable <Source> OrderByDescending <TSource, TKey> (denna IEnumerable <TSource> -källa, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> OrderByDescending <TSource, TKey> (denna IEnumerable <Source> källa, Func <TSource, TKey> keySelector, IComparer <TKey> jämförare)
  • 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> (denna IEnumerable <TSource> -källa)
  • public static IEnumerable <TResult> Välj <TSource, TResult> (denna IEnumerable <TSource> -källa, Func <TSource, TResult> selector)
  • public static IEnumerable <TResult> Välj <TSource, TResult> (denna IEnumerable <TSource> -källa, Func <TSource, Int32, TResult> selector)
  • public static IEnumerable <TResult> SelectMany <TSource, TResult> (denna IEnumerable <TSource> -källa, Func <TSource, IEnumerable <TResult>> selector)
  • public static IEnumerable <TResult> SelectMany <TSource, TResult> (denna IEnumerable <TSource> -källa, Func <TSource, Int32, IEnumerable <TResult>> selector)
  • public static IEnumerable <TResult> SelectMany <TSource, TCollection, TResult> (denna IEnumerable <Source> -källa, Func <TSource, IEnumerable <TCollection>> collectionSelector, Func <TSource, TCollection, TResult> resultSelector)
  • public static IEnumerable <TResult> SelectMany <TSource, TCollection, TResult> (denna IEnumerable <Source> källa, Func <TSource, Int32, IEnumerable <TCollection>> collectionSelector, Func <TSource, TCollection, TResult> resultSelector)
  • public static Boolean SequenceEqual <Source> (denna IEnumerable <TSource> först, IEnumerable <TSource> second)
  • public static Boolean SequenceEqual <Source> (denna IEnumerable <Source> först, IEnumerable <TSource> second, IEqualityComparer <Source> jämförare)
  • public static TSource Single <TSource> (denna IEnumerable <TSource> -källa)
  • public static TSource Single <TSource> (denna IEnumerable <ource> -källa, Func <TSource, Boolean> predikat)
  • offentlig statisk TSource SingleOrDefault <Källa> (denna IEnumerable <Källa> källa)
  • public static TSource SingleOrDefault <Source> (denna IEnumerable <TSource> -källa, Func <TSource, Boolean> predikat)
  • public static IEnumerable <TSource> Hoppa över <TSource> (denna IEnumerable <TSource> -källa, Int32-räkning)
  • public static IEnumerable <TSource> SkipWhile <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Boolean> predikat)
  • public static IEnumerable <TSource> SkipWhile <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Int32, Boolean> predikat)
  • public static Decimal Sum (denna IEnumerable <Decimal> källa)
  • public static Double Sum (denna IEnumerable <Double> -källa)
  • public static Int32 Sum (denna IEnumerable <Int32> källa)
  • public static Int64 Sum (denna IEnumerable <Int64> källa)
  • public static Nullable <Decimal> Sum (denna IEnumerable <Nullable <Decimal>> källa)
  • public static Nullable <Double> Sum (denna IEnumerable <Nullable <Double>> källa)
  • public static Nullable <Int32> Sum (denna IEnumerable <Nullable <Int32>> källa)
  • public static Nullable <Int64> Sum (denna IEnumerable <Nullable <Int64>> källa)
  • public static Nullable <Single> Sum (denna IEnumerable <Nullable <Single>> källa)
  • public static Single Sum (denna IEnumerable <Single> -källa)
  • public static Decimal Sum <TSource> (denna IEnumerable <TSource> källa, Func <TSource, Decimal> selector)
  • public static Double Sum <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Double> -väljare)
  • public static Int32 Sum <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Int32> -väljare)
  • public static Int64 Sum <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Int64> -väljare)
  • public static Nullable <Decimal> Sum <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Nullable <Decimal>> selector)
  • public static Nullable <Double> Sum <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Nullable <Double>> -väljare)
  • public static Nullable <Int32> Sum <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Nullable <Int32>> selector)
  • public static Nullable <Int64> Sum <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Nullable <Int64>> selector)
  • public static Nullable <Single> Sum <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Nullable <Single>> selector)
  • public static Enkel summa <Källa> (denna IEnumerable <Källa> källa, Func <TSource, Single> selector)
  • public static IEnumerable <TSource> Take <TSource> (denna IEnumerable <TSource> -källa, Int32-räkning)
  • public static IEnumerable <TSource> TakeWhile <Source> (denna IEnumerable <TSource> -källa, Func <TSource, Boolean> predikat)
  • public static IEnumerable <Source> TakeWhile <Source> (denna IEnumerable <TSource> -källa, Func <TSource, Int32, Boolean> predikat)
  • public static IOrderedEnumerable <Source> ThenBy <TSource, TKey> (denna IOrderedEnumerable <Source> källa, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> ThenBy <TSource, TKey> (denna IOrderedEnumerable <Source> källa, Func <TSource, TKey> keySelector, IComparer <TKey> jämförare)
  • public static IOrderedEnumerable <TSource> ThenByDescending <TSource, TKey> (denna IOrderedEnumerable <Source> källa, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> ThenByDescending <TSource, TKey> (denna IOrderedEnumerable <Source> källa, Func <TSource, TKey> keySelector, IComparer <TKey> jämförare)
  • public static TSource [] ToArray <Source> (denna IEnumerable <TSource> -källa)
  • public static Dictionary <TKey, TSource> ToDiction <TSource, TKey> (denna IEnumerable <Source> -källa, Func <TSource, TKey> keySelector)
  • public static Dictionary <TKey, TSource> ToDiction <TSource, TKey> (denna IEnumerable <Source> -källa, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> jämförare)
  • public static Dictionary <TKey, TElement> ToDiction <TSource, TKey, TElement> (denna IEnumerable <Source> -källa, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • public static Dictionary <TKey, TElement> ToDiction <TSource, TKey, TElement> (denna IEnumerable <Source> -källa, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> jämförare)
  • offentlig statisk lista <Källa> ToList <Källa> (denna IEnumerable <Källa> källa)
  • public static ILookup <TKey, TSource> ToLookup <TSource, TKey> (denna IEnumerable <TSource> -källa, Func <TSource, TKey> keySelector)
  • public static ILookup <TKey, TSource> ToLookup <TSource, TKey> (denna IEnumerable <Source> -källa, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> jämförare)
  • public static ILookup <TKey, TElement> ToLookup <TSource, TKey, TElement> (denna IEnumerable <Source> -källa, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • public static ILookup <TKey, TElement> ToLookup <TSource, TKey, TElement> (denna IEnumerable <Source> källa, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> jämförare)
  • public static IEnumerable <TSource> Union <TSource> (denna IEnumerable <TSource> först, IEnumerable <TSource> second)
  • public static IEnumerable <TSource> Union <TSource> (denna IEnumerable <TSource> först, IEnumerable <TSource> second, IEqualityComparer <Source> jämförare)
  • public static IEnumerable <TSource> Where <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Boolean> predikat)
  • public static IEnumerable <TSource> Where <TSource> (denna IEnumerable <TSource> -källa, Func <TSource, Int32, Boolean> predikat)
  • public static IEnumerable <TResult> Zip <TFirst, TSecond, TResult> (denna IEnumerable <TFirst> först, IEnumerable <TSecond> second, Func <TFirst, TSecond, TResult> resultSelector)

Anmärkningar

De inbyggda LINQ-metoderna är förlängningsmetoder för IEnumerable<T> -gränssnittet som lever i klassen System.Linq.Enumerable i System.Linq.Enumerable System.Core . De finns tillgängliga i .NET Framework 3.5 och senare.

LINQ möjliggör enkel modifiering, transformation och kombination av olika IEnumerable hjälp av en fråga-liknande eller funktionell syntax.

Medan standard LINQ-metoderna kan fungera på alla IEnumerable<T> , inklusive de enkla matriserna och List<T> , kan de också användas på databasobjekt, där uppsättningen av LINQ-uttryck i många fall kan omvandlas till SQL om dataobjekt stöder det. Se LINQ till SQL .

För de metoder som jämför objekt (som Contains och Except ) används IEquatable<T>.Equals om typen T i samlingen implementerar det gränssnittet. Annars standard Equals och GetHashCode av typen (möjligen överstyras från standard Object är implementeringar) används. Det finns också överbelastningar för dessa metoder som gör det möjligt att specificera en anpassad IEqualityComparer<T> .

För ...OrDefault metoderna används default(T) för att generera standardvärden.

Officiell referens: Antalet klass

Lat utvärdering

Praktiskt taget varje fråga som returnerar ett IEnumerable<T> utvärderas inte omedelbart; istället försenas logiken tills frågan itereras. En implikation är att varje gång någon itererar över ett IEnumerable<T> skapat från en av dessa frågor, t.ex. .Where() , upprepas hela frågan logiken. Om predikatet är långvarigt kan det vara en orsak till prestandaproblem.

En enkel lösning (när du vet eller kan kontrollera den ungefärliga storleken på den resulterande sekvensen) är att buffra resultaten med hjälp av .ToArray() eller .ToList() . .ToDictionary() eller .ToLookup() kan fylla samma roll. Man kan naturligtvis också iterera över hela sekvensen och buffra elementen enligt annan anpassad logik.

ToArray() eller ToList() ?

Både .ToArray() och .ToList() genom alla element i en IEnumerable<T> -sekvens och sparar resultaten i en samling lagrad i minnet. Använd följande riktlinjer för att avgöra vilka du ska välja:

  • Vissa API: er kan kräva en T[] eller en List<T> .
  • .ToList() kör vanligtvis snabbare och genererar mindre skräp än .ToArray() , eftersom den senare måste kopiera alla element till en ny samling i fast storlek en gång till än den förra, i nästan alla fall.
  • Element kan läggas till eller tas bort från List<T> returneras av. .ToList() , medan T[] returneras från .ToArray() förblir en fast storlek under hela sin livstid. Med andra ord, List<T> är muterbara, och T[] är oföränderlig.
  • T[] returneras från .ToArray() använder mindre minne än List<T> returneras från .ToList() , så om resultatet kommer att lagras under lång tid, föredrar du .ToArray() . Samtalslista List<T>.TrimExcess() skulle göra minnesskillnaden strikt akademisk, till bekostnad av att eliminera den relativa hastighetsfördelen med. .ToList() .

Välj (karta)

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

Denna typ av funktion kallas vanligtvis map på funktionella programmeringsspråk.

Var (filter)

Den här metoden returnerar ett IEantal med alla element som uppfyller lambda-uttrycket

Exempel 

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

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

Produktion:

Foo, Fizz

Visa demo

Sortera efter

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

innehåller

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

Bortsett från

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

Korsas

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

Observera att dubletter hålls i resultatet. Om detta är oönskat, använd Union istället.

Först (hitta)

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

Följande kastar InvalidOperationException med meddelandet "Sequence innehåller inget matchande element": 

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

Enda

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

Följande kastar InvalidOperationException eftersom det finns mer än ett element i sekvensen: 

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

Sista

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

Följande kastar 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

Följande kastar 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

Några

Returnerar true om samlingen har några element som uppfyller villkoret i lambda-uttrycket: 

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

Allt

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

Observera att All metoden fungerar genom att kontrollera att det första elementet utvärderas som false enligt predikatet. Därför kommer metoden returnera true för alla predikat i det fall att uppsättningen är tom: 

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

SelectMany (platt karta)

Enumerable.Select returnerar ett utgångselement för varje ingångselement. Medan Enumerable.SelectMany producerar ett variabelt antal utgångselement för varje ingångselement. Detta betyder att utgångssekvensen kan innehålla fler eller färre element än vad som fanns i ingångssekvensen.

Lambda expressions skickas till Enumerable.Select måste returnera en enda artikel. Lambda-uttryck som skickas till Enumerable.SelectMany måste producera en barnsekvens. Denna barnsekvens kan innehålla ett varierande antal element för varje element i ingångssekvensen.

Exempel 

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

Produktion:

1,2,3,4,5,6

Visa demo

Enumerable.SelectMany kan också uppnås med en syntaxbaserad fråga med två på varandra följande from klausuler: 

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

Summa

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

Hoppa

Skip kommer att räkna upp de första N-artiklarna utan att returnera dem. När artikelnummer N + 1 har nåtts, börjar Skip returnera varje uppräknat objekt: 

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

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

//3,4,5

Ta

Denna metod tar de första n elementen från ett antal. 

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

Omvänd

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

Medel

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

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

Denna metod beräknar medelvärdet av antalet siffror. 

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

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

Den här metoden beräknar medelvärdet av en mängd med delegerad funktion.

Blixtlås

.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

Distinkt

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

Grupp av

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

Gruppera fakturor per land, genererar ett nytt objekt med antalet poster, totalt betalt och genomsnittligt betalt 

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

Om vi bara vill ha totalen, ingen grupp 

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

Om vi behöver flera räkningar 

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

Returnerar en ny ordlista från källan IEnumerable med den medföljande keySelector-funktionen för att bestämma nycklar. Kasta en ArgumentException om keySelector inte är injicerande (returnerar ett unikt värde för varje medlem i källsamlingen.) Det finns överbelastningar som gör att man kan ange värdet som ska lagras och nyckeln. 

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

Om du bara Dictionary<TKey,TVal> skapas en Dictionary<TKey,TVal> med TKey Dictionary<TKey,TVal> , TVal den ursprungliga objekttypen och det ursprungliga objektet som det lagrade värdet. 

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

Dictionary<TKey,TVal> TKey skapas en Dictionary<TKey,TVal> med TKey fortfarande TKey , men TVal nu TVal och det returnerade värdet som det lagrade värdet. 

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

Som nämnts ovan måste knapparna som returneras av tangentväljaren vara unika. Följande kommer att kasta ett undantag. 

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)

Om en unik nyckel inte kan ges för källsamlingen, överväg att använda ToLookup istället. På ytan uppträder ToLookup på samma sätt som ToDiction, men i den resulterande sökningen är varje tangent parad med en samling värden med matchande tangenter.

Union

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

Observera att dubletter tas bort från resultatet. Om detta är oönskat, använd Concat istället.

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[]

Att lista

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

Räkna

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

Aggregera (vika)

Generera ett nytt objekt i varje steg: 

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,

Använda samma objekt i alla steg: 

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

Med hjälp av en resultatväljare: 

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,

Om ett frö utelämnas blir det första elementet fröet: 

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

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

Att kolla upp

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

Ansluta sig

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

Kasta

Cast skiljer sig från de andra metoderna i Enumerable att det är en förlängningsmetod för IEnumerable , inte för IEnumerable<T> . Således kan den användas för att konvertera förekomster av de förstnämnda till förekomster av de senare.

Detta sammanställs inte eftersom ArrayList inte implementerar IEnumerable<T> : 

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

Detta fungerar som förväntat: 

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

Cast utför inte konverteringskast. Följande sammanställer men kastar InvalidCastException vid körning: 

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

Det rätta sättet att utföra en konverterande roll till en samling är som följer: 

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

Tömma

Så här skapar du ett tomt IEantal av int: 

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

Denna tomma IEnumerable är cachelagrad för varje typ T, så att: 

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

ThenBy

ThenBy kan endast användas efter en OrderBy klausul som gör det möjligt att beställa med flera kriterier 

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

Räckvidd

De två parametrarna för Range är det första numret och antalet element som ska produceras (inte det sista numret). 

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

Vänster yttre anslutning

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

Upprepa

Enumerable.Repeat genererar en sekvens med ett upprepat värde. I detta exempel genererar det "Hej" fyra gånger. 

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
Licensierat under CC BY-SA 3.0
Inte anslutet till Stack Overflow