.NET Framework
LINQ

ASP.NET asp.net-mvc C# Language Entity Framework JavaScript Regular Expressions SQL Microsoft SQL Server Visual Basic .NET Language wpf
Поиск…


Вступление

LINQ (Language Integrated Query) - это выражение, которое извлекает данные из источника данных. LINQ упрощает эту ситуацию, предлагая согласованную модель для работы с данными в различных источниках и форматах данных. В запросе LINQ вы всегда работаете с объектами. Вы используете одни и те же базовые шаблоны кодирования для запроса и преобразования данных в документы XML, базы данных SQL, наборы данных ADO.NET, коллекции .NET и любой другой формат, доступный для провайдера. LINQ может использоваться в C # и VB.

Синтаксис

  • public static TSource Aggregate <TSource> (этот источник IEnumerable <TSource>, Func <TSource, TSource, TSource> func)
  • public static TAccumulate Aggregate <TSource, TAccumulate> (этот источник IEnumerable <TSource>, TAccumulate seed, Func <TAccumulate, TSource, TAccumulate> func)
  • public static TResult Aggregate <TSource, TAccumulate, TResult> (этот источник IEnumerable <TSource>, TAccumulate seed, Func <TAccumulate, TSource, TAccumulate> func, Func <TAccumulate, TResult> resultSelector)
  • public static Boolean Все <TSource> (этот источник IEnumerable <TSource>, предикат Func <TSource, Boolean>)
  • public static Boolean Любой <TSource> (этот источник IEnumerable <TSource>)
  • public static Boolean Любой <TSource> (этот источник IEnumerable <TSource>, предикат Func <TSource, Boolean>)
  • public static IEnumerable <TSource> AsEnumerable <TSource> (этот источник IEnumerable <TSource>)
  • public static Decimal Average (этот IEnumerable <десятичный> источник)
  • public static Double Average (этот источник IEnumerable <Double>)
  • public static Double Average (этот источник IEnumerable <Int32>)
  • public static Double Average (этот источник IEnumerable <Int64>)
  • public static Nullable <Decimal> Average (этот IEnumerable <Nullable <Decimal >> source)
  • public static Nullable <Double> Среднее (этот IEnumerable <Nullable <Double >> source)
  • public static Nullable <Double> Средний (этот IEnumerable <Nullable <Int32 >> source)
  • public static Nullable <Double> Средний (этот IEnumerable <Nullable <Int64 >> source)
  • public static Nullable <Single> Average (этот IEnumerable <Nullable <Single >> source)
  • public static Single Average (этот IEnumerable <Single> source)
  • public static Decimal Average <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Decimal>)
  • public static Double Average <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Double>)
  • public static Double Average <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Int32>)
  • public static Double Average <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Int64>)
  • public static Nullable <Decimal> Average <TSource> (этот источник IEnumerable <TSource>, Func <TSource, Nullable <Decimal >> selector)
  • public static Nullable <Double> Average <TSource> (этот источник IEnumerable <TSource>, Func <TSource, Nullable <Double >> selector)
  • public static Nullable <Double> Средний <TSource> (этот источник IEnumerable <TSource>, Func <TSource, Nullable <Int32 >> selector)
  • public static Nullable <Double> Average <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Nullable <Int64 >>)
  • public static Nullable <Single> Average <TSource> (этот источник IEnumerable <TSource>, Func <TSource, Nullable <Single >> selector))
  • public static Single Average <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Single>)
  • public static IEnumerable <TResult> Cast <TResult> (этот источник IEnumerable)
  • public static IEnumerable <TSource> Concat <TSource> (этот IEnumerable <TSource> сначала, IEnumerable <TSource> второй)
  • public static Boolean Содержит <TSource> (этот источник IEnumerable <TSource>, значение TSource)
  • public static Boolean Содержит <TSource> (этот источник IEnumerable <TSource>, значение TSource, сравнитель IEqualityComparer <TSource>)
  • public static Int32 Count <TSource> (этот источник IEnumerable <TSource>)
  • public static Int32 Count <TSource> (этот источник IEnumerable <TSource>, предикат Func <TSource, Boolean>)
  • public static IEnumerable <TSource> DefaultIfEmpty <TSource> (этот источник IEnumerable <TSource>)
  • public static IEnumerable <TSource> DefaultIfEmpty <TSource> (этот источник IEnumerable <TSource>, TSource defaultValue)
  • public static IEnumerable <TSource> Distinct <TSource> (этот источник IEnumerable <TSource>)
  • public static IEnumerable <TSource> Distinct <TSource> (этот источник IEnumerable <TSource>, сравнительный файл IEqualityComparer <TSource>)
  • public static TSource ElementAt <TSource> (этот источник IEnumerable <TSource>, индекс Int32)
  • public static TSource ElementAtOrDefault <TSource> (этот источник IEnumerable <TSource>, индекс Int32)
  • public static IEnumerable <TResult> Пусто <TResult> ()
  • public static IEnumerable <TSource> За исключением <TSource> (этот IEnumerable <TSource> сначала, IEnumerable <TSource> второй)
  • public static IEnumerable <TSource> За исключением <TSource> (этот IEnumerable <TSource> сначала, IEnumerable <TSource> второй, IEqualityComparer <TSource> Comparer)
  • public static TSource Первый <TSource> (этот источник IEnumerable <TSource>)
  • public static TSource First <TSource> (этот источник IEnumerable <TSource>, предикат Func <TSource, Boolean>)
  • public static TSource FirstOrDefault <TSource> (этот источник IEnumerable <TSource>)
  • public static TSource FirstOrDefault <TSource> (этот источник IEnumerable <TSource>, предикат Func <TSource, Boolean>)
  • public static IEnumerable <IGrouping <TKey, TSource >> GroupBy <TSource, TKey> (этот источник IEnumerable <TSource>, Func <TSource, TKey> keySelector)
  • public static IEnumerable <IGrouping <TKey, TSource >> GroupBy <TSource, TKey> (этот источник IEnumerable <TSource>, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> Comparer)
  • public static IEnumerable <IGrouping <TKey, TElement >> GroupBy <TSource, TKey, TElement> (этот источник IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • публичный статический IEnumerable <IGrouping <TKey, TElement >> GroupBy <TSource, TKey, TElement> (этот источник IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> Comparer)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TResult> (этот источник IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TKey, IEnumerable <TSource>, TResult> resultSelector)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TResult> (этот источник IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TKey, IEnumerable <TSource>, TResult> resultSelector, IEqualityComparer <TKey> Comparer)
  • публичный статический IEnumerable <TResult> GroupBy <TSource, TKey, TElement, TResult> (этот источник IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <TKey, IEnumerable <TElement>, TResult > resultSelector)
  • публичный статический IEnumerable <TResult> GroupBy <TSource, TKey, TElement, TResult> (этот источник IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <TKey, IEnumerable <TElement>, TResult > resultSelector, IEqualityComparer <TKey> Comparer)
  • публичный статический IEnumerable <TResult> GroupJoin <TOuter, TInner, TKey, TResult> (этот IEnumerable <TOuter> внешний, IEnumerable <TInner> внутренний, Func <TOuter, TKey> внешнийKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, IEnumerable <TInner>, TResult> resultSelector)
  • публичный статический IEnumerable <TResult> GroupJoin <TOuter, TInner, TKey, TResult> (этот IEnumerable <TOuter> внешний, IEnumerable <TInner> внутренний, Func <TOuter, TKey> внешнийKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, IEnumerable <TInner>, TResult> resultSelector, IEqualityComparer <TKey> Comparer)
  • public static IEnumerable <TSource> Intersect <TSource> (этот IEnumerable <TSource> сначала, IEnumerable <TSource> второй)
  • public static IEnumerable <TSource> Intersect <TSource> (этот IEnumerable <TSource> сначала, IEnumerable <TSource> второй, IEqualityComparer <TSource> Comparer)
  • публичный статический IEnumerable <TResult> Join <TOuter, TInner, TKey, TResult> (этот IEnumerable <TOuter> внешний, IEnumerable <TInner> внутренний, Func <TOuter, TKey> внешнийKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, TInner, TResult> resultSelector)
  • публичный статический IEnumerable <TResult> Join <TOuter, TInner, TKey, TResult> (этот IEnumerable <TOuter> внешний, IEnumerable <TInner> внутренний, Func <TOuter, TKey> внешнийKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, TInner, TResult> resultSelector, IEqualityComparer <TKey> Comparer)
  • public static TSource Last <TSource> (этот источник IEnumerable <TSource>)
  • public static TSource Last <TSource> (этот источник IEnumerable <TSource>, предикат Func <TSource, Boolean>)
  • public static TSource LastOrDefault <TSource> (этот источник IEnumerable <TSource>)
  • public static TSource LastOrDefault <TSource> (этот источник IEnumerable <TSource>, предикат Func <TSource, Boolean>)
  • public static Int64 LongCount <TSource> (этот источник IEnumerable <TSource>)
  • public static Int64 LongCount <TSource> (этот источник IEnumerable <TSource>, предикат Func <TSource, Boolean>)
  • public static Decimal Max (этот источник IEnumerable <Decimal>)
  • public static Double Max (этот источник IEnumerable <Double>)
  • public static Int32 Max (этот источник IEnumerable <Int32>)
  • public static Int64 Max (этот источник IEnumerable <Int64>)
  • public static Nullable <Decimal> Max (этот IEnumerable <Nullable <Decimal >> source)
  • public static Nullable <Double> Max (этот IEnumerable <Nullable <Double >> источник)
  • public static Nullable <Int32> Max (этот IEnumerable <Nullable <Int32 >> source)
  • public static Nullable <Int64> Max (этот IEnumerable <Nullable <Int64 >> источник)
  • public static Nullable <Single> Max (этот IEnumerable <Nullable <Single >> source)
  • public static Single Max (этот IEnumerable <Single> source)
  • public static TSource Max <TSource> (этот источник IEnumerable <TSource>)
  • public static Decimal Max <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Decimal>)
  • public static Double Max <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Double>)
  • public static Int32 Max <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Int32>)
  • public static Int64 Max <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Int64>)
  • public static Nullable <Decimal> Max <TSource> (этот источник IEnumerable <TSource>, Func <TSource, Nullable <Decimal >> selector)
  • public static Nullable <Double> Max <TSource> (этот источник IEnumerable <TSource>, Func <TSource, Nullable <Double >> selector)
  • public static Nullable <Int32> Max <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Nullable <Int32 >>)
  • public static Nullable <Int64> Max <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Nullable <Int64 >>)
  • public static Nullable <Single> Max <TSource> (этот источник IEnumerable <TSource>, Func <TSource, Nullable <Single >> selector))
  • public static Single Max <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Single>)
  • public static TResult Max <TSource, TResult> (этот источник IEnumerable <TSource>, селектор Func <TSource, TResult>)
  • public static Decimal Min (этот IEnumerable <Decimal> source)
  • public static Double Min (этот источник IEnumerable <Double>)
  • public static Int32 Min (этот источник IEnumerable <Int32>)
  • public static Int64 Min (этот источник IEnumerable <Int64>)
  • public static Nullable <Decimal> Min (этот IEnumerable <Nullable <Decimal >> source)
  • public static Nullable <Double> Min (этот IEnumerable <Nullable <Double >> source)
  • public static Nullable <Int32> Min (этот IEnumerable <Nullable <Int32 >> source)
  • public static Nullable <Int64> Min (этот IEnumerable <Nullable <Int64 >> source)
  • public static Nullable <Single> Min (этот IEnumerable <Nullable <Single >> source)
  • public static Single Min (этот IEnumerable <Single> source)
  • public static TSource Min <TSource> (этот источник IEnumerable <TSource>)
  • public static Decimal Min <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, десятичный>)
  • public static Double Min <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Double>)
  • public static Int32 Min <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Int32>)
  • public static Int64 Min <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Int64>)
  • public static Nullable <Decimal> Min <TSource> (этот источник IEnumerable <TSource>, Func <TSource, Nullable <Decimal >> selector)
  • public static Nullable <Double> Min <TSource> (этот источник IEnumerable <TSource>, Func <TSource, Nullable <Double >> selector)
  • public static Nullable <Int32> Min <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Nullable <Int32 >>)
  • public static Nullable <Int64> Min <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Nullable <Int64 >>)
  • public static Nullable <Single> Min <TSource> (этот источник IEnumerable <TSource>, Func <TSource, Nullable <Single >> selector))
  • public static Single Min <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Single>)
  • public static TResult Min <TSource, TResult> (этот источник IEnumerable <TSource>, селектор Func <TSource, TResult>)
  • public static IEnumerable <TResult> OfType <TResult> (этот источник IEnumerable)
  • public static IOrderedEnumerable <TSource> OrderBy <TSource, TKey> (этот источник IEnumerable <TSource>, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> OrderBy <TSource, TKey> (этот источник IEnumerable <TSource>, Func <TSource, TKey> keySelector, IComparer <TKey> Comparer)
  • public static IOrderedEnumerable <TSource> OrderByDescending <TSource, TKey> (этот источник IEnumerable <TSource>, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> OrderByDescending <TSource, TKey> (этот источник IEnumerable <TSource>, Func <TSource, TKey> keySelector, IComparer <TKey> Comparer)
  • public static IEnumerable <Int32> Range (Int32 start, Int32 count)
  • public static IEnumerable <TResult> Repeat <TResult> (элемент TResult, число Int32)
  • public static IEnumerable <TSource> Обратный <TSource> (этот источник IEnumerable <TSource>)
  • public static IEnumerable <TResult> Выберите <TSource, TResult> (этот источник IEnumerable <TSource>, селектор Func <TSource, TResult>)
  • public static IEnumerable <TResult> Выберите <TSource, TResult> (этот источник IEnumerable <TSource>, селектор Func <TSource, Int32, TResult>)
  • public static IEnumerable <TResult> SelectMany <TSource, TResult> (этот источник IEnumerable <TSource>, селектор Func <TSource, IEnumerable <TResult >>)
  • public static IEnumerable <TResult> SelectMany <TSource, TResult> (этот источник IEnumerable <TSource>, Func <TSource, Int32, IEnumerable <селектор TResult >>)
  • public static IEnumerable <TResult> SelectMany <TSource, TCollection, TResult> (этот источник IEnumerable <TSource>, Func <TSource, IEnumerable <TCollection >> collectionSelector, Func <TSource, TCollection, TResult> resultSelector)
  • public static IEnumerable <TResult> SelectMany <TSource, TCollection, TResult> (этот источник IEnumerable <TSource>, Func <TSource, Int32, IEnumerable <TCollection >> collectionSelector, Func <TSource, TCollection, TResult> resultSelector)
  • public static Boolean SequenceEqual <TSource> (этот IEnumerable <TSource> сначала, IEnumerable <TSource> второй)
  • public static Boolean SequenceEqual <TSource> (этот IEnumerable <TSource> сначала, IEnumerable <TSource> второй, IEqualityComparer <TSource> Comparer)
  • public static TSource Single <TSource> (этот источник IEnumerable <TSource>)
  • public static TSource Single <TSource> (этот источник IEnumerable <TSource>, предикат Func <TSource, Boolean>)
  • public static TSource SingleOrDefault <TSource> (этот источник IEnumerable <TSource>)
  • public static TSource SingleOrDefault <TSource> (этот источник IEnumerable <TSource>, предикат Func <TSource, Boolean>)
  • public static IEnumerable <TSource> Пропустить <TSource> (этот источник IEnumerable <TSource>, количество Int32)
  • public static IEnumerable <TSource> SkipWhile <TSource> (этот источник IEnumerable <TSource>, предикат Func <TSource, Boolean>)
  • public static IEnumerable <TSource> SkipWhile <TSource> (этот источник IEnumerable <TSource>, предикат Func <TSource, Int32, Boolean>)
  • public static Decimal Sum (этот IEnumerable <десятичный> источник)
  • public static Double Sum (этот IEnumerable <Double> source)
  • public static Int32 Sum (этот источник IEnumerable <Int32>)
  • public static Int64 Sum (этот источник IEnumerable <Int64>)
  • public static Nullable <Decimal> Sum (этот IEnumerable <Nullable <Decimal >> source)
  • public static Nullable <Double> Sum (этот IEnumerable <Nullable <Double >> источник)
  • public static Nullable <Int32> Sum (этот IEnumerable <Nullable <Int32 >> source)
  • public static Nullable <Int64> Sum (этот IEnumerable <Nullable <Int64 >> источник)
  • public static Nullable <Single> Sum (этот IEnumerable <Nullable <Single >> source)
  • public static Single Sum (этот IEnumerable <Single> source)
  • public static Decimal Sum <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Decimal>)
  • public static Double Sum <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Double>)
  • public static Int32 Sum <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Int32>)
  • public static Int64 Sum <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Int64>)
  • public static Nullable <Decimal> Sum <TSource> (этот источник IEnumerable <TSource>, Func <TSource, Nullable <Decimal >> selector)
  • public static Nullable <Double> Sum <TSource> (этот источник IEnumerable <TSource>, Func <TSource, Nullable <Double >> selector)
  • public static Nullable <Int32> Sum <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Nullable <Int32 >>)
  • public static Nullable <Int64> Sum <TSource> (этот источник IEnumerable <TSource>, Func <TSource, Nullable <Int64 >> селектор)
  • public static Nullable <Single> Sum <TSource> (этот источник IEnumerable <TSource>, Func <TSource, Nullable <Single >> selector)
  • public static Single Sum <TSource> (этот источник IEnumerable <TSource>, селектор Func <TSource, Single>)
  • public static IEnumerable <TSource> Возьмите <TSource> (этот источник IEnumerable <TSource>, количество Int32)
  • public static IEnumerable <TSource> TakeWhile <TSource> (этот источник IEnumerable <TSource>, предикат Func <TSource, Boolean>)
  • public static IEnumerable <TSource> TakeWhile <TSource> (этот источник IEnumerable <TSource>, предикат Func <TSource, Int32, Boolean>)
  • public static IOrderedEnumerable <TSource> ThenBy <TSource, TKey> (этот источник IOrderedEnumerable <TSource>, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> ThenBy <TSource, TKey> (этот источник IOrderedEnumerable <TSource>, Func <TSource, TKey> keySelector, IComparer <TKey> Comparer)
  • public static IOrderedEnumerable <TSource> ThenByDescending <TSource, TKey> (этот источник IOrderedEnumerable <TSource>, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> ThenByDescending <TSource, TKey> (этот источник IOrderedEnumerable <TSource>, Func <TSource, TKey> keySelector, IComparer <TKey> comparer)
  • public static TSource [] ToArray <TSource> (этот источник IEnumerable <TSource>)
  • public static Dictionary <TKey, TSource> ToDictionary <TSource, TKey> (этот источник IEnumerable <TSource>, Func <TSource, TKey> keySelector)
  • публичный статический словарь <TKey, TSource> ToDictionary <TSource, TKey> (этот источник IEnumerable <TSource>, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> Comparer)
  • публичный статический словарь <TKey, TElement> ToDictionary <TSource, TKey, TElement> (этот источник IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • публичный статический словарь <TKey, TElement> ToDictionary <TSource, TKey, TElement> (этот источник IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> Comparer)
  • public static List <TSource> ToList <TSource> (этот источник IEnumerable <TSource>)
  • public static ILookup <TKey, TSource> ToLookup <TSource, TKey> (этот источник IEnumerable <TSource>, Func <TSource, TKey> keySelector)
  • public static ILookup <TKey, TSource> ToLookup <TSource, TKey> (этот источник IEnumerable <TSource>, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> Comparer)
  • public static ILookup <TKey, TElement> ToLookup <TSource, TKey, TElement> (этот источник IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • публичный статический ILookup <TKey, TElement> ToLookup <TSource, TKey, TElement> (этот источник IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> comparer)
  • public static IEnumerable <TSource> Union <TSource> (этот IEnumerable <TSource> сначала, IEnumerable <TSource> второй)
  • public static IEnumerable <TSource> Union <TSource> (этот IEnumerable <TSource> во-первых, IEnumerable <TSource> второй, IEqualityComparer <TSource> Comparer)
  • public static IEnumerable <TSource> Где <TSource> (этот источник IEnumerable <TSource>, предикат Func <TSource, Boolean>)
  • public static IEnumerable <TSource> Где <TSource> (этот источник IEnumerable <TSource>, предикат Func <TSource, Int32, Boolean>)
  • public static IEnumerable <TResult> Zip <TFirst, TSecond, TResult> (этот IEnumerable <TFirst> сначала, IEnumerable <TSecond> второй, Func <TFirst, TSecond, TResult> resultSelector)

замечания

  • См. Также LINQ .

Встроенные методы LINQ - это методы расширения для интерфейса IEnumerable<T> которые живут в классе System.Linq.Enumerable в сборке System.Core . Они доступны в .NET Framework 3.5 и более поздних версиях.

LINQ позволяет просто изменять, преобразовывать и комбинировать различные IEnumerable с использованием запроса или функционального синтаксиса.

Хотя стандартные методы LINQ могут работать с любым IEnumerable<T> , включая простые массивы и List<T> s, их также можно использовать для объектов базы данных, где множество выражений LINQ во многих случаях может быть преобразовано в SQL, если объект данных поддерживает его. См. LINQ to SQL .

Для методов, которые сравнивают объекты (такие как Contains и Except ), IEquatable<T>.Equals используется, если тип T коллекции реализует этот интерфейс. В противном случае используются стандартные Equals и GetHashCode типа (возможно, переопределенные из реализаций Object по умолчанию). Существуют также перегрузки для этих методов, которые позволяют указать пользовательский IEqualityComparer<T> .

Для методов ...OrDefault default(T) используется для создания значений по умолчанию.

Официальная ссылка: Перечислимый класс

Ленивая оценка

Практически каждый запрос, возвращающий IEnumerable<T> , сразу не оценивается; вместо этого логика задерживается до тех пор, пока запрос не будет повторен. Одним из следствий является то, что каждый раз, когда кто-то выполняет итерацию над IEnumerable<T> созданным с помощью одного из этих запросов, например, .Where() , повторяется полная логика запроса. Если предикат длительный, это может быть причиной проблем с производительностью.

Одно простое решение (когда вы знаете или можете контролировать приблизительный размер результирующей последовательности) состоит в том, чтобы полностью .ToArray() результаты с использованием .ToArray() или .ToList() . .ToDictionary() или .ToLookup() могут выполнять ту же роль. Можно также, конечно, перебрать всю последовательность и буферизировать элементы в соответствии с другой пользовательской логикой.

ToArray() или ToList() ?

Оба .ToArray() и .ToList() все элементы последовательности IEnumerable<T> и сохраняют результаты в коллекции, хранящейся в памяти. Используйте следующие рекомендации, чтобы определить, какой из них выбрать:

  • Для некоторых API может потребоваться T[] или List<T> .
  • .ToList() обычно работает быстрее и генерирует меньше мусора, чем .ToArray() , потому что последний должен копировать все элементы в новую коллекцию фиксированного размера еще раз, чем первый, почти в каждом случае.
  • Элементы могут быть добавлены или удалены из List<T> возвращаемого .ToList() , тогда как T[] возвращаемый из .ToArray() остается фиксированным размером на протяжении всего его жизненного .ToArray() . Другими словами, List<T> является изменяемым, а T[] является неизменным.
  • T[] возвращаемый из .ToArray() использует меньше памяти, чем List<T> возвращаемый из .ToList() , поэтому, если результат будет храниться в течение длительного времени, предпочитайте .ToArray() . Calling List<T>.TrimExcess() сделает разницу в памяти строго академической ценой за счет исключения относительного преимущества скорости .ToList() .

Выбрать (карта)

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

Этот тип функции обычно называется map в языках функционального программирования.

Где (фильтр)

Этот метод возвращает IEnumerable со всеми элементами, которые соответствуют выражению лямбда

пример 

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

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

Выход:

Foo, Fizz

Посмотреть демо

Сортировать по

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

Содержит

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

Кроме

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

пересекаться

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

Обратите внимание, что дубликаты сохраняются в результате. Если это нежелательно, используйте Union .

Сначала (найти)

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

Следующие InvalidOperationException с сообщением «Последовательность не содержит соответствующего элемента»: 

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

не замужем

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

Следующий InvalidOperationException вызывает InvalidOperationException поскольку в последовательности содержится более одного элемента: 

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

Прошлой

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

Следующие 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

Следующие 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

любой

Возвращает true если в коллекции есть элементы, которые удовлетворяют условию в выражении лямбда: 

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

Все

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

Обратите внимание, что функция « All работает, проверяя, что первый элемент оценивается как false соответствии с предикатом. Следовательно, метод вернет true для любого предиката в случае, когда множество пусто: 

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

SelectMany (плоская карта)

Enumerable.Select возвращает выходной элемент для каждого элемента ввода. В то время как Enumerable.SelectMany производит переменное количество выходных элементов для каждого элемента ввода. Это означает, что выходная последовательность может содержать больше или меньше элементов, чем во входной последовательности.

Lambda expressions передаются в Enumerable.Select должны возвращать один элемент. Лямбда-выражения передаются в Enumerable.SelectMany должны генерировать дочернюю последовательность. Эта дочерняя последовательность может содержать различное количество элементов для каждого элемента во входной последовательности.

пример 

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

Выход:

1,2,3,4,5,6

Посмотреть демо

Enumerable.SelectMany также может быть достигнут с помощью синтаксического запроса, используя два последовательных from предложений: 

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

сумма

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

Пропускать

Skip будет перечислять первые N элементов, не возвращая их. Как только номер позиции N + 1 достигнут, Skip начинает возвращать каждый перечислимый элемент: 

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

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

//3,4,5

принимать

Этот метод берет первые n элементов из перечислимого. 

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

Задний ход

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

Максимум

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

Средний

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

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

Этот метод вычисляет среднее число перечислимых чисел. 

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

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

Этот метод вычисляет среднее значение перечислимого с помощью делегированной функции.

застежка-молния

.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

отчетливый

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

Группа по

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

Групповые счета по странам, генерирующие новый объект с количеством записей, общей оплатой и средней оплатой 

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

Если мы хотим только итоговые суммы, ни одна группа 

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

Если нам нужно несколько подсчетов 

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

Возвращает новый словарь из исходного IEnumerable используя предоставленную функцию keySelector для определения ключей. Выбросит ArgumentException если keySelector не является инъективным (возвращает уникальное значение для каждого члена исходной коллекции). Существуют перегрузки, которые позволяют указывать значение, которое нужно сохранить, а также ключ. 

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

Указание только функции выбора ключа создаст Dictionary<TKey,TVal> с TKey return Тип селектора клавиш, TVal - исходный тип объекта, а исходный объект - как сохраненное значение. 

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

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

Указание функции селектора значений также приведет к созданию Dictionary<TKey,TVal> когда TKey прежнему является типом возврата селектора клавиш, но TVal теперь возвращает тип функции выбора значения и возвращаемое значение в качестве хранимого значения. 

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

Как указано выше, ключи, возвращаемые селектором ключей, должны быть уникальными. Следующее выдает исключение. 

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)

Если уникальный уникальный ключ не может быть предоставлен для исходной коллекции, попробуйте вместо этого использовать ToLookup. На первый взгляд, ToLookup ведет себя аналогично ToDictionary, однако в полученном Lookup каждый ключ сопряжен с набором значений с соответствующими ключами.

союз

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

Обратите внимание, что дубликаты удаляются из результата. Если это нежелательно, используйте 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[]

К списку

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

подсчитывать

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

Совокупный (складной)

Создание нового объекта на каждом шаге: 

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,

Использование одного и того же объекта на всех этапах: 

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

Использование селектора результатов: 

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,

Если семя опущено, первым элементом становится семя: 

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

Присоединиться

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

В ролях

Cast отличается от других методов Enumerable тем, что это метод расширения для IEnumerable , а не для IEnumerable<T> . Таким образом, его можно использовать для преобразования экземпляров первого в экземпляры позже.

Это не компилируется, поскольку ArrayList не реализует IEnumerable<T> : 

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

Это работает так, как ожидалось: 

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

Cast не выполняет преобразования. Следующие компиляции, но InvalidCastException во время выполнения: 

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

Правильный способ преобразования конвертирования в коллекцию выглядит следующим образом: 

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

пустой

Чтобы создать пустой IEnumerable из int: 

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

Этот пустой IEnumerable кэшируется для каждого типа T, так что: 

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

ThenBy

ThenBy может использоваться только после предложения OrderBy , позволяющего заказать несколько критериев 

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

Спектр

Два параметра Range - это первое число и количество элементов для создания (а не последнее число). 

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

Левая внешняя связь

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

Повторение

Enumerable.Repeat генерирует последовательность повторяющегося значения. В этом примере он генерирует «Привет» 4 раза. 

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
Лицензировано согласно CC BY-SA 3.0
Не связан с Stack Overflow