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 unaList<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 laT[]
devuelta desde.ToArray()
sigue siendo un tamaño fijo durante toda su vida útil. En otras palabras, laList<T>
es mutable, yT[]
es inmutable. - La
T[]
devuelta desde.ToArray()
usa menos memoria que laList<T>
devuelta desde.ToList()
, por lo tanto, si el resultado se va a almacenar por mucho tiempo, prefiera.ToArray()
.List<T>.TrimExcess()
llamadasList<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
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
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
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
*/