linq
Operadores de consultas estándar
Buscar..
Observaciones
Las consultas de Linq se escriben utilizando los Operadores de consultas estándar (que son un conjunto de métodos de extensión que funcionan principalmente en objetos de tipo IEnumerable<T> e IQueryable<T> ) o utilizando Expresiones de consulta (que en el momento de la compilación, se convierten en Operador de consultas estándar método de llamadas).
Los operadores de consultas proporcionan capacidades de consulta que incluyen filtrado, proyección, agregación, clasificación y más.
Operaciones de concatenación
La concatenación se refiere a la operación de anexar una secuencia a otra.
Concat
Concatena dos secuencias para formar una secuencia.
Sintaxis del método
// Concat
var numbers1 = new int[] { 1, 2, 3 };
var numbers2 = new int[] { 4, 5, 6 };
var numbers = numbers1.Concat(numbers2);
// numbers = { 1, 2, 3, 4, 5, 6 }
Sintaxis de consulta
// Not applicable.
Operaciones de filtrado
El filtrado se refiere a las operaciones de restringir el conjunto de resultados para que contengan solo aquellos elementos que satisfacen una condición específica.
Dónde
Selecciona valores que se basan en una función de predicado.
Sintaxis del método
// Where
var numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var evens = numbers.Where(n => n % 2 == 0);
// evens = { 2, 4, 6, 8 }
Sintaxis de consulta
// where
var numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var odds = from n in numbers
where n % 2 != 0
select n;
// odds = { 1, 3, 5, 7 }
De tipo
Selecciona valores, en función de su capacidad para convertirse en un tipo específico.
Sintaxis del método
// OfType
var numbers = new object[] { 1, "one", 2, "two", 3, "three" };
var strings = numbers.OfType<string>();
// strings = { "one", "two", "three" }
Sintaxis de consulta
// Not applicable.
Unir Operaciones
Una combinación de dos fuentes de datos es la asociación de objetos en una fuente de datos con objetos que comparten un atributo común en otra fuente de datos.
Unirse
Une dos secuencias basadas en funciones de selector de clave y extrae pares de valores.
Sintaxis del método
// Join
class Customer
{
public int Id { get; set; }
public string Name { get; set; }
}
class Order
{
public string Description { get; set; }
public int CustomerId { get; set; }
}
...
var customers = new Customer[]
{
new Customer { Id = 1, Name = "C1" },
new Customer { Id = 2, Name = "C2" },
new Customer { Id = 3, Name = "C3" }
};
var orders = new Order[]
{
new Order { Description = "O1", CustomerId = 1 },
new Order { Description = "O2", CustomerId = 1 },
new Order { Description = "O3", CustomerId = 2 },
new Order { Description = "O4", CustomerId = 3 },
};
var join = customers.Join(orders, c => c.Id, o => o.CustomerId, (c, o) => c.Name + "-" + o.Description);
// join = { "C1-O1", "C1-O2", "C2-O3", "C3-O4" }
Sintaxis de consulta
// join … in … on … equals …
var join = from c in customers
join o in orders
on c.Id equals o.CustomerId
select o.Description + "-" + c.Name;
// join = { "O1-C1", "O2-C1", "O3-C2", "O4-C3" }
Grupo unirse a
Une dos secuencias basadas en funciones de selector de teclas y agrupa las coincidencias resultantes para cada elemento.
Sintaxis del método
// GroupJoin
var groupJoin = customers.GroupJoin(orders,
c => c.Id,
o => o.CustomerId,
(c, ors) => c.Name + "-" + string.Join(",", ors.Select(o => o.Description)));
// groupJoin = { "C1-O1,O2", "C2-O3", "C3-O4" }
Sintaxis de consulta
// join … in … on … equals … into …
var groupJoin = from c in customers
join o in orders
on c.Id equals o.CustomerId
into customerOrders
select string.Join(",", customerOrders.Select(o => o.Description)) + "-" + c.Name;
// groupJoin = { "O1,O2-C1", "O3-C2", "O4-C3" }
Cremallera
Aplica una función específica a los elementos correspondientes de dos secuencias, produciendo una secuencia de los resultados.
var numbers = new [] { 1, 2, 3, 4, 5, 6 };
var words = new [] { "one", "two", "three" };
var numbersWithWords =
numbers
.Zip(
words,
(number, word) => new { number, word });
// Results
//| number | word |
//| ------ | ------ |
//| 1 | one |
//| 2 | two |
//| 3 | three |
Operaciones de proyección
La proyección se refiere a las operaciones de transformación de un objeto en una nueva forma.
Seleccionar
Proyecta valores que se basan en una función de transformación.
Sintaxis del método
// Select
var numbers = new int[] { 1, 2, 3, 4, 5 };
var strings = numbers.Select(n => n.ToString());
// strings = { "1", "2", "3", "4", "5" }
Sintaxis de consulta
// select
var numbers = new int[] { 1, 2, 3, 4, 5 };
var strings = from n in numbers
select n.ToString();
// strings = { "1", "2", "3", "4", "5" }
SelectMany
Proyecta secuencias de valores que se basan en una función de transformación y luego las aplana en una secuencia.
Sintaxis del método
// SelectMany
class Customer
{
public Order[] Orders { get; set; }
}
class Order
{
public Order(string desc) { Description = desc; }
public string Description { get; set; }
}
...
var customers = new Customer[]
{
new Customer { Orders = new Order[] { new Order("O1"), new Order("O2") } },
new Customer { Orders = new Order[] { new Order("O3") } },
new Customer { Orders = new Order[] { new Order("O4") } },
};
var orders = customers.SelectMany(c => c.Orders);
// orders = { Order("O1"), Order("O3"), Order("O3"), Order("O4") }
Sintaxis de consulta
// multiples from
var orders = from c in customers
from o in c.Orders
select o;
// orders = { Order("O1"), Order("O3"), Order("O3"), Order("O4") }
Operaciones de clasificación
Una operación de clasificación ordena los elementos de una secuencia basándose en uno o más atributos.
Orden por
Ordena los valores en orden ascendente.
Sintaxis del método
// OrderBy
var numbers = new int[] { 5, 4, 8, 2, 7, 1, 9, 3, 6 };
var ordered = numbers.OrderBy(n => n);
// ordered = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }
Sintaxis de consulta
// orderby
var numbers = new int[] { 5, 4, 8, 2, 7, 1, 9, 3, 6 };
var ordered = from n in numbers
orderby n
select n;
// ordered = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }
OrderByDescending
Ordena los valores en orden descendente.
Sintaxis del método
// OrderByDescending
var numbers = new int[] { 5, 4, 8, 2, 7, 1, 9, 3, 6 };
var ordered = numbers.OrderByDescending(n => n);
// ordered = { 9, 8, 7, 6, 5, 4, 3, 2, 1 }
Sintaxis de consulta
// orderby
var numbers = new int[] { 5, 4, 8, 2, 7, 1, 9, 3, 6 };
var ordered = from n in numbers
orderby n descending
select n;
// ordered = { 9, 8, 7, 6, 5, 4, 3, 2, 1 }
Entonces por
Realiza una clasificación secundaria en orden ascendente.
Sintaxis del método
// ThenBy
string[] words = { "the", "quick", "brown", "fox", "jumps" };
var ordered = words.OrderBy(w => w.Length).ThenBy(w => w[0]);
// ordered = { "fox", "the", "brown", "jumps", "quick" }
Sintaxis de consulta
// orderby …, …
string[] words = { "the", "quick", "brown", "fox", "jumps" };
var ordered = from w in words
orderby w.Length, w[0]
select w;
// ordered = { "fox", "the", "brown", "jumps", "quick" }
ThenByDescending
Realiza una clasificación secundaria en orden descendente.
Sintaxis del método
// ThenByDescending
string[] words = { "the", "quick", "brown", "fox", "jumps" };
var ordered = words.OrderBy(w => w[0]).ThenByDescending(w => w.Length);
// ordered = { "brown", "fox", "jumps", "quick", "the" }
Sintaxis de consulta
// orderby …, … descending
string[] words = { "the", "quick", "brown", "fox", "jumps" };
var ordered = from w in words
orderby w.Length, w[0] descending
select w;
// ordered = { "the", "fox", "quick", "jumps", "brown" }
Marcha atrás
Invierte el orden de los elementos en una colección.
Sintaxis del método
// Reverse
var numbers = new int[] { 1, 2, 3, 4, 5 };
var reversed = numbers.Reverse();
// reversed = { 5, 4, 3, 2, 1 }
Sintaxis de consulta
// Not applicable.
Operaciones de conversión
Las operaciones de conversión cambian el tipo de objetos de entrada.
ComoEnumerable
Devuelve la entrada escrita como IEnumerable.
Sintaxis del método
// AsEnumerable
int[] numbers = { 1, 2, 3, 4, 5 };
var nums = numbers.AsEnumerable();
// nums: static type is IEnumerable<int>
Sintaxis de consulta
// Not applicable.
AsQueryable
Convierte un IEnumerable en un IQueryable.
Sintaxis del método
// AsQueryable
int[] numbers = { 1, 2, 3, 4, 5 };
var nums = numbers.AsQueryable();
// nums: static type is IQueryable<int>
Sintaxis de consulta
// Not applicable.
Emitir
Convierte los elementos de una colección a un tipo especificado.
Sintaxis del método
// Cast
var numbers = new object[] { 1, 2, 3, 4, 5 };
var nums = numbers.Cast<int>();
// nums: static type is IEnumerable<int>
Sintaxis de consulta
// Use an explicitly typed range variable.
var numbers = new object[] { 1, 2, 3, 4, 5 };
var nums = from int n in numbers select n;
// nums: static type is IEnumerable<int>
De tipo
Filtra los valores, dependiendo de su capacidad para ser convertidos a un tipo específico.
Sintaxis del método
// OfType
var objects = new object[] { 1, "one", 2, "two", 3, "three" };
var numbers = objects.OfType<int>();
// nums = { 1, 2, 3 }
Sintaxis de consulta
// Not applicable.
ToArray
Convierte una colección en una matriz.
Sintaxis del método
// ToArray
var numbers = Enumerable.Range(1, 5);
int[] array = numbers.ToArray();
// array = { 1, 2, 3, 4, 5 }
Sintaxis de consulta
// Not applicable.
Listar
Convierte una colección en una lista.
Sintaxis del método
// ToList
var numbers = Enumerable.Range(1, 5);
List<int> list = numbers.ToList();
// list = { 1, 2, 3, 4, 5 }
Sintaxis de consulta
// Not applicable.
Al diccionario
Pone elementos en un diccionario basado en una función de selector de teclas.
Sintaxis del método
// ToDictionary
var numbers = new int[] { 1, 2, 3 };
var dict = numbers.ToDictionary(n => n.ToString());
// dict = { "1" => 1, "2" => 2, "3" => 3 }
Sintaxis de consulta
// Not applicable.
Operaciones de agregación
Las operaciones de agregación calculan un único valor de una colección de valores.
Agregar
Realiza una operación de agregación personalizada en los valores de una colección.
Sintaxis del método
// Aggregate
var numbers = new int[] { 1, 2, 3, 4, 5 };
var product = numbers.Aggregate(1, (acc, n) => acc * n);
// product = 120
Sintaxis de consulta
// Not applicable.
Promedio
Calcula el valor promedio de una colección de valores.
Sintaxis del método
// Average
var numbers = new int[] { 1, 2, 3, 4, 5 };
var average = numbers.Average();
// average = 3
Sintaxis de consulta
// Not applicable.
Contar
Cuenta los elementos en una colección, opcionalmente solo aquellos elementos que satisfacen una función de predicado.
Sintaxis del método
// Count
var numbers = new int[] { 1, 2, 3, 4, 5 };
int count = numbers.Count(n => n % 2 == 0);
// count = 2
Sintaxis de consulta
// Not applicable.
LongCount
Cuenta los elementos en una colección grande, opcionalmente solo aquellos elementos que satisfacen una función de predicado.
Sintaxis del método
// LongCount
var numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
long count = numbers.LongCount();
// count = 10
Sintaxis de consulta
// Not applicable.
Max
Determina el valor máximo en una colección. Lanza una excepción si la colección está vacía.
Sintaxis del método
// Max
var numbers = new int[] { 1, 2, 3, 4, 5 };
var max = numbers.Max();
// max = 5
Sintaxis de consulta
// Not applicable.
Min
Determina el valor mínimo en una colección. Lanza una excepción si la colección está vacía.
Sintaxis del método
// Min
var numbers = new int[] { 1, 2, 3, 4, 5 };
var min = numbers.Min();
// min = 1
Sintaxis de consulta
// Not applicable.
Min- / MaxOrDefault
A diferencia de otras extensiones LinQ,
Min()yMax()no tienen una sobrecarga sin excepciones. Por lo tanto, elIEnumerabledebe verificarse enAny()antes de llamar aMin()oMax()
// Max
var numbers = new int[] { };
var max = numbers.Any() ? numbers.Max() : 0;
// max = 0
Suma
Calcula la suma de los valores en una colección.
Sintaxis del método
// Sum
var numbers = new int[] { 1, 2, 3, 4, 5 };
var sum = numbers.Sum();
// sum = 15
Sintaxis de consulta
// Not applicable.
Operaciones de cuantificación
Las operaciones de cuantificación devuelven un valor booleano que indica si algunos o todos los elementos en una secuencia satisfacen una condición.
Todos
Determina si todos los elementos en una secuencia satisfacen una condición.
Sintaxis del método
// All
var numbers = new int[] { 1, 2, 3, 4, 5 };
bool areLessThan10 = numbers.All(n => n < 10);
// areLessThan10 = true
Sintaxis de consulta
// Not applicable.
Alguna
Determina si algún elemento en una secuencia satisface una condición.
Sintaxis del método
// Any
var numbers = new int[] { 1, 2, 3, 4, 5 };
bool anyOneIsEven = numbers.Any(n => n % 2 == 0);
// anyOneIsEven = true
Sintaxis de consulta
// Not applicable.
Contiene
Determina si una secuencia contiene un elemento especificado.
Sintaxis del método
// Contains
var numbers = new int[] { 1, 2, 3, 4, 5 };
bool appears = numbers.Contains(10);
// appears = false
Sintaxis de consulta
// Not applicable.
Operaciones de agrupación
La agrupación se refiere a las operaciones de poner datos en grupos para que los elementos de cada grupo compartan un atributo común.
Agrupar por
Agrupa elementos que comparten un atributo común.
Sintaxis del método
// GroupBy
class Order
{
public string Customer { get; set; }
public string Description { get; set; }
}
...
var orders = new Order[]
{
new Order { Customer = "C1", Description = "O1" },
new Order { Customer = "C2", Description = "O2" },
new Order { Customer = "C3", Description = "O3" },
new Order { Customer = "C1", Description = "O4" },
new Order { Customer = "C1", Description = "O5" },
new Order { Customer = "C3", Description = "O6" },
};
var groups = orders.GroupBy(o => o.Customer);
// groups: { (Key="C1", Values="O1","O4","O5"), (Key="C2", Values="O2"), (Key="C3", Values="O3","O6") }
Sintaxis de consulta
// group … by
var groups = from o in orders
group o by o.Customer;
// groups: { (Key="C1", Values="O1","O4","O5"), (Key="C2", Values="O2"), (Key="C3", Values="O3","O6") }
Para buscar
Inserta elementos en un diccionario de uno a varios basado en una función de selector de teclas.
Sintaxis del método
// ToLookUp
var ordersByCustomer = orders.ToLookup(o => o.Customer);
// ordersByCustomer = ILookUp<string, Order>
// {
// "C1" => { Order("01"), Order("04"), Order("05") },
// "C2" => { Order("02") },
// "C3" => { Order("03"), Order("06") }
// }
Sintaxis de consulta
// Not applicable.
Operaciones de partición
La partición se refiere a las operaciones de dividir una secuencia de entrada en dos secciones, sin reorganizar los elementos, y luego devolver una de las secciones.
Omitir
Salta elementos hasta una posición específica en una secuencia.
Sintaxis del método
// Skip
var numbers = new int[] { 1, 2, 3, 4, 5 };
var skipped = numbers.Skip(3);
// skipped = { 4, 5 }
Sintaxis de consulta
// Not applicable.
SkipWhile
Omite elementos basados en una función de predicado hasta que un elemento no cumpla la condición.
Sintaxis del método
// Skip
var numbers = new int[] { 1, 3, 5, 2, 1, 3, 5 };
var skipLeadingOdds = numbers.SkipWhile(n => n % 2 != 0);
// skipLeadingOdds = { 2, 1, 3, 5 }
Sintaxis de consulta
// Not applicable.
Tomar
Lleva los elementos hasta una posición específica en una secuencia.
Sintaxis del método
// Take
var numbers = new int[] { 1, 2, 3, 4, 5 };
var taken = numbers.Take(3);
// taken = { 1, 2, 3 }
Sintaxis de consulta
// Not applicable.
TakeWhile
Toma elementos basados en una función de predicado hasta que un elemento no satisface la condición.
Sintaxis del método
// TakeWhile
var numbers = new int[] { 1, 3, 5, 2, 1, 3, 5 };
var takeLeadingOdds = numbers.TakeWhile(n => n % 2 != 0);
// takeLeadingOdds = { 1, 3, 5 }
Sintaxis de consulta
// Not applicable.
Operaciones de generacion
Generación se refiere a la creación de una nueva secuencia de valores.
DefaultIfEmpty
Reemplaza una colección vacía con una colección singleton de valor predeterminado.
Sintaxis del método
// DefaultIfEmpty
var nums = new int[0];
var numbers = nums.DefaultIfEmpty();
// numbers = { 0 }
Sintaxis de consulta
// Not applicable.
Vacío
Devuelve una colección vacía.
Sintaxis del método
// Empty
var empty = Enumerable.Empty<string>();
// empty = IEnumerable<string> { }
Sintaxis de consulta
// Not applicable.
Distancia
Genera una colección que contiene una secuencia de números.
Sintaxis del método
// Range
var range = Enumerable.Range(1, 5);
// range = { 1, 2, 3, 4, 5 }
Sintaxis de consulta
// Not applicable.
Repetir
Genera una colección que contiene un valor repetido.
Sintaxis del método
// Repeat
var repeats = Enumerable.Repeat("s", 3);
// repeats = { "s", "s", "s" }
Sintaxis de consulta
// Not applicable.
Establecer Operaciones
Las operaciones de conjunto se refieren a las operaciones de consulta que producen un conjunto de resultados que se basa en la presencia o ausencia de elementos equivalentes dentro de las mismas colecciones o conjuntos (o conjuntos).
Distinto
Elimina valores duplicados de una colección.
Sintaxis del método
// Distinct
var numbers = new int[] { 1, 2, 3, 1, 2, 3 };
var distinct = numbers.Distinct();
// distinct = { 1, 2, 3 }
Sintaxis de consulta
// Not applicable.
Excepto
Devuelve la diferencia establecida, lo que significa que los elementos de una colección no aparecen en una segunda colección.
Sintaxis del método
// Except
var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 4, 5, 6, 7, 8 };
var except = numbers1.Except(numbers2);
// except = { 1, 2, 3 }
Sintaxis de consulta
// Not applicable.
Intersecarse
Devuelve la intersección del conjunto, lo que significa que los elementos que aparecen en cada una de las dos colecciones.
Sintaxis del método
// Intersect
var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 4, 5, 6, 7, 8 };
var intersect = numbers1.Intersect(numbers2);
// intersect = { 4, 5 }
Sintaxis de consulta
// Not applicable.
Unión
Devuelve la unión establecida, lo que significa elementos únicos que aparecen en cualquiera de las dos colecciones.
Sintaxis del método
// Union
var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 4, 5, 6, 7, 8 };
var union = numbers1.Union(numbers2);
// union = { 1, 2, 3, 4, 5, 6, 7, 8 }
Sintaxis de consulta
// Not applicable.
Operaciones de igualdad
Dos secuencias cuyos elementos correspondientes son iguales y que tienen el mismo número de elementos se consideran iguales.
SecuenciaEqual
Determina si dos secuencias son iguales comparando elementos de una manera por pares.
Sintaxis del método
// SequenceEqual
var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 1, 2, 3, 4, 5 };
var equals = numbers1.SequenceEqual(numbers2);
// equals = true
Sintaxis de consulta
// Not Applicable.
Operaciones de elementos
Las operaciones de elementos devuelven un único elemento específico de una secuencia.
Elemento
Devuelve el elemento en un índice especificado en una colección.
Sintaxis del método
// ElementAt
var strings = new string[] { "zero", "one", "two", "three" };
var str = strings.ElementAt(2);
// str = "two"
Sintaxis de consulta
// Not Applicable.
ElementAtOrDefault
Devuelve el elemento en un índice especificado en una colección o un valor predeterminado si el índice está fuera de rango.
Sintaxis del método
// ElementAtOrDefault
var strings = new string[] { "zero", "one", "two", "three" };
var str = strings.ElementAtOrDefault(10);
// str = null
Sintaxis de consulta
// Not Applicable.
primero
Devuelve el primer elemento de una colección, o el primer elemento que satisface una condición.
Sintaxis del método
// First
var numbers = new int[] { 1, 2, 3, 4, 5 };
var first = strings.First();
// first = 1
Sintaxis de consulta
// Not Applicable.
FirstOrDefault
Devuelve el primer elemento de una colección, o el primer elemento que satisface una condición. Devuelve un valor predeterminado si no existe tal elemento.
Sintaxis del método
// FirstOrDefault
var numbers = new int[] { 1, 2, 3, 4, 5 };
var firstGreaterThanTen = strings.FirstOrDefault(n => n > 10);
// firstGreaterThanTen = 0
Sintaxis de consulta
// Not Applicable.
Último
Devuelve el último elemento de una colección, o el último elemento que satisface una condición.
Sintaxis del método
// Last
var numbers = new int[] { 1, 2, 3, 4, 5 };
var last = strings.Last();
// last = 5
Sintaxis de consulta
// Not Applicable.
LastOrDefault
Devuelve el último elemento de una colección, o el último elemento que satisface una condición. Devuelve un valor predeterminado si no existe tal elemento.
Sintaxis del método
// LastOrDefault
var numbers = new int[] { 1, 2, 3, 4, 5 };
var lastGreaterThanTen = strings.LastOrDefault(n => n > 10);
// lastGreaterThanTen = 0
Sintaxis de consulta
// Not Applicable.
Soltero
Devuelve el único elemento de una colección, o el único elemento que satisface una condición.
Sintaxis del método
// Single
var numbers = new int[] { 1 };
var single = strings.Single();
// single = 1
Sintaxis de consulta
// Not Applicable.
SingleOrDefault
Devuelve el único elemento de una colección, o el único elemento que satisface una condición. Devuelve un valor predeterminado si no existe tal elemento o la colección no contiene exactamente un elemento.
Sintaxis del método
// SingleOrDefault
var numbers = new int[] { 1, 2, 3, 4, 5 };
var singleGreaterThanFour = strings.SingleOrDefault(n => n > 4);
// singleGreaterThanFour = 5
Sintaxis de consulta
// Not Applicable.
