.NET Framework
LINQ

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


Introducción

LINQ (Language Integrated Query) es una expresión que recupera datos de un origen de datos. LINQ simplifica esta situación al ofrecer un modelo consistente para trabajar con datos a través de varios tipos de fuentes de datos y formatos. En una consulta LINQ, siempre está trabajando con objetos. Utiliza los mismos patrones de codificación básicos para consultar y transformar datos en documentos XML, bases de datos SQL, conjuntos de datos ADO.NET, colecciones .NET y cualquier otro formato para el que un proveedor esté disponible. LINQ se puede utilizar en C # y VB.

Sintaxis

  • agregación estática pública de TSource <TSource> (esta fuente IEnumerable <TSource>, Func <TSource, TSource, TSource> func)
  • agregación estática pública TAccumulate <TSource, TAccumulate> (esta fuente IEnumerable <TSource>, TAccumulate seed, Func <TAccumulate, TSource, TAccumulate> func)
  • agregación estática pública de TResult <TSource, TAccumulate, TResult> (esta fuente IEnumerable <TSource>, fuente de TAccumulate, Func <TAccumulate, TSource, TAccumulate> func, Func <TAccumulate, TResult> resultadoSelector)
  • Public static Boolean All <TSource> (este IEnumerable <TSource> source, Func <TSource, Boolean> predicate)
  • Public static Boolean Any <TSource> (esta fuente IEnumerable <TSource>)
  • Public static Boolean Any <TSource> (este IEnumerable <TSource> source, Func <TSource, Boolean> predicate)
  • IEnumerable estático público <TSource> AsEnumerable <TSource> (esta fuente <TSource> IEnumerable)
  • Promedio Decimal estático público (esta fuente <Decimal> IEnumerable)
  • Promedio doble estático público (esta fuente <Double> de IEnumerable)
  • Promedio público doble estático (esta fuente IEnumerable <Int32>)
  • Promedio público doble estático (esta fuente IEnumerable <Int64>)
  • Promedio público nullable <Decimal> (este IEnumerable <Nullable <Decimal>> fuente)
  • Nullable estático público <Double> Promedio (este IEnumerable <Nullable <Double>> fuente)
  • Nullable estático público <Double> Promedio (este IEnumerable <Nullable <Int32>> fuente)
  • Nullable estático público <Double> Promedio (este IEnumerable <Nullable <Int64>> fuente)
  • Nullable estático público <Single> Promedio (este IEnumerable <Nullable <Single>> fuente)
  • Promedio único estático público (esta fuente <Single> de IEnumerable)
  • Promedio Decimal estático público <TSource> (este IEnumerable <TSource> source, Func <TSource, Decimal> selector)
  • Promedio público doble estático <TSource> (esta fuente IEnumerable <TSource>, Func <TSource, Double> selector)
  • Promedio público doble estático <TSource> (este IEnumerable <TSource> fuente, Func <TSource, Int32> selector)
  • Promedio público doble estático <TSource> (este IEnumerable <TSource> fuente, Func <TSource, Int64> selector)
  • Nullable estático público <Decimal> Promedio <TSource> (este IEnumerable <TSource> fuente, Func <TSource, Nullable <Decimal>> selector)
  • Nullable estático público <Double> Promedio <TSource> (este IEnumerable <TSource> fuente, Func <TSource, Nullable <Double>> selector)
  • Nullable estático público <Double> Promedio <TSource> (este IEnumerable <TSource> fuente, Func <TSource, Nullable <Int32>> selector)
  • Nullable estático público <Double> Promedio <TSource> (este IEnumerable <TSource> fuente, Func <TSource, Nullable <Int64>> selector)
  • Nullable estático público <Single> Promedio <TSource> (este IEnumerable <TSource> fuente, Func <TSource, Nullable <Single>> selector)
  • Promedio único público estático <TSource> (este IEnumerable <TSource> fuente, Func <TSource, Single> selector)
  • Public static IEnumerable <TResult> Cast <TResult> (esta fuente IEnumerable)
  • pública <Entrada> ITenumo> Concat <Toma> (este <EnTienda <Entrada> IEnumerable <Testidad> en segundo lugar)
  • public static Boolean Contiene <TSource> (esta fuente IEnumerable <TSource>, valor de TSource)
  • public static Boolean Contiene <TSource> (este IEnumerable <TSource> fuente, TSource valor, IEqualityComparer <TSource> comparador)
  • cuenta estática pública Int32 <TSource> (esta fuente IEnumerable <TSource>)
  • cuenta estática pública Int32 Count <TSource> (esta fuente IEnumerable <TSource>, Func <TSource, Boolean> predicate)
  • Public static IEnumerable <TSource> DefaultIfEmpty <TSource> (esta fuente IEnumerable <TSource>)
  • public static IEnumerable <TSource> DefaultIfEmpty <TSource> (esta fuente IEnumerable <TSource>, TSource defaultValue)
  • Public static IEnumerable <TSource> Distinct <TSource> (esta fuente IEnumerable <TSource>)
  • IEnumerable estático público <TSource> Distintivo <TSource> (este IEnumerable <TSource> fuente, IEqualityComparer <TSource> comparador)
  • TSA estática pública ElementAt <TSource> (esta IEnumerable <TSource> fuente, índice Int32)
  • TSource estático público ElementAtOrDefault <TSource> (este IEnumerable <TSource> fuente, índice Int32)
  • Public static IEnumerable <TResult> Empty <TResult> ()
  • IEnumerable estático público <TSource> Excepto <TSource> (este IEnumerable <TSource> primero, IEnumerable <TSource> segundo)
  • IEnumerable estático público <TSource> Excepto <TSource> (este IEnumerable <TSource> primero, IEnumerable <TSource> segundo, IEqualityComparer <TSource> comparador)
  • fuente estática pública TSource First <TSource> (esta fuente IEnumerable <TSource>)
  • Public static TSource First <TSource> (este IEnumerable <TSource> source, Func <TSource, Boolean> predicate)
  • público estático TSource FirstOrDefault <TSource> (esta fuente IEnumerable <TSource>)
  • public static TSource FirstOrDefault <TSource> (este IEnumerable <TSource> source, Func <TSource, Boolean> predicate)
  • IEnumerable estático público <IGrouping <TKey, TSource >> GroupBy <TSource, TKey> (este IEnumerable <TSource> source, Func <TSource, TKey> keySelector)
  • IEnumerable estático público <IGrouping <TKey, TSource >> GroupBy <TSource, TKey> (este IEnumerable <TSource> fuente, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> comparador)
  • público IEnumerable estático <IGrouping <TKey, TElement >> GroupBy <TSource, TKey, TElement> (esta fuente IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • public static IEnumerable <IGrouping <TKey, TElement >> GroupBy <TSource, TKey, TElement> (esta fuente IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> comparer)
  • público Estática IEnumerable <TResult> GrupoBy <TSource, TKey, TResult> (esta fuente IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TKey, IEnumerable <TSource>, TResult> resultSelector)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TResult> (esta fuente IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TKey, IEnumerable <TSource>, TResult> resultSelector, IEqualityComparer <TKey> comparer)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TElement, TResult> (esta fuente IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <TKey, IEnumerable <TElement>, TResult > resultSelector)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TElement, TResult> (esta fuente IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <TKey, IEnumerable <TElement>, TResult > resultSelector, comparador IEqualityComparer <TKey>)
  • public static IEnumerable <TResult> GroupJoin <TOuter, TInner, TKey, TResult> (este IEnumerable <TOuter> external, IEnumerable <TInner> inner, Func <Touter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <Touter, IEnumerable <TInner>, TResult> resultSelector)
  • public static IEnumerable <TResult> GroupJoin <TOuter, TInner, TKey, TResult> (este IEnumerable <TOuter> external, IEnumerable <TInner> inner, Func <Touter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <Touter, IEnumerable <TInner>, TResult> resultSelector, IEqualityComparer <TKey> comparer)
  • IEnumerable estático público <TSource> Intersect <TSource> (este IEnumerable <TSource> primero, IEnumerable <TSource> segundo)
  • IEnumerable estático público <TSource> Intersect <TSource> (este IEnumerable <TSource> primero, IEnumerable <TSource> segundo, IEqualityComparer <TSource> comparador)
  • public static IEnumerable <TResult> Join <TOuter, TInner, TKey, TResult> (este IEnumerable <TOuter> external, IEnumerable <TInner> inner, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <Touter, TInner, TResult> resultSelector)
  • public static IEnumerable <TResult> Join <TOuter, TInner, TKey, TResult> (este IEnumerable <TOuter> external, IEnumerable <TInner> inner, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <Touter, TInner, TResult> resultSelector, IEqualityComparer <TKey> comparer)
  • Último <TSource> de esta fuente estática pública (esta fuente <TSource> de IEnumerable)
  • Último recurso público de TSource <TSource> (este IEnumerable <TSource> source, Func <TSource, Boolean> predicate)
  • público estático TSource LastOrDefault <TSource> (esta fuente IEnumerable <TSource>)
  • público estático TSource LastOrDefault <TSource> (este IEnumerable <TSource> fuente, Func <TSource, Boolean> predicado)
  • pública estática Int64 LongCount <TSource> (esta fuente IEnumerable <TSource>)
  • pública estática Int64 LongCount <TSource> (esta fuente IEnumerable <TSource>, Func <TSource, Boolean> predicate)
  • Máximo decimal estático público (esta fuente <Decimal> IEnumerable)
  • doble estática pública (esta fuente <Double> de IEnumerable)
  • pública estática Int32 Max (esta fuente IEnumerable <Int32>)
  • pública estática Int64 Max (esta fuente IEnumerable <Int64>)
  • Nullable estática pública <Decimal> Máx (este IEnumerable <Nullable <Decimal>> fuente)
  • Nullable estático público <Double> Max (este IEnumerable <Nullable <Double>> fuente)
  • Nullable estática pública <Int32> Máx (este IEnumerable <Nullable <Int32>> fuente)
  • Nullable estática pública <Int64> Máx (este IEnumerable <Nullable <Int64>> fuente)
  • Nullable estático público <Single> Máx (este IEnumerable <Nullable <Single>> fuente)
  • único estático público (esta fuente <Single> de IEnumerable)
  • public static TSource Max <TSource> (esta fuente IEnumerable <TSource>)
  • public static Decimal Max <TSource> (este IEnumerable <TSource> source, Func <TSource, Decimal> selector)
  • public static Double Max <TSource> (esta fuente IEnumerable <TSource>, Func <TSource, Double> selector)
  • public static Int32 Max <TSource> (esta fuente IEnumerable <TSource>, Func <TSource, Int32> selector)
  • pública estática Int64 Max <TSource> (esta fuente IEnumerable <TSource>, Func <TSource, Int64> selector)
  • pública estática Nullable <Decimal> Max <TSource> (esta fuente IEnumerable <TSource>, Func <TSource, Nullable <Decimal>> selector)
  • pública estática Nullable <Double> Max <TSource> (esta fuente IEnumerable <TSource>, Func <TSource, Nullable <Double>> selector)
  • Public static Nullable <Int32> Max <TSource> (esta fuente IEnumerable <TSource>, Func <TSource, Nullable <Int32>> selector)
  • Public static Nullable <Int64> Max <TSource> (esta fuente IEnumerable <TSource>, Func <TSource, Nullable <Int64>> selector)
  • pública estática Nullable <Single> Max <TSource> (esta fuente IEnumerable <TSource>, Func <TSource, Nullable <Single>> selector)
  • public static Single Max <TSource> (este IEnumerable <TSource> source, Func <TSource, Single> selector)
  • public static TResult Max <TSource, TResult> (esta fuente IEnumerable <TSource>, Func <TSource, TResult> selector)
  • Minimal Decimal estático público (esta fuente <Decimal> IEnumerable)
  • Double Min estática pública (esta fuente <Double> de IEnumerable)
  • Int32 Min público estático (esta fuente IEnumerable <Int32>)
  • Int64 público estático (esta fuente IEnumerable <Int64>)
  • Nullable estático público <Decimal> Min (este IEnumerable <Nullable <Decimal>> fuente)
  • Nullable estático público <Double> Min (este IEnumerable <Nullable <Double>> fuente)
  • Nullable estática pública <Int32> Min (este IEnumerable <Nullable <Int32>> fuente)
  • Nullable estática pública <Int64> Min (este IEnumerable <Nullable <Int64>> fuente)
  • Nullable estático público <Single> Min (este IEnumerable <Nullable <Single>> fuente)
  • pública (solo) estática mínima (esta fuente <Single> de IEnumerable)
  • <<source Source> (esta fuente IEnumerable <TSource>) estática pública
  • Minimal Decimal estático público <TSource> (este IEnumerable <TSource> source, Func <TSource, Decimal> selector)
  • pública estática Double Min <TSource> (esta fuente IEnumerable <TSource>, Func <TSource, Double> selector)
  • <> Fuente pública estática Int32 Min <TSource> (esta fuente IEnumerable <TSource>, Func <TSource, Int32> selector)
  • Int64 público estático Int64 Min <TSource> (este IEnumerable <TSource> fuente, Func <TSource, Int64> selector)
  • Nullable estática pública <Decimal> Min <TSource> (este <Entrada <EntradaDeIerable <Funcional, Func <TSource, <Decimal> Nullable>> selector))
  • Public static Nullable <Double> Min <TSource> (esta fuente IEnumerable <TSource>, Func <TSource, Nullable <Double>> selector)
  • Nullable estática pública <Int32> Min <TSource> (este IEnumerable <TSource> fuente, Func <TSource, Nullable <Int32>> selector)
  • Nullable estático público <Int64> Min <TSource> (este IEnumerable <TSource> fuente, Func <TSource, Nullable <Int64>> selector)
  • Nullable estática pública <Single> Min <TSource> (esta IEnumerable <TSource> fuente, Func <TSource, Nullable <Single>> selector)
  • Public static Single Min <TSource> (este IEnumerable <TSource> source, Func <TSource, Single> selector)
  • público estático TResult Min <TSource, TResult> (este IEnumerable <TSource> fuente, Func <TSource, TResult> selector)
  • IEnumerable estático público <TResult> OfType <TResult> (esta fuente IEnumerable)
  • Public static IOrderedEnumerable <TSource> OrderBy <TSource, TKey> (esta fuente IEnumerable <TSource>, Func <TSource, TKey> keySelector)
  • Public static IOrderedEnumerable <TSource> OrderBy <TSource, TKey> (esta fuente IEnumerable <TSource>, Func <TSource, TKey> keySelector, IComparer <TKey> comparador)
  • Public static IOrderedEnumerable <TSource> OrderByDescending <TSource, TKey> (esta fuente IEnumerable <TSource>, Func <TSource, TKey> keySelector)
  • Public static IOrderedEnumerable <TSource> OrderByDescending <TSource, TKey> (esta fuente IEnumerable <TSource>, Func <TSource, TKey> keySelector, IComparer <TKey> comparador)
  • Intervalo IEnumerable estático público <Int32> (Int32 start, Int32 count)
  • Public static IEnumerable <TResult> Repetir <TResult> (elemento TResult, conteo Int32)
  • Public static IEnumerable <TSource> Reverse <TSource> (esta fuente IEnumerable <TSource>)
  • IEnumerable estático público <TResult> Seleccione <TSource, TResult> (este <Entrada> <En este fuente IEnumerable, Func <TSource, TResult> selector)
  • IEnumerable estático público <TResult> Seleccione <TSource, TResult> (esta fuente <TSource> IEnumerable>, Func <TSource, Int32, TResult> selector)
  • public static IEnumerable <TResult> SelectMany <TSource, TResult> (esta fuente IEnumerable <TSource>, Func <TSource, IEnumerable <TResult>> selector)
  • public static IEnumerable <TResult> SelectMany <TSource, TResult> (esta fuente IEnumerable <TSource>, Func <TSource, Int32, IEnumerable <TResult>> selector)
  • public static IEnumerable <TResult> SelectMany <TSource, TCollection, TResult> (esta fuente IEnumerable <TSource>, Func <TSource, IEnumerable <TCollection>> collectionSelector, Func <TSource, TCollection, TResult> resultadoSelector)
  • public static IEnumerable <TResult> SelectMany <TSource, TCollection, TResult> (esta fuente IEnumerable <TSource>, Func <TSource, Int32, IEnumerable <TCollection>> collectionSelector, Func <TSource, TCollection, TResult> resultSelector)
  • Public static Boolean SequenceEqual <TSource> (este IEnumerable <TSource> primero, IEnumerable <TSource> segundo)
  • Public static Boolean SequenceEqual <TSource> (este IEnumerable <TSource> primero, IEnumerable <TSource> segundo, IEqualityComparer <TSource> comparer)
  • Public static TSource Single <TSource> (esta fuente IEnumerable <TSource>)
  • Fuente estática pública TSource Single <TSource> (esta fuente <Entrada>, <Entrada>, Func <TSource, Boolean> predicado)
  • público estático TSource SingleOrDefault <TSource> (esta fuente IEnumerable <TSource>)
  • público estático TSource SingleOrDefault <TSource> (este IEnumerable <TSource> fuente, Func <TSource, Boolean> predicado)
  • ITenumerable <TSource> estático público Omitir <TSource> (esta fuente <TSource> IEnumerable, cuenta Int32)
  • público IEnumerable I <> <> <> Fuente> Omitir> <<<Fuente> (<En este <I> IEnumerable <TSource>, Func <TSource, Boolean> predicate)
  • público IEnumerable I <> <> <> Fuente> Omitir> <<<Fuente> (<En este <I> <I> Fuente <En <> <> <<<<Source Source>, Func <TSource, Int32, Boolean> predicate)
  • Suma decimal estática pública (esta fuente <Decimal> IEnumerable)
  • Suma estática pública doble (esta fuente <Double> de IEnumerable)
  • suma estática pública Int32 (esta fuente IEnumerable <Int32>)
  • Suma estática pública Int64 (esta fuente IEnumerable <Int64>)
  • Public static Nullable <Decimal> Sum (este IEnumerable <Nullable <Decimal>> source)
  • Public static Nullable <Double> Sum (este IEnumerable <Nullable <Double>> source)
  • Public static Nullable <Int32> Sum (este IEnumerable <Nullable <Int32>> source)
  • Nullable estática pública <Int64> Suma (esta IEnumerable <Nullable <Int64>> fuente)
  • Public static Nullable <Single> Sum (este IEnumerable <Nullable <Single>> fuente)
  • Suma única estática pública (esta fuente IEnumerable <Single>)
  • Suma Decimal estática pública <TSource> (esta fuente <Entrada> IEnumerable, Func <TSource, Decimal> selector)
  • Public static Double Sum <TSource> (este IEnumerable <TSource> source, Func <TSource, Double> selector)
  • Public static Int32 Sum <TSource> (este IEnumerable <TSource> source, Func <TSource, Int32> selector)
  • Public static Int64 Sum <TSource> (esta fuente IEnumerable <TSource>, Func <TSource, Int64> selector)
  • Public static Nullable <Decimal> Sum <TSource> (este IEnumerable <TSource> source, Func <TSource, Nullable <Decimal>> selector)
  • Public static Nullable <Double> Sum <TSource> (este IEnumerable <TSource> source, Func <TSource, Nullable <Double>> selector)
  • Public static Nullable <Int32> Sum <TSource> (esta fuente IEnumerable <TSource>, Func <TSource, Nullable <Int32>> selector)
  • Public static Nullable <Int64> Sum <TSource> (esta fuente IEnumerable <TSource>, Func <TSource, Nullable <Int64>> selector)
  • pública estática Nullable <Single> Sum <TSource> (esta fuente IEnumerable <TSource>, Func <TSource, Nullable <Single>> selector)
  • Public static Single Sum <TSource> (este IEnumerable <TSource> source, Func <TSource, Single> selector)
  • ITenumerable <TSource> estático público Tomar <TSource> (esta fuente <TSource> IEnumerable, cuenta de Int32)
  • público IEnumerable <TSource> TakeWhile <TSource> (este IEnumerable <TSource> fuente, Func <TSource, Boolean> predicado)
  • público IEnumerable <TSource> TakeWhile <TSource> (este IEnumerable <TSource> fuente, Func <TSource, Int32, Boolean> predicado)
  • Public static IOrderedEnumerable <TSource> ThenBy <TSource, TKey> (esta fuente IOrderedEnumerable <TSource>, Func <TSource, TKey> keySelector)
  • Public static IOrderedEnumerable <TSource> ThenBy <TSource, TKey> (esta fuente IOrderedEnumerable <TSource>, Func <TSource, TKey> keySelector, IComparer <TKey> comparador)
  • public static IOrderedEnumerable <TSource> ThenByDescending <TSource, TKey> (esta fuente IOrderedEnumerable <TSource>, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> ThenByDescending <TSource, TKey> (esta fuente IOrderedEnumerable <TSource>, Func <TSource, TKey> keySelector, IComparer <TKey> comparer)
  • TSource estático público [] ToArray <TSource> (esta fuente IEnumerable <TSource>)
  • Diccionario estático público <TKey, TSource> ToDictionary <TSource, TKey> (este <Entrada <Entrada> fuente, Func <TSource, TKey> keySelector)
  • Diccionario estático público <TKey, TSource> ToDictionary <TSource, TKey> (esta fuente IEnumerable <TSource>, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> comparador)
  • Diccionario estático público <TKey, TElement> ToDictionary <TSource, TKey, TElement> (esta fuente <EntradaTenerable ITenumerable, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • diccionario estático público <TKey, TElement> ToDictionary <TSource, TKey, TElement> (este <Entrada <EntradaTenera <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> comparador)
  • Lista estática pública <TSource> ToList <TSource> (esta fuente IEnumerable <TSource>)
  • pública ILookup estática <TKey, TSource> ToLookup <TSource, TKey> (esta fuente <Ted> IEnumerable <TSource, Func <TSource, TKey> keySelector)
  • pública ILookup estática <TKey, TSource> ToLookup <TSource, TKey> (esta fuente IEnumerable <TSource>, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> comparador)
  • pública ILookup estática <TKey, TElement> ToLookup <TSource, TKey, TElement> (esta fuente IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • pública estática ILookup <TKey, TElement> ToLookup <TSource, TKey, TElement> (esta fuente enumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> comparador)
  • Unión <TSource> estática pública <TSource> <TSource> (primero <TSource> IEnumerable <TSource>, <TSource> IEnumerable <TSource)
  • Public <B> <TSource> Union <TSource> estática pública (esta <TSource> IEnumerable <TSource> en primer lugar, <TSource> IEnumerable <TSource>, comparador IEqualityComparer <TSource>)
  • ITenumerable <TSource> estático público Donde <TSource> (este <Tedource> IEnumerable fuente, Func <TSource, booleano> predicado)
  • ITenumerable <TSource> estático público Donde <TSource> (este <Tedource> IEnumerable fuente, Func <TSource, Int32, booleano> predicado)
  • público IEnumerable IEnumerable <TResult> Zip <TFirst, TSecond, TResult> (este IEnumerable <TFirst> primero, IEnumerable <TSecond> segundo, Func <TFirst, TSecond, TResult> resultSelector)

Observaciones

  • Véase también LINQ .

Los métodos incorporados de LINQ son métodos de extensión para la IEnumerable<T> que viven en la clase System.Linq.Enumerable en el ensamblado System.Core . Están disponibles en .NET Framework 3.5 y versiones posteriores.

LINQ permite la modificación, transformación y combinación IEnumerable de varios IEnumerable mediante una sintaxis funcional o de tipo consulta.

Mientras que los métodos estándar de LINQ pueden trabajar en cualquier IEnumerable<T> , incluyendo las matrices simples y List<T> s, también pueden ser utilizados en los objetos de base de datos, donde el conjunto de expresiones LINQ se puede transformar en muchos casos a SQL si la objeto de datos lo soporta. Ver LINQ to SQL .

Para los métodos que comparan objetos (como Contains y Except ), IEquatable<T>.Equals se usa si el tipo T de la colección implementa esa interfaz. De lo contrario, se utilizan los Equals y GetHashCode estándar del tipo (posiblemente anulados de las implementaciones de Object predeterminadas). También hay sobrecargas para estos métodos que permiten especificar un IEqualityComparer<T> .

Para los métodos ...OrDefault , el default(T) se utiliza para generar valores predeterminados.

Referencia oficial: clase enumerable.

Evaluación perezosa

Prácticamente todas las consultas que devuelven un IEnumerable<T> no se evalúan de inmediato; en cambio, la lógica se retrasa hasta que la consulta se repite. Una implicación es que cada vez que alguien itera sobre un IEnumerable<T> creado a partir de una de estas consultas, por ejemplo, .Where() , se repite la lógica de consulta completa. Si el predicado es de larga ejecución, esto puede ser una causa de problemas de rendimiento.

Una solución simple (cuando sabe o puede controlar el tamaño aproximado de la secuencia resultante) es amortiguar completamente los resultados utilizando .ToArray() o .ToList() . .ToDictionary() o .ToLookup() pueden cumplir la misma función. Por supuesto, también se puede iterar en toda la secuencia y almacenar en búfer los elementos de acuerdo con otra lógica personalizada.

ToArray() o ToList() ?

Tanto .ToArray() como .ToList() recorren todos los elementos de una IEnumerable<T> y guardan los resultados en una colección almacenada en la memoria. Utilice las siguientes pautas para determinar cuál elegir:

  • Algunas API pueden requerir una T[] o una List<T> .
  • .ToList() normalmente se ejecuta más rápido y genera menos basura que .ToArray() , porque este último debe copiar todos los elementos en una nueva colección de tamaño fijo una vez más que la anterior, en casi todos los casos.
  • Los elementos se pueden agregar o quitar de la List<T> devuelta por .ToList() , mientras que la T[] devuelta desde .ToArray() sigue siendo un tamaño fijo durante toda su vida útil. En otras palabras, la List<T> es mutable, y T[] es inmutable.
  • La T[] devuelta desde .ToArray() usa menos memoria que la List<T> devuelta desde .ToList() , por lo tanto, si el resultado se va a almacenar por mucho tiempo, prefiera .ToArray() . List<T>.TrimExcess() llamadas List<T>.TrimExcess() haría que la diferencia de memoria fuera estrictamente académica, al costo de eliminar la ventaja de velocidad relativa de .ToList() .

Seleccione (mapa)

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

var names = persons.Select(p => p.Name);
Console.WriteLine(string.Join(",", names.ToArray()));

//Foo,Bar,Fizz,Buzz

Este tipo de función se suele llamar map en los lenguajes de programación funcionales.

Donde (filtro)

Este método devuelve un IEnumerable con todos los elementos que cumplen con la expresión lambda

Ejemplo 

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

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

Salida:

Foo, Fizz

Ver demostración

Orden por

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

Contiene

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

Excepto

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

Intersecarse

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

Tenga en cuenta que los duplicados se mantienen en el resultado. Si esto no es deseable, usa Union lugar.

Primero (encontrar)

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

La siguiente InvalidOperationException lanza InvalidOperationException con el mensaje "La secuencia no contiene ningún elemento coincidente": 

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

Soltero

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

Lo siguiente lanza la InvalidOperationException ya que hay más de un elemento en la secuencia: 

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

Último

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

Lo siguiente lanza 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

Lo siguiente lanza 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

Alguna

Devuelve true si la colección tiene algún elemento que cumpla con la condición en la expresión lambda: 

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

var isNotEmpty = numbers.Any();
Console.WriteLine(isNotEmpty); //True

var anyNumberIsOne = numbers.Any(n => n == 1);
Console.WriteLine(anyNumberIsOne); //True

var anyNumberIsSix = numbers.Any(n => n == 6);
Console.WriteLine(anyNumberIsSix); //False    

var anyNumberIsOdd = numbers.Any(n => (n & 1) == 1);
Console.WriteLine(anyNumberIsOdd); //True

var anyNumberIsNegative = numbers.Any(n => n < 0);
Console.WriteLine(anyNumberIsNegative); //False

Todos

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

Tenga en cuenta que el método All funciona al verificar que el primer elemento se evalúe como false según el predicado. Por lo tanto, el método devolverá true para cualquier predicado en el caso de que el conjunto esté vacío: 

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

SelectMany (mapa plano)

Enumerable.Select devuelve un elemento de salida para cada elemento de entrada. Mientras que Enumerable.SelectMany produce un número variable de elementos de salida para cada elemento de entrada. Esto significa que la secuencia de salida puede contener más o menos elementos de los que estaban en la secuencia de entrada.

Lambda expressions pasadas a Enumerable.Select deben devolver un solo elemento. Las expresiones Lambda pasadas a Enumerable.SelectMany deben producir una secuencia secundaria. Esta secuencia secundaria puede contener un número variable de elementos para cada elemento en la secuencia de entrada.

Ejemplo 

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

Salida:

1,2,3,4,5,6

Ver demostración

Enumerable.SelectMany también se puede lograr con una consulta basada en la sintaxis usando dos cláusulas consecutivas from : 

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

Suma

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

var sumOfAllNumbers = numbers.Sum();
Console.WriteLine(sumOfAllNumbers); //10

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

var totalPopulation = cities.Sum(c => c.Population);
Console.WriteLine(totalPopulation); //7500

Omitir

Omitir enumerará los primeros N elementos sin devolverlos. Una vez que se alcanza el número de artículo N + 1, Skip comienza a devolver cada artículo enumerado: 

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

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

//3,4,5

Tomar

Este método toma los primeros n elementos de un enumerable. 

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

var threeFirstNumbers = numbers.Take(3);
Console.WriteLine(string.Join(",", threeFirstNumbers.ToArray()));

//1,2,3

SecuenciaEqual

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

Marcha atrás

var numbers = new[] {1,2,3,4,5};
var reversed = numbers.Reverse();

Console.WriteLine(string.Join(",", reversed.ToArray()));

//5,4,3,2,1

De tipo

var mixed = new object[] {1,"Foo",2,"Bar",3,"Fizz",4,"Buzz"};
var numbers = mixed.OfType<int>();

Console.WriteLine(string.Join(",", numbers.ToArray()));

//1,2,3,4

Max

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

var maxNumber = numbers.Max();
Console.WriteLine(maxNumber); //4

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

var maxPopulation = cities.Max(c => c.Population);
Console.WriteLine(maxPopulation); //4000

Min

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

var minNumber = numbers.Min();
Console.WriteLine(minNumber); //1

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

var minPopulation = cities.Min(c => c.Population);
Console.WriteLine(minPopulation); //1000

Promedio

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

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

Este método calcula el promedio de enumerables de números. 

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

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

Este método calcula el promedio de enumerable usando la función delegada.

Cremallera

.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

Distinto

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

Agrupar por

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

Agrupe las facturas por país, generando un nuevo objeto con el número de registro, el total pagado y el promedio pagado 

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

Si queremos solo los totales, no hay grupo. 

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

Si necesitamos varios recuentos. 

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

Al diccionario

Devuelve un nuevo diccionario de la fuente IEnumerable usando la función de selector de teclas provista para determinar las claves. Lanzará una ArgumentException si keySelector no es inyectivo (devuelve un valor único para cada miembro de la colección de origen). Hay sobrecargas que permiten a uno especificar el valor que se almacenará, así como la clave. 

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

Especificar solo una función de selector de clave creará un Dictionary<TKey,TVal> con TKey el tipo de retorno del selector de clave, TVal el tipo de objeto original y el objeto original como valor almacenado. 

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

La especificación de una función de selector de valor también creará un Dictionary<TKey,TVal> con TKey aún el tipo de retorno del selector de teclas, pero TVal ahora es el tipo de retorno de la función del selector de valor, y el valor devuelto como el valor almacenado. 

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

Como se indicó anteriormente, las claves devueltas por el selector de claves deben ser únicas. Lo siguiente lanzará una excepción. 

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)

Si no se puede dar una clave única para la colección de origen, considere usar ToLookup en su lugar. En la superficie, ToLookup se comporta de manera similar a ToDictionary, sin embargo, en la búsqueda resultante, cada clave se empareja con una colección de valores con claves coincidentes.

Unión

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

Tenga en cuenta que los duplicados se eliminan del resultado. Si esto no es deseable, use Concat en Concat lugar.

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

Listar

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

Contar

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

Elemento

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

Agregado (pliegue)

Generando un nuevo objeto en cada paso: 

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,

Usando el mismo objeto en todos los pasos: 

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

Usando un selector de resultados: 

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,

Si se omite una semilla, el primer elemento se convierte en la semilla: 

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

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

Para buscar

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

Unirse

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

Grupo unirse a

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

Emitir

Cast es diferente de los otros métodos de Enumerable en que es un método de extensión para IEnumerable , no para IEnumerable<T> . Por lo tanto, se puede utilizar para convertir instancias del primero en instancias del último.

Esto no se compila ya que ArrayList no implementa IEnumerable<T> : 

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

Esto funciona como se esperaba: 

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

Cast no realiza conversiones de conversión. Lo siguiente compila pero lanza la excepción InvalidCastException en tiempo de ejecución: 

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

La forma correcta de realizar una conversión de conversión a una colección es la siguiente: 

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

Vacío

Para crear un IEnumerable vacío de int: 

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

Este IEnumerable vacío se almacena en caché para cada tipo T, de modo que: 

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

Entonces por

ThenBy solo se puede utilizar después de una cláusula OrderBy que permite realizar pedidos utilizando varios criterios 

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

Distancia

Los dos parámetros para Range son el primer número y el conteo de elementos a producir (no el último número). 

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

Izquierda combinación externa

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

Repetir

Enumerable.Repeat genera una secuencia de un valor repetido. En este ejemplo se genera "Hola" 4 veces. 

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
Licenciado bajo CC BY-SA 3.0
No afiliado a Stack Overflow