.NET Framework
LINQ

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


Wprowadzenie

LINQ (Language Integrated Query) to wyrażenie, które pobiera dane ze źródła danych. LINQ upraszcza tę sytuację, oferując spójny model pracy z danymi w różnych źródłach i formatach danych. W zapytaniu LINQ zawsze pracujesz z obiektami. Korzystasz z tych samych podstawowych wzorców kodowania, aby wyszukiwać i przekształcać dane w dokumentach XML, bazach danych SQL, zestawach danych ADO.NET, kolekcjach .NET i dowolnym innym formacie, dla którego dostawca jest dostępny. LINQ może być używany w C # i VB.

Składnia

  • public static TSource Aggregate <TSource> (to IEnumerable <TSource> źródło, Func <TSource, TSource, TSource> func)
  • public static TAccumulate Aggregate <TSource, TAccumulate> (to IEnumerable <TSource> źródło, TAccumulate seed, Func <TAccumulate, TSource, TAccumulate> func)
  • public static TResult Aggregate <TSource, TAccumulate, TResult> (to IEnumerable <TSource> źródło, TAccumulate seed, Func <TAccumulate, TSource, TAccumulate> func, Func <TAccumulate, TResult> resultSelector)
  • public static Boolean All <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Boolean> predykat)
  • public static Boolean Any <TSource> (to IEnumerable <TSource> source)
  • public static Boolean Any <TSource> (to IEnumerable <TSource> source, Func <TSource, Boolean> predicate)
  • public static IEnumerable <TSource> AsEnumerable <TSource> (to źródło IEnumerable <TSource>)
  • public static Decimal Average (to IEnumerable <Decimal> źródło)
  • publiczna statyczna podwójna średnia (to IEnumerable <Double> źródło)
  • publiczna statyczna podwójna średnia (to IEnumerable <Int32> źródło)
  • publiczna statyczna podwójna średnia (to IEnumerable <Int64> źródło)
  • public static Nullable <Decimal> Average (to IEnumerable <Nullable <Decimal>> źródło)
  • public static Nullable <Double> Average (to IEnumerable <Nullable <Double>> źródło)
  • public static Nullable <Double> Average (to IEnumerable <Nullable <Int32>> źródło)
  • public static Nullable <Double> Average (to IEnumerable <Nullable <Int64>> źródło)
  • public static Nullable <Single> Average (to IEnumerable <Nullable <Single>> źródło)
  • public static Single Average (to IEnumerable <Single> źródło)
  • public static Decimal Average <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Decimal>)
  • public static Double Average <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Double> selektor)
  • public static Double Average <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Int32> selektor)
  • public static Double Average <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Int64> selektor)
  • public static Nullable <Decimal> Average <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Nullable <Decimal>> selektor)
  • public static Nullable <Double> Average <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Nullable <Double>>)
  • public static Nullable <Double> Average <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Nullable <Int32>> selektor)
  • public static Nullable <Double> Average <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Nullable <Int64>>)
  • public static Nullable <Single> Average <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Nullable <Single>> selektor)
  • public static Single Average <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Single> selektor)
  • public static IEnumerable <TResult> Cast <TResult> (to źródło IEnumerable)
  • public static IEnumerable <TSource> Concat <TSource> (ten IEnumerable <TSource> pierwszy, IEnumerable <TSource> drugi)
  • public static Boolean Zawiera <TSource> (to IEnumerable <TSource> źródło, TSource wartość)
  • public static Boolean Zawiera <TSource> (to IEnumerable <TSource> źródło, wartość TSource, IEqualityComparer <TSource> porównywarka)
  • public static Int32 Count <TSource> (to IEnumerable <TSource> source)
  • public static Int32 Count <TSource> (to IEnumerable <TSource> source, Func <TSource, Boolean> predicate)
  • public static IEnumerable <TSource> DefaultIfEmpty <TSource> (to źródło IEnumerable <TSource>
  • public static IEnumerable <TSource> DefaultIfEmpty <TSource> (to źródło IEnumerable <TSource>, TSource defaultValue)
  • public static IEnumerable <TSource> Distinct <TSource> (to IEnumerable <TSource> źródło)
  • public static IEnumerable <TSource> Distinct <TSource> (to IEnumerable <TSource> źródło, IEqualityComparer <TSource> porównywarka)
  • public static TSource ElementAt <TSource> (to IEnumerable <TSource> źródło, indeks Int32)
  • public static TSource ElementAtOrDefault <TSource> (to IEnumerable <TSource> źródło, indeks Int32)
  • public static IEnumerable <TResult> Pusty <TResult> ()
  • public static IEnumerable <TSource> Z wyjątkiem <TSource> (ten IEnumerable <TSource> pierwszy, IEnumerable <TSource> drugi)
  • public static IEnumerable <TSource> Z wyjątkiem <TSource> (ten IEnumerable <TSource> pierwszy, IEnumerable <TSource> drugi, IEqualityComparer <TSource> porównywarka)
  • public static TSource First <TSource> (to IEnumerable <TSource> źródło)
  • public static TSource First <TSource> (to IEnumerable <TSource> source, Func <TSource, Boolean> predicate)
  • publiczne statyczne TSource FirstOrDefault <TSource> (to IEnumerable <TSource> źródło)
  • public static TSource FirstOrDefault <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Boolean> predykat)
  • public static IEnumerable <IGrouping <TKey, TSource >> GroupBy <TSource, TKey> (to IEnumerable <TSource> źródło, Func <TSource, TKey> keySelector)
  • public static IEnumerable <IGrouping <TKey, TSource >> GroupBy <TSource, TKey> (to IEnumerable <TSource> źródło, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> porównywarka)
  • public static IEnumerable <IGrouping <TKey, TElement >> GroupBy <TSource, TKey, TElement> (to IEnumerable <TSource> źródło, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • public static IEnumerable <IGrouping <TKey, TElement >> GroupBy <TSource, TKey, TElement> (ten IEnumerable <TSource> źródło, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> porównawczy)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TResult> (to IEnumerable <TSource> źródło, Func <TSource, TKey> keySelector, Func <TKey, IEnumerable <TSource>, TResult> wynikSelector)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TResult> (to IEnumerable <TSource> źródło, Func <TSource, TKey> keySelector, Func <TKey, IEnumerable <TSource>, TResult> resultSelector, IEqualityComparer <TKey> porównywarka)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TElement, TResult> (to IEnumerable <TSource> źródło, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <TKey, IEnumerable <TElement>, TResult > resultSelector)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TElement, TResult> (to IEnumerable <TSource> źródło, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <TKey, IEnumerable <TElement>, TResult > resultSelector, IEqualityComparer <TKey> Comparer)
  • public static IEnumerable <TResult> GroupJoin <TOuter, TInner, TKey, TResult> (ten IEnumerable <TOuter> zewnętrzny, IEnumerable <TInner> wewnętrzny, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> wewnętrznyKeySelector, Func <TOuter, IEnumerable <TInner>, TResult> resultSelector)
  • public static IEnumerable <TResult> GroupJoin <TOuter, TInner, TKey, TResult> (ten IEnumerable <TOuter> zewnętrzny, IEnumerable <TInner> wewnętrzny, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> wewnętrznyKeySelector, Func <TOuter, IEnumerable <TInner>, TResult> resultSelector, IEqualityComparer <TKey> Comparer)
  • publiczny statyczny IEnumerable <TSource> Przecinaj <TSource> (ten IEnumerable <TSource> pierwszy, IEnumerable <TSource> drugi)
  • publiczny statyczny IEnumerable <TSource> Przecięcie <TSource> (ten IEnumerable <TSource> pierwszy, IEnumerable <TSource> drugi, IEqualityComparer <TSource> porównywarka)
  • public static IEnumerable <TResult> Dołącz <TOuter, TInner, TKey, TResult> (ten IEnumerable <TOuter> zewnętrzny, IEnumerable <TInner> wewnętrzny, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, TInner, TResult> resultSelector)
  • public static IEnumerable <TResult> Dołącz <TOuter, TInner, TKey, TResult> (ten IEnumerable <TOuter> zewnętrzny, IEnumerable <TInner> wewnętrzny, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, TInner, TResult> resultSelector, IEqualityComparer <TKey> Comparer)
  • public static TSource Last <TSource> (to IEnumerable <TSource> źródło)
  • public static TSource Last <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Boolean> predykat)
  • public static TSource LastOrDefault <TSource> (to IEnumerable <TSource> źródło)
  • public static TSource LastOrDefault <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Boolean> predykat)
  • public static Int64 LongCount <TSource> (to IEnumerable <TSource> źródło)
  • public static Int64 LongCount <TSource> (to IEnumerable <TSource> source, Func <TSource, Boolean> predicate)
  • public static Decimal Max (to IEnumerable <Decimal> źródło)
  • public static Double Max (to IEnumerable <Double> źródło)
  • public static Int32 Max (to IEnumerable <Int32> źródło)
  • public static Int64 Max (to IEnumerable <Int64> źródło)
  • public static Nullable <Decimal> Max (to IEnumerable <Nullable <Decimal>> źródło)
  • public static Nullable <Double> Max (to IEnumerable <Nullable <Double>> źródło)
  • public static Nullable <Int32> Max (to IEnumerable <Nullable <Int32>> źródło)
  • public static Nullable <Int64> Max (to IEnumerable <Nullable <Int64>> źródło)
  • public static Nullable <Single> Max (to IEnumerable <Nullable <Single>> źródło)
  • public static Single Max (to IEnumerable <Single> źródło)
  • public static TSource Max <TSource> (to IEnumerable <TSource> źródło)
  • public static Decimal Max <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Decimal>)
  • public static Double Max <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Double> selektor)
  • public static Int32 Max <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Int32> selektor)
  • public static Int64 Max <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Int64> selektor)
  • public static Nullable <Decimal> Max <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Nullable <Decimal>> selektor)
  • public static Nullable <Double> Max <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Nullable <Double>>)
  • public static Nullable <Int32> Max <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Nullable <Int32>> selektor)
  • public static Nullable <Int64> Max <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Nullable <Int64>> selektor)
  • public static Nullable <Single> Max <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Nullable <Single>> selektor)
  • public static Single Max <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Single> selektor)
  • public static TResult Max <TSource, TResult> (ten IEnumerable <TSource> źródło, Func <TSource, TResult> selektor)
  • public static Decimal Min (to IEnumerable <Decimal> źródło)
  • public static Double Min (to IEnumerable <Double> źródło)
  • public static Int32 Min (to IEnumerable <Int32> źródło)
  • public static Int64 Min (to IEnumerable <Int64> źródło)
  • public static Nullable <Decimal> Min (to IEnumerable <Nullable <Decimal>> źródło)
  • public static Nullable <Double> Min (to IEnumerable <Nullable <Double>> źródło)
  • public static Nullable <Int32> Min (to IEnumerable <Nullable <Int32>> źródło)
  • public static Nullable <Int64> Min (to IEnumerable <Nullable <Int64>> źródło)
  • public static Nullable <Single> Min (to IEnumerable <Nullable <Single>> źródło)
  • public static Single Min (to IEnumerable <Single> źródło)
  • public static TSource Min <TSource> (to IEnumerable <TSource> źródło)
  • public static Decimal Min <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Decimal>)
  • public static Double Min <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Double> selektor)
  • public static Int32 Min <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Int32> selektor)
  • public static Int64 Min <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Int64> selektor)
  • public static Nullable <Decimal> Min <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Nullable <Decimal>> selektor)
  • public static Nullable <Double> Min <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Nullable <Double>>)
  • public static Nullable <Int32> Min <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Nullable <Int32>> selektor)
  • public static Nullable <Int64> Min <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Nullable <Int64>> selektor)
  • public static Nullable <Single> Min <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Nullable <Single>> selektor)
  • public static Single Min <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Single> selektor)
  • public static TResult Min <TSource, TResult> (ten IEnumerable <TSource> źródło, Func <TSource, TResult> selektor)
  • public static IEnumerable <TResult> OfType <TResult> (to źródło IEnumerable)
  • public static IOrdersEnumerable <TSource> OrderBy <TSource, TKey> (to IEnumerable <TSource> źródło, Func <TSource, TKey> keySelector)
  • public static IOrdersEnumerable <TSource> OrderBy <TSource, TKey> (to IEnumerable <TSource> źródło, Func <TSource, TKey> keySelector, IComparer <TKey> moduł porównujący)
  • public static IOrdersEnumerable <TSource> OrderByDescending <TSource, TKey> (to IEnumerable <TSource> źródło, Func <TSource, TKey> keySelector)
  • public static IOrdersEnumerable <TSource> OrderByDescending <TSource, TKey> (to IEnumerable <TSource> źródło, Func <TSource, TKey> keySelector, IComparer <TKey> porównywarka)
  • public static IEnumerable <Int32> Range (Int32 start, Int32 count)
  • public static IEnumerable <TResult> Powtórz <TResult> (element TResult, liczba Int32)
  • public static IEnumerable <TSource> Reverse <TSource> (to IEnumerable <TSource> źródło)
  • public static IEnumerable <TResult> Wybierz <TSource, TResult> (ten IEnumerable <TSource> źródło, Func <TSource, TResult>)
  • public static IEnumerable <TResult> Wybierz <TSource, TResult> (ten IEnumerable <TSource> źródło, Func <TSource, Int32, TResult>)
  • public static IEnumerable <TResult> SelectMany <TSource, TResult> (to źródło IEnumerable <TSource>, Func <TSource, IEnumerable <TResult>> selektor)
  • publiczny statyczny IEnumerable <TResult> SelectMany <TSource, TResult> (ten IEnumerable <TSource> źródło, Func <TSource, Int32, IEnumerable <TResult>> selektor)
  • public static IEnumerable <TResult> SelectMany <TSource, TCollection, TResult> (to IEnumerable <TSource> źródło, Func <TSource, IEnumerable <TCollection>> collectionSelector, Func <TSource, TCollection, TResult> scoreSelector
  • public static IEnumerable <TResult> SelectMany <TSource, TCollection, TResult> (to IEnumerable <TSource> źródło, Func <TSource, Int32, IEnumerable <TCollection>> collectionSelector, Func <TSource, TCollection, TResult> resultSelector
  • public static Boolean SequenceEqual <TSource> (ten IEnumerable <TSource> pierwszy, IEnumerable <TSource> drugi)
  • public static Boolean SequenceEqual <TSource> (ten IEnumerable <TSource> pierwszy, IEnumerable <TSource> drugi, IEqualityComparer <TSource> porównywarka)
  • publiczny statyczny TSource Single <TSource> (to IEnumerable <TSource> źródło)
  • public static TSource Single <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Boolean> predykat)
  • public static TSource SingleOrDefault <TSource> (to IEnumerable <TSource> źródło)
  • public static TSource SingleOrDefault <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Boolean> predykat)
  • public static IEnumerable <TSource> Skip <TSource> (to IEnumerable <TSource> source, Int32 count)
  • public static IEnumerable <TSource> SkipWhile <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Boolean> predykat)
  • public static IEnumerable <TSource> SkipWhile <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Int32, Boolean> predykat)
  • public static Decimal Sum (to IEnumerable <Decimal> źródło)
  • public static Double Sum (to IEnumerable <Double> źródło)
  • publiczna statyczna suma Int32 (to IEnumerable <Int32> źródło)
  • publiczna statyczna suma Int64 (to IEnumerable <Int64> źródło)
  • public static Nullable <Decimal> Sum (this IEnumerable <Nullable <Decimal>> source)
  • public static Nullable <Double> Sum (this IEnumerable <Nullable <Double>> source)
  • public static static Nullable <Int32> Sum (this IEnumerable <Nullable <Int32>> source)
  • public static static Nullable <Int64> Sum (this IEnumerable <Nullable <Int64>> source)
  • public static Nullable <Single> Sum (to IEnumerable <Nullable <Single>> źródło)
  • public static Single Sum (to IEnumerable <Single> źródło)
  • public static Decimal Sum <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Decimal>)
  • public static Double Sum <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Double> selektor)
  • public static Int32 Sum <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Int32> selektor)
  • public static Int64 Sum <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Int64> selektor)
  • public static Nullable <Decimal> Sum <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Nullable <Decimal>> selektor)
  • public static Nullable <Double> Sum <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Nullable <Double>>)
  • public static Nullable <Int32> Sum <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Nullable <Int32>> selektor)
  • public static Nullable <Int64> Sum <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Nullable <Int64>> selektor)
  • public static Nullable <Single> Sum <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Nullable <Single>> selektor)
  • public static Single Sum <TSource> (ten IEnumerable <TSource> źródło, Func <TSource, Single> selektor)
  • public static IEnumerable <TSource> Weź <TSource> (to IEnumerable <TSource> źródło, liczba Int32)
  • public static IEnumerable <TSource> TakeWhile <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Boolean> predykat)
  • public static IEnumerable <TSource> TakeWhile <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Int32, Boolean> predykat)
  • public static IOrdersEnumerable <TSource> ThenBy <TSource, TKey> (to źródło IOrdersEnumerable <TSource>, Func <TSource, TKey> keySelector)
  • public static IOrdersEnumerable <TSource> ThenBy <TSource, TKey> (to IOrdersEnumerable <TSource> źródło, Func <TSource, TKey> keySelector, IComparer <TKey> porównujący)
  • public static IOrdersEnumerable <TSource> ThenByDescending <TSource, TKey> (to IOrdersEnumerable <TSource> źródło, Func <TSource, TKey> keySelector)
  • public static IOrdersEnumerable <TSource> ThenByDescending <TSource, TKey> (to IOrdersEnumerable <TSource> źródło, Func <TSource, TKey> keySelector, IComparer <TKey> moduł porównujący)
  • public static TSource [] ToArray <TSource> (to IEnumerable <TSource> źródło)
  • publiczny słownik statyczny <TKey, TSource> ToDictionary <TSource, TKey> (to IEnumerable <TSource> źródło, Func <TSource, TKey> keySelector)
  • publiczny słownik statyczny <TKey, TSource> ToDictionary <TSource, TKey> (to IEnumerable <TSource> źródło, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> porównywarka)
  • publiczny słownik statyczny <TKey, TElement> ToDictionary <TSource, TKey, TElement> (to IEnumerable <TSource> źródło, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • publiczny słownik statyczny <TKey, TElement> ToDictionary <TSource, TKey, TElement> (to IEnumerable <TSource> źródło, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> porównawczy)
  • public static List <TSource> ToList <TSource> (to IEnumerable <TSource> źródło)
  • publiczny statyczny ILookup <TKey, TSource> ToLookup <TSource, TKey> (to IEnumerable <TSource> źródło, Func <TSource, TKey> keySelector)
  • publiczny statyczny ILookup <TKey, TSource> ToLookup <TSource, TKey> (to IEnumerable <TSource> źródło, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> porównaj)
  • publiczne statyczne ILookup <TKey, TElement> ToLookup <TSource, TKey, TElement> (to IEnumerable <TSource> źródło, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • public static ILookup <TKey, TElement> ToLookup <TSource, TKey, TElement> (to IEnumerable <TSource> źródło, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> porównawczy)
  • publiczny statyczny IEnumerable <TSource> Union <TSource> (ten IEnumerable <TSource> pierwszy, IEnumerable <TSource> drugi)
  • publiczny statyczny IEnumerable <TSource> Union <TSource> (ten IEnumerable <TSource> pierwszy, IEnumerable <TSource> drugi, IEqualityComparer <TSource> porównywarka)
  • public static IEnumerable <TSource> Where <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Boolean> predicate)
  • public static IEnumerable <TSource> Where <TSource> (to IEnumerable <TSource> źródło, Func <TSource, Int32, Boolean> predykat)
  • public static IEnumerable <TResult> Zip <TFirst, TSecond, TResult> (ten IEnumerable <TFirst> pierwszy, IEnumerable <TSecond> drugi, Func <TFirst, TSecond, TResult> wynikSelector)

Uwagi

  • Zobacz także LINQ .

Wbudowane metody LINQ są metodami rozszerzenia interfejsu IEnumerable<T> , które istnieją w klasie System.Linq.Enumerable w zestawie System.Core . Są one dostępne w .NET Framework 3.5 i nowszych.

LINQ pozwala na prostą modyfikację, transformację i kombinację różnych IEnumerable przy użyciu składni podobnej do zapytania lub funkcjonalnej.

Chociaż standardowe metody LINQ mogą działać na dowolnym IEnumerable<T> , w tym na prostych tablicach i List<T> , mogą być również używane na obiektach bazy danych, w których zestaw wyrażeń LINQ można w wielu przypadkach przekształcić na SQL, jeśli obiekt danych obsługuje to. Zobacz LINQ to SQL .

W przypadku metod, które porównują obiekty (takie jak Contains i Except ), IEquatable<T>.Equals jest używany, jeśli typ T kolekcji implementuje ten interfejs. W przeciwnym razie stosowane są standardowe typy Equals i GetHashCode (ewentualnie zastąpione z domyślnych implementacji Object ). Istnieją również przeciążenia dla tych metod, które pozwalają określić niestandardowy IEqualityComparer<T> .

W przypadku metod ...OrDefault do generowania wartości domyślnych używana jest default(T) .

Oficjalne odniesienie: klasa wymienna

Leniwa ocena

Praktycznie każde zapytanie zwracające IEnumerable<T> nie jest oceniane natychmiast; zamiast tego logika jest opóźniona do momentu iteracji zapytania. Jedną z implikacji jest to, że za każdym razem, gdy ktoś iteruje w IEnumerable<T> utworzonym z jednego z tych zapytań, np. .Where() , logika pełnego zapytania jest powtarzana. Jeśli predykat jest długotrwały, może to być przyczyną problemów z wydajnością.

Jednym prostym rozwiązaniem (gdy znasz lub możesz kontrolować przybliżony rozmiar wynikowej sekwencji) jest pełne buforowanie wyników za pomocą .ToArray() lub .ToList() . .ToDictionary() lub .ToLookup() mogą spełniać tę samą rolę. Oczywiście można również iterować całą sekwencję i buforować elementy zgodnie z inną niestandardową logiką.

ToArray() czy ToList() ?

Zarówno .ToArray() i .ToList() przechodzą przez wszystkie elementy IEnumerable<T> sekwencji IEnumerable<T> i zapisują wyniki w kolekcji przechowywanej w pamięci. Skorzystaj z następujących wskazówek, aby określić, który wybrać:

  • Niektóre interfejsy API mogą wymagać T[] lub List<T> .
  • .ToList() zazwyczaj działa szybciej i generuje mniej śmieci niż .ToArray() , ponieważ ten ostatni musi skopiować wszystkie elementy do nowej kolekcji o stałym rozmiarze raz więcej niż poprzedni, prawie w każdym przypadku.
  • Elementy mogą być dodawane lub usuwane z List<T> zwracanej przez .ToList() , podczas gdy T[] zwracany z .ToArray() pozostaje przez cały czas ustalony rozmiar. Innymi słowy, List<T> jest zmienna, a T[] jest niezmienny.
  • T[] zwrócony z .ToArray() zużywa mniej pamięci niż List<T> zwrócona z .ToList() , więc jeśli wynik ma być przechowywany przez długi czas, wybierz .ToArray() . Wywołanie List<T>.TrimExcess() spowodowałoby, że różnica w pamięci byłaby ściśle akademicka, kosztem wyeliminowania przewagi prędkości względnej .ToList() .

Wybierz (mapa)

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

Ten typ funkcji jest zwykle nazywany map w funkcjonalnych językach programowania.

Gdzie (filtr)

Ta metoda zwraca IEnumerable ze wszystkimi elementami, które spełniają wyrażenie lambda

Przykład 

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

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

Wynik:

Foo, Fizz

Zobacz demo

Zamów przez

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

Zawiera

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

Z wyjątkiem

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

Krzyżować

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

Zauważ, że w wyniku są przechowywane duplikaty. Jeśli jest to niepożądane, użyj Union zamiast tego.

Pierwszy (znajdź)

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

Następujący wyrzuca InvalidOperationException z komunikatem „Sekwencja nie zawiera pasującego elementu”: 

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

Pojedynczy

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

Poniższe zgłasza InvalidOperationException ponieważ w sekwencji jest więcej niż jeden element: 

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

Ostatni, ubiegły, zeszły

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

Poniższe zgłasza 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

Poniższe zgłasza 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

Każdy

Zwraca wartość true jeśli kolekcja zawiera elementy spełniające warunek wyrażenia lambda: 

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

Wszystko

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

Zauważ, że metoda All działa, sprawdzając, czy pierwszy element ma wartość false zgodnie z predykatem. Dlatego metoda zwróci true dla każdego predykatu w przypadku, gdy zestaw jest pusty: 

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

SelectMany (płaska mapa)

Enumerable.Select zwraca element wyjściowy dla każdego elementu wejściowego. Natomiast Enumerable.SelectMany produkuje zmienną liczbę elementów wyjściowych dla każdego elementu wejściowego. Oznacza to, że sekwencja wyjściowa może zawierać więcej lub mniej elementów niż w sekwencji wejściowej.

Lambda expressions przekazane do Enumerable.Select musi zwrócić pojedynczy element. Wyrażenia lambda przekazane do Enumerable.SelectMany muszą wytworzyć sekwencję Enumerable.SelectMany . Ta sekwencja potomna może zawierać zmienną liczbę elementów dla każdego elementu w sekwencji wejściowej.

Przykład 

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

Wynik:

1,2,3,4,5,6

Zobacz demo

Enumerable.SelectMany można również osiągnąć za pomocą zapytania opartego na składni, używając dwóch następujących from klauzul: 

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

Suma

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

Pominąć

Skip wyliczy pierwsze N elementów bez ich zwracania. Po osiągnięciu numeru pozycji N + 1 Skip zaczyna zwracać każdy wyliczony przedmiot: 

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

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

//3,4,5

Brać

Ta metoda bierze pierwsze n elementów z wyliczalnego. 

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

Rewers

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

Średni

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

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

Ta metoda oblicza średnią liczbową liczb. 

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

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

Ta metoda oblicza średnią wyliczenia za pomocą funkcji delegowanej.

Zamek błyskawiczny

.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

Odrębny

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

Grupuj według

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

Grupuj faktury według kraju, generując nowy obiekt z liczbą rekordów, sumą zapłaconą i średnią zapłaconą 

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

Jeśli chcemy tylko sumy, nie ma grupy 

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

Jeśli potrzebujemy kilku obliczeń 

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

Zwraca nowy słownik ze źródłowej IEnumerable za pomocą dostarczonej funkcji keySelector w celu ustalenia kluczy. Zgłasza ArgumentException jeśli keySelector nie jest iniekcyjny (zwraca unikalną wartość dla każdego elementu kolekcji źródłowej). Istnieją przeciążenia, które pozwalają określić wartość, która ma być przechowywana, a także klucz. 

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

Podanie tylko funkcji wyboru klucza spowoduje utworzenie Dictionary<TKey,TVal> pomocą TKey zwracany typ selektora klucza, TVal oryginalny typ obiektu i obiekt oryginalny jako wartość przechowywana. 

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

Podanie również funkcji wyboru wartości spowoduje utworzenie Dictionary<TKey,TVal> z TKey nadal typem zwrotnym selektora klawiszy, ale TVal teraz typem zwrotnym funkcji selektora wartości i zwróconą wartością jako zapamiętaną wartością. 

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

Jak wspomniano powyżej, klucze zwrócone przez selektor kluczy muszą być unikalne. Poniższe spowoduje zgłoszenie wyjątku. 

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)

