.NET Framework
LINQ

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


Einführung

LINQ (Language Integrated Query) ist ein Ausdruck, der Daten aus einer Datenquelle abruft. LINQ vereinfacht diese Situation, indem es ein konsistentes Modell für die Arbeit mit Daten über verschiedene Arten von Datenquellen und -formaten anbietet. In einer LINQ-Abfrage arbeiten Sie immer mit Objekten. Sie verwenden dieselben grundlegenden Codierungsmuster zum Abfragen und Umwandeln von Daten in XML-Dokumenten, SQL-Datenbanken, ADO.NET-Datensätzen, .NET-Sammlungen und anderen Formaten, für die ein Anbieter verfügbar ist. LINQ kann in C # und VB verwendet werden.

Syntax

  • public static TSource Aggregate <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, TSource, TSource> func)
  • public static TAccumulate Aggregate <TSource, TAccumulate> (diese IEnumerable <TSource> -Quelle, TAccumulate-Samen, Func <TAccumulate, TSource, TAccumulate> -Funk)
  • public static TResult Aggregate <TSource, TAccumulate, TResult> (diese IEnumerable <TSource> -Quelle, TAccumulate-Samen, Func <TAccumulate, TSource, TAccumulate> func, Func <TAccumulate, TResult> resultSelector)
  • public static Boolean All <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Boolean> -Prädikat)
  • public static Boolean Any <TSource> (diese IEnumerable-Quelle <TSource>)
  • public static Boolean Any <TSource> (diese IEnumerable-Quelle <TSource>, Func <TSource, Boolean> -Prädikat)
  • public static IEnumerable <TSource> AsEnumerable <TSource> (diese IEnumerable-Quelle <TSource>)
  • public static decimal Average (diese IEnumerable-Quelle <Decimal>)
  • public static Double Average (diese IEnumerable-Quelle <Double>)
  • public static Double Average (diese IEnumerable-Quelle <Int32>)
  • public static Double Average (diese IEnumerable-Quelle <Int64>)
  • public static Nullable <Decimal> Average (diese IEnumerable <Nullable <Decimal >> -Quelle)
  • public static Nullable <Double> Average (diese IEnumerable <Nullable <Double >> -Quelle)
  • public static Nullable <Double> Average (diese IEnumerable <Nullable <Int32 >> -Quelle)
  • public static Nullable <Double> Average (diese IEnumerable <Nullable <Int64 >> -Quelle)
  • public static Nullable <Single> Average (diese IEnumerable <Nullable <Single >> -Quelle)
  • public static Single Average (diese IEnumerable-Quelle <Single>)
  • public static Decimal Average <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Decimal> -Selektor)
  • public static Double Average <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Double> -Selektor)
  • public static Double Average <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Int32> -Selektor)
  • public static Double Average <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Int64> -Selektor)
  • public static Nullable <Decimal> Average <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Nullable <Decimal >> -Selektor)
  • public static Nullable <Double> Average <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Nullable <Double >> -Selektor)
  • public static Nullable <Double> Average <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Nullable <Int32 >> -Selektor)
  • public static Nullable <Double> Average <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Nullable <Int64 >> -Selektor)
  • public static Nullable <Single> Average <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Nullable <Single >> -selektor)
  • public static Single Average <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Single> -Selektor)
  • public static IEnumerable <TResult> Cast <TResult> (diese IEnumerable-Quelle)
  • public static IEnumerable <TSource> Concat <TSource> (zuerst IEnumerable <TSource>, zuerst IEnumerable <TSource>)
  • public static Boolean Enthält <TSource> (diese IEnumerable <TSource> -Quelle, TSource-Wert)
  • public static Boolean Enthält <TSource> (diese IEnumerable <TSource> -Quelle, TSource-Wert, IEqualityComparer <TSource> -Vergleicher)
  • public static Int32 Count <TSource> (diese IEnumerable-Quelle <TSource>)
  • public static Int32 Count <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Boolean> -Prädikat)
  • public static IEnumerable <TSource> DefaultIfEmpty <TSource> (diese IEnumerable-Quelle <TSource>)
  • public static IEnumerable <TSource> DefaultIfEmpty <TSource> (diese IEnumerable <TSource> -Quelle, TSource defaultValue)
  • public static IEnumerable <TSource> Distinct <TSource> (diese IEnumerable-Quelle <TSource>)
  • public static IEnumerable <TSource> Distinct <TSource> (diese IEnumerable <TSource> -Quelle, IEqualityComparer <TSource> -Vergleicher)
  • public static TSource ElementAt <TSource> (diese IEnumerable <TSource> -Quelle, Int32-Index)
  • public static TSource ElementAtOrDefault <TSource> (diese IEnumerable-Quelle <TSource>, Int32-Index)
  • public static IEnumerable <TResult> Leer <TResult> ()
  • public static IEnumerable <TSource> Außer <TSource> (zuerst IEnumerable <TSource>, IEnumerable <TSource> Sekunde)
  • public static IEnumerable <TSource> Außer <TSource> (zuerst IEnumerable <TSource>, IEnumerable <TSource>, IEqualityComparer <TSource>)
  • public static TSource First <TSource> (diese IEnumerable-Quelle <TSource>)
  • public static TSource First <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Boolean> -Prädikat)
  • öffentliche statische TSource FirstOrDefault <TSource> (diese IEnumerable-Quelle <TSource>)
  • public static TSource FirstOrDefault <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Boolean> -Prädikat)
  • public static IEnumerable <IGrouping <TKey, TSource >> GroupBy <TSource, TKey> (diese IEnumerable-Quelle <TSource>, Func <TSource, TKey> keySelector)
  • public static IEnumerable <IGrouping <TKey, TSource >> GroupBy <TSource, TKey> (diese IEnumerable-Quelle <TSource>, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> -Vergleicher)
  • public static IEnumerable <IGrouping <TKey, TElement >> GroupBy <TSource, TKey, TElement> (diese IEnumerable-Quelle <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • public static IEnumerable <IGrouping <TKey, TElement >> GroupBy <TSource, TKey, TElement> (diese IEnumerable <TSource> -Quelle, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> -Vergleicher)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TResult> (diese IEnumerable <TSource> -Quelle, Func <TSource, TKey> keySelector, Func <TKey, IEnumerable <TSource>, TResult> resultSelector)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TResult> (diese IEnumerable <TSource> -Quelle, Func <TSource, TKey> keySelector, Func <TKey, IEnumerable <TSource>, TResult> resultSelector, IEqualityComparer <TKey> Vergleicher)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TElement, TResult> (diese IEnumerable-Quelle <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <TKey, IEnumerable <TElement>, TResult.) > resultSelector)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TElement, TResult> (diese IEnumerable-Quelle <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <TKey, IEnumerable <TElement>, TResult.) > resultSelector, IEqualityComparer <TKey> (Vergleicher)
  • public static IEnumerable <TResult> GroupJoin <TOuter, TInner, TKey, TResult> (dieses IEnumerable <TOuter> äußere, IEnumerable <TInner> inner, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <Touter, IEnumerable <TInner>, TResult> resultSelector)
  • public static IEnumerable <TResult> GroupJoin <TOuter, TInner, TKey, TResult> (dieses IEnumerable <TOuter> äußere, IEnumerable <TInner> inner, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <Touter, IEnumerable <TInner>, TResult> resultSelector, IEqualityComparer <TKey> (Vergleicher)
  • public static IEnumerable <TSource> Intersect <TSource> (zuerst IEnumerable <TSource>, zuerst IEnumerable <TSource>)
  • public static IEnumerable <TSource> Intersect <TSource> (zuerst IEnumerable <TSource>, IEnumerable <TSource>, IEqualityComparer <TSource>)
  • public static IEnumerable <TResult> Join <TOuter, TInner, TKey, TResult> (dieses IEnumerable <TOuter> äußere, IEnumerable <TInner> inner, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <Touter, TInner, TResult> resultSelector)
  • public static IEnumerable <TResult> Join <TOuter, TInner, TKey, TResult> (dieses IEnumerable <TOuter> äußere, IEnumerable <TInner> inner, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <Touter, TInner, TResult> resultSelector, IEqualityComparer <TKey> (Vergleicher)
  • public static TSource Last <TSource> (diese IEnumerable-Quelle <TSource>)
  • public static TSource Last <TSource> (diese IEnumerable-Quelle <TSource>, Func <TSource, Boolean> -Prädikat)
  • public static TSource LastOrDefault <TSource> (diese IEnumerable-Quelle <TSource>)
  • public static TSource LastOrDefault <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Boolean> -Prädikat)
  • public static Int64 LongCount <TSource> (diese IEnumerable <TSource> -Quelle)
  • public static Int64 LongCount <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Boolean> -Prädikat)
  • public static decimal Max (diese IEnumerable-Quelle <Decimal>)
  • public static Double Max (diese IEnumerable-Quelle <Double>)
  • public static Int32 Max (diese IEnumerable-Quelle <Int32>)
  • public static Int64 Max (diese IEnumerable-Quelle <Int64>)
  • public static Nullable <Decimal> Max (diese IEnumerable <Nullable <Decimal >> -Quelle)
  • public static Nullable <Double> Max (diese IEnumerable <Nullable <Double >> -Quelle)
  • public static Nullable <Int32> Max (diese IEnumerable <Nullable <Int32 >> -Quelle)
  • public static Nullable <Int64> Max (diese IEnumerable <Nullable <Int64 >> -Quelle)
  • public static Nullable <Single> Max (diese IEnumerable <Nullable <Single >> -Quelle)
  • public static Single Max (diese IEnumerable-Quelle <Single>)
  • public static TSource Max <TSource> (diese IEnumerable-Quelle <TSource>)
  • public static Decimal Max <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Decimal> -Selektor)
  • public static Double Max <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Double> -Selektor)
  • public static Int32 Max <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Int32> -Selektor)
  • public static Int64 Max <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Int64> -Selektor)
  • public static Nullable <Decimal> Max. <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Nullable <Decimal >> -Selektor)
  • public static Nullable <Double> Max <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Nullable <Double >> -Selektor)
  • public static Nullable <Int32> Max. <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Nullable <Int32 >> -Selektor)
  • public static Nullable <Int64> Max <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Nullable <Int64 >> -Selektor)
  • public static Nullable <Single> Max <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Nullable <Single >> -selektor)
  • public static Single Max <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Single> -Selektor)
  • public static TResult Max <TSource, TResult> (diese IEnumerable <TSource> -Quelle, Func <TSource, TResult> -Selektor)
  • public static decimal Min (diese IEnumerable-Quelle <Decimal>)
  • public static Double Min (diese IEnumerable-Quelle <Double>)
  • public static Int32 Min (diese IEnumerable-Quelle <Int32>)
  • public static Int64 Min (diese IEnumerable-Quelle <Int64>)
  • public static Nullable <Decimal> Min (diese IEnumerable <Nullable <Decimal >> -Quelle)
  • public static Nullable <Double> Min (diese IEnumerable <Nullable <Double >> -Quelle)
  • public static Nullable <Int32> Min (diese IEnumerable <Nullable <Int32 >> -Quelle)
  • public static Nullable <Int64> Min (diese IEnumerable <Nullable <Int64 >> -Quelle)
  • public static Nullable <Single> Min (diese IEnumerable <Nullable <Single >> -Quelle)
  • public static Single Min (diese IEnumerable-Quelle <Single>)
  • öffentliche statische TSource Min <TSource> (diese IEnumerable-Quelle <TSource>)
  • public static Decimal Min <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Decimal> -Selektor)
  • public static Double Min <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Double> -Selektor)
  • public static Int32 Min <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Int32> -Selektor)
  • public static Int64 Min <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Int64> -Selektor)
  • public static Nullable <Decimal> Min. <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Nullable <Decimal >> -Selektor)
  • public static Nullable <Double> Min <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Nullable <Double >> -Selektor)
  • public static Nullable <Int32> Min. <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Nullable <Int32 >> -Selektor)
  • public static Nullable <Int64> Min. <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Nullable <Int64 >> -Selektor)
  • public static Nullable <Single> Min <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Nullable <Single >> -selektor)
  • public static Single Min <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Single> -Selektor)
  • public static TResult Min <TSource, TResult> (diese IEnumerable <TSource> -Quelle, Func <TSource, TResult> -Selektor)
  • public static IEnumerable <TResult> OfType <TResult> (diese IEnumerable-Quelle)
  • public static IOrderedEnumerable <TSource> OrderBy <TSource, TKey> (diese IEnumerable-Quelle <TSource>, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> OrderBy <TSource, TKey> (diese IEnumerable-Quelle <TSource>, Func <TSource, TKey> keySelector, IComparer <TKey> -Vergleicher)
  • public static IOrderedEnumerable <TSource> OrderByDescending <TSource, TKey> (diese IEnumerable-Quelle <TSource>, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> OrderByDescending <TSource, TKey> (diese IEnumerable-Quelle <TSource>, Func <TSource, TKey> keySelector, IComparer <TKey> -Vergleicher)
  • public static IEnumerable <Int32> Bereich (Int32-Start, Int32-Zählung)
  • public static IEnumerable <TResult> Repeat <TResult> (TResult-Element, Int32-Zählung)
  • public static IEnumerable <TSource> Reverse <TSource> (diese IEnumerable-Quelle <TSource>)
  • public static IEnumerable <TResult> Select <TSource, TResult> (diese IEnumerable <TSource> -Quelle, Func <TSource, TResult> -Selektor)
  • public static IEnumerable <TResult> Wählen Sie <TSource, TResult> aus (diese IEnumerable-Quelle <TSource>, Func <TSource, Int32, TResult> -Selektor).
  • public static IEnumerable <TResult> SelectMany <TSource, TResult> (diese IEnumerable <TSource> -Quelle, Func <TSource, IEnumerable <TResult >> -Selektor)
  • public static IEnumerable <TResult> SelectMany <TSource, TResult> (diese IEnumerable <TSource> -Quelle, Func <TSource, Int32, IEnumerable <TResult >> -Selektor)
  • public static IEnumerable <TResult> SelectMany <TSource, TCollection, TResult> (diese IEnumerable <TSource> -Quelle, Func <TSource, IEnumerable <TCollection >> collectionSelector, Func <TSource, TCollection, TResult> resultSelector)
  • public static IEnumerable <TResult> SelectMany <TSource, TCollection, TResult> (diese IEnumerable <TSource> -Quelle, Func <TSource, Int32, IEnumerable <TCollection >> collectionSelector, Func <TSource, TCollection, TResult> resultSelector)
  • public static Boolean SequenceEqual <TSource> (zuerst IEnumerable <TSource>, IEnumerable <TSource> Sekunde)
  • public static Boolean SequenceEqual <TSource> (zuerst IEnumerable <TSource>, IEnumerable <TSource>, IEqualityComparer <TSource>)
  • public static TSource Single <TSource> (diese IEnumerable-Quelle <TSource>)
  • public static TSource Single <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Boolean> -Prädikat)
  • public static TSource SingleOrDefault <TSource> (diese IEnumerable-Quelle <TSource>)
  • public static TSource SingleOrDefault <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Boolean> -Prädikat)
  • public static IEnumerable <TSource> Überspringen <TSource> (diese IEnumerable <TSource> -Quelle, Int32-Zähler)
  • public static IEnumerable <TSource> SkipWhile <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Boolean> -Prädikat)
  • public static IEnumerable <TSource> SkipWhile <TSource> (diese IEnumerable-Quelle <TSource>, Func <TSource, Int32, Boolean>)
  • öffentliche statische Dezimalsumme (diese IEnumerable-Quelle <Decimal>)
  • öffentliche statische Doppelsumme (diese IEnumerable-Quelle <Double>)
  • public static Int32 Sum (diese IEnumerable-Quelle <Int32>)
  • public static Int64 Sum (diese IEnumerable-Quelle <Int64>)
  • public static Nullable <Decimal> Summe (diese IEnumerable <Nullable <Decimal >> -Quelle)
  • public static Nullable <Double> Summe (diese IEnumerable <Nullable <Double >> -Quelle)
  • public static Nullable <Int32> Summe (diese IEnumerable <Nullable <Int32 >> -Quelle)
  • public static Nullable <Int64> Summe (diese IEnumerable <Nullable <Int64 >> -Quelle)
  • public static Nullable <Single> Summe (diese IEnumerable <Nullable <Single >> -Quelle)
  • public static Single Sum (diese IEnumerable-Quelle <Single>)
  • public static Decimal Sum <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Decimal> -Selektor)
  • public static Double Sum <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Double> -Selektor)
  • public static Int32 Summe <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Int32> -Selektor)
  • public static Int64 Sum <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Int64> -Selektor)
  • public static Nullable <Decimal> Summe <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Nullable <Decimal >> -Selektor)
  • public static Nullable <Double> Summe <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Nullable <Double >> -Selektor)
  • public static Nullable <Int32> Summe <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Nullable <Int32 >> -Selektor)
  • public static Nullable <Int64> Summe <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Nullable <Int64 >> -Selektor)
  • public static Nullable <Single> Summe <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Nullable <Single >> -Selektor)
  • public static Single Sum <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Single> -Selektor)
  • public static IEnumerable <TSource> Nehmen Sie <TSource> (diese IEnumerable <TSource> -Quelle, Int32-Zählung)
  • public static IEnumerable <TSource> TakeWhile <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Boolean> -Prädikat)
  • public static IEnumerable <TSource> TakeWhile <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Int32, Boolean> -Prädikat)
  • public static IOrderedEnumerable <TSource> ThenBy <TSource, TKey> (diese IOrderedEnumerable-Quelle <TSource>, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> ThenBy <TSource, TKey> (diese IOrderedEnumerable-Quelle <TSource>, Func <TSource, TKey> keySelector, IComparer <TKey> -Vergleicher)
  • public static IOrderedEnumerable <TSource> ThenByDescending <TSource, TKey> (diese IOrderedEnumerable-Quelle <TSource>, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> ThenByDescending <TSource, TKey> (diese IOrderedEnumerable-Quelle <TSource>, Func <TSource, TKey> keySelector, IComparer <TKey> -Vergleicher)
  • public static TSource [] ToArray <TSource> (diese IEnumerable-Quelle <TSource>)
  • public static Dictionary <TKey, TSource> ToDictionary <TSource, TKey> (diese IEnumerable-Quelle <TSource>, Func <TSource, TKey> keySelector)
  • public static Dictionary <TKey, TSource> ToDictionary <TSource, TKey> (diese IEnumerable-Quelle <TSource>, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> -Vergleicher)
  • public static Dictionary <TKey, TElement> ToDictionary <TSource, TKey, TElement> (diese IEnumerable-Quelle <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • public static Dictionary <TKey, TElement> ToDictionary <TSource, TKey, TElement> (diese IEnumerable <TSource> -Quelle, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> -Vergleicher)
  • öffentliche statische Liste <TSource> ToList <TSource> (diese IEnumerable-Quelle <TSource>)
  • public static ILookup <TKey, TSource> ToLookup <TSource, TKey> (diese IEnumerable-Quelle <TSource>, Func <TSource, TKey> keySelector)
  • public static ILookup <TKey, TSource> ToLookup <TSource, TKey> (diese IEnumerable-Quelle <TSource>, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> -Vergleicher)
  • public static ILookup <TKey, TElement> ToLookup <TSource, TKey, TElement> (diese IEnumerable-Quelle <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • public static ILookup <TKey, TElement> ToLookup <TSource, TKey, TElement> (diese IEnumerable-Quelle <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> -Vergleicher)
  • public static IEnumerable <TSource> Union <TSource> (zuerst IEnumerable <TSource>, zuerst IEnumerable <TSource>)
  • public static IEnumerable <TSource> Union <TSource> (zuerst IEnumerable <TSource>, IEnumerable <TSource>, IEqualityComparer <TSource>)
  • public static IEnumerable <TSource> Where <TSource> (diese IEnumerable <TSource> -Quelle, Func <TSource, Boolean> -Prädikat)
  • public static IEnumerable <TSource> Where <TSource> (diese IEnumerable-Quelle <TSource>, Func <TSource, Int32, Boolean>)
  • public static IEnumerable <TResult> Zip <TFirst, TSecond, TResult> (zuerst IEnumerable <TFirst>, IEnumerable <TSecond> Zweitens, Func <TFirst, TSecond, TResult> resultSelector)

Bemerkungen

Die in LINQ integrierten Methoden sind Erweiterungsmethoden für die IEnumerable<T> -Schnittstelle, die in der System.Linq.Enumerable Klasse in der System.Core Assembly leben. Sie sind in .NET Framework 3.5 und höher verfügbar.

LINQ ermöglicht die einfache Änderung, Transformation und Kombination verschiedener IEnumerable mithilfe einer IEnumerable oder funktionalen Syntax.

Die Standard-LINQ-Methoden können zwar auf jedem IEnumerable<T> , einschließlich der einfachen Arrays und List<T> , verwendet werden, sie können jedoch auch auf Datenbankobjekte angewendet werden, bei denen der Satz von LINQ-Ausdrücken in vielen Fällen in SQL umgewandelt werden kann, wenn das Datenobjekt unterstützt es. Siehe LINQ to SQL .

Für die Methoden, die Objekte vergleichen (z. B. Contains und Except ), wird IEquatable<T>.Equals verwendet, wenn der Typ T der Auflistung diese Schnittstelle implementiert. Andernfalls wird die Standard - Equals und GetHashCode des Typs (möglicherweise von den Standard überschrieben Object verwendet werden. Es gibt auch Überladungen für diese Methoden, mit denen ein benutzerdefinierter IEqualityComparer<T> .

Bei den ...OrDefault Methoden wird default(T) verwendet, um Standardwerte zu generieren.

Offizielle Referenz: Enumerable-Klasse

Faule Bewertung

Praktisch jede Abfrage, die ein IEnumerable<T> wird nicht sofort ausgewertet. Stattdessen wird die Logik verzögert, bis die Abfrage wiederholt wird. Eine Konsequenz ist, dass jedes Mal, wenn jemand einen IEnumerable<T> .Where() , der aus einer dieser Abfragen erstellt wurde, z. B. .Where() , die vollständige Abfragelogik wiederholt wird. Wenn das Prädikat lange dauert, kann dies zu Leistungsproblemen führen.

Eine einfache Lösung (wenn Sie die ungefähre Größe der resultierenden Sequenz kennen oder steuern können) ist das vollständige .ToArray() der Ergebnisse mithilfe von .ToArray() oder .ToList() . .ToDictionary() oder .ToLookup() kann dieselbe Rolle erfüllen. Man kann natürlich auch über die gesamte Sequenz iterieren und die Elemente gemäß anderer benutzerdefinierter Logik puffern.

ToArray() oder ToList() ?

Sowohl .ToArray() als auch .ToList() durchlaufen alle Elemente einer IEnumerable<T> -Sequenz und speichern die Ergebnisse in einer im Speicher gespeicherten Auflistung. Verwenden Sie die folgenden Richtlinien, um zu bestimmen, welche Auswahl Sie treffen sollen:

  • Einige APIs erfordern möglicherweise ein T[] oder eine List<T> .
  • .ToList() läuft normalerweise schneller und erzeugt weniger Abfall als .ToArray() , da letztere alle Elemente einmal in eine neue Sammlung fester Größe kopieren muss, in fast allen Fällen.
  • Elemente können der von .ToList() List<T> hinzugefügt oder daraus entfernt werden, wohingegen das von .ToList() T[] während seiner gesamten Lebensdauer eine feste Größe .ToArray() . Mit anderen Worten, List<T> ist veränderlich und T[] ist unveränderlich.
  • Die T[] zurückgegeben von .ToArray() benötigt weniger Speicher als die List<T> von zurück .ToList() , so dass , wenn das Ergebnis für eine lange Zeit gelagert wird, bevorzugen .ToArray() . Durch das Aufrufen der List<T>.TrimExcess() der Speicherunterschied streng akademisch, wobei jedoch der relative Geschwindigkeitsvorteil von .ToList() .

Auswählen (karte)

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

Diese Art von Funktion wird in funktionalen Programmiersprachen normalerweise als map .

Wo (Filter)

Diese Methode gibt ein IEnumerable mit allen Elementen zurück, die den Lambda-Ausdruck erfüllen

Beispiel 

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

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

Ausgabe:

Foo, Fizz

Demo anzeigen

Sortieren nach

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

Enthält

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

Außer

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

Sich schneiden

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

Beachten Sie, dass Duplikate im Ergebnis bleiben. Wenn dies nicht erwünscht ist, verwenden Sie stattdessen Union .

Erstes (Finden)

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

Der folgende InvalidOperationException mit der Meldung "Sequenz enthält kein übereinstimmendes Element" aus: 

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

Der folgende InvalidOperationException da die Sequenz mehrere Elemente enthält: 

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

Zuletzt

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

Die folgende 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

Die folgende 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

Irgendein

Gibt " true wenn die Auflistung Elemente enthält, die die Bedingung im Lambda-Ausdruck erfüllen: 

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

Alles

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

Beachten Sie, dass die All Methode funktioniert, indem geprüft wird, ob das erste Element gemäß dem Prädikat als false bewertet wird. Daher gibt die Methode für jedes Prädikat true wenn die Menge leer ist: 

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

SelectMany (flache Karte)

Enumerable.Select gibt für jedes Eingabeelement ein Ausgabeelement zurück. Während Enumerable.SelectMany für jedes Eingabeelement eine variable Anzahl von Ausgabeelementen erzeugt. Dies bedeutet, dass die Ausgabefolge möglicherweise mehr oder weniger Elemente enthält als in der Eingabefolge.

An Enumerable.Select Lambda expressions müssen ein einzelnes Element zurückgeben. An Enumerable.SelectMany Lambda-Ausdrücke müssen eine Enumerable.SelectMany Sequenz erzeugen. Diese untergeordnete Sequenz kann eine unterschiedliche Anzahl von Elementen für jedes Element in der Eingabesequenz enthalten.

Beispiel 

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

Ausgabe:

1,2,3,4,5,6

Demo anzeigen

Enumerable.SelectMany kann auch mit einer auf Syntax basierenden Abfrage erreicht werden, wobei zwei aufeinanderfolgende from Klauseln verwendet werden: 

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

Summe

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

Überspringen

Überspringen wird die ersten N Elemente auflisten, ohne sie zurückzugeben. Sobald die Artikelnummer N + 1 erreicht ist, gibt Skip alle aufgelisteten Elemente zurück: 

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

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

//3,4,5

Nehmen

Diese Methode entnimmt die ersten n Elemente einer Aufzählung. 

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

Umkehren

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

Mindest

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

Durchschnittlich

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

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

Diese Methode berechnet den Durchschnitt der Anzahl der Zahlen. 

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

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

Diese Methode berechnet den Durchschnitt der Aufzählungszeichen mithilfe der delegierten Funktion.

Postleitzahl

.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

Eindeutig

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

Gruppiere nach

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

Gruppieren Sie die Rechnungen nach Land und erstellen Sie ein neues Objekt mit der Anzahl der Datensätze, der Gesamtzahl der Zahlungen und dem Durchschnittsgehalt 

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

Wenn wir nur die Summen wollen, keine Gruppe 

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

Wenn wir mehrere Zählungen benötigen 

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

Gibt ein neues Wörterbuch aus dem Quell- IEnumerable mit der bereitgestellten keySelector-Funktion zurück, um Schlüssel zu ermitteln. Löst eine ArgumentException wenn keySelector nicht injektiv ist (gibt einen eindeutigen Wert für jedes Mitglied der Quellensammlung zurück.) Es gibt Überladungen, mit denen der zu speichernde Wert sowie der Schlüssel angegeben werden können. 

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

Wenn Sie nur eine Schlüsselauswahlfunktion Dictionary<TKey,TVal> wird ein Dictionary<TKey,TVal> mit TKey der Rückgabetyp des Schlüsselwählers, TVal der ursprüngliche Objekttyp und das ursprüngliche Objekt als gespeicherter Wert erstellt. 

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

Wenn Sie auch eine Wertauswahlfunktion Dictionary<TKey,TVal> wird ein Dictionary<TKey,TVal> wobei TKey weiterhin den Rückgabetyp der Schlüsselauswahl, aber TVal jetzt den Rückgabetyp der TVal und den zurückgegebenen Wert als gespeicherten Wert darstellt. 

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

Wie bereits erwähnt, müssen die vom Schlüsselwähler zurückgegebenen Schlüssel eindeutig sein. Das folgende wird eine Ausnahme auslösen. 

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)

Wenn für die Quellensammlung kein eindeutiger Schlüssel angegeben werden kann, sollten Sie stattdessen ToLookup verwenden. Auf der Oberfläche verhält sich ToLookup ähnlich wie ToDictionary, in der resultierenden Suche wird jeder Schlüssel mit einer Auflistung von Werten mit übereinstimmenden Schlüsseln gepaart.

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

Beachten Sie, dass Duplikate aus dem Ergebnis entfernt werden. Wenn dies nicht erwünscht ist, verwenden Concat stattdessen Concat .

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

Auflisten

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

Anzahl

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

SkipWährend

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

Aggregat (falten)

In jedem Schritt ein neues Objekt erzeugen: 

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 allen Schritten dasselbe Objekt verwenden: 

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

Verwenden eines Ergebniswählers: 

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,

Wenn ein Seed weggelassen wird, wird das erste Element zum Seed: 

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

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

Nachschlagen

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

Beitreten

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

Besetzung

Cast unterscheidet sich von den anderen Methoden von Enumerable darin, dass es eine Erweiterungsmethode für IEnumerable , nicht für IEnumerable<T> . Somit können Instanzen des ersteren in Instanzen des späteren umgewandelt werden.

Dies wird nicht kompiliert, da ArrayList IEnumerable<T> nicht implementiert: 

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

Das funktioniert wie erwartet: 

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

Cast führt keine Konvertierungscasts durch. Die folgenden Kompilierungen InvalidCastException zur Laufzeit aus: 

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

Die richtige Methode zum Umwandeln einer Besetzung in eine Sammlung ist wie folgt: 

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

Leeren

So erstellen Sie ein leeres IEnumerable von int: 

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

Dieses leere IEnumerable wird für jeden Typ T zwischengespeichert, so dass: 

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

ThenBy

ThenBy kann nur nach einer OrderBy Klausel verwendet werden, die die Bestellung anhand mehrerer Kriterien ermöglicht 

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

Angebot

Die beiden Parameter für Range sind die erste Anzahl und die Anzahl der zu erzeugenden Elemente (nicht die letzte Anzahl). 

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

Linke äußere Verbindung

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

Wiederholen

Enumerable.Repeat generiert eine Folge eines wiederholten Werts. In diesem Beispiel wird 4-mal "Hallo" generiert. 

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
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow