.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 시드, Func <TAccumulate, TSource, TAccumulate> 함수)
  • public static TResult Aggregate <TSource, TAccumulate, TResult> (이 IEnumerable <TSource> 소스, TAccumulate 시드, Func <TAccumulate, TSource, TAccumulate> 함수, Func <TAccumulate, TResult> resultSelector)
  • public static Boolean 모두 <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, 부울> 조건 자)
  • public static Boolean Any <TSource> (이 IEnumerable <TSource> 소스)
  • public static Boolean 모든 <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, 부울> 조건 자)
  • public static IEnumerable <TSource> AsEnumerable <TSource> (이 IEnumerable <TSource> 소스)
  • public static Decimal Average (이 IEnumerable <Decimal> 소스)
  • 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 >> 원본)
  • public static Nullable <Double> Average (이 IEnumerable <Nullable <Double >> 소스)
  • public static Nullable <Double> Average (이 IEnumerable <Nullable <Int32 >> 소스)
  • public static Nullable <Double> Average (이 IEnumerable <Nullable <Int64 >> 소스)
  • public static Nullable <Single> Average (이 IEnumerable <Nullable <Single >> 원본)
  • public static Single Average (이 IEnumerable <Single> 소스)
  • public static Decimal Average <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Decimal> 선택기)
  • public static Double Average <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Double> 선택기)
  • 공공 정적 Double 평균 <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> Average <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Nullable <Int32 >> selector)
  • public static Nullable <Double> 평균 <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Nullable <Int64 >> selector)
  • public static Nullable <Single> Average <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Nullable <Single >> selector)
  • public static Single Average <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Single> selector)
  • public static IEnumerable <TResult> 캐스트 <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, 부울> 조건 자)
  • public static IEnumerable <TSource> DefaultIfEmpty <TSource> (이 IEnumerable <TSource> 소스)
  • public static IEnumerable <TSource> DefaultIfEmpty <TSource> (이 IEnumerable <TSource> 소스, TSource defaultValue)
  • public static IEnumerable <TSource> 고유 한 <TSource> (이 IEnumerable <TSource> 소스)
  • public static IEnumerable <TSource> 고유 한 <TSource> (이 IEnumerable <TSource> 소스, IEqualityComparer <TSource> 비교 자)
  • public static TSource ElementAt <TSource> (이 IEnumerable <TSource> 소스, Int32 인덱스)
  • public static TSource ElementAtOrDefault <TSource> (이 IEnumerable <TSource> 소스, Int32 인덱스)
  • 공공 정적 IEnumerable <TResult> 빈 <TResult> ()
  • public static IEnumerable <TSource> <TSource>를 제외 (이 IEnumerable <TSource>가 먼저, IEnumerable <TSource>가 second)
  • public static IEnumerable <TSource> <TSource>를 제외 (이 IEnumerable <TSource>가 먼저, IEnumerable <TSource>가 두 번째, IEqualityComparer <TSource>가 comparer)
  • public static TSource 첫 번째 <TSource> (이 IEnumerable <TSource> 소스)
  • public static TSource 첫 번째 <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, 부울> 조건 자)
  • public static TSource FirstOrDefault <TSource> (이 IEnumerable <TSource> 소스)
  • public static TSource FirstOrDefault <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Boolean> 조건 자)
  • public static IEnumerable <IGKeying <TKey, TSource >> GroupBy <TSource, TKey> (이 IEnumerable <TSource> 소스, Func <TSource, TKey> keySelector)
  • public static IEnumerable <IGKeying <TKey, TSource >> GroupBy <TSource, TKey> (이 IEnumerable <TSource> 소스, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> 비교 자)
  • public IEnumerable <IGrouping <TKey, TElement >> GroupBy <TSource, TKey, TElement> (이 IEnumerable <TSource> 소스, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • 이 IEnumerable <TSource> 소스, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> comparer) 공용 정적 IEnumerable <IGrouping <TKey, TElement >> GroupBy <TSource, TKey, TElement>
  • public IEnumerable <TResult> GroupBy <TSource, TKey, TResult> (이 IEnumerable <TSource> 소스, Func <TSource, TKey> 키 셀렉터, Func <TKey, IEnumerable <TSource>, TResult> resultSelector)
  • 이 IEnumerable <TSource> 소스, Func <TSource, TKey> keySelector, Func <TKey, IEnumerable <TSource>, TResult> resultSelector, IEqualityComparer <TKey> comparer) 공용 정적 IEnumerable <TResult> GroupBy <TSource, TKey, TResult>
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TElement, TResult> (이 IEnumerable <TSource> 소스, Func <TSource, TKey> 키 셀렉터, Func <TSource, TElement> 요소 셀렉터, Func <TKey, IEnumerable <TElement>, TResult > resultSelector)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TElement, TResult> (이 IEnumerable <TSource> 소스, Func <TSource, TKey> 키 셀렉터, Func <TSource, TElement> 요소 셀렉터, Func <TKey, IEnumerable <TElement>, TResult > resultSelector, IEqualityComparer <TKey> 비교 자)
  • public static IEnumerable <TResult> GroupJoin <TOuter, TInner, TKey, TResult> (이 IEnumerable <TOuter> 외부, IEnumerable <내부 IEnumerable, 내부 키, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> 내부 키 선택기, Func <TOuter, IEnumerable <TInner>, TResult> resultSelector)
  • public static IEnumerable <TResult> GroupJoin <TOuter, TInner, TKey, TResult> (이 IEnumerable <TOuter> 외부, IEnumerable <내부 IEnumerable, 내부 키, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> 내부 키 선택기, 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> first, IEnumerable <TSource> second, IEqualityComparer <TSource> comparer)
  • public static IEnumerable <TResult> innerKeySelector, Func <TOuter, TKey, TResult> (이 IEnumerable <TOuter> 아우터, IEnumerable <TInner> 내부, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> TInner, TResult> resultSelector)
  • public static IEnumerable <TResult> innerKeySelector, Func <TOuter, TKey, TResult> (이 IEnumerable <TOuter> 아우터, IEnumerable <TInner> 내부, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> TInner, TResult> resultSelector, IEqualityComparer <TKey> 비교 자)
  • public static TSource 마지막 <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 >> 원본)
  • public static Nullable <Double> Max (이 IEnumerable <Nullable <Double >> 소스)
  • public static Nullable <Int32> Max (이 IEnumerable <Nullable <Int32 >> 소스)
  • public static Nullable <Int64> Max (이 IEnumerable <Nullable <Int64 >> 소스)
  • public static Nullable <Single> Max (이 IEnumerable <Nullable <Single >> 소스)
  • public static Single Max (이 IEnumerable <Single> 소스)
  • public static TSource Max <TSource> (이 IEnumerable <TSource> 소스)
  • public static Decimal Max <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Decimal> selector)
  • 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 >> selector)
  • public static Nullable <Int64> Max <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Nullable <Int64 >> selector)
  • public static Nullable <Single> Max <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Nullable <Single >> selector)
  • public static Single Max <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Single> selector)
  • public static TResult Max <TSource, TResult> (이 IEnumerable <TSource> 소스, Func <TSource, TResult> selector)
  • 공공 정적 Decimal Min (IEnumerable <Decimal> 소스)
  • 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 >> 원본)
  • public static Nullable <Double> Min (이 IEnumerable <Nullable <Double >> 소스)
  • public static Nullable <Int32> Min (이 IEnumerable <Nullable <Int32 >> 소스)
  • public static Nullable <Int64> Min (이 IEnumerable <Nullable <Int64 >> 소스)
  • public static Nullable <Single> Min (이 IEnumerable <Nullable <Single >> 소스)
  • public static Single Min (이 IEnumerable <Single> 소스)
  • public static TSource Min <TSource> (이 IEnumerable <TSource> 소스)
  • public static Decimal Min <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Decimal> 선택기)
  • 공용 정적 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 >> selector)
  • public static Nullable <Int64> Min <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Nullable <Int64 >> selector)
  • public static Nullable <Single> Min <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Nullable <Single >> selector)
  • public static Single Min <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Single> selector)
  • public static TResult Min <TSource, TResult> (이 IEnumerable <TSource> 소스, Func <TSource, TResult> selector)
  • 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> 비교 자)
  • 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> 비교 자)
  • 공용 정적 IEnumerable <Int32> 범위 (Int32 시작, Int32 개수)
  • public static IEnumerable <TResult> 반복 <TResult> (TResult 요소, Int32 개수)
  • public static IEnumerable <TSource> Reverse <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> selector)를 선택합니다.
  • public static IEnumerable <TResult> SelectMany <TSource, TResult> (이 IEnumerable <TSource> 소스, Func <TSource, IEnumerable <TResult >> selector)
  • public static IEnumerable <TResult> SelectMany <TSource, TResult> (이 IEnumerable <TSource> 소스, Func <TSource, Int32, IEnumerable <TResult >> selector)
  • public static IEnumerable <TResult> SelectMany <TSource, TCollection, TResult> (이 IEnumerable <TSource> 소스, Func <TSource, IEnumerable <TCollection >> 컬렉션 셀렉터, Func <TSource, TCollection, TResult> resultSelector)
  • public static IEnumerable <TResult> SelectMany <TSource, TCollection, TResult> (이 IEnumerable <TSource> 소스, Func <TSource, Int32, IEnumerable <TCollection >> 컬렉션 셀렉터, Func <TSource, TCollection, TResult> resultSelector)
  • public static Boolean SequenceEqual <TSource> (이 IEnumerable <TSource> first, IEnumerable <TSource> second)
  • public static Boolean SequenceEqual <TSource> (이 IEnumerable <TSource> 첫 번째, IEnumerable <TSource> 초, IEqualityComparer <TSource> 비교 자)
  • public static TSource Single <TSource> (이 IEnumerable <TSource> 소스)
  • public static TSource 단일 <TSource> (이 IEnumerable <TSource> 원본, Func <TSource, 부울> 조건 자)
  • public static TSource SingleOrDefault <TSource> (이 IEnumerable <TSource> 소스)
  • public static TSource SingleOrDefault <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Boolean> 조건 자)
  • public static IEnumerable <TSource> Skip <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 <Decimal> 소스)
  • public static Double Sum (이 IEnumerable <Double> 소스)
  • 공용 정적 Int32 Sum (이 IEnumerable <Int32> 소스)
  • public static Int64 Sum (이 IEnumerable <Int64> 소스)
  • public static Nullable <Decimal> Sum (이 IEnumerable <Nullable <Decimal >> 원본)
  • public static Nullable <Double> Sum (이 IEnumerable <Nullable <Double >> 소스)
  • public static Nullable <Int32> Sum (이 IEnumerable <Nullable <Int32 >> 소스)
  • public static Nullable <Int64> Sum (이 IEnumerable <Nullable <Int64 >> 소스)
  • public static Nullable <Single> Sum (이 IEnumerable <Nullable <Single >> 원본)
  • public static Single Sum (이 IEnumerable <Single> 소스)
  • 공공 정적 Decimal Sum <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Decimal> selector)
  • public static Double Sum <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Double> 선택기)
  • 공용 static Int32 Sum <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Int32> selector)
  • 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 >> selector)
  • public static Nullable <Int64> Sum <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Nullable <Int64 >> selector)
  • public static Nullable <Single> Sum <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Nullable <Single >> selector)
  • public static Single Sum <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Single> selector)
  • public static IEnumerable <TSource> Take <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> 비교 자)
  • 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> 비교 자)
  • public static TSource [] ToArray <TSource> (이 IEnumerable <TSource> 소스)
  • public static Dictionary <TKey, TSource> ToDictionary <TSource, TKey> (이 IEnumerable <TSource> 소스, Func <TSource, TKey> keySelector)
  • public static Dictionary <TKey, TSource> ToDictionary <TSource, TKey> (이 IEnumerable <TSource> 소스, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> 비교 자)
  • public static Dictionary <TKey, TElement> ToDictionary <TSource, TKey, TElement> (이 IEnumerable <TSource> 소스, Func <TSource, TKey> 키 셀렉터, Func <TSource, TElement> elementSelector)
  • 이 IEnumerable <TSource> 소스, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> 비교 자) 공용 정적 사전 <TKey, TElement>
  • 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> 비교 자)
  • public static ILookup <TKey, TElement> ToLookup <TSource, TKey, TElement> (이 IEnumerable <TSource> 소스, Func <TSource, TKey> 키 셀렉터, Func <TSource, TElement> elementSelector)
  • 이 IEnumerable <TSource> 소스, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> 비교 자) 공용 정적 ILookup <TKey, TElement> ToLookup <TSource, TKey, TElement>
  • public static IEnumerable <TSource> Union <TSource> (이 IEnumerable <TSource>가 먼저, IEnumerable <TSource>가 second)
  • public static IEnumerable <TSource> Union <TSource> (이 IEnumerable <TSource> 첫 번째, IEnumerable <TSource> 초, IEqualityComparer <TSource> 비교 자)
  • public static IEnumerable <TSource> 여기서 <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Boolean> 조건 자)
  • public static IEnumerable <TSource> 여기서 <TSource> (이 IEnumerable <TSource> 소스, Func <TSource, Int32, 부울> 조건 자)
  • public static IEnumerable <TResult> Zip <TFirst, TSecond, TResult> (이 IEnumerable <TFirst> 첫 번째, IEnumerable <TSecond> 초, Func <TFirst, TSecond, TResult> resultSelector)

비고

LINQ 기본 제공 메서드는 System.Core 어셈블리의 System.Linq.Enumerable 클래스에있는 IEnumerable<T> 인터페이스의 확장 메서드입니다. .NET Framework 3.5 이상에서 사용할 수 있습니다.

LINQ를 사용하면 쿼리와 유사한 구문을 사용하여 다양한 IEnumerable 을 간단하게 수정, 변환 및 조합 할 수 있습니다.

표준 LINQ 메서드는 간단한 배열과 List<T> 포함하여 모든 IEnumerable<T> 에서 작동 할 수 있지만 데이터베이스 개체에서도 사용할 수 있습니다. LINQ 식 집합은 많은 경우에 SQL로 변환 될 수 있습니다. 데이터 객체가이를 지원합니다. LINQ to SQL을 참조하십시오.

Contains 및 Except 와 같은 개체를 비교하는 메서드의 경우 컬렉션의 형식 T가 해당 인터페이스를 구현하는 경우 IEquatable<T>.Equals 가 사용됩니다. 그렇지 않은 경우는, 표준의 Equals 와 GetHashCode 가 디폴트의 Object 구현으로부터 오버라이드 (override) 될 가능성이 있습니다. 또한 사용자 정의 IEqualityComparer<T> 를 지정할 수있는 이러한 메소드에 대한 오버로드가 있습니다.

...OrDefault 메서드의 경우 default(T) 이 기본값을 생성하는 데 사용됩니다.

공식 참조 : 열거 가능한 클래스

게으른 평가

사실 IEnumerable<T> 를 반환하는 모든 쿼리는 즉시 평가되지 않습니다. 대신 쿼리가 반복 될 때까지 로직이 지연됩니다. 한 가지 의미는 누군가가 이러한 쿼리 중 하나 .Where() 예 : .Where() 에서 생성 된 IEnumerable<T> 반복 할 때마다 전체 쿼리 논리가 반복된다는 것입니다. 술어가 장기 실행되면 이것은 성능. 제의 원인이 될 수 있습니다.

하나의 간단한 솔루션 (결과 시퀀스의 대략적인 크기를 알고 있거나 제어 할 수있는 경우)은 .ToArray() 또는 .ToList() 사용하여 결과를 완전히 버퍼링하는 것입니다. .ToDictionary() 또는 .ToLookup() 같은 역할을 수행 할 수 있습니다. 물론 전체 시퀀스를 반복하고 다른 사용자 지정 논리에 따라 요소를 버퍼링 할 수도 있습니다.

ToArray() 또는 ToList() ?

.ToArray() 및 .ToList() 는 IEnumerable<T> 시퀀스의 모든 요소를 ​​반복하고 결과를 메모리에 저장된 컬렉션에 저장합니다. 선택할 지침을 결정하려면 다음 지침을 따르십시오.

  • 일부 API에는 T[] 또는 List<T> 가 필요할 수 있습니다.
  • .ToList() 대개 더 빠르게 실행되고 .ToArray() 보다 더 적은 쓰레기를 생성합니다. 왜냐하면 후자는 거의 모든 경우에 전자보다 한 번 더 새로운 고정 크기의 컬렉션에 모든 요소를 ​​복사해야하기 때문입니다.
  • 요소가 추가 또는 삭제 될 수 List<T> 에 의해 반환 .ToList() , 반면, T[] 로부터 반환 .ToArray() 의 수명에 걸쳐 고정 된 크기가 유지된다. 즉, List<T> 는 변경 가능하고 T[] 는 변경할 수 없습니다.
  • T[] 로부터 반환 .ToArray() 댄 적은 메모리를 사용 List<T> 에서 반환 .ToList() 결과 장시간 동안 저장 될 것 인 경우에 따라서, 선호 .ToArray() . 호출 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));

산출:

푸, 피즈

데모보기

주문

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

콩 카트

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 을 throw 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 이 throw됩니다. 

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 throw 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 throw 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 반환 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 를 반환 true . 

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

SelectMany (평면지도)

Enumerable.Select 는 모든 입력 요소에 대한 출력 요소를 반환합니다. 반면 Enumerable.SelectMany 는 각 입력 요소에 대해 가변 개수의 출력 요소를 생성합니다. 이것은 출력 순서가 입력 순서보다 더 많거나 적은 요소를 포함 할 수 있음을 의미합니다.

Enumerable.Select 전달 된 Lambda expressions 단일 항목을 반환해야합니다. 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

최소

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

GroupBy

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

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

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

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

국가 별 송장을 그룹화하여 기록, 총 지급액 및 평균 지급액으로 새 오브젝트 생성 

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

제공된 keySelector 함수를 사용하여 키를 확인하는 IEnumerable 소스에서 새 사전을 반환합니다. keySelector가 injective가 아닌 경우 (소스 컬렉션의 각 멤버에 대해 고유 한 값을 반환하는 경우) ArgumentException throw합니다. 키와 함께 저장할 값을 지정할 수있는 오버로드가 있습니다. 

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 는 키 선택기의 반환 유형, 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

위에서 설명한 것처럼 키 선택기에서 반환 한 키는 고유해야합니다. 다음은 예외를 throw합니다. 

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

ToList

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

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

var someNumbersList = someNumbers.ToList();

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

카운트

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

요소

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,

찾아보다

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

그룹 조인

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 는 IEnumerable<T> 아닌 IEnumerable 의 확장 메서드라는 점에서 Enumerable 의 다른 메서드와 다릅니다. 따라서 이전 인스턴스를 나중에 인스턴스로 변환하는 데 사용할 수 있습니다.

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

빈

int의 빈 IEnumerable을 만들려면 : 

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

이 빈 IEnumerable은 각 Type T에 대해 캐시되므로 다음과 같습니다. 

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

그 다음에

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 는 반복되는 값의 시퀀스를 생성합니다. 이 예제에서는 "Hello"를 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