Jeśli nie można podać unikalnego klucza dla kolekcji źródłowej, rozważ użycie ToLookup zamiast tego. Na powierzchni ToLookup zachowuje się podobnie jak ToDictionary, jednak w wynikowym odnośniku każdy klucz jest sparowany z kolekcją wartości z pasującymi kluczami.

Unia

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

Pamiętaj, że duplikaty są usuwane z wyniku. Jeśli jest to niepożądane, zamiast tego użyj 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[]

Notować

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

Liczyć

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

Kruszywo (krotnie)

Generowanie nowego obiektu na każdym kroku: 

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,

Używanie tego samego obiektu we wszystkich krokach: 

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

Za pomocą selektora wyników: 

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,

Jeśli ziarno zostanie pominięte, pierwszy element staje się ziarnem: 

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

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

ToLookup

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

Przystąp

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

Odlew

Cast różni się od innych metod Enumerable na tym, że jest to metoda rozszerzenie dla IEnumerable , nie dla IEnumerable<T> . W ten sposób można go wykorzystać do konwersji wystąpień tego pierwszego na wystąpienie późniejszego.

Nie kompiluje się, ponieważ ArrayList nie implementuje IEnumerable<T> : 

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

Działa to zgodnie z oczekiwaniami: 

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

Cast nie wykonuje rzutów konwersji. Następujące kompiluje, ale zgłasza InvalidCastException w czasie wykonywania: 

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

Właściwy sposób przeprowadzenia konwersji rzutowania na kolekcję jest następujący: 

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

Pusty

Aby utworzyć pusty IEnumerable int: 

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

Ten pusty IEnumerable jest buforowany dla każdego typu T, dzięki czemu: 

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

Więc przez

ThenBy można użyć tylko po klauzuli OrderBy pozwalającej na zamówienie przy użyciu wielu kryteriów 

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

Zasięg

Dwa parametry do Range to pierwsza liczba i liczba elementów do wyprodukowania (nie ostatnia liczba). 

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

Lewy zewnętrzny łącznik

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

Powtarzać

Enumerable.Repeat generuje sekwencję powtarzanej wartości. W tym przykładzie generuje „Cześć” 4 razy. 

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
Licencjonowany na podstawie CC BY-SA 3.0
Nie związany z Stack Overflow