LINQ

Contents
System.Linq
Enumerable
Aggregate
All
Any
Append
AsEnumerable
Average
Cast
Concat
Contains
Count
DefaultIfEmpty
Distinct
ElementAt
ElementAtOrDefault
Empty
Except
First
FirstOrDefault
GroupBy
GroupJoin
Intersect
Join
Last
LastOrDefault
LongCount
Max
Min
OfType
OrderBy
OrderByDescending
Prepend
Range
Repeat
Reverse
Select
SelectMany
SequenceEqual
Single
SingleOrDefault
Skip
SkipLast
SkipWhile
Sum
Take
TakeLast
TakeWhile
ThenBy
ThenByDescending
ToArray
ToDictionary
ToHashSet
ToList
ToLookup
Union
Where
Zip
EnumerableExecutor
EnumerableExecutor
EnumerableExecutor<T>
EnumerableQuery
EnumerableQuery
EnumerableQuery<T>
EnumerableQuery<T>
IEnumerable.GetEnumerator
IEnumerable<T>.GetEnumerator
IQueryable.ElementType
IQueryable.Expression
IQueryable.Provider
IQueryProvider.CreateQuery
IQueryProvider.Execute
ToString
IGrouping<TKey,TElement>
Key
ILookup<TKey,TElement>
Contains
Count
Item[TKey]
ImmutableArrayExtensions
Aggregate
All
Any
ElementAt
ElementAtOrDefault
First
FirstOrDefault
Last
LastOrDefault
Select
SelectMany
SequenceEqual
Single
SingleOrDefault
ToArray
ToDictionary
Where
IOrderedEnumerable<TElement>
CreateOrderedEnumerable
IOrderedQueryable
IOrderedQueryable<T>
IQueryable
ElementType
Expression
Provider
IQueryable<T>
IQueryProvider
CreateQuery
Execute
Lookup<TKey,TElement>
ApplyResultSelector
Contains
Count
GetEnumerator
Item[TKey]
OrderedParallelQuery<TSource>
GetEnumerator
ParallelEnumerable
Aggregate
All
Any
AsEnumerable
AsOrdered
AsParallel
AsSequential
AsUnordered
Average
Cast
Concat
Contains
Count
DefaultIfEmpty
Distinct
ElementAt
ElementAtOrDefault
Empty
Except
First
FirstOrDefault
ForAll
GroupBy
GroupJoin
Intersect
Join
Last
LastOrDefault
LongCount
Max
Min
OfType
OrderBy
OrderByDescending
Range
Repeat
Reverse
Select
SelectMany
SequenceEqual
Single
SingleOrDefault
Skip
SkipWhile
Sum
Take
TakeWhile
ThenBy
ThenByDescending
ToArray
ToDictionary
ToList
ToLookup
Union
Where
WithCancellation
WithDegreeOfParallelism
WithExecutionMode
WithMergeOptions
Zip
ParallelExecutionMode
ParallelMergeOptions
ParallelQuery
ParallelQuery<TSource>
GetEnumerator
Queryable
Aggregate
All
Any
Append
AsQueryable
Average
Cast
Concat
Contains
Count
DefaultIfEmpty
Distinct
ElementAt
ElementAtOrDefault
Except
First
FirstOrDefault
GroupBy
GroupJoin
Intersect
Join
Last
LastOrDefault
LongCount
Max
Min
OfType
OrderBy
OrderByDescending
Prepend
Reverse
Select
SelectMany
SequenceEqual
Single
SingleOrDefault
Skip
SkipLast
SkipWhile
Sum
Take
TakeLast
TakeWhile
ThenBy
ThenByDescending
Union
Where
Zip
System.Linq Namespace
O namespace System.Linq fornece classes e interfaces compatíveis com consultas que usam LINQ (Consulta Integrada
à Linguagem).
Introduction
O System.Linq namespace está no assembly System. Core (em dll).
O Enumerable classe contém LINQ operadores de consulta padrão que operam em objetos que implementam
IEnumerable<T>.
O Queryable classe contém LINQ operadores de consulta padrão que operam em objetos que implementam
IQueryable<T>.
Para obter informações sobre o LINQ to SQL, consulte LINQ to SQL [LINQ to SQL ].
Classes
Enumerable
Fornece um conjunto de métodos static ( Shared no
Visual Basic) para consultar objetos que implementam
IEnumerable<T>.
EnumerableExecutor
Representa uma árvore de expressão e fornece funcionalidade
para executar a árvore de expressão depois de reescrevê-los.
Representa uma árvore de expressão e fornece funcionalidade
para executar a árvore de expressão depois de reescrevê-los.
EnumerableQuery
Representa um IEnumerable como uma fonte de dados
EnumerableQuery.
EnumerableQuery<T>
Representa uma coleção de IEnumerable<T> como uma fonte
de dados IQueryable<T>.
ImmutableArrayExtensions
Substituições de método de extensão LINQ que oferecem
maior eficiência para ImmutableArray<T> que os métodos
LINQ padrão Pacote NuGet: System.Collections.Immutable
(sobre coleções imutáveis e como instalá-las)
Lookup<TKey,TElement>
Representa uma coleção de chaves, cada uma mapeada para
um ou mais valores.
OrderedParallelQuery<TSource>
Representa uma sequência paralela e classificada.
ParallelEnumerable
Fornece um conjunto de métodos de consulta de objetos que
implementam ParallelQuery {TSource}. Este é o equivalente
paralelo de Enumerable.
ParallelQuery
Representa uma sequência paralela.
ParallelQuery<TSource>
Queryable
Fornece um conjunto de métodos static ( Shared no
Visual Basic) para consultar estruturas de dados que
implementam IQueryable<T>.
Interfaces
IGrouping<TKey,TElement>
Representa uma coleção de objetos que têm uma chave
comum.
ILookup<TKey,TElement>
Define um indexador, a propriedade de tamanho e o método
de pesquisa booliana para estruturas de dados que mapeiam
chaves para sequências IEnumerable<T> de valores.
IOrderedEnumerable<TElement>
Representa uma sequência classificada.
IOrderedQueryable
Representa o resultado de uma operação de classificação.
IOrderedQueryable<T>
IQueryable
Fornece a funcionalidade para avaliar as consultas em uma
fonte de dados específica no qual o tipo de dado não foi
especificado.
IQueryable<T>
Fornece a funcionalidade para avaliar as consultas em uma
fonte de dados específica no qual o tipo de dado é conhecido.
IQueryProvider
Define métodos para criar e executar consultas que são
descritas por um objeto IQueryable.
Enums
ParallelExecutionMode
O modo de execução de consulta é uma dica que especifica
como o sistema deve tratar as compensações de desempenho
ao paralelizar consultas.
ParallelMergeOptions
Especifica o tipo preferencial de mesclagem de saída a ser
usado em uma consulta. Em outras palavras, ele indica como o
PLINQ deve mesclar os resultados de várias partições
novamente em uma sequência de resultados. Isso é apenas
uma dica e pode não ser respeitado pelo sistema ao paralelizar
todas as consultas.
Enumerable Enumerable Class
Fornece um conjunto de métodos static ( Shared no Visual Basic) para consultar objetos que implementam
IEnumerable<T>.
D eclaration
public static class Enumerable
type Enumerable = class
I nheritance H ierarchy
Object Object
Remarks
Os métodos nessa classe fornecem uma implementação de operadores de consulta padrão para consultar dados de
fontes que implementam IEnumerable<T>. Operadores de consulta padrão são os métodos de finalidade geral que
seguem o LINQ padrão e lhe permitem expressar operações de passagem, filtro e projeção sobre dados em qualquer
um. Linguagem de programação baseado em NET.
A maioria dos métodos nessa classe são definidos como métodos de extensão que estendem IEnumerable<T>. Isso
significa que eles podem ser chamados como um método de instância em qualquer objeto que implementa
IEnumerable<T>.
Métodos que são usados em uma consulta que retorna uma sequência de valores não consomem os dados de destino
até que o objeto de consulta seja enumerado. Isso é conhecido como execução adiada. Métodos que são usados em
uma consulta que retorna um valor singleton execute e consumam os dados de destino imediatamente.
Methods
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate,
Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate,
Aplica uma função de acumulador a uma sequência. O valor de semente especificado é usado como o valor inicial
do acumulador e a função especificada é usada para selecionar o valor do resultado.
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate,
Func<TAccumulate,TSource,TAccumulate>)
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate,
do acumulador.
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)
Aplica uma função de acumulador a uma sequência.

All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Determina se todos os elementos de uma sequência atendem a uma condição.
Any<TSource>(IEnumerable<TSource>)
Any<TSource>(IEnumerable<TSource>)
Determina se uma sequência contém elementos.
Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Determina se algum elemento de uma sequência atende a uma condição.
Append<TSource>(IEnumerable<TSource>, TSource)
Append<TSource>(IEnumerable<TSource>, TSource)
Acrescenta um valor ao final da sequência.
AsEnumerable<TSource>(IEnumerable<TSource>)
AsEnumerable<TSource>(IEnumerable<TSource>)
Retorna a entrada digitada como IEnumerable<T>.
Average(IEnumerable<Single>)
Average(IEnumerable<Single>)
Computa a média de uma sequência de valores Single.
Average(IEnumerable<Nullable<Single>>)
Computa a média de uma sequência de valores Single que permitem valores nulos.
Average(IEnumerable<Nullable<Int64>>)
Computa a média de uma sequência de valores Int64 que permitem valores nulos.
Average(IEnumerable<Nullable<Double>>)
Computa a média de uma sequência de valores Double que permitem valores nulos.
Average(IEnumerable<Int64>)
Computa a média de uma sequência de valores Int64.
Average(IEnumerable<Double>)
Average(IEnumerable<Double>)
Computa a média de uma sequência de valores Double.
Average(IEnumerable<Decimal>)
Computa a média de uma sequência de valores Decimal.
Average(IEnumerable<Nullable<Decimal>>)
Computa a média de uma sequência de valores Decimal que permitem valores nulos.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)
Calcula a média de uma sequência de valores Int32 que permitem valor nulo obtidos pela invocação de uma
função de transformação em cada elemento da sequência de entrada.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)
Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)
Calcula a média de uma sequência de valores Single obtidos pela invocação de uma função de transformação em
cada elemento da sequência de entrada.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)
Calcula a média de uma sequência de valores Single que permitem valor nulo obtidos pela invocação de uma
Calcula a média de uma sequência de valores Int64 que permitem valor nulo obtidos pela invocação de uma
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)
Calcula a média de uma sequência de valores Double que permitem valor nulo obtidos pela invocação de uma
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)
Calcula a média de uma sequência de valores Decimal que permitem valor nulo obtidos pela invocação de uma
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)
Calcula a média de uma sequência de valores Int64 obtidos pela invocação de uma função de transformação em
Calcula a média de uma sequência de valores Int32 obtidos pela invocação de uma função de transformação em
Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)
Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)
Calcula a média de uma sequência de valores Double obtidos pela invocação de uma função de transformação em
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)
Calcula a média de uma sequência de valores Decimal obtidos pela invocação de uma função de transformação
em cada elemento da sequência de entrada.
Cast<TResult>(IEnumerable)
Cast<TResult>(IEnumerable)
Converte os elementos de um IEnumerable para o tipo especificado.
Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)
Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)
Concatena duas sequências.
Contains<TSource>(IEnumerable<TSource>, TSource)
Determina se uma sequência contém um elemento especificado usando o comparador de igualdade padrão.
Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)

Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)
Determina se uma sequência contém um elemento especificado usando um IEqualityComparer<T> especificado.
Count<TSource>(IEnumerable<TSource>)
Count<TSource>(IEnumerable<TSource>)
Retorna o número de elementos em uma sequência.
Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Retorna um número que representa quantos elementos na sequência especificada atendem a uma condição.
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)
Retorna os elementos da sequência especificada ou o valor especificado em uma coleção de singletons se a

sequência está vazia.
DefaultIfEmpty<TSource>(IEnumerable<TSource>)
Retornará os elementos da sequência especificada ou o valor padrão do parâmetro de tipo em uma coleção de
singletons se a sequência estiver vazia.
Distinct<TSource>(IEnumerable<TSource>)
Distinct<TSource>(IEnumerable<TSource>)
Retorna os elementos distintos de uma sequência usando o comparador de igualdade padrão para comparar
valores.
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)
Retorna os elementos distintos de uma sequência usando um IEqualityComparer<T> especificado para comparar
valores.
ElementAt<TSource>(IEnumerable<TSource>, Int32)
ElementAt<TSource>(IEnumerable<TSource>, Int32)
Retorna o elemento de um índice especificado em uma sequência.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)
Retorna o elemento em um índice especificado em uma sequência ou um valor padrão se o índice estiver fora do
intervalo.
Empty<TResult>()
Empty<TResult>()
Retorna um IEnumerable<T> vazio que tem o argumento do tipo especificado.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)
Produz a diferença de conjunto de duas sequências usando o comparador de igualdade padrão para comparar os
valores.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
Produz a diferença de conjunto de duas sequências usando o IEqualityComparer<T> especificado para comparar
os valores.
First<TSource>(IEnumerable<TSource>)
First<TSource>(IEnumerable<TSource>)
Retorna o primeiro elemento de uma sequência.
First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Retorna o primeiro elemento em uma sequência que satisfaz uma condição especificada.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Retorna o primeiro elemento da sequência que satisfaz uma condição ou um valor padrão, caso esse elemento
não seja encontrado.
FirstOrDefault<TSource>(IEnumerable<TSource>)
Retorna o primeiro elemento de uma sequência ou um valor padrão se a sequência não contém elementos.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>,
Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)
Agrupa os elementos de uma sequência de acordo com uma função do seletor de chave especificada e cria um
valor de resultado de cada grupo e sua chave. Os elementos de cada grupo são projetados usando uma função
especificada.
Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>, IEqualityComparer<TKey>)
valor de resultado de cada grupo e sua chave. Os valores da chave são comparados usando um comparador
especificado e os elementos de cada grupo são projetados usando uma função especificada.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Agrupa os elementos de uma sequência de acordo com a função de seletor de chave especificada e projeta os
elementos de cada grupo usando uma função especificada.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>,

IEqualityComparer<TKey>)
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>,
Agrupa os elementos de uma sequência de acordo com uma função de seletor de chave. As chaves são
comparadas usando um comparador e os elementos de cada grupo são projetados usando uma função
especificada.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>,
Func<TKey,IEnumerable<TSource>,TResult>)
valor de resultado de cada grupo e sua chave.
Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)
valor de resultado de cada grupo e sua chave. As chaves são comparadas usando um comparador especificado.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)
Agrupa os elementos de uma sequência de acordo com uma função de seletor de chave especificada.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)
Agrupa os elementos de uma sequência de acordo com uma função do seletor de chave especificada e compara as
chaves usando um comparador especificado.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>,

Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>, IEqualityComparer<TKey>)
Correlaciona os elementos de duas sequências com base na igualdade de chaves e agrupa os resultados. Um
IEqualityComparer<T> especificado é usado para comparar chaves.

Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>)
Correlaciona os elementos de duas sequências com base na igualdade de chaves e agrupa os resultados. O
comparador de igualdade padrão é usado para comparar chaves.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
Produz a interseção de conjunto de duas sequências usando o IEqualityComparer<T> especificado para comparar
os valores.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)
Produz a interseção de conjunto de duas sequências usando o comparador de igualdade padrão para comparar os
valores.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>,

Func<TInner,TKey>, Func<TOuter,TInner,TResult>)
Correlaciona os elementos de duas sequências com base em chaves de correspondência. O comparador de

igualdade padrão é usado para comparar chaves.

Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)
Correlaciona os elementos de duas sequências com base em chaves de correspondência. Um

Last<TSource>(IEnumerable<TSource>)
Last<TSource>(IEnumerable<TSource>)
Retorna o último elemento de uma sequência.
Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Retorna o último elemento de uma sequência que satisfaz uma condição especificada.
LastOrDefault<TSource>(IEnumerable<TSource>)
Retorna o último elemento de uma sequência ou um valor padrão se a sequência não contém elementos.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Retorna o último elemento de uma sequência que satisfaz uma condição ou um valor padrão, caso esse elemento
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Retorna um Int64 que representa quantos elementos na sequência atendem a uma condição.
LongCount<TSource>(IEnumerable<TSource>)
Retorna um Int64 que representa o número total de elementos em uma sequência.
Max(IEnumerable<Nullable<Single>>)
Retorna o valor máximo em uma sequência de valores Single anuláveis.
Max(IEnumerable<Int32>)
Retorna o valor máximo em uma sequência de valores Int32.
Max(IEnumerable<Nullable<Int64>>)
Retorna o valor máximo em uma sequência de valores Int64 anuláveis.
Max(IEnumerable<Single>)
Max(IEnumerable<Single>)
Retorna o valor máximo em uma sequência de valores Single.
Max(IEnumerable<Decimal>)
Max(IEnumerable<Decimal>)
Retorna o valor máximo em uma sequência de valores Decimal.
Max(IEnumerable<Nullable<Decimal>>)
Retorna o valor máximo em uma sequência de valores Decimal anuláveis.

Max(IEnumerable<Double>)
Max(IEnumerable<Double>)
Retorna o valor máximo em uma sequência de valores Double.
Max(IEnumerable<Nullable<Double>>)
Retorna o valor máximo em uma sequência de valores Double anuláveis.
Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)
Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)
Invoca uma função de transformação em cada elemento de uma sequência genérica e retorna o maior valor
resultante.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Single máximo.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Single máximo que
permite valor nulo.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int64 máximo que
permite valor nulo.
permite valor nulo.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Double máximo que
permite valor nulo.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int64 máximo.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Double máximo.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Decimal máximo.
Max<TSource>(IEnumerable<TSource>)
Max<TSource>(IEnumerable<TSource>)
Retorna o valor máximo em uma sequência genérica.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Decimal máximo que
permite valor nulo.
Min(IEnumerable<Nullable<Int64>>)
Retorna o valor mínimo em uma sequência de valores Int64 anuláveis.
Min(IEnumerable<Single>)
Min(IEnumerable<Single>)
Retorna o valor mínimo em uma sequência de valores Single.

Min(IEnumerable<Nullable<Single>>)
Retorna o valor mínimo em uma sequência de valores Single anuláveis.
Min(IEnumerable<Nullable<Double>>)
Retorna o valor mínimo em uma sequência de valores Double anuláveis.
Min(IEnumerable<Double>)
Min(IEnumerable<Double>)
Retorna o valor mínimo em uma sequência de valores Double.
Min(IEnumerable<Int64>)
Retorna o valor mínimo em uma sequência de valores Int64.
Min(IEnumerable<Nullable<Decimal>>)
Retorna o valor mínimo em uma sequência de valores Decimal anuláveis.
Min(IEnumerable<Decimal>)
Min(IEnumerable<Decimal>)
Retorna o valor mínimo em uma sequência de valores Decimal.
Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)
Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)
Invoca uma função de transformação em cada elemento de uma sequência genérica e retorna o menor valor
resultante.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Single mínimo.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Single mínimo que
permite valor nulo.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int64 mínimo que
permite valor nulo.
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int32 mínimo que
permite valor nulo.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Double mínimo que
permite valor nulo.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int64 mínimo.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Double mínimo.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Decimal mínimo.
Min<TSource>(IEnumerable<TSource>)
Min<TSource>(IEnumerable<TSource>)
Retorna o valor mínimo em uma sequência genérica.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Decimal mínimo que
permite valor nulo.
OfType<TResult>(IEnumerable)
OfType<TResult>(IEnumerable)
Filtra os elementos de um IEnumerable com base em um tipo especificado.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)
Classifica os elementos de uma sequência em ordem crescente de acordo com uma chave.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)
Classifica os elementos de uma sequência em ordem crescente usando um comparador especificado.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)
Classifica os elementos de uma sequência em ordem decrescente usando um comparador especificado.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)
Classifica os elementos de uma sequência em ordem decrescente de acordo com uma chave.
Prepend<TSource>(IEnumerable<TSource>, TSource)
Prepend<TSource>(IEnumerable<TSource>, TSource)
Adiciona um valor ao início da sequência.
Range(Int32, Int32)
Range(Int32, Int32)
Gera uma sequência de números integrais dentro de um intervalo especificado.

Repeat<TResult>(TResult, Int32)
Gera uma sequência que contém um valor repetido.
Reverse<TSource>(IEnumerable<TSource>)
Reverse<TSource>(IEnumerable<TSource>)
Inverte a ordem dos elementos em uma sequência.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)
Projeta cada elemento de uma sequência em um novo formulário, incorporando o índice do elemento.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)
Projeta cada elemento de uma sequência em um novo formulário.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>,
Func<TSource,TCollection,TResult>)
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>,
Projeta cada elemento de uma sequência em um IEnumerable<T>, mescla as sequências resultantes em uma
sequência e chama uma função de seletor de resultado em cada elemento contido nele.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>,
Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)
sequência e chama uma função de seletor de resultado em cada elemento contido nele. O índice de cada elemento
de origem é usado no formulário projetado intermediário do elemento.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)
Projeta cada elemento de uma sequência em um IEnumerable<T> e nivela as sequências resultantes em uma
sequência.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)
sequência. O índice de cada elemento de origem é usado no formulário projetado desse elemento.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)
Determina se duas sequências são iguais comparando os elementos usando o comparador de igualdade padrão
para o tipo.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
Determina se duas sequências são iguais, comparando seus elementos usando um IEqualityComparer<T>
especificado.
Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Retorna o único elemento de uma sequência que satisfaz uma condição especificada e gera uma exceção se
houver mais de um tal elemento.
Single<TSource>(IEnumerable<TSource>)
Single<TSource>(IEnumerable<TSource>)
Retornará o único elemento de uma sequência e lançará uma exceção se não houver exatamente um elemento na
sequência.
SingleOrDefault<TSource>(IEnumerable<TSource>)
Retorna o único elemento de uma sequência ou um valor padrão se a sequência é vazia; esse método gera uma
exceção se há mais de um elemento na sequência.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Retorna o único elemento de uma sequência que satisfaz uma condição especificada ou um valor padrão se esse
elemento não existir. Esse método lança uma exceção se mais de um elemento satisfizer a condição.
Skip<TSource>(IEnumerable<TSource>, Int32)
Skip<TSource>(IEnumerable<TSource>, Int32)
Ignora um número especificado de elementos em uma sequência e retorna os elementos restantes.
SkipLast<TSource>(IEnumerable<TSource>, Int32)
SkipLast<TSource>(IEnumerable<TSource>, Int32)
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Ignora elementos em uma sequência, contanto que uma condição especificada seja verdadeira e retorne os
elementos restantes.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)
elementos restantes. O índice do elemento é usado na lógica da função de predicado.
Sum(IEnumerable<Nullable<Int32>>)
Computa a soma de uma sequência de valores Int32 que permitem valores nulos.
Sum(IEnumerable<Nullable<Single>>)
Computa a soma de uma sequência de valores Single que permitem valores nulos.
Sum(IEnumerable<Single>)
Sum(IEnumerable<Single>)
Calcula a soma de uma sequência de valores Single.
Sum(IEnumerable<Nullable<Double>>)
Computa a soma de uma sequência de valores Double que permitem valores nulos.
Sum(IEnumerable<Double>)
Sum(IEnumerable<Double>)
Calcula a soma de uma sequência de valores Double.
Sum(IEnumerable<Int64>)
Calcula a soma de uma sequência de valores Int64.

Sum(IEnumerable<Decimal>)
Sum(IEnumerable<Decimal>)
Calcula a soma de uma sequência de valores Decimal.
Sum(IEnumerable<Nullable<Decimal>>)
Computa a soma de uma sequência de valores Decimal que permitem valores nulos.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)
Calcula a soma da sequência de valores Single obtidos pela invocação de uma função de transformação em cada
elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)
Calcula a soma da sequência de valores Single anuláveis obtidos pela invocação de uma função de transformação
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)
Calcula a soma da sequência de valores Int64 anuláveis obtidos pela invocação de uma função de transformação
Calcula a soma da sequência de valores Int32 anuláveis obtidos pela invocação de uma função de transformação
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)
Calcula a soma da sequência de valores Double anuláveis obtidos pela invocação de uma função de
transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)
Calcula a soma da sequência de valores Decimal anuláveis obtidos pela invocação de uma função de
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)
Calcula a soma da sequência de valores Int64 obtidos pela invocação de uma função de transformação em cada
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)
Calcula a soma da sequência de valores Double obtidos pela invocação de uma função de transformação em cada
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)
Calcula a soma da sequência de valores Decimal obtidos pela invocação de uma função de transformação em cada
Take<TSource>(IEnumerable<TSource>, Int32)
Take<TSource>(IEnumerable<TSource>, Int32)
Retorna um número especificado de elementos contíguos do início de uma sequência.
TakeLast<TSource>(IEnumerable<TSource>, Int32)
TakeLast<TSource>(IEnumerable<TSource>, Int32)
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Retorna os elementos de uma sequência contanto que uma condição especificada seja verdadeira.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)
Retorna os elementos de uma sequência contanto que uma condição especificada seja verdadeira. O índice do
elemento é usado na lógica da função de predicado.
ThenBy<TSource,TKey>(IOrderedEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

ThenBy<TSource,TKey>(IOrderedEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)
Executa uma ordenação posterior dos elementos em uma sequência em ordem crescente usando um comparador
especificado.
ThenBy<TSource,TKey>(IOrderedEnumerable<TSource>, Func<TSource,TKey>)
ThenBy<TSource,TKey>(IOrderedEnumerable<TSource>, Func<TSource,TKey>)
Executa uma ordenação posterior dos elementos em uma sequência em ordem crescente de acordo com uma
chave.
ThenByDescending<TSource,TKey>(IOrderedEnumerable<TSource>, Func<TSource,TKey>)
ThenByDescending<TSource,TKey>(IOrderedEnumerable<TSource>, Func<TSource,TKey>)
Executa uma ordenação posterior dos elementos em uma sequência em ordem decrescente, de acordo com uma
chave.
ThenByDescending<TSource,TKey>(IOrderedEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

ThenByDescending<TSource,TKey>(IOrderedEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)
Executa uma ordenação posterior dos elementos em uma sequência em ordem decrescente usando um
comparador especificado.
ToArray<TSource>(IEnumerable<TSource>)
ToArray<TSource>(IEnumerable<TSource>)
Cria uma matriz de um IEnumerable<T>.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)
Cria um Dictionary<TKey,TValue> de um IEnumerable<T>, de acordo com as funções especificadas de seletor de

chave e seletor de elemento.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>,

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>,
Cria um Dictionary<TKey,TValue> de um IEnumerable<T> de acordo com uma função de seletor de chave, um

comparador e uma função de seletor de elemento especificados.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)
Cria um Dictionary<TKey,TValue> de um IEnumerable<T>, de acordo com uma função de seletor de chave

especificada.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

especificada e um comparador de chaves.
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)
Cria um HashSet<T> de um IEnumerable<T> usando o comparer para comparar chaves
ToHashSet<TSource>(IEnumerable<TSource>)
Cria um HashSet<T> de um IEnumerable<T>.
ToList<TSource>(IEnumerable<TSource>)
ToList<TSource>(IEnumerable<TSource>)
Cria um List<T> de um IEnumerable<T>.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)
Cria um Lookup<TKey,TElement> de um IEnumerable<T>, de acordo com as funções especificadas de seletor de

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>,

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>,
Cria um Lookup<TKey,TElement> de um IEnumerable<T> de acordo com uma função de seletor de chave, um

ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)
Cria um Lookup<TKey,TElement> de um IEnumerable<T>, de acordo com uma função de seletor de chave

especificada.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)
Produz a união de conjunto de duas sequências usando o comparador de igualdade padrão.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
Produz a união de conjunto de duas sequências usando o IEqualityComparer<T> especificado.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)
Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)
Filtra uma sequência de valores com base em um predicado. O índice de cada elemento é usado na lógica da
função de predicado.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Filtra uma sequência de valores com base em um predicado.
Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)

Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)
Aplica uma função especificada para os elementos correspondentes de duas sequências, produzindo uma
sequência dos resultados.
See Also
Enumerable.Aggregate Enumerable.Aggregate
I n this Article
Overloads
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<
TSource>, TAccumulate, Func<TAccumulate,TSource, Aplica uma função de acumulador a uma sequência. O valor
TAccumulate>, Func<TAccumulate,TResult>) Aggregate< de semente especificado é usado como o valor inicial do
TSource,TAccumulate,TResult>(IEnumerable<TSource>, acumulador e a função especificada é usada para selecionar o
TAccumulate, Func<TAccumulate,TSource,TAccumulate>, valor do resultado.
Func<TAccumulate,TResult>)
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>,
TAccumulate, Func<TAccumulate,TSource,TAccumulate>) Aplica uma função de acumulador a uma sequência. O valor
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, de semente especificado é usado como o valor inicial do
TAccumulate, Func<TAccumulate,TSource,TAccumulate>) acumulador.
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,
TSource,TSource>) Aggregate<TSource>(IEnumerable< Aplica uma função de acumulador a uma sequência.
TSource>, Func<TSource,TSource,TSource>)
Aggregate<TSource,TAccumulate,TResult>
(IEnumerable<TSource>, TAccumulate,
Func<TAccumulate,TSource,TAccumulate>,
(IEnumerable<TSource>, TAccumulate,
Aplica uma função de acumulador a uma sequência. O valor de semente especificado é usado como o valor inicial do
acumulador e a função especificada é usada para selecionar o valor do resultado.
public static TResult Aggregate<TSource,TAccumulate,TResult> (this
System.Collections.Generic.IEnumerable<TSource> source, TAccumulate seed,
Func<TAccumulate,TSource,TAccumulate> func, Func<TAccumulate,TResult> resultSelector);
static member Aggregate : seq<'Source> * 'Accumulate * Func<'Accumulate, 'Source, 'Accumulate> *
Func<'Accumulate, 'Result> -> 'Result
Type Parameters
TSource
O tipo dos elementos de source .
TAccumulate
O tipo do valor do acumulador.
TResult
O tipo do valor resultante.
Parameters
source IEnumerable<TSource>
Um IEnumerable<T> no qual será feita a agregação.
seed TAccumulate TAccumulate
O valor inicial do acumulador.
func Func<TAccumulate,TSource,TAccumulate>
Uma função de acumulador a ser invocada em cada elemento.
resultSelector Func<TAccumulate,TResult>
Uma função para transformar o valor final do acumulador no valor de resultado.
Returns
TResult TResult
O valor final do acumulador transformado.
Exceptions
ArgumentNullException ArgumentNullException
source , func ou resultSelector é null .
Examples
O exemplo de código a seguir demonstra como usar Aggregate para aplicar uma função de acumulador e um seletor
de resultado.
string[] fruits = { "apple", "mango", "orange", "passionfruit", "grape" };
// Determine whether any string in the array is longer than "banana".

string longestName =
fruits.Aggregate("banana",
(longest, next) =>
next.Length > longest.Length ? next : longest,
// Return the final result as an upper case string.
fruit => fruit.ToUpper());
Console.WriteLine(
"The fruit with the longest name is {0}.",
longestName);
// This code produces the following output:

//
// The fruit with the longest name is PASSIONFRUIT.
Remarks
O Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate,
Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>) método torna simples para executar um
cálculo em uma sequência de valores. Esse método funciona chamando func uma vez para cada elemento em source
. Cada vez func é chamado, Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate,
Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>) passa os dois o elemento da sequência e um
valor agregado (como o primeiro argumento para func ). O valor da seed parâmetro é usado como o valor de
agregação inicial. O resultado de func substitui o valor agregado anterior. O resultado final da func é passado para
resultSelector para obter o resultado final de Aggregate<TSource,TAccumulate,TResult>( IEnumerable<TSource>,
TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>).
Para simplificar as operações de agregação comuns, os operadores de consulta padrão também incluem um método
de contagem de uso geral Counte quatro métodos de agregação numéricas, ou seja, Min, Max, Sum, e Average.
TAccumulate, Func<TAccumulate,TSource,TAccumulate>)
acumulador.
public static TAccumulate Aggregate<TSource,TAccumulate> (this

System.Collections.Generic.IEnumerable<TSource> source, TAccumulate seed,
Func<TAccumulate,TSource,TAccumulate> func);
static member Aggregate : seq<'Source> * 'Accumulate * Func<'Accumulate, 'Source, 'Accumulate> ->
'Accumulate
Type Parameters
TSource
TAccumulate
Parameters
Returns
TAccumulate TAccumulate
O valor final do acumulador.
Exceptions
source ou func é null .
Examples
O exemplo de código a seguir demonstra como usar Aggregate para aplicar uma função de acumulador e usar um
valor de semente.
int[] ints = { 4, 8, 8, 3, 9, 0, 7, 8, 2 };
// Count the even numbers in the array, using a seed value of 0.

int numEven = ints.Aggregate(0, (total, next) =>
next % 2 == 0 ? total + 1 : total);
Console.WriteLine("The number of even integers is: {0}", numEven);

//
// The number of even integers is: 6
Remarks
O Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate,
Func<TAccumulate,TSource,TAccumulate>) método torna simples para executar um cálculo em uma sequência de
valores. Esse método funciona chamando func uma vez para cada elemento em source . Cada vez func é chamado,
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)
passa os dois o elemento da sequência e um valor agregado (como o primeiro argumento para func ). O valor da
seed parâmetro é usado como o valor de agregação inicial. O resultado de func substitui o valor agregado anterior.
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)
Retorna o resultado final da func .
Aggregate<TSource>(IEnumerable<TSource>,
Func<TSource,TSource,TSource>) Aggregate<TSource>
(IEnumerable<TSource>, Func<TSource,TSource,TSource>)
public static TSource Aggregate<TSource> (this System.Collections.Generic.IEnumerable<TSource>
source, Func<TSource,TSource,TSource> func);
static member Aggregate : seq<'Source> * Func<'Source, 'Source, 'Source> -> 'Source
Type Parameters
TSource
Parameters
func Func<TSource,TSource,TSource>
Returns
TSource TSource
Exceptions
InvalidOperationException InvalidOperationException
source não contém elementos.
Examples
O exemplo de código a seguir demonstra como reverter a ordem das palavras em uma cadeia de caracteres usando
Aggregate.
string sentence = "the quick brown fox jumps over the lazy dog";
// Split the string into individual words.

string[] words = sentence.Split(' ');
// Prepend each word to the beginning of the

// new sentence to reverse the word order.
string reversed = words.Aggregate((workingSentence, next) =>
next + " " + workingSentence);
Console.WriteLine(reversed);

//
// dog lazy the over jumps fox brown quick the
Remarks
O Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>) método torna simples para
executar um cálculo em uma sequência de valores. Esse método funciona chamando func uma vez para cada
elemento em source , exceto o primeiro deles. Cada vez func é chamado, Aggregate<TSource>
(IEnumerable<TSource>, Func<TSource,TSource,TSource>) passa os dois o elemento da sequência e um valor
agregado (como o primeiro argumento para func ). O primeiro elemento da source é usado como o valor de
agregação inicial. O resultado de func substitui o valor agregado anterior. Aggregate<TSource>
(IEnumerable<TSource>, Func<TSource,TSource,TSource>) Retorna o resultado final da func .
Essa sobrecarga da Aggregate método não é adequado para todos os casos porque ele usa o primeiro elemento da
source como o valor de agregação inicial. Você deve escolher outra sobrecarga se o valor de retorno deve incluir
apenas os elementos de source que atendem determinada condição. Por exemplo, essa sobrecarga não é confiável
para calcular a soma de números pares em source . O resultado será incorreto se o primeiro elemento é ímpar em vez
do mesmo.
Enumerable.All Enumerable.All
I n this Article
public static bool All<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,bool> predicate);
static member All : seq<'Source> * Func<'Source, bool> -> bool
Type Parameters
TSource
Parameters
Um IEnumerable<T> que contém os elementos aos quais o predicado será aplicado.
predicate Func<TSource,Boolean>
Uma função para testar cada elemento em relação a uma condição.
Returns
Boolean Boolean
true se todos os elementos da sequência de origem passarem no teste no predicado especificado ou se a sequência
for vazia; caso contrário, false .
Exceptions
source ou predicate é null .
Examples
O exemplo de código a seguir demonstra como usar All para determinar se todos os elementos em uma sequência
satisfazem uma condição. Variável allStartWithB é true se todos os nomes de animal de estimação iniciar com "B" ou
se o pets matriz está vazia.
class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}
public static void AllEx()

{
// Create an array of Pets.
Pet[] pets = { new Pet { Name="Barley", Age=10 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=6 } };
// Determine whether all pet names

// in the array start with 'B'.
bool allStartWithB = pets.All(pet =>
pet.Name.StartsWith("B"));
Console.WriteLine(
"{0} pet names start with 'B'.",
allStartWithB ? "All" : "Not all");
}

//
// Not all pet names start with 'B'.
O valor booleano que o All método retorna, normalmente é usada no predicado de um where cláusula ( Where
cláusula no Visual Basic) ou uma chamada direta para o Where método. O exemplo a seguir demonstra o uso do All
método.
class Pet
{
}
class Person
{
public string LastName { get; set; }
public Pet[] Pets { get; set; }
}
public static void AllEx2()

{
List<Person> people = new List<Person>
{ new Person { LastName = "Haas",
Pets = new Pet[] { new Pet { Name="Barley", Age=10 },
new Pet { Name="Whiskers", Age=6 }}},
new Person { LastName = "Fakhouri",
Pets = new Pet[] { new Pet { Name = "Snowball", Age = 1}}},
new Person { LastName = "Antebi",
Pets = new Pet[] { new Pet { Name = "Belle", Age = 8} }},
new Person { LastName = "Philips",
Pets = new Pet[] { new Pet { Name = "Sweetie", Age = 2},
new Pet { Name = "Rover", Age = 13}} }
};
// Determine which people have pets that are all older than 5.
IEnumerable<string> names = from person in people
where person.Pets.All(pet => pet.Age > 5)
select person.LastName;
foreach (string name in names)

{
Console.WriteLine(name);
}
/* This code produces the following output:

*
* Haas
* Antebi
*/
}
Remarks
Note
Esse método não retorna todos os elementos de uma coleção. Em vez disso, ele determina se todos os elementos de
uma coleção satisfazem uma condição.
A enumeração de source é interrompido assim que o resultado pode ser determinado.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into All() cláusula se traduz em uma
invocação de All.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also
Enumerable.Any Enumerable.Any
I n this Article
Overloads
Any<TSource>(IEnumerable<TSource>) Any<TSource>(
IEnumerable<TSource>) Determina se uma sequência contém elementos.
Any<TSource>(IEnumerable<TSource>, Func<TSource,
Boolean>) Any<TSource>(IEnumerable<TSource>, Func< Determina se algum elemento de uma sequência atende a
TSource,Boolean>) uma condição.
Any<TSource>(IEnumerable<TSource>) Any<TSource>
(IEnumerable<TSource>)
public static bool Any<TSource> (this System.Collections.Generic.IEnumerable<TSource> source);
static member Any : seq<'Source> -> bool
Type Parameters
TSource
Parameters
O IEnumerable<T> a ser verificado se está vazio.
Returns
Boolean Boolean
true se a sequência de origem contiver elementos; caso contrário, false .
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Any para determinar se uma sequência contém elementos.
List<int> numbers = new List<int> { 1, 2 };
bool hasElements = numbers.Any();
Console.WriteLine("The list {0} empty.",

hasElements ? "is not" : "is");

//
// The list is not empty.
O valor booleano que o Any<TSource>(IEnumerable<TSource>) método retorna, normalmente é usada no predicado
de um where cláusula ( Where cláusula no Visual Basic) ou uma chamada direta para o Where<TSource>
(IEnumerable<TSource>, Func<TSource,Boolean>) método. O exemplo a seguir demonstra o uso do Any método.
class Pet
{
}
class Person
{
}
public static void AnyEx2()

{
Pets = new Pet[] { }},
};
// Determine which people have a non-empty Pet array.

where person.Pets.Any()

{
}
Haas
Fakhouri
Philips
*/
}
Remarks
Note
Esse método não retorna qualquer elemento de uma coleção. Em vez disso, ele determina se a coleção contém
quaisquer elementos.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Any() cláusula se traduz em uma
invocação de Any.
See
Also
Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)Any<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>)
Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
public static bool Any<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,

static member Any : seq<'Source> * Func<'Source, bool> -> bool
Type Parameters
TSource
Parameters
Um IEnumerable<T> a cujos elementos o predicado será aplicado.
Returns
Boolean Boolean
true se algum elemento na sequência de origem for aprovado no teste do predicado especificado; caso contrário,
false .
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Any para determinar se qualquer elemento em uma sequência
satisfazem uma condição.
class Pet
{
public bool Vaccinated { get; set; }
}

{
Pet[] pets =
{ new Pet { Name="Barley", Age=8, Vaccinated=true },
new Pet { Name="Boots", Age=4, Vaccinated=false },
new Pet { Name="Whiskers", Age=1, Vaccinated=false } };
// Determine whether any pets over age 1 are also unvaccinated.

bool unvaccinated =
pets.Any(p => p.Age > 1 && p.Vaccinated == false);
Console.WriteLine(
"There {0} unvaccinated animals over age one.",
unvaccinated ? "are" : "are not any");
}

//
// There are unvaccinated animals over age one.
Remarks
Note
Esse método não retorna qualquer elemento de uma coleção. Em vez disso, ele determina se os elementos de uma
coleção satisfazem uma condição.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Any() cláusula se traduz em uma
invocação de Any.
Also
Enumerable.Append Enumerable.Append
I n this Article
Acrescenta um valor ao final da sequência.
public static System.Collections.Generic.IEnumerable<TSource> Append<TSource> (this
System.Collections.Generic.IEnumerable<TSource> source, TSource element);
static member Append : seq<'Source> * 'Source -> seq<'Source>
Type Parameters
TSource
Parameters
Uma sequência de valores.
element TSource TSource
O valor a ser acrescentado a source .
Returns
IEnumerable<TSource>
Uma nova sequência que termina com element .
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Append para acrescentar um valor ao final da sequência.
// Creating a list of numbers
List<int> numbers = new List<int> { 1, 2, 3, 4 };
// Trying to append any value of the same type

numbers.Append(5);
// It doesn't work because the original list has not been changed
Console.WriteLine(string.Join(", ", numbers));
// It works now because we are using a changed copy of the original list
Console.WriteLine(string.Join(", ", numbers.Append(5)));
// If you prefer, you can create a new list explicitly

List<int> newNumbers = numbers.Append(5).ToList();
// And then write to the console output

Console.WriteLine(string.Join(", ", newNumbers));

//
// 1, 2, 3, 4
// 1, 2, 3, 4, 5
// 1, 2, 3, 4, 5
Remarks
Note
Esse método não modifica os elementos da coleção. Em vez disso, ele cria uma cópia da coleção com o novo elemento.
Enumerable.AsEnumerable Enumerable.AsEnumerable
I n this Article
Retorna a entrada digitada como IEnumerable<T>.
public static System.Collections.Generic.IEnumerable<TSource> AsEnumerable<TSource> (this
System.Collections.Generic.IEnumerable<TSource> source);
static member AsEnumerable : seq<'Source> -> seq<'Source>
Type Parameters
TSource
Parameters
A sequência a ser digitada como IEnumerable<T>.
Returns
A sequência de entrada digitada como IEnumerable<T>.
Examples
O exemplo de código a seguir demonstra como usar AsEnumerable<TSource>(IEnumerable<TSource>) para ocultar
um tipo do personalizado Where método quando a implementação do operador de consulta padrão é desejada.
// Custom class.
class Clump<T> : List<T>
{
// Custom implementation of Where().
public IEnumerable<T> Where(Func<T, bool> predicate)
{
Console.WriteLine("In Clump's implementation of Where().");
return Enumerable.Where(this, predicate);
}
}
static void AsEnumerableEx1()

{
// Create a new Clump<T> object.
Clump<string> fruitClump =
new Clump<string> { "apple", "passionfruit", "banana",
"mango", "orange", "blueberry", "grape", "strawberry" };
// First call to Where():

// Call Clump's Where() method with a predicate.
IEnumerable<string> query1 =
fruitClump.Where(fruit => fruit.Contains("o"));
Console.WriteLine("query1 has been created.

");
// Second call to Where():

// First call AsEnumerable() to hide Clump's Where() method and thereby
// force System.Linq.Enumerable's Where() method to be called.
fruitClump.AsEnumerable().Where(fruit => fruit.Contains("o"));
// Display the output.

Console.WriteLine("query2 has been created.");
}

//
// In Clump's implementation of Where().
// query1 has been created.
//
// query2 has been created.
Remarks
O AsEnumerable<TSource>(IEnumerable<TSource>) método não tem nenhum efeito diferente de alterar o tipo de
tempo de compilação de source de um tipo que implementa IEnumerable<T> para IEnumerable<T> em si.
AsEnumerable<TSource>(IEnumerable<TSource>) pode ser usado para escolher entre implementações de consulta

quando uma sequência implementa IEnumerable<T> , mas também tem um conjunto diferente de métodos de
consulta públicas disponíveis. Por exemplo, dada uma classe genérica Table que implementa IEnumerable<T> e tem
seus próprios métodos, como Where , Select , e SelectMany , uma chamada para Where invocaria o público Where
método Table . Um Table tipo que representa uma tabela de banco de dados poderia ter um Where método que usa
o argumento como uma árvore de expressão de predicado e converte a árvore para o SQL para execução remota. Se a
execução remota não for desejada, por exemplo porque o predicado invoca um método de local, o AsEnumerable
método pode ser usado para ocultar os métodos personalizados e disponibilizar os operadores de consulta padrão em
vez disso.
Enumerable.Average Enumerable.Average
I n this Article
Overloads
Average(IEnumerable<Single>) Average(IEnumerable<
Single>) Computa a média de uma sequência de valores Single.
Average(IEnumerable<Nullable<Single>>) Average(
IEnumerable<Nullable<Single>>) Computa a média de uma sequência de valores Single que
permitem valores nulos.
Average(IEnumerable<Nullable<Int64>>) Average(
IEnumerable<Nullable<Int64>>) Computa a média de uma sequência de valores Int64 que
Average(IEnumerable<Nullable<Int32>>) Average(
IEnumerable<Nullable<Int32>>) Computa a média de uma sequência de valores Int32 que
Average(IEnumerable<Nullable<Double>>) Average(
IEnumerable<Nullable<Double>>) Computa a média de uma sequência de valores Double que
Average(IEnumerable<Int64>) Average(IEnumerable<Int64>)
Average(IEnumerable<Double>) Average(IEnumerable<
Double>) Computa a média de uma sequência de valores Double.
Average(IEnumerable<Decimal>) Average(IEnumerable<
Decimal>) Computa a média de uma sequência de valores Decimal.
Average(IEnumerable<Nullable<Decimal>>) Average(
IEnumerable<Nullable<Decimal>>) Computa a média de uma sequência de valores Decimal que
Average<TSource>(IEnumerable<TSource>, Func<TSource,
Nullable<Int32>>) Average<TSource>(IEnumerable< Calcula a média de uma sequência de valores Int32 que
TSource>, Func<TSource,Nullable<Int32>>) permitem valor nulo obtidos pela invocação de uma função de
Single>) Average<TSource>(IEnumerable<TSource>, Func< Calcula a média de uma sequência de valores Single obtidos
TSource,Single>) pela invocação de uma função de transformação em cada
Nullable<Single>>) Average<TSource>(IEnumerable< Calcula a média de uma sequência de valores Single que
TSource>, Func<TSource,Nullable<Single>>) permitem valor nulo obtidos pela invocação de uma função de
Nullable<Int64>>) Average<TSource>(IEnumerable< Calcula a média de uma sequência de valores Int64 que
TSource>, Func<TSource,Nullable<Int64>>) permitem valor nulo obtidos pela invocação de uma função de
Nullable<Double>>) Average<TSource>(IEnumerable< Calcula a média de uma sequência de valores Double que
TSource>, Func<TSource,Nullable<Double>>) permitem valor nulo obtidos pela invocação de uma função de
Nullable<Decimal>>) Average<TSource>(IEnumerable< Calcula a média de uma sequência de valores Decimal que
TSource>, Func<TSource,Nullable<Decimal>>) permitem valor nulo obtidos pela invocação de uma função de
Int64>) Average<TSource>(IEnumerable<TSource>, Func< Calcula a média de uma sequência de valores Int64 obtidos
TSource,Int64>) pela invocação de uma função de transformação em cada
Int32>) Average<TSource>(IEnumerable<TSource>, Func< Calcula a média de uma sequência de valores Int32 obtidos
TSource,Int32>) pela invocação de uma função de transformação em cada
Double>) Average<TSource>(IEnumerable<TSource>, Func< Calcula a média de uma sequência de valores Double obtidos
TSource,Double>) pela invocação de uma função de transformação em cada
Decimal>) Average<TSource>(IEnumerable<TSource>, Func< Calcula a média de uma sequência de valores Decimal obtidos
TSource,Decimal>) pela invocação de uma função de transformação em cada
Average(IEnumerable<Single>) Average(IEnumerable<Single>)
public static float Average (this System.Collections.Generic.IEnumerable<float> source);

static member Average : seq<single> -> single
Parameters
source IEnumerable<Single>
Uma sequência de valores Single para realizar o cálculo da média.
Returns
Single Single
A média da sequência de valores.
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Average(IEnumerable<Int32>) para calcular uma média.
Note
Este exemplo de código usa uma sobrecarga desse método sobrecarregado que é diferente da sobrecarga específica
descrita neste tópico. Para estender o exemplo para este tópico, substitua os elementos da sequência de origem por
elementos do tipo numérico adequado.
List<int> grades = new List<int> { 78, 92, 100, 37, 81 };
double average = grades.Average();
Console.WriteLine("The average grade is {0}.", average);

//
// The average grade is 77.6.
Remarks
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Average() cláusula se traduz em uma
invocação de Average.
Also
public static Nullable<float> Average (this System.Collections.Generic.IEnumerable<Nullable<float>>

source);
static member Average : seq<Nullable<single>> -> Nullable<single>
Parameters
source IEnumerable<Nullable<Single>>
Uma sequência de valores Single que permitem valores nulos para cálculo da média.
Returns
Nullable<Single>
A média da sequência de valores ou null , se a sequência de origem estiver vazia ou contiver somente valores que são
null .
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Average(IEnumerable<Nullable<Int64>>) para calcular uma
média.
Note
long?[] longs = { null, 10007L, 37L, 399846234235L };
double? average = longs.Average();
Console.WriteLine("The average is {0}.", average);

//
// The average is 133282081426.333.
Remarks
Also
public static Nullable<double> Average (this System.Collections.Generic.IEnumerable<Nullable<long>>

source);
static member Average : seq<Nullable<int64>> -> Nullable<double>
Parameters
source IEnumerable<Nullable<Int64>>
Uma sequência de valores Int64 que permitem valores nulos para cálculo da média.
Returns
Nullable<Double>
null .
Exceptions
source é null .
OverflowException OverflowException
A soma dos elementos na sequência é maior do que MaxValue.
Examples
média.

//
// The average is 133282081426.333.
Remarks
Also
public static Nullable<double> Average (this System.Collections.Generic.IEnumerable<Nullable<int>>

source);
static member Average : seq<Nullable<int>> -> Nullable<double>
Parameters
Returns
Nullable<Double>
null .
Exceptions
source é null .
Examples
média.
Note

//
// The average is 133282081426.333.
Remarks
Also
public static Nullable<double> Average (this

System.Collections.Generic.IEnumerable<Nullable<double>> source);
static member Average : seq<Nullable<double>> -> Nullable<double>
Parameters
source IEnumerable<Nullable<Double>>
Uma sequência de valores Double que permitem valores nulos para cálculo da média.
Returns
Nullable<Double>
null .
Exceptions
source é null .
Examples
média.
Note

//
// The average is 133282081426.333.
Remarks
Se a soma dos elementos é muito grande para ser representado como um Double, esse método retorna infinito
positivo ou negativo.
Also
public static double Average (this System.Collections.Generic.IEnumerable<long> source);

static member Average : seq<int64> -> double
Parameters
source IEnumerable<Int64>
Uma sequência de valores Int64 para realizar o cálculo da média.
Returns
Double Double
Exceptions
source é null .
Examples
Note

//
Remarks
Also
public static double Average (this System.Collections.Generic.IEnumerable<int> source);

static member Average : seq<int> -> double
Parameters
Returns
Double Double
Exceptions
source é null .
Examples

//
Remarks
Also
Average(IEnumerable<Double>) Average(IEnumerable<Double>)
public static double Average (this System.Collections.Generic.IEnumerable<double> source);

static member Average : seq<double> -> double
Parameters
source IEnumerable<Double>
Uma sequência de valores Double para realizar o cálculo da média.
Returns
Double Double
Exceptions
source é null .
Examples
Note

//
Remarks
Se a soma dos elementos é muito grande para ser representado como um Double, esse método retorna infinito
positivo ou negativo.
Also
public static decimal Average (this System.Collections.Generic.IEnumerable<decimal> source);

static member Average : seq<decimal> -> decimal
Parameters
source IEnumerable<Decimal>
Uma sequência de valores Decimal para realizar o cálculo da média.
Returns
Decimal Decimal
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Average(IEnumerable<Int32>) para calcular a média de uma
sequência de valores.
Note

//
Remarks
Also
public static Nullable<decimal> Average (this

System.Collections.Generic.IEnumerable<Nullable<decimal>> source);
static member Average : seq<Nullable<decimal>> -> Nullable<decimal>
Parameters
source IEnumerable<Nullable<Decimal>>
Uma sequência de valores Decimal que permitem valores nulos para cálculo da média.
Returns
Nullable<Decimal>
null .
Exceptions
source é null .
Examples
média.
Note

//
// The average is 133282081426.333.
Remarks
Also
Average<TSource>(IEnumerable<TSource>,
Func<TSource,Nullable<Int32>>) Average<TSource>
(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)
Calcula a média de uma sequência de valores Int32 que permitem valor nulo obtidos pela invocação de uma função de
public static Nullable<double> Average<TSource> (this

System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,Nullable<int>> selector);
static member Average : seq<'Source> * Func<'Source, Nullable<int>> -> Nullable<double>
Type Parameters
TSource
Parameters
Uma sequência de valores para cálculo da média.
selector Func<TSource,Nullable<Int32>>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Nullable<Double>
null .
Exceptions
source ou selector é null .
Examples
O exemplo de código a seguir demonstra como usar Average<TSource>(IEnumerable<TSource>,
Func<TSource,Int32>) para calcular uma média.
Note
descrita neste tópico. Para estender o exemplo a este tópico, altere o corpo da função selector .
string[] fruits = { "apple", "banana", "mango", "orange", "passionfruit", "grape" };
double average = fruits.Average(s => s.Length);
Console.WriteLine("The average string length is {0}.", average);

//
// The average string length is 6.5.
Remarks
Also
Func<TSource,Single>) Average<TSource>
(IEnumerable<TSource>, Func<TSource,Single>)
Calcula a média de uma sequência de valores Single obtidos pela invocação de uma função de transformação em cada
public static float Average<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,float> selector);
static member Average : seq<'Source> * Func<'Source, single> -> single
Type Parameters
TSource
Parameters
selector Func<TSource,Single>
Returns
Single Single
Exceptions
Examples
Note

//
Remarks
Also
Func<TSource,Nullable<Single>>) Average<TSource>
(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)
Calcula a média de uma sequência de valores Single que permitem valor nulo obtidos pela invocação de uma função
de transformação em cada elemento da sequência de entrada.
public static Nullable<float> Average<TSource> (this System.Collections.Generic.IEnumerable<TSource>

source, Func<TSource,Nullable<float>> selector);
static member Average : seq<'Source> * Func<'Source, Nullable<single>> -> Nullable<single>
Type Parameters
TSource
Parameters
selector Func<TSource,Nullable<Single>>
Returns
Nullable<Single>
null .
Exceptions
Examples
Note

//
Remarks
Also
Calcula a média de uma sequência de valores Int64 que permitem valor nulo obtidos pela invocação de uma função de
System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,Nullable<long>> selector);
static member Average : seq<'Source> * Func<'Source, Nullable<int64>> -> Nullable<double>
Type Parameters
TSource
Parameters
Returns
Nullable<Double>
null .
Examples
Note
string[] numbers = { "10007", "37", "299846234235" };
double average = numbers.Average(num => Convert.ToInt64(num));

//
// The average is 99948748093.
Remarks
Also
Func<TSource,Nullable<Double>>) Average<TSource>
(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)
Calcula a média de uma sequência de valores Double que permitem valor nulo obtidos pela invocação de uma função

System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,Nullable<double>> selector);
static member Average : seq<'Source> * Func<'Source, Nullable<double>> -> Nullable<double>
Type Parameters
TSource
Parameters
selector Func<TSource,Nullable<Double>>
Returns
Nullable<Double>
null .
Exceptions
Examples
Note
string[] numbers = { "10007", "37", "299846234235" };

//
Remarks
Also
Func<TSource,Nullable<Decimal>>) Average<TSource>
(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)
Calcula a média de uma sequência de valores Decimal que permitem valor nulo obtidos pela invocação de uma função
public static Nullable<decimal> Average<TSource> (this
System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,Nullable<decimal>> selector);
static member Average : seq<'Source> * Func<'Source, Nullable<decimal>> -> Nullable<decimal>
Type Parameters
TSource
Parameters
selector Func<TSource,Nullable<Decimal>>
Returns
Nullable<Decimal>
null .
Exceptions
Examples
Note
string[] numbers = { "10007", "37", "299846234235" };

//
Remarks
Also
Func<TSource,Int64>) Average<TSource>
(IEnumerable<TSource>, Func<TSource,Int64>)
Calcula a média de uma sequência de valores Int64 obtidos pela invocação de uma função de transformação em cada
public static double Average<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,long> selector);
static member Average : seq<'Source> * Func<'Source, int64> -> double
Type Parameters
TSource
O tipo dos elementos da fonte.
Parameters
selector Func<TSource,Int64>
Returns
Double Double
Exceptions
Examples
string[] numbers = { "10007", "37", "299846234235" };

//
Remarks
Also
(IEnumerable<TSource>, Func<TSource,Int32>)
Calcula a média de uma sequência de valores Int32 obtidos pela invocação de uma função de transformação em cada
Func<TSource,int> selector);
static member Average : seq<'Source> * Func<'Source, int> -> double
Type Parameters
TSource
Parameters
Returns
Double Double
Exceptions
Examples

//
Remarks
Also
Func<TSource,Double>) Average<TSource>
(IEnumerable<TSource>, Func<TSource,Double>)
Calcula a média de uma sequência de valores Double obtidos pela invocação de uma função de transformação em

Func<TSource,double> selector);
static member Average : seq<'Source> * Func<'Source, double> -> double
Type Parameters
TSource
Parameters
selector Func<TSource,Double>
Returns
Double Double
Exceptions
Examples
Note
string[] numbers = { "10007", "37", "299846234235" };

//
Remarks
Also
Func<TSource,Decimal>) Average<TSource>
(IEnumerable<TSource>, Func<TSource,Decimal>)
Calcula a média de uma sequência de valores Decimal obtidos pela invocação de uma função de transformação em
public static decimal Average<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,decimal> selector);
static member Average : seq<'Source> * Func<'Source, decimal> -> decimal
Type Parameters
TSource
Parameters
Uma sequência de valores usados para calcular uma média.
selector Func<TSource,Decimal>
Returns
Decimal Decimal
Exceptions
Examples
Note
string[] numbers = { "10007", "37", "299846234235" };

//
Remarks
Also
Enumerable.Cast Enumerable.Cast
I n this Article
Converte os elementos de um IEnumerable para o tipo especificado.
public static System.Collections.Generic.IEnumerable<TResult> Cast<TResult> (this
System.Collections.IEnumerable source);
static member Cast : System.Collections.IEnumerable -> seq<'Result>
Type Parameters
TResult
O tipo no qual os elementos de source deverão ser convertidos.
Parameters
source IEnumerable IEnumerable
O IEnumerable que contém os elementos a serem convertidos no tipo TResult .
Returns
IEnumerable<TResult>
Um IEnumerable<T> que contém cada elemento da sequência de origem convertido para o tipo especificado.
Exceptions
source é null .
InvalidCastException InvalidCastException
Um elemento na sequência não pode ser convertido para o tipo TResult .
Examples
O exemplo de código a seguir demonstra como usar Cast<TResult>(IEnumerable) para habilitar o uso de operadores
de consulta padrão em um ArrayList.
System.Collections.ArrayList fruits = new System.Collections.ArrayList();
fruits.Add("mango");
fruits.Add("apple");
fruits.Add("lemon");
IEnumerable<string> query =
fruits.Cast<string>().OrderBy(fruit => fruit).Select(fruit => fruit);
// The following code, without the cast, doesn't compile.

//IEnumerable<string> query1 =
// fruits.OrderBy(fruit => fruit).Select(fruit => fruit);
foreach (string fruit in query)

{
Console.WriteLine(fruit);
}

//
// apple
// lemon
// mango
Remarks
Esse método é implementado usando a execução adiada. O imediata valor retornado é um objeto que armazena todas
as informações necessárias para executar a ação. A consulta representada por esse método não é executada até que o
objeto é enumerado chamando-se suas GetEnumerator método diretamente ou usando foreach no Visual c# ou
For Each no Visual Basic.
O Cast<TResult>(IEnumerable) método permite que os operadores de consulta padrão a ser invocada em coleções
não genéricas, fornecendo as informações de tipo necessários. Por exemplo, ArrayList não implementa
IEnumerable<T>, mas chamando Cast<TResult>(IEnumerable) sobre o ArrayList do objeto, os operadores de consulta
padrão, em seguida, podem ser usados para consultar a sequência.
Se um elemento não pode ser convertido no tipo TResult , esse método lança um InvalidCastException.
A sequência de origem para este método é IEnumerable, que significa que os elementos têm o tipo estático do tempo
de compilação da object . Apenas conversões de tipo que são executadas por esse método são conversões de
referência e conversões unboxing. O tipo de tempo de execução dos elementos na coleção deve corresponder ao tipo
de destino ou, no caso de tipos de valor, o tipo de tempo de execução dos elementos deve ser o resultado de uma
conversão boxing do tipo de destino. Outros tipos de conversão, como aqueles entre diferentes tipos numéricos, não
são permitidos.
Para obter apenas os elementos que podem ser convertidos para o tipo TResult , use o OfType método em vez de
Cast<TResult>(IEnumerable).
Em uma expressão de consulta, uma variável de iteração digitadas explicitamente se traduz em uma invocação de
Cast<TResult>(IEnumerable). Este exemplo mostra a sintaxe para uma variável de intervalo de tipo explícito.
from int i in objects
Use o select cláusula de uma consulta para executar outros tipos de conversão, como as conversões numéricas
implícitas. O exemplo a seguir usa o Cast método e um select instrução para converter uma sequência de inteiros
demarcados em uma sequência de duplicatas.
IEnumerable sequence = Enumerable.Range(0, 10);
var doubles = from int item in sequence
select (double)item;
See Cláusula from (Referência de C#)from clause (C# Reference)

Also Cláusula From (Visual Basic)From Clause (Visual Basic)
Enumerable.Concat Enumerable.Concat
I n this Article
public static System.Collections.Generic.IEnumerable<TSource> Concat<TSource> (this
System.Collections.Generic.IEnumerable<TSource> first,
System.Collections.Generic.IEnumerable<TSource> second);
static member Concat : seq<'Source> * seq<'Source> -> seq<'Source>
Type Parameters
TSource
O tipo dos elementos das sequências de entrada.
Parameters
first IEnumerable<TSource>
A primeira sequência a ser concatenada.
second IEnumerable<TSource>
A sequência a ser concatenada com a primeira sequência.
Returns
Um IEnumerable<T> que contém os elementos concatenados das duas sequências de entrada.
Exceptions
first ou second é null .
Examples
O exemplo de código a seguir demonstra como usar Concat<TSource>(IEnumerable<TSource>,
IEnumerable<TSource>) para concatenar duas sequências.
class Pet
{
}
static Pet[] GetCats()

{
Pet[] cats = { new Pet { Name="Barley", Age=8 },
return cats;
}
static Pet[] GetDogs()

{
Pet[] dogs = { new Pet { Name="Bounder", Age=3 },
new Pet { Name="Snoopy", Age=14 },
new Pet { Name="Fido", Age=9 } };
return dogs;
}
public static void ConcatEx1()

{
Pet[] cats = GetCats();
Pet[] dogs = GetDogs();
cats.Select(cat => cat.Name).Concat(dogs.Select(dog => dog.Name));
foreach (string name in query)

{
}
}

//
// Barley
// Boots
// Whiskers
// Bounder
// Snoopy
// Fido
Uma maneira alternativa de concatenar duas sequências é construir uma coleção, por exemplo uma matriz de
sequências e, em seguida, aplicar o SelectMany método, passando a ele a função de seletor de identidade. O exemplo a
seguir demonstra o uso de SelectMany.
new[] { cats.Select(cat => cat.Name), dogs.Select(dog => dog.Name) }
.SelectMany(name => name);

{
}

//
// Barley
// Boots
// Whiskers
// Bounder
// Snoopy
// Fido
Remarks
O Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) difere do método de Union método porque o

Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) método retorna todos os elementos originais
nas sequências de entrada. O Union método retorna apenas os elementos exclusivos.
Enumerable.Contains Enumerable.Contains
I n this Article
Overloads
Contains<TSource>(IEnumerable<TSource>, TSource) Determina se uma sequência contém um elemento
especificado usando o comparador de igualdade padrão.
Contains<TSource>(IEnumerable<TSource>, TSource,
IEqualityComparer<TSource>) Contains<TSource>( Determina se uma sequência contém um elemento
IEnumerable<TSource>, TSource, IEqualityComparer< especificado usando um IEqualityComparer<T> especificado.
TSource>)
public static bool Contains<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
TSource value);
static member Contains : seq<'Source> * 'Source -> bool
Type Parameters
TSource
Parameters
Uma sequência na qual um valor será localizado.
value TSource TSource
O valor a ser localizado na sequência.
Returns
Boolean Boolean
true se a sequência de origem contiver um elemento que tem o valor especificado; caso contrário, false .
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Contains<TSource>(IEnumerable<TSource>, TSource) para
determinar se uma matriz contém um elemento específico.
string fruit = "mango";
bool hasMango = fruits.Contains(fruit);
Console.WriteLine(
"The array {0} contain '{1}'.",
hasMango ? "does" : "does not",
fruit);

//
// The array does contain 'mango'.
Remarks
Se o tipo de source implementa ICollection<T>, o Contains método em que a implementação é chamado para obter
o resultado. Caso contrário, este método determina se source contém o elemento especificado.
Enumeração será encerrada assim que um elemento correspondente for encontrado.
Elementos são comparados com o valor especificado usando o comparador de igualdade padrão, Default.
Contains<TSource>(IEnumerable<TSource>, TSource,
IEqualityComparer<TSource>) Contains<TSource>
(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)
public static bool Contains<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,

TSource value, System.Collections.Generic.IEqualityComparer<TSource> comparer);
static member Contains : seq<'Source> * 'Source *
System.Collections.Generic.IEqualityComparer<'Source> -> bool
Type Parameters
TSource
Parameters
comparer IEqualityComparer<TSource>
Um comparador de igualdade para comparar valores.
Returns
Boolean Boolean
true se a sequência de origem contiver um elemento que tem o valor especificado; caso contrário, false .
Exceptions
source é null .
Examples
O exemplo a seguir mostra como implementar um comparador de igualdade que pode ser usado no Contains método.
public class Product
{
public int Code { get; set; }
}
// Custom comparer for the Product class

class ProductComparer : IEqualityComparer<Product>
{
// Products are equal if their names and product numbers are equal.
public bool Equals(Product x, Product y)
{
//Check whether the compared objects reference the same data.

if (Object.ReferenceEquals(x, y)) return true;
//Check whether any of the compared objects is null.

if (Object.ReferenceEquals(x, null) || Object.ReferenceEquals(y, null))
return false;
//Check whether the products' properties are equal.

return x.Code == y.Code && x.Name == y.Name;
}
// If Equals() returns true for a pair of objects

// then GetHashCode() must return the same value for these objects.
public int GetHashCode(Product product)

{
//Check whether the object is null
if (Object.ReferenceEquals(product, null)) return 0;
//Get hash code for the Name field if it is not null.

int hashProductName = product.Name == null ? 0 : product.Name.GetHashCode();
//Get hash code for the Code field.

int hashProductCode = product.Code.GetHashCode();
//Calculate the hash code for the product.

return hashProductName ^ hashProductCode;
}
Depois de implementar esse comparador, você pode usar uma sequência de Product objetos no Contains método,
conforme mostrado no exemplo a seguir.
Product[] fruits = { new Product { Name = "apple", Code = 9 },
new Product { Name = "orange", Code = 4 },
new Product { Name = "lemon", Code = 12 } };
Product apple = new Product { Name = "apple", Code = 9 };

Product kiwi = new Product {Name = "kiwi", Code = 8 };
ProductComparer prodc = new ProductComparer();
bool hasApple = fruits.Contains(apple, prodc);

bool hasKiwi = fruits.Contains(kiwi, prodc);
Console.WriteLine("Apple? " + hasApple);

Console.WriteLine("Kiwi? " + hasKiwi);
/*
This code produces the following output:
Apple? True
Kiwi? False
*/
Remarks
Enumeração será encerrada assim que um elemento correspondente for encontrado.
Se comparer está null , o comparador de igualdade padrão, Default, é usado para comparar elementos para o valor
especificado.
Enumerable.Count Enumerable.Count
I n this Article
Overloads
Count<TSource>(IEnumerable<TSource>) Count<TSource>(
IEnumerable<TSource>) Retorna o número de elementos em uma sequência.
Count<TSource>(IEnumerable<TSource>, Func<TSource,
Boolean>) Count<TSource>(IEnumerable<TSource>, Func< Retorna um número que representa quantos elementos na
TSource,Boolean>) sequência especificada atendem a uma condição.
Count<TSource>(IEnumerable<TSource>) Count<TSource>
public static int Count<TSource> (this System.Collections.Generic.IEnumerable<TSource> source);
static member Count : seq<'Source> -> int
Type Parameters
TSource
Parameters
Uma sequência que contém os elementos a serem contados.
Returns
Int32 Int32
O número de elementos na sequência de entrada.
Exceptions
source é null .
O número de elementos no source é maior que MaxValue.
Examples
O exemplo de código a seguir demonstra como usar Count<TSource>(IEnumerable<TSource>) para contar os
elementos em uma matriz.
try
{
int numberOfFruits = fruits.Count();
Console.WriteLine(
"There are {0} fruits in the collection.",
numberOfFruits);
}
catch (OverflowException)
{
Console.WriteLine("The count is too large to store as an Int32.");
Console.WriteLine("Try using the LongCount() method instead.");
}

//
// There are 6 fruits in the collection.
Remarks
Se o tipo de source implementa ICollection<T>, que a implementação é usada para obter a contagem de elementos.
Caso contrário, este método determina a contagem.
Use o LongCount método quando você esperar e deseja permitir que o resultado seja maior do que MaxValue.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Count() cláusula se traduz em uma
invocação de Count.
Also
Count<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) Count<TSource>
(IEnumerable<TSource>, Func<TSource,Boolean>)
Retorna um número que representa quantos elementos na sequência especificada atendem a uma condição.
public static int Count<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
static member Count : seq<'Source> * Func<'Source, bool> -> int
Type Parameters
TSource
Parameters
Uma sequência que contém os elementos a serem testados e contados.
Returns
Int32 Int32
Um número que representa quantos elementos na sequência atendem à condição na função de predicado.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Count<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) para contar os elementos em uma matriz que satisfazem uma condição.
class Pet
{
}
public static void CountEx2()

{
Pet[] pets = { new Pet { Name="Barley", Vaccinated=true },
new Pet { Name="Boots", Vaccinated=false },
new Pet { Name="Whiskers", Vaccinated=false } };
try
{
int numberUnvaccinated = pets.Count(p => p.Vaccinated == false);
Console.WriteLine("There are {0} unvaccinated animals.", numberUnvaccinated);
}
catch (OverflowException)
{
Console.WriteLine("The count is too large to store as an Int32.");
Console.WriteLine("Try using the LongCount() method instead.");
}
}

//
// There are 2 unvaccinated animals.
Remarks
Se o tipo de source implementa ICollection<T>, que a implementação é usada para obter a contagem de elementos.
Caso contrário, este método determina a contagem.
Você deve usar o LongCount método quando você esperar e deseja permitir que o resultado seja maior do que
MaxValue.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Count() cláusula se traduz em uma
invocação de Count.
Also
Enumerable.DefaultIfEmpty Enumerable.DefaultIfEmpty
I n this Article
Overloads
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource) Retorna os elementos da sequência especificada ou o valor
especificado em uma coleção de singletons se a sequência está
vazia.
DefaultIfEmpty<TSource>(IEnumerable<TSource>) DefaultIf
Empty<TSource>(IEnumerable<TSource>) Retornará os elementos da sequência especificada ou o valor
padrão do parâmetro de tipo em uma coleção de singletons se
a sequência estiver vazia.
Retorna os elementos da sequência especificada ou o valor especificado em uma coleção de singletons se a sequência
está vazia.
public static System.Collections.Generic.IEnumerable<TSource> DefaultIfEmpty<TSource> (this
System.Collections.Generic.IEnumerable<TSource> source, TSource defaultValue);
static member DefaultIfEmpty : seq<'Source> * 'Source -> seq<'Source>
Type Parameters
TSource
Parameters
A sequência para a qual será retornado o valor especificado se ela estiver vazia.
defaultValue TSource TSource
O valor a ser retornado se a sequência estiver vazia.
Returns
Um IEnumerable<T> que contém defaultValue se source está vazio; caso contrário, source .
Examples
O exemplo de código a seguir demonstra como usar o DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)
método e especificar um valor padrão. A primeira sequência não está vazia e a segunda sequência está vazia.
class Pet
{
}
public static void DefaultIfEmptyEx2()

{
Pet defaultPet = new Pet { Name = "Default Pet", Age = 0 };
List<Pet> pets1 =
new List<Pet>{ new Pet { Name="Barley", Age=8 },
foreach (Pet pet in pets1.DefaultIfEmpty(defaultPet))

{
Console.WriteLine("Name: {0}", pet.Name);
}
List<Pet> pets2 = new List<Pet>();
foreach (Pet pet in pets2.DefaultIfEmpty(defaultPet))

{
Console.WriteLine("
Name: {0}", pet.Name);
}
}
/*
Name: Barley
Name: Boots
Name: Whiskers
Name: Default Pet

*/
Remarks
Esse método pode ser usado para produzir uma junção externa esquerda quando ele é combinado com o GroupJoin)
método.
See IngressandoJoining
Also
public static System.Collections.Generic.IEnumerable<TSource> DefaultIfEmpty<TSource> (this
static member DefaultIfEmpty : seq<'Source> -> seq<'Source>
Type Parameters
TSource
Parameters
A sequência para a qual será retornado um valor padrão se ela estiver vazia.
Returns
Um objeto IEnumerable<T> que contém o valor padrão do tipo TSource se source estiver vazio; caso contrário,
source .
Exceptions
source é null .
Examples
Os exemplos de código a seguir demonstram como usar DefaultIfEmpty<TSource>(IEnumerable<TSource>) para
fornecer um valor padrão caso a sequência de origem está vazia.
Este exemplo usa uma sequência não vazia.
class Pet
{
}

{
List<Pet> pets =
foreach (Pet pet in pets.DefaultIfEmpty())

{
Console.WriteLine(pet.Name);
}
}
/*
Barley
Boots
Whiskers
*/
Este exemplo usa uma sequência vazia.

List<int> numbers = new List<int>();
foreach (int number in numbers.DefaultIfEmpty())

{
Console.WriteLine(number);
}
/*
0
*/
Remarks
O valor padrão para referência e tipos que permitem valor nulos é null .
Esse método pode ser usado para produzir uma junção externa esquerda quando ele é combinado com o GroupJoin)
método.
Also
Enumerable.Distinct Enumerable.Distinct
I n this Article
Overloads
Distinct<TSource>(IEnumerable<TSource>) Distinct<
TSource>(IEnumerable<TSource>) Retorna os elementos distintos de uma sequência usando o
comparador de igualdade padrão para comparar valores.
Distinct<TSource>(IEnumerable<TSource>, IEquality
Comparer<TSource>) Distinct<TSource>(IEnumerable< Retorna os elementos distintos de uma sequência usando um
TSource>, IEqualityComparer<TSource>) IEqualityComparer<T> especificado para comparar valores.
Remarks
A sequência de resultado é desordenada.
Distinct<TSource>(IEnumerable<TSource>) Distinct<TSource>
Retorna os elementos distintos de uma sequência usando o comparador de igualdade padrão para comparar valores.
public static System.Collections.Generic.IEnumerable<TSource> Distinct<TSource> (this
static member Distinct : seq<'Source> -> seq<'Source>
Type Parameters
TSource
Parameters
A sequência da qual os elementos duplicados serão removidos.
Returns
Um IEnumerable<T> que contém elementos distintos da sequência de origem.
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Distinct<TSource>(IEnumerable<TSource>) retornar elementos
distintos de uma sequência de inteiros.
List<int> ages = new List<int> { 21, 46, 46, 55, 17, 21, 55, 55 };
IEnumerable<int> distinctAges = ages.Distinct();
Console.WriteLine("Distinct ages:");
foreach (int age in distinctAges)

{
Console.WriteLine(age);
}
/*
Distinct ages:
21
46
55
17
*/
Se você quiser retornar elementos distintos de sequências de objetos de algum tipo de dados personalizado, você
precisa implementar o IEquatable<T> interface genérica na classe. O exemplo de código a seguir mostra como
implementar essa interface em um tipo de dados personalizadas e fornecer GetHashCode e Equals métodos.
public class Product : IEquatable<Product>

{
public bool Equals(Product other)

{
//Check whether the compared object is null.

if (Object.ReferenceEquals(other, null)) return false;
//Check whether the compared object references the same data.

if (Object.ReferenceEquals(this, other)) return true;

return Code.Equals(other.Code) && Name.Equals(other.Name);
}

public override int GetHashCode()

{

int hashProductName = Name == null ? 0 : Name.GetHashCode();

int hashProductCode = Code.GetHashCode();

}
}
Depois de implementar essa interface, você pode usar uma sequência de Product objetos no Distinct<TSource>
(IEnumerable<TSource>) método, conforme mostrado no exemplo a seguir.
Product[] products = { new Product { Name = "apple", Code = 9 },
new Product { Name = "apple", Code = 9 },
//Exclude duplicates.
IEnumerable<Product> noduplicates =
products.Distinct();
foreach (var product in noduplicates)

Console.WriteLine(product.Name + " " + product.Code);
/*
apple 9
orange 4
lemon 12
*/
Remarks
O Distinct<TSource>(IEnumerable<TSource>) método retorna uma sequência não ordenada que não contenha
valores duplicados. Ele usa o comparador de igualdade padrão, Default, para comparar valores.
Na sintaxe de expressão de consulta do Visual Basic, uma Distinct cláusula se traduz em uma invocação de Distinct.
O comparador de igualdade padrão, Default, é usado para comparar valores de tipos que implementam o
IEquatable<T> interface genérica. Para comparar um tipo de dados personalizado, você precisa implementar esta
interface e fornecer seus próprios GetHashCode e Equals métodos para o tipo.
Para obter um exemplo que usa IEqualityComparer<T> para definir um comparador personalizado, consulte
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>).
See Cláusula Distinct (Visual Basic)Distinct Clause (Visual Basic)
Also
Distinct<TSource>(IEnumerable<TSource>,
IEqualityComparer<TSource>) Distinct<TSource>
(IEnumerable<TSource>, IEqualityComparer<TSource>)
valores.
public static System.Collections.Generic.IEnumerable<TSource> Distinct<TSource> (this

System.Collections.Generic.IEnumerable<TSource> source,
System.Collections.Generic.IEqualityComparer<TSource> comparer);
static member Distinct : seq<'Source> * System.Collections.Generic.IEqualityComparer<'Source> ->
seq<'Source>
Type Parameters
TSource
Parameters
Um IEqualityComparer<T> para comparar valores.
Returns
Um IEnumerable<T> que contém elementos distintos da sequência de origem.
Exceptions
source é null .
Examples
O exemplo a seguir mostra como implementar um comparador de igualdade que pode ser usado no Distinct método.
{
}

{
{


return false;

}


{



}
Depois de implementar esse comparador, você pode usar uma sequência de Product objetos no Distinct método,
Product[] products = { new Product { Name = "apple", Code = 9 },
new Product { Name = "apple", Code = 9 },
//Exclude duplicates.
IEnumerable<Product> noduplicates =
products.Distinct(new ProductComparer());
foreach (var product in noduplicates)

/*
apple 9
orange 4
lemon 12
*/
Remarks
O Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) método retorna uma sequência não

ordenada que não contenha valores duplicados. Se comparer está null , o comparador de igualdade padrão, Default, é
usado para comparar valores.
Enumerable.ElementAt Enumerable.ElementAt
I n this Article
public static TSource ElementAt<TSource> (this System.Collections.Generic.IEnumerable<TSource>
source, int index);
static member ElementAt : seq<'Source> * int -> 'Source
Type Parameters
TSource
Parameters
Um IEnumerable<T> do qual um elemento será retornado.
index Int32 Int32
O índice baseado em zero do elemento a ser recuperado.
Returns
TSource TSource
O elemento na posição especificada na sequência de origem.
Exceptions
source é null .
ArgumentOutOfRangeException ArgumentOutOfRangeException
index é menor que 0 ou maior ou igual ao número de elementos em source .
Examples
O exemplo de código a seguir demonstra como usar ElementAt para retornar um elemento em uma posição específica.
string[] names =
{ "Hartono, Tommy", "Adams, Terry", "Andersen, Henriette Thaulow",
"Hedlund, Magnus", "Ito, Shu" };

Random random = new Random(DateTime.Now.Millisecond);
string name = names.ElementAt(random.Next(0, names.Length));
Console.WriteLine("The name chosen at random is '{0}'.", name);
/*
This code produces the following sample output:
The name chosen at random is 'Ito, Shu'.

*/
Remarks
Se o tipo de source implementa IList<T>, que a implementação é usada para obter o elemento no índice especificado.
Caso contrário, esse método obtém o elemento especificado.
Esse método gera uma exceção se index está fora do intervalo. Para retornar em vez disso, um valor padrão quando o
índice especificado está fora do intervalo, use o ElementAtOrDefault método.
Enumerable.ElementAtOrDefault Enumerable.ElementAt
OrDefault
I n this Article
intervalo.
public static TSource ElementAtOrDefault<TSource> (this
System.Collections.Generic.IEnumerable<TSource> source, int index);
static member ElementAtOrDefault : seq<'Source> * int -> 'Source
Type Parameters
TSource
Parameters
index Int32 Int32
Returns
TSource TSource
default ( TSource ) se o índice estiver fora dos limites da sequência de origem; caso contrário, o elemento na posição
especificada na sequência de origem.
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar ElementAtOrDefault. Este exemplo usa um índice está fora dos
limites da matriz.
string[] names =
{ "Hartono, Tommy", "Adams, Terry", "Andersen, Henriette Thaulow",
int index = 20;
string name = names.ElementAtOrDefault(index);
Console.WriteLine(
"The name chosen at index {0} is '{1}'.",
index,
String.IsNullOrEmpty(name) ? "<no name at this index>" : name);
/*
The name chosen at index 20 is '<no name at this index>'.

*/
Remarks
Se o tipo de source implementa IList<T>, que a implementação é usada para obter o elemento no índice especificado.
Caso contrário, esse método obtém o elemento especificado.
Enumerable.Empty Enumerable.Empty
I n this Article
Retorna um IEnumerable<T> vazio que tem o argumento do tipo especificado.
public static System.Collections.Generic.IEnumerable<TResult> Empty<TResult> ();
static member Empty : unit -> seq<'Result>
Type Parameters
TResult
O tipo a ser atribuído ao parâmetro de tipo genérico IEnumerable<T> retornado.
Returns
Um IEnumerable<T> vazio cujo tipo de argumento é TResult .
Examples
O exemplo de código a seguir demonstra como usar Empty<TResult>() para gerar um vazio IEnumerable<T>.
IEnumerable<decimal> empty = Enumerable.Empty<decimal>();
O exemplo de código a seguir demonstra um aplicativo possíveis do Empty<TResult>() método. O Aggregate método
é aplicado a uma coleção de matrizes de cadeia de caracteres. Os elementos de cada matriz na coleção são adicionados
ao resultante IEnumerable<T> somente se essa matriz contém quatro ou mais elementos. Empty é usado para gerar o
valor de semente para Aggregate porque se nenhuma matriz na coleção tem quatro ou mais elementos, somente a
sequência vazia é retornada.
string[] names1 = { "Hartono, Tommy" };
string[] names2 = { "Adams, Terry", "Andersen, Henriette Thaulow",
string[] names3 = { "Solanki, Ajay", "Hoeing, Helge",
"Andersen, Henriette Thaulow",
"Potra, Cristina", "Iallo, Lucio" };
List<string[]> namesList =
new List<string[]> { names1, names2, names3 };
// Only include arrays that have four or more elements

IEnumerable<string> allNames =
namesList.Aggregate(Enumerable.Empty<string>(),
(current, next) => next.Length > 3 ? current.Union(next) : current);
foreach (string name in allNames)

{
}
/*
Adams, Terry
Andersen, Henriette Thaulow
Hedlund, Magnus
Ito, Shu
Solanki, Ajay
Hoeing, Helge
Potra, Cristina
Iallo, Lucio
*/
Remarks
O Empty<TResult>() método armazena em cache uma sequência vazia do tipo TResult . Quando o objeto que ela
retorna é enumerado, ele gera nenhum elemento.
Em alguns casos, esse método é útil para passar uma sequência vazia para um método definido pelo usuário que usa
um IEnumerable<T>. Ele também pode ser usado para gerar um elemento neutro para métodos como Union.
Consulte a seção de exemplo para obter um exemplo de uso de Empty<TResult>().
Enumerable.Except Enumerable.Except
I n this Article
Overloads
Except<TSource>(IEnumerable<TSource>, IEnumerable<
TSource>) Except<TSource>(IEnumerable<TSource>, Produz a diferença de conjunto de duas sequências usando o
IEnumerable<TSource>) comparador de igualdade padrão para comparar os valores.
Except<TSource>(IEnumerable<TSource>, IEnumerable<
TSource>, IEqualityComparer<TSource>) Except<TSource>( Produz a diferença de conjunto de duas sequências usando o
IEnumerable<TSource>, IEnumerable<TSource>, IEquality IEqualityComparer<T> especificado para comparar os valores.
Comparer<TSource>)
Except<TSource>(IEnumerable<TSource>,
IEnumerable<TSource>) Except<TSource>
(IEnumerable<TSource>, IEnumerable<TSource>)
valores.
public static System.Collections.Generic.IEnumerable<TSource> Except<TSource> (this
static member Except : seq<'Source> * seq<'Source> -> seq<'Source>
Type Parameters
TSource
Parameters
Um IEnumerable<T> cujos elementos que não estão presentes também no second serão retornados.
Um IEnumerable<T> cujos elementos que também ocorrem na primeira sequência farão com que esses elementos
sejam removidos da sequência retornada.
Returns
Uma sequência que contém a diferença de conjunto dos elementos das duas sequências.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar o Except<TSource>(IEnumerable<TSource>,
IEnumerable<TSource>) método para comparar duas sequências de números e retornar elementos que aparecem
somente na primeira sequência.
double[] numbers1 = { 2.0, 2.0, 2.1, 2.2, 2.3, 2.3, 2.4, 2.5 };
double[] numbers2 = { 2.2 };
IEnumerable<double> onlyInFirstSet = numbers1.Except(numbers2);
foreach (double number in onlyInFirstSet)

/*
2
2.1
2.3
2.4
2.5
*/
Se você quiser comparar sequências de objetos de algum tipo de dados personalizado, você precisa implementar o
IEqualityComparer<T> interface genérica em um helperclass. O exemplo de código a seguir mostra como
public class ProductA: IEquatable<ProductA>
{
public bool Equals(ProductA other)

{
if (other is null)
return false;
return this.Name == other.Name && this.Code == other.Code;

}
public override bool Equals(object obj) => Equals(obj as ProductA);

public override int GetHashCode() => (Name, Code).GetHashCode();
}
Depois de implementar essa interface, você pode usar sequências de ProductA objetos no Except<TSource>
(IEnumerable<TSource>, IEnumerable<TSource>) método, conforme mostrado no exemplo a seguir.
ProductA[] fruits1 = { new ProductA { Name = "apple", Code = 9 },
new ProductA { Name = "orange", Code = 4 },
new ProductA { Name = "lemon", Code = 12 } };
ProductA[] fruits2 = { new ProductA { Name = "apple", Code = 9 } };
//Get all the elements from the first array

//except for the elements from the second array.
IEnumerable<ProductA> except =
fruits1.Except(fruits2);
foreach (var product in except)

/*
orange 4
lemon 12
*/
Remarks
A diferença de conjunto de dois conjuntos é definida como os membros do primeiro conjunto que não aparecem no
segundo conjunto.
Note
Esse método retorna os elementos na first que não aparecem no second . Ele também não retornar esses elementos
no second que não aparecem no first .
IEqualityComparer<T> interface genérica. Para comparar um tipo de dados personalizado, você precisa implementar
esta interface e fornecer seus próprios GetHashCode e Equals métodos para o tipo.
IEnumerable<TSource>, IEqualityComparer<TSource>)
Produz a diferença de conjunto de duas sequências usando o IEqualityComparer<T> especificado para comparar os
valores.
public static System.Collections.Generic.IEnumerable<TSource> Except<TSource> (this
System.Collections.Generic.IEnumerable<TSource> second,
static member Except : seq<'Source> * seq<'Source> *
System.Collections.Generic.IEqualityComparer<'Source> -> seq<'Source>
Type Parameters
TSource
Parameters
Um IEnumerable<T> cujos elementos que não estão presentes também no second serão retornados.
Um IEnumerable<T> cujos elementos que também ocorrem na primeira sequência farão com que esses elementos
sejam removidos da sequência retornada.
Returns
Exceptions
Examples
O exemplo a seguir mostra como implementar um comparador de igualdade que pode ser usado no Except método.
{
}

{
{


return false;

}


{



}
Depois de implementar esse comparador, você pode usar sequências de Product objetos no Except método, conforme
mostrado no exemplo a seguir.
Product[] fruits1 = { new Product { Name = "apple", Code = 9 },
Product[] fruits2 = { new Product { Name = "apple", Code = 9 } };
//Get all the elements from the first array

//except for the elements from the second array.
IEnumerable<Product> except =
fruits1.Except(fruits2, new ProductComparer());
foreach (var product in except)

/*
orange 4
lemon 12
*/
Remarks
Se comparer está null , o comparador de igualdade padrão, Default, é usado para comparar valores.
Enumerable.First Enumerable.First
I n this Article
Overloads
First<TSource>(IEnumerable<TSource>) First<TSource>(
IEnumerable<TSource>) Retorna o primeiro elemento de uma sequência.
First<TSource>(IEnumerable<TSource>, Func<TSource,
Boolean>) First<TSource>(IEnumerable<TSource>, Func< Retorna o primeiro elemento em uma sequência que satisfaz
TSource,Boolean>) uma condição especificada.
First<TSource>(IEnumerable<TSource>) First<TSource>
public static TSource First<TSource> (this System.Collections.Generic.IEnumerable<TSource> source);
static member First : seq<'Source> -> 'Source
Type Parameters
TSource
Parameters
O IEnumerable<T> do qual o primeiro elemento será retornado.
Returns
TSource TSource
O primeiro elemento na sequência especificada.
Exceptions
source é null .
Uma sequência de origem está vazia.
Examples
O exemplo de código a seguir demonstra como usar First<TSource>(IEnumerable<TSource>) para retornar o
primeiro elemento de uma matriz.
int[] numbers = { 9, 34, 65, 92, 87, 435, 3, 54,
83, 23, 87, 435, 67, 12, 19 };
int first = numbers.First();
Console.WriteLine(first);
/*
9
*/
Remarks
O First<TSource>(IEnumerable<TSource>) método lança uma exceção se source não contiver elementos. Para
retornar em vez disso, um valor padrão quando a sequência de origem estiver vazia, use o FirstOrDefault método.
public static TSource First<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,

static member First : seq<'Source> * Func<'Source, bool> -> 'Source
Type Parameters
TSource
Parameters
Returns
TSource TSource
O primeiro elemento na sequência que passa o teste na função de predicado especificada.
Exceptions
Nenhum elemento satisfaz a condição na predicate .
- ou - Uma sequência de origem está vazia.
Examples
O exemplo de código a seguir demonstra como usar First<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) para retornar o primeiro elemento de uma matriz que satisfaz uma condição.
int[] numbers = { 9, 34, 65, 92, 87, 435, 3, 54,
83, 23, 87, 435, 67, 12, 19 };
int first = numbers.First(number => number > 80);
/*
92
*/
Remarks
O First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) método gera uma exceção se nenhum elemento
correspondente for encontrado no source . Para retornar em vez disso, um valor padrão quando nenhum elemento
correspondente for encontrado, use o FirstOrDefault método.
Enumerable.FirstOrDefault Enumerable.FirstOrDefault
I n this Article
Overloads
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<
TSource,Boolean>) FirstOrDefault<TSource>(IEnumerable< Retorna o primeiro elemento da sequência que satisfaz uma
TSource>, Func<TSource,Boolean>) condição ou um valor padrão, caso esse elemento não seja
encontrado.
FirstOrDefault<TSource>(IEnumerable<TSource>) FirstOr
Default<TSource>(IEnumerable<TSource>) Retorna o primeiro elemento de uma sequência ou um valor
padrão se a sequência não contém elementos.
FirstOrDefault<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) FirstOrDefault<TSource>
Retorna o primeiro elemento da sequência que satisfaz uma condição ou um valor padrão, caso esse elemento não seja
encontrado.
public static TSource FirstOrDefault<TSource> (this System.Collections.Generic.IEnumerable<TSource>
source, Func<TSource,bool> predicate);
static member FirstOrDefault : seq<'Source> * Func<'Source, bool> -> 'Source
Type Parameters
TSource
Parameters
Returns
TSource TSource
default ( TSource ) se source estiver vazio ou se nenhum elemento for aprovado no teste especificado por
predicate ; caso contrário, o primeiro elemento em source que for aprovado no teste especificado por predicate .
Exceptions
Examples
O exemplo de código a seguir demonstra como usar FirstOrDefault<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) , passando um predicado. A segunda chamada para o método, há nenhum elemento na
matriz que atende à condição.
string[] names = { "Hartono, Tommy", "Adams, Terry",
string firstLongName = names.FirstOrDefault(name => name.Length > 20);
Console.WriteLine("The first long name is '{0}'.", firstLongName);
string firstVeryLongName = names.FirstOrDefault(name => name.Length > 30);
Console.WriteLine(
"There is {0} name longer than 30 characters.",
string.IsNullOrEmpty(firstVeryLongName) ? "not a" : "a");
/*
The first long name is 'Andersen, Henriette Thaulow'.

There is not a name longer than 30 characters.
*/
Remarks
public static TSource FirstOrDefault<TSource> (this System.Collections.Generic.IEnumerable<TSource>

source);
static member FirstOrDefault : seq<'Source> -> 'Source
Type Parameters
TSource
Parameters
O IEnumerable<T> do qual o primeiro elemento será retornado.
Returns
TSource TSource
default ( TSource ) se source estiver vazio; caso contrário, o primeiro elemento em source .
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar FirstOrDefault<TSource>(IEnumerable<TSource>) em uma
matriz vazia.
int[] numbers = { };
int first = numbers.FirstOrDefault();
/*
0
*/
Às vezes, o valor de default(TSource) não é o valor padrão que você deseja usar se a coleção não contiver
elementos. Em vez de verificar o resultado para o valor padrão indesejado e, em seguida, alterando-se necessário, você
pode usar o DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource) método para especificar o valor padrão que
você deseja usar, se a coleção está vazia. Em seguida, chame First<TSource>(IEnumerable<TSource>) para obter o
primeiro elemento. O exemplo de código a seguir usa ambas as técnicas para obter um valor padrão de 1 se uma
coleção de meses numéricos está vazia. Como o valor padrão para um número inteiro é 0, o que não corresponde a
qualquer mês, o valor padrão deve ser especificado como 1 em vez disso. A primeira variável de resultado é verificada
para o valor padrão indesejados após a conclusão da consulta em execução. A segunda variável de resultado é obtida
usando DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource) para especificar um valor padrão de 1.
List<int> months = new List<int> { };
// Setting the default value to 1 after the query.

int firstMonth1 = months.FirstOrDefault();
if (firstMonth1 == 0)
{
firstMonth1 = 1;
}
Console.WriteLine("The value of the firstMonth1 variable is {0}", firstMonth1);
// Setting the default value to 1 by using DefaultIfEmpty() in the query.

int firstMonth2 = months.DefaultIfEmpty(1).First();
/*
The value of the firstMonth1 variable is 1

*/
Remarks
O FirstOrDefault método não fornece uma maneira de especificar um valor padrão. Se você quiser especificar um
valor padrão diferente de default(TSource) , use o DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)
método conforme descrito na seção de exemplo.
Enumerable.GroupBy Enumerable.GroupBy
I n this Article
Overloads
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<
TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Agrupa os elementos de uma sequência de acordo com uma
Func<TKey,IEnumerable<TElement>,TResult>) GroupBy< função do seletor de chave especificada e cria um valor de
TSource,TKey,TElement,TResult>(IEnumerable<TSource>, resultado de cada grupo e sua chave. Os elementos de cada
Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey, grupo são projetados usando uma função especificada.
IEnumerable<TElement>,TResult>)
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<
Func<TKey,IEnumerable<TElement>,TResult>, IEquality função do seletor de chave especificada e cria um valor de
Comparer<TKey>) GroupBy<TSource,TKey,TElement,TResult>( resultado de cada grupo e sua chave. Os valores da chave são
IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource, comparados usando um comparador especificado e os
TElement>, Func<TKey,IEnumerable<TElement>,TResult>, elementos de cada grupo são projetados usando uma função
IEqualityComparer<TKey>) especificada.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>,
Func<TSource,TKey>, Func<TSource,TElement>) GroupBy< Agrupa os elementos de uma sequência de acordo com a
TSource,TKey,TElement>(IEnumerable<TSource>, Func< função de seletor de chave especificada e projeta os elementos
TSource,TKey>, Func<TSource,TElement>) de cada grupo usando uma função especificada.
Func<TSource,TKey>, Func<TSource,TElement>, IEquality Agrupa os elementos de uma sequência de acordo com uma
Comparer<TKey>) GroupBy<TSource,TKey,TElement>( função de seletor de chave. As chaves são comparadas usando
IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource, um comparador e os elementos de cada grupo são projetados
TElement>, IEqualityComparer<TKey>) usando uma função especificada.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>,
Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>, Agrupa os elementos de uma sequência de acordo com uma
TResult>) GroupBy<TSource,TKey,TResult>(IEnumerable< função do seletor de chave especificada e cria um valor de
TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable< resultado de cada grupo e sua chave.
TSource>,TResult>)
Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>, Agrupa os elementos de uma sequência de acordo com uma
TResult>, IEqualityComparer<TKey>) GroupBy<TSource,TKey, função do seletor de chave especificada e cria um valor de
TResult>(IEnumerable<TSource>, Func<TSource,TKey>, resultado de cada grupo e sua chave. As chaves são
Func<TKey,IEnumerable<TSource>,TResult>, IEquality comparadas usando um comparador especificado.
Comparer<TKey>)
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<
TSource,TKey>) GroupBy<TSource,TKey>(IEnumerable< Agrupa os elementos de uma sequência de acordo com uma
TSource>, Func<TSource,TKey>) função de seletor de chave especificada.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<
TSource,TKey>, IEqualityComparer<TKey>) GroupBy<TSource, Agrupa os elementos de uma sequência de acordo com uma
TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEquality função do seletor de chave especificada e compara as chaves
Comparer<TKey>) usando um comparador especificado.
GroupBy<TSource,TKey,TElement,TResult>
(IEnumerable<TSource>, Func<TSource,TKey>,
Func<TSource,TElement>,
Func<TKey,IEnumerable<TElement>,TResult>)
Agrupa os elementos de uma sequência de acordo com uma função do seletor de chave especificada e cria um valor de
resultado de cada grupo e sua chave. Os elementos de cada grupo são projetados usando uma função especificada.
public static System.Collections.Generic.IEnumerable<TResult> GroupBy<TSource,TKey,TElement,TResult>
(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector,
Func<TSource,TElement> elementSelector,
Func<TKey,System.Collections.Generic.IEnumerable<TElement>,TResult> resultSelector);
static member GroupBy : seq<'Source> * Func<'Source, 'Key> * Func<'Source, 'Element> * Func<'Key,
seq<'Element>, 'Result> -> seq<'Result>
Type Parameters
TSource
TKey
O tipo da chave retornada por keySelector .
TElement
O tipo dos elementos em cada IGrouping<TKey,TElement>.
TResult
O tipo do valor de resultado retornado por resultSelector .
Parameters
Um IEnumerable<T> cujos elementos serão agrupados.
keySelector Func<TSource,TKey>
Uma função para extrair a chave de cada elemento.
elementSelector Func<TSource,TElement>
Uma função para mapear cada elemento de origem para um elemento em um IGrouping<TKey,TElement>.
resultSelector Func<TKey,IEnumerable<TElement>,TResult>
Uma função para criar um valor de resultado de cada grupo.
Returns
Uma coleção de elementos do tipo TResult , em que cada elemento representa uma projeção em um grupo e sua
chave.
Examples
O exemplo de código a seguir demonstra como usar GroupBy<TSource,TKey,TElement,TResult>
(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>,
Func<TKey,IEnumerable<TElement>,TResult>) para agrupar os elementos projetados de uma sequência e, em
seguida, uma sequência de resultados do tipo de projeto TResult .
class Pet
{
public double Age { get; set; }
}
public static void GroupByEx4()

{
// Create a list of pets.
List<Pet> petsList =
new List<Pet>{ new Pet { Name="Barley", Age=8.3 },
new Pet { Name="Boots", Age=4.9 },
new Pet { Name="Whiskers", Age=1.5 },
new Pet { Name="Daisy", Age=4.3 } };
// Group Pet.Age values by the Math.Floor of the age.

// Then project an anonymous type from each group
// that consists of the key, the count of the group's
// elements, and the minimum and maximum age in the group.
var query = petsList.GroupBy(
pet => Math.Floor(pet.Age),
pet => pet.Age,
(baseAge, ages) => new
{
Key = baseAge,
Count = ages.Count(),
Min = ages.Min(),
Max = ages.Max()
});
// Iterate over each anonymous type.

foreach (var result in query)
{
Console.WriteLine("
Age group: " + result.Key);
Console.WriteLine("Number of pets in this age group: " + result.Count);
Console.WriteLine("Minimum age: " + result.Min);
Console.WriteLine("Maximum age: " + result.Max);
}
Age group: 8
Number of pets in this age group: 1
Minimum age: 8.3
Maximum age: 8.3
Age group: 4
Minimum age: 4.3
Maximum age: 4.9
Age group: 1
Minimum age: 1.5
Maximum age: 1.5
*/
}
Remarks
Na sintaxe de expressão de consulta, uma group by (Visual c#) ou Group By Into cláusula (Visual Basic) se traduz
em uma invocação de GroupBy.
See Cláusula group (Referência de C#)group clause (C# Reference)
Also Cláusula Group By (Visual Basic)Group By Clause (Visual Basic)
Func<TKey,IEnumerable<TElement>,TResult>,
resultado de cada grupo e sua chave. Os valores da chave são comparados usando um comparador especificado e os
elementos de cada grupo são projetados usando uma função especificada.
public static System.Collections.Generic.IEnumerable<TResult> GroupBy<TSource,TKey,TElement,TResult>

(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector,
Func<TSource,TElement> elementSelector,
Func<TKey,System.Collections.Generic.IEnumerable<TElement>,TResult> resultSelector,
System.Collections.Generic.IEqualityComparer<TKey> comparer);
static member GroupBy : seq<'Source> * Func<'Source, 'Key> * Func<'Source, 'Element> * Func<'Key,
seq<'Element>, 'Result> * System.Collections.Generic.IEqualityComparer<'Key> -> seq<'Result>
Type Parameters
TSource
TKey
TElement
TResult
Parameters
comparer IEqualityComparer<TKey>
Um IEqualityComparer<T> com o qual as chaves serão comparadas.
Returns
chave.
Func<TSource,TKey>, Func<TSource,TElement>)
public static System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey,TElement>>

GroupBy<TSource,TKey,TElement> (this System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,TKey> keySelector, Func<TSource,TElement> elementSelector);
static member GroupBy : seq<'Source> * Func<'Source, 'Key> * Func<'Source, 'Element> ->
seq<System.Linq.IGrouping<'Key, 'Element>>
Type Parameters
TSource
TKey
TElement
O tipo dos elementos no IGrouping<TKey,TElement>.
Parameters
Uma função para mapear cada elemento de origem para um elemento no IGrouping<TKey,TElement>.
Returns
IEnumerable<IGrouping<TKey,TElement>>
Um IEnumerable<IGrouping<TKey, TElement>> em C# ou IEnumerable(Of IGrouping(Of TKey, TElement)) no
Visual Basic em que cada objeto IGrouping<TKey,TElement> contém uma coleção de objetos de tipo TElement e uma
chave.
Exceptions
source , keySelector ou elementSelector é null .
Examples
O exemplo de código a seguir demonstra como usar GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>,
Func<TSource,TKey>, Func<TSource,TElement>) para agrupar os elementos de uma sequência.
class Pet
{
}
// Uses method-based query syntax.

{
List<Pet> pets =
new Pet { Name="Whiskers", Age=1 },
new Pet { Name="Daisy", Age=4 } };
// Group the pets using Age as the key value

// and selecting only the pet's Name for each value.
IEnumerable<IGrouping<int, string>> query =
pets.GroupBy(pet => pet.Age, pet => pet.Name);
// Iterate over each IGrouping in the collection.

foreach (IGrouping<int, string> petGroup in query)
{
// Print the key value of the IGrouping.
Console.WriteLine(petGroup.Key);
// Iterate over each value in the
// IGrouping and print the value.
foreach (string name in petGroup)
Console.WriteLine(" {0}", name);
}
}
/*
8
Barley
4
Boots
Daisy
1
Whiskers
*/
em uma invocação de GroupBy. A conversão da expressão de consulta no exemplo a seguir é equivalente à consulta no
exemplo acima.

from pet in pets
group pet.Name by pet.Age;
Note
Em uma expressão de consulta Visual c# ou Visual Basic, ocorrem as expressões de seleção do elemento e a chave na
ordem inversa de suas posições de argumento em uma chamada para o GroupBy<TSource,TKey,TElement>
(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) método.
Remarks
O GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

método retorna uma coleção de IGrouping<TKey,TElement> objetos, um para cada chave distinto que foi encontrado.
Uma IGrouping<TKey,TElement> é um IEnumerable<T> que também tem uma chave associada a seus elementos.
O IGrouping<TKey,TElement> objetos são gerados em uma ordem com base na ordem de elementos no source que
produziu a primeira chave de cada IGrouping<TKey,TElement>. Elementos em um agrupamento são gerados na
ordem em que os elementos que as produziu aparecer em source .
O comparador de igualdade padrão Default é usado para comparar chaves.

Func<TSource,TKey>, Func<TSource,TElement>,
IEqualityComparer<TKey>) GroupBy<TSource,TKey,TElement>
Func<TSource,TElement>, IEqualityComparer<TKey>)
Agrupa os elementos de uma sequência de acordo com uma função de seletor de chave. As chaves são comparadas
usando um comparador e os elementos de cada grupo são projetados usando uma função especificada.
public static System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey,TElement>>

GroupBy<TSource,TKey,TElement> (this System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,TKey> keySelector, Func<TSource,TElement> elementSelector,
static member GroupBy : seq<'Source> * Func<'Source, 'Key> * Func<'Source, 'Element> *
System.Collections.Generic.IEqualityComparer<'Key> -> seq<System.Linq.IGrouping<'Key, 'Element>>
Type Parameters
TSource
TKey
TElement
Parameters
Um IEqualityComparer<T> para comparar chaves.
Returns
IEnumerable<IGrouping<TKey,TElement>>
Um IEnumerable<IGrouping<TKey, TElement>> em C# ou IEnumerable(Of IGrouping(Of TKey, TElement)) no
Visual Basic em que cada objeto IGrouping<TKey,TElement> contém uma coleção de objetos de tipo TElement e uma
chave.
Exceptions
Remarks
Note
Para obter exemplos de GroupBy , consulte os tópicos a seguir.

O GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>,
IEqualityComparer<TKey>) método retorna uma coleção de IGrouping<TKey,TElement> objetos, um para cada chave
distinto que foi encontrado. Uma IGrouping<TKey,TElement> é um IEnumerable<T> que também tem uma chave
associada a seus elementos.
ordem em que os elementos que as produziu aparecer em source .
Se comparer está null , o comparador de igualdade padrão Default é usado para comparar chaves.
Se duas chaves forem consideradas iguais de acordo com comparer , a primeira chave é escolhida como a chave de
agrupamento.
em uma invocação de GroupBy. Para obter mais informações e exemplos de uso, consulte cláusula group e por
cláusula Group.
Func<TSource,TKey>,
Func<TSource,TKey>,
resultado de cada grupo e sua chave.
public static System.Collections.Generic.IEnumerable<TResult> GroupBy<TSource,TKey,TResult> (this

System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector,
Func<TKey,System.Collections.Generic.IEnumerable<TSource>,TResult> resultSelector);
static member GroupBy : seq<'Source> * Func<'Source, 'Key> * Func<'Key, seq<'Source>, 'Result> ->
seq<'Result>
Type Parameters
TSource
TKey
TResult
Parameters
resultSelector Func<TKey,IEnumerable<TSource>,TResult>
Returns
chave.
Examples
O exemplo de código a seguir demonstra como usar GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>,
Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>) para agrupar os elementos de uma sequência e
uma sequência de resultados do tipo de projeto TResult .
class Pet
{
}

{
// Group Pet objects by the Math.Floor of their age.

var query = petsList.GroupBy(
(age, pets) => new
{
Key = age,
Count = pets.Count(),
Min = pets.Min(pet => pet.Age),
Max = pets.Max(pet => pet.Age)
});

{
Console.WriteLine("
}
Age group: 8
Minimum age: 8.3
Maximum age: 8.3
Age group: 4
Minimum age: 4.3
Maximum age: 4.9
Age group: 1
Minimum age: 1.5
Maximum age: 1.5
*/
}
Remarks
em uma invocação de GroupBy.
Func<TSource,TKey>,
Func<TKey,IEnumerable<TSource>,TResult>,
IEqualityComparer<TKey>) GroupBy<TSource,TKey,TResult>
resultado de cada grupo e sua chave. As chaves são comparadas usando um comparador especificado.
public static System.Collections.Generic.IEnumerable<TResult> GroupBy<TSource,TKey,TResult> (this
Func<TKey,System.Collections.Generic.IEnumerable<TSource>,TResult> resultSelector,
static member GroupBy : seq<'Source> * Func<'Source, 'Key> * Func<'Key, seq<'Source>, 'Result> *
System.Collections.Generic.IEqualityComparer<'Key> -> seq<'Result>
Type Parameters
TSource
TKey
TResult
Parameters
Um IEqualityComparer<T> com o qual as chaves serão comparadas.
Returns
chave.
GroupBy<TSource,TKey>(IEnumerable<TSource>,
Func<TSource,TKey>) GroupBy<TSource,TKey>
(IEnumerable<TSource>, Func<TSource,TKey>)
public static System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey,TSource>>

GroupBy<TSource,TKey> (this System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,TKey> keySelector);
static member GroupBy : seq<'Source> * Func<'Source, 'Key> -> seq<System.Linq.IGrouping<'Key,
'Source>>
Type Parameters
TSource
TKey
Parameters
Returns
IEnumerable<IGrouping<TKey,TSource>>
Um IEnumerable<IGrouping<TKey, TSource>> em C# ou IEnumerable(Of IGrouping(Of TKey, TSource)) no
Visual Basic em que cada objeto IGrouping<TKey,TElement> contém uma sequência de objetos e uma chave.
Exceptions
source ou keySelector é null .
Remarks
Note

O GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) método retorna uma coleção de
IGrouping<TKey,TElement> objetos, um para cada chave distinto que foi encontrado. Uma
IGrouping<TKey,TElement> é um IEnumerable<T> que também tem uma chave associada a seus elementos.
ordem em que aparecem no source .
cláusula Group.
Func<TSource,TKey>, IEqualityComparer<TKey>)
public static System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey,TSource>>
GroupBy<TSource,TKey> (this System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey> comparer);
static member GroupBy : seq<'Source> * Func<'Source, 'Key> *
System.Collections.Generic.IEqualityComparer<'Key> -> seq<System.Linq.IGrouping<'Key, 'Source>>
Type Parameters
TSource
TKey
Parameters
Returns
IEnumerable<IGrouping<TKey,TSource>>
Um IEnumerable<IGrouping<TKey, TSource>> em C# ou IEnumerable(Of IGrouping(Of TKey, TSource)) no
Visual Basic em que cada objeto IGrouping<TKey,TElement> contém uma coleção de objetos e uma chave.
Exceptions
Remarks
Note

O GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) método
retorna uma coleção de IGrouping<TKey,TElement> objetos, um para cada chave distinto que foi encontrado. Uma
IGrouping<TKey,TElement> é um IEnumerable<T> que também tem uma chave associada a seus elementos.
ordem em que aparecem no source .
Se duas chaves forem consideradas iguais de acordo com comparer , a primeira chave é escolhida como a chave de
agrupamento.
cláusula Group.
Enumerable.GroupJoin Enumerable.GroupJoin
I n this Article
Overloads
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<
TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func< Correlaciona os elementos de duas sequências com base na
TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>, igualdade de chaves e agrupa os resultados. Um
IEqualityComparer<TKey>) GroupJoin<TOuter,TInner,TKey, IEqualityComparer<T> especificado é usado para comparar
TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, chaves.
Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,
IEnumerable<TInner>,TResult>, IEqualityComparer<TKey>)
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<
TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func< Correlaciona os elementos de duas sequências com base na
TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>) igualdade de chaves e agrupa os resultados. O comparador de
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable< igualdade padrão é usado para comparar chaves.
TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<
TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>)
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>,
IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>,
Func<TOuter,IEnumerable<TInner>,TResult>,
public static System.Collections.Generic.IEnumerable<TResult> GroupJoin<TOuter,TInner,TKey,TResult>
(this System.Collections.Generic.IEnumerable<TOuter> outer,
System.Collections.Generic.IEnumerable<TInner> inner, Func<TOuter,TKey> outerKeySelector,
Func<TInner,TKey> innerKeySelector,
Func<TOuter,System.Collections.Generic.IEnumerable<TInner>,TResult> resultSelector,
static member GroupJoin : seq<'Outer> * seq<'Inner> * Func<'Outer, 'Key> * Func<'Inner, 'Key> *
Func<'Outer, seq<'Inner>, 'Result> * System.Collections.Generic.IEqualityComparer<'Key> ->
seq<'Result>
Type Parameters
TOuter
O tipo dos elementos da primeira sequência.
TInner
O tipo dos elementos da segunda sequência.
TKey
O tipo das chaves retornadas pelas funções de seletor de chave.
TResult
O tipo dos elementos de resultado.
Parameters
outer IEnumerable<TOuter>
A primeira sequência a ser ingressada.
inner IEnumerable<TInner>
A sequência a ser ingressada à primeira sequência.
outerKeySelector Func<TOuter,TKey>
Uma função para extrair a chave de junção de cada elemento da primeira sequência.
innerKeySelector Func<TInner,TKey>
Uma função para extrair a chave de junção de cada elemento da segunda sequência.
resultSelector Func<TOuter,IEnumerable<TInner>,TResult>
Uma função para criar um elemento de resultado de um elemento da primeira sequência e uma coleção de elementos
correspondentes da segunda sequência.
Um IEqualityComparer<T> para executar hash e comparar chaves.
Returns
Um IEnumerable<T> que contém elementos do tipo TResult obtidos pela execução de uma junção agrupada em
duas sequências.
Exceptions
outer ou inner ou outerKeySelector ou innerKeySelector ou resultSelector é null .
Remarks
Se comparer está null , o comparador de igualdade padrão, Default, é usado para hash e comparar chaves.
GroupJoin produz resultados hierárquicos que significa que elementos de outer são emparelhados com coleções de
elementos correspondentes da inner . GroupJoin permite que você baseie seus resultados em todo um conjunto de
correspondências para cada elemento da outer .
Note
Se não houver nenhum elemento correlacionado no inner para um determinado elemento de outer , a sequência de
correspondências para esse elemento estará vazia, mas ainda aparecerá nos resultados.
O resultSelector função é chamada apenas uma vez para cada outer elemento junto com uma coleção de todos os
inner elementos que correspondem a outer elemento. Isso difere de Join método no qual a função de seletor de
resultado é invocada em pares que contêm um elemento de outer e um elemento de inner .
GroupJoin preserva a ordem dos elementos da outer e para cada elemento de outer , a ordem dos elementos
correspondentes de inner .
GroupJoin tem equivalente direto em termos de banco de dados relacionais tradicionais. No entanto, esse método
implementa um superconjunto de junções internas e junções externas esquerdas. Ambas essas operações podem ser
gravadas em termos de uma junção agrupada. Ver operações de junção.
See Executando operações de junçãoPerforming Join Operations
Also
Func<TOuter,IEnumerable<TInner>,TResult>)
public static System.Collections.Generic.IEnumerable<TResult> GroupJoin<TOuter,TInner,TKey,TResult>
(this System.Collections.Generic.IEnumerable<TOuter> outer,
System.Collections.Generic.IEnumerable<TInner> inner, Func<TOuter,TKey> outerKeySelector,
Func<TInner,TKey> innerKeySelector,
Func<TOuter,System.Collections.Generic.IEnumerable<TInner>,TResult> resultSelector);
static member GroupJoin : seq<'Outer> * seq<'Inner> * Func<'Outer, 'Key> * Func<'Inner, 'Key> *
Func<'Outer, seq<'Inner>, 'Result> -> seq<'Result>
Type Parameters
TOuter
TInner
TKey
TResult
Parameters
Returns
Um IEnumerable<T> que contém elementos do tipo TResult obtidos pela execução de uma junção agrupada em
duas sequências.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>,
IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>) para
realizar uma junção agrupada em duas sequências.
class Person
{
}
class Pet
{
public Person Owner { get; set; }
}
public static void GroupJoinEx1()

{
Person magnus = new Person { Name = "Hedlund, Magnus" };
Person terry = new Person { Name = "Adams, Terry" };
Person charlotte = new Person { Name = "Weiss, Charlotte" };
Pet barley = new Pet { Name = "Barley", Owner = terry };

Pet boots = new Pet { Name = "Boots", Owner = terry };
Pet whiskers = new Pet { Name = "Whiskers", Owner = charlotte };
Pet daisy = new Pet { Name = "Daisy", Owner = magnus };
List<Person> people = new List<Person> { magnus, terry, charlotte };

List<Pet> pets = new List<Pet> { barley, boots, whiskers, daisy };
// Create a list where each element is an anonymous

// type that contains a person's name and
// a collection of names of the pets they own.
var query =
people.GroupJoin(pets,
person => person,
pet => pet.Owner,
(person, petCollection) =>
new
{
OwnerName = person.Name,
Pets = petCollection.Select(pet => pet.Name)
});
foreach (var obj in query)

{
// Output the owner's name.
Console.WriteLine("{0}:", obj.OwnerName);
// Output each of the owner's pet's names.
foreach (string pet in obj.Pets)
{
Console.WriteLine(" {0}", pet);
}
}
}
/*
Hedlund, Magnus:
Daisy
Adams, Terry:
Barley
Boots
Weiss, Charlotte:
Whiskers
*/
Remarks
O comparador de igualdade padrão, Default, é usado para hash e comparar chaves.

GroupJoin produz resultados hierárquicos que significa que elementos de outer são emparelhados com coleções de
elementos correspondentes da inner . GroupJoin permite que você baseie seus resultados em todo um conjunto de
correspondências para cada elemento da outer .
Note
Se não houver nenhum elemento correlacionado no inner para um determinado elemento de outer , a sequência de
correspondências para esse elemento estará vazia, mas ainda aparecerá nos resultados.
O resultSelector função é chamada apenas uma vez para cada outer elemento junto com uma coleção de todos os
inner elementos que correspondem a outer elemento. Isso difere de Join método, em que a função de seletor de
resultado é chamada nos pares de contenham um elemento de outer e um elemento de inner .
GroupJoin preserva a ordem dos elementos da outer e para cada elemento de outer , a ordem dos elementos
correspondentes de inner .
GroupJoin tem equivalente direto em termos de banco de dados relacionais tradicionais. No entanto, esse método
implementa um superconjunto de junções internas e junções externas esquerdas. Ambas essas operações podem ser
gravadas em termos de uma junção agrupada. Ver operações de junção.
Na sintaxe de expressão de consulta, uma join … into (Visual c#) ou Group Join cláusula (Visual Basic) se traduz
em uma invocação de GroupJoin.
See Operações joinJoin Operations
Also Cláusula join (Referência de C#)join clause (C# Reference)
Cláusula Join Group (Visual Basic)Group Join Clause (Visual Basic)
Enumerable.Intersect Enumerable.Intersect
I n this Article
Overloads
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<
TSource>, IEqualityComparer<TSource>) Intersect<TSource>( Produz a interseção de conjunto de duas sequências usando o
IEnumerable<TSource>, IEnumerable<TSource>, IEquality IEqualityComparer<T> especificado para comparar os valores.
Comparer<TSource>)
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<
TSource>) Intersect<TSource>(IEnumerable<TSource>, Produz a interseção de conjunto de duas sequências usando o
Intersect<TSource>(IEnumerable<TSource>,
Produz a interseção de conjunto de duas sequências usando o IEqualityComparer<T> especificado para comparar os
valores.
public static System.Collections.Generic.IEnumerable<TSource> Intersect<TSource> (this
static member Intersect : seq<'Source> * seq<'Source> *
Type Parameters
TSource
Parameters
Um IEnumerable<T> cujos elementos distintos que também aparecem em second serão retornados.
Um IEnumerable<T> cujos elementos distintos que também aparecem na primeira sequência serão retornados.
Returns
Uma sequência que contém os elementos que formam a interseção de conjunto de duas sequências.
Exceptions
Examples
O exemplo a seguir mostra como implementar um comparador de igualdade que pode ser usado no Intersect método.
{
}

{
{


return false;

}


{



}
Depois de implementar esse comparador, você pode usar sequências de Product objetos no Intersect método,
Product[] store1 = { new Product { Name = "apple", Code = 9 },

new Product { Name = "orange", Code = 4 } };

// Get the products from the first array
// that have duplicates in the second array.
IEnumerable<Product> duplicates =
store1.Intersect(store2, new ProductComparer());
foreach (var product in duplicates)

/*
apple 9
*/
Remarks
A interseção de dois conjuntos A e B é definida como o conjunto que contém todos os elementos de um que também
aparecem em B, mas nenhum outro elemento.
Quando o objeto retornado por esse método é enumerado, Intersect produz elementos distintos que ocorrem em
ambas as sequências na ordem em que aparecem na first .
IEnumerable<TSource>) Intersect<TSource>
valores.
public static System.Collections.Generic.IEnumerable<TSource> Intersect<TSource> (this

static member Intersect : seq<'Source> * seq<'Source> -> seq<'Source>
Type Parameters
TSource
Parameters
Um IEnumerable<T> cujos elementos distintos que também aparecem em second serão retornados.
Um IEnumerable<T> cujos elementos distintos que também aparecem na primeira sequência serão retornados.
Returns
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Intersect<TSource>(IEnumerable<TSource>,
IEnumerable<TSource>) para retornar os elementos que aparecem em cada uma das duas sequências de inteiros.
int[] id1 = { 44, 26, 92, 30, 71, 38 };

int[] id2 = { 39, 59, 83, 47, 26, 4, 30 };
IEnumerable<int> both = id1.Intersect(id2);
foreach (int id in both)

Console.WriteLine(id);
/*
26
30
*/
Se você quiser comparar sequências de objetos de um tipo de dados personalizado, você precisa implementar o
IEqualityComparer<T> interface genérica em uma classe auxiliar. O exemplo de código a seguir mostra como
{

{
if (other is null)
return false;

}

}
Depois de implementar essa interface, você pode usar sequências de ProductA objetos no Intersect método, conforme
ProductA[] store1 = { new ProductA { Name = "apple", Code = 9 },

new ProductA { Name = "orange", Code = 4 } };

// Get the products from the first array
// that have duplicates in the second array.
IEnumerable<ProductA> duplicates =
store1.Intersect(store2);
foreach (var product in duplicates)

/*
apple 9
*/
Remarks
A interseção de dois conjuntos A e B é definida como o conjunto que contém todos os elementos de um que também
aparecem em B, mas nenhum outro elemento.
Quando o objeto retornado por esse método é enumerado, Intersect produz elementos distintos que ocorrem em
ambas as sequências na ordem em que aparecem na first .
Enumerable.Join Enumerable.Join
I n this Article
Overloads
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>,
IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner, Correlaciona os elementos de duas sequências com base em
TKey>, Func<TOuter,TInner,TResult>) Join<TOuter,TInner, chaves de correspondência. O comparador de igualdade
TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, padrão é usado para comparar chaves.
TInner,TResult>)
IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner, Correlaciona os elementos de duas sequências com base em
TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer< chaves de correspondência. Um IEqualityComparer<T>
TKey>) Join<TOuter,TInner,TKey,TResult>(IEnumerable< especificado é usado para comparar chaves.
TInner,TKey>, Func<TOuter,TInner,TResult>, IEquality
Comparer<TKey>)
Func<TOuter,TInner,TResult>) Join<TOuter,TInner,TKey,TResult>
(IEnumerable<TOuter>, IEnumerable<TInner>,
Func<TOuter,TKey>, Func<TInner,TKey>,
Func<TOuter,TInner,TResult>)
Correlaciona os elementos de duas sequências com base em chaves de correspondência. O comparador de igualdade
padrão é usado para comparar chaves.
public static System.Collections.Generic.IEnumerable<TResult> Join<TOuter,TInner,TKey,TResult> (this
System.Collections.Generic.IEnumerable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner>
inner, Func<TOuter,TKey> outerKeySelector, Func<TInner,TKey> innerKeySelector,
Func<TOuter,TInner,TResult> resultSelector);
static member Join : seq<'Outer> * seq<'Inner> * Func<'Outer, 'Key> * Func<'Inner, 'Key> *
Func<'Outer, 'Inner, 'Result> -> seq<'Result>
Type Parameters
TOuter
TInner
TKey
TResult
Parameters
resultSelector Func<TOuter,TInner,TResult>
Uma função para criar um elemento de resultado de dois elementos correspondentes.
Returns
Um IEnumerable<T> com elementos do tipo TResult obtidos pela execução de uma junção interna em duas
sequências.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>,
IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>) para realizar uma
junção interna de duas sequências com base em uma chave comum.
class Person
{
}
class Pet
{
}
public static void JoinEx1()

{


// Create a list of Person-Pet pairs where

// each element is an anonymous type that contains a
// Pet's name and the name of the Person that owns the Pet.
var query =
people.Join(pets,
person => person,
pet => pet.Owner,
(person, pet) =>
new { OwnerName = person.Name, Pet = pet.Name });

{
Console.WriteLine(
"{0} - {1}",
obj.OwnerName,
obj.Pet);
}
}
/*
Hedlund, Magnus - Daisy

Adams, Terry - Barley
Adams, Terry - Boots
Weiss, Charlotte - Whiskers
*/
Remarks
O comparador de igualdade padrão, Default, é usado para hash e comparar chaves.

Uma associação refere-se à operação de correlacionar os elementos de duas fontes de informações com base em uma
chave comum. Join traz as duas fontes de informações e as chaves pelo qual elas são correspondidas juntos em uma
chamada de método. Isso é diferente do uso de SelectMany , que requer mais de uma chamada de método para
executar a mesma operação.
Join preserva a ordem dos elementos da outer e para cada um desses elementos, a ordem dos elementos
correspondentes da inner .
Na sintaxe de expressão de consulta, uma join (Visual c#) ou Join cláusula (Visual Basic) se traduz em uma
invocação de Join.
Em termos de banco de dados relacional, o Join método implementa uma junção por igualdade interna. 'Interna'
significa que apenas os elementos que têm uma correspondência na outra sequência são incluídos nos resultados. Um
' equijoin' é uma junção na qual as chaves são comparadas quanto à igualdade. A esquerda da operação de junção
externa, que tem nenhum operador de consulta padrão dedicado, mas pode ser executada usando o GroupJoin
método. Ver operações de junção.
Also Cláusula join (Referência de C#)join clause (C# Reference)
Cláusula Join (Visual Basic)Join Clause (Visual Basic)
Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)
Correlaciona os elementos de duas sequências com base em chaves de correspondência. Um IEqualityComparer<T>
especificado é usado para comparar chaves.
public static System.Collections.Generic.IEnumerable<TResult> Join<TOuter,TInner,TKey,TResult> (this

System.Collections.Generic.IEnumerable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner>
inner, Func<TOuter,TKey> outerKeySelector, Func<TInner,TKey> innerKeySelector,
Func<TOuter,TInner,TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>
comparer);
static member Join : seq<'Outer> * seq<'Inner> * Func<'Outer, 'Key> * Func<'Inner, 'Key> *
Func<'Outer, 'Inner, 'Result> * System.Collections.Generic.IEqualityComparer<'Key> -> seq<'Result>
Type Parameters
TOuter
TInner
TKey
TResult
Parameters
Returns
Um IEnumerable<T> com elementos do tipo TResult obtidos pela execução de uma junção interna em duas
sequências.
Exceptions
Remarks
Se comparer está null , o comparador de igualdade padrão, Default, é usado para hash e comparar chaves.
Uma associação refere-se à operação de correlacionar os elementos de duas fontes de informações com base em uma
chave comum. Join traz as duas fontes de informações e as chaves pelo qual elas são correspondidas juntos em uma
chamada de método. Isso é diferente do uso de SelectMany , que requer mais de uma chamada de método para
executar a mesma operação.
Join preserva a ordem dos elementos da outer e para cada um desses elementos, a ordem dos elementos
correspondentes da inner .
Em termos de banco de dados relacional, o Join método implementa uma junção por igualdade interna. 'Interna'
significa que apenas os elementos que têm uma correspondência na outra sequência são incluídos nos resultados. Um
' equijoin' é uma junção na qual as chaves são comparadas quanto à igualdade. A esquerda da operação de junção
externa, que tem nenhum operador de consulta padrão dedicado, mas pode ser executada usando o GroupJoin
método. Ver operações de junção.
Also
Enumerable.Last Enumerable.Last
I n this Article
Overloads
Last<TSource>(IEnumerable<TSource>) Last<TSource>(
IEnumerable<TSource>) Retorna o último elemento de uma sequência.
Last<TSource>(IEnumerable<TSource>, Func<TSource,
Boolean>) Last<TSource>(IEnumerable<TSource>, Func< Retorna o último elemento de uma sequência que satisfaz
TSource,Boolean>) uma condição especificada.
Last<TSource>(IEnumerable<TSource>) Last<TSource>
Retorna o último elemento de uma sequência.
public static TSource Last<TSource> (this System.Collections.Generic.IEnumerable<TSource> source);
static member Last : seq<'Source> -> 'Source
Type Parameters
TSource
Parameters
Um IEnumerable<T> do qual o último elemento será retornado.
Returns
TSource TSource
O valor na última posição na sequência de origem.
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Last<TSource>(IEnumerable<TSource>) para retornar o último
elemento de uma matriz.
int[] numbers = { 9, 34, 65, 92, 87, 435, 3, 54,
83, 23, 87, 67, 12, 19 };
int last = numbers.Last();
Console.WriteLine(last);
/*
19
*/
Remarks
O Last<TSource>(IEnumerable<TSource>) método lança uma exceção se source não contiver elementos. Para
retornar em vez disso, um valor padrão quando a sequência de origem estiver vazia, use o LastOrDefault método.
public static TSource Last<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,

static member Last : seq<'Source> * Func<'Source, bool> -> 'Source
Type Parameters
TSource
Parameters
Returns
TSource TSource
O último elemento na sequência que passa o teste na função de predicado especificada.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Last<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) para retornar o último elemento de uma matriz que satisfaz uma condição.
int[] numbers = { 9, 34, 65, 92, 87, 435, 3, 54,
83, 23, 87, 67, 12, 19 };
int last = numbers.Last(num => num > 80);
/*
87
*/
Remarks
O Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) método gera uma exceção se nenhum elemento
correspondente for encontrado no source . Para retornar em vez disso, um valor padrão quando nenhum elemento
correspondente for encontrado, use o LastOrDefault método.
Enumerable.LastOrDefault Enumerable.LastOrDefault
I n this Article
Overloads
LastOrDefault<TSource>(IEnumerable<TSource>) LastOr
Default<TSource>(IEnumerable<TSource>) Retorna o último elemento de uma sequência ou um valor
LastOrDefault<TSource>(IEnumerable<TSource>, Func<
TSource,Boolean>) LastOrDefault<TSource>(IEnumerable< Retorna o último elemento de uma sequência que satisfaz
TSource>, Func<TSource,Boolean>) uma condição ou um valor padrão, caso esse elemento não
seja encontrado.
public static TSource LastOrDefault<TSource> (this System.Collections.Generic.IEnumerable<TSource>

source);
static member LastOrDefault : seq<'Source> -> 'Source
Type Parameters
TSource
Parameters
Um IEnumerable<T> do qual o último elemento será retornado.
Returns
TSource TSource
default ( TSource ) se a sequência de origem estiver vazia; caso contrário, o último elemento no IEnumerable<T>.
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar LastOrDefault<TSource>(IEnumerable<TSource>) em uma
matriz vazia.
string[] fruits = { };
string last = fruits.LastOrDefault();
Console.WriteLine(
String.IsNullOrEmpty(last) ? "<string is null or empty>" : last);
/*
<string is null or empty>

*/
você deseja usar, se a coleção está vazia. Em seguida, chame Last<TSource>(IEnumerable<TSource>) para obter o
último elemento. O exemplo de código a seguir usa ambas as técnicas para obter um valor padrão de 1, se uma
coleção de numéricos dias do mês está vazia. Como o valor padrão para um número inteiro é 0, o que não
corresponde a qualquer dia do mês, o valor padrão deve ser especificado como 1 em vez disso. A primeira variável de
resultado é verificada para o valor padrão indesejados após a conclusão da consulta em execução. A segunda variável
de resultado é obtida usando DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource) para especificar um valor
padrão de 1.
List<int> daysOfMonth = new List<int> { };

int lastDay1 = daysOfMonth.LastOrDefault();
if (lastDay1 == 0)
{
lastDay1 = 1;
}
Console.WriteLine("The value of the lastDay1 variable is {0}", lastDay1);

int lastDay2 = daysOfMonth.DefaultIfEmpty(1).Last();
/*
The value of the lastDay1 variable is 1

*/
Remarks
O LastOrDefault método não fornece uma maneira de especificar um valor padrão. Se você quiser especificar um valor
padrão diferente de default(TSource) , use o DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource) método
conforme descrito na seção de exemplo.
LastOrDefault<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) LastOrDefault<TSource>
Retorna o último elemento de uma sequência que satisfaz uma condição ou um valor padrão, caso esse elemento não
seja encontrado.
public static TSource LastOrDefault<TSource> (this System.Collections.Generic.IEnumerable<TSource>
static member LastOrDefault : seq<'Source> * Func<'Source, bool> -> 'Source
Type Parameters
TSource
Parameters
Returns
TSource TSource
default ( TSource ) se a sequência for vazia ou se nenhum elemento passar no teste na função de predicado; caso
contrário, o último elemento que passar no teste na função de predicado.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar LastOrDefault<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) , passando um predicado. A segunda chamada para o método, há nenhum elemento na
sequência que satisfaz a condição.
double[] numbers = { 49.6, 52.3, 51.0, 49.4, 50.2, 48.3 };
double last50 = numbers.LastOrDefault(n => Math.Round(n) == 50.0);
Console.WriteLine("The last number that rounds to 50 is {0}.", last50);
double last40 = numbers.LastOrDefault(n => Math.Round(n) == 40.0);
Console.WriteLine(
"The last number that rounds to 40 is {0}.",
last40 == 0.0 ? "<DOES NOT EXIST>" : last40.ToString());
/*
The last number that rounds to 50 is 50.2.

The last number that rounds to 40 is <DOES NOT EXIST>.
*/
Remarks
Enumerable.LongCount Enumerable.LongCount
I n this Article
Overloads
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,
Boolean>) LongCount<TSource>(IEnumerable<TSource>, Retorna um Int64 que representa quantos elementos na
Func<TSource,Boolean>) sequência atendem a uma condição.
LongCount<TSource>(IEnumerable<TSource>) LongCount<
TSource>(IEnumerable<TSource>) Retorna um Int64 que representa o número total de
elementos em uma sequência.
LongCount<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) LongCount<TSource>
Retorna um Int64 que representa quantos elementos na sequência atendem a uma condição.
public static long LongCount<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
static member LongCount : seq<'Source> * Func<'Source, bool> -> int64
Type Parameters
TSource
Parameters
Um IEnumerable<T> que contém os elementos a serem contados.
Returns
Int64 Int64
Exceptions
O número de elementos correspondentes excede MaxValue.
Examples
O exemplo de código a seguir demonstra como usar LongCount<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) para contar os elementos em uma matriz que satisfazem uma condição.
class Pet
{
}
public static void LongCountEx2()

{
const int Age = 3;
long count = pets.LongCount(pet => pet.Age > Age);
Console.WriteLine("There are {0} animals over age {1}.", count, Age);

}
/*
There are 2 animals over age 3.

*/
Remarks
Use esse método em vez de Count quando você espera que o resultado seja maior do que MaxValue.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into LongCount() cláusula se traduz em uma
invocação de LongCount.
Also
public static long LongCount<TSource> (this System.Collections.Generic.IEnumerable<TSource> source);
static member LongCount : seq<'Source> -> int64
Type Parameters
TSource
Parameters
Um IEnumerable<T> que contém os elementos a serem contados.
Returns
Int64 Int64
O número de elementos na sequência de origem.
Exceptions
source é null .
O número de elementos excede MaxValue.
Examples
O exemplo de código a seguir demonstra como usar LongCount<TSource>(IEnumerable<TSource>) para contar os
string[] fruits = { "apple", "banana", "mango",

"orange", "passionfruit", "grape" };
long count = fruits.LongCount();
Console.WriteLine("There are {0} fruits in the collection.", count);
/*
There are 6 fruits in the collection.

*/
Remarks
Use esse método em vez de Count quando você espera que o resultado seja maior do que MaxValue.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into LongCount() cláusula se traduz em uma
invocação de LongCount.
Also
Enumerable.Max Enumerable.Max
I n this Article
Overloads
Max(IEnumerable<Nullable<Single>>) Max(IEnumerable<
Nullable<Single>>) Retorna o valor máximo em uma sequência de valores Single
anuláveis.
Max(IEnumerable<Int32>) Max(IEnumerable<Int32>)
Max(IEnumerable<Nullable<Int64>>) Max(IEnumerable<
Nullable<Int64>>) Retorna o valor máximo em uma sequência de valores Int64
anuláveis.
Max(IEnumerable<Single>) Max(IEnumerable<Single>)
Max(IEnumerable<Nullable<Int32>>) Max(IEnumerable<
Nullable<Int32>>) Retorna o valor máximo em uma sequência de valores Int32
anuláveis.
Max(IEnumerable<Decimal>) Max(IEnumerable<Decimal>)
Retorna o valor máximo em uma sequência de valores
Decimal.
Max(IEnumerable<Nullable<Decimal>>) Max(IEnumerable<
Nullable<Decimal>>) Retorna o valor máximo em uma sequência de valores Decimal
anuláveis.
Max(IEnumerable<Double>) Max(IEnumerable<Double>)
Max(IEnumerable<Nullable<Double>>) Max(IEnumerable<
Nullable<Double>>) Retorna o valor máximo em uma sequência de valores Double
anuláveis.
Max<TSource,TResult>(IEnumerable<TSource>, Func<
TSource,TResult>) Max<TSource,TResult>(IEnumerable< Invoca uma função de transformação em cada elemento de
TSource>, Func<TSource,TResult>) uma sequência genérica e retorna o maior valor resultante.
Max<TSource>(IEnumerable<TSource>, Func<TSource,
Single>) Max<TSource>(IEnumerable<TSource>, Func< Invoca uma função de transformação em cada elemento de
TSource,Single>) uma sequência e retorna o valor Single máximo.
Nullable<Single>>) Max<TSource>(IEnumerable<TSource>, Invoca uma função de transformação em cada elemento de
Func<TSource,Nullable<Single>>) uma sequência e retorna o valor Single máximo que permite
valor nulo.
Nullable<Int64>>) Max<TSource>(IEnumerable<TSource>, Invoca uma função de transformação em cada elemento de
Func<TSource,Nullable<Int64>>) uma sequência e retorna o valor Int64 máximo que permite
valor nulo.
Nullable<Int32>>) Max<TSource>(IEnumerable<TSource>, Invoca uma função de transformação em cada elemento de
Func<TSource,Nullable<Int32>>) uma sequência e retorna o valor Int32 máximo que permite
valor nulo.
Nullable<Double>>) Max<TSource>(IEnumerable<TSource>, Invoca uma função de transformação em cada elemento de
Func<TSource,Nullable<Double>>) uma sequência e retorna o valor Double máximo que permite
valor nulo.
Int64>) Max<TSource>(IEnumerable<TSource>, Func< Invoca uma função de transformação em cada elemento de
TSource,Int64>) uma sequência e retorna o valor Int64 máximo.
Int32>) Max<TSource>(IEnumerable<TSource>, Func< Invoca uma função de transformação em cada elemento de
TSource,Int32>) uma sequência e retorna o valor Int32 máximo.
Double>) Max<TSource>(IEnumerable<TSource>, Func< Invoca uma função de transformação em cada elemento de
TSource,Double>) uma sequência e retorna o valor Double máximo.
Decimal>) Max<TSource>(IEnumerable<TSource>, Func< Invoca uma função de transformação em cada elemento de
TSource,Decimal>) uma sequência e retorna o valor Decimal máximo.
Max<TSource>(IEnumerable<TSource>) Max<TSource>(
IEnumerable<TSource>) Retorna o valor máximo em uma sequência genérica.
Nullable<Decimal>>) Max<TSource>(IEnumerable<TSource>, Invoca uma função de transformação em cada elemento de
Func<TSource,Nullable<Decimal>>) uma sequência e retorna o valor Decimal máximo que permite
valor nulo.
Retorna o valor máximo em uma sequência de valores Single anuláveis.
public static Nullable<float> Max (this System.Collections.Generic.IEnumerable<Nullable<float>>
source);
static member Max : seq<Nullable<single>> -> Nullable<single>
Parameters
Uma sequência de valores Single anuláveis para determinar o valor máximo.
Returns
Nullable<Single>
Um valor do tipo Nullable<Single> em C# ou Nullable(Of Single) no Visual Basic que corresponde ao valor
máximo na sequência.
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Max(IEnumerable<Nullable<Double>>) para determinar o valor
máximo em uma sequência.
Note
double?[] doubles = { null, 1.5E+104, 9E+103, -2E+103 };
double? max = doubles.Max();
Console.WriteLine("The largest number is {0}.", max);
/*
The largest number is 1.5E+104.

*/
Remarks
O Max(IEnumerable<Nullable<Single>>) usa o Single implementação de IComparable<T> para comparar valores.
Se a sequência de origem estiver vazia ou contiver somente valores que são null , essa função retorna null .
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Max() cláusula se traduz em uma
invocação de Max.
Also
public static int Max (this System.Collections.Generic.IEnumerable<int> source);

static member Max : seq<int> -> int
Parameters
Uma sequência de valores Int32 da qual será determinado o valor máximo.
Returns
Int32 Int32
O valor máximo na sequência.
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Max(IEnumerable<Int64>) para determinar o valor máximo em
uma sequência.
Note
List<long> longs = new List<long> { 4294967296L, 466855135L, 81125L };
long max = longs.Max();
/*
The largest number is 4294967296.

*/
Remarks
O Max(IEnumerable<Int32>) usa o Int32 implementação de IComparable<T> para comparar valores.
invocação de Max.
Also
public static Nullable<long> Max (this System.Collections.Generic.IEnumerable<Nullable<long>>

source);
static member Max : seq<Nullable<int64>> -> Nullable<int64>
Parameters
Uma sequência de valores Int64 anuláveis para determinar o valor máximo.
Returns
Nullable<Int64>
Um valor do tipo Nullable<Int64> em C# ou Nullable(Of Int64) no Visual Basic que corresponde ao valor máximo
na sequência.
Exceptions
source é null .
Examples
Note
/*

*/
Remarks
O Max(IEnumerable<Nullable<Int64>>) usa o Int64 implementação de IComparable<T> para comparar valores.
invocação de Max.
Also
Max(IEnumerable<Single>) Max(IEnumerable<Single>)
public static float Max (this System.Collections.Generic.IEnumerable<float> source);

static member Max : seq<single> -> single
Parameters
Uma sequência de valores Single da qual será determinado o valor máximo.
Returns
Single Single
Exceptions
source é null .
Examples
uma sequência.
Note
/*

*/
Remarks
O Max(IEnumerable<Single>) usa o Single implementação de IComparable<T> para comparar valores.
invocação de Max.
Also
public static Nullable<int> Max (this System.Collections.Generic.IEnumerable<Nullable<int>> source);

static member Max : seq<Nullable<int>> -> Nullable<int>
Parameters
Uma sequência de valores Int32 anuláveis para determinar o valor máximo.
Returns
Nullable<Int32>
Um valor do tipo Nullable<Int32> em C# ou Nullable(Of Int32) no Visual Basic que corresponde ao valor máximo
na sequência.
Exceptions
source é null .
Examples
Note
/*

*/
Remarks
O Max(IEnumerable<Nullable<Int32>>) usa o Int32 implementação de IComparable<T> para comparar valores.
invocação de Max.
Also
Max(IEnumerable<Decimal>) Max(IEnumerable<Decimal>)
Retorna o valor máximo em uma sequência de valores Decimal.
public static decimal Max (this System.Collections.Generic.IEnumerable<decimal> source);

static member Max : seq<decimal> -> decimal
Parameters
Uma sequência de valores Decimal da qual será determinado o valor máximo.
Returns
Decimal Decimal
Exceptions
source é null .
Examples
uma sequência.
Note
/*

*/
Remarks
O Max(IEnumerable<Decimal>) usa o Decimal implementação de IComparable<T> para comparar valores.
invocação de Max.
Also
Retorna o valor máximo em uma sequência de valores Decimal anuláveis.
public static Nullable<decimal> Max (this System.Collections.Generic.IEnumerable<Nullable<decimal>>

source);
static member Max : seq<Nullable<decimal>> -> Nullable<decimal>
Parameters
Uma sequência de valores Decimal anuláveis para determinar o valor máximo.
Returns
Nullable<Decimal>
Um valor do tipo Nullable<Decimal> em C# ou Nullable(Of Decimal) no Visual Basic que corresponde ao valor
Exceptions
source é null .
Examples
Note
/*

*/
Remarks
O Max(IEnumerable<Nullable<Decimal>>) usa o Decimal implementação de IComparable<T> para comparar
valores.
invocação de Max.
Also
public static long Max (this System.Collections.Generic.IEnumerable<long> source);

static member Max : seq<int64> -> int64
Parameters
Uma sequência de valores Int64 da qual será determinado o valor máximo.
Returns
Int64 Int64
Exceptions
source é null .
Examples
uma sequência.
/*

*/
Remarks
O Max(IEnumerable<Int64>) usa o Int64 implementação de IComparable<T> para comparar valores.
invocação de Max.
Also
Max(IEnumerable<Double>) Max(IEnumerable<Double>)
public static double Max (this System.Collections.Generic.IEnumerable<double> source);

static member Max : seq<double> -> double
Parameters
Uma sequência de valores Double da qual será determinado o valor máximo.
Returns
Double Double
Exceptions
source é null .
Examples
uma sequência.
Note
/*

*/
Remarks
O Max(IEnumerable<Double>) usa o Double implementação de IComparable<T> para comparar valores.
invocação de Max.
Also
Retorna o valor máximo em uma sequência de valores Double anuláveis.
public static Nullable<double> Max (this System.Collections.Generic.IEnumerable<Nullable<double>>

source);
static member Max : seq<Nullable<double>> -> Nullable<double>
Parameters
Uma sequência de valores Double anuláveis para determinar o valor máximo.
Returns
Nullable<Double>
Um valor do tipo Nullable<Double> em C# ou Nullable(Of Double) no Visual Basic que corresponde ao valor
Exceptions
source é null .
Examples
/*

*/
Remarks
O Max(IEnumerable<Nullable<Double>>) usa o Double implementação de IComparable<T> para comparar valores.
invocação de Max.
Also
Max<TSource,TResult>(IEnumerable<TSource>,
Func<TSource,TResult>) Max<TSource,TResult>
(IEnumerable<TSource>, Func<TSource,TResult>)
Invoca uma função de transformação em cada elemento de uma sequência genérica e retorna o maior valor resultante.
public static TResult Max<TSource,TResult> (this System.Collections.Generic.IEnumerable<TSource>
source, Func<TSource,TResult> selector);
static member Max : seq<'Source> * Func<'Source, 'Result> -> 'Result
Type Parameters
TSource
TResult
O tipo do valor retornado por selector .
Parameters
Uma sequência de valores para determinação do valor máximo.
selector Func<TSource,TResult>
Returns
TResult TResult
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)
para determinar o valor máximo em uma sequência de valores projetados.
Note
class Pet
{
}
public static void MaxEx4()

{
int max = pets.Max(pet => pet.Age + pet.Name.Length);
Console.WriteLine(
"The maximum pet age plus name length is {0}.",
max);
}
/*
The maximum pet age plus name length is 14.

*/
Remarks
Se tipo TResult implementa IComparable<T>, esse método usa essa implementação para comparar valores. Caso
contrário, se tipo TResult implementa IComparable, que a implementação é usada para comparar valores.
invocação de Max.
Also
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Single máximo.
public static float Max<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
static member Max : seq<'Source> * Func<'Source, single> -> single
Type Parameters
TSource
Parameters
Returns
Single Single
Exceptions
Examples
Note
class Pet
{
}

{
Console.WriteLine(
max);
}
/*

*/
Remarks
O Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>) usa o Single implementação de IComparable<T>
para comparar valores.
Você pode aplicar esse método em uma sequência de valores arbitrários, se você fornecer uma função selector , que
os membros de projetos source em um tipo numérico, especificamente Single.
invocação de Max.
Also
Max<TSource>(IEnumerable<TSource>,
Func<TSource,Nullable<Single>>) Max<TSource>
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Single máximo que
permite valor nulo.
public static Nullable<float> Max<TSource> (this System.Collections.Generic.IEnumerable<TSource>

static member Max : seq<'Source> * Func<'Source, Nullable<single>> -> Nullable<single>
Type Parameters
TSource
Parameters
Returns
Nullable<Single>
O valor do tipo Nullable<Single> em C# ou Nullable(Of Single) no Visual Basic que corresponde ao valor
Exceptions
Examples
Note
class Pet
{
}

{
Console.WriteLine(
max);
}
/*

*/
Remarks
O Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) usa o Single implementação de
IComparable<T> para comparar valores.
os membros de projetos source em um tipo numérico, especificamente Nullable<Single> em c# ou
Nullable(Of Single) no Visual Basic.
invocação de Max.
Also
Func<TSource,Nullable<Int64>>) Max<TSource>
permite valor nulo.
public static Nullable<long> Max<TSource> (this System.Collections.Generic.IEnumerable<TSource>

source, Func<TSource,Nullable<long>> selector);
static member Max : seq<'Source> * Func<'Source, Nullable<int64>> -> Nullable<int64>
Type Parameters
TSource
Parameters
Returns
Nullable<Int64>
O valor do tipo Nullable<Int64> em C# ou Nullable(Of Int64) no Visual Basic que corresponde ao valor máximo
na sequência.
Exceptions
Examples
Note
class Pet
{
}

{
Console.WriteLine(
max);
}
/*

*/
Remarks
O Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) usa o Int64 implementação de
os membros de projetos source em um tipo numérico, especificamente Nullable<Int64> em c# ou
Nullable(Of Int64) no Visual Basic.
invocação de Max.
Also
permite valor nulo.
public static Nullable<int> Max<TSource> (this System.Collections.Generic.IEnumerable<TSource>

source, Func<TSource,Nullable<int>> selector);
static member Max : seq<'Source> * Func<'Source, Nullable<int>> -> Nullable<int>
Type Parameters
TSource
Parameters
Returns
Nullable<Int32>
O valor do tipo Nullable<Int32> em C# ou Nullable(Of Int32) no Visual Basic que corresponde ao valor máximo
na sequência.
Exceptions
Examples
Note
class Pet
{
}

{
Console.WriteLine(
max);
}
/*

*/
Remarks
O Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) usa o Int32 implementação de
invocação de Max.
Also
Func<TSource,Nullable<Double>>) Max<TSource>
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Double máximo que
permite valor nulo.
public static Nullable<double> Max<TSource> (this System.Collections.Generic.IEnumerable<TSource>

source, Func<TSource,Nullable<double>> selector);
static member Max : seq<'Source> * Func<'Source, Nullable<double>> -> Nullable<double>
Type Parameters
TSource
Parameters
Returns
Nullable<Double>
O valor do tipo Nullable<Double> em C# ou Nullable(Of Double) no Visual Basic que corresponde ao valor
Exceptions
Examples
Note
class Pet
{
}

{
Console.WriteLine(
max);
}
/*

*/
Remarks
O Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) usa o Double implementação de
os membros de projetos source em um tipo numérico, especificamente Nullable<Double> em c# ou
Nullable(Of Double) no Visual Basic.
invocação de Max.
Also
public static long Max<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,

static member Max : seq<'Source> * Func<'Source, int64> -> int64
Type Parameters
TSource
Parameters
Returns
Int64 Int64
Exceptions
Examples
Note
class Pet
{
}

{
Console.WriteLine(
max);
}
/*

*/
Remarks
O Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) usa o Int64 implementação de IComparable<T>
os membros de projetos source em um tipo numérico, especificamente Int64.
invocação de Max.
Also
public static int Max<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
static member Max : seq<'Source> * Func<'Source, int> -> int
Type Parameters
TSource
Parameters
Returns
Int32 Int32
Exceptions
Examples
class Pet
{
}

{
Console.WriteLine(
max);
}
/*

*/
Remarks
O Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) usa o Int32 implementação de IComparable<T>
invocação de Max.
Also
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Double máximo.
public static double Max<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
static member Max : seq<'Source> * Func<'Source, double> -> double
Type Parameters
TSource
Parameters
Returns
Double Double
Exceptions
Examples
Note
class Pet
{
}

{
Console.WriteLine(
max);
}
/*

*/
Remarks
O Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>) usa o Double implementação de
os membros de projetos source em um tipo numérico, especificamente Double.
invocação de Max.
Also
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Decimal máximo.
public static decimal Max<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
static member Max : seq<'Source> * Func<'Source, decimal> -> decimal
Type Parameters
TSource
Parameters
Returns
Decimal Decimal
Exceptions
Examples
Note
class Pet
{
}

{
Console.WriteLine(
max);
}
/*

*/
Remarks
O Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) usa o Decimal implementação de
os membros de projetos source em um tipo numérico, especificamente Decimal.
invocação de Max.
Also
Max<TSource>(IEnumerable<TSource>) Max<TSource>
Retorna o valor máximo em uma sequência genérica.
public static TSource Max<TSource> (this System.Collections.Generic.IEnumerable<TSource> source);
static member Max : seq<'Source> -> 'Source
Type Parameters
TSource
Parameters
Returns
TSource TSource
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Max<TSource>(IEnumerable<TSource>) para determinar o valor
máximo em uma sequência de IComparable<T> objetos.
/// <summary>
/// This class implements IComparable to be able to
/// compare one Pet to another Pet.
/// </summary>
class Pet : IComparable<Pet>
{
/// <summary>
/// Compares this Pet to another Pet by
/// summing each Pet's age and name length.
/// </summary>
/// <param name="other">The Pet to compare this Pet to.</param>
/// <returns>-1 if this Pet is 'less' than the other Pet,
/// 0 if they are equal,
/// or 1 if this Pet is 'greater' than the other Pet.</returns>
int IComparable<Pet>.CompareTo(Pet other)
{
int sumOther = other.Age + other.Name.Length;
int sumThis = this.Age + this.Name.Length;
if (sumOther > sumThis)

return -1;
else if (sumOther == sumThis)
return 0;
else
return 1;
}
}

{
Pet max = pets.Max();
Console.WriteLine(
"The 'maximum' animal is {0}.",
max.Name);
}
/*
The 'maximum' animal is Barley.

*/
Remarks
Se tipo TSource implementa IComparable<T>, o Max<TSource>(IEnumerable<TSource>) usa o método que a
implementação para comparar valores. Caso contrário, se tipo TSource implementa IComparable, que a
implementação é usada para comparar valores.
Se TSource é um tipo de referência e a sequência de origem estiver vazia ou contiver somente valores que são null ,
esse método retornará null .
invocação de Max.
Also
Func<TSource,Nullable<Decimal>>) Max<TSource>
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Decimal máximo que
permite valor nulo.
public static Nullable<decimal> Max<TSource> (this System.Collections.Generic.IEnumerable<TSource>
source, Func<TSource,Nullable<decimal>> selector);
static member Max : seq<'Source> * Func<'Source, Nullable<decimal>> -> Nullable<decimal>
Type Parameters
TSource
Parameters
Returns
Nullable<Decimal>
O valor do tipo Nullable<Decimal> em C# ou Nullable(Of Decimal) no Visual Basic que corresponde ao valor
Exceptions
Examples
Note
class Pet
{
}

{
Console.WriteLine(
max);
}
/*

*/
Remarks
O Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) usa o Decimal implementação de
os membros de projetos source em um tipo numérico, especificamente Nullable<Decimal> em c# ou
Nullable(Of Decimal) no Visual Basic.
invocação de Max.
Also
Enumerable.Min Enumerable.Min
I n this Article
Overloads
Min(IEnumerable<Nullable<Int64>>) Min(IEnumerable<
Nullable<Int64>>) Retorna o valor mínimo em uma sequência de valores Int64
anuláveis.
Min(IEnumerable<Nullable<Int32>>) Min(IEnumerable<
Nullable<Int32>>) Retorna o valor mínimo em uma sequência de valores Int32
anuláveis.
Min(IEnumerable<Single>) Min(IEnumerable<Single>)
Min(IEnumerable<Nullable<Single>>) Min(IEnumerable<
Nullable<Single>>) Retorna o valor mínimo em uma sequência de valores Single
anuláveis.
Min(IEnumerable<Nullable<Double>>) Min(IEnumerable<
Nullable<Double>>) Retorna o valor mínimo em uma sequência de valores Double
anuláveis.
Min(IEnumerable<Double>) Min(IEnumerable<Double>)
Min(IEnumerable<Int64>) Min(IEnumerable<Int64>)
Min(IEnumerable<Nullable<Decimal>>) Min(IEnumerable<
Nullable<Decimal>>) Retorna o valor mínimo em uma sequência de valores Decimal
anuláveis.
Min(IEnumerable<Decimal>) Min(IEnumerable<Decimal>)
Min<TSource,TResult>(IEnumerable<TSource>, Func<
TSource,TResult>) Min<TSource,TResult>(IEnumerable< Invoca uma função de transformação em cada elemento de
TSource>, Func<TSource,TResult>) uma sequência genérica e retorna o menor valor resultante.
Min<TSource>(IEnumerable<TSource>, Func<TSource,
Single>) Min<TSource>(IEnumerable<TSource>, Func< Invoca uma função de transformação em cada elemento de
TSource,Single>) uma sequência e retorna o valor Single mínimo.
Nullable<Single>>) Min<TSource>(IEnumerable<TSource>, Invoca uma função de transformação em cada elemento de
Func<TSource,Nullable<Single>>) uma sequência e retorna o valor Single mínimo que permite
valor nulo.
Nullable<Int64>>) Min<TSource>(IEnumerable<TSource>, Invoca uma função de transformação em cada elemento de
Func<TSource,Nullable<Int64>>) uma sequência e retorna o valor Int64 mínimo que permite
valor nulo.
Nullable<Int32>>) Min<TSource>(IEnumerable<TSource>, Invoca uma função de transformação em cada elemento de
Func<TSource,Nullable<Int32>>) uma sequência e retorna o valor Int32 mínimo que permite
valor nulo.
Nullable<Double>>) Min<TSource>(IEnumerable<TSource>, Invoca uma função de transformação em cada elemento de
Func<TSource,Nullable<Double>>) uma sequência e retorna o valor Double mínimo que permite
valor nulo.
Int64>) Min<TSource>(IEnumerable<TSource>, Func< Invoca uma função de transformação em cada elemento de
TSource,Int64>) uma sequência e retorna o valor Int64 mínimo.
Int32>) Min<TSource>(IEnumerable<TSource>, Func< Invoca uma função de transformação em cada elemento de
TSource,Int32>) uma sequência e retorna o valor Int32 mínimo.
Double>) Min<TSource>(IEnumerable<TSource>, Func< Invoca uma função de transformação em cada elemento de
TSource,Double>) uma sequência e retorna o valor Double mínimo.
Decimal>) Min<TSource>(IEnumerable<TSource>, Func< Invoca uma função de transformação em cada elemento de
TSource,Decimal>) uma sequência e retorna o valor Decimal mínimo.
Min<TSource>(IEnumerable<TSource>) Min<TSource>(
IEnumerable<TSource>) Retorna o valor mínimo em uma sequência genérica.
Nullable<Decimal>>) Min<TSource>(IEnumerable<TSource>, Invoca uma função de transformação em cada elemento de
Func<TSource,Nullable<Decimal>>) uma sequência e retorna o valor Decimal mínimo que permite
valor nulo.
public static Nullable<long> Min (this System.Collections.Generic.IEnumerable<Nullable<long>>

source);
static member Min : seq<Nullable<int64>> -> Nullable<int64>
Parameters
Uma sequência de valores Int64 anuláveis dos quais determinar o valor mínimo.
Returns
Nullable<Int64>
Um valor do tipo Nullable<Int64> em C# ou Nullable(Of Int64) no Visual Basic que corresponde ao valor mínimo
na sequência.
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Min(IEnumerable<Nullable<Int32>>) para determinar o valor
mínimo em uma sequência.
Note
int?[] grades = { 78, 92, null, 99, 37, 81 };
int? min = grades.Min();
Console.WriteLine("The lowest grade is {0}.", min);
/*
The lowest grade is 37.

*/
Remarks
O Min(IEnumerable<Nullable<Int64>>) usa o Int64 implementação de IComparable<T> para comparar valores.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Min() cláusula se traduz em uma
invocação de Min.
Also
public static Nullable<int> Min (this System.Collections.Generic.IEnumerable<Nullable<int>> source);

static member Min : seq<Nullable<int>> -> Nullable<int>
Parameters
Uma sequência de valores Int32 anuláveis dos quais determinar o valor mínimo.
Returns
Nullable<Int32>
Um valor do tipo Nullable<Int32> em C# ou Nullable(Of Int32) no Visual Basic que corresponde ao valor mínimo
na sequência.
Exceptions
source é null .
Examples
int?[] grades = { 78, 92, null, 99, 37, 81 };
/*

*/
Remarks
O Min(IEnumerable<Nullable<Int32>>) usa o Int32 implementação de IComparable<T> para comparar valores.
invocação de Min.
Also
Min(IEnumerable<Single>) Min(IEnumerable<Single>)
public static float Min (this System.Collections.Generic.IEnumerable<float> source);

static member Min : seq<single> -> single
Parameters
Uma sequência de valores Single para determinação do valor mínimo.
Returns
Single Single
O valor mínimo na sequência.
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Min(IEnumerable<Double>) para determinar o valor mínimo em
uma sequência.
Note
double[] doubles = { 1.5E+104, 9E+103, -2E+103 };
double min = doubles.Min();
Console.WriteLine("The smallest number is {0}.", min);
/*
The smallest number is -2E+103.

*/
Remarks
O Min(IEnumerable<Single>) usa o Single implementação de IComparable<T> para comparar valores.
invocação de Min.
Also
Retorna o valor mínimo em uma sequência de valores Single anuláveis.
public static Nullable<float> Min (this System.Collections.Generic.IEnumerable<Nullable<float>>

source);
static member Min : seq<Nullable<single>> -> Nullable<single>
Parameters
Uma sequência de valores Single anuláveis dos quais determinar o valor mínimo.
Returns
Nullable<Single>
Um valor do tipo Nullable<Single> em C# ou Nullable(Of Single) no Visual Basic que corresponde ao valor
mínimo na sequência.
Exceptions
source é null .
Examples
Note
int?[] grades = { 78, 92, null, 99, 37, 81 };
/*

*/
Remarks
O Min(IEnumerable<Nullable<Single>>) usa o Single implementação de IComparable<T> para comparar valores.
invocação de Min.
Also
Retorna o valor mínimo em uma sequência de valores Double anuláveis.
public static Nullable<double> Min (this System.Collections.Generic.IEnumerable<Nullable<double>>

source);
static member Min : seq<Nullable<double>> -> Nullable<double>
Parameters
Uma sequência de valores Double anuláveis dos quais determinar o valor mínimo.
Returns
Nullable<Double>
Um valor do tipo Nullable<Double> em C# ou Nullable(Of Double) no Visual Basic que corresponde ao valor
Exceptions
source é null .
Examples
Note
int?[] grades = { 78, 92, null, 99, 37, 81 };
/*

*/
Remarks
O Min(IEnumerable<Nullable<Double>>) usa o Double implementação de IComparable<T> para comparar valores.
invocação de Min.
Also
Min(IEnumerable<Double>) Min(IEnumerable<Double>)
public static double Min (this System.Collections.Generic.IEnumerable<double> source);

static member Min : seq<double> -> double
Parameters
Uma sequência de valores Double para determinação do valor mínimo.
Returns
Double Double
Exceptions
source é null .
Examples
uma sequência.
/*

*/
Remarks
O Min(IEnumerable<Double>) usa o Double implementação de IComparable<T> para comparar valores.
invocação de Min.
Also
public static long Min (this System.Collections.Generic.IEnumerable<long> source);

static member Min : seq<int64> -> int64
Parameters
Uma sequência de valores Int64 para determinação do valor mínimo.
Returns
Int64 Int64
Exceptions
source é null .
Examples
uma sequência.
Note
/*

*/
Remarks
O Min(IEnumerable<Int64>) usa o Int64 implementação de IComparable<T> para comparar valores.
invocação de Min.
Also
public static int Min (this System.Collections.Generic.IEnumerable<int> source);

static member Min : seq<int> -> int
Parameters
Uma sequência de valores Int32 para determinação do valor mínimo.
Returns
Int32 Int32
Exceptions
source é null .
Examples
uma sequência.
Note
/*

*/
Remarks
O Min(IEnumerable<Int32>) usa o Int32 implementação de IComparable<T> para comparar valores.
invocação de Min.
Also
Retorna o valor mínimo em uma sequência de valores Decimal anuláveis.
public static Nullable<decimal> Min (this System.Collections.Generic.IEnumerable<Nullable<decimal>>

source);
static member Min : seq<Nullable<decimal>> -> Nullable<decimal>
Parameters
Uma sequência de valores Decimal anuláveis dos quais determinar o valor mínimo.
Returns
Nullable<Decimal>
Um valor do tipo Nullable<Decimal> em C# ou Nullable(Of Decimal) no Visual Basic que corresponde ao valor
Exceptions
source é null .
Examples
Note
int?[] grades = { 78, 92, null, 99, 37, 81 };
/*

*/
Remarks
O Min(IEnumerable<Nullable<Decimal>>) usa o Decimal implementação de IComparable<T> para comparar
valores.
invocação de Min.
Also
Min(IEnumerable<Decimal>) Min(IEnumerable<Decimal>)
public static decimal Min (this System.Collections.Generic.IEnumerable<decimal> source);
static member Min : seq<decimal> -> decimal
Parameters
Uma sequência de valores Decimal para determinação do valor mínimo.
Returns
Decimal Decimal
Exceptions
source é null .
Examples
uma sequência.
Note
/*

*/
Remarks
O Min(IEnumerable<Decimal>) usa o Decimal implementação de IComparable<T> para comparar valores.
invocação de Min.
Also
Min<TSource,TResult>(IEnumerable<TSource>,
Func<TSource,TResult>) Min<TSource,TResult>
Invoca uma função de transformação em cada elemento de uma sequência genérica e retorna o menor valor
resultante.
public static TResult Min<TSource,TResult> (this System.Collections.Generic.IEnumerable<TSource>

source, Func<TSource,TResult> selector);
static member Min : seq<'Source> * Func<'Source, 'Result> -> 'Result
Type Parameters
TSource
TResult
Parameters
Uma sequência de valores da qual será determinado o valor mínimo.
Returns
TResult TResult
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)
para determinar o valor mínimo em uma sequência de valores projetados.
Note
class Pet
{
}
public static void MinEx4()

{
int min = pets.Min(pet => pet.Age);
Console.WriteLine("The youngest animal is age {0}.", min);

}
/*
The youngest animal is age 1.

*/
Remarks
Se tipo TResult implementa IComparable<T>, esse método usa essa implementação para comparar valores. Caso
contrário, se tipo TResult implementa IComparable, que a implementação é usada para comparar valores.
invocação de Min.
Also
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Single mínimo.
public static float Min<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,

static member Min : seq<'Source> * Func<'Source, single> -> single
Type Parameters
TSource
Parameters
Uma sequência de valores para determinação do valor mínimo.
Returns
Single Single
Exceptions
Examples
Note
class Pet
{
}

{

}
/*

*/
Remarks
O Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>) usa o Single implementação de IComparable<T>
invocação de Min.
Also
Min<TSource>(IEnumerable<TSource>,
Func<TSource,Nullable<Single>>) Min<TSource>
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Single mínimo que
permite valor nulo.
public static Nullable<float> Min<TSource> (this System.Collections.Generic.IEnumerable<TSource>

static member Min : seq<'Source> * Func<'Source, Nullable<single>> -> Nullable<single>
Type Parameters
TSource
Parameters
Returns
Nullable<Single>
O valor do tipo Nullable<Single> em C# ou Nullable(Of Single) no Visual Basic que corresponde ao valor
Exceptions
Examples
Note
class Pet
{
}

{

}
/*

*/
Remarks
O Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) usa o Single implementação de
invocação de Min.
Also
Func<TSource,Nullable<Int64>>) Min<TSource>
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int64 mínimo que permite
valor nulo.
public static Nullable<long> Min<TSource> (this System.Collections.Generic.IEnumerable<TSource>

static member Min : seq<'Source> * Func<'Source, Nullable<int64>> -> Nullable<int64>
Type Parameters
TSource
Parameters
Returns
Nullable<Int64>
O valor do tipo Nullable<Int64> em C# ou Nullable(Of Int64) no Visual Basic que corresponde ao valor mínimo
na sequência.
Exceptions
Examples
Note
class Pet
{
}

{

}
/*

*/
Remarks
O Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) usa o Int64 implementação de
invocação de Min.
Also
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int32 mínimo que permite
valor nulo.
public static Nullable<int> Min<TSource> (this System.Collections.Generic.IEnumerable<TSource>
static member Min : seq<'Source> * Func<'Source, Nullable<int>> -> Nullable<int>
Type Parameters
TSource
Parameters
Returns
Nullable<Int32>
O valor do tipo Nullable<Int32> em C# ou Nullable(Of Int32) no Visual Basic que corresponde ao valor mínimo
na sequência.
Exceptions
Examples
Note
class Pet
{
}

{

}
/*

*/
Remarks
O Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) usa o Int32 implementação de
projeta os membros de origem em um tipo numérico, especificamente Nullable<Int32> em c# ou
invocação de Min.
Also
Func<TSource,Nullable<Double>>) Min<TSource>
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Double mínimo que
permite valor nulo.
public static Nullable<double> Min<TSource> (this System.Collections.Generic.IEnumerable<TSource>
static member Min : seq<'Source> * Func<'Source, Nullable<double>> -> Nullable<double>
Type Parameters
TSource
Parameters
Returns
Nullable<Double>
O valor do tipo Nullable<Double> em C# ou Nullable(Of Double) no Visual Basic que corresponde ao valor
Exceptions
Examples
Note
class Pet
{
}

{

}
/*

*/
Remarks
O Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) usa o Double implementação de
invocação de Min.
Also
public static long Min<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
static member Min : seq<'Source> * Func<'Source, int64> -> int64
Type Parameters
TSource
Parameters
Returns
Int64 Int64
Exceptions
Examples
Note
class Pet
{
}

{

}
/*

*/
Remarks
O Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) usa o Int64 implementação de IComparable<T>
invocação de Min.
Also
public static int Min<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,

static member Min : seq<'Source> * Func<'Source, int> -> int
Type Parameters
TSource
Parameters
Returns
Int32 Int32
Exceptions
Examples
class Pet
{
}

{

}
/*

*/
Remarks
O Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) usa o Int32 implementação de IComparable<T>
invocação de Min.
Also
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Double mínimo.
public static double Min<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,

static member Min : seq<'Source> * Func<'Source, double> -> double
Type Parameters
TSource
Parameters
Returns
Double Double
Exceptions
Examples
Note
class Pet
{
}

{

}
/*

*/
Remarks
O Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>) usa o Double implementação de
invocação de Min.
Also
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Decimal mínimo.
public static decimal Min<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
static member Min : seq<'Source> * Func<'Source, decimal> -> decimal
Type Parameters
TSource
Parameters
Returns
Decimal Decimal
Exceptions
Examples
Note
class Pet
{
}

{

}
/*

*/
Remarks
O Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) usa o Decimal implementação de
invocação de Min.
Also
Min<TSource>(IEnumerable<TSource>) Min<TSource>
Retorna o valor mínimo em uma sequência genérica.
public static TSource Min<TSource> (this System.Collections.Generic.IEnumerable<TSource> source);
static member Min : seq<'Source> -> 'Source
Type Parameters
TSource
Parameters
Returns
TSource TSource
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Min<TSource>(IEnumerable<TSource>) para determinar o valor
mínimo em uma sequência de IComparable<T> objetos.
/// <summary>
/// This class implements IComparable in order to
/// be able to compare different Pet objects.
/// </summary>
class Pet : IComparable<Pet>
{
/// <summary>
/// Compares this Pet's age to another Pet's age.
/// </summary>
/// <param name="other">The Pet to compare this Pet to.</param>
/// <returns>-1 if this Pet's age is smaller,
/// 0 if the Pets' ages are equal, or
/// 1 if this Pet's age is greater.</returns>
int IComparable<Pet>.CompareTo(Pet other)
{
if (other.Age > this.Age)
return -1;
else if (other.Age == this.Age)
return 0;
else
return 1;
}
}

{
Pet min = pets.Min();
Console.WriteLine(
"The 'minimum' animal is {0}.",
min.Name);
}
/*
The 'minimum' animal is Whiskers.

*/
Remarks
Se tipo TSource implementa IComparable<T>, esse método usa essa implementação para comparar valores. Caso
contrário, se tipo TSource implementa IComparable, que a implementação é usada para comparar valores.
Se TSource é um tipo de referência e a sequência de origem estiver vazia ou contiver somente valores que são null ,
essa função retorna null .
invocação de Min.
Also
Func<TSource,Nullable<Decimal>>) Min<TSource>
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Decimal mínimo que
permite valor nulo.
public static Nullable<decimal> Min<TSource> (this System.Collections.Generic.IEnumerable<TSource>

static member Min : seq<'Source> * Func<'Source, Nullable<decimal>> -> Nullable<decimal>
Type Parameters
TSource
Parameters
Returns
Nullable<Decimal>
O valor do tipo Nullable<Decimal> em C# ou Nullable(Of Decimal) no Visual Basic que corresponde ao valor
Exceptions
Examples
Note
class Pet
{
}

{

}
/*

*/
Remarks
O Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) usa o Decimal implementação de
invocação de Min.
Also
Enumerable.OfType Enumerable.OfType
I n this Article
Filtra os elementos de um IEnumerable com base em um tipo especificado.
public static System.Collections.Generic.IEnumerable<TResult> OfType<TResult> (this
System.Collections.IEnumerable source);
static member OfType : System.Collections.IEnumerable -> seq<'Result>
Type Parameters
TResult
O tipo no qual filtrar os elementos da sequência.
Parameters
O IEnumerable cujos elementos serão filtrados.
Returns
Um IEnumerable<T> que contém elementos da sequência de entrada de tipo TResult .
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar OfType para filtrar os elementos de um IEnumerable.
System.Collections.ArrayList fruits = new System.Collections.ArrayList(4);
fruits.Add("Mango");
fruits.Add("Orange");
fruits.Add("Apple");
fruits.Add(3.0);
fruits.Add("Banana");
// Apply OfType() to the ArrayList.

IEnumerable<string> query1 = fruits.OfType<string>();
Console.WriteLine("Elements of type 'string' are:");

foreach (string fruit in query1)
{
}
// The following query shows that the standard query operators such as
// Where() can be applied to the ArrayList type after calling OfType().
fruits.OfType<string>().Where(fruit => fruit.ToLower().Contains("n"));
Console.WriteLine("
The following strings contain 'n':");
foreach (string fruit in query2)
{
}

//
// Elements of type 'string' are:
// Mango
// Orange
// Apple
// Banana
//
// The following strings contain 'n':
// Mango
// Orange
// Banana
Remarks
O OfType<TResult>(IEnumerable) método retorna apenas os elementos no source que pode ser convertido no tipo
TResult . Em vez disso, receba uma exceção se um elemento não pode ser convertido para o tipo TResult , use
Cast<TResult>(IEnumerable).
Esse método é um dos alguns métodos de operador de consulta padrão que podem ser aplicados a uma coleção que
tem um tipo sem parâmetros, como um ArrayList. Isso ocorre porque OfType estende o tipo IEnumerable. OfType não
pode ser aplicado somente às coleções que são baseadas em com os parâmetros IEnumerable<T> tipo, mas as
coleções que se baseiam os sem parâmetros IEnumerable tipo também.
Aplicando OfType em uma coleção que implementa IEnumerable, você ganha a capacidade de consultar a coleção
usando os operadores de consulta padrão. Por exemplo, especificar um argumento de tipo de Object à OfType
retornaria um objeto do tipo IEnumerable<Object> em c# ou IEnumerable(Of Object) no Visual Basic, para que os
operadores de consulta padrão podem ser aplicados.
Enumerable.OrderBy Enumerable.OrderBy
I n this Article
Overloads
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<
TSource,TKey>) OrderBy<TSource,TKey>(IEnumerable< Classifica os elementos de uma sequência em ordem crescente
TSource>, Func<TSource,TKey>) de acordo com uma chave.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<
TSource,TKey>, IComparer<TKey>) OrderBy<TSource,TKey>( Classifica os elementos de uma sequência em ordem crescente
IEnumerable<TSource>, Func<TSource,TKey>, IComparer< usando um comparador especificado.
TKey>)
OrderBy<TSource,TKey>(IEnumerable<TSource>,
Func<TSource,TKey>) OrderBy<TSource,TKey>
public static System.Linq.IOrderedEnumerable<TSource> OrderBy<TSource,TKey> (this
System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector);
static member OrderBy : seq<'Source> * Func<'Source, 'Key> ->
System.Linq.IOrderedEnumerable<'Source>
Type Parameters
TSource
TKey
Parameters
Uma sequência de valores a serem ordenados.
Uma função para extrair uma chave de um elemento.
Returns
IOrderedEnumerable<TSource>
Um IOrderedEnumerable<TElement> cujos elementos são classificados de acordo com uma chave.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar OrderBy<TSource,TKey>(IEnumerable<TSource>,
Func<TSource,TKey>) para classificar os elementos de uma sequência.
class Pet
{
}
public static void OrderByEx1()

{
IEnumerable<Pet> query = pets.OrderBy(pet => pet.Age);
foreach (Pet pet in query)

{
Console.WriteLine("{0} - {1}", pet.Name, pet.Age);
}
}
/*
Whiskers - 1
Boots - 4
Barley - 8
*/
Remarks
Para solicitar uma sequência pelos valores dos próprios elementos, especifique a função identity ( x => x no Visual c#
ou Function(x) x no Visual Basic) para keySelector .
Dois métodos são definidos para estender o tipo IOrderedEnumerable<TElement>, que é o tipo de retorno desse
método. Esses dois métodos, ou seja, ThenBy e ThenByDescending , permitem que você especifique os critérios
adicionais de classificação para classificar uma sequência. ThenBy e ThenByDescending também retornam uma
IOrderedEnumerable<TElement>, que significa que qualquer número de chamadas consecutivas para ThenBy ou
ThenByDescending podem ser feitas.
Note
Porque IOrderedEnumerable<TElement> herda IEnumerable<T>, você pode chamar OrderBy ou OrderByDescending

nos resultados de uma chamada para OrderBy, OrderByDescending, ThenBy ou ThenByDescending. Isso apresenta
um novo primário ordenação que ignora a ordem estabelecida anteriormente.
Esse método compara as chaves usando o comparador padrão Default.
Esse método executa uma classificação estável; ou seja, se as chaves de dois elementos são iguais, a ordem dos
elementos é preservada. Em contraste, uma classificação instável não preserva a ordem dos elementos que têm a
mesma chave.
Na sintaxe de expressão de consulta, uma orderby (Visual c#) ou Order By cláusula (Visual Basic) se traduz em uma
invocação de OrderBy.
See
Also
OrderByDescending<TSource,TKey>(IEnumerable<TSource>,
Func<TSource,TKey>)OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>,
IComparer<TKey>)OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>,
IComparer<TKey>)
Cláusula orderby (Referência de C#)orderby clause (C# Reference)
Cláusula Order By (Visual Basic)Order By Clause (Visual Basic)
Func<TSource,TKey>, IComparer<TKey>)
public static System.Linq.IOrderedEnumerable<TSource> OrderBy<TSource,TKey> (this
System.Collections.Generic.IComparer<TKey> comparer);
static member OrderBy : seq<'Source> * Func<'Source, 'Key> *
System.Collections.Generic.IComparer<'Key> -> System.Linq.IOrderedEnumerable<'Source>
Type Parameters
TSource
TKey
Parameters
comparer IComparer<TKey>
Um IComparer<T> para comparar chaves.
Returns
Exceptions
Remarks
Note

Se comparer está null , o comparador padrão Default é usado para comparar chaves.
mesma chave.
See
Also
Func<TSource,TKey>)OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>,
IComparer<TKey>)OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>,
IComparer<TKey>)
Enumerable.OrderByDescending Enumerable.OrderBy
Descending
I n this Article
Overloads
Func<TSource,TKey>, IComparer<TKey>) OrderBy Classifica os elementos de uma sequência em ordem
Descending<TSource,TKey>(IEnumerable<TSource>, Func< decrescente usando um comparador especificado.
TSource,TKey>, IComparer<TKey>)
Func<TSource,TKey>) OrderByDescending<TSource,TKey>( Classifica os elementos de uma sequência em ordem
IEnumerable<TSource>, Func<TSource,TKey>) decrescente de acordo com uma chave.
public static System.Linq.IOrderedEnumerable<TSource> OrderByDescending<TSource,TKey> (this
static member OrderByDescending : seq<'Source> * Func<'Source, 'Key> *
Type Parameters
TSource
TKey
Parameters
Returns
Um IOrderedEnumerable<TElement> cujos elementos são classificados em ordem decrescente de acordo com uma
chave.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar OrderByDescending<TSource,TKey>(IEnumerable<TSource>,
Func<TSource,TKey>, IComparer<TKey>) para classificar os elementos de uma sequência em ordem decrescente
usando uma função de transformação e um comparador personalizado.
/// <summary>
/// This IComparer class sorts by the fractional part of the decimal number.
/// </summary>
public class SpecialComparer : IComparer<decimal>
{
/// <summary>
/// Compare two decimal numbers by their fractional parts.
/// </summary>
/// <param name="d1">The first decimal to compare.</param>
/// <param name="d2">The second decimal to compare.</param>
/// <returns>1 if the first decimal's fractional part
/// is greater than the second decimal's fractional part,
/// -1 if the first decimal's fractional
/// part is less than the second decimal's fractional part,
/// or the result of calling Decimal.Compare()
/// if the fractional parts are equal.</returns>
public int Compare(decimal d1, decimal d2)
{
decimal fractional1, fractional2;
// Get the fractional part of the first number.

try
{
fractional1 = decimal.Remainder(d1, decimal.Floor(d1));
}
catch (DivideByZeroException)
{
fractional1 = d1;
}
// Get the fractional part of the second number.
try
{
}
{
fractional2 = d2;
}
if (fractional1 == fractional2)
return Decimal.Compare(d1, d2);
else if (fractional1 > fractional2)
return 1;
else
return -1;
}
}
public static void OrderByDescendingEx1()

{
List<decimal> decimals =
new List<decimal> { 6.2m, 8.3m, 0.5m, 1.3m, 6.3m, 9.7m };
IEnumerable<decimal> query =
decimals.OrderByDescending(num =>
num, new SpecialComparer());
foreach (decimal num in query)

{
Console.WriteLine(num);
}
}
/*
9.7
0.5
8.3
6.3
1.3
6.2
*/
Remarks
Note

mesma chave.
See
Also
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)OrderBy<TSource,TKey>
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>,
IComparer<TKey>)OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>,
IComparer<TKey>)
Func<TSource,TKey>) OrderByDescending<TSource,TKey>
public static System.Linq.IOrderedEnumerable<TSource> OrderByDescending<TSource,TKey> (this

static member OrderByDescending : seq<'Source> * Func<'Source, 'Key> ->
Type Parameters
TSource
TKey
Parameters
Returns
chave.
Exceptions
Remarks
Para obter um exemplo desse método, consulte OrderByDescending<TSource,TKey>(IEnumerable<TSource>,

Func<TSource,TKey>, IComparer<TKey>).
Note

mesma chave.
Na sintaxe de expressão de consulta, uma orderby descending (Visual c#) ou Order By Descending cláusula (Visual
Basic) se traduz em uma invocação de OrderByDescending.
See
Also
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)OrderBy<TSource,TKey>
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>,
IComparer<TKey>)OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>,
IComparer<TKey>)
Cláusula orderby (Referência de C#)orderby clause (C# Reference)
Cláusula Order By (Visual Basic)Order By Clause (Visual Basic)
Enumerable.Prepend Enumerable.Prepend
I n this Article
Adiciona um valor ao início da sequência.
public static System.Collections.Generic.IEnumerable<TSource> Prepend<TSource> (this
System.Collections.Generic.IEnumerable<TSource> source, TSource element);
static member Prepend : seq<'Source> * 'Source -> seq<'Source>
Type Parameters
TSource
Parameters
Uma sequência de valores.
O valor a ser precedido a source .
Returns
Uma nova sequência que começa com element .
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Prepend preceder um valor para o início da sequência.
// Creating a list of numbers
List<int> numbers = new List<int> { 1, 2, 3, 4 };
// Trying to prepend any value of the same type

numbers.Prepend(0);
// It doesn't work because the original list has not been changed
Console.WriteLine(string.Join(", ", numbers));
// It works now because we are using a changed copy of the original list
Console.WriteLine(string.Join(", ", numbers.Prepend(0)));
// If you prefer, you can create a new list explicitly

List<int> newNumbers = numbers.Prepend(0).ToList();
// And then write to the console output

Console.WriteLine(string.Join(", ", newNumbers));

//
// 1, 2, 3, 4
// 0, 1, 2, 3, 4
// 0, 1, 2, 3, 4
Remarks
Note
Esse método não modifica os elementos da coleção. Em vez disso, ele cria uma cópia da coleção com o novo elemento.
Enumerable.Range Enumerable.Range
I n this Article
Gera uma sequência de números integrais dentro de um intervalo especificado.
public static System.Collections.Generic.IEnumerable<int> Range (int start, int count);
static member Range : int * int -> seq<int>
Parameters
start Int32 Int32
O valor do primeiro inteiro na sequência.
count Int32 Int32
O número de inteiros sequenciais a serem gerados.
Returns
IEnumerable<Int32>
Um IEnumerable<Int32> em C# ou IEnumerable(Of Int32) no Visual Basic que contém um intervalo de números
inteiros sequenciais.
Exceptions
count é menor que 0.
- ou - start + count -1 é maior que MaxValue.
Examples
O exemplo de código a seguir demonstra como usar Range para gerar uma sequência de valores.
// Generate a sequence of integers from 1 to 10
// and then select their squares.
IEnumerable<int> squares = Enumerable.Range(1, 10).Select(x => x * x);
foreach (int num in squares)

{
}
/*
1
4
9
16
25
36
49
64
81
100
*/
Remarks
Enumerable.Repeat Enumerable.Repeat
I n this Article
Gera uma sequência que contém um valor repetido.
public static System.Collections.Generic.IEnumerable<TResult> Repeat<TResult> (TResult element, int
count);
static member Repeat : 'Result * int -> seq<'Result>
Type Parameters
TResult
O tipo do valor a ser repetido na sequência de resultado.
Parameters
element TResult TResult
O valor a ser repetido.
count Int32 Int32
O número de vezes para repetir o valor na sequência gerada.
Returns
Um IEnumerable<T> que contém um valor repetido.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Repeat para gerar uma sequência de um valor repetido.
IEnumerable<string> strings =
Enumerable.Repeat("I like programming.", 15);
foreach (String str in strings)

{
Console.WriteLine(str);
}
/*
I like programming.
I like programming.
I like programming.
I like programming.
I like programming.
I like programming.
I like programming.
I like programming.
I like programming.
I like programming.
I like programming.
I like programming.
I like programming.
I like programming.
I like programming.
*/
Remarks
Enumerable.Reverse Enumerable.Reverse
I n this Article
public static System.Collections.Generic.IEnumerable<TSource> Reverse<TSource> (this
static member Reverse : seq<'Source> -> seq<'Source>
Type Parameters
TSource
Parameters
Uma sequência de valores a ser revertida.
Returns
Uma sequência cujos elementos correspondem aos elementos da sequência de entrada em ordem inversa.
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Reverse para inverter a ordem dos elementos em uma matriz.
char[] apple = { 'a', 'p', 'p', 'l', 'e' };
char[] reversed = apple.Reverse().ToArray();
foreach (char chr in reversed)

{
Console.Write(chr + " ");
}
Console.WriteLine();
/*
e l p p a
*/
Remarks
Ao contrário de OrderBy, esse método de classificação não considera os valores reais em si determinar a ordem. Em
vez disso, ele retorna apenas os elementos na ordem inversa da qual eles são produzidos pela fonte subjacente.
Enumerable.Select Enumerable.Select
I n this Article
Overloads
Select<TSource,TResult>(IEnumerable<TSource>, Func<
TSource,Int32,TResult>) Select<TSource,TResult>( Projeta cada elemento de uma sequência em um novo
IEnumerable<TSource>, Func<TSource,Int32,TResult>) formulário, incorporando o índice do elemento.
Select<TSource,TResult>(IEnumerable<TSource>, Func<
TSource,TResult>) Select<TSource,TResult>(IEnumerable< Projeta cada elemento de uma sequência em um novo
TSource>, Func<TSource,TResult>) formulário.
Select<TSource,TResult>(IEnumerable<TSource>,
Func<TSource,Int32,TResult>) Select<TSource,TResult>
(IEnumerable<TSource>, Func<TSource,Int32,TResult>)
public static System.Collections.Generic.IEnumerable<TResult> Select<TSource,TResult> (this
System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,int,TResult> selector);
static member Select : seq<'Source> * Func<'Source, int, 'Result> -> seq<'Result>
Type Parameters
TSource
TResult
Parameters
Uma sequência de valores na qual uma função de transformação será invocada.
selector Func<TSource,Int32,TResult>
Uma função de transformação para aplicar a cada elemento de origem; o segundo parâmetro da função representa o
índice do elemento de origem.
Returns
Um IEnumerable<T> cujos elementos são o resultado da invocação da função de transformação em cada elemento de
source .
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Select<TSource,TResult>(IEnumerable<TSource>,
Func<TSource,Int32,TResult>) em uma sequência de valores de projeto e usar o índice de cada elemento.
string[] fruits = { "apple", "banana", "mango", "orange",
"passionfruit", "grape" };
var query =
fruits.Select((fruit, index) =>
new { index, str = fruit.Substring(0, index) });

{
Console.WriteLine("{0}", obj);
}
/*
{index=0, str=}
{index=1, str=b}
{index=2, str=ma}
{index=3, str=ora}
{index=4, str=pass}
{index=5, str=grape}
*/
Remarks
O primeiro argumento para selector representa o elemento para processar. O segundo argumento para selector
representa o índice baseado em zero do elemento na sequência de origem. Isso pode ser útil se os elementos estão em
uma ordem conhecida e você deseja fazer algo com um elemento em um índice específico, por exemplo. Ele também
pode ser útil se você quiser recuperar o índice de um ou mais elementos.
Esse método de projeção requer que a função de transformação selector , para produzir um valor para cada valor na
sequência de origem, source . Se selector retorna um valor que é uma coleção, é responsabilidade do consumidor
para percorrer as subsequências manualmente. Nessa situação, talvez seja melhor para a sua consulta retornar uma
única sequência conciliada de valores. Para fazer isso, use o SelectMany método em vez de Select. Embora
SelectMany funciona da mesma forma que Select , ele é diferente em que a função de transformação retorna uma
coleção que, em seguida, é expandida por SelectMany antes de ser retornado.
Select<TSource,TResult>(IEnumerable<TSource>,
Func<TSource,TResult>) Select<TSource,TResult>
public static System.Collections.Generic.IEnumerable<TResult> Select<TSource,TResult> (this
System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TResult> selector);
static member Select : seq<'Source> * Func<'Source, 'Result> -> seq<'Result>
Type Parameters
TSource
TResult
Parameters
Returns
Um IEnumerable<T> cujos elementos são o resultado da invocação da função de transformação em cada elemento de
source .
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Select<TSource,TResult>(IEnumerable<TSource>,
Func<TSource,TResult>) ao projeto em uma sequência de valores.
IEnumerable<int> squares =
Enumerable.Range(1, 10).Select(x => x * x);

{
}
/*
1
4
9
16
25
36
49
64
81
100
*/
Remarks
Esse método de projeção requer que a função de transformação selector , para produzir um valor para cada valor na
sequência de origem, source . Se selector retorna um valor que é uma coleção, é responsabilidade do consumidor
para percorrer as subsequências manualmente. Nessa situação, talvez seja melhor para a sua consulta retornar uma
única sequência conciliada de valores. Para fazer isso, use o SelectMany método em vez de Select. Embora
SelectMany funciona da mesma forma que Select , ele é diferente em que a função de transformação retorna uma
coleção que, em seguida, é expandida por SelectMany antes de ser retornado.
Na sintaxe de expressão de consulta, uma select (Visual c#) ou Select cláusula (Visual Basic) se traduz em uma
invocação de Select.
See Cláusula select (Referência de C#)select clause (C# Reference)
Also Cláusula Select (Visual Basic)Select Clause (Visual Basic)
Enumerable.SelectMany Enumerable.SelectMany
I n this Article
Overloads
SelectMany<TSource,TCollection,TResult>(IEnumerable<
TSource>, Func<TSource,IEnumerable<TCollection>>, Func< Projeta cada elemento de uma sequência em um
TSource,TCollection,TResult>) SelectMany<TSource, IEnumerable<T>, mescla as sequências resultantes em uma
TCollection,TResult>(IEnumerable<TSource>, Func<TSource, sequência e chama uma função de seletor de resultado em
IEnumerable<TCollection>>, Func<TSource,TCollection, cada elemento contido nele.
TResult>)
SelectMany<TSource,TCollection,TResult>(IEnumerable<
TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Projeta cada elemento de uma sequência em um
Func<TSource,TCollection,TResult>) SelectMany<TSource, IEnumerable<T>, mescla as sequências resultantes em uma
TCollection,TResult>(IEnumerable<TSource>, Func<TSource, sequência e chama uma função de seletor de resultado em
Int32,IEnumerable<TCollection>>, Func<TSource,TCollection, cada elemento contido nele. O índice de cada elemento de
TResult>) origem é usado no formulário projetado intermediário do
elemento.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<
TSource,IEnumerable<TResult>>) SelectMany<TSource, Projeta cada elemento de uma sequência em um
TResult>(IEnumerable<TSource>, Func<TSource, IEnumerable<T> e nivela as sequências resultantes em uma
IEnumerable<TResult>>) sequência.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<
TSource,Int32,IEnumerable<TResult>>) SelectMany<TSource, Projeta cada elemento de uma sequência em um
TResult>(IEnumerable<TSource>, Func<TSource,Int32, IEnumerable<T> e nivela as sequências resultantes em uma
IEnumerable<TResult>>) sequência. O índice de cada elemento de origem é usado no
formulário projetado desse elemento.
SelectMany<TSource,TCollection,TResult>
(IEnumerable<TSource>,
Func<TSource,IEnumerable<TCollection>>,
public static System.Collections.Generic.IEnumerable<TResult>
SelectMany<TSource,TCollection,TResult> (this System.Collections.Generic.IEnumerable<TSource>
source, Func<TSource,System.Collections.Generic.IEnumerable<TCollection>> collectionSelector,
Func<TSource,TCollection,TResult> resultSelector);
static member SelectMany : seq<'Source> * Func<'Source, seq<'Collection>> * Func<'Source,
'Collection, 'Result> -> seq<'Result>
Type Parameters
TSource
TCollection
O tipo dos elementos intermediários coletados por collectionSelector .
TResult
O tipo dos elementos da sequência resultante.
Parameters
Uma sequência de valores a serem projetados.
collectionSelector Func<TSource,IEnumerable<TCollection>>
Uma função de transformação a ser aplicada a cada elemento da sequência de entrada.
resultSelector Func<TSource,TCollection,TResult>
Uma função de transformação a ser aplicada a cada elemento da sequência intermediária.
Returns
Um IEnumerable<T> cujos elementos são o resultado de chamar a função de transformação de um para muitos
collectionSelector em cada elemento de source e, em seguida, mapear cada um desses elementos de sequência e
seu elemento de origem correspondente para um elemento de resultado.
Exceptions
source , collectionSelector ou resultSelector é null .
Examples
O exemplo de código a seguir demonstra como usar SelectMany<TSource,TCollection,TResult>
(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) para
executar uma projeção um-para-muitos em uma matriz e usar uma função de seletor de resultado para manter cada
elemento correspondente da sequência de origem no escopo para a chamada final para Select .
class PetOwner
{
public List<string> Pets { get; set; }
}
public static void SelectManyEx3()

{
PetOwner[] petOwners =
{ new PetOwner { Name="Higa",
Pets = new List<string>{ "Scruffy", "Sam" } },
new PetOwner { Name="Ashkenazi",
Pets = new List<string>{ "Walker", "Sugar" } },
new PetOwner { Name="Price",
Pets = new List<string>{ "Scratches", "Diesel" } },
new PetOwner { Name="Hines",
Pets = new List<string>{ "Dusty" } } };
// Project the pet owner's name and the pet's name.

var query =
petOwners
.SelectMany(petOwner => petOwner.Pets, (petOwner, petName) => new { petOwner, petName })
.Where(ownerAndPet => ownerAndPet.petName.StartsWith("S"))
.Select(ownerAndPet =>
new
{
Owner = ownerAndPet.petOwner.Name,
Pet = ownerAndPet.petName
}
);
// Print the results.

{
Console.WriteLine(obj);
}
}

//
// {Owner=Higa, Pet=Scruffy}
// {Owner=Higa, Pet=Sam}
// {Owner=Ashkenazi, Pet=Sugar}
// {Owner=Price, Pet=Scratches}
Remarks
O SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>,
Func<TSource,TCollection,TResult>) método é útil quando você precisa manter os elementos de source no escopo
para a lógica de consulta que ocorre após a chamada para SelectMany<TSource,TCollection,TResult>
(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>). Consulte
a seção de exemplo para obter um exemplo de código. Se há uma relação bidirecional entre objetos do tipo TSource e
objetos do tipo TCollection , ou seja, se um objeto do tipo TCollection fornece uma propriedade para recuperar o
TSource objeto que o produziu, isso não é necessário sobrecarga de SelectMany<TSource,TCollection,TResult>
(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>). Em vez
disso, você pode usar SelectMany<TSource,TResult>(IEnumerable<TSource>,
Func<TSource,IEnumerable<TResult>>) e navegue de volta para o TSource por meio do objeto a TCollection
objeto.
Na sintaxe de expressão de consulta, cada from cláusula (Visual c#) ou From cláusula (Visual Basic) após inicial um se
traduz em uma invocação de SelectMany.
Func<TSource,Int32,IEnumerable<TCollection>>,
sequência e chama uma função de seletor de resultado em cada elemento contido nele. O índice de cada elemento de
origem é usado no formulário projetado intermediário do elemento.

SelectMany<TSource,TCollection,TResult> (this System.Collections.Generic.IEnumerable<TSource>
source, Func<TSource,int,System.Collections.Generic.IEnumerable<TCollection>> collectionSelector,
static member SelectMany : seq<'Source> * Func<'Source, int, seq<'Collection>> * Func<'Source,
'Collection, 'Result> -> seq<'Result>
Type Parameters
TSource
TCollection
TResult
Parameters
collectionSelector Func<TSource,Int32,IEnumerable<TCollection>>
Returns
seu elemento de origem correspondente para um elemento de resultado.
Exceptions
Remarks
O SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>,
Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) método é útil quando você
precisa manter os elementos de source no escopo para a lógica de consulta que ocorre após a chamada para
Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>). Consulte a seção de exemplo
para obter um exemplo de código. Se há uma relação bidirecional entre objetos do tipo TSource e objetos do tipo
TCollection , ou seja, se um objeto do tipo TCollection fornece uma propriedade para recuperar o TSource objeto
que o produziu, isso não é necessário sobrecarga de SelectMany<TSource,TCollection,TResult>
(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>). Em
vez disso, você pode usar SelectMany<TSource,TResult>(IEnumerable<TSource>,
Func<TSource,Int32,IEnumerable<TResult>>) e navegue de volta para o TSource por meio do objeto a TCollection
objeto.
SelectMany<TSource,TResult>(IEnumerable<TSource>,
Func<TSource,IEnumerable<TResult>>)
sequência.
public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TResult> (this

Func<TSource,System.Collections.Generic.IEnumerable<TResult>> selector);
static member SelectMany : seq<'Source> * Func<'Source, seq<'Result>> -> seq<'Result>
Type Parameters
TSource
TResult
O tipo dos elementos da sequência retornada por selector .
Parameters
selector Func<TSource,IEnumerable<TResult>>
Returns
Um IEnumerable<T> cujos elementos são resultado da invocação da função de transformação de um para muitos em
Exceptions
Examples
O exemplo de código a seguir demonstra como usar SelectMany<TSource,TResult>(IEnumerable<TSource>,
Func<TSource,IEnumerable<TResult>>) para realizar uma projeção um-para-muitos em uma matriz.
class PetOwner
{
public List<String> Pets { get; set; }
}

{
{ new PetOwner { Name="Higa, Sidney",
new PetOwner { Name="Ashkenazi, Ronen",
new PetOwner { Name="Price, Vernette",
Pets = new List<string>{ "Scratches", "Diesel" } } };
// Query using SelectMany().

IEnumerable<string> query1 = petOwners.SelectMany(petOwner => petOwner.Pets);
Console.WriteLine("Using SelectMany():");
// Only one foreach loop is required to iterate

// through the results since it is a
// one-dimensional collection.
foreach (string pet in query1)
{
Console.WriteLine(pet);
}
// This code shows how to use Select()

// instead of SelectMany().
IEnumerable<List<String>> query2 =
petOwners.Select(petOwner => petOwner.Pets);
Console.WriteLine("
Using Select():");
Using Select():");
// Notice that two foreach loops are required to

// iterate through the results
// because the query returns a collection of arrays.
foreach (List<String> petList in query2)
{
foreach (string pet in petList)
{
}
}
}
/*
Using SelectMany():
Scruffy
Sam
Walker
Sugar
Scratches
Diesel
Using Select():
Scruffy
Sam
Walker
Sugar
Scratches
Diesel
*/
Remarks
O SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) método enumera

a sequência de entrada, usa uma função de transformação para mapear cada elemento para um IEnumerable<T>e, em
seguida, enumera e gera os elementos de cada tais IEnumerable<T> objeto. Ou seja, para cada elemento da source ,
selector é invocado e uma sequência de valores é retornada. SelectMany<TSource,TResult>
(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) em seguida, mescla esta coleção bidimensional de
coleções em um unidimensional IEnumerable<T> e o retorna. Por exemplo, se uma consulta usa
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) para obter os
pedidos (do tipo Order ) para cada cliente em um banco de dados, o resultado é do tipo IEnumerable<Order> em c#
ou IEnumerable(Of Order) no Visual Basic. Se, em vez disso, a consulta usa Select para obter os pedidos, a coleção de
coleções de pedidos não é combinada e o resultado é do tipo IEnumerable<List<Order>> em c# ou
IEnumerable(Of List(Of Order)) no Visual Basic.
Na sintaxe de expressão de consulta, cada from cláusula (Visual c#) ou From cláusula (Visual Basic) após inicial um se
traduz em uma invocação de SelectMany.
Func<TSource,Int32,IEnumerable<TResult>>)
public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TResult> (this

Func<TSource,int,System.Collections.Generic.IEnumerable<TResult>> selector);
static member SelectMany : seq<'Source> * Func<'Source, int, seq<'Result>> -> seq<'Result>
Type Parameters
TSource
TResult
O tipo dos elementos da sequência retornada por selector .
Parameters
selector Func<TSource,Int32,IEnumerable<TResult>>
Returns
Um IEnumerable<T> cujos elementos são o resultado da invocação da função de transformação um-para-muitos em
cada elemento de uma sequência de entrada.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar SelectMany<TSource,TResult>(IEnumerable<TSource>,
Func<TSource,Int32,IEnumerable<TResult>>) para realizar uma projeção um-para-muitos em uma matriz e usar o
índice de cada elemento externo.
class PetOwner
{
}

{
new PetOwner { Name="Hines, Patrick",
// Project the items in the array by appending the index

// of each PetOwner to each pet's name in that petOwner's
// array of pets.
petOwners.SelectMany((petOwner, index) =>
petOwner.Pets.Select(pet => index + pet));
foreach (string pet in query)

{
}
}

//
// 0Scruffy
// 0Sam
// 1Walker
// 1Sugar
// 2Scratches
// 2Diesel
// 3Dusty
Remarks
O SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) método

enumera a sequência de entrada, usa uma função de transformação para mapear cada elemento para um
IEnumerable<T>e, em seguida, enumera e gera os elementos de cada tais IEnumerable<T> objeto. Ou seja, para cada
elemento da source , selector é invocado e uma sequência de valores é retornada. SelectMany<TSource,TResult>
(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) em seguida, mescla esta coleção
bidimensional de coleções em um unidimensional IEnumerable<T> e o retorna. Por exemplo, se uma consulta usa
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) para obter os
pedidos (do tipo Order ) para cada cliente em um banco de dados, o resultado é do tipo IEnumerable<Order> em c#
ou IEnumerable(Of Order) no Visual Basic. Se, em vez disso, a consulta usa Select para obter os pedidos, a coleção de
coleções de pedidos não é combinada e o resultado é do tipo IEnumerable<List<Order>> em c# ou
IEnumerable(Of List(Of Order)) no Visual Basic.
O primeiro argumento para selector representa o elemento para processar. O segundo argumento para selector
representa o índice baseado em zero do elemento na sequência de origem. Isso pode ser útil se os elementos estão em
uma ordem conhecida e você deseja fazer algo com um elemento em um índice específico, por exemplo. Ele também
pode ser útil se você quiser recuperar o índice de um ou mais elementos.
Enumerable.SequenceEqual Enumerable.SequenceEqual
I n this Article
Overloads
SequenceEqual<TSource>(IEnumerable<TSource>,
IEnumerable<TSource>) SequenceEqual<TSource>( Determina se duas sequências são iguais comparando os
IEnumerable<TSource>, IEnumerable<TSource>) elementos usando o comparador de igualdade padrão para o
tipo.
IEnumerable<TSource>, IEqualityComparer<TSource>) Determina se duas sequências são iguais, comparando seus
SequenceEqual<TSource>(IEnumerable<TSource>, elementos usando um IEqualityComparer<T> especificado.
IEnumerable<TSource>) SequenceEqual<TSource>
Determina se duas sequências são iguais comparando os elementos usando o comparador de igualdade padrão para o
tipo.
public static bool SequenceEqual<TSource> (this System.Collections.Generic.IEnumerable<TSource>
first, System.Collections.Generic.IEnumerable<TSource> second);
static member SequenceEqual : seq<'Source> * seq<'Source> -> bool
Type Parameters
TSource
Parameters
Um IEnumerable<T> para comparar com second .
Um IEnumerable<T> para comparar com a primeira sequência.
Returns
Boolean Boolean
true se as duas sequências de origem forem de mesmo comprimento e seus elementos correspondentes forem iguais
de acordo com o comparador de igualdade padrão para seu tipo; caso contrário, false .
Exceptions
Examples
Os exemplos de código a seguir demonstram como usar SequenceEqual<TSource>(IEnumerable<TSource>,
IEnumerable<TSource>) para determinar se duas sequências são iguais. Nos dois primeiros exemplos, o método
determina se as sequências comparadas contêm referências aos mesmos objetos. No terceiro e quarto exemplos, o
método compara os dados reais dos objetos dentro das sequências.
Neste exemplo, as sequências são iguais.
class Pet
{
}
public static void SequenceEqualEx1()

{
Pet pet1 = new Pet { Name = "Turbo", Age = 2 };
Pet pet2 = new Pet { Name = "Peanut", Age = 8 };
// Create two lists of pets.

List<Pet> pets1 = new List<Pet> { pet1, pet2 };
bool equal = pets1.SequenceEqual(pets2);
Console.WriteLine(
"The lists {0} equal.",
equal ? "are" : "are not");
}
/*
The lists are equal.

*/
O exemplo de código a seguir compara duas sequências que não são iguais. Observe que as sequências contêm dados
idênticos, mas como os objetos que eles contêm têm referências diferentes, as sequências não são consideradas iguais.
class Pet
{
}

{
Pet pet1 = new Pet() { Name = "Turbo", Age = 2 };
Pet pet2 = new Pet() { Name = "Peanut", Age = 8 };

List<Pet> pets2 =
new List<Pet> { new Pet { Name = "Turbo", Age = 2 },
new Pet { Name = "Peanut", Age = 8 } };
bool equal = pets1.SequenceEqual(pets2);
Console.WriteLine("The lists {0} equal.", equal ? "are" : "are not");

}
/*
The lists are not equal.

*/
Se você quiser comparar os dados reais dos objetos nas sequências em vez de apenas comparar suas referências, você
precisa implementar o IEqualityComparer<T> interface genérica em sua classe. O exemplo de código a seguir mostra
como implementar essa interface em uma classe auxiliar e fornecer GetHashCode e Equals métodos.
{

{
if (other is null)
return false;

}

}
Depois de implementar essa interface, você pode usar sequências de ProductA objetos no SequenceEqual<TSource>
ProductA[] storeA = { new ProductA { Name = "apple", Code = 9 },
ProductA[] storeB = { new ProductA { Name = "apple", Code = 9 },

bool equalAB = storeA.SequenceEqual(storeB);
Console.WriteLine("Equal? " + equalAB);
/*
Equal? True
*/
Remarks
O SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) método enumera as duas sequências
de origem em paralelo e compara os elementos correspondentes usando o comparador de igualdade padrão para
TSource , Default. O comparador de igualdade padrão, Default, é usado para comparar valores de tipos que
implementam o IEqualityComparer<T> interface genérica. Para comparar um tipo de dados personalizado, você
precisa implementar esta interface e fornecer seus próprios GetHashCode e Equals métodos para o tipo.
Determina se duas sequências são iguais, comparando seus elementos usando um IEqualityComparer<T>
especificado.
public static bool SequenceEqual<TSource> (this System.Collections.Generic.IEnumerable<TSource>

first, System.Collections.Generic.IEnumerable<TSource> second,
static member SequenceEqual : seq<'Source> * seq<'Source> *
Type Parameters
TSource
Parameters
Um IEnumerable<T> para comparar com second .
Um IEnumerable<T> para comparar com a primeira sequência.
Um IEqualityComparer<T> a ser usado para comparar elementos.
Returns
Boolean Boolean
truese as duas sequências de origem tiverem o mesmo tamanho e seus elementos correspondentes forem
comparados como iguais de acordo com o comparer ; caso contrário, false .
Exceptions
Examples
O exemplo a seguir mostra como implementar um comparador de igualdade que pode ser usado no
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) método.

{
}

{
{


return false;

}


{



}
Depois de implementar esse comparador, você pode usar sequências de Product objetos no
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) método,
Product[] storeA = { new Product { Name = "apple", Code = 9 },
Product[] storeB = { new Product { Name = "apple", Code = 9 },

bool equalAB = storeA.SequenceEqual(storeB, new ProductComparer());
Console.WriteLine("Equal? " + equalAB);
/*
Equal? True
*/
Remarks
O SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
método enumera as duas sequências de origem em paralelo e compara os elementos correspondentes usando
especificado IEqualityComparer<T>. Se comparer está null , o comparador de igualdade padrão, Default, é usado
para comparar elementos.
Enumerable.Single Enumerable.Single
I n this Article
Overloads
Single<TSource>(IEnumerable<TSource>, Func<TSource,
Boolean>) Single<TSource>(IEnumerable<TSource>, Func< Retorna o único elemento de uma sequência que satisfaz uma
TSource,Boolean>) condição especificada e gera uma exceção se houver mais de
um tal elemento.
Single<TSource>(IEnumerable<TSource>) Single<TSource>(
IEnumerable<TSource>) Retornará o único elemento de uma sequência e lançará uma
exceção se não houver exatamente um elemento na
sequência.
Single<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) Single<TSource>
Retorna o único elemento de uma sequência que satisfaz uma condição especificada e gera uma exceção se houver
mais de um tal elemento.
public static TSource Single<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
static member Single : seq<'Source> * Func<'Source, bool> -> 'Source
Type Parameters
TSource
Parameters
Um IEnumerable<T> do qual retornar um único elemento.
Uma função para testar um elemento em relação a uma condição.
Returns
TSource TSource
O único elemento da sequência de entrada que atende a uma condição.
Exceptions
- ou - Mais de um elemento satisfaz a condição na predicate .
Examples
O exemplo de código a seguir demonstra como usar Single<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) para selecionar o único elemento de uma matriz que satisfaz uma condição.
string fruit1 = fruits.Single(fruit => fruit.Length > 10);
Console.WriteLine(fruit1);
/*
passionfruit
*/
O exemplo de código a seguir demonstra que Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

lança uma exceção quando a sequência não contém exatamente um elemento que satisfaz a condição.
string fruit2 = null;
try
{
fruit2 = fruits.Single(fruit => fruit.Length > 15);
}
catch (System.InvalidOperationException)
{
Console.WriteLine(@"The collection does not contain exactly
one element whose length is greater than 15.");
}

//
// The collection does not contain exactly
// one element whose length is greater than 15.
Remarks
O Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) método lança uma exceção se a sequência de
entrada não contém elementos correspondentes. Em vez disso, retornar null quando nenhum elemento
correspondente for encontrado, use SingleOrDefault.
Single<TSource>(IEnumerable<TSource>) Single<TSource>
sequência.
public static TSource Single<TSource> (this System.Collections.Generic.IEnumerable<TSource> source);
static member Single : seq<'Source> -> 'Source
Type Parameters
TSource
Parameters
Um IEnumerable<T> do qual o único elemento será retornado.
Returns
TSource TSource
O único elemento de uma sequência de entrada.
Exceptions
source é null .
A sequência de entrada contém mais de um elemento.
- ou - A sequência de entrada está vazia.
Examples
O exemplo de código a seguir demonstra como usar Single<TSource>(IEnumerable<TSource>) para selecionar o
único elemento de uma matriz.
string[] fruits1 = { "orange" };
string fruit1 = fruits1.Single();
/*
orange
*/
O exemplo de código a seguir demonstra que Single<TSource>(IEnumerable<TSource>) lança uma exceção quando a
sequência não contém exatamente um elemento.
string[] fruits2 = { "orange", "apple" };
string fruit2 = null;
try
{
fruit2 = fruits2.Single();
}
{
Console.WriteLine("The collection does not contain exactly one element.");
}
/*
The collection does not contain exactly one element.

*/
Remarks
O Single<TSource>(IEnumerable<TSource>) método lança uma exceção se a sequência de entrada está vazia. Em vez
disso, retornar null quando a sequência de entrada estiver vazia, use SingleOrDefault.
Enumerable.SingleOrDefault Enumerable.SingleOr
Default
I n this Article
Overloads
SingleOrDefault<TSource>(IEnumerable<TSource>) SingleOr
Default<TSource>(IEnumerable<TSource>) Retorna o único elemento de uma sequência ou um valor
padrão se a sequência é vazia; esse método gera uma exceção
se há mais de um elemento na sequência.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<
TSource,Boolean>) SingleOrDefault<TSource>(IEnumerable< Retorna o único elemento de uma sequência que satisfaz uma
TSource>, Func<TSource,Boolean>) condição especificada ou um valor padrão se esse elemento
não existir. Esse método lança uma exceção se mais de um
elemento satisfizer a condição.
public static TSource SingleOrDefault<TSource> (this System.Collections.Generic.IEnumerable<TSource>
source);
static member SingleOrDefault : seq<'Source> -> 'Source
Type Parameters
TSource
Parameters
Um IEnumerable<T> do qual o único elemento será retornado.
Returns
TSource TSource
O único elemento da sequência de entrada, ou default ( TSource ), se a sequência não contiver elementos.
Exceptions
source é null .
A sequência de entrada contém mais de um elemento.
Examples
O exemplo de código a seguir demonstra como usar SingleOrDefault<TSource>(IEnumerable<TSource>) para
selecionar o único elemento de uma matriz.
string fruit1 = fruits1.SingleOrDefault();
/*
orange
*/
O exemplo de código a seguir demonstra que SingleOrDefault<TSource>(IEnumerable<TSource>) retorna um valor

padrão quando a sequência não contém exatamente um elemento.
string[] fruits2 = { };
string fruit2 = fruits2.SingleOrDefault();
Console.WriteLine(
String.IsNullOrEmpty(fruit2) ? "No such string!" : fruit2);
/*
No such string!
*/
você deseja usar, se a coleção está vazia. Em seguida, chame Single<TSource>(IEnumerable<TSource>) para obter o
elemento. O exemplo de código a seguir usa ambas as técnicas para obter um valor padrão de 1, se uma coleção de
números de página está vazia. Porque o valor padrão para um número inteiro é 0, que não é um número válido de
página geralmente, o valor padrão deve ser especificado como 1 em vez disso. A primeira variável de resultado é
verificada para o valor padrão indesejados após a conclusão da consulta em execução. A segunda variável de resultado
é obtida usando DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource) para especificar um valor padrão de 1.
int[] pageNumbers = { };

int pageNumber1 = pageNumbers.SingleOrDefault();
if (pageNumber1 == 0)
{
pageNumber1 = 1;
}
Console.WriteLine("The value of the pageNumber1 variable is {0}", pageNumber1);

int pageNumber2 = pageNumbers.DefaultIfEmpty(1).Single();
/*
The value of the pageNumber1 variable is 1

*/
Remarks
O SingleOrDefault método não fornece uma maneira de especificar um valor padrão. Se você quiser especificar um
valor padrão diferente de default(TSource) , use o DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)
SingleOrDefault<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) SingleOrDefault<TSource>
public static TSource SingleOrDefault<TSource> (this System.Collections.Generic.IEnumerable<TSource>

static member SingleOrDefault : seq<'Source> * Func<'Source, bool> -> 'Source
Type Parameters
TSource
Parameters
Um IEnumerable<T> do qual retornar um único elemento.
Returns
TSource TSource
O único elemento da sequência de entrada que atende à condição ou default ( TSource ) se esse elemento não for
encontrado.
Exceptions
Mais de um elemento satisfaz a condição na predicate .
Examples
O exemplo de código a seguir demonstra como usar SingleOrDefault<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) para selecionar o único elemento de uma matriz que satisfaz uma condição.
string fruit1 = fruits.SingleOrDefault(fruit => fruit.Length > 10);
/*
passionfruit
*/
O exemplo de código a seguir demonstra que SingleOrDefault<TSource>(IEnumerable<TSource>,

Func<TSource,Boolean>) retorna um valor padrão quando a sequência não contém exatamente um elemento que
satisfaz a condição.
string fruit2 =
fruits.SingleOrDefault(fruit => fruit.Length > 15);
Console.WriteLine(
String.IsNullOrEmpty(fruit2) ? "No such string!" : fruit2);
/*
No such string!
*/
Remarks
Enumerable.Skip Enumerable.Skip
I n this Article
public static System.Collections.Generic.IEnumerable<TSource> Skip<TSource> (this
System.Collections.Generic.IEnumerable<TSource> source, int count);
static member Skip : seq<'Source> * int -> seq<'Source>
Type Parameters
TSource
Parameters
Um IEnumerable<T> do qual os elementos serão retornados.
count Int32 Int32
O número de elementos a serem ignorados antes de retornar os elementos restantes.
Returns
Um IEnumerable<T> que contém os elementos que ocorrem após o índice especificado na sequência de entrada.
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Skip para ignorar um número especificado de elementos em uma
matriz classificada e retornar os elementos restantes.
int[] grades = { 59, 82, 70, 56, 92, 98, 85 };
IEnumerable<int> lowerGrades =
grades.OrderByDescending(g => g).Skip(3);
Console.WriteLine("All grades except the top three are:");

foreach (int grade in lowerGrades)
{
Console.WriteLine(grade);
}
/*
All grades except the top three are:

82
70
59
56
*/
Remarks
Se source contiver menos count elementos, vazia IEnumerable<T> é retornado. Se count é menor ou igual a zero,
todos os elementos de source são gerados.
O Take e Skip métodos são complementa funcional. Dada uma determinada sequência coll e um número inteiro n ,
concatenando os resultados de coll.Take(n) e coll.Skip(n) produz a mesma sequência que coll .
Na sintaxe de expressão de consulta do Visual Basic, uma Skip cláusula se traduz em uma invocação de Skip.
See Cláusula Skip (Visual Basic)Skip Clause (Visual Basic)
Also
Enumerable.SkipLast Enumerable.SkipLast
I n this Article
public static System.Collections.Generic.IEnumerable<TSource> SkipLast<TSource> (this
static member SkipLast : seq<'Source> * int -> seq<'Source>
Type Parameters
TSource
Parameters
count Int32 Int32
Returns
Enumerable.SkipWhile Enumerable.SkipWhile
I n this Article
Overloads
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,
Boolean>) SkipWhile<TSource>(IEnumerable<TSource>, Ignora elementos em uma sequência, contanto que uma
Func<TSource,Boolean>) condição especificada seja verdadeira e retorne os elementos
restantes.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,
Int32,Boolean>) SkipWhile<TSource>(IEnumerable<TSource>, Ignora elementos em uma sequência, contanto que uma
Func<TSource,Int32,Boolean>) condição especificada seja verdadeira e retorne os elementos
restantes. O índice do elemento é usado na lógica da função
de predicado.
SkipWhile<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) SkipWhile<TSource>
Ignora elementos em uma sequência, contanto que uma condição especificada seja verdadeira e retorne os elementos
restantes.
public static System.Collections.Generic.IEnumerable<TSource> SkipWhile<TSource> (this
System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,bool> predicate);
static member SkipWhile : seq<'Source> * Func<'Source, bool> -> seq<'Source>
Type Parameters
TSource
Parameters
Returns
Um IEnumerable<T> que contém os elementos da sequência de entrada, começando no primeiro elemento da série
linear que não passa no teste especificado por predicate .
Exceptions
Examples
O exemplo de código a seguir demonstra como usar SkipWhile<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) para ignorar os elementos de uma matriz como uma condição seja verdadeira.
int[] grades = { 59, 82, 70, 56, 92, 98, 85 };
grades
.OrderByDescending(grade => grade)
.SkipWhile(grade => grade >= 80);
Console.WriteLine("All grades below 80:");

{
}
/*
All grades below 80:

70
59
56
*/
Remarks
O SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) método é implementado usando a
execução adiada. O imediata valor retornado é um objeto que armazena todas as informações necessárias para
executar a ação. A consulta representada por esse método não é executada até que o objeto é enumerado chamando-
se suas GetEnumerator método diretamente ou usando foreach no Visual c# ou For Each no Visual Basic.
Este método testa cada elemento da source por meio predicate e ignora o elemento se o resultado for true . Depois
que a função de predicado retorna false de um elemento, esse elemento e os elementos restantes na source geradas
e não há nenhum mais invocações de predicate .
Se predicate retorna true para todos os elementos na sequência, vazia IEnumerable<T> é retornado.
O TakeWhile e SkipWhile métodos são complementa funcional. Dada uma determinada sequência coll e uma função
pura p , concatenando os resultados de coll.TakeWhile(p) e coll.SkipWhile(p) produz a mesma sequência que
coll .
Na sintaxe de expressão de consulta do Visual Basic, uma Skip While cláusula se traduz em uma invocação de
SkipWhile.
See Ignorar cláusula While (Visual Basic)Skip While Clause (Visual Basic)
Also
SkipWhile<TSource>(IEnumerable<TSource>,
Func<TSource,Int32,Boolean>) SkipWhile<TSource>
(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)
restantes. O índice do elemento é usado na lógica da função de predicado.
public static System.Collections.Generic.IEnumerable<TSource> SkipWhile<TSource> (this
System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,int,bool> predicate);
static member SkipWhile : seq<'Source> * Func<'Source, int, bool> -> seq<'Source>
Type Parameters
TSource
Parameters
predicate Func<TSource,Int32,Boolean>
Uma função para testar cada elemento de origem em relação a uma condição; o segundo parâmetro da função
representa o índice do elemento de origem.
Returns
Um IEnumerable<T> que contém os elementos da sequência de entrada, começando no primeiro elemento da série
linear que não passa no teste especificado por predicate .
Exceptions
Examples
O exemplo de código a seguir demonstra como usar SkipWhile<TSource>(IEnumerable<TSource>,
Func<TSource,Int32,Boolean>) para ignorar os elementos de uma matriz como uma condição que depende do índice
do elemento é verdadeira.
int[] amounts = { 5000, 2500, 9000, 8000,

6500, 4000, 1500, 5500 };
IEnumerable<int> query =
amounts.SkipWhile((amount, index) => amount > index * 1000);
foreach (int amount in query)

{
Console.WriteLine(amount);
}
/*
4000
1500
5500
*/
Remarks
O SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) método testa cada elemento de

source usando predicate e ignora o elemento se o resultado for true . Depois que a função de predicado retorna
false de um elemento, esse elemento e os elementos restantes na source geradas e não há nenhum mais invocações
de predicate .
Se predicate retorna true para todos os elementos na sequência, vazia IEnumerable<T> é retornado.
O primeiro argumento do predicate representa o elemento a ser testado. O segundo argumento representa o índice
baseado em zero do elemento no source .
coll .
Na sintaxe de expressão de consulta do Visual Basic, uma Skip While cláusula se traduz em uma invocação de
SkipWhile.
See Ignorar cláusula While (Visual Basic)Skip While Clause (Visual Basic)
Also
Enumerable.Sum Enumerable.Sum
I n this Article
Overloads
Sum(IEnumerable<Nullable<Int32>>) Sum(IEnumerable<
Nullable<Int32>>) Computa a soma de uma sequência de valores Int32 que
Sum(IEnumerable<Nullable<Single>>) Sum(IEnumerable<
Nullable<Single>>) Computa a soma de uma sequência de valores Single que
Sum(IEnumerable<Single>) Sum(IEnumerable<Single>)
Sum(IEnumerable<Nullable<Int64>>) Sum(IEnumerable<
Sum(IEnumerable<Nullable<Double>>) Sum(IEnumerable<
Nullable<Double>>) Computa a soma de uma sequência de valores Double que
Sum(IEnumerable<Double>) Sum(IEnumerable<Double>)
Sum(IEnumerable<Int64>) Sum(IEnumerable<Int64>)
Sum(IEnumerable<Decimal>) Sum(IEnumerable<Decimal>)
Sum(IEnumerable<Nullable<Decimal>>) Sum(IEnumerable<
Nullable<Decimal>>) Computa a soma de uma sequência de valores Decimal que
Sum<TSource>(IEnumerable<TSource>, Func<TSource,
Single>) Sum<TSource>(IEnumerable<TSource>, Func< Calcula a soma da sequência de valores Single obtidos pela
TSource,Single>) invocação de uma função de transformação em cada elemento
da sequência de entrada.
Nullable<Single>>) Sum<TSource>(IEnumerable<TSource>, Calcula a soma da sequência de valores Single anuláveis
Func<TSource,Nullable<Single>>) obtidos pela invocação de uma função de transformação em
Nullable<Int64>>) Sum<TSource>(IEnumerable<TSource>, Calcula a soma da sequência de valores Int64 anuláveis
Func<TSource,Nullable<Int64>>) obtidos pela invocação de uma função de transformação em
Nullable<Int32>>) Sum<TSource>(IEnumerable<TSource>, Calcula a soma da sequência de valores Int32 anuláveis
Func<TSource,Nullable<Int32>>) obtidos pela invocação de uma função de transformação em
Nullable<Double>>) Sum<TSource>(IEnumerable<TSource>, Calcula a soma da sequência de valores Double anuláveis
Func<TSource,Nullable<Double>>) obtidos pela invocação de uma função de transformação em
Nullable<Decimal>>) Sum<TSource>(IEnumerable<TSource>, Calcula a soma da sequência de valores Decimal anuláveis
Func<TSource,Nullable<Decimal>>) obtidos pela invocação de uma função de transformação em
Int64>) Sum<TSource>(IEnumerable<TSource>, Func< Calcula a soma da sequência de valores Int64 obtidos pela
TSource,Int64>) invocação de uma função de transformação em cada elemento
Int32>) Sum<TSource>(IEnumerable<TSource>, Func< Calcula a soma da sequência de valores Int32 obtidos pela
TSource,Int32>) invocação de uma função de transformação em cada elemento
Double>) Sum<TSource>(IEnumerable<TSource>, Func< Calcula a soma da sequência de valores Double obtidos pela
TSource,Double>) invocação de uma função de transformação em cada elemento
Decimal>) Sum<TSource>(IEnumerable<TSource>, Func< Calcula a soma da sequência de valores Decimal obtidos pela
TSource,Decimal>) invocação de uma função de transformação em cada elemento
public static Nullable<int> Sum (this System.Collections.Generic.IEnumerable<Nullable<int>> source);
static member Sum : seq<Nullable<int>> -> Nullable<int>
Parameters
Uma sequência de valores Int32 que permitem valores nulos para cálculo da soma.
Returns
Nullable<Int32>
A soma dos valores na sequência.
Exceptions
source é null .
A soma é maior que MaxValue.
Examples
O exemplo de código a seguir demonstra como usar Sum(IEnumerable<Nullable<Single>>) para somar os valores de
uma sequência.
Note
float?[] points = { null, 0, 92.83F, null, 100.0F, 37.46F, 81.1F };
float? sum = points.Sum();
Console.WriteLine("Total points earned: {0}", sum);
/*
Total points earned: 311.39

*/
Remarks
Esse método retornará zero se source não contiver elementos.
O resultado não inclui valores que são null .

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula se traduz em uma
invocação de Sum.
Also
public static Nullable<float> Sum (this System.Collections.Generic.IEnumerable<Nullable<float>>

source);
static member Sum : seq<Nullable<single>> -> Nullable<single>
Parameters
Uma sequência de valores Single que permitem valores nulos para cálculo da soma.
Returns
Nullable<Single>
Exceptions
source é null .
Examples
uma sequência.
/*

*/
Remarks
invocação de Sum.
Also
Sum(IEnumerable<Single>) Sum(IEnumerable<Single>)
public static float Sum (this System.Collections.Generic.IEnumerable<float> source);
static member Sum : seq<single> -> single
Parameters
Uma sequência de valores Single para cálculo da soma.
Returns
Single Single
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Sum(IEnumerable<Single>) para somar os valores de uma
sequência.
List<float> numbers = new List<float> { 43.68F, 1.25F, 583.7F, 6.5F };
float sum = numbers.Sum();
Console.WriteLine("The sum of the numbers is {0}.", sum);
/*
The sum of the numbers is 635.13.

*/
Remarks
invocação de Sum.
Also
public static Nullable<long> Sum (this System.Collections.Generic.IEnumerable<Nullable<long>>

source);
static member Sum : seq<Nullable<int64>> -> Nullable<int64>
Parameters
Returns
Nullable<Int64>
Exceptions
source é null .
Examples
uma sequência.
Note
/*

*/
Remarks

invocação de Sum.
Also
public static Nullable<double> Sum (this System.Collections.Generic.IEnumerable<Nullable<double>>

source);
static member Sum : seq<Nullable<double>> -> Nullable<double>
Parameters
Uma sequência de valores Double que permitem valores nulos para cálculo da soma.
Returns
Nullable<Double>
Exceptions
source é null .
Examples
uma sequência.
Note
/*

*/
Remarks
invocação de Sum.
Also
Sum(IEnumerable<Double>) Sum(IEnumerable<Double>)
public static double Sum (this System.Collections.Generic.IEnumerable<double> source);
static member Sum : seq<double> -> double
Parameters
Uma sequência de valores Double para cálculo da soma.
Returns
Double Double
Exceptions
source é null .
Examples
sequência.
Note
/*

*/
Remarks
invocação de Sum.
Also
public static long Sum (this System.Collections.Generic.IEnumerable<long> source);

static member Sum : seq<int64> -> int64
Parameters
Uma sequência de valores Int64 para cálculo da soma.
Returns
Int64 Int64
Exceptions
source é null .
Examples
sequência.
Note
/*

*/
Remarks
invocação de Sum.
Also
public static int Sum (this System.Collections.Generic.IEnumerable<int> source);

static member Sum : seq<int> -> int
Parameters
Returns
Int32 Int32
Exceptions
source é null .
Examples
sequência.
Note
/*

*/
Remarks
invocação de Sum.
Also
Sum(IEnumerable<Decimal>) Sum(IEnumerable<Decimal>)
public static decimal Sum (this System.Collections.Generic.IEnumerable<decimal> source);

static member Sum : seq<decimal> -> decimal
Parameters
Uma sequência de valores Decimal para cálculo da soma.
Returns
Decimal Decimal
Exceptions
source é null .
Examples
sequência.
Note
/*

*/
Remarks
O Sum(IEnumerable<Decimal>) método retorna zero se source não contiver elementos.
invocação de Sum.
Also
public static Nullable<decimal> Sum (this System.Collections.Generic.IEnumerable<Nullable<decimal>>

source);
static member Sum : seq<Nullable<decimal>> -> Nullable<decimal>
Parameters
Uma sequência de valores Decimal que permitem valores nulos para cálculo da soma.
Returns
Nullable<Decimal>
Exceptions
source é null .
Examples
uma sequência.
Note
/*

*/
Remarks
O resultado incluem valores que são null .

invocação de Sum.
Also
Calcula a soma da sequência de valores Single obtidos pela invocação de uma função de transformação em cada
public static float Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,

static member Sum : seq<'Source> * Func<'Source, single> -> single
Type Parameters
TSource
Parameters
Uma sequência de valores usados para calcular uma soma.
Returns
Single Single
A soma dos valores projetados.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Sum<TSource>(IEnumerable<TSource>,
Func<TSource,Double>) para somar os valores previstos de uma sequência.
Note
class Package
{
public string Company { get; set; }
public double Weight { get; set; }
}
public static void SumEx1()

{
List<Package> packages =
new List<Package>
{ new Package { Company = "Coho Vineyard", Weight = 25.2 },
new Package { Company = "Lucerne Publishing", Weight = 18.7 },
new Package { Company = "Wingtip Toys", Weight = 6.0 },
new Package { Company = "Adventure Works", Weight = 33.8 } };
double totalWeight = packages.Sum(pkg => pkg.Weight);
Console.WriteLine("The total weight of the packages is: {0}", totalWeight);

}
/*
The total weight of the packages is: 83.7

*/
Remarks
O Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>) método retorna zero se source não contiver
elementos.
invocação de Sum.
Also
Sum<TSource>(IEnumerable<TSource>,
Func<TSource,Nullable<Single>>) Sum<TSource>
Calcula a soma da sequência de valores Single anuláveis obtidos pela invocação de uma função de transformação em
public static Nullable<float> Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource>

static member Sum : seq<'Source> * Func<'Source, Nullable<single>> -> Nullable<single>
Type Parameters
TSource
Parameters
Returns
Nullable<Single>
Exceptions
Examples
Note
class Package
{
}

{
new List<Package>

}
/*

*/
Remarks
invocação de Sum.
Also
Func<TSource,Nullable<Int64>>) Sum<TSource>
Calcula a soma da sequência de valores Int64 anuláveis obtidos pela invocação de uma função de transformação em
public static Nullable<long> Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource>
static member Sum : seq<'Source> * Func<'Source, Nullable<int64>> -> Nullable<int64>
Type Parameters
TSource
Parameters
Returns
Nullable<Int64>
Exceptions
Examples
Note
class Package
{
}

{
new List<Package>

}
/*

*/
Remarks
Nullable(Of Int64) no Visual Basic
invocação de Sum.
Also
Calcula a soma da sequência de valores Int32 anuláveis obtidos pela invocação de uma função de transformação em
public static Nullable<int> Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource>
static member Sum : seq<'Source> * Func<'Source, Nullable<int>> -> Nullable<int>
Type Parameters
TSource
Parameters
Returns
Nullable<Int32>
Exceptions
Examples
Note
class Package
{
}

{
new List<Package>

}
/*

*/
Remarks
invocação de Sum.
Also
Func<TSource,Nullable<Double>>) Sum<TSource>
Calcula a soma da sequência de valores Double anuláveis obtidos pela invocação de uma função de transformação em
public static Nullable<double> Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource>
static member Sum : seq<'Source> * Func<'Source, Nullable<double>> -> Nullable<double>
Type Parameters
TSource
Parameters
Returns
Nullable<Double>
Exceptions
Examples
Note
class Package
{
}

{
new List<Package>

}
/*

*/
Remarks
invocação de Sum.
Also
Func<TSource,Nullable<Decimal>>) Sum<TSource>
Calcula a soma da sequência de valores Decimal anuláveis obtidos pela invocação de uma função de transformação
public static Nullable<decimal> Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource>

static member Sum : seq<'Source> * Func<'Source, Nullable<decimal>> -> Nullable<decimal>
Type Parameters
TSource
Parameters
Returns
Nullable<Decimal>
Exceptions
Examples
Note
class Package
{
}

{
new List<Package>

}
/*

*/
Remarks
O resultado não incluía valores que são null .
invocação de Sum.
Also
public static long Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
static member Sum : seq<'Source> * Func<'Source, int64> -> int64
Type Parameters
TSource
Parameters
Returns
Int64 Int64
Exceptions
Examples
Note
class Package
{
}

{
new List<Package>

}
/*

*/
Remarks
invocação de Sum.
Also
public static int Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
static member Sum : seq<'Source> * Func<'Source, int> -> int
Type Parameters
TSource
Parameters
Returns
Int32 Int32
Exceptions
Examples
Note
class Package
{
}

{
new List<Package>

}
/*

*/
Remarks
invocação de Sum.
Also
Calcula a soma da sequência de valores Double obtidos pela invocação de uma função de transformação em cada
public static double Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,

static member Sum : seq<'Source> * Func<'Source, double> -> double
Type Parameters
TSource
Parameters
Returns
Double Double
Exceptions
Examples
class Package
{
}

{
new List<Package>

}
/*

*/
Remarks
invocação de Sum.
Also
public static decimal Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,

static member Sum : seq<'Source> * Func<'Source, decimal> -> decimal
Type Parameters
TSource
Parameters
Returns
Decimal Decimal
Exceptions
Examples
Note
class Package
{
}

{
new List<Package>

}
/*

*/
Remarks
invocação de Sum.
Also
Enumerable.Take Enumerable.Take
I n this Article
public static System.Collections.Generic.IEnumerable<TSource> Take<TSource> (this
static member Take : seq<'Source> * int -> seq<'Source>
Type Parameters
TSource
Parameters
A sequência da qual os elementos serão retornados.
count Int32 Int32
O número de elementos a serem retornados.
Returns
Um IEnumerable<T> que contém o número especificado de elementos do início da sequência de entrada.
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Take para retornar os elementos desde o início de uma sequência.
int[] grades = { 59, 82, 70, 56, 92, 98, 85 };
IEnumerable<int> topThreeGrades =
grades.OrderByDescending(grade => grade).Take(3);
Console.WriteLine("The top three grades are:");

foreach (int grade in topThreeGrades)
{
}
/*
The top three grades are:

98
92
85
*/
Remarks
Take Enumera source e gera elementos de até count elementos foram produzidos ou source não contém mais
nenhum elemento. Se count excede o número de elementos no source , todos os elementos de source são
retornados.
Se count é menor que ou igual a zero, source não é enumerada e um vazio IEnumerable<T> é retornado.
O Take e Skip métodos são complementa funcional. Dada uma determinada sequência coll e um número inteiro n ,
concatenando os resultados de coll.Take(n) e coll.Skip(n) produz a mesma sequência que coll .
Na sintaxe de expressão de consulta do Visual Basic, uma Take cláusula se traduz em uma invocação de Take.
See Cláusula Take (Visual Basic)Take Clause (Visual Basic)
Also
Enumerable.TakeLast Enumerable.TakeLast
I n this Article
public static System.Collections.Generic.IEnumerable<TSource> TakeLast<TSource> (this
static member TakeLast : seq<'Source> * int -> seq<'Source>
Type Parameters
TSource
Parameters
count Int32 Int32
Returns
Enumerable.TakeWhile Enumerable.TakeWhile
I n this Article
Overloads
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,
Boolean>) TakeWhile<TSource>(IEnumerable<TSource>, Retorna os elementos de uma sequência contanto que uma
Func<TSource,Boolean>) condição especificada seja verdadeira.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,
Int32,Boolean>) TakeWhile<TSource>(IEnumerable<TSource>, Retorna os elementos de uma sequência contanto que uma
Func<TSource,Int32,Boolean>) condição especificada seja verdadeira. O índice do elemento é
usado na lógica da função de predicado.
TakeWhile<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) TakeWhile<TSource>
public static System.Collections.Generic.IEnumerable<TSource> TakeWhile<TSource> (this
static member TakeWhile : seq<'Source> * Func<'Source, bool> -> seq<'Source>
Type Parameters
TSource
Parameters
Uma sequência a qual retornar os elementos.
Returns
Um IEnumerable<T> que contém elementos da sequência de entrada que ocorrem antes do elemento no qual o teste
não é mais aprovado.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar TakeWhile<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) para retornar elementos desde o início de uma sequência, desde que uma condição seja
verdadeira.
fruits.TakeWhile(fruit => String.Compare("orange", fruit, true) != 0);

{
}
/*
apple
banana
mango
*/
Remarks
O TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) método testa cada elemento de source

usando predicate , gerando o elemento se o resultado for true . Enumeração interrompe quando a função de
predicado retorna false para um elemento ou quando source não contém mais nenhum elemento.
coll .
Na sintaxe de expressão de consulta do Visual Basic, uma Take While cláusula se traduz em uma invocação de
TakeWhile.
See Cláusula Take While (Visual Basic)Take While Clause (Visual Basic)
Also
TakeWhile<TSource>(IEnumerable<TSource>,
Func<TSource,Int32,Boolean>) TakeWhile<TSource>
public static System.Collections.Generic.IEnumerable<TSource> TakeWhile<TSource> (this
static member TakeWhile : seq<'Source> * Func<'Source, int, bool> -> seq<'Source>
Type Parameters
TSource
Parameters
Returns
Um IEnumerable<T> que contém elementos da sequência de entrada que ocorrem antes do elemento no qual o teste
não é mais aprovado.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar TakeWhile<TSource>(IEnumerable<TSource>,
Func<TSource,Int32,Boolean>) para retornar elementos desde o início de uma sequência, desde que uma condição
que usa o índice do elemento é verdadeira.
string[] fruits = { "apple", "passionfruit", "banana", "mango",

"orange", "blueberry", "grape", "strawberry" };
fruits.TakeWhile((fruit, index) => fruit.Length >= index);

{
}
/*
apple
passionfruit
banana
mango
orange
blueberry
*/
Remarks
O TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) método testa cada elemento de

source usando predicate , gerando o elemento se o resultado for true . Enumeração interrompe quando a função
de predicado retorna false para um elemento ou quando source não contém mais nenhum elemento.
coll .
Na sintaxe de expressão de consulta do Visual Basic, uma Take While cláusula se traduz em uma invocação de
TakeWhile.
See Cláusula Take While (Visual Basic)Take While Clause (Visual Basic)
Also
Enumerable.ThenBy Enumerable.ThenBy
I n this Article
Overloads
ThenBy<TSource,TKey>(IOrderedEnumerable<TSource>,
Func<TSource,TKey>, IComparer<TKey>) ThenBy<TSource, Executa uma ordenação posterior dos elementos em uma
TKey>(IOrderedEnumerable<TSource>, Func<TSource,TKey>, sequência em ordem crescente usando um comparador
IComparer<TKey>) especificado.
Func<TSource,TKey>) ThenBy<TSource,TKey>(IOrdered Executa uma ordenação posterior dos elementos em uma
Enumerable<TSource>, Func<TSource,TKey>) sequência em ordem crescente de acordo com uma chave.
Func<TSource,TKey>, IComparer<TKey>) ThenBy<TSource,TKey>
(IOrderedEnumerable<TSource>, Func<TSource,TKey>,
IComparer<TKey>)
especificado.
public static System.Linq.IOrderedEnumerable<TSource> ThenBy<TSource,TKey> (this
System.Linq.IOrderedEnumerable<TSource> source, Func<TSource,TKey> keySelector,
static member ThenBy : System.Linq.IOrderedEnumerable<'Source> * Func<'Source, 'Key> *
Type Parameters
TSource
TKey
Parameters
source IOrderedEnumerable<TSource>
Um IOrderedEnumerable<TElement> que contém elementos a ser classificados.
Uma função para extrair uma chave de cada elemento.
Returns
Exceptions
Remarks
ThenBy e ThenByDescending são definidos para estender o tipo IOrderedEnumerable<TElement>, que também é o
tipo de retorno dos métodos a seguir. Esse design permite que você especificar vários critérios de classificação por
meio da aplicação de qualquer número de ThenBy ou ThenByDescending métodos.
Note

mesma chave.
Func<TSource,TKey>) ThenBy<TSource,TKey>
(IOrderedEnumerable<TSource>, Func<TSource,TKey>)
Executa uma ordenação posterior dos elementos em uma sequência em ordem crescente de acordo com uma chave.
public static System.Linq.IOrderedEnumerable<TSource> ThenBy<TSource,TKey> (this

System.Linq.IOrderedEnumerable<TSource> source, Func<TSource,TKey> keySelector);
static member ThenBy : System.Linq.IOrderedEnumerable<'Source> * Func<'Source, 'Key> ->
Type Parameters
TSource
TKey
Parameters
Returns
Exceptions
Examples
O exemplo de código a seguir demonstra como usar ThenBy<TSource,TKey>(IOrderedEnumerable<TSource>,
Func<TSource,TKey>) para executar uma classificação secundária dos elementos em uma sequência.
string[] fruits = { "grape", "passionfruit", "banana", "mango",
"orange", "raspberry", "apple", "blueberry" };
// Sort the strings first by their length and then

//alphabetically by passing the identity selector function.
fruits.OrderBy(fruit => fruit.Length).ThenBy(fruit => fruit);

{
}
/*
apple
grape
mango
banana
orange
blueberry
raspberry
passionfruit
*/
Remarks
Note

mesma chave.
Na sintaxe de expressão de consulta, uma orderby [first criterion], [second criterion] (Visual c#) ou
Order By [first criterion], [second criterion] cláusula ( Visual Basic) se traduz em uma invocação de ThenBy.
See Cláusula orderby (Referência de C#)orderby clause (C# Reference)

Also Cláusula Order By (Visual Basic)Order By Clause (Visual Basic)
Enumerable.ThenByDescending Enumerable.ThenBy
Descending
I n this Article
Overloads
ThenByDescending<TSource,TKey>(IOrderedEnumerable<
TSource>, Func<TSource,TKey>) ThenByDescending<TSource, Executa uma ordenação posterior dos elementos em uma
TKey>(IOrderedEnumerable<TSource>, Func<TSource,TKey>) sequência em ordem decrescente, de acordo com uma chave.
ThenByDescending<TSource,TKey>(IOrderedEnumerable<
TSource>, Func<TSource,TKey>, IComparer<TKey>) ThenBy Executa uma ordenação posterior dos elementos em uma
Descending<TSource,TKey>(IOrderedEnumerable<TSource>, sequência em ordem decrescente usando um comparador
Func<TSource,TKey>, IComparer<TKey>) especificado.
ThenByDescending<TSource,TKey>
chave.
public static System.Linq.IOrderedEnumerable<TSource> ThenByDescending<TSource,TKey> (this
System.Linq.IOrderedEnumerable<TSource> source, Func<TSource,TKey> keySelector);
static member ThenByDescending : System.Linq.IOrderedEnumerable<'Source> * Func<'Source, 'Key> ->
Type Parameters
TSource
TKey
Parameters
Returns
chave.
Exceptions
Remarks
Note

Esse método de classificação compara as chaves usando o comparador padrão Default.
mesma chave.
No Visual c# sintaxe de expressão de consulta, uma orderby [first criterion], [second criterion] descending
cláusula se traduz em uma invocação de ThenByDescending.
Na sintaxe de expressão de consulta do Visual Basic, uma
Order By [first criterion], [second criterion] Descending cláusula se traduz em uma invocação de
ThenByDescending.
See Cláusula orderby (Referência de C#)orderby clause (C# Reference)
Also Cláusula Order By (Visual Basic)Order By Clause (Visual Basic)
IComparer<TKey>) ThenByDescending<TSource,TKey>
IComparer<TKey>)
Executa uma ordenação posterior dos elementos em uma sequência em ordem decrescente usando um comparador
especificado.
public static System.Linq.IOrderedEnumerable<TSource> ThenByDescending<TSource,TKey> (this
System.Linq.IOrderedEnumerable<TSource> source, Func<TSource,TKey> keySelector,
static member ThenByDescending : System.Linq.IOrderedEnumerable<'Source> * Func<'Source, 'Key> *
Type Parameters
TSource
TKey
Parameters
Returns
chave.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar ThenByDescending<TSource,TKey>
(IOrderedEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) para executar uma classificação
secundária dos elementos em uma sequência em ordem decrescente usando um comparador personalizado.
public class CaseInsensitiveComparer : IComparer<string>
{
public int Compare(string x, string y)
{
return string.Compare(x, y, true);
}
}
public static void ThenByDescendingEx1()

{
string[] fruits = { "apPLe", "baNanA", "apple", "APple", "orange", "BAnana", "ORANGE", "apPLE"
};
// Sort the strings first ascending by their length and

// then descending using a custom case insensitive comparer.
fruits
.OrderBy(fruit => fruit.Length)
.ThenByDescending(fruit => fruit, new CaseInsensitiveComparer());

{
}
}
/*
apPLe
apple
APple
apPLE
orange
ORANGE
baNanA
BAnana
*/
Remarks
Note

mesma chave.
Enumerable.ToArray Enumerable.ToArray
I n this Article
Cria uma matriz de um IEnumerable<T>.
public static TSource[] ToArray<TSource> (this System.Collections.Generic.IEnumerable<TSource>
source);
static member ToArray : seq<'Source> -> 'Source[]
Type Parameters
TSource
Parameters
Um IEnumerable<T> para criar uma matriz.
Returns
TSource[]
Uma matriz que contém os elementos da sequência de entrada.
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar ToArray para forçar a avaliação imediata de consulta e retornar
uma matriz de resultados.
class Package
{
}
public static void ToArrayEx1()

{
new List<Package>
string[] companies = packages.Select(pkg => pkg.Company).ToArray();
foreach (string company in companies)

{
Console.WriteLine(company);
}
}
/*
Coho Vineyard
Lucerne Publishing
Wingtip Toys
Adventure Works
*/
Remarks
O ToArray<TSource>(IEnumerable<TSource>) método força a avaliação imediata de consulta e retorna uma matriz
que contém os resultados da consulta. Você pode acrescentar esse método à sua consulta para obter uma cópia
armazenada em cache os resultados da consulta.
ToList tem um comportamento semelhante mas retorna um List<T> em vez de uma matriz.
Enumerable.ToDictionary Enumerable.ToDictionary
I n this Article
Overloads
ToDictionary<TSource,TKey,TElement>(IEnumerable<
TSource>, Func<TSource,TKey>, Func<TSource,TElement>) To Cria um Dictionary<TKey,TValue> de um IEnumerable<T>, de
Dictionary<TSource,TKey,TElement>(IEnumerable<TSource>, acordo com as funções especificadas de seletor de chave e
Func<TSource,TKey>, Func<TSource,TElement>) seletor de elemento.
ToDictionary<TSource,TKey,TElement>(IEnumerable<
TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Cria um Dictionary<TKey,TValue> de um IEnumerable<T> de
IEqualityComparer<TKey>) ToDictionary<TSource,TKey, acordo com uma função de seletor de chave, um comparador
TElement>(IEnumerable<TSource>, Func<TSource,TKey>, e uma função de seletor de elemento especificados.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<
TSource,TKey>) ToDictionary<TSource,TKey>(IEnumerable< Cria um Dictionary<TKey,TValue> de um IEnumerable<T>, de
TSource>, Func<TSource,TKey>) acordo com uma função de seletor de chave especificada.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<
TSource,TKey>, IEqualityComparer<TKey>) ToDictionary< Cria um Dictionary<TKey,TValue> de um IEnumerable<T>, de
TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, acordo com uma função de seletor de chave especificada e um
IEqualityComparer<TKey>) comparador de chaves.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>,
Cria um Dictionary<TKey,TValue> de um IEnumerable<T>, de acordo com as funções especificadas de seletor de
public static System.Collections.Generic.Dictionary<TKey,TElement>
ToDictionary<TSource,TKey,TElement> (this System.Collections.Generic.IEnumerable<TSource> source,
static member ToDictionary : seq<'Source> * Func<'Source, 'Key> * Func<'Source, 'Element> ->
System.Collections.Generic.Dictionary<'Key, 'Element>
Type Parameters
TSource
TKey
TElement
O tipo do valor retornado por elementSelector .
Parameters
Um IEnumerable<T> por meio do qual um Dictionary<TKey,TValue> será criado.
Uma função de transformação para produzir um valor de elemento de resultado de cada elemento.
Returns
Dictionary<TKey,TElement>
Um Dictionary<TKey,TValue> que contém valores do tipo TElement selecionados da sequência de entrada.
Exceptions
- ou - keySelector gera uma chave que é null .
ArgumentException ArgumentException
keySelector gera chaves duplicatas para dois elementos.
Remarks
O ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)
método usa o comparador de igualdade padrão Default para comparar chaves.
Cria um Dictionary<TKey,TValue> de um IEnumerable<T> de acordo com uma função de seletor de chave, um

ToDictionary<TSource,TKey,TElement> (this System.Collections.Generic.IEnumerable<TSource> source,
static member ToDictionary : seq<'Source> * Func<'Source, 'Key> * Func<'Source, 'Element> *
System.Collections.Generic.IEqualityComparer<'Key> -> System.Collections.Generic.Dictionary<'Key,
'Element>
Type Parameters
TSource
TKey
TElement
Parameters
Returns
Um Dictionary<TKey,TValue> que contém valores do tipo TElement selecionados da sequência de entrada.
Exceptions
Remarks
ToDictionary<TSource,TKey>(IEnumerable<TSource>,
Func<TSource,TKey>) ToDictionary<TSource,TKey>
especificada.
public static System.Collections.Generic.Dictionary<TKey,TSource> ToDictionary<TSource,TKey> (this

static member ToDictionary : seq<'Source> * Func<'Source, 'Key> ->
System.Collections.Generic.Dictionary<'Key, 'Source>
Type Parameters
TSource
TKey
Parameters
Returns
Dictionary<TKey,TSource>
Um Dictionary<TKey,TValue> que contém chaves e valores.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar ToDictionary<TSource,TKey>(IEnumerable<TSource>,
Func<TSource,TKey>) para criar um Dictionary<TKey,TValue> por meio de um seletor de chave.
class Package
{
public long TrackingNumber { get; set; }
}
public static void ToDictionaryEx1()

{
new List<Package>
{ new Package { Company = "Coho Vineyard", Weight = 25.2, TrackingNumber = 89453312L },
new Package { Company = "Lucerne Publishing", Weight = 18.7, TrackingNumber =
89112755L },
new Package { Company = "Wingtip Toys", Weight = 6.0, TrackingNumber = 299456122L },
new Package { Company = "Adventure Works", Weight = 33.8, TrackingNumber = 4665518773L
} };
// Create a Dictionary of Package objects,

// using TrackingNumber as the key.
Dictionary<long, Package> dictionary =
packages.ToDictionary(p => p.TrackingNumber);
foreach (KeyValuePair<long, Package> kvp in dictionary)

{
Console.WriteLine(
"Key {0}: {1}, {2} pounds",
kvp.Key,
kvp.Value.Company,
kvp.Value.Weight);
}
}
/*
Key 89453312: Coho Vineyard, 25.2 pounds

Key 89112755: Lucerne Publishing, 18.7 pounds
Key 299456122: Wingtip Toys, 6 pounds
Key 4665518773: Adventure Works, 33.8 pounds
*/
Remarks
O ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) método usa o comparador de
igualdade padrão Default para comparar chaves.
static member ToDictionary : seq<'Source> * Func<'Source, 'Key> *
'Source>
Type Parameters
TSource
TKey
O tipo das chaves retornadas por keySelector .
Parameters
Returns
Exceptions
Remarks
Enumerable.ToHashSet Enumerable.ToHashSet
I n this Article
Overloads
ToHashSet<TSource>(IEnumerable<TSource>, IEquality
Comparer<TSource>) ToHashSet<TSource>(IEnumerable< Cria um HashSet<T> de um IEnumerable<T> usando o
TSource>, IEqualityComparer<TSource>) comparer para comparar chaves
ToHashSet<TSource>(IEnumerable<TSource>) ToHashSet<
TSource>(IEnumerable<TSource>) Cria um HashSet<T> de um IEnumerable<T>.
ToHashSet<TSource>(IEnumerable<TSource>,
IEqualityComparer<TSource>) ToHashSet<TSource>
(IEnumerable<TSource>, IEqualityComparer<TSource>)
Cria um HashSet<T> de um IEnumerable<T> usando o comparer para comparar chaves
public static System.Collections.Generic.HashSet<TSource> ToHashSet<TSource> (this

static member ToHashSet : seq<'Source> * System.Collections.Generic.IEqualityComparer<'Source> ->
System.Collections.Generic.HashSet<'Source>
Type Parameters
TSource
Parameters
Um IEnumerable<T> por meio do qual um HashSet<T> será criado.
Returns
HashSet<TSource>
Um HashSet<T> que contém valores do tipo TSource selecionados da sequência de entrada.
Cria um HashSet<T> de um IEnumerable<T>.
public static System.Collections.Generic.HashSet<TSource> ToHashSet<TSource> (this
static member ToHashSet : seq<'Source> -> System.Collections.Generic.HashSet<'Source>
Type Parameters
TSource
Parameters
Um IEnumerable<T> por meio do qual um HashSet<T> será criado.
Returns
HashSet<TSource>
Um HashSet<T> que contém os valores do tipo TSource selecionados da sequência de entrada.
Enumerable.ToList Enumerable.ToList
I n this Article
Cria um List<T> de um IEnumerable<T>.
public static System.Collections.Generic.List<TSource> ToList<TSource> (this
static member ToList : seq<'Source> -> System.Collections.Generic.List<'Source>
Type Parameters
TSource
Parameters
O IEnumerable<T> por meio do qual um List<T> será criado.
Returns
List<TSource>
Um List<T> que contém elementos da sequência de entrada.
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar ToList para forçar a avaliação imediata de consulta e retornar um
List<T> que contém os resultados da consulta.
List<int> lengths = fruits.Select(fruit => fruit.Length).ToList();
foreach (int length in lengths)

{
Console.WriteLine(length);
}
/*
5
12
6
5
6
9
5
10
*/
Remarks
O ToList<TSource>(IEnumerable<TSource>) método força a avaliação imediata de consulta e retorna um List<T> que
contém os resultados da consulta. Você pode acrescentar esse método à sua consulta para obter uma cópia
armazenada em cache os resultados da consulta.
ToArray tem um comportamento semelhante mas retorna uma matriz em vez de um List<T>.
Enumerable.ToLookup Enumerable.ToLookup
I n this Article
Overloads
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>,
Func<TSource,TKey>, Func<TSource,TElement>) ToLookup< Cria um Lookup<TKey,TElement> de um IEnumerable<T>, de
TSource,TKey,TElement>(IEnumerable<TSource>, Func< acordo com as funções especificadas de seletor de chave e
TSource,TKey>, Func<TSource,TElement>) seletor de elemento.
Func<TSource,TKey>, Func<TSource,TElement>, IEquality Cria um Lookup<TKey,TElement> de um IEnumerable<T> de
Comparer<TKey>) ToLookup<TSource,TKey,TElement>( acordo com uma função de seletor de chave, um comparador
IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource, e uma função de seletor de elemento especificados.
TElement>, IEqualityComparer<TKey>)
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<
TSource,TKey>) ToLookup<TSource,TKey>(IEnumerable< Cria um Lookup<TKey,TElement> de um IEnumerable<T>, de
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<
TSource,TKey>, IEqualityComparer<TKey>) ToLookup< Cria um Lookup<TKey,TElement> de um IEnumerable<T>, de
TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, acordo com uma função de seletor de chave especificada e um
IEqualityComparer<TKey>) comparador de chaves.
Cria um Lookup<TKey,TElement> de um IEnumerable<T>, de acordo com as funções especificadas de seletor de
public static System.Linq.ILookup<TKey,TElement> ToLookup<TSource,TKey,TElement> (this
Func<TSource,TElement> elementSelector);
static member ToLookup : seq<'Source> * Func<'Source, 'Key> * Func<'Source, 'Element> ->
System.Linq.ILookup<'Key, 'Element>
Type Parameters
TSource
TKey
TElement
Parameters
O IEnumerable<T> por meio do qual um Lookup<TKey,TElement> será criado.
Returns
ILookup<TKey,TElement> ILookup<TKey,TElement>
Um Lookup<TKey,TElement> que contém valores do tipo TElement selecionados da sequência de entrada.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>,
Func<TSource,TKey>, Func<TSource,TElement>) para criar um Lookup<TKey,TElement> usando uma função de
seletor de chave e uma função de seletor de elemento.
class Package
{
public long TrackingNumber { get; set; }
}
public static void ToLookupEx1()

{
// Create a list of Packages.
new List<Package>
{ new Package { Company = "Coho Vineyard",
Weight = 25.2, TrackingNumber = 89453312L },
new Package { Company = "Lucerne Publishing",
new Package { Company = "Wingtip Toys",
new Package { Company = "Contoso Pharmaceuticals",
new Package { Company = "Wide World Importers",
Weight = 33.8, TrackingNumber = 4665518773L } };
// Create a Lookup to organize the packages.

// Use the first character of Company as the key value.
// Select Company appended to TrackingNumber
// as the element values of the Lookup.
ILookup<char, string> lookup =
packages
.ToLookup(p => Convert.ToChar(p.Company.Substring(0, 1)),
p => p.Company + " " + p.TrackingNumber);
// Iterate through each IGrouping in the Lookup.

foreach (IGrouping<char, string> packageGroup in lookup)
{
Console.WriteLine(packageGroup.Key);
// Iterate through each value in the
// IGrouping and print its value.
foreach (string str in packageGroup)
Console.WriteLine(" {0}", str);
}
}
/*
C
Coho Vineyard 89453312
Contoso Pharmaceuticals 670053128
L
Lucerne Publishing 89112755
W
Wingtip Toys 299456122
Wide World Importers 4665518773
*/
Remarks
O ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)
método retorna um Lookup<TKey,TElement>, um dicionário de um-para-muitos que mapeia chaves para coleções de
valores. Um Lookup<TKey,TElement> difere de um Dictionary<TKey,TValue>, que executa um mapeamento de chaves
para valores únicos.
IEqualityComparer<TKey>) ToLookup<TSource,TKey,TElement>
Cria um Lookup<TKey,TElement> de um IEnumerable<T> de acordo com uma função de seletor de chave, um

Func<TSource,TElement> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>
comparer);
static member ToLookup : seq<'Source> * Func<'Source, 'Key> * Func<'Source, 'Element> *
System.Collections.Generic.IEqualityComparer<'Key> -> System.Linq.ILookup<'Key, 'Element>
Type Parameters
TSource
TKey
TElement
Parameters
Returns
Um Lookup<TKey,TElement> que contém valores do tipo TElement selecionados da sequência de entrada.
Exceptions
Remarks
O ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>,
IEqualityComparer<TKey>) método retorna um Lookup<TKey,TElement>, um dicionário de um-para-muitos que
mapeia chaves para coleções de valores. Um Lookup<TKey,TElement> difere de um Dictionary<TKey,TValue>, que
executa um mapeamento de chaves para valores únicos.
ToLookup<TSource,TKey>(IEnumerable<TSource>,
Func<TSource,TKey>) ToLookup<TSource,TKey>
especificada.
public static System.Linq.ILookup<TKey,TSource> ToLookup<TSource,TKey> (this
static member ToLookup : seq<'Source> * Func<'Source, 'Key> -> System.Linq.ILookup<'Key, 'Source>
Type Parameters
TSource
TKey
Parameters
Returns
ILookup<TKey,TSource>
Um Lookup<TKey,TElement> que contém chaves e valores.
Exceptions
Remarks
O ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) método retorna um
Lookup<TKey,TElement>, um dicionário de um-para-muitos que mapeia chaves para coleções de valores. Um
Lookup<TKey,TElement> difere de um Dictionary<TKey,TValue>, que executa um mapeamento de chaves para
valores únicos.
static member ToLookup : seq<'Source> * Func<'Source, 'Key> *
System.Collections.Generic.IEqualityComparer<'Key> -> System.Linq.ILookup<'Key, 'Source>
Type Parameters
TSource
TKey
Parameters
Returns
Um Lookup<TKey,TElement> que contém chaves e valores.
Exceptions
Remarks
O ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) método
retorna um Lookup<TKey,TElement>, um dicionário de um-para-muitos que mapeia chaves para coleções de valores.
Um Lookup<TKey,TElement> é diferente para um Dictionary<TKey,TValue>, que executa um mapeamento de chaves
para valores únicos.
Enumerable.Union Enumerable.Union
I n this Article
Overloads
Union<TSource>(IEnumerable<TSource>, IEnumerable<
TSource>) Union<TSource>(IEnumerable<TSource>, Produz a união de conjunto de duas sequências usando o
IEnumerable<TSource>) comparador de igualdade padrão.
Union<TSource>(IEnumerable<TSource>, IEnumerable<
TSource>, IEqualityComparer<TSource>) Union<TSource>( Produz a união de conjunto de duas sequências usando o
IEnumerable<TSource>, IEnumerable<TSource>, IEquality IEqualityComparer<T> especificado.
Comparer<TSource>)
Union<TSource>(IEnumerable<TSource>,
IEnumerable<TSource>) Union<TSource>
public static System.Collections.Generic.IEnumerable<TSource> Union<TSource> (this
static member Union : seq<'Source> * seq<'Source> -> seq<'Source>
Type Parameters
TSource
Parameters
Um IEnumerable<T> cujos elementos distintos formam o primeiro conjunto da união.
Um IEnumerable<T> cujos elementos distintos formam o segundo conjunto da união.
Returns
Um IEnumerable<T> que contém os elementos de ambas as sequências de entrada, excluindo as duplicatas.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Union<TSource>(IEnumerable<TSource>,
IEnumerable<TSource>) para obter a união de duas sequências de inteiros.
int[] ints1 = { 5, 3, 9, 7, 5, 9, 3, 7 };
int[] ints2 = { 8, 3, 6, 4, 4, 9, 1, 0 };
IEnumerable<int> union = ints1.Union(ints2);
foreach (int num in union)

{
Console.Write("{0} ", num);
}
/*
5 3 9 7 8 6 4 1 0
*/
Se você quiser comparar sequências de objetos de um tipo de dados personalizado, você precisa implementar o
IEqualityComparer<T> interface genérica em um helperclass. O exemplo de código a seguir mostra como
{

{
if (other is null)
return false;

}

}
Depois de implementar essa interface, você pode usar sequências de ProductA objetos no Union<TSource>


//Get the products from the both arrays

//excluding duplicates.
IEnumerable<ProductA> union =
store1.Union(store2);
foreach (var product in union)

/*
apple 9
orange 4
lemon 12
*/
Remarks
Este método exclui duplicatas do conjunto de retorno. Isso é um comportamento diferente para o Concat método, que
retorna todos os elementos nas sequências de entrada, incluindo duplicatas.
Quando o objeto retornado por esse método é enumerado, Union enumera first e second nessa ordem e produz
cada elemento que já não foram produzido.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>,
IEqualityComparer<TSource>) Union<TSource>
(IEnumerable<TSource>, IEnumerable<TSource>,
IEqualityComparer<TSource>)
public static System.Collections.Generic.IEnumerable<TSource> Union<TSource> (this
static member Union : seq<'Source> * seq<'Source> *
Type Parameters
TSource
Parameters
Um IEnumerable<T> cujos elementos distintos formam o primeiro conjunto da união.
Um IEnumerable<T> cujos elementos distintos formam o segundo conjunto da união.
O IEqualityComparer<T> para comparar valores.
Returns
Um IEnumerable<T> que contém os elementos de ambas as sequências de entrada, excluindo as duplicatas.
Exceptions
Examples
O exemplo a seguir mostra como implementar um comparador de igualdade que pode ser usado no Union método.
{
}

{
{


return false;

}


{



}
Depois de implementar esse comparador, você pode usar sequências de Product objetos no Union método, conforme


//Get the products from the both arrays
//excluding duplicates.
IEnumerable<Product> union =
store1.Union(store2, new ProductComparer());
foreach (var product in union)

/*
apple 9
orange 4
lemon 12
*/
Remarks
Quando o objeto retornado por esse método é enumerado, Union enumera first e second nessa ordem e produz
cada elemento que já não foram produzido.
O Concat difere do método de Union método porque o Concat método retorna todos os elementos nas sequências de
entrada, incluindo as duplicatas, enquanto Union retorna apenas valores exclusivos.
Enumerable.Where Enumerable.Where
I n this Article
Overloads
Where<TSource>(IEnumerable<TSource>, Func<TSource,
Int32,Boolean>) Where<TSource>(IEnumerable<TSource>, Filtra uma sequência de valores com base em um predicado. O
Func<TSource,Int32,Boolean>) índice de cada elemento é usado na lógica da função de
predicado.
Where<TSource>(IEnumerable<TSource>, Func<TSource,
Boolean>) Where<TSource>(IEnumerable<TSource>, Func< Filtra uma sequência de valores com base em um predicado.
TSource,Boolean>)
Where<TSource>(IEnumerable<TSource>,
Func<TSource,Int32,Boolean>) Where<TSource>
Filtra uma sequência de valores com base em um predicado. O índice de cada elemento é usado na lógica da função de
predicado.
public static System.Collections.Generic.IEnumerable<TSource> Where<TSource> (this
static member Where : seq<'Source> * Func<'Source, int, bool> -> seq<'Source>
Type Parameters
TSource
Parameters
Um IEnumerable<T> a ser filtrado.
Returns
Um IEnumerable<T> que contém elementos da sequência de entrada que atendem à condição.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Where<TSource>(IEnumerable<TSource>,
Func<TSource,Int32,Boolean>) para filtrar uma sequência com base em um predicado que envolve o índice de cada
elemento.
int[] numbers = { 0, 30, 20, 15, 90, 85, 40, 75 };
numbers.Where((number, index) => number <= index * 10);
foreach (int number in query)

{
}
/*
0
20
15
40
*/
Remarks
Where<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) Where<TSource>
public static System.Collections.Generic.IEnumerable<TSource> Where<TSource> (this
static member Where : seq<'Source> * Func<'Source, bool> -> seq<'Source>
Type Parameters
TSource
Parameters
Um IEnumerable<T> a ser filtrado.
Returns
Um IEnumerable<T> que contém elementos da sequência de entrada que atendem à condição.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Where<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) para filtrar uma sequência.
List<string> fruits =
new List<string> { "apple", "passionfruit", "banana", "mango",
IEnumerable<string> query = fruits.Where(fruit => fruit.Length < 6);

{
}
/*
apple
mango
grape
*/
Remarks
Na sintaxe de expressão de consulta, uma where (Visual c#) ou Where cláusula (Visual Basic) se traduz em uma
invocação de Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>).
See Cláusula where (Referência de C#)where clause (C# Reference)
Also Cláusula Where (Visual Basic)Where Clause (Visual Basic)
Enumerable.Zip Enumerable.Zip
I n this Article
Aplica uma função especificada para os elementos correspondentes de duas sequências, produzindo uma sequência
dos resultados.
public static System.Collections.Generic.IEnumerable<TResult> Zip<TFirst,TSecond,TResult> (this

System.Collections.Generic.IEnumerable<TFirst> first,
System.Collections.Generic.IEnumerable<TSecond> second, Func<TFirst,TSecond,TResult>
resultSelector);
static member Zip : seq<'First> * seq<'Second> * Func<'First, 'Second, 'Result> -> seq<'Result>
Type Parameters
TFirst
O tipo de elementos na primeira sequência de entrada.
TSecond
O tipo de elementos na segunda sequência de entrada.
TResult
O tipo de elementos na sequência de resultado.
Parameters
first IEnumerable<TFirst>
A primeira sequência a ser mesclada.
second IEnumerable<TSecond>
A segunda sequência a ser mesclada.
resultSelector Func<TFirst,TSecond,TResult>
Uma função que especifica como mesclar os elementos das duas sequências.
Returns
Um IEnumerable<T> que contém elementos mesclados de duas sequências de entrada.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar o Zip método para mesclar duas sequências.
int[] numbers = { 1, 2, 3, 4 };
string[] words = { "one", "two", "three" };
var numbersAndWords = numbers.Zip(words, (first, second) => first + " " + second);
foreach (var item in numbersAndWords)

Console.WriteLine(item);
// 1 one
// 2 two
// 3 three
Remarks
O método mescla cada elemento da primeira sequência com um elemento que tem o mesmo índice na segunda
sequência. Se as sequências não tiverem o mesmo número de elementos, o método mescla as sequências até atingir o
final de um deles. Por exemplo, se uma sequência tem três elementos e o outro é tem quatro, a sequência de resultado
terá apenas três elementos.
EnumerableExecutor EnumerableExecutor Class
Representa uma árvore de expressão e fornece funcionalidade para executar a árvore de expressão depois de
reescrevê-los.
D eclaration
public abstract class EnumerableExecutor
type EnumerableExecutor = class
Object Object
Constructors
EnumerableExecutor()
EnumerableExecutor()
Inicializa uma nova instância da classe EnumerableExecutor.

EnumerableExecutor
I n this Article
Inicializa uma nova instância da classe EnumerableExecutor.
protected EnumerableExecutor ();
EnumerableExecutor<T> EnumerableExecutor<T> Class
Representa uma árvore de expressão e fornece funcionalidade para executar a árvore de expressão depois de
reescrevê-los.
D eclaration
public class EnumerableExecutor<T> : System.Linq.EnumerableExecutor
type EnumerableExecutor<'T> = class
inherit EnumerableExecutor
Object Object
EnumerableExecutor EnumerableExecutor
Constructors
EnumerableExecutor<T>(Expression)
EnumerableExecutor<T>(Expression)
Inicializa uma nova instância da classe EnumerableExecutor<T>.

EnumerableExecutor<T> EnumerableExecutor<T>
I n this Article
Inicializa uma nova instância da classe EnumerableExecutor<T>.
public EnumerableExecutor (System.Linq.Expressions.Expression expression);
new System.Linq.EnumerableExecutor<'T> : System.Linq.Expressions.Expression ->
System.Linq.EnumerableExecutor<'T>
Parameters
expression Expression Expression
Uma árvore de expressão para associar à nova instância.
EnumerableQuery EnumerableQuery Class
Representa um IEnumerable como uma fonte de dados EnumerableQuery.
D eclaration
public abstract class EnumerableQuery
type EnumerableQuery = class
Object Object
Constructors
EnumerableQuery()
EnumerableQuery()
Inicializa uma nova instância da classe EnumerableQuery.

EnumerableQuery
I n this Article
Inicializa uma nova instância da classe EnumerableQuery.
protected EnumerableQuery ();
EnumerableQuery<T> EnumerableQuery<T> Class
Representa uma coleção de IEnumerable<T> como uma fonte de dados IQueryable<T>.
D eclaration
public class EnumerableQuery<T> : System.Linq.EnumerableQuery,
System.Collections.Generic.IEnumerable<T>, System.Linq.IOrderedQueryable<T>,
System.Linq.IQueryable<T>, System.Linq.IQueryProvider
type EnumerableQuery<'T> = class
inherit EnumerableQuery
interface IOrderedQueryable<'T>
interface IQueryable
interface IQueryProvider
interface seq<'T>
interface IEnumerable
interface IQueryable<'T>
interface IOrderedQueryable
Object Object
EnumerableQuery EnumerableQuery
Constructors
EnumerableQuery<T>(IEnumerable<T>)
EnumerableQuery<T>(IEnumerable<T>)
Inicializa uma nova instância da classe EnumerableQuery<T> e a associa a uma coleção IEnumerable<T>.
EnumerableQuery<T>(Expression)
EnumerableQuery<T>(Expression)
Inicializa uma nova instância da classe EnumerableQuery<T> e associa a instância a uma árvore de expressão.
Methods
ToString()
ToString()
Retorna uma representação textual da coleção enumerável ou, se for nulo, da árvore de expressão que está
associada a esta instância.
IEnumerable<T>.GetEnumerator()
IEnumerable<T>.GetEnumerator()
Retorna um enumerador que pode iterar por meio da coleção IEnumerable<T> associada ou, se for nulo, por
meio da coleção que resulta da regravação da árvore de expressão associada como uma consulta em uma fonte
de dados IEnumerable<T> e da execução dela.
IEnumerable.GetEnumerator()
Retorna um enumerador que pode iterar por meio da coleção IEnumerable<T> associada ou, se for nulo, por
meio da coleção que resulta da regravação da árvore de expressão associada como uma consulta em uma fonte
de dados IEnumerable<T> e da execução dela.
Obtém o tipo dos dados na coleção que são representados por esta instância.
Obtém a árvore de expressão que está associada com esta instância ou que a representa.
IQueryable.Provider
IQueryable.Provider
Obtém o provedor de consulta associado esta instância.
IQueryProvider.CreateQuery(Expression)
Constrói um novo objeto EnumerableQuery<T> e associa-o a uma árvore de expressão especificada que
representa uma coleção de dados IQueryable.
IQueryProvider.CreateQuery<S>(Expression)
Constrói um novo objeto EnumerableQuery<T> e associa-o a uma árvore de expressão especificada que
representa uma coleção de dados IQueryable<T>.
IQueryProvider.Execute(Expression)
Executa uma expressão depois de reescrevê-la para chamar métodos Enumerable em vez de métodos Queryable
em quaisquer fontes de dados enumeráveis que não podem ser consultadas por métodos Queryable.
IQueryProvider.Execute<S>(Expression)
Executa uma expressão depois de reescrevê-la para chamar métodos Enumerable em vez de métodos Queryable
em quaisquer fontes de dados enumeráveis que não podem ser consultadas por métodos Queryable.
EnumerableQuery<T> EnumerableQuery<T>
I n this Article
Overloads
EnumerableQuery<T>(IEnumerable<T>) EnumerableQuery<
T>(IEnumerable<T>) Inicializa uma nova instância da classe EnumerableQuery<T> e
a associa a uma coleção IEnumerable<T>.
EnumerableQuery<T>(Expression) EnumerableQuery<T>(
Expression) Inicializa uma nova instância da classe EnumerableQuery<T> e
associa a instância a uma árvore de expressão.
EnumerableQuery<T>(IEnumerable<T>) EnumerableQuery<T>
(IEnumerable<T>)
Inicializa uma nova instância da classe EnumerableQuery<T> e a associa a uma coleção IEnumerable<T>.
public EnumerableQuery (System.Collections.Generic.IEnumerable<T> enumerable);
new System.Linq.EnumerableQuery<'T> : seq<'T> -> System.Linq.EnumerableQuery<'T>
Parameters
enumerable IEnumerable<T> IEnumerable<T>
Uma coleção a associar à nova instância.
EnumerableQuery<T>(Expression) EnumerableQuery<T>
(Expression)
Inicializa uma nova instância da classe EnumerableQuery<T> e associa a instância a uma árvore de expressão.
public EnumerableQuery (System.Linq.Expressions.Expression expression);
new System.Linq.EnumerableQuery<'T> : System.Linq.Expressions.Expression ->
System.Linq.EnumerableQuery<'T>
Parameters
Uma árvore de expressão para associar à nova instância.
EnumerableQuery<T>.IEnumerable.GetEnumerator
I n this Article
Retorna um enumerador que pode iterar por meio da coleção IEnumerable<T> associada ou, se for nulo, por meio da
coleção que resulta da regravação da árvore de expressão associada como uma consulta em uma fonte de dados
IEnumerable<T> e da execução dela.
System.Collections.IEnumerator IEnumerable.GetEnumerator ();
Returns
IEnumerator
Um enumerador que pode ser usado para iterar pela fonte de dados associada.
EnumerableQuery<T>.IEnumerable<T>.GetEnumerator
I n this Article
Retorna um enumerador que pode iterar por meio da coleção IEnumerable<T> associada ou, se for nulo, por meio da
coleção que resulta da regravação da árvore de expressão associada como uma consulta em uma fonte de dados
IEnumerable<T> e da execução dela.
System.Collections.Generic.IEnumerator<T> IEnumerable<T>.GetEnumerator ();
Returns
IEnumerator<T>
Um enumerador que pode ser usado para iterar pela fonte de dados associada.
EnumerableQuery<T>.IQueryable.ElementType
I n this Article
Obtém o tipo dos dados na coleção que são representados por esta instância.
Type System.Linq.IQueryable.ElementType { get; }
Returns
Type
O tipo de dados na coleção que representa esta instância.
EnumerableQuery<T>.IQueryable.Expression
I n this Article
Obtém a árvore de expressão que está associada com esta instância ou que a representa.
System.Linq.Expressions.Expression System.Linq.IQueryable.Expression { get; }
Returns
Expression
A árvore de expressão que está associada ou que representa esta instância.
EnumerableQuery<T>.IQueryable.Provider
I n this Article
Obtém o provedor de consulta associado esta instância.
System.Linq.IQueryProvider System.Linq.IQueryable.Provider { get; }
Returns
IQueryProvider
O provedor de consulta que está associado esta instância.
EnumerableQuery<T>.IQueryProvider.CreateQuery
I n this Article
Overloads
Constrói um novo objeto EnumerableQuery<T> e associa-o a
uma árvore de expressão especificada que representa uma
coleção de dados IQueryable.
Constrói um novo objeto EnumerableQuery<T> e associa-o a
uma árvore de expressão especificada que representa uma
coleção de dados IQueryable<T>.
Constrói um novo objeto EnumerableQuery<T> e associa-o a uma árvore de expressão especificada que representa
uma coleção de dados IQueryable.
System.Linq.IQueryable IQueryProvider.CreateQuery (System.Linq.Expressions.Expression expression);
Parameters
expression Expression
Uma árvore de expressão que representa uma coleção de dados IQueryable.
Returns
IQueryable
Um objeto EnumerableQuery<T> que está associado a expression .
Constrói um novo objeto EnumerableQuery<T> e associa-o a uma árvore de expressão especificada que representa
uma coleção de dados IQueryable<T>.
System.Linq.IQueryable<S> IQueryProvider.CreateQuery<S> (System.Linq.Expressions.Expression
expression);
Type Parameters
S
O tipo de dados na coleção que expression representa.
Parameters
Uma árvore de expressão para executar.
Returns
IQueryable<S>
Representa um objeto EnumerableQuery associado a expression .
EnumerableQuery<T>.IQueryProvider.Execute
I n this Article
Overloads
Executa uma expressão depois de reescrevê-la para chamar
métodos Enumerable em vez de métodos Queryable em
quaisquer fontes de dados enumeráveis que não podem ser
consultadas por métodos Queryable.
Executa uma expressão depois de reescrevê-la para chamar
métodos Enumerable em vez de métodos Queryable em
quaisquer fontes de dados enumeráveis que não podem ser
consultadas por métodos Queryable.
Executa uma expressão depois de reescrevê-la para chamar métodos Enumerable em vez de métodos Queryable em
quaisquer fontes de dados enumeráveis que não podem ser consultadas por métodos Queryable.
object IQueryProvider.Execute (System.Linq.Expressions.Expression expression);
Parameters
Returns
Object
O valor que resulta da execução de expression .
Executa uma expressão depois de reescrevê-la para chamar métodos Enumerable em vez de métodos Queryable em
quaisquer fontes de dados enumeráveis que não podem ser consultadas por métodos Queryable.
S IQueryProvider.Execute<S> (System.Linq.Expressions.Expression expression);
Type Parameters
S
O tipo de dados na coleção que expression representa.
Parameters
Returns
S
O valor que resulta da execução de expression .
EnumerableQuery<T>.ToString EnumerableQuery<T>.To
String
I n this Article
Retorna uma representação textual da coleção enumerável ou, se for nulo, da árvore de expressão que está associada a
esta instância.
public override string ToString ();
override this.ToString : unit -> string
Returns
String String
Uma representação textual da coleção enumerável ou, se for nulo, da árvore de expressão que está associada a esta
instância.
IGrouping<TKey,TElement> IGrouping<TKey,TElement>
Interface
Representa uma coleção de objetos que têm uma chave comum.
D eclaration
public interface IGrouping<out TKey,out TElement> : System.Collections.Generic.IEnumerable<out
TElement>
type IGrouping<'Key, 'Element> = interface
interface seq<'Element>
None
Remarks
Uma IGrouping<TKey,TElement> é um IEnumerable<T> Além disso, que tem uma chave. A chave representa o
atributo que é comum a cada valor no IGrouping<TKey,TElement>.
Os valores de uma IGrouping<TKey,TElement> são acessados muito como os elementos de um IEnumerable<T> são
acessados. Por exemplo, você pode acessar os valores usando um foreach no Visual c# ou For Each in Visual Basic
para iterar por meio de IGrouping<TKey,TElement> objeto. A seção de exemplo contém um exemplo de código que
mostra como acessar a chave e os valores de um IGrouping<TKey,TElement> objeto.
O IGrouping<TKey,TElement> tipo é usado pelas GroupBy métodos de operador de consulta padrão, que retornam
uma sequência de elementos do tipo IGrouping<TKey,TElement>.
Properties
Key
Key
Obtém a chave do IGrouping<TKey,TElement>.

IGrouping<TKey,TElement>.Key IGrouping<TKey,
TElement>.Key
I n this Article
Obtém a chave do IGrouping<TKey,TElement>.
public TKey Key { get; }

member this.Key : 'Key
Returns
TKey TKey
A chave do IGrouping<TKey,TElement>.
Examples
O exemplo a seguir demonstra como usar o Key propriedade para rotular cada IGrouping<TKey,TElement> objeto em
uma sequência de IGrouping<TKey,TElement> objetos. O GroupBy<TSource,TKey>(IEnumerable<TSource>,
Func<TSource,TKey>) método é usado para obter uma sequência de IGrouping<TKey,TElement> objetos. O foreach
no Visual c# ou For Each no Visual Basic loop, em seguida, itera por meio de cada IGrouping<TKey,TElement>
objeto, gerar sua chave e o número de valores que ele contém.
// Get a sequence of IGrouping objects.
IEnumerable<IGrouping<System.Reflection.MemberTypes, System.Reflection.MemberInfo>> memberQuery =
typeof(String).GetMembers().
GroupBy(member => member.MemberType);
// Output the key of each IGrouping object and the count of values.
foreach (IGrouping<System.Reflection.MemberTypes, System.Reflection.MemberInfo> group in
memberQuery)
Console.WriteLine("(Key) {0} (Member count) {1}", group.Key, group.Count());
// The output is similar to:

// (Key) Method (Member count) 113
// (Key) Constructor (Member count) 8
// (Key) Property (Member count) 2
// (Key) Field (Member count) 1
Remarks
A chave de um IGrouping<TKey,TElement> representa o atributo que é comum a cada valor no
IGrouping<TKey,TElement>.
Interface
Define um indexador, a propriedade de tamanho e o método de pesquisa booliana para estruturas de dados que
mapeiam chaves para sequências IEnumerable<T> de valores.
D eclaration
public interface ILookup<TKey,TElement> :
System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey,TElement>>
type ILookup<'Key, 'Element> = interface
interface seq<IGrouping<'Key, 'Element>>
None
Remarks
O tipo Lookup<TKey,TElement> implementa o ILookup<TKey,TElement> interface.
O método de extensão ToLookup, que pode ser acrescentado ao final de uma consulta LINQ, retorna um objeto do
tipo ILookup<TKey,TElement>.
Properties
Count
Count
Obtém o número de pares da coleção chave-valor no ILookup<TKey,TElement>.
Item[TKey]
Item[TKey]
Obtém o sequência de valores IEnumerable<T> indexados por uma chave especificada.
Methods
Contains(TKey)
Contains(TKey)
Determina se uma chave especificada existe no ILookup<TKey,TElement>.

ILookup<TKey,TElement>.Contains ILookup<TKey,
TElement>.Contains
I n this Article
Determina se uma chave especificada existe no ILookup<TKey,TElement>.
public bool Contains (TKey key);

abstract member Contains : 'Key -> bool
Parameters
key TKey TKey
Uma chave pela qual pesquisar no ILookup<TKey,TElement>.
Returns
Boolean Boolean
true se key estiver no ILookup<TKey,TElement>; caso contrário, false .
ILookup<TKey,TElement>.Count ILookup<TKey,
TElement>.Count
I n this Article
Obtém o número de pares da coleção chave-valor no ILookup<TKey,TElement>.
public int Count { get; }

member this.Count : int
Returns
Int32 Int32
O número de pares chave/valor da coleção no ILookup<TKey,TElement>.
ILookup<TKey,TElement>.Item[TKey] ILookup<TKey,
TElement>.Item[TKey]
I n this Article
Obtém o sequência de valores IEnumerable<T> indexados por uma chave especificada.
public System.Collections.Generic.IEnumerable<TElement> this[TKey key] { get; }

member this.Item('Key) : seq<'Element>
Parameters
key TKey TKey
A chave da sequência de valores desejada.
Returns
IEnumerable<TElement>
A sequência de valores IEnumerable<T> indexados pela chave especificada.
ImmutableArrayExtensions ImmutableArrayExtensions
Class
Substituições de método de extensão LINQ que oferecem maior eficiência para ImmutableArray<T> que os métodos
LINQ padrão Pacote NuGet: System.Collections.Immutable (sobre coleções imutáveis e como instalá-las)
D eclaration
public static class ImmutableArrayExtensions
type ImmutableArrayExtensions = class
Object Object
Methods
Aggregate<T>(ImmutableArray<T>, Func<T,T,T>)
Aplica uma função a uma sequência de elementos de uma maneira cumulativa.
Aggregate<TAccumulate,T>(ImmutableArray<T>, TAccumulate, Func<TAccumulate,T,TAccumulate>)

Aggregate<TAccumulate,T>(ImmutableArray<T>, TAccumulate, Func<TAccumulate,T,TAccumulate>)
Aggregate<TAccumulate,TResult,T>(ImmutableArray<T>, TAccumulate, Func<TAccumulate,T,TAccumulate>,

Aggregate<TAccumulate,TResult,T>(ImmutableArray<T>, TAccumulate, Func<TAccumulate,T,TAccumulate>,
All<T>(ImmutableArray<T>, Func<T,Boolean>)
All<T>(ImmutableArray<T>, Func<T,Boolean>)
Obtém um valor que indica se todos os elementos nesta matriz correspondem a uma determinada condição.
Any<T>(ImmutableArray<T>)
Obtém um valor que indica se a matriz contém elementos.
Retorna um valor que indica se esta coleção contém quaisquer elementos.

Any<T>(ImmutableArray<T>, Func<T,Boolean>)
Any<T>(ImmutableArray<T>, Func<T,Boolean>)
Obtém um valor que indica se a matriz contém elementos correspondentes a uma condição especificada.
ElementAt<T>(ImmutableArray<T>, Int32)
ElementAt<T>(ImmutableArray<T>, Int32)
Retorna o elemento de um índice especificado na matriz.
ElementAtOrDefault<T>(ImmutableArray<T>, Int32)
ElementAtOrDefault<T>(ImmutableArray<T>, Int32)
intervalo.
First<T>(ImmutableArray<T>)
Retorna o primeiro elemento em uma matriz.
Retorna o primeiro elemento na coleção.
First<T>(ImmutableArray<T>, Func<T,Boolean>)
First<T>(ImmutableArray<T>, Func<T,Boolean>)
FirstOrDefault<T>(ImmutableArray<T>)
Retorna o primeiro elemento na coleção ou o valor padrão, se a coleção está vazia.
FirstOrDefault<T>(ImmutableArray<T>, Func<T,Boolean>)
Retorna o primeiro elemento da sequência que satisfaz uma condição ou um valor padrão, caso esse elemento
Last<T>(ImmutableArray<T>)
Retorna o último elemento na coleção.
Last<T>(ImmutableArray<T>, Func<T,Boolean>)
Last<T>(ImmutableArray<T>, Func<T,Boolean>)
Retorna o último elemento da matriz.
LastOrDefault<T>(ImmutableArray<T>)
Retorna o último elemento na coleção, ou o valor padrão se a coleção está vazia.
LastOrDefault<T>(ImmutableArray<T>, Func<T,Boolean>)
Select<T,TResult>(ImmutableArray<T>, Func<T,TResult>)
Select<T,TResult>(ImmutableArray<T>, Func<T,TResult>)
SelectMany<TSource,TCollection,TResult>(ImmutableArray<TSource>,
Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)
SelectMany<TSource,TCollection,TResult>(ImmutableArray<TSource>,
Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)
SequenceEqual<TDerived,TBase>(ImmutableArray<TBase>, IEnumerable<TDerived>, IEqualityComparer<TBase>)
SequenceEqual<TDerived,TBase>(ImmutableArray<TBase>, IEnumerable<TDerived>, IEqualityComparer<TBase>)
Determina se duas sequências são iguais de acordo com um comparador de igualdade.
SequenceEqual<TDerived,TBase>(ImmutableArray<TBase>, ImmutableArray<TDerived>,
IEqualityComparer<TBase>)
IEqualityComparer<TBase>)
Func<TBase,TBase,Boolean>)
Func<TBase,TBase,Boolean>)
Single<T>(ImmutableArray<T>)
Single<T>(ImmutableArray<T>)
sequência.
Single<T>(ImmutableArray<T>, Func<T,Boolean>)
Single<T>(ImmutableArray<T>, Func<T,Boolean>)
SingleOrDefault<T>(ImmutableArray<T>)
SingleOrDefault<T>(ImmutableArray<T>)
Retorna o único elemento da matriz ou um valor padrão se a sequência é vazia; esse método gera uma exceção se
há mais de um elemento na sequência.
SingleOrDefault<T>(ImmutableArray<T>, Func<T,Boolean>)
ToArray<T>(ImmutableArray<T>)
ToArray<T>(ImmutableArray<T>)
Copia o conteúdo dessa matriz para uma matriz mutável.

ToDictionary<TKey,T>(ImmutableArray<T>, Func<T,TKey>)
Cria um dicionário com base no conteúdo desta matriz.
ToDictionary<TKey,T>(ImmutableArray<T>, Func<T,TKey>, IEqualityComparer<TKey>)

ToDictionary<TKey,T>(ImmutableArray<T>, Func<T,TKey>, IEqualityComparer<TKey>)
ToDictionary<TKey,TElement,T>(ImmutableArray<T>, Func<T,TKey>, Func<T,TElement>,

ToDictionary<TKey,TElement,T>(ImmutableArray<T>, Func<T,TKey>, Func<T,TElement>,
ToDictionary<TKey,TElement,T>(ImmutableArray<T>, Func<T,TKey>, Func<T,TElement>)

ToDictionary<TKey,TElement,T>(ImmutableArray<T>, Func<T,TKey>, Func<T,TElement>)
Where<T>(ImmutableArray<T>, Func<T,Boolean>)
Where<T>(ImmutableArray<T>, Func<T,Boolean>)

ImmutableArrayExtensions.Aggregate ImmutableArray
Extensions.Aggregate
I n this Article
Overloads
Aggregate<T>(ImmutableArray<T>, Func<T,T,T>) Aplica uma função a uma sequência de elementos de uma
maneira cumulativa.
Aggregate<TAccumulate,T>(ImmutableArray<T>,
TAccumulate, Func<TAccumulate,T,TAccumulate>) Aplica uma função a uma sequência de elementos de uma
Aggregate<TAccumulate,T>(ImmutableArray<T>, maneira cumulativa.
TAccumulate, Func<TAccumulate,T,TAccumulate>)
Aggregate<TAccumulate,TResult,T>(ImmutableArray<T>,
TAccumulate, Func<TAccumulate,T,TAccumulate>, Func< Aplica uma função a uma sequência de elementos de uma
TAccumulate,TResult>) Aggregate<TAccumulate,TResult,T>( maneira cumulativa.
ImmutableArray<T>, TAccumulate, Func<TAccumulate,T,
TAccumulate>, Func<TAccumulate,TResult>)
Aggregate<T>(ImmutableArray<T>, Func<T,T,T>) Aggregate<T>

(ImmutableArray<T>, Func<T,T,T>)
public static T Aggregate<T> (this System.Collections.Immutable.ImmutableArray<T> immutableArray,
Func<T,T,T> func);
static member Aggregate : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, 'T, 'T> -> 'T
Type Parameters
T
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
A coleção à qual aplicar a função.
func Func<T,T,T>
Uma função a ser invocada em cada elemento, de modo cumulativo.
Returns
TT
O valor final depois que a função cumulativa foi aplicada a todos os elementos.
Remarks
Aggregate método torna simples para executar um cálculo em uma sequência de valores. Esse método funciona
chamando func uma vez para cada elemento na origem. Cada vez func é chamado, Aggregate passa os dois o
elemento da sequência e um valor agregado (como o primeiro argumento para func). O valor da seed parâmetro é
usado como o valor de agregação inicial. O resultado de func substitui o valor agregado anterior. Aggregate Retorna o
resultado final da func .
Aggregate<TAccumulate,T>(ImmutableArray<T>, TAccumulate,
Func<TAccumulate,T,TAccumulate>) Aggregate<TAccumulate,T>
(ImmutableArray<T>, TAccumulate,
Func<TAccumulate,T,TAccumulate>)
public static TAccumulate Aggregate<TAccumulate,T> (this
System.Collections.Immutable.ImmutableArray<T> immutableArray, TAccumulate seed,
Func<TAccumulate,T,TAccumulate> func);
static member Aggregate : System.Collections.Immutable.ImmutableArray<'T> * 'Accumulate *
Func<'Accumulate, 'T, 'Accumulate> -> 'Accumulate
Type Parameters
TAccumulate
O tipo de valor acumulado.
T
Parameters
func Func<TAccumulate,T,TAccumulate>
Returns
Remarks
Aggregate<TAccumulate,TResult,T>(ImmutableArray<T>,
TAccumulate, Func<TAccumulate,T,TAccumulate>,
Func<TAccumulate,TResult>) Aggregate<TAccumulate,TResult,T>
(ImmutableArray<T>, TAccumulate,
Func<TAccumulate,T,TAccumulate>, Func<TAccumulate,TResult>)
public static TResult Aggregate<TAccumulate,TResult,T> (this

System.Collections.Immutable.ImmutableArray<T> immutableArray, TAccumulate seed,
Func<TAccumulate,T,TAccumulate> func, Func<TAccumulate,TResult> resultSelector);
static member Aggregate : System.Collections.Immutable.ImmutableArray<'T> * 'Accumulate *
Func<'Accumulate, 'T, 'Accumulate> * Func<'Accumulate, 'Result> -> 'Result
Type Parameters
TAccumulate
O tipo de valor acumulado.
TResult
O tipo de resultado retornado pelo seletor de resultado.
T
Parameters
func Func<TAccumulate,T,TAccumulate>
Returns
TResult TResult
Remarks
ImmutableArrayExtensions.All ImmutableArray
Extensions.All
I n this Article
Obtém um valor que indica se todos os elementos nesta matriz correspondem a uma determinada condição.
public static bool All<T> (this System.Collections.Immutable.ImmutableArray<T> immutableArray,

Func<T,bool> predicate);
static member All : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, bool> -> bool
Type Parameters
T
Parameters
A matriz na qual verificar se há correspondências.
predicate Func<T,Boolean>
O predicado.
Returns
Boolean Boolean
true se todos os elementos da sequência de origem forem aprovados no teste no predicado especificado; caso
contrário, false .
ImmutableArrayExtensions.Any ImmutableArray
Extensions.Any
I n this Article
Overloads
Any<T>(ImmutableArray<T>) Any<T>(ImmutableArray<T>)
Retorna um valor que indica se esta coleção contém quaisquer
elementos.
Any<T>(ImmutableArray<T>, Func<T,Boolean>) Any<T>(

ImmutableArray<T>, Func<T,Boolean>) Obtém um valor que indica se a matriz contém elementos
correspondentes a uma condição especificada.
public static bool Any<T> (this System.Collections.Immutable.ImmutableArray<T> immutableArray);
static member Any : System.Collections.Immutable.ImmutableArray<'T> -> bool
Type Parameters
T
Parameters
A matriz na qual verificar se há elementos.
Returns
Boolean Boolean
true se a matriz contém elementos; caso contrário, false .
Retorna um valor que indica se esta coleção contém quaisquer elementos.
public static bool Any<T> (this System.Collections.Immutable.ImmutableArray<T>.Builder builder);
static member Any : System.Collections.Immutable.ImmutableArray<'T>.Builder -> bool
Type Parameters
T
O tipo dos elementos na matriz.
Parameters
builder ImmutableArray<T>.Builder
O construtor no qual verificar se há correspondências.
Returns
Boolean Boolean
true se o construtor da matriz contiver elementos; caso contrário, false .
Any<T>(ImmutableArray<T>, Func<T,Boolean>) Any<T>

(ImmutableArray<T>, Func<T,Boolean>)
Obtém um valor que indica se a matriz contém elementos correspondentes a uma condição especificada.
public static bool Any<T> (this System.Collections.Immutable.ImmutableArray<T> immutableArray,
static member Any : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, bool> -> bool
Type Parameters
T
Parameters
A matriz na qual verificar se há elementos.
O delegado que define a condição para corresponder a um elemento.
Returns
Boolean Boolean
true se um elemento corresponder à condição especificada; caso contrário, false .
ImmutableArrayExtensions.ElementAt ImmutableArray
Extensions.ElementAt
I n this Article
Retorna o elemento de um índice especificado na matriz.
public static T ElementAt<T> (this System.Collections.Immutable.ImmutableArray<T> immutableArray,

int index);
static member ElementAt : System.Collections.Immutable.ImmutableArray<'T> * int -> 'T
Type Parameters
T
Parameters
A matriz na qual localizar um elemento.
index Int32 Int32
O índice do elemento a se recuperar.
Returns
TT
O item no índice especificado.
ImmutableArrayExtensions.ElementAtOrDefault
ImmutableArrayExtensions.ElementAtOrDefault
I n this Article
intervalo.
public static T ElementAtOrDefault<T> (this System.Collections.Immutable.ImmutableArray<T>
immutableArray, int index);
static member ElementAtOrDefault : System.Collections.Immutable.ImmutableArray<'T> * int -> 'T
Type Parameters
T
Parameters
A matriz na qual localizar um elemento.
index Int32 Int32
O índice do elemento a se recuperar.
Returns
TT
O item no índice especificado ou o valor padrão se o índice não for encontrado.
ImmutableArrayExtensions.First ImmutableArray
Extensions.First
I n this Article
Overloads
First<T>(ImmutableArray<T>) First<T>(ImmutableArray<T>)
First<T>(ImmutableArray<T>, Func<T,Boolean>) First<T>(

ImmutableArray<T>, Func<T,Boolean>) Retorna o primeiro elemento em uma sequência que satisfaz
uma condição especificada.
public static T First<T> (this System.Collections.Immutable.ImmutableArray<T> immutableArray);
static member First : System.Collections.Immutable.ImmutableArray<'T> -> 'T
Type Parameters
T
Parameters
A matriz da qual obter um item.
Returns
TT
O primeiro item na matriz.
Exceptions
Se a matriz está vazia.
public static T First<T> (this System.Collections.Immutable.ImmutableArray<T>.Builder builder);
static member First : System.Collections.Immutable.ImmutableArray<'T>.Builder -> 'T
Type Parameters
T
O tipo de itens na matriz.
Parameters
O construtor do qual recuperar um item.
Returns
TT
O primeiro item na lista.
Exceptions
First<T>(ImmutableArray<T>, Func<T,Boolean>) First<T>

public static T First<T> (this System.Collections.Immutable.ImmutableArray<T> immutableArray,

static member First : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, bool> -> 'T
Type Parameters
T
Parameters
A matriz da qual obter um item.
O delegado que define as condições do elemento a ser pesquisado.
Returns
TT
O primeiro item na lista se ele atende à condição especificada por predicate .
Exceptions
ImmutableArrayExtensions.FirstOrDefault Immutable
ArrayExtensions.FirstOrDefault
I n this Article
Overloads
FirstOrDefault<T>(ImmutableArray<T>) FirstOrDefault<T>(
ImmutableArray<T>) Retorna o primeiro elemento de uma sequência ou um valor
FirstOrDefault<T>(ImmutableArray<T>) FirstOrDefault<T>(
ImmutableArray<T>) Retorna o primeiro elemento na coleção ou o valor padrão, se
a coleção está vazia.
FirstOrDefault<T>(ImmutableArray<T>, Func<T,Boolean>) Retorna o primeiro elemento da sequência que satisfaz uma
condição ou um valor padrão, caso esse elemento não seja
encontrado.
FirstOrDefault<T>(ImmutableArray<T>) FirstOrDefault<T>
(ImmutableArray<T>)
public static T FirstOrDefault<T> (this System.Collections.Immutable.ImmutableArray<T>
immutableArray);
static member FirstOrDefault : System.Collections.Immutable.ImmutableArray<'T> -> 'T
Type Parameters
T
Parameters
A matriz da qual recuperar itens.
Returns
TT
O primeiro item na lista, se encontrado; caso contrário, o valor padrão para o tipo de item.
FirstOrDefault<T>(ImmutableArray<T>) FirstOrDefault<T>
(ImmutableArray<T>)
Retorna o primeiro elemento na coleção ou o valor padrão, se a coleção está vazia.
public static T FirstOrDefault<T> (this System.Collections.Immutable.ImmutableArray<T>.Builder
builder);
static member FirstOrDefault : System.Collections.Immutable.ImmutableArray<'T>.Builder -> 'T
Type Parameters
T
O tipo de item no construtor.
Parameters
O construtor do qual recuperar um elemento.
Returns
TT
Retorna o primeiro elemento da sequência que satisfaz uma condição ou um valor padrão, caso esse elemento não seja
encontrado.
public static T FirstOrDefault<T> (this System.Collections.Immutable.ImmutableArray<T>
immutableArray, Func<T,bool> predicate);
static member FirstOrDefault : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, bool> ->
'T
Type Parameters
T
Parameters
A matriz da qual recuperar elementos.
Returns
TT
ImmutableArrayExtensions.Last ImmutableArray
Extensions.Last
I n this Article
Overloads
Last<T>(ImmutableArray<T>) Last<T>(ImmutableArray<T>)
Last<T>(ImmutableArray<T>, Func<T,Boolean>) Last<T>(

ImmutableArray<T>, Func<T,Boolean>) Retorna o último elemento de uma sequência que satisfaz
uma condição especificada.
public static T Last<T> (this System.Collections.Immutable.ImmutableArray<T>.Builder builder);
static member Last : System.Collections.Immutable.ImmutableArray<'T>.Builder -> 'T
Type Parameters
T
Parameters
O construtor do qual recuperar elementos.
Returns
TT
O último elemento no construtor.
Exceptions
Gerada se a coleção está vazia.
Last<T>(ImmutableArray<T>, Func<T,Boolean>) Last<T>

public static T Last<T> (this System.Collections.Immutable.ImmutableArray<T> immutableArray,
static member Last : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, bool> -> 'T
Type Parameters
T
Parameters
A matriz da qual recuperar elementos.
O delegado que define as condições do elemento a recuperar.
Returns
TT
O último elemento da matriz que satisfaz a condição predicate .
Exceptions
public static T Last<T> (this System.Collections.Immutable.ImmutableArray<T> immutableArray);

static member Last : System.Collections.Immutable.ImmutableArray<'T> -> 'T
Type Parameters
T
O tipo de elemento contido pela matriz.
Parameters
Returns
TT
O último elemento na matriz.
Exceptions
ImmutableArrayExtensions.LastOrDefault Immutable
ArrayExtensions.LastOrDefault
I n this Article
Overloads
LastOrDefault<T>(ImmutableArray<T>) LastOrDefault<T>(
ImmutableArray<T>) Retorna o último elemento de uma sequência ou um valor
LastOrDefault<T>(ImmutableArray<T>) LastOrDefault<T>(
ImmutableArray<T>) Retorna o último elemento na coleção, ou o valor padrão se a
coleção está vazia.
LastOrDefault<T>(ImmutableArray<T>, Func<T,Boolean>) Retorna o último elemento de uma sequência que satisfaz
uma condição ou um valor padrão, caso esse elemento não
seja encontrado.
LastOrDefault<T>(ImmutableArray<T>) LastOrDefault<T>
(ImmutableArray<T>)
public static T LastOrDefault<T> (this System.Collections.Immutable.ImmutableArray<T>
immutableArray);
static member LastOrDefault : System.Collections.Immutable.ImmutableArray<'T> -> 'T
Type Parameters
T
Parameters
Returns
TT
O último elemento de uma sequência ou um valor padrão se a sequência não contém elementos.
LastOrDefault<T>(ImmutableArray<T>) LastOrDefault<T>
(ImmutableArray<T>)
Retorna o último elemento na coleção, ou o valor padrão se a coleção está vazia.
public static T LastOrDefault<T> (this System.Collections.Immutable.ImmutableArray<T>.Builder
builder);
static member LastOrDefault : System.Collections.Immutable.ImmutableArray<'T>.Builder -> 'T
Type Parameters
T
Parameters
O construtor do qual recuperar um elemento.
Returns
TT
seja encontrado.
public static T LastOrDefault<T> (this System.Collections.Immutable.ImmutableArray<T>
static member LastOrDefault : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, bool> -> 'T
Type Parameters
T
Parameters
A matriz da qual recuperar um elemento.
Returns
TT
ImmutableArrayExtensions.Select ImmutableArray
Extensions.Select
I n this Article
public static System.Collections.Generic.IEnumerable<TResult> Select<T,TResult> (this

System.Collections.Immutable.ImmutableArray<T> immutableArray, Func<T,TResult> selector);
static member Select : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, 'Result> ->
seq<'Result>
Type Parameters
T
TResult
O tipo de elemento de resultado.
Parameters
A matriz imutável da qual selecionar itens.
selector Func<T,TResult> Func<T,TResult>
Returns
Um IEnumerable<T> cujos elementos são o resultado da invocação da função de transformação em cada elemento da
origem.
ImmutableArrayExtensions.SelectMany ImmutableArray
Extensions.SelectMany
I n this Article
SelectMany<TSource,TCollection,TResult> (this System.Collections.Immutable.ImmutableArray<TSource>
immutableArray, Func<TSource,System.Collections.Generic.IEnumerable<TCollection>>
collectionSelector, Func<TSource,TCollection,TResult> resultSelector);
static member SelectMany : System.Collections.Immutable.ImmutableArray<'Source> * Func<'Source,
seq<'Collection>> * Func<'Source, 'Collection, 'Result> -> seq<'Result>
Type Parameters
TSource
O tipo dos elementos de immutableArray .
TCollection
TResult
Parameters
immutableArray ImmutableArray<TSource>
A matriz imutável.
Uma função de transformação a ser aplicada a cada elemento da sequência de entrada.
Returns
collectionSelector em cada elemento de immutableArray e, em seguida, mapear cada um desses elementos de
sequência e seu elemento de origem correspondente para um elemento de resultado.
ImmutableArrayExtensions.SequenceEqual Immutable
ArrayExtensions.SequenceEqual
I n this Article
Overloads
SequenceEqual<TDerived,TBase>(ImmutableArray<TBase>,
IEnumerable<TDerived>, IEqualityComparer<TBase>) Determina se duas sequências são iguais de acordo com um
SequenceEqual<TDerived,TBase>(ImmutableArray<TBase>, comparador de igualdade.
IEnumerable<TDerived>, IEqualityComparer<TBase>)
ImmutableArray<TDerived>, IEqualityComparer<TBase>) Determina se duas sequências são iguais de acordo com um
ImmutableArray<TDerived>, IEqualityComparer<TBase>)
ImmutableArray<TDerived>, Func<TBase,TBase,Boolean>) Determina se duas sequências são iguais de acordo com um
ImmutableArray<TDerived>, Func<TBase,TBase,Boolean>)
public static bool SequenceEqual<TDerived,TBase> (this

System.Collections.Immutable.ImmutableArray<TBase> immutableArray,
System.Collections.Generic.IEnumerable<TDerived> items,
System.Collections.Generic.IEqualityComparer<TBase> comparer = null) where TDerived : TBase;
static member SequenceEqual : System.Collections.Immutable.ImmutableArray<'Base> * seq<#'Base> *
System.Collections.Generic.IEqualityComparer<'Base> -> bool
Type Parameters
TDerived
O tipo de elemento da matriz comparado.
TBase
Parameters
immutableArray ImmutableArray<TBase>
A matriz a ser usada para comparação.
items IEnumerable<TDerived>
Os itens a serem usados para comparação.
comparer IEqualityComparer<TBase>
O comparador a ser usado para verificar quanto à igualdade.
Returns
Boolean Boolean
true para indicar que as sequências são iguais; caso contrário, false .

System.Collections.Immutable.ImmutableArray<TDerived> items,
System.Collections.Generic.IEqualityComparer<TBase> comparer = null) where TDerived : TBase;
static member SequenceEqual : System.Collections.Immutable.ImmutableArray<'Base> *
System.Collections.Immutable.ImmutableArray<#'Base> *
System.Collections.Generic.IEqualityComparer<'Base> -> bool
Type Parameters
TDerived
TBase
Parameters
items ImmutableArray<TDerived>
comparer IEqualityComparer<TBase>
Returns
Boolean Boolean

System.Collections.Immutable.ImmutableArray<TDerived> items, Func<TBase,TBase,bool> predicate) where
TDerived : TBase;
static member SequenceEqual : System.Collections.Immutable.ImmutableArray<'Base> *
System.Collections.Immutable.ImmutableArray<#'Base> * Func<'Base, 'Base, bool> -> bool
Type Parameters
TDerived
TBase
Parameters
items ImmutableArray<TDerived>
predicate Func<TBase,TBase,Boolean>
Returns
Boolean Boolean
ImmutableArrayExtensions.Single ImmutableArray
Extensions.Single
I n this Article
Overloads
Single<T>(ImmutableArray<T>) Single<T>(ImmutableArray<
T>) Retornará o único elemento de uma sequência e lançará uma
sequência.
Single<T>(ImmutableArray<T>, Func<T,Boolean>) Single<T>(

ImmutableArray<T>, Func<T,Boolean>) Retorna o único elemento de uma sequência que satisfaz uma
condição especificada e gera uma exceção se houver mais de
um tal elemento.
Single<T>(ImmutableArray<T>) Single<T>(ImmutableArray<T>)
sequência.
public static T Single<T> (this System.Collections.Immutable.ImmutableArray<T> immutableArray);
static member Single : System.Collections.Immutable.ImmutableArray<'T> -> 'T
Type Parameters
T
Parameters
A matriz da qual recuperar o elemento.
Returns
TT
O elemento na sequência.
Single<T>(ImmutableArray<T>, Func<T,Boolean>) Single<T>

public static T Single<T> (this System.Collections.Immutable.ImmutableArray<T> immutableArray,
static member Single : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, bool> -> 'T
Type Parameters
T
Parameters
Returns
TT
Retorna Boolean.
ImmutableArrayExtensions.SingleOrDefault Immutable
ArrayExtensions.SingleOrDefault
I n this Article
Overloads
SingleOrDefault<T>(ImmutableArray<T>) SingleOrDefault<
T>(ImmutableArray<T>) Retorna o único elemento da matriz ou um valor padrão se a
sequência é vazia; esse método gera uma exceção se há mais
de um elemento na sequência.
SingleOrDefault<T>(ImmutableArray<T>, Func<T,Boolean>) Retorna o único elemento de uma sequência que satisfaz uma
condição especificada ou um valor padrão se esse elemento
não existir. Esse método lança uma exceção se mais de um
SingleOrDefault<T>(ImmutableArray<T>) SingleOrDefault<T>
(ImmutableArray<T>)
Retorna o único elemento da matriz ou um valor padrão se a sequência é vazia; esse método gera uma exceção se há
mais de um elemento na sequência.
public static T SingleOrDefault<T> (this System.Collections.Immutable.ImmutableArray<T>
immutableArray);
static member SingleOrDefault : System.Collections.Immutable.ImmutableArray<'T> -> 'T
Type Parameters
T
Parameters
A matriz.
Returns
TT
O elemento da matriz ou o valor padrão, se a matriz está vazia.
Exceptions
source contém mais de um elemento.
public static T SingleOrDefault<T> (this System.Collections.Immutable.ImmutableArray<T>
static member SingleOrDefault : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, bool> ->
'T
Type Parameters
T
Parameters
A matriz da qual obter o elemento.
A condição que o elemento deve satisfazer.
Returns
TT
O elemento, se ele atende à condição especificada; caso contrário, o elemento padrão.
Exceptions
ImmutableArrayExtensions.ToArray ImmutableArray
Extensions.ToArray
I n this Article
Copia o conteúdo dessa matriz para uma matriz mutável.
public static T[] ToArray<T> (this System.Collections.Immutable.ImmutableArray<T> immutableArray);

static member ToArray : System.Collections.Immutable.ImmutableArray<'T> -> 'T[]
Type Parameters
T
Parameters
Returns
T[]
A matriz recém-instanciada.
ImmutableArrayExtensions.ToDictionary ImmutableArray
Extensions.ToDictionary
I n this Article
Overloads
ToDictionary<TKey,T>(ImmutableArray<T>, Func<T,TKey>) To
Dictionary<TKey,T>(ImmutableArray<T>, Func<T,TKey>) Cria um dicionário com base no conteúdo desta matriz.
ToDictionary<TKey,T>(ImmutableArray<T>, Func<T,TKey>,
IEqualityComparer<TKey>) ToDictionary<TKey,T>(Immutable Cria um dicionário com base no conteúdo desta matriz.
Array<T>, Func<T,TKey>, IEqualityComparer<TKey>)
ToDictionary<TKey,TElement,T>(ImmutableArray<T>, Func<T,
TKey>, Func<T,TElement>, IEqualityComparer<TKey>) To Cria um dicionário com base no conteúdo desta matriz.
Dictionary<TKey,TElement,T>(ImmutableArray<T>, Func<T,
TKey>, Func<T,TElement>, IEqualityComparer<TKey>)
ToDictionary<TKey,TElement,T>(ImmutableArray<T>, Func<T,
TKey>, Func<T,TElement>) ToDictionary<TKey,TElement,T>( Cria um dicionário com base no conteúdo desta matriz.
ImmutableArray<T>, Func<T,TKey>, Func<T,TElement>)
public static System.Collections.Generic.Dictionary<TKey,T> ToDictionary<TKey,T> (this
System.Collections.Immutable.ImmutableArray<T> immutableArray, Func<T,TKey> keySelector);
static member ToDictionary : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, 'Key> ->
System.Collections.Generic.Dictionary<'Key, 'T>
Type Parameters
TKey
Tipo da chave.
T
Parameters
A matriz com base na qual criar um dicionário.
keySelector Func<T,TKey>
O seletor de chave.
Returns
Dictionary<TKey,T>
O dicionário recentemente inicializado.
ToDictionary<TKey,T>(ImmutableArray<T>, Func<T,TKey>,
IEqualityComparer<TKey>) ToDictionary<TKey,T>
(ImmutableArray<T>, Func<T,TKey>, IEqualityComparer<TKey>)
public static System.Collections.Generic.Dictionary<TKey,T> ToDictionary<TKey,T> (this
System.Collections.Immutable.ImmutableArray<T> immutableArray, Func<T,TKey> keySelector,
static member ToDictionary : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, 'Key> *
'T>
Type Parameters
TKey
Tipo da chave.
T
Parameters
O seletor de chave.
O comparador com o qual inicializar o dicionário.
Returns
Dictionary<TKey,T>
ToDictionary<TKey,TElement,T>(ImmutableArray<T>,
Func<T,TKey>, Func<T,TElement>, IEqualityComparer<TKey>)
Func<T,TKey>, Func<T,TElement>, IEqualityComparer<TKey>)
public static System.Collections.Generic.Dictionary<TKey,TElement> ToDictionary<TKey,TElement,T>

(this System.Collections.Immutable.ImmutableArray<T> immutableArray, Func<T,TKey> keySelector,
Func<T,TElement> elementSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer);
Func<'T, 'Element> * System.Collections.Generic.IEqualityComparer<'Key> ->
Type Parameters
TKey
Tipo da chave.
TElement
O tipo do elemento.
T
Parameters
O seletor de chave.
elementSelector Func<T,TElement>
O seletor de elemento.
O comparador com o qual inicializar o dicionário.
Returns
Func<T,TKey>, Func<T,TElement>)
Func<T,TKey>, Func<T,TElement>)
public static System.Collections.Generic.Dictionary<TKey,TElement> ToDictionary<TKey,TElement,T>

(this System.Collections.Immutable.ImmutableArray<T> immutableArray, Func<T,TKey> keySelector,
Func<T,TElement> elementSelector);
Func<'T, 'Element> -> System.Collections.Generic.Dictionary<'Key, 'Element>
Type Parameters
TKey
Tipo da chave.
TElement
O tipo do elemento.
T
Parameters
O seletor de chave.
elementSelector Func<T,TElement>
O seletor de elemento.
Returns
ImmutableArrayExtensions.Where ImmutableArray
Extensions.Where
I n this Article
public static System.Collections.Generic.IEnumerable<T> Where<T> (this

System.Collections.Immutable.ImmutableArray<T> immutableArray, Func<T,bool> predicate);
static member Where : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, bool> -> seq<'T>
Type Parameters
T
Parameters
A matriz a filtrar.
A condição a ser usada para filtrar o conteúdo da matriz.
Returns
IEnumerable<T> IEnumerable<T>
Retorna IEnumerable<T>, que contém elementos que atendem à condição.
IOrderedEnumerable<TElement> IOrderedEnumerable<
TElement> Interface
Representa uma sequência classificada.
D eclaration
public interface IOrderedEnumerable<TElement> : System.Collections.Generic.IEnumerable<TElement>
type IOrderedEnumerable<'Element> = interface
interface seq<'Element>
None
Remarks
Esse tipo é enumerável, porque ele herda de IEnumerable<T>.
Os métodos de extensão ThenBy e ThenByDescending operam em objetos do tipo IOrderedEnumerable<TElement>.
Um objeto do tipo IOrderedEnumerable<TElement> pode ser obtido chamando um dos métodos de classificação
primária OrderBy ou OrderByDescending, que retornarão um IOrderedEnumerable<TElement>. ThenBy e
ThenByDescending, os métodos de classificação subordinada, por sua vez também retornam um objeto do tipo
IOrderedEnumerable<TElement>. Esse design permite que qualquer número de chamadas consecutivas para ThenBy
ou ThenByDescending, em que cada chamada executa uma ordenação subordinada os dados classificados retornados
da chamada anterior.
Methods
CreateOrderedEnumerable<TKey>(Func<TElement,TKey>, IComparer<TKey>, Boolean)
CreateOrderedEnumerable<TKey>(Func<TElement,TKey>, IComparer<TKey>, Boolean)
Executa uma ordenação subsequente nos elementos de uma IOrderedEnumerable<TElement> de acordo com
uma chave.
IOrderedEnumerable<TElement>.CreateOrdered
Enumerable IOrderedEnumerable<TElement>.Create
OrderedEnumerable
I n this Article
Executa uma ordenação subsequente nos elementos de uma IOrderedEnumerable<TElement> de acordo com uma
chave.
public System.Linq.IOrderedEnumerable<TElement> CreateOrderedEnumerable<TKey> (Func<TElement,TKey>

keySelector, System.Collections.Generic.IComparer<TKey> comparer, bool descending);
abstract member CreateOrderedEnumerable : Func<'Element, 'Key> *
System.Collections.Generic.IComparer<'Key> * bool -> System.Linq.IOrderedEnumerable<'Element>
Type Parameters
TKey
O tipo da chave produzida por keySelector .
Parameters
keySelector Func<TElement,TKey>
O Func<T,TResult> usado para extrair a chave de cada elemento.
O IComparer<T> usado para comparar chaves para posicionamento na sequência retornada.
descending Boolean Boolean
true para classificar os elementos em ordem decrescente; false para classificar os elementos em ordem crescente.
Returns
IOrderedEnumerable<TElement> IOrderedEnumerable<TElement>
Examples
O exemplo de código a seguir demonstra como usar CreateOrderedEnumerable para executar uma classificação
secundária em um IOrderedEnumerable<TElement>.
// Create an array of strings to sort.
string[] fruits = { "apricot", "orange", "banana", "mango", "apple", "grape", "strawberry" };
// First sort the strings by their length.
IOrderedEnumerable<string> sortedFruits2 =
fruits.OrderBy(fruit => fruit.Length);
// Secondarily sort the strings alphabetically, using the default comparer.
IOrderedEnumerable<string> sortedFruits3 =
sortedFruits2.CreateOrderedEnumerable<string>(
fruit => fruit,
Comparer<string>.Default, false);
// Output the resulting sequence of strings.

foreach (string fruit in sortedFruits3)

//
// apple
// grape
// mango
// banana
// orange
// apricot
// strawberry
Remarks
A funcionalidade fornecida por este método é como o fornecido pelo ThenBy ou ThenByDescending, dependendo de
se descending é true ou false . Ambos os realizam uma ordenação subordinada de uma sequência já classificada do
tipo IOrderedEnumerable<TElement>.
IOrderedQueryable IOrderedQueryable Interface
D eclaration
public interface IOrderedQueryable : System.Collections.IEnumerable, System.Linq.IQueryable
type IOrderedQueryable = interface
None
Remarks
O IOrderedQueryable interface destina-se para implementação pelos provedores de consulta.
Essa interface representa o resultado de uma consulta de classificação que chama os métodos OrderBy,
OrderByDescending, ThenBy ou ThenByDescending. Quando CreateQuery é chamado e passado a uma árvore de
expressão que representa uma consulta de classificação resultante IQueryable objeto deve ser de um tipo que
implementa IOrderedQueryable.
Para obter mais informações sobre como criar seu próprio provedor LINQ, consulte LINQ: Criando um provedor
IQueryable em Blogs do MSDN.
IOrderedQueryable<T> IOrderedQueryable<T>
Interface
D eclaration
public interface IOrderedQueryable<out T> : System.Collections.Generic.IEnumerable<out T>,
System.Linq.IOrderedQueryable, System.Linq.IQueryable<out T>
type IOrderedQueryable<'T> = interface
interface IQueryable<'T>
interface IOrderedQueryable
interface seq<'T>
None
Remarks
O IOrderedQueryable<T> interface destina-se para implementação pelos provedores de consulta.
Essa interface representa o resultado de uma consulta de classificação que chama os métodos OrderBy,
OrderByDescending, ThenBy ou ThenByDescending. Quando CreateQuery<TElement>(Expression) é chamado e
passado a uma árvore de expressão que representa uma consulta de classificação resultante IQueryable<T> objeto
deve ser de um tipo que implementa IOrderedQueryable<T>.
See Also
IQueryable<T> IQueryable<T>
IQueryable IQueryable Interface
Fornece a funcionalidade para avaliar as consultas em uma fonte de dados específica no qual o tipo de dado não foi
especificado.
D eclaration
public interface IQueryable : System.Collections.IEnumerable
type IQueryable = interface
None
Remarks
O IQueryable interface destina-se para implementação pelos provedores de consulta. Ele só deverá ser implementado
por provedores que também implementam IQueryable<T>. Se o provedor não implementa também IQueryable<T>,
operadores de consulta padrão não podem ser usados na fonte de dados do provedor.
O IQueryable interface herda o IEnumerable interface para que se ele representa uma consulta, os resultados da
consulta podem ser enumerados. Enumeração faz com que a árvore de expressão associada com um IQueryable
objeto a ser executado. A definição de "execução de uma árvore de expressão" é específica para um provedor de
consultas. Por exemplo, ele pode envolver a converter a árvore de expressão para uma linguagem de consulta
apropriada para a fonte de dados subjacente. As consultas que não retornam resultados enumeráveis são executadas
quando o Execute método é chamado.
Properties
ElementType
ElementType
Obtém o tipo de elemento que é retornado quando a árvore de expressão associada a esta instância do
IQueryable é executada.
Expression
Expression
Obtém a árvore de expressão que é associada à instância de IQueryable.
Provider
Provider
Obtém o provedor de consulta associado esta fonte de dados.

IQueryable.ElementType IQueryable.ElementType
I n this Article
Obtém o tipo de elemento que é retornado quando a árvore de expressão associada a esta instância do IQueryable é
executada.
public Type ElementType { get; }

member this.ElementType : Type
Returns
Type Type
Um Type que representa o tipo de elemento que é retornado quando a árvore de expressão associada a este objeto é
executada.
Remarks
O ElementType propriedade representa o "T" em IQueryable<T> ou IQueryable(Of T) .
IQueryable.Expression IQueryable.Expression
I n this Article
Obtém a árvore de expressão que é associada à instância de IQueryable.
public System.Linq.Expressions.Expression Expression { get; }
member this.Expression : System.Linq.Expressions.Expression
Returns
Expression Expression
A Expression associada a essa instância de IQueryable.
Remarks
Se uma instância do IQueryable representa um LINQ consulta em uma fonte de dados, a árvore de expressão
associada representa a consulta.
IQueryable.Provider IQueryable.Provider
I n this Article
Obtém o provedor de consulta associado esta fonte de dados.
public System.Linq.IQueryProvider Provider { get; }
member this.Provider : System.Linq.IQueryProvider
Returns
IQueryProvider IQueryProvider
A IQueryProvider associado a essa fonte de dados.
Remarks
Se uma instância do IQueryable representa uma LINQ consulta em uma fonte de dados, o provedor de consulta
associado é o provedor que criou o IQueryable instância.
IQueryable<T> IQueryable<T> Interface
Fornece a funcionalidade para avaliar as consultas em uma fonte de dados específica no qual o tipo de dado é
conhecido.
D eclaration
public interface IQueryable<out T> : System.Collections.Generic.IEnumerable<out T>,
System.Linq.IQueryable
type IQueryable<'T> = interface
interface seq<'T>
None
Remarks
O IQueryable<T> interface destina-se para implementação pelos provedores de consulta.
Essa interface é herdada de IEnumerable<T> interface para que se ele representa uma consulta, os resultados da
consulta podem ser enumerados. Enumeração força a árvore de expressão associada com um IQueryable<T> objeto a
ser executado. As consultas que não retornam resultados enumeráveis são executadas quando o Execute<TResult>
(Expression) método é chamado.
A definição de "execução de uma árvore de expressão" é específica para um provedor de consultas. Por exemplo, ele
pode envolver a converter a árvore de expressão para uma linguagem de consulta apropriada para uma fonte de
dados subjacente.
O IQueryable<T> interface permite que as consultas ser polimórficas. Ou seja, porque uma consulta em relação a um
IQueryable fonte de dados é representada como uma árvore de expressão, ele pode ser executado em diferentes tipos
de fontes de dados.
O static ( Shared no Visual Basic) métodos definidos na classe Queryable (exceto AsQueryable, ThenBy, e
ThenByDescending) estender objetos de tipos que implementam o IQueryable<T> interface.
IQueryProvider IQueryProvider Interface
Define métodos para criar e executar consultas que são descritas por um objeto IQueryable.
D eclaration
public interface IQueryProvider
type IQueryProvider = interface
None
Remarks
O IQueryProvider interface destina-se para implementação pelos provedores de consulta.
Methods
CreateQuery(Expression)
CreateQuery(Expression)
Constrói um objeto IQueryable que pode avaliar a consulta representada por uma árvore de expressão
especificada.
CreateQuery<TElement>(Expression)
CreateQuery<TElement>(Expression)
Constrói um objeto IQueryable<T> que pode avaliar a consulta representada por uma árvore de expressão
especificada.
Execute(Expression)
Execute(Expression)
Executa a consulta representada por uma árvore de expressão especificada.
Execute<TResult>(Expression)
Execute<TResult>(Expression)
Executa a consulta fortemente tipada representada por uma árvore de expressão especificada.
See Also
IQueryable<T> IQueryable<T>
IQueryProvider.CreateQuery IQueryProvider.Create
Query
I n this Article
Overloads
CreateQuery(Expression) CreateQuery(Expression)
Constrói um objeto IQueryable que pode avaliar a consulta
representada por uma árvore de expressão especificada.
CreateQuery<TElement>(Expression) CreateQuery<
TElement>(Expression) Constrói um objeto IQueryable<T> que pode avaliar a
consulta representada por uma árvore de expressão
especificada.
CreateQuery(Expression) CreateQuery(Expression)
Constrói um objeto IQueryable que pode avaliar a consulta representada por uma árvore de expressão especificada.
public System.Linq.IQueryable CreateQuery (System.Linq.Expressions.Expression expression);
abstract member CreateQuery : System.Linq.Expressions.Expression -> System.Linq.IQueryable
Parameters
Uma árvore de expressão que representa uma consulta LINQ.
Returns
IQueryable IQueryable
Um objeto IQueryable que pode avaliar a consulta representada pela árvore de expressão especificada.
Remarks
Note
O Expression propriedade retornada IQueryable objeto é igual a expression .

O CreateQuery método é usado para criar um novo IQueryable objetos, dado uma árvore de expressão. A consulta
que é representada pelo objeto retornado é associada um provedor LINQ específico.
Vários dos métodos de operador de consulta padrão definidos no Queryable, como OfType e Cast, chamar este
método. Eles passá-lo um MethodCallExpression que representa um LINQ consulta.
CreateQuery<TElement>(Expression) CreateQuery<TElement>
(Expression)
Constrói um objeto IQueryable<T> que pode avaliar a consulta representada por uma árvore de expressão
especificada.
public System.Linq.IQueryable<TElement> CreateQuery<TElement> (System.Linq.Expressions.Expression
expression);
abstract member CreateQuery : System.Linq.Expressions.Expression -> System.Linq.IQueryable<'Element>
Type Parameters
TElement
O tipo dos elementos do IQueryable<T> que é retornado.
Parameters
Returns
IQueryable<TElement>
Um objeto IQueryable<T> que pode avaliar a consulta representada pela árvore de expressão especificada.
Remarks
Note
O Expression propriedade retornada IQueryable<T> objeto é igual a expression .
O CreateQuery método é usado para criar um novo IQueryable<T> objetos, dado uma árvore de expressão. A
consulta que é representada pelo objeto retornado é associada um provedor LINQ específico.
A maioria do Queryable métodos de operador de consulta padrão que retornam resultados enumeráveis chamam esse
método. Eles passá-lo um MethodCallExpression que representa um LINQ consulta.
IQueryProvider.Execute IQueryProvider.Execute
I n this Article
Overloads
Execute(Expression) Execute(Expression)
Executa a consulta representada por uma árvore de expressão
especificada.
Execute<TResult>(Expression) Execute<TResult>(Expression)
Executa a consulta fortemente tipada representada por uma
árvore de expressão especificada.
Execute(Expression) Execute(Expression)
Executa a consulta representada por uma árvore de expressão especificada.
public object Execute (System.Linq.Expressions.Expression expression);
abstract member Execute : System.Linq.Expressions.Expression -> obj
Parameters
Returns
Object Object
O valor resultante da execução da consulta especificada.
Remarks
O Execute método executa consultas que retornam um único valor (em vez de uma sequência enumerável de valores).
Árvores de expressão que representa as consultas que retornam resultados enumeráveis são executadas quando seus
respectivos IQueryable objeto é enumerado.
Execute<TResult>(Expression) Execute<TResult>(Expression)
Executa a consulta fortemente tipada representada por uma árvore de expressão especificada.
public TResult Execute<TResult> (System.Linq.Expressions.Expression expression);
abstract member Execute : System.Linq.Expressions.Expression -> 'Result
Type Parameters
TResult
O tipo do valor resultante da execução da consulta.
Parameters
Returns
TResult TResult
O valor resultante da execução da consulta especificada.
Remarks
O Execute método executa consultas que retornam um único valor (em vez de uma sequência enumerável de valores).
Árvores de expressão que representa as consultas que retornam resultados enumeráveis são executadas quando o
IQueryable<T> objeto que contém a árvore de expressão é enumerado.
O Queryable métodos de operador de consulta padrão que retornam a chamada de resultados de singleton Execute.
Eles passá-lo um MethodCallExpression que representa um LINQ consulta.
Lookup<TKey,TElement> Lookup<TKey,TElement> Class
Representa uma coleção de chaves, cada uma mapeada para um ou mais valores.
D eclaration
public class Lookup<TKey,TElement> :
System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey,TElement>>,
System.Linq.ILookup<TKey,TElement>
type Lookup<'Key, 'Element> = class
interface seq<IGrouping<'Key, 'Element>>
interface ILookup<'Key, 'Element>
Object Object
Remarks
Um Lookup<TKey,TElement> é semelhante a um Dictionary<TKey,TValue>. A diferença é que um
Dictionary<TKey,TValue> mapeia chaves para valores únicos, enquanto um Lookup<TKey,TElement> mapeia chaves
para coleções de valores.
Você pode criar uma instância de um Lookup<TKey,TElement> chamando ToLookup em um objeto que implementa
IEnumerable<T>.
Note
Não há nenhum construtor público para criar uma nova instância de um Lookup<TKey,TElement>. Além disso,
Lookup<TKey,TElement> objetos são imutáveis, ou seja, você não pode adicionar ou remover elementos ou chaves de
um Lookup<TKey,TElement> após ele ter sido criado do objeto.
Properties
Count
Count
Obtém o número de pares da coleção chave-valor no Lookup<TKey,TElement>.
Item[TKey]
Item[TKey]
Obtém a coleção de valores indexados pela chave especificada.
Methods
ApplyResultSelector<TResult>(Func<TKey,IEnumerable<TElement>,TResult>)
ApplyResultSelector<TResult>(Func<TKey,IEnumerable<TElement>,TResult>)
Aplica uma função de transformação a cada chave e seus valores associados e retorna os resultados.
Contains(TKey)
Contains(TKey)
Determina se uma chave especificada está no Lookup<TKey,TElement>.
GetEnumerator()
GetEnumerator()
Retorna um enumerador genérico que itera por Lookup<TKey,TElement>.
Retorna um enumerador que itera por meio de Lookup<TKey,TElement>. Essa classe não pode ser herdada.
Lookup<TKey,TElement>.ApplyResultSelector Lookup<
TKey,TElement>.ApplyResultSelector
I n this Article
Aplica uma função de transformação a cada chave e seus valores associados e retorna os resultados.
public System.Collections.Generic.IEnumerable<TResult> ApplyResultSelector<TResult>

(Func<TKey,System.Collections.Generic.IEnumerable<TElement>,TResult> resultSelector);
member this.ApplyResultSelector : Func<'Key, seq<'Element>, 'Result> -> seq<'Result>
Type Parameters
TResult
O tipo dos valores de resultado produzida por resultSelector .
Parameters
Uma função para projetar um valor de resultado de cada chave e seus valores associados.
Returns
Uma coleção que contém um valor para cada par da coleção chave-valor no Lookup<TKey,TElement>.
Lookup<TKey,TElement>.Contains Lookup<TKey,
TElement>.Contains
I n this Article
Determina se uma chave especificada está no Lookup<TKey,TElement>.
public bool Contains (TKey key);

abstract member Contains : 'Key -> bool
override this.Contains : 'Key -> bool
Parameters
key TKey TKey
A chave a ser localizada no Lookup<TKey,TElement>.
Returns
Boolean Boolean
true se key estiver no Lookup<TKey,TElement>; caso contrário, false .
Examples
O exemplo a seguir demonstra como usar Contains para determinar se um Lookup<TKey,TElement> contém uma
chave especificada. Este exemplo de código é parte de um exemplo maior fornecido para o Lookup<TKey,TElement>
classe.
// Determine if there is a key with the value 'G' in the Lookup.
bool hasG = lookup.Contains('G');
Lookup<TKey,TElement>.Count Lookup<TKey,
TElement>.Count
I n this Article
Obtém o número de pares da coleção chave-valor no Lookup<TKey,TElement>.
public int Count { get; }

member this.Count : int
Returns
Int32 Int32
O número de pares chave/valor da coleção no Lookup<TKey,TElement>.
Examples
O exemplo a seguir demonstra como usar Count para determinar o número de pares chave/valor da coleção em um
Lookup<TKey,TElement>. Este exemplo de código é parte de um exemplo maior fornecido para o
Lookup<TKey,TElement> classe.
// Get the number of key-collection pairs in the Lookup.

int count = lookup.Count;
Remarks
O valor da Count propriedade não muda, porque os itens não podem ser adicionados ou removidos de um
Lookup<TKey,TElement> após ele ter sido criado do objeto.
Lookup<TKey,TElement>.GetEnumerator Lookup<TKey,
TElement>.GetEnumerator
I n this Article
Retorna um enumerador genérico que itera por Lookup<TKey,TElement>.
public System.Collections.Generic.IEnumerator<System.Linq.IGrouping<TKey,TElement>> GetEnumerator

();
abstract member GetEnumerator : unit ->
System.Collections.Generic.IEnumerator<System.Linq.IGrouping<'Key, 'Element>>
override this.GetEnumerator : unit ->
System.Collections.Generic.IEnumerator<System.Linq.IGrouping<'Key, 'Element>>
Returns
IEnumerator<IGrouping<TKey,TElement>>
Um enumerador para o Lookup<TKey,TElement>.
Examples
O exemplo a seguir demonstra como usar GetEnumerator para iterar por meio de chaves e valores de um
Lookup<TKey,TElement>. Este exemplo de código é parte de um exemplo maior fornecido para o
Lookup<TKey,TElement> classe.
// Iterate through each IGrouping in the Lookup and output the contents.
foreach (IGrouping<char, string> packageGroup in lookup)
{
Console.WriteLine(packageGroup.Key);
// Iterate through each value in the IGrouping and print its value.
foreach (string str in packageGroup)
Console.WriteLine(" {0}", str);
}
Lookup<TKey,TElement>.IEnumerable.GetEnumerator
I n this Article
Retorna um enumerador que itera por meio de Lookup<TKey,TElement>. Essa classe não pode ser herdada.
Returns
IEnumerator
Um enumerador para o Lookup<TKey,TElement>.
Lookup<TKey,TElement>.Item[TKey] Lookup<TKey,
TElement>.Item[TKey]
I n this Article
Obtém a coleção de valores indexados pela chave especificada.
public System.Collections.Generic.IEnumerable<TElement> this[TKey key] { get; }

member this.Item('Key) : seq<'Element>
Parameters
key TKey TKey
A chave da coleção de valores desejada.
Returns
IEnumerable<TElement>
A coleção de valores indexada pela chave especificada.
Examples
O exemplo a seguir demonstra como usar Item[TKey] indexar diretamente em um Lookup<TKey,TElement>. Este
exemplo de código é parte de um exemplo maior fornecido para o Lookup<TKey,TElement> classe.
// Select a collection of Packages by indexing directly into the Lookup.
IEnumerable<string> cgroup = lookup['C'];
Remarks
Esta propriedade indexada fornece a capacidade de indexar um conjunto específico de valores na
Lookup<TKey,TElement> usando a seguinte sintaxe: myLookup[key] no Visual c# ou myLookup(key) no Visual Basic.
Se o key não for encontrado na coleção, uma sequência vazia é retornada.
OrderedParallelQuery<TSource> OrderedParallelQuery<
TSource> Class
Representa uma sequência paralela e classificada.
D eclaration
public class OrderedParallelQuery<TSource> : System.Linq.ParallelQuery<TSource>
type OrderedParallelQuery<'Source> = class
inherit ParallelQuery<'Source>
Object Object
ParallelQuery ParallelQuery
ParallelQuery<TSource> ParallelQuery<TSource>
Methods
GetEnumerator()
GetEnumerator()
Retorna um enumerador que itera pela sequência.
See Also
OrderedParallelQuery<TSource>.GetEnumerator
OrderedParallelQuery<TSource>.GetEnumerator
I n this Article
public override System.Collections.Generic.IEnumerator<TSource> GetEnumerator ();

override this.GetEnumerator : unit -> System.Collections.Generic.IEnumerator<'Source>
Returns
IEnumerator<TSource>
Um enumerador que itera pela sequência.
See LINQ paralelo (PLINQ )Parallel LINQ (PLINQ )
Also
ParallelEnumerable ParallelEnumerable Class
Fornece um conjunto de métodos de consulta de objetos que implementam ParallelQuery {TSource}. Este é o
equivalente paralelo de Enumerable.
D eclaration
public static class ParallelEnumerable
type ParallelEnumerable = class
Object Object
Methods
Aggregate<TSource,TAccumulate,TResult>(ParallelQuery<TSource>, TAccumulate,
Aplica em paralelo uma função acumuladora em uma sequência. O valor de semente especificado é usado como o
valor inicial do acumulador e a função especificada é usada para selecionar o valor do resultado.
Aggregate<TSource,TAccumulate,TResult>(ParallelQuery<TSource>, Func<TAccumulate>,
Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TAccumulate,TAccumulate>,
Aggregate<TSource,TAccumulate,TResult>(ParallelQuery<TSource>, Func<TAccumulate>,
Aplica em paralelo uma função acumuladora em uma sequência. Essa sobrecarga não está disponível na
implementação sequencial.
Aggregate<TSource,TAccumulate>(ParallelQuery<TSource>, TAccumulate,
Aggregate<TSource,TAccumulate>(ParallelQuery<TSource>, TAccumulate,
valor inicial do acumulador.
Aggregate<TSource>(ParallelQuery<TSource>, Func<TSource,TSource,TSource>)
Aggregate<TSource>(ParallelQuery<TSource>, Func<TSource,TSource,TSource>)
Aplica em paralelo uma função acumuladora em uma sequência.
All<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
All<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
Determina em paralelo se todos os elementos de uma sequência atendem a uma condição.
Any<TSource>(ParallelQuery<TSource>)
Any<TSource>(ParallelQuery<TSource>)
Determina se uma sequência paralela contém algum elemento.
Any<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
Determina em paralelo se algum elemento de uma sequência atende a uma condição.
AsEnumerable<TSource>(ParallelQuery<TSource>)
AsEnumerable<TSource>(ParallelQuery<TSource>)
Converte uma ParallelQuery<TSource> em uma IEnumerable<T> para forçar a avaliação sequencial da consulta.
AsOrdered(ParallelQuery)
AsOrdered(ParallelQuery)
Permite o tratamento de uma fonte de dados como se estivesse ordenada, substituindo o padrão de fora de
ordem. AsOrdered pode ser invocado somente em sequências não genéricas retornadas por AsParallel,
ParallelEnumerable.Range e ParallelEnumerable.Repeat.
AsOrdered<TSource>(ParallelQuery<TSource>)
Permite o tratamento de uma fonte de dados como se estivesse ordenada, substituindo o padrão de fora de
ordem. AsOrdered pode ser invocado somente em sequências genéricas retornadas por AsParallel,
AsParallel(IEnumerable)
AsParallel(IEnumerable)
Habilita a paralelização de uma consulta.
AsParallel<TSource>(Partitioner<TSource>)
AsParallel<TSource>(Partitioner<TSource>)
Possibilita a paralelização de uma consulta, conforme originada por um particionador personalizado que é
responsável pela divisão da sequência de entrada em partições.
AsParallel<TSource>(IEnumerable<TSource>)
AsSequential<TSource>(ParallelQuery<TSource>)
AsSequential<TSource>(ParallelQuery<TSource>)
AsUnordered<TSource>(ParallelQuery<TSource>)
AsUnordered<TSource>(ParallelQuery<TSource>)
Permite que uma consulta intermediária seja tratada como se nenhuma ordem estivesse implícita entre os
elementos.
Average(ParallelQuery<Single>)
Average(ParallelQuery<Single>)
Calcula em paralelo a média de uma sequência de valores.
Average(ParallelQuery<Nullable<Int64>>)
Average(ParallelQuery<Nullable<Double>>)
Average(ParallelQuery<Nullable<Single>>)

Average(ParallelQuery<Int64>)
Average(ParallelQuery<Double>)
Average(ParallelQuery<Decimal>)
Average(ParallelQuery<Nullable<Decimal>>)
Average<TSource>(ParallelQuery<TSource>, Func<TSource,Single>)
Average<TSource>(ParallelQuery<TSource>, Func<TSource,Single>)
Calcula em paralelo a média de uma sequência de valores que são obtidos invocando uma função de
Average<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Int64>>)
Average<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Double>>)
Average<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Double>>)
Average<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Single>>)
Average<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Single>>)
Average<TSource>(ParallelQuery<TSource>, Func<TSource,Int64>)
Average<TSource>(ParallelQuery<TSource>, Func<TSource,Double>)
Average<TSource>(ParallelQuery<TSource>, Func<TSource,Double>)
Average<TSource>(ParallelQuery<TSource>, Func<TSource,Decimal>)
Average<TSource>(ParallelQuery<TSource>, Func<TSource,Decimal>)
Average<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Decimal>>)
Average<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Decimal>>)
Cast<TResult>(ParallelQuery)
Cast<TResult>(ParallelQuery)
Converte os elementos de uma ParallelQuery para o tipo especificado.

Concat<TSource>(ParallelQuery<TSource>, IEnumerable<TSource>)
Concat<TSource>(ParallelQuery<TSource>, IEnumerable<TSource>)
Essa sobrecarga Concat nunca deve ser chamada. Esse método está marcado como obsoleto e sempre gera
NotSupportedException quando chamado.
Concat<TSource>(ParallelQuery<TSource>, ParallelQuery<TSource>)
Concat<TSource>(ParallelQuery<TSource>, ParallelQuery<TSource>)
Concatena duas sequências paralelas.
Contains<TSource>(ParallelQuery<TSource>, TSource, IEqualityComparer<TSource>)

Contains<TSource>(ParallelQuery<TSource>, TSource, IEqualityComparer<TSource>)
Determina em paralelo se uma sequência contém um elemento especificado usando um IEqualityComparer<T>.
Contains<TSource>(ParallelQuery<TSource>, TSource)
Em paralelo, determina se uma sequência contém um elemento especificado usando o comparador de igualdade
padrão.
Count<TSource>(ParallelQuery<TSource>)
Count<TSource>(ParallelQuery<TSource>)
Retorna o número de elementos em uma sequência paralela.
Count<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
Count<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
Retorna um número que representa quantos elementos na sequência paralela especificada satisfazem uma
condição.
DefaultIfEmpty<TSource>(ParallelQuery<TSource>)
Retorna os elementos da sequência paralela especificada ou o valor padrão do parâmetro de tipo em uma coleção
de singleton se a sequência estiver vazia.
DefaultIfEmpty<TSource>(ParallelQuery<TSource>, TSource)
Retorna os elementos da sequência paralela especificada ou o valor especificado em uma coleção de singleton, se
Distinct<TSource>(ParallelQuery<TSource>)
Distinct<TSource>(ParallelQuery<TSource>)
Retorna elementos distintos de uma sequência paralela usando o comparador de igualdade padrão para comparar
valores.
Distinct<TSource>(ParallelQuery<TSource>, IEqualityComparer<TSource>)
Distinct<TSource>(ParallelQuery<TSource>, IEqualityComparer<TSource>)
Retorna os elementos distintos de uma sequência paralela usando um IEqualityComparer<T> para comparar
valores.
ElementAt<TSource>(ParallelQuery<TSource>, Int32)
ElementAt<TSource>(ParallelQuery<TSource>, Int32)
Retorna o elemento em um índice especificado em uma sequência paralela.
ElementAtOrDefault<TSource>(ParallelQuery<TSource>, Int32)
ElementAtOrDefault<TSource>(ParallelQuery<TSource>, Int32)
Retorna o elemento em um índice especificado em uma sequência ou um valor padrão paralelo se o índice estiver
fora do intervalo.
Empty<TResult>()
Empty<TResult>()
Retorna uma ParallelQuery{TResult} vazia com o argumento do tipo especificado.
Except<TSource>(ParallelQuery<TSource>, IEnumerable<TSource>)
Except<TSource>(ParallelQuery<TSource>, IEnumerable<TSource>)
Essa sobrecarga Except nunca deve ser chamada. Esse método está marcado como obsoleto e sempre gera
Except<TSource>(ParallelQuery<TSource>, ParallelQuery<TSource>)
Except<TSource>(ParallelQuery<TSource>, ParallelQuery<TSource>)
Produz a diferença de conjunto de duas sequências paralelas usando o comparador de igualdade padrão para
comparar os valores.
Except<TSource>(ParallelQuery<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Except<TSource>(ParallelQuery<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
Except<TSource>(ParallelQuery<TSource>, ParallelQuery<TSource>, IEqualityComparer<TSource>)
Except<TSource>(ParallelQuery<TSource>, ParallelQuery<TSource>, IEqualityComparer<TSource>)
Produz a diferença de conjunto de duas sequências paralelas usando o IEqualityComparer<T> especificado para
First<TSource>(ParallelQuery<TSource>)
First<TSource>(ParallelQuery<TSource>)
Retorna o primeiro elemento de uma sequência paralela.
First<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
First<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
Retorna o primeiro elemento em uma sequência paralela que satisfaz uma condição especificada.
FirstOrDefault<TSource>(ParallelQuery<TSource>)
Retornará o primeiro elemento de uma sequência paralela ou um valor padrão, se a sequência não contiver
elementos.
FirstOrDefault<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
FirstOrDefault<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
Retorna o primeiro elemento da sequência paralela que satisfaz a uma condição ou um valor padrão, caso esse
elemento não seja encontrado.
ForAll<TSource>(ParallelQuery<TSource>, Action<TSource>)
ForAll<TSource>(ParallelQuery<TSource>, Action<TSource>)
Invoca a ação especificada em paralelo para cada elemento no source .
GroupBy<TSource,TKey,TElement,TResult>(ParallelQuery<TSource>, Func<TSource,TKey>,
valor de resultado de cada grupo e sua chave. Os valores da chave são comparados usando um comparador
especificado e os elementos de cada grupo são projetados usando uma função especificada.
Agrupa em paralelo os elementos de uma sequência de acordo com uma função do seletor de chave especificada
e cria um valor de resultado de cada grupo e sua chave. Os elementos de cada grupo são projetados usando uma
função especificada.
GroupBy<TSource,TKey,TElement>(ParallelQuery<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

GroupBy<TSource,TKey,TElement>(ParallelQuery<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)
Agrupa em paralelo os elementos de uma sequência de acordo com a função de seletor de chave especificada e
projeta os elementos de cada grupo usando uma função especificada.
GroupBy<TSource,TKey,TElement>(ParallelQuery<TSource>, Func<TSource,TKey>, Func<TSource,TElement>,

GroupBy<TSource,TKey,TElement>(ParallelQuery<TSource>, Func<TSource,TKey>, Func<TSource,TElement>,
Agrupa em paralelo os elementos de uma sequência de acordo com uma função de seletor de chave. As chaves
são comparadas usando um comparador e os elementos de cada grupo são projetados usando uma função
especificada.
GroupBy<TSource,TKey,TResult>(ParallelQuery<TSource>, Func<TSource,TKey>,
e cria um valor de resultado de cada grupo e sua chave.
e cria um valor de resultado de cada grupo e sua chave. As chaves são comparadas usando um comparador
especificado.
GroupBy<TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

GroupBy<TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)
e compara as chaves usando um IComparer<T> especificado.
GroupBy<TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>)
GroupBy<TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>)
Agrupa em paralelo os elementos de uma sequência de acordo com uma função de seletor de chave especificada.
GroupJoin<TOuter,TInner,TKey,TResult>(ParallelQuery<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>,
Essa sobrecarga GroupJoin nunca deve ser chamada. Esse método está marcado como obsoleto e sempre gera
GroupJoin<TOuter,TInner,TKey,TResult>(ParallelQuery<TOuter>, ParallelQuery<TInner>, Func<TOuter,TKey>,

Correlaciona em paralelo os elementos de duas sequências com base na igualdade de chaves e agrupa os
resultados. O comparador de igualdade padrão é usado para comparar chaves.


Correlaciona em paralelo os elementos de duas sequências com base na igualdade de chaves e agrupa os
resultados. Um IEqualityComparer<T> especificado é usado para comparar chaves.
Intersect<TSource>(ParallelQuery<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Intersect<TSource>(ParallelQuery<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
Essa sobrecarga Intersect nunca deve ser chamada. Esse método está marcado como obsoleto e sempre gera
Intersect<TSource>(ParallelQuery<TSource>, ParallelQuery<TSource>, IEqualityComparer<TSource>)

Intersect<TSource>(ParallelQuery<TSource>, ParallelQuery<TSource>, IEqualityComparer<TSource>)
Produz a interseção de conjunto de duas sequências paralelas usando o IEqualityComparer{T} especificado para
Intersect<TSource>(ParallelQuery<TSource>, IEnumerable<TSource>)
Intersect<TSource>(ParallelQuery<TSource>, IEnumerable<TSource>)
Intersect<TSource>(ParallelQuery<TSource>, ParallelQuery<TSource>)
Intersect<TSource>(ParallelQuery<TSource>, ParallelQuery<TSource>)
Produz a interseção de conjunto de duas sequências em paralelo usando o comparador de igualdade padrão para
Join<TOuter,TInner,TKey,TResult>(ParallelQuery<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>,

Essa sobrecarga Join nunca deve ser chamada. Esse método está marcado como obsoleto e sempre gera
NotSupportedException quando invocado.
Join<TOuter,TInner,TKey,TResult>(ParallelQuery<TOuter>, ParallelQuery<TInner>, Func<TOuter,TKey>,

Correlaciona em paralelo os elementos de duas sequências com base em chaves de correspondência. O



Correlaciona em paralelo os elementos de duas sequências com base em chaves de correspondência. Um

Last<TSource>(ParallelQuery<TSource>)
Last<TSource>(ParallelQuery<TSource>)
Retorna o último elemento de uma sequência paralela.
Last<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
Retorna o último elemento de uma sequência paralela que satisfaz a uma condição especificada.
LastOrDefault<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
LastOrDefault<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
Retorna o último elemento de uma sequência em paralelo que satisfaz a uma condição ou um valor padrão, caso
esse elemento não seja encontrado.
LastOrDefault<TSource>(ParallelQuery<TSource>)
Retornará o último elemento de uma sequência paralela ou um valor padrão, se a sequência não contiver
elementos.
LongCount<TSource>(ParallelQuery<TSource>)
Retorna um Int64 que representa o número total de elementos em uma sequência paralela.
LongCount<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
LongCount<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
Retorna um Int64 que representa quantos elementos em uma sequência paralela satisfazem a uma condição.
Max(ParallelQuery<Nullable<Single>>)
Retorna o valor máximo em uma sequência paralela de valores.
Max(ParallelQuery<Single>)
Max(ParallelQuery<Single>)
Max(ParallelQuery<Nullable<Int64>>)
Max(ParallelQuery<Nullable<Double>>)

Max(ParallelQuery<Double>)
Max(ParallelQuery<Double>)
Max(ParallelQuery<Int64>)
Max(ParallelQuery<Decimal>)
Max(ParallelQuery<Decimal>)
Max(ParallelQuery<Nullable<Decimal>>)
Max<TSource,TResult>(ParallelQuery<TSource>, Func<TSource,TResult>)
Max<TSource,TResult>(ParallelQuery<TSource>, Func<TSource,TResult>)
Invoca em paralelo uma função de transformação em cada elemento de uma sequência e retorna o valor máximo.
Max<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Int64>>)
Max<TSource>(ParallelQuery<TSource>, Func<TSource,Single>)
Max<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Single>>)
Max<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Single>>)
Max<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Double>>)
Max<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Double>>)
Max<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Decimal>>)
Max<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Decimal>>)
Max<TSource>(ParallelQuery<TSource>, Func<TSource,Int64>)
Max<TSource>(ParallelQuery<TSource>, Func<TSource,Double>)
Max<TSource>(ParallelQuery<TSource>, Func<TSource,Decimal>)
Max<TSource>(ParallelQuery<TSource>, Func<TSource,Decimal>)
Max<TSource>(ParallelQuery<TSource>)
Max<TSource>(ParallelQuery<TSource>)
Min(ParallelQuery<Single>)
Min(ParallelQuery<Single>)
Retorna o valor mínimo em uma sequência paralela de valores.
Min(ParallelQuery<Nullable<Single>>)
Min(ParallelQuery<Nullable<Int64>>)
Min(ParallelQuery<Nullable<Double>>)
Min(ParallelQuery<Nullable<Decimal>>)
Min(ParallelQuery<Int64>)
Min(ParallelQuery<Double>)
Min(ParallelQuery<Double>)

Min(ParallelQuery<Decimal>)
Min(ParallelQuery<Decimal>)
Min<TSource,TResult>(ParallelQuery<TSource>, Func<TSource,TResult>)
Min<TSource,TResult>(ParallelQuery<TSource>, Func<TSource,TResult>)
Invoca em paralelo uma função de transformação em cada elemento de uma sequência e retorna o valor mínimo.
Min<TSource>(ParallelQuery<TSource>, Func<TSource,Single>)
Min<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Single>>)
Min<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Single>>)
Min<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Int32>>)
Min<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Double>>)
Min<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Double>>)
Min<TSource>(ParallelQuery<TSource>, Func<TSource,Int64>)
Min<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Decimal>>)
Min<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Decimal>>)
Min<TSource>(ParallelQuery<TSource>, Func<TSource,Double>)
Min<TSource>(ParallelQuery<TSource>, Func<TSource,Decimal>)
Min<TSource>(ParallelQuery<TSource>)
Min<TSource>(ParallelQuery<TSource>)
OfType<TResult>(ParallelQuery)
OfType<TResult>(ParallelQuery)
Filtra os elementos de uma ParallelQuery com base em um tipo especificado.
OrderBy<TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>)
OrderBy<TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>)
Classifica em paralelo os elementos de uma sequência em ordem crescente de acordo com uma chave.
OrderBy<TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>, IComparer<TKey>)

OrderBy<TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>, IComparer<TKey>)
Classifica em paralelo os elementos de uma sequência em ordem crescente usando um comparador especificado.
OrderByDescending<TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>)
OrderByDescending<TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>)
Classifica em paralelo os elementos de uma sequência em ordem decrescente de acordo com uma chave.
OrderByDescending<TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>, IComparer<TKey>)

OrderByDescending<TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Range(Int32, Int32)
Range(Int32, Int32)
Gera uma sequência paralela de números integrais dentro de um intervalo especificado.
Gera uma sequência paralela que contém um valor repetido.
Reverse<TSource>(ParallelQuery<TSource>)
Reverse<TSource>(ParallelQuery<TSource>)
Inverte a ordem dos elementos em uma sequência paralela.
Select<TSource,TResult>(ParallelQuery<TSource>, Func<TSource,Int32,TResult>)
Select<TSource,TResult>(ParallelQuery<TSource>, Func<TSource,Int32,TResult>)
Projeta em paralelo cada elemento de uma sequência em um novo formulário incorporando o índice do elemento.
Select<TSource,TResult>(ParallelQuery<TSource>, Func<TSource,TResult>)
Select<TSource,TResult>(ParallelQuery<TSource>, Func<TSource,TResult>)
Projeta em paralelo cada elemento de uma sequência em um novo formulário.
SelectMany<TSource,TCollection,TResult>(ParallelQuery<TSource>, Func<TSource,IEnumerable<TCollection>>,
SelectMany<TSource,TCollection,TResult>(ParallelQuery<TSource>, Func<TSource,IEnumerable<TCollection>>,
SelectMany<TSource,TCollection,TResult>(ParallelQuery<TSource>,
SelectMany<TSource,TCollection,TResult>(ParallelQuery<TSource>,
sequência e chama uma função de seletor de resultado em cada elemento contido nele. O índice de cada elemento
de origem é usado no formulário projetado intermediário do elemento.
SelectMany<TSource,TResult>(ParallelQuery<TSource>, Func<TSource,IEnumerable<TResult>>)
SelectMany<TSource,TResult>(ParallelQuery<TSource>, Func<TSource,IEnumerable<TResult>>)
Projeta em paralelo em cada elemento de uma sequência para um IEnumerable<T> e mescla as sequências
resultantes em uma sequência.
SelectMany<TSource,TResult>(ParallelQuery<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)
SelectMany<TSource,TResult>(ParallelQuery<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)
resultantes em uma sequência. O índice de cada elemento de origem é usado no formulário projetado desse
elemento.
SequenceEqual<TSource>(ParallelQuery<TSource>, IEnumerable<TSource>)
SequenceEqual<TSource>(ParallelQuery<TSource>, IEnumerable<TSource>)
Essa sobrecarga SequenceEqual nunca deve ser chamada. Esse método está marcado como obsoleto e sempre
gera NotSupportedException quando chamado.
SequenceEqual<TSource>(ParallelQuery<TSource>, ParallelQuery<TSource>)
SequenceEqual<TSource>(ParallelQuery<TSource>, ParallelQuery<TSource>)
Determina se duas sequências paralelas são iguais comparando os elementos usando o comparador de igualdade
padrão para o tipo.
SequenceEqual<TSource>(ParallelQuery<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

SequenceEqual<TSource>(ParallelQuery<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
Essa sobrecarga SequenceEqual nunca deve ser chamada. Esse método está marcado como obsoleto e sempre
gera NotSupportedException quando chamado.
SequenceEqual<TSource>(ParallelQuery<TSource>, ParallelQuery<TSource>, IEqualityComparer<TSource>)

SequenceEqual<TSource>(ParallelQuery<TSource>, ParallelQuery<TSource>, IEqualityComparer<TSource>)
Determina se duas sequências paralelas são iguais comparando seus elementos usando um IEqualityComparer{T}
especificado.
Single<TSource>(ParallelQuery<TSource>)
Single<TSource>(ParallelQuery<TSource>)
Retorna o único elemento de uma sequência paralela e gerará uma exceção se não houver exatamente um
elemento na sequência.
Single<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
Single<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
Retorna o único elemento de uma sequência paralela que satisfaz uma condição especificada e gera uma exceção
se houver mais de um desses elementos.
SingleOrDefault<TSource>(ParallelQuery<TSource>)
Retorna o único elemento de uma sequência paralela ou um valor padrão, se a sequência estiver vazia. Esse
método gerará uma exceção se houver mais de um elemento na sequência.
SingleOrDefault<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
SingleOrDefault<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
Retorna o único elemento de uma sequência paralela que satisfaz uma condição especificada ou um valor padrão
se esse elemento não existir. Esse método lançará uma exceção se mais de um elemento satisfizer a condição.
Skip<TSource>(ParallelQuery<TSource>, Int32)
Skip<TSource>(ParallelQuery<TSource>, Int32)
Ignora um número especificado de elementos em uma sequência paralela e retorna os elementos restantes.
SkipWhile<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
SkipWhile<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
Ignora elementos em uma sequência paralela, contanto que uma condição especificada seja verdadeira e retorne
os elementos restantes.
SkipWhile<TSource>(ParallelQuery<TSource>, Func<TSource,Int32,Boolean>)
SkipWhile<TSource>(ParallelQuery<TSource>, Func<TSource,Int32,Boolean>)
Ignora elementos em uma sequência paralela, contanto que uma condição especificada seja verdadeira e retorne
os elementos restantes. O índice do elemento é usado na lógica da função de predicado.
Sum(ParallelQuery<Nullable<Single>>)
Calcula em paralelo a soma de uma sequência de valores.
Sum(ParallelQuery<Nullable<Int64>>)
Sum(ParallelQuery<Nullable<Double>>)

Sum(ParallelQuery<Single>)
Sum(ParallelQuery<Single>)
Sum(ParallelQuery<Int64>)
Sum(ParallelQuery<Double>)
Sum(ParallelQuery<Double>)
Sum(ParallelQuery<Decimal>)
Sum(ParallelQuery<Decimal>)
Sum(ParallelQuery<Nullable<Decimal>>)
Sum<TSource>(ParallelQuery<TSource>, Func<TSource,Single>)
Calcula em paralelo a soma da sequência de valores obtidos chamando uma função de transformação em cada
Sum<TSource>(ParallelQuery<TSource>, Func<TSource,Decimal>)
Sum<TSource>(ParallelQuery<TSource>, Func<TSource,Decimal>)
Sum<TSource>(ParallelQuery<TSource>, Func<TSource,Double>)
Sum<TSource>(ParallelQuery<TSource>, Func<TSource,Int32>)
Sum<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Decimal>>)
Sum<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Decimal>>)
Sum<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Double>>)
Sum<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Double>>)
Sum<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Int32>>)
Sum<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Single>>)
Sum<TSource>(ParallelQuery<TSource>, Func<TSource,Nullable<Single>>)
Take<TSource>(ParallelQuery<TSource>, Int32)
Take<TSource>(ParallelQuery<TSource>, Int32)
Retorna um número especificado de elementos contíguos do início de uma sequência paralela.
TakeWhile<TSource>(ParallelQuery<TSource>, Func<TSource,Int32,Boolean>)
TakeWhile<TSource>(ParallelQuery<TSource>, Func<TSource,Int32,Boolean>)
Retorna os elementos de uma sequência paralela, contanto que uma condição especificada seja verdadeira. O
índice do elemento é usado na lógica da função de predicado.
TakeWhile<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
TakeWhile<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
Retorna os elementos de uma sequência paralela, contanto que uma condição especificada seja verdadeira.
ThenBy<TSource,TKey>(OrderedParallelQuery<TSource>, Func<TSource,TKey>)
ThenBy<TSource,TKey>(OrderedParallelQuery<TSource>, Func<TSource,TKey>)
Executa em paralelo uma ordenação subsequente dos elementos em uma sequência em ordem crescente de
acordo com uma chave.
ThenBy<TSource,TKey>(OrderedParallelQuery<TSource>, Func<TSource,TKey>, IComparer<TKey>)

ThenBy<TSource,TKey>(OrderedParallelQuery<TSource>, Func<TSource,TKey>, IComparer<TKey>)
Executa em paralelo uma ordenação posterior dos elementos em uma sequência em ordem crescente usando um
ThenByDescending<TSource,TKey>(OrderedParallelQuery<TSource>, Func<TSource,TKey>)
ThenByDescending<TSource,TKey>(OrderedParallelQuery<TSource>, Func<TSource,TKey>)
Executa em paralelo uma ordenação subsequente dos elementos em uma sequência em ordem decrescente de
ThenByDescending<TSource,TKey>(OrderedParallelQuery<TSource>, Func<TSource,TKey>, IComparer<TKey>)

ThenByDescending<TSource,TKey>(OrderedParallelQuery<TSource>, Func<TSource,TKey>, IComparer<TKey>)
Executa em paralelo uma ordenação posterior dos elementos em uma sequência em ordem decrescente usando
um comparador especificado.
ToArray<TSource>(ParallelQuery<TSource>)
ToArray<TSource>(ParallelQuery<TSource>)
Cria uma matriz de um ParallelQuery<TSource>.

ToDictionary<TSource,TKey,TElement>(ParallelQuery<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)
ToDictionary<TSource,TKey,TElement>(ParallelQuery<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)
Cria um Dictionary<TKey,TValue> de um ParallelQuery<TSource> de acordo com as funções especificadas de

seletor de chave e seletor de elemento.
ToDictionary<TSource,TKey,TElement>(ParallelQuery<TSource>, Func<TSource,TKey>, Func<TSource,TElement>,

ToDictionary<TSource,TKey,TElement>(ParallelQuery<TSource>, Func<TSource,TKey>, Func<TSource,TElement>,
Cria um Dictionary<TKey,TValue> de um ParallelQuery<TSource> de acordo com uma função de seletor de

chave, um comparador e uma função de seletor de elemento especificados.
ToDictionary<TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>)
ToDictionary<TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>)

chave especificada.
ToDictionary<TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

ToDictionary<TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

chave e um comparador de chaves especificados.
ToList<TSource>(ParallelQuery<TSource>)
ToList<TSource>(ParallelQuery<TSource>)
Cria um List<T> de um ParallelQuery<TSource>.
ToLookup<TSource,TKey,TElement>(ParallelQuery<TSource>, Func<TSource,TKey>, Func<TSource,TElement>,

ToLookup<TSource,TKey,TElement>(ParallelQuery<TSource>, Func<TSource,TKey>, Func<TSource,TElement>,
Cria um ILookup<TKey,TElement> de um ParallelQuery<TSource> de acordo com uma função de seletor de

chave, um comparador e uma função de seletor de elemento especificados.
ToLookup<TSource,TKey,TElement>(ParallelQuery<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

ToLookup<TSource,TKey,TElement>(ParallelQuery<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)
Cria um ILookup<TKey,TElement> de um ParallelQuery<TSource> de acordo com as funções especificadas de

seletor de chave e seletor de elemento.
ToLookup<TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

ToLookup<TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)
chave e um comparador de chaves especificados.
ToLookup<TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>)
ToLookup<TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>)

chave especificada.
Union<TSource>(ParallelQuery<TSource>, IEnumerable<TSource>)
Union<TSource>(ParallelQuery<TSource>, IEnumerable<TSource>)
Essa sobrecarga Union nunca deve ser chamada. Esse método está marcado como obsoleto e sempre gera
Union<TSource>(ParallelQuery<TSource>, ParallelQuery<TSource>)
Union<TSource>(ParallelQuery<TSource>, ParallelQuery<TSource>)
Produz a união de conjunto de duas sequências paralelas usando o comparador de igualdade padrão.
Union<TSource>(ParallelQuery<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Union<TSource>(ParallelQuery<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
Union<TSource>(ParallelQuery<TSource>, ParallelQuery<TSource>, IEqualityComparer<TSource>)

Union<TSource>(ParallelQuery<TSource>, ParallelQuery<TSource>, IEqualityComparer<TSource>)
Produz a união de conjunto de duas sequências paralelas usando um IEqualityComparer{T} especificado.
Where<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
Where<TSource>(ParallelQuery<TSource>, Func<TSource,Boolean>)
Filtra uma sequência paralela de valores com base em um predicado.
Where<TSource>(ParallelQuery<TSource>, Func<TSource,Int32,Boolean>)
Where<TSource>(ParallelQuery<TSource>, Func<TSource,Int32,Boolean>)
Filtra uma sequência paralela de valores com base em um predicado. O índice de cada elemento é usado na lógica
da função de predicado.
WithCancellation<TSource>(ParallelQuery<TSource>, CancellationToken)
WithCancellation<TSource>(ParallelQuery<TSource>, CancellationToken)
Define o CancellationToken a associar à consulta.
WithDegreeOfParallelism<TSource>(ParallelQuery<TSource>, Int32)
WithDegreeOfParallelism<TSource>(ParallelQuery<TSource>, Int32)
Define o grau de paralelismo a ser usado em uma consulta. O grau de paralelismo é o número máximo de tarefas
que serão usadas simultaneamente para processar a consulta.
WithExecutionMode<TSource>(ParallelQuery<TSource>, ParallelExecutionMode)
WithExecutionMode<TSource>(ParallelQuery<TSource>, ParallelExecutionMode)
Define o modo de execução da consulta.
WithMergeOptions<TSource>(ParallelQuery<TSource>, ParallelMergeOptions)
WithMergeOptions<TSource>(ParallelQuery<TSource>, ParallelMergeOptions)
Define as opções de mesclagem para essa consulta, que especifica como a consulta armazenará em buffer a saída.
Zip<TFirst,TSecond,TResult>(ParallelQuery<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)

Zip<TFirst,TSecond,TResult>(ParallelQuery<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)
Essa sobrecarga de Zip nunca deve ser chamada. Esse método está marcado como obsoleto e sempre gera
Zip<TFirst,TSecond,TResult>(ParallelQuery<TFirst>, ParallelQuery<TSecond>,
Func<TFirst,TSecond,TResult>)
Zip<TFirst,TSecond,TResult>(ParallelQuery<TFirst>, ParallelQuery<TSecond>,
Func<TFirst,TSecond,TResult>)
Mescla em paralelo duas sequências usando a função de predicado especificada.
See Also
ParallelEnumerable.Aggregate ParallelEnumerable.
Aggregate
I n this Article
Overloads
Aggregate<TSource,TAccumulate,TResult>(ParallelQuery<
TSource>, TAccumulate, Func<TAccumulate,TSource, Aplica em paralelo uma função acumuladora em uma
TAccumulate>, Func<TAccumulate,TResult>) Aggregate< sequência. O valor de semente especificado é usado como o
TSource,TAccumulate,TResult>(ParallelQuery<TSource>, valor inicial do acumulador e a função especificada é usada
TAccumulate, Func<TAccumulate,TSource,TAccumulate>, para selecionar o valor do resultado.
TSource>, Func<TAccumulate>, Func<TAccumulate,TSource, Aplica em paralelo uma função acumuladora em uma
TAccumulate>, Func<TAccumulate,TAccumulate, sequência. Essa sobrecarga não está disponível na
TAccumulate>, Func<TAccumulate,TResult>) Aggregate< implementação sequencial.
TSource,TAccumulate,TResult>(ParallelQuery<TSource>,
Func<TAccumulate>, Func<TAccumulate,TSource,
TAccumulate>, Func<TAccumulate,TAccumulate,
TAccumulate>, Func<TAccumulate,TResult>)
TSource>, TAccumulate, Func<TAccumulate,TSource, Aplica em paralelo uma função acumuladora em uma
TAccumulate>, Func<TAccumulate,TAccumulate, sequência. Essa sobrecarga não está disponível na
TAccumulate>, Func<TAccumulate,TResult>) Aggregate< implementação sequencial.
TSource,TAccumulate,TResult>(ParallelQuery<TSource>,
TAccumulate, Func<TAccumulate,TSource,TAccumulate>,
Func<TAccumulate,TAccumulate,TAccumulate>, Func<
TAccumulate,TResult>)
Aggregate<TSource,TAccumulate>(ParallelQuery<TSource>,
TAccumulate, Func<TAccumulate,TSource,TAccumulate>) Aplica em paralelo uma função acumuladora em uma
Aggregate<TSource,TAccumulate>(ParallelQuery<TSource>, sequência. O valor de semente especificado é usado como o
TAccumulate, Func<TAccumulate,TSource,TAccumulate>) valor inicial do acumulador.
Aggregate<TSource>(ParallelQuery<TSource>, Func<TSource,
TSource,TSource>) Aggregate<TSource>(ParallelQuery< Aplica em paralelo uma função acumuladora em uma
TSource>, Func<TSource,TSource,TSource>) sequência.
(ParallelQuery<TSource>, TAccumulate,
valor inicial do acumulador e a função especificada é usada para selecionar o valor do resultado.
System.Linq.ParallelQuery<TSource> source, TAccumulate seed, Func<TAccumulate,TSource,TAccumulate>
func, Func<TAccumulate,TResult> resultSelector);
static member Aggregate : System.Linq.ParallelQuery<'Source> * 'Accumulate * Func<'Accumulate,
'Source, 'Accumulate> * Func<'Accumulate, 'Result> -> 'Result
Type Parameters
TSource
TAccumulate
TResult
Parameters
source ParallelQuery<TSource> ParallelQuery<TSource>
Uma sequência a ser agregada.
Returns
TResult TResult
Exceptions
OperationCanceledException OperationCanceledException
A consulta foi cancelada com o token transmitido pelo WithCancellation .
source ou func ou resultSelector é uma referência nula (Nothing no Visual Basic).
AggregateException AggregateException
Uma ou mais exceções ocorreram durante a avaliação da consulta.
Also
(ParallelQuery<TSource>, Func<TAccumulate>,
Func<TAccumulate,TAccumulate,TAccumulate>,
(ParallelQuery<TSource>, Func<TAccumulate>,
System.Linq.ParallelQuery<TSource> source, Func<TAccumulate> seedFactory,
Func<TAccumulate,TSource,TAccumulate> updateAccumulatorFunc,
Func<TAccumulate,TAccumulate,TAccumulate> combineAccumulatorsFunc, Func<TAccumulate,TResult>
resultSelector);
static member Aggregate : System.Linq.ParallelQuery<'Source> * Func<'Accumulate> * Func<'Accumulate,
'Source, 'Accumulate> * Func<'Accumulate, 'Accumulate, 'Accumulate> * Func<'Accumulate, 'Result> ->
'Result
Type Parameters
TSource
TAccumulate
TResult
Parameters
seedFactory Func<TAccumulate>
Uma função que retorna o valor inicial do acumulador.
updateAccumulatorFunc Func<TAccumulate,TSource,TAccumulate>
Uma função de acumulador a ser invocada em cada elemento em uma partição.
combineAccumulatorsFunc Func<TAccumulate,TAccumulate,TAccumulate>
Uma função de acumulador a ser invocada produziu resultado do acumulador de cada partição.
Returns
TResult TResult
Exceptions
source ou seedFactory ou updateAccumulatorFunc ou combineAccumulatorsFunc ou resultSelector é uma
referência nula (Nothing no Visual Basic).
Remarks
Essa sobrecarga é específica para consultas em paralelo. Uma consulta em paralelo pode particionar a sequência de
origem de dados em várias sequências de subpastas (partições). O updateAccumulatorFunc é invocada em cada
elemento dentro de partições. Cada partição, em seguida, produz um único resultado acumulado. O
combineAccumulatorsFunc é invocado, em seguida, nos resultados de cada partição para produzir um único elemento.
Esse elemento é transformado pelo resultSelector função.

Also
System.Linq.ParallelQuery<TSource> source, TAccumulate seed, Func<TAccumulate,TSource,TAccumulate>
updateAccumulatorFunc, Func<TAccumulate,TAccumulate,TAccumulate> combineAccumulatorsFunc,
Func<TAccumulate,TResult> resultSelector);
'Source, 'Accumulate> * Func<'Accumulate, 'Accumulate, 'Accumulate> * Func<'Accumulate, 'Result> ->
'Result
Type Parameters
TSource
TAccumulate
TResult
Parameters
updateAccumulatorFunc Func<TAccumulate,TSource,TAccumulate>
Uma função de acumulador a ser invocada em cada elemento em uma partição.
combineAccumulatorsFunc Func<TAccumulate,TAccumulate,TAccumulate>
Uma função de acumulador a ser invocada produziu resultado do acumulador de cada partição.
Returns
TResult TResult
Exceptions
source ou updateAccumulatorFunc ou combineAccumulatorsFunc ou resultSelector é uma referência nula
(Nothing no Visual Basic).
Remarks
Essa sobrecarga é específica para processamento de uma consulta em paralelo. Uma consulta em paralelo pode
particionar a sequência de origem de dados em várias sequências de subpastas (partições). O updateAccumulatorFunc
é invocada em cada elemento dentro de partições. Cada partição, em seguida, produz um único resultado acumulado.
O combineAccumulatorsFunc é invocado, em seguida, nos resultados de cada partição para produzir um único
elemento. Esse elemento é transformado pelo resultSelector função.
Also
valor inicial do acumulador.
public static TAccumulate Aggregate<TSource,TAccumulate> (this System.Linq.ParallelQuery<TSource>

source, TAccumulate seed, Func<TAccumulate,TSource,TAccumulate> func);
'Source, 'Accumulate> -> 'Accumulate
Type Parameters
TSource
TAccumulate
Parameters
Returns
Exceptions
source ou func é uma referência nula (Nothing no Visual Basic).
Also
Aggregate<TSource>(ParallelQuery<TSource>,
Func<TSource,TSource,TSource>) Aggregate<TSource>
(ParallelQuery<TSource>, Func<TSource,TSource,TSource>)
Aplica em paralelo uma função acumuladora em uma sequência.
public static TSource Aggregate<TSource> (this System.Linq.ParallelQuery<TSource> source,

Func<TSource,TSource,TSource> func);
static member Aggregate : System.Linq.ParallelQuery<'Source> * Func<'Source, 'Source, 'Source> ->
'Source
Type Parameters
TSource
Parameters
func Func<TSource,TSource,TSource>
Returns
TSource TSource
Exceptions
source ou func é uma referência nula (Nothing no Visual Basic).

Also
ParallelEnumerable.All ParallelEnumerable.All
I n this Article
Determina em paralelo se todos os elementos de uma sequência atendem a uma condição.
public static bool All<TSource> (this System.Linq.ParallelQuery<TSource> source, Func<TSource,bool>
predicate);
static member All : System.Linq.ParallelQuery<'Source> * Func<'Source, bool> -> bool
Type Parameters
TSource
Parameters
A sequência a cujos elementos aplicar o predicado.
Returns
Boolean Boolean
estiver vazia; caso contrário, false.
Exceptions
source ou predicate é uma referência nula (Nothing no Visual Basic).
Also
ParallelEnumerable.Any ParallelEnumerable.Any
I n this Article
Overloads
Any<TSource>(ParallelQuery<TSource>) Any<TSource>(
ParallelQuery<TSource>) Determina se uma sequência paralela contém algum elemento.
Any<TSource>(ParallelQuery<TSource>, Func<TSource,
Boolean>) Any<TSource>(ParallelQuery<TSource>, Func< Determina em paralelo se algum elemento de uma sequência
TSource,Boolean>) atende a uma condição.
Any<TSource>(ParallelQuery<TSource>) Any<TSource>
(ParallelQuery<TSource>)
Determina se uma sequência paralela contém algum elemento.
public static bool Any<TSource> (this System.Linq.ParallelQuery<TSource> source);
static member Any : System.Linq.ParallelQuery<'Source> -> bool
Type Parameters
TSource
Parameters
A sequência para verificar se está vazia.
Returns
Boolean Boolean
true se a sequência de origem contiver elementos; caso contrário, false.
Exceptions
source é uma referência nula (Nada no Visual Basic).
Remarks
Essa sobrecarga da qualquer método faz com que uma mesclagem com buffer completo a serem executadas antes do
resultado é retornado. O comportamento de mesclagem pode afetar o desempenho ou causar uma exceção de falta de
memória em grandes enumeráveis. Para evitar o comportamento de mesclagem, use a sobrecarga de qualquer um
que utiliza um parâmetro de Func, caso contrário, use um método alternativo como FirstOrDefault.
Also
Determina em paralelo se algum elemento de uma sequência atende a uma condição.
public static bool Any<TSource> (this System.Linq.ParallelQuery<TSource> source, Func<TSource,bool>
predicate);
static member Any : System.Linq.ParallelQuery<'Source> * Func<'Source, bool> -> bool
Type Parameters
TSource
Parameters
Uma sequência a cujos elementos o predicado será aplicado.
Returns
Boolean Boolean
true se algum elemento na sequência de origem for aprovado no teste do predicado especificado; caso contrário, false.
Exceptions
Also
ParallelEnumerable.AsEnumerable ParallelEnumerable.As
Enumerable
I n this Article
public static System.Collections.Generic.IEnumerable<TSource> AsEnumerable<TSource> (this

System.Linq.ParallelQuery<TSource> source);
static member AsEnumerable : System.Linq.ParallelQuery<'Source> -> seq<'Source>
Type Parameters
TSource
Parameters
A sequência a ser convertida como IEnumerable<T>.
Returns
A sequência de entrada digitada como IEnumerable<T>.
Exceptions
Also
ParallelEnumerable.AsOrdered ParallelEnumerable.As
Ordered
I n this Article
Overloads
AsOrdered(ParallelQuery) AsOrdered(ParallelQuery)
Permite o tratamento de uma fonte de dados como se
estivesse ordenada, substituindo o padrão de fora de ordem.
AsOrdered pode ser invocado somente em sequências não
genéricas retornadas por AsParallel, ParallelEnumerable.Range
e ParallelEnumerable.Repeat.
AsOrdered<TSource>(ParallelQuery<TSource>) AsOrdered<
TSource>(ParallelQuery<TSource>) Permite o tratamento de uma fonte de dados como se
estivesse ordenada, substituindo o padrão de fora de ordem.
AsOrdered pode ser invocado somente em sequências
genéricas retornadas por AsParallel, ParallelEnumerable.Range
AsOrdered(ParallelQuery) AsOrdered(ParallelQuery)
Permite o tratamento de uma fonte de dados como se estivesse ordenada, substituindo o padrão de fora de ordem.
AsOrdered pode ser invocado somente em sequências não genéricas retornadas por AsParallel,
public static System.Linq.ParallelQuery AsOrdered (this System.Linq.ParallelQuery source);
static member AsOrdered : System.Linq.ParallelQuery -> System.Linq.ParallelQuery
Parameters
source ParallelQuery ParallelQuery
A sequência de entrada.
Returns
A sequência de origem que manterá a ordem original nos operadores de consulta subsequentes.
Exceptions
lançado se source não contiver elementos - ou - se AsOrdered for chamado durante uma consulta. Ele tem permissão
para ser chamado imediatamente após AsParallel(IEnumerable), Range(Int32, Int32) ou Repeat<TResult>(TResult,
Int32).
Remarks
Existe uma tensão natural entre desempenho e preservando a ordem de processamento paralelo. Por padrão, uma
consulta em paralelo se comporta como se a ordenação dos resultados é arbitrária, a menos que AsOrdered for
aplicado, ou há um operador OrderBy explícito na consulta. Para saber mais, veja Preservação da ordem em PLINQ.
Also
Permite o tratamento de uma fonte de dados como se estivesse ordenada, substituindo o padrão de fora de ordem.
AsOrdered pode ser invocado somente em sequências genéricas retornadas por AsParallel, ParallelEnumerable.Range
public static System.Linq.ParallelQuery<TSource> AsOrdered<TSource> (this
static member AsOrdered : System.Linq.ParallelQuery<'Source> -> System.Linq.ParallelQuery<'Source>
Type Parameters
TSource
Parameters
Returns
A sequência de origem que manterá a ordem original nos operadores de consulta subsequentes.
Exceptions
Gerado se source não contiver elementos - ou - se source não for um dos AsParallel, ParallelEnumerable.Range ou
ParallelEnumerable.Repeat.
Remarks
Existe uma tensão natural entre desempenho e preservando a ordem de processamento paralelo. Por padrão, uma
consulta em paralelo se comporta como se a ordenação dos resultados é arbitrária, a menos que AsOrdered for
aplicado, ou há um operador OrderBy explícito na consulta. Para saber mais, veja Preservação da ordem em PLINQ.
Also
ParallelEnumerable.AsParallel ParallelEnumerable.As
Parallel
I n this Article
Overloads
AsParallel(IEnumerable) AsParallel(IEnumerable)
AsParallel<TSource>(Partitioner<TSource>) AsParallel<
TSource>(Partitioner<TSource>) Possibilita a paralelização de uma consulta, conforme originada
por um particionador personalizado que é responsável pela
divisão da sequência de entrada em partições.
AsParallel<TSource>(IEnumerable<TSource>) AsParallel<
TSource>(IEnumerable<TSource>) Habilita a paralelização de uma consulta.
Remarks
Esse método associa a consulta PLINQ. Para obter mais informações, consulte PLINQ (Parallel LINQ ).
AsParallel(IEnumerable) AsParallel(IEnumerable)
public static System.Linq.ParallelQuery AsParallel (this System.Collections.IEnumerable source);
static member AsParallel : System.Collections.IEnumerable -> System.Linq.ParallelQuery
Parameters
Um IEnumerable<T> a ser convertido em um ParallelQuery.
Returns
A origem como um ParallelQuery a ser associada a métodos de extensão ParallelEnumerable.
Exceptions
Remarks
O Cast operador pode ser usado para converter um ParallelQuery para um ParallelQuery(T).
Also
AsParallel<TSource>(Partitioner<TSource>) AsParallel<TSource>
(Partitioner<TSource>)
Possibilita a paralelização de uma consulta, conforme originada por um particionador personalizado que é responsável
pela divisão da sequência de entrada em partições.
public static System.Linq.ParallelQuery<TSource> AsParallel<TSource> (this
System.Collections.Concurrent.Partitioner<TSource> source);
static member AsParallel : System.Collections.Concurrent.Partitioner<'Source> ->
System.Linq.ParallelQuery<'Source>
Type Parameters
TSource
Parameters
source Partitioner<TSource> Partitioner<TSource>
Um particionador da sequência de entrada.
Returns
O source como um ParallelQuery a ser associado a métodos de extensão ParallelEnumerable.
Exceptions
Remarks
GetOrderedPartitions do particionador de código-fonte método é usado quando a ordenação é ativada, enquanto
GetPartitions do particionador é usada se a ordenação não é habilitada (padrão). O particionador de origem
GetDynamicPartitions e GetDynamicOrderedPartitions não são usados. Para obter mais informações e exemplos,
consulte Particionadores personalizados para PLINQ e TPL.
Also
public static System.Linq.ParallelQuery<TSource> AsParallel<TSource> (this

static member AsParallel : seq<'Source> -> System.Linq.ParallelQuery<'Source>
Type Parameters
TSource
Parameters
Um IEnumerable<T> a ser convertido em um ParallelQuery<TSource>.
Returns
A fonte como um ParallelQuery<TSource> para associar a métodos de extensão ParallelEnumerable.
Exceptions

Also
ParallelEnumerable.AsSequential ParallelEnumerable.As
Sequential
I n this Article
public static System.Collections.Generic.IEnumerable<TSource> AsSequential<TSource> (this

static member AsSequential : System.Linq.ParallelQuery<'Source> -> seq<'Source>
Type Parameters
TSource
Parameters
Uma ParallelQuery<TSource> a ser convertida em uma IEnumerable<T>.
Returns
A fonte como uma IEnumerable<T> para associar a métodos de extensão sequenciais.
Exceptions
Remarks
Para obter mais informações, consulte preservação da ordem em PLINQ e como: Controle a ordem em uma consulta
PLINQ.
Also
ParallelEnumerable.AsUnordered ParallelEnumerable.As
Unordered
I n this Article
Permite que uma consulta intermediária seja tratada como se nenhuma ordem estivesse implícita entre os elementos.
public static System.Linq.ParallelQuery<TSource> AsUnordered<TSource> (this

static member AsUnordered : System.Linq.ParallelQuery<'Source> -> System.Linq.ParallelQuery<'Source>
Type Parameters
TSource
Parameters
Returns
A sequência de origem com ordem arbitrária.
Exceptions
Remarks
AsUnordered pode fornecer benefícios de desempenho quando a ordenação não é necessário em uma parte de uma
consulta. Por padrão, o PLINQ trata uma sequência de entrada como não ordenada, a menos que OrderBy ou
AsOrdered for especificado. No entanto, se ordenação foi ativada e não é mais necessário, em seguida, AsUnordered
pode ser usado para desativá-lo na consulta intermediária e isso pode resultar em benefícios de desempenho. O
próprio operador AsUnordered não embaralhar a sequência de origem; ele simplesmente remove o requisito de
ordenação para os operadores subsequentes. Se a origem for ordenada, os operadores subsequentes podem manter a
ordenação se ele é mais eficiente para fazer isso. AsUnordered pode ser chamado em qualquer lugar na consulta; ele
não precisa ser chamado imediatamente após AsParallel. Para obter mais informações, consulte Noções básicas sobre
agilização em PLINQ e preservação da ordem em PLINQ.
Also
ParallelEnumerable.Average ParallelEnumerable.Average
I n this Article
Overloads
Average(ParallelQuery<Single>) Average(ParallelQuery<
Single>) Calcula em paralelo a média de uma sequência de valores.
Average(ParallelQuery<Nullable<Int64>>) Average(Parallel
Query<Nullable<Int64>>) Calcula em paralelo a média de uma sequência de valores.
Average(ParallelQuery<Nullable<Int32>>) Average(Parallel
Query<Nullable<Int32>>) Calcula em paralelo a média de uma sequência de valores.
Average(ParallelQuery<Nullable<Double>>) Average(Parallel
Query<Nullable<Double>>) Calcula em paralelo a média de uma sequência de valores.
Average(ParallelQuery<Nullable<Single>>) Average(Parallel
Query<Nullable<Single>>) Calcula em paralelo a média de uma sequência de valores.
Average(ParallelQuery<Int64>) Average(ParallelQuery<
Int64>) Calcula em paralelo a média de uma sequência de valores.
Average(ParallelQuery<Int32>) Average(ParallelQuery<
Int32>) Calcula em paralelo a média de uma sequência de valores.
Average(ParallelQuery<Double>) Average(ParallelQuery<
Double>) Calcula em paralelo a média de uma sequência de valores.
Average(ParallelQuery<Decimal>) Average(ParallelQuery<
Decimal>) Calcula em paralelo a média de uma sequência de valores.
Average(ParallelQuery<Nullable<Decimal>>) Average(Parallel
Query<Nullable<Decimal>>) Calcula em paralelo a média de uma sequência de valores.
Average<TSource>(ParallelQuery<TSource>, Func<TSource,
Single>) Average<TSource>(ParallelQuery<TSource>, Func< Calcula em paralelo a média de uma sequência de valores que
TSource,Single>) são obtidos invocando uma função de transformação em cada
Nullable<Int64>>) Average<TSource>(ParallelQuery< Calcula em paralelo a média de uma sequência de valores que
TSource>, Func<TSource,Nullable<Int64>>) são obtidos invocando uma função de transformação em cada
Nullable<Int32>>) Average<TSource>(ParallelQuery< Calcula em paralelo a média de uma sequência de valores que
TSource>, Func<TSource,Nullable<Int32>>) são obtidos invocando uma função de transformação em cada
Nullable<Double>>) Average<TSource>(ParallelQuery< Calcula em paralelo a média de uma sequência de valores que
TSource>, Func<TSource,Nullable<Double>>) são obtidos invocando uma função de transformação em cada
Nullable<Single>>) Average<TSource>(ParallelQuery< Calcula em paralelo a média de uma sequência de valores que
TSource>, Func<TSource,Nullable<Single>>) são obtidos invocando uma função de transformação em cada
Int64>) Average<TSource>(ParallelQuery<TSource>, Func< Calcula em paralelo a média de uma sequência de valores que
TSource,Int64>) são obtidos invocando uma função de transformação em cada
Int32>) Average<TSource>(ParallelQuery<TSource>, Func< Calcula em paralelo a média de uma sequência de valores que
TSource,Int32>) são obtidos invocando uma função de transformação em cada
Double>) Average<TSource>(ParallelQuery<TSource>, Func< Calcula em paralelo a média de uma sequência de valores que
TSource,Double>) são obtidos invocando uma função de transformação em cada
Decimal>) Average<TSource>(ParallelQuery<TSource>, Func< Calcula em paralelo a média de uma sequência de valores que
TSource,Decimal>) são obtidos invocando uma função de transformação em cada
Nullable<Decimal>>) Average<TSource>(ParallelQuery< Calcula em paralelo a média de uma sequência de valores que
TSource>, Func<TSource,Nullable<Decimal>>) são obtidos invocando uma função de transformação em cada
Average(ParallelQuery<Single>) Average(ParallelQuery<Single>)
public static float Average (this System.Linq.ParallelQuery<float> source);

static member Average : System.Linq.ParallelQuery<single> -> single
Parameters
source ParallelQuery<Single>
Returns
Single Single
Exceptions
Also
public static Nullable<double> Average (this System.Linq.ParallelQuery<Nullable<long>> source);
static member Average : System.Linq.ParallelQuery<Nullable<int64>> -> Nullable<double>
Parameters
source ParallelQuery<Nullable<Int64>>
Returns
Nullable<Double>
Exceptions
A soma ou a contagem de elementos na sequência é maior do que MaxValue. -ou- Uma ou mais exceções ocorreram
durante a avaliação da consulta.
Also
public static Nullable<double> Average (this System.Linq.ParallelQuery<Nullable<int>> source);
static member Average : System.Linq.ParallelQuery<Nullable<int>> -> Nullable<double>
Parameters
Returns
Nullable<Double>
Exceptions

Also
public static Nullable<double> Average (this System.Linq.ParallelQuery<Nullable<double>> source);

static member Average : System.Linq.ParallelQuery<Nullable<double>> -> Nullable<double>
Parameters
source ParallelQuery<Nullable<Double>>
A sequência de origem.
Returns
Nullable<Double>
Exceptions
Uma sequência de valores que são usados para calcular uma média. A média da sequência de valores. source é uma
referência nula (Nothing no Visual Basic).

Also
public static Nullable<float> Average (this System.Linq.ParallelQuery<Nullable<float>> source);

static member Average : System.Linq.ParallelQuery<Nullable<single>> -> Nullable<single>
Parameters
source ParallelQuery<Nullable<Single>>
Returns
Nullable<Single>
Exceptions

Also
Average(ParallelQuery<Int64>) Average(ParallelQuery<Int64>)
public static double Average (this System.Linq.ParallelQuery<long> source);

static member Average : System.Linq.ParallelQuery<int64> -> double
Parameters
source ParallelQuery<Int64>
Returns
Double Double
Exceptions

Also
Average(ParallelQuery<Int32>) Average(ParallelQuery<Int32>)
public static double Average (this System.Linq.ParallelQuery<int> source);

static member Average : System.Linq.ParallelQuery<int> -> double
Parameters
Returns
Double Double
Exceptions

Also
public static double Average (this System.Linq.ParallelQuery<double> source);

static member Average : System.Linq.ParallelQuery<double> -> double
Parameters
source ParallelQuery<Double>
Returns
Double Double
Exceptions

Also
public static decimal Average (this System.Linq.ParallelQuery<decimal> source);

static member Average : System.Linq.ParallelQuery<decimal> -> decimal
Parameters
source ParallelQuery<Decimal>
Returns
Decimal Decimal
Exceptions

Also
public static Nullable<decimal> Average (this System.Linq.ParallelQuery<Nullable<decimal>> source);

static member Average : System.Linq.ParallelQuery<Nullable<decimal>> -> Nullable<decimal>
Parameters
source ParallelQuery<Nullable<Decimal>>
Returns
Nullable<Decimal>
Exceptions

Also
Average<TSource>(ParallelQuery<TSource>,
Func<TSource,Single>) Average<TSource>
(ParallelQuery<TSource>, Func<TSource,Single>)
Calcula em paralelo a média de uma sequência de valores que são obtidos invocando uma função de transformação
public static float Average<TSource> (this System.Linq.ParallelQuery<TSource> source,

static member Average : System.Linq.ParallelQuery<'Source> * Func<'Source, single> -> single
Type Parameters
TSource
Parameters
Returns
Single Single
Exceptions
source ou selector é uma referência nula (Nothing no Visual Basic).
(Gerada como a exceção interna em um AggregateException). A função selector retorna um valor superior a
MaxValue para o tipo de elemento.
Also
(ParallelQuery<TSource>, Func<TSource,Nullable<Int64>>)
public static Nullable<double> Average<TSource> (this System.Linq.ParallelQuery<TSource> source,

Func<TSource,Nullable<long>> selector);
static member Average : System.Linq.ParallelQuery<'Source> * Func<'Source, Nullable<int64>> ->
Nullable<double>
Type Parameters
TSource
Parameters
Returns
Nullable<Double>
Exceptions
Also

Func<TSource,Nullable<int>> selector);
static member Average : System.Linq.ParallelQuery<'Source> * Func<'Source, Nullable<int>> ->
Nullable<double>
Type Parameters
TSource
Parameters
Returns
Nullable<Double>
Exceptions
Also
Func<TSource,Nullable<Double>>) Average<TSource>
(ParallelQuery<TSource>, Func<TSource,Nullable<Double>>)

Func<TSource,Nullable<double>> selector);
static member Average : System.Linq.ParallelQuery<'Source> * Func<'Source, Nullable<double>> ->
Nullable<double>
Type Parameters
TSource
Parameters
Returns
Nullable<Double>
Exceptions
Also
Func<TSource,Nullable<Single>>) Average<TSource>
(ParallelQuery<TSource>, Func<TSource,Nullable<Single>>)
public static Nullable<float> Average<TSource> (this System.Linq.ParallelQuery<TSource> source,

Func<TSource,Nullable<float>> selector);
static member Average : System.Linq.ParallelQuery<'Source> * Func<'Source, Nullable<single>> ->
Nullable<single>
Type Parameters
TSource
Parameters
Returns
Nullable<Single>
Exceptions
Also
(ParallelQuery<TSource>, Func<TSource,Int64>)
public static double Average<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member Average : System.Linq.ParallelQuery<'Source> * Func<'Source, int64> -> double
Type Parameters
TSource
Parameters
Returns
Double Double
Exceptions
Also
(ParallelQuery<TSource>, Func<TSource,Int32>)
static member Average : System.Linq.ParallelQuery<'Source> * Func<'Source, int> -> double
Type Parameters
TSource
Parameters
Returns
Double Double
Exceptions
Also
Func<TSource,Double>) Average<TSource>
(ParallelQuery<TSource>, Func<TSource,Double>)

static member Average : System.Linq.ParallelQuery<'Source> * Func<'Source, double> -> double
Type Parameters
TSource
Parameters
Returns
Double Double
Exceptions
Also
Func<TSource,Decimal>) Average<TSource>
(ParallelQuery<TSource>, Func<TSource,Decimal>)
public static decimal Average<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member Average : System.Linq.ParallelQuery<'Source> * Func<'Source, decimal> -> decimal
Type Parameters
TSource
Parameters
Returns
Decimal Decimal
Exceptions
Also
Func<TSource,Nullable<Decimal>>) Average<TSource>
(ParallelQuery<TSource>, Func<TSource,Nullable<Decimal>>)
public static Nullable<decimal> Average<TSource> (this System.Linq.ParallelQuery<TSource> source,

Func<TSource,Nullable<decimal>> selector);
static member Average : System.Linq.ParallelQuery<'Source> * Func<'Source, Nullable<decimal>> ->
Nullable<decimal>
Type Parameters
TSource
Parameters
Returns
Nullable<Decimal>
Exceptions
Also
ParallelEnumerable.Cast ParallelEnumerable.Cast
I n this Article
Converte os elementos de uma ParallelQuery para o tipo especificado.
public static System.Linq.ParallelQuery<TResult> Cast<TResult> (this System.Linq.ParallelQuery
source);
static member Cast : System.Linq.ParallelQuery -> System.Linq.ParallelQuery<'Result>
Type Parameters
TResult
O tipo para o qual os elementos de source deverão ser convertidos.
Parameters
A sequência que contém os elementos a serem convertidos.
Returns
ParallelQuery<TResult>
Uma sequência que contém cada elemento da sequência de origem é convertido para o tipo especificado.
Exceptions
O tipo da sequência de origem não pôde ser convertido em TResult .
Also
ParallelEnumerable.Concat ParallelEnumerable.Concat
I n this Article
Overloads
Concat<TSource>(ParallelQuery<TSource>, IEnumerable<
TSource>) Concat<TSource>(ParallelQuery<TSource>, Essa sobrecarga Concat nunca deve ser chamada. Esse
IEnumerable<TSource>) método está marcado como obsoleto e sempre gera
Concat<TSource>(ParallelQuery<TSource>, ParallelQuery<
TSource>) Concat<TSource>(ParallelQuery<TSource>, Parallel Concatena duas sequências paralelas.
Query<TSource>)
Concat<TSource>(ParallelQuery<TSource>,
IEnumerable<TSource>) Concat<TSource>
(ParallelQuery<TSource>, IEnumerable<TSource>)
Essa sobrecarga Concat nunca deve ser chamada. Esse método está marcado como obsoleto e sempre gera
[System.Obsolete("The second data source of a binary operator must be of type
System.Linq.ParallelQuery<T> rather than System.Collections.Generic.IEnumerable<T>. To fix this
problem, use the AsParallel() extension method to convert the right data source to
System.Linq.ParallelQuery<T>.")]
public static System.Linq.ParallelQuery<TSource> Concat<TSource> (this
System.Linq.ParallelQuery<TSource> first, System.Collections.Generic.IEnumerable<TSource> second);
static member Concat : System.Linq.ParallelQuery<'Source> * seq<'Source> ->
Type Parameters
TSource
Este parâmetro de tipo não é usado.
Parameters
first ParallelQuery<TSource> ParallelQuery<TSource>
Este parâmetro não é usado.
Returns
Essa sobrecarga sempre gera um NotSupportedException.
Attributes ObsoleteAttribute
Exceptions
NotSupportedException NotSupportedException
A exceção que ocorre quando esse método é chamado.
Remarks
Essa sobrecarga existe para não permitir o uso de Concat com uma fonte de dados à esquerda do tipo
ParallelQuery<TSource> e uma fonte de dados à direita do tipo IEnumerable<T>. Caso contrário, o operador Concat
apareceria a ligação com a implementação paralela, mas na realidade associaria na implementação sequencial.
Also
Concat<TSource>(ParallelQuery<TSource>,
ParallelQuery<TSource>) Concat<TSource>
(ParallelQuery<TSource>, ParallelQuery<TSource>)
Concatena duas sequências paralelas.
public static System.Linq.ParallelQuery<TSource> Concat<TSource> (this
System.Linq.ParallelQuery<TSource> first, System.Linq.ParallelQuery<TSource> second);
static member Concat : System.Linq.ParallelQuery<'Source> * System.Linq.ParallelQuery<'Source> ->
Type Parameters
TSource
Parameters
second ParallelQuery<TSource> ParallelQuery<TSource>
Returns
Uma sequência que contém os elementos concatenados das duas sequências de entrada.
Exceptions
first ou second é uma referência nula (Nothing no Visual Basic).

Also
ParallelEnumerable.Contains ParallelEnumerable.
Contains
I n this Article
Overloads
Contains<TSource>(ParallelQuery<TSource>, TSource,
IEqualityComparer<TSource>) Contains<TSource>(Parallel Determina em paralelo se uma sequência contém um
Query<TSource>, TSource, IEqualityComparer<TSource>) elemento especificado usando um IEqualityComparer<T>.
Contains<TSource>(ParallelQuery<TSource>, TSource) Em paralelo, determina se uma sequência contém um
elemento especificado usando o comparador de igualdade
padrão.
Contains<TSource>(ParallelQuery<TSource>, TSource,
(ParallelQuery<TSource>, TSource, IEqualityComparer<TSource>)
Determina em paralelo se uma sequência contém um elemento especificado usando um IEqualityComparer<T>.
public static bool Contains<TSource> (this System.Linq.ParallelQuery<TSource> source, TSource value,
static member Contains : System.Linq.ParallelQuery<'Source> * 'Source *
Type Parameters
TSource
Parameters
Um comparador de igualdade para comparar valores.
Returns
Boolean Boolean
true se a sequência de origem contiver um elemento que tem o valor especificado; caso contrário, false.
Exceptions
Also
Em paralelo, determina se uma sequência contém um elemento especificado usando o comparador de igualdade
padrão.
public static bool Contains<TSource> (this System.Linq.ParallelQuery<TSource> source, TSource
value);
static member Contains : System.Linq.ParallelQuery<'Source> * 'Source -> bool
Type Parameters
TSource
Parameters
Returns
Boolean Boolean
true se a sequência de origem contiver um elemento que tem o valor especificado; caso contrário, false.
Exceptions
Also
ParallelEnumerable.Count ParallelEnumerable.Count
I n this Article
Overloads
Count<TSource>(ParallelQuery<TSource>) Count<TSource>(
ParallelQuery<TSource>) Retorna o número de elementos em uma sequência paralela.
Count<TSource>(ParallelQuery<TSource>, Func<TSource,
Boolean>) Count<TSource>(ParallelQuery<TSource>, Func< Retorna um número que representa quantos elementos na
TSource,Boolean>) sequência paralela especificada satisfazem uma condição.
Count<TSource>(ParallelQuery<TSource>) Count<TSource>
Retorna o número de elementos em uma sequência paralela.
public static int Count<TSource> (this System.Linq.ParallelQuery<TSource> source);
static member Count : System.Linq.ParallelQuery<'Source> -> int
Type Parameters
TSource
Parameters
Returns
Int32 Int32
Exceptions
O número de elementos na origem é maior do que MaxValue. (Nesse caso, é InnerException OverflowException) -ou-
Also
Count<TSource>(ParallelQuery<TSource>,
Count<TSource>(ParallelQuery<TSource>,
Func<TSource,Boolean>) Count<TSource>
(ParallelQuery<TSource>, Func<TSource,Boolean>)
Retorna um número que representa quantos elementos na sequência paralela especificada satisfazem uma condição.
public static int Count<TSource> (this System.Linq.ParallelQuery<TSource> source, Func<TSource,bool>
predicate);
static member Count : System.Linq.ParallelQuery<'Source> * Func<'Source, bool> -> int
Type Parameters
TSource
Parameters
Returns
Int32 Int32
Exceptions
O número de elementos na origem é maior do que MaxValue. (Nesse caso, é InnerException OverflowException) -ou-
Also
ParallelEnumerable.DefaultIfEmpty ParallelEnumerable.
DefaultIfEmpty
I n this Article
Overloads
DefaultIfEmpty<TSource>(ParallelQuery<TSource>) DefaultIf
Empty<TSource>(ParallelQuery<TSource>) Retorna os elementos da sequência paralela especificada ou o
valor padrão do parâmetro de tipo em uma coleção de
singleton se a sequência estiver vazia.
DefaultIfEmpty<TSource>(ParallelQuery<TSource>, TSource) Retorna os elementos da sequência paralela especificada ou o
valor especificado em uma coleção de singleton, se a
sequência estiver vazia.
Retorna os elementos da sequência paralela especificada ou o valor padrão do parâmetro de tipo em uma coleção de
singleton se a sequência estiver vazia.
public static System.Linq.ParallelQuery<TSource> DefaultIfEmpty<TSource> (this
static member DefaultIfEmpty : System.Linq.ParallelQuery<'Source> ->
Type Parameters
TSource
Parameters
A sequência para a qual será retornado um valor padrão se ela estiver vazia.
Returns
Uma sequência que contém default(TSource) se source estiver vazio; caso contrário, source .
Exceptions
Also
Retorna os elementos da sequência paralela especificada ou o valor especificado em uma coleção de singleton, se a
sequência estiver vazia.
public static System.Linq.ParallelQuery<TSource> DefaultIfEmpty<TSource> (this
System.Linq.ParallelQuery<TSource> source, TSource defaultValue);
static member DefaultIfEmpty : System.Linq.ParallelQuery<'Source> * 'Source ->
Type Parameters
TSource
Parameters
A sequência para a qual será retornado o valor especificado se ela estiver vazia.
Returns
Uma sequência que contém defaultValue se source estiver vazio; caso contrário, source .
Exceptions
Also
ParallelEnumerable.Distinct ParallelEnumerable.Distinct
I n this Article
Overloads
Distinct<TSource>(ParallelQuery<TSource>) Distinct<
TSource>(ParallelQuery<TSource>) Retorna elementos distintos de uma sequência paralela
usando o comparador de igualdade padrão para comparar
valores.
Distinct<TSource>(ParallelQuery<TSource>, IEquality
Comparer<TSource>) Distinct<TSource>(ParallelQuery< Retorna os elementos distintos de uma sequência paralela
TSource>, IEqualityComparer<TSource>) usando um IEqualityComparer<T> para comparar valores.
Distinct<TSource>(ParallelQuery<TSource>) Distinct<TSource>
Retorna elementos distintos de uma sequência paralela usando o comparador de igualdade padrão para comparar
valores.
public static System.Linq.ParallelQuery<TSource> Distinct<TSource> (this
static member Distinct : System.Linq.ParallelQuery<'Source> -> System.Linq.ParallelQuery<'Source>
Type Parameters
TSource
Parameters
Returns
Uma sequência que contém elementos distintos de sequência de origem.
Exceptions
Also
Distinct<TSource>(ParallelQuery<TSource>,
(ParallelQuery<TSource>, IEqualityComparer<TSource>)
Retorna os elementos distintos de uma sequência paralela usando um IEqualityComparer<T> para comparar valores.
public static System.Linq.ParallelQuery<TSource> Distinct<TSource> (this
System.Linq.ParallelQuery<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>
comparer);
static member Distinct : System.Linq.ParallelQuery<'Source> *
System.Collections.Generic.IEqualityComparer<'Source> -> System.Linq.ParallelQuery<'Source>
Type Parameters
TSource
Parameters
Returns
Uma sequência que contém elementos distintos de sequência de origem.
Exceptions
Also
ParallelEnumerable.ElementAt ParallelEnumerable.
ElementAt
I n this Article
Retorna o elemento em um índice especificado em uma sequência paralela.
public static TSource ElementAt<TSource> (this System.Linq.ParallelQuery<TSource> source, int

index);
static member ElementAt : System.Linq.ParallelQuery<'Source> * int -> 'Source
Type Parameters
TSource
Parameters
Uma sequência da qual retornar um elemento.
index Int32 Int32
Returns
TSource TSource
O elemento na posição especificada na sequência de origem.
Exceptions
index é menor que 0 ou maior ou igual ao número de elementos em source .
Also
ParallelEnumerable.ElementAtOrDefault Parallel
Enumerable.ElementAtOrDefault
I n this Article
Retorna o elemento em um índice especificado em uma sequência ou um valor padrão paralelo se o índice estiver fora
do intervalo.
public static TSource ElementAtOrDefault<TSource> (this System.Linq.ParallelQuery<TSource> source,
int index);
static member ElementAtOrDefault : System.Linq.ParallelQuery<'Source> * int -> 'Source
Type Parameters
TSource
Parameters
Uma sequência da qual retornar um elemento.
index Int32 Int32
Returns
TSource TSource
default(TSource) se o índice estiver fora dos limites da sequência de origem; caso contrário, o elemento na posição
especificada na sequência de origem.
Exceptions
Also
ParallelEnumerable.Empty ParallelEnumerable.Empty
I n this Article
Retorna uma ParallelQuery{TResult} vazia com o argumento do tipo especificado.
public static System.Linq.ParallelQuery<TResult> Empty<TResult> ();
static member Empty : unit -> System.Linq.ParallelQuery<'Result>
Type Parameters
TResult
O tipo a ser atribuído ao parâmetro de tipo da sequência retornada genérico.
Returns
Uma sequência vazia cujo argumento de tipo é TResult .
Also
ParallelEnumerable.Except ParallelEnumerable.Except
I n this Article
Overloads
Except<TSource>(ParallelQuery<TSource>, IEnumerable<
TSource>) Except<TSource>(ParallelQuery<TSource>, Essa sobrecarga Except nunca deve ser chamada. Esse método
IEnumerable<TSource>) está marcado como obsoleto e sempre gera
Except<TSource>(ParallelQuery<TSource>, ParallelQuery<
TSource>) Except<TSource>(ParallelQuery<TSource>, Parallel Produz a diferença de conjunto de duas sequências paralelas
Query<TSource>) usando o comparador de igualdade padrão para comparar os
valores.
Except<TSource>(ParallelQuery<TSource>, IEnumerable<
TSource>, IEqualityComparer<TSource>) Except<TSource>( Essa sobrecarga Except nunca deve ser chamada. Esse método
ParallelQuery<TSource>, IEnumerable<TSource>, IEquality está marcado como obsoleto e sempre gera
Comparer<TSource>) NotSupportedException quando chamado.
Except<TSource>(ParallelQuery<TSource>, ParallelQuery<
TSource>, IEqualityComparer<TSource>) Except<TSource>( Produz a diferença de conjunto de duas sequências paralelas
ParallelQuery<TSource>, ParallelQuery<TSource>, IEquality usando o IEqualityComparer<T> especificado para comparar
Comparer<TSource>) os valores.
Except<TSource>(ParallelQuery<TSource>,
IEnumerable<TSource>) Except<TSource>
public static System.Linq.ParallelQuery<TSource> Except<TSource> (this
static member Except : System.Linq.ParallelQuery<'Source> * seq<'Source> ->
Type Parameters
TSource
Parameters
Returns
Exceptions
Remarks
Essa sobrecarga existe para não permitir o uso de exceto com uma fonte de dados à esquerda do tipo
ParallelQuery<TSource> e uma fonte de dados à direita do tipo IEnumerable<T>. Caso contrário, o operador Except
Also
ParallelQuery<TSource>) Except<TSource>
Produz a diferença de conjunto de duas sequências paralelas usando o comparador de igualdade padrão para
static member Except : System.Linq.ParallelQuery<'Source> * System.Linq.ParallelQuery<'Source> ->
Type Parameters
TSource
Parameters
Uma sequência cujos elementos que não estão também em second será retornada.

Uma sequência cujos elementos que também ocorrem na primeira sequência fará com que esses elementos sejam
removido da sequência retornada.
Returns
Exceptions
Also

System.Linq.ParallelQuery<TSource> first, System.Collections.Generic.IEnumerable<TSource> second,
static member Except : System.Linq.ParallelQuery<'Source> * seq<'Source> *
Type Parameters
TSource
Parameters
Returns
Exceptions
Remarks
Essa sobrecarga existe para não permitir o uso de exceto com uma fonte de dados à esquerda do tipo
ParallelQuery<TSource> e uma fonte de dados à direita do tipo IEnumerable<T>. Caso contrário, o operador Except
Also
ParallelQuery<TSource>, IEqualityComparer<TSource>)
Produz a diferença de conjunto de duas sequências paralelas usando o IEqualityComparer<T> especificado para

System.Linq.ParallelQuery<TSource> first, System.Linq.ParallelQuery<TSource> second,
static member Except : System.Linq.ParallelQuery<'Source> * System.Linq.ParallelQuery<'Source> *
Type Parameters
TSource
Parameters
Uma sequência cujos elementos que não estão também em second será retornada.

Uma sequência cujos elementos que também ocorrem na primeira sequência fará com que esses elementos sejam
removido da sequência retornada.
IEqualityComparer<T> para comparar valores.
Returns
Exceptions
Also
ParallelEnumerable.First ParallelEnumerable.First
I n this Article
Overloads
First<TSource>(ParallelQuery<TSource>) First<TSource>(
ParallelQuery<TSource>) Retorna o primeiro elemento de uma sequência paralela.
First<TSource>(ParallelQuery<TSource>, Func<TSource,
Boolean>) First<TSource>(ParallelQuery<TSource>, Func< Retorna o primeiro elemento em uma sequência paralela que
TSource,Boolean>) satisfaz uma condição especificada.
First<TSource>(ParallelQuery<TSource>) First<TSource>
Retorna o primeiro elemento de uma sequência paralela.
public static TSource First<TSource> (this System.Linq.ParallelQuery<TSource> source);
static member First : System.Linq.ParallelQuery<'Source> -> 'Source
Type Parameters
TSource
Parameters
A sequência da qual retornar o primeiro elemento.
Returns
TSource TSource
O primeiro elemento na sequência especificada.
Exceptions
Remarks
Se a consulta não é solicitada, o primeiro elemento é não determinística. Para saber mais, veja Preservação da ordem
em PLINQ.
Also
First<TSource>(ParallelQuery<TSource>,
Func<TSource,Boolean>) First<TSource>
Retorna o primeiro elemento em uma sequência paralela que satisfaz uma condição especificada.
public static TSource First<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member First : System.Linq.ParallelQuery<'Source> * Func<'Source, bool> -> 'Source
Type Parameters
TSource
Parameters
A sequência da qual retornar um elemento.
Returns
TSource TSource
O primeiro elemento na sequência que passa o teste na função de predicado especificada.
Exceptions
Nenhum elemento de source satisfaz a condição em predicate .
Remarks
em PLINQ.
Also
ParallelEnumerable.FirstOrDefault ParallelEnumerable.
FirstOrDefault
I n this Article
Overloads
FirstOrDefault<TSource>(ParallelQuery<TSource>) FirstOr
Default<TSource>(ParallelQuery<TSource>) Retornará o primeiro elemento de uma sequência paralela ou
um valor padrão, se a sequência não contiver elementos.
FirstOrDefault<TSource>(ParallelQuery<TSource>, Func<
TSource,Boolean>) FirstOrDefault<TSource>(ParallelQuery< Retorna o primeiro elemento da sequência paralela que
TSource>, Func<TSource,Boolean>) satisfaz a uma condição ou um valor padrão, caso esse
Retornará o primeiro elemento de uma sequência paralela ou um valor padrão, se a sequência não contiver elementos.
public static TSource FirstOrDefault<TSource> (this System.Linq.ParallelQuery<TSource> source);
static member FirstOrDefault : System.Linq.ParallelQuery<'Source> -> 'Source
Type Parameters
TSource
Parameters
A sequência da qual retornar o primeiro elemento.
Returns
TSource TSource
default(TSource) se source estiver vazio; caso contrário, o primeiro elemento em source .
Exceptions
Remarks
em PLINQ.
Also
FirstOrDefault<TSource>(ParallelQuery<TSource>,
Func<TSource,Boolean>) FirstOrDefault<TSource>
Retorna o primeiro elemento da sequência paralela que satisfaz a uma condição ou um valor padrão, caso esse
public static TSource FirstOrDefault<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member FirstOrDefault : System.Linq.ParallelQuery<'Source> * Func<'Source, bool> -> 'Source
Type Parameters
TSource
Parameters
Returns
TSource TSource
default(TSource) se source estiver vazio ou se nenhum elemento for aprovado no teste especificado pelo predicado;
caso contrário, o primeiro elemento em source que for aprovado no teste especificado pelo predicado.
Exceptions
Remarks
em PLINQ.
Also
ParallelEnumerable.ForAll ParallelEnumerable.ForAll
I n this Article
Invoca a ação especificada em paralelo para cada elemento no source .
public static void ForAll<TSource> (this System.Linq.ParallelQuery<TSource> source, Action<TSource>

action);
static member ForAll : System.Linq.ParallelQuery<'Source> * Action<'Source> -> unit
Type Parameters
TSource
Parameters
O ParallelQuery<TSource> cujos elementos serão processados pelo action .
action Action<TSource>
Uma Ação que será invocada em cada elemento.
Exceptions
source ou action é uma referência nula (Nothing no Visual Basic).
Remarks
Isso é uma maneira eficiente para processar a saída de uma consulta em paralelo, porque ele não requer uma etapa de
mesclagem no final. Para obter mais informações, consulte opções de mesclagem em PLINQ ou preservação da
ordem em PLINQ. Como esse método produz um efeito colateral, ele pode ser usado para observar a ordem real de
execução em uma consulta paralela.
Also
ParallelEnumerable.GroupBy ParallelEnumerable.Group
By
I n this Article
Overloads
GroupBy<TSource,TKey,TElement,TResult>(ParallelQuery<
Func<TKey,IEnumerable<TElement>,TResult>, IEquality função do seletor de chave especificada e cria um valor de
Comparer<TKey>) GroupBy<TSource,TKey,TElement,TResult>( resultado de cada grupo e sua chave. Os valores da chave são
ParallelQuery<TSource>, Func<TSource,TKey>, Func<TSource, comparados usando um comparador especificado e os
TElement>, Func<TKey,IEnumerable<TElement>,TResult>, elementos de cada grupo são projetados usando uma função
IEqualityComparer<TKey>) especificada.
GroupBy<TSource,TKey,TElement,TResult>(ParallelQuery<
TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Agrupa em paralelo os elementos de uma sequência de
Func<TKey,IEnumerable<TElement>,TResult>) GroupBy< acordo com uma função do seletor de chave especificada e cria
TSource,TKey,TElement,TResult>(ParallelQuery<TSource>, um valor de resultado de cada grupo e sua chave. Os
Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey, elementos de cada grupo são projetados usando uma função
IEnumerable<TElement>,TResult>) especificada.
GroupBy<TSource,TKey,TElement>(ParallelQuery<TSource>,
Func<TSource,TKey>, Func<TSource,TElement>) GroupBy< Agrupa em paralelo os elementos de uma sequência de
TSource,TKey,TElement>(ParallelQuery<TSource>, Func< acordo com a função de seletor de chave especificada e
TSource,TKey>, Func<TSource,TElement>) projeta os elementos de cada grupo usando uma função
especificada.
Func<TSource,TKey>, Func<TSource,TElement>, IEquality Agrupa em paralelo os elementos de uma sequência de
Comparer<TKey>) GroupBy<TSource,TKey,TElement>(Parallel acordo com uma função de seletor de chave. As chaves são
Query<TSource>, Func<TSource,TKey>, Func<TSource, comparadas usando um comparador e os elementos de cada
TElement>, IEqualityComparer<TKey>) grupo são projetados usando uma função especificada.
GroupBy<TSource,TKey,TResult>(ParallelQuery<TSource>,
Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>, Agrupa em paralelo os elementos de uma sequência de
TResult>) GroupBy<TSource,TKey,TResult>(ParallelQuery< acordo com uma função do seletor de chave especificada e cria
TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable< um valor de resultado de cada grupo e sua chave.
TSource>,TResult>)
Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>, Agrupa em paralelo os elementos de uma sequência de
TResult>, IEqualityComparer<TKey>) GroupBy<TSource,TKey, acordo com uma função do seletor de chave especificada e cria
TResult>(ParallelQuery<TSource>, Func<TSource,TKey>, um valor de resultado de cada grupo e sua chave. As chaves
Func<TKey,IEnumerable<TSource>,TResult>, IEquality são comparadas usando um comparador especificado.
Comparer<TKey>)
GroupBy<TSource,TKey>(ParallelQuery<TSource>, Func<
TSource,TKey>, IEqualityComparer<TKey>) GroupBy<TSource, Agrupa em paralelo os elementos de uma sequência de
TKey>(ParallelQuery<TSource>, Func<TSource,TKey>, acordo com uma função do seletor de chave especificada e
IEqualityComparer<TKey>) compara as chaves usando um IComparer<T> especificado.
GroupBy<TSource,TKey>(ParallelQuery<TSource>, Func<
TSource,TKey>) GroupBy<TSource,TKey>(ParallelQuery< Agrupa em paralelo os elementos de uma sequência de
(ParallelQuery<TSource>, Func<TSource,TKey>,
resultado de cada grupo e sua chave. Os valores da chave são comparados usando um comparador especificado e os
elementos de cada grupo são projetados usando uma função especificada.
public static System.Linq.ParallelQuery<TResult> GroupBy<TSource,TKey,TElement,TResult> (this

System.Linq.ParallelQuery<TSource> source, Func<TSource,TKey> keySelector, Func<TSource,TElement>
elementSelector, Func<TKey,System.Collections.Generic.IEnumerable<TElement>,TResult> resultSelector,
static member GroupBy : System.Linq.ParallelQuery<'Source> * Func<'Source, 'Key> * Func<'Source,
'Element> * Func<'Key, seq<'Element>, 'Result> * System.Collections.Generic.IEqualityComparer<'Key>
-> System.Linq.ParallelQuery<'Result>
Type Parameters
TSource
TKey
TElement
O tipo dos elementos em cada IGrouping {TKey, TElement}.
TResult
Parameters
A sequência cujos elementos agrupar.
Uma função para mapear cada elemento de origem para um elemento em um IGrouping{Key, TElement}.
Returns
Uma sequência de elementos do tipo TResult , em que cada elemento representa uma projeção em um grupo e sua
chave.
Exceptions
Also
Agrupa em paralelo os elementos de uma sequência de acordo com uma função do seletor de chave especificada e cria
um valor de resultado de cada grupo e sua chave. Os elementos de cada grupo são projetados usando uma função
especificada.
public static System.Linq.ParallelQuery<TResult> GroupBy<TSource,TKey,TElement,TResult> (this

elementSelector, Func<TKey,System.Collections.Generic.IEnumerable<TElement>,TResult>
resultSelector);
'Element> * Func<'Key, seq<'Element>, 'Result> -> System.Linq.ParallelQuery<'Result>
Type Parameters
TSource
TKey
TElement
O tipo dos elementos em cada IGrouping {TKey, TElement}.
TResult
Parameters
Uma função para mapear cada elemento de origem para um elemento em um IGrouping<TKey, TElement>.
Returns
chave.
Exceptions
Also
Agrupa em paralelo os elementos de uma sequência de acordo com a função de seletor de chave especificada e projeta
os elementos de cada grupo usando uma função especificada.
public static System.Linq.ParallelQuery<System.Linq.IGrouping<TKey,TElement>>
GroupBy<TSource,TKey,TElement> (this System.Linq.ParallelQuery<TSource> source, Func<TSource,TKey>
keySelector, Func<TSource,TElement> elementSelector);
'Element> -> System.Linq.ParallelQuery<System.Linq.IGrouping<'Key, 'Element>>
Type Parameters
TSource
TKey
TElement
Parameters
Um OrderedParallelQuery<TSource> que contém elementos a ser classificados.
Returns
ParallelQuery<IGrouping<TKey,TElement>>
Uma sequência de grupos que são classificados em ordem decrescente de acordo com TKey .
Exceptions
Also
Agrupa em paralelo os elementos de uma sequência de acordo com uma função de seletor de chave. As chaves são
comparadas usando um comparador e os elementos de cada grupo são projetados usando uma função especificada.
public static System.Linq.ParallelQuery<System.Linq.IGrouping<TKey,TElement>>

GroupBy<TSource,TKey,TElement> (this System.Linq.ParallelQuery<TSource> source, Func<TSource,TKey>
keySelector, Func<TSource,TElement> elementSelector,
'Element> * System.Collections.Generic.IEqualityComparer<'Key> ->
System.Linq.ParallelQuery<System.Linq.IGrouping<'Key, 'Element>>
Type Parameters
TSource
TKey
TElement
O tipo dos elementos no IGrouping
Parameters
Uma OrderedParallelQuery{TSource} que contém elementos a classificar.
Uma função para mapear cada elemento de origem para um elemento em um IGrouping.
Um IComparer{TSource} para comparar as chaves.
Returns
ParallelQuery<IGrouping<TKey,TElement>>
Exceptions
Also
Func<TSource,TKey>,
Func<TSource,TKey>,
um valor de resultado de cada grupo e sua chave.
public static System.Linq.ParallelQuery<TResult> GroupBy<TSource,TKey,TResult> (this

System.Linq.ParallelQuery<TSource> source, Func<TSource,TKey> keySelector,
Func<TKey,System.Collections.Generic.IEnumerable<TSource>,TResult> resultSelector);
static member GroupBy : System.Linq.ParallelQuery<'Source> * Func<'Source, 'Key> * Func<'Key,
seq<'Source>, 'Result> -> System.Linq.ParallelQuery<'Result>
Type Parameters
TSource
TKey
TResult
Parameters
Returns
chave.
Exceptions
Also
Func<TSource,TKey>,
um valor de resultado de cada grupo e sua chave. As chaves são comparadas usando um comparador especificado.
public static System.Linq.ParallelQuery<TResult> GroupBy<TSource,TKey,TResult> (this

Func<TKey,System.Collections.Generic.IEnumerable<TSource>,TResult> resultSelector,
static member GroupBy : System.Linq.ParallelQuery<'Source> * Func<'Source, 'Key> * Func<'Key,
seq<'Source>, 'Result> * System.Collections.Generic.IEqualityComparer<'Key> ->
System.Linq.ParallelQuery<'Result>
Type Parameters
TSource
TKey
TResult
Parameters
Returns
Uma sequência de grupos.
Exceptions
Also
GroupBy<TSource,TKey>(ParallelQuery<TSource>,
Agrupa em paralelo os elementos de uma sequência de acordo com uma função do seletor de chave especificada e
compara as chaves usando um IComparer<T> especificado.
public static System.Linq.ParallelQuery<System.Linq.IGrouping<TKey,TSource>> GroupBy<TSource,TKey>
(this System.Linq.ParallelQuery<TSource> source, Func<TSource,TKey> keySelector,
static member GroupBy : System.Linq.ParallelQuery<'Source> * Func<'Source, 'Key> *
System.Collections.Generic.IEqualityComparer<'Key> ->
System.Linq.ParallelQuery<System.Linq.IGrouping<'Key, 'Source>>
Type Parameters
TSource
TKey
O tipo da chave retornada por keySelector >.
Parameters
Um OrderedParallelQuery<TSource> que contém elementos a ser classificados.
Returns
ParallelQuery<IGrouping<TKey,TSource>>
Exceptions
Also
Func<TSource,TKey>) GroupBy<TSource,TKey>
(ParallelQuery<TSource>, Func<TSource,TKey>)
Agrupa em paralelo os elementos de uma sequência de acordo com uma função de seletor de chave especificada.
public static System.Linq.ParallelQuery<System.Linq.IGrouping<TKey,TSource>> GroupBy<TSource,TKey>

(this System.Linq.ParallelQuery<TSource> source, Func<TSource,TKey> keySelector);
static member GroupBy : System.Linq.ParallelQuery<'Source> * Func<'Source, 'Key> ->
System.Linq.ParallelQuery<System.Linq.IGrouping<'Key, 'Source>>
Type Parameters
TSource
TKey
Parameters
Returns
ParallelQuery<IGrouping<TKey,TSource>>
Exceptions
Also
ParallelEnumerable.GroupJoin ParallelEnumerable.Group
Join
I n this Article
Overloads
GroupJoin<TOuter,TInner,TKey,TResult>(ParallelQuery<
TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func< Essa sobrecarga GroupJoin nunca deve ser chamada. Esse
TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>) método está marcado como obsoleto e sempre gera
GroupJoin<TOuter,TInner,TKey,TResult>(ParallelQuery< NotSupportedException quando chamado.
TOuter>, ParallelQuery<TInner>, Func<TOuter,TKey>, Func< Correlaciona em paralelo os elementos de duas sequências
TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>) com base na igualdade de chaves e agrupa os resultados. O
GroupJoin<TOuter,TInner,TKey,TResult>(ParallelQuery< comparador de igualdade padrão é usado para comparar
TOuter>, ParallelQuery<TInner>, Func<TOuter,TKey>, Func< chaves.
TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func< Essa sobrecarga GroupJoin nunca deve ser chamada. Esse
TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>, método está marcado como obsoleto e sempre gera
IEqualityComparer<TKey>) GroupJoin<TOuter,TInner,TKey, NotSupportedException quando chamado.
TResult>(ParallelQuery<TOuter>, IEnumerable<TInner>,
TOuter>, ParallelQuery<TInner>, Func<TOuter,TKey>, Func< Correlaciona em paralelo os elementos de duas sequências
TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>, com base na igualdade de chaves e agrupa os resultados. Um
IEqualityComparer<TKey>) GroupJoin<TOuter,TInner,TKey, IEqualityComparer<T> especificado é usado para comparar
TResult>(ParallelQuery<TOuter>, ParallelQuery<TInner>, chaves.
GroupJoin<TOuter,TInner,TKey,TResult>(ParallelQuery<TOuter>,
public static System.Linq.ParallelQuery<TResult> GroupJoin<TOuter,TInner,TKey,TResult> (this
System.Linq.ParallelQuery<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner,
Func<TOuter,TKey> outerKeySelector, Func<TInner,TKey> innerKeySelector,
static member GroupJoin : System.Linq.ParallelQuery<'Outer> * seq<'Inner> * Func<'Outer, 'Key> *
Func<'Inner, 'Key> * Func<'Outer, seq<'Inner>, 'Result> -> System.Linq.ParallelQuery<'Result>
Type Parameters
TOuter
TInner
TKey
TResult
Parameters
outer ParallelQuery<TOuter>
Returns
Exceptions
Remarks
Essa sobrecarga existe para não permitir o uso de GroupJoin com uma fonte de dados à esquerda do tipo
ParallelQuery<TSource> e uma fonte de dados à direita do tipo IEnumerable<T>. Caso contrário, o operador de
GroupJoin apareceria a ligação com a implementação paralela, mas na realidade associaria na implementação
sequencial.
Also
ParallelQuery<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>,
Correlaciona em paralelo os elementos de duas sequências com base na igualdade de chaves e agrupa os resultados.
O comparador de igualdade padrão é usado para comparar chaves.

System.Linq.ParallelQuery<TOuter> outer, System.Linq.ParallelQuery<TInner> inner, Func<TOuter,TKey>
outerKeySelector, Func<TInner,TKey> innerKeySelector,
static member GroupJoin : System.Linq.ParallelQuery<'Outer> * System.Linq.ParallelQuery<'Inner> *
Func<'Outer, 'Key> * Func<'Inner, 'Key> * Func<'Outer, seq<'Inner>, 'Result> ->
Type Parameters
TOuter
TInner
TKey
TResult
Parameters
inner ParallelQuery<TInner>
Returns
Uma sequência que tem elementos do tipo TResult que são obtidos executando uma junção agrupada em duas
sequências.
Exceptions
Also
Func<TOuter,TKey> outerKeySelector, Func<TInner,TKey> innerKeySelector,
static member GroupJoin : System.Linq.ParallelQuery<'Outer> * seq<'Inner> * Func<'Outer, 'Key> *
Func<'Inner, 'Key> * Func<'Outer, seq<'Inner>, 'Result> *
System.Collections.Generic.IEqualityComparer<'Key> -> System.Linq.ParallelQuery<'Result>
Type Parameters
TOuter
TInner
TKey
TResult
Parameters
Returns
Exceptions
Remarks
Essa sobrecarga existe para não permitir o uso de GroupJoin com uma fonte de dados à esquerda do tipo
GroupJoin apareceria a ligação com a implementação paralela, mas na realidade associaria na implementação
sequencial.
Also
Correlaciona em paralelo os elementos de duas sequências com base na igualdade de chaves e agrupa os resultados.
Um IEqualityComparer<T> especificado é usado para comparar chaves.

outerKeySelector, Func<TInner,TKey> innerKeySelector,
static member GroupJoin : System.Linq.ParallelQuery<'Outer> * System.Linq.ParallelQuery<'Inner> *
Func<'Outer, 'Key> * Func<'Inner, 'Key> * Func<'Outer, seq<'Inner>, 'Result> *
Type Parameters
TOuter
TInner
TKey
TResult
Parameters
Returns
Uma sequência que tem elementos do tipo TResult que são obtidos executando uma junção agrupada em duas
sequências.
Exceptions
Also
ParallelEnumerable.Intersect ParallelEnumerable.Intersect
I n this Article
Overloads
Intersect<TSource>(ParallelQuery<TSource>, IEnumerable<
TSource>, IEqualityComparer<TSource>) Intersect<TSource>( Essa sobrecarga Intersect nunca deve ser chamada. Esse
ParallelQuery<TSource>, IEnumerable<TSource>, IEquality método está marcado como obsoleto e sempre gera
Intersect<TSource>(ParallelQuery<TSource>, ParallelQuery<
TSource>, IEqualityComparer<TSource>) Intersect<TSource>( Produz a interseção de conjunto de duas sequências paralelas
ParallelQuery<TSource>, ParallelQuery<TSource>, IEquality usando o IEqualityComparer{T} especificado para comparar os
Comparer<TSource>) valores.
Intersect<TSource>(ParallelQuery<TSource>, IEnumerable<
TSource>) Intersect<TSource>(ParallelQuery<TSource>, Essa sobrecarga Intersect nunca deve ser chamada. Esse
IEnumerable<TSource>) método está marcado como obsoleto e sempre gera
Intersect<TSource>(ParallelQuery<TSource>, ParallelQuery<
TSource>) Intersect<TSource>(ParallelQuery<TSource>, Produz a interseção de conjunto de duas sequências em
ParallelQuery<TSource>) paralelo usando o comparador de igualdade padrão para
Intersect<TSource>(ParallelQuery<TSource>,
public static System.Linq.ParallelQuery<TSource> Intersect<TSource> (this
static member Intersect : System.Linq.ParallelQuery<'Source> * seq<'Source> *
Type Parameters
TSource
Parameters
Returns
Exceptions
Remarks
Essa sobrecarga existe para não permitir o uso de interseção com uma fonte de dados à esquerda do tipo
ParallelQuery<TSource> e uma fonte de dados à direita do tipo IEnumerable<T>. Caso contrário, o operador Intersect
Also
Produz a interseção de conjunto de duas sequências paralelas usando o IEqualityComparer{T} especificado para
static member Intersect : System.Linq.ParallelQuery<'Source> * System.Linq.ParallelQuery<'Source> *
Type Parameters
TSource
Parameters
A sequência cujos elementos distintos que também são exibidos em second será retornada.
Uma sequência cujos elementos distintos que também são exibidos na primeira sequência serão retornados.
Returns
Exceptions
Also

static member Intersect : System.Linq.ParallelQuery<'Source> * seq<'Source> ->
Type Parameters
TSource
Parameters
Returns
Exceptions
Remarks
Essa sobrecarga existe para não permitir o uso de interseção com uma fonte de dados à esquerda do tipo
ParallelQuery<TSource> e uma fonte de dados à direita do tipo IEnumerable<T>. Caso contrário, o operador Intersect
Also
ParallelQuery<TSource>) Intersect<TSource>
Produz a interseção de conjunto de duas sequências em paralelo usando o comparador de igualdade padrão para

static member Intersect : System.Linq.ParallelQuery<'Source> * System.Linq.ParallelQuery<'Source> ->
Type Parameters
TSource
Parameters
A sequência cujos elementos distintos que também são exibidos em second será retornada.

Uma sequência cujos elementos distintos que também são exibidos na primeira sequência serão retornados.
Returns
Exceptions
Also
ParallelEnumerable.Join ParallelEnumerable.Join
I n this Article
Overloads
Join<TOuter,TInner,TKey,TResult>(ParallelQuery<TOuter>,
IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner, Essa sobrecarga Join nunca deve ser chamada. Esse método
TKey>, Func<TOuter,TInner,TResult>) Join<TOuter,TInner, está marcado como obsoleto e sempre gera
TKey,TResult>(ParallelQuery<TOuter>, IEnumerable<TInner>, NotSupportedException quando invocado.
TInner,TResult>)
ParallelQuery<TInner>, Func<TOuter,TKey>, Func<TInner, Correlaciona em paralelo os elementos de duas sequências
TKey>, Func<TOuter,TInner,TResult>) Join<TOuter,TInner, com base em chaves de correspondência. O comparador de
TKey,TResult>(ParallelQuery<TOuter>, ParallelQuery< igualdade padrão é usado para comparar chaves.
TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<
TOuter,TInner,TResult>)
IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner, Essa sobrecarga Join nunca deve ser chamada. Esse método
TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer< está marcado como obsoleto e sempre gera
TKey>) Join<TOuter,TInner,TKey,TResult>(ParallelQuery< NotSupportedException quando invocado.
Comparer<TKey>)
ParallelQuery<TInner>, Func<TOuter,TKey>, Func<TInner, Correlaciona em paralelo os elementos de duas sequências
TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer< com base em chaves de correspondência. Um
TKey>) Join<TOuter,TInner,TKey,TResult>(ParallelQuery< IEqualityComparer<T> especificado é usado para comparar
TOuter>, ParallelQuery<TInner>, Func<TOuter,TKey>, Func< chaves.
Comparer<TKey>)
(ParallelQuery<TOuter>, IEnumerable<TInner>,
public static System.Linq.ParallelQuery<TResult> Join<TOuter,TInner,TKey,TResult> (this
Func<TOuter,TKey> outerKeySelector, Func<TInner,TKey> innerKeySelector, Func<TOuter,TInner,TResult>
resultSelector);
static member Join : System.Linq.ParallelQuery<'Outer> * seq<'Inner> * Func<'Outer, 'Key> *
Func<'Inner, 'Key> * Func<'Outer, 'Inner, 'Result> -> System.Linq.ParallelQuery<'Result>
Type Parameters
TOuter
TInner
TKey
TResult
Parameters
Returns
Exceptions
Remarks
Essa sobrecarga existe para não permitir o uso de junção com uma fonte de dados à esquerda do tipo
junção apareceria a ligação com a implementação paralela, mas na realidade associaria na implementação sequencial.
Also
(ParallelQuery<TOuter>, ParallelQuery<TInner>,
Correlaciona em paralelo os elementos de duas sequências com base em chaves de correspondência. O comparador
de igualdade padrão é usado para comparar chaves.
outerKeySelector, Func<TInner,TKey> innerKeySelector, Func<TOuter,TInner,TResult> resultSelector);
static member Join : System.Linq.ParallelQuery<'Outer> * System.Linq.ParallelQuery<'Inner> *
Func<'Outer, 'Key> * Func<'Inner, 'Key> * Func<'Outer, 'Inner, 'Result> ->
Type Parameters
TOuter
TInner
TKey
TResult
Parameters
Returns
Uma sequência com elementos do tipo TResult obtidos pela execução de uma junção interna em duas sequências.
Exceptions
Also

Func<TOuter,TKey> outerKeySelector, Func<TInner,TKey> innerKeySelector, Func<TOuter,TInner,TResult>
resultSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer);
static member Join : System.Linq.ParallelQuery<'Outer> * seq<'Inner> * Func<'Outer, 'Key> *
Func<'Inner, 'Key> * Func<'Outer, 'Inner, 'Result> *
Type Parameters
TOuter
TInner
TKey
TResult
Parameters
Returns
Exceptions
Remarks
Essa sobrecarga existe para não permitir o uso de junção com uma fonte de dados à esquerda do tipo
junção apareceria a ligação com a implementação paralela, mas na realidade associaria na implementação sequencial.
Also
Correlaciona em paralelo os elementos de duas sequências com base em chaves de correspondência. Um
outerKeySelector, Func<TInner,TKey> innerKeySelector, Func<TOuter,TInner,TResult> resultSelector,
static member Join : System.Linq.ParallelQuery<'Outer> * System.Linq.ParallelQuery<'Inner> *
Func<'Outer, 'Key> * Func<'Inner, 'Key> * Func<'Outer, 'Inner, 'Result> *
Type Parameters
TOuter
TInner
TKey
TResult
Parameters
Returns
Uma sequência com elementos do tipo TResult obtidos pela execução de uma junção interna em duas sequências.
Exceptions
Also
ParallelEnumerable.Last ParallelEnumerable.Last
I n this Article
Overloads
Last<TSource>(ParallelQuery<TSource>) Last<TSource>(
ParallelQuery<TSource>) Retorna o último elemento de uma sequência paralela.
Last<TSource>(ParallelQuery<TSource>, Func<TSource,
Boolean>) Last<TSource>(ParallelQuery<TSource>, Func< Retorna o último elemento de uma sequência paralela que
TSource,Boolean>) satisfaz a uma condição especificada.
Last<TSource>(ParallelQuery<TSource>) Last<TSource>
Retorna o último elemento de uma sequência paralela.
public static TSource Last<TSource> (this System.Linq.ParallelQuery<TSource> source);
static member Last : System.Linq.ParallelQuery<'Source> -> 'Source
Type Parameters
TSource
Parameters
A sequência da qual retornar o último elemento.
Returns
TSource TSource
O valor na última posição na sequência de origem.
Exceptions
Remarks
Se a consulta não é solicitada, o último elemento é não determinística. Para saber mais, veja Preservação da ordem em
PLINQ.
Also
Retorna o último elemento de uma sequência paralela que satisfaz a uma condição especificada.
public static TSource Last<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member Last : System.Linq.ParallelQuery<'Source> * Func<'Source, bool> -> 'Source
Type Parameters
TSource
Parameters
Returns
TSource TSource
O último elemento na sequência que passa o teste na função de predicado especificada.
Exceptions
Nenhum elemento de source satisfaz a condição em predicate .
Remarks
PLINQ.
Also
ParallelEnumerable.LastOrDefault ParallelEnumerable.
LastOrDefault
I n this Article
Overloads
LastOrDefault<TSource>(ParallelQuery<TSource>, Func<
TSource,Boolean>) LastOrDefault<TSource>(ParallelQuery< Retorna o último elemento de uma sequência em paralelo que
TSource>, Func<TSource,Boolean>) satisfaz a uma condição ou um valor padrão, caso esse
LastOrDefault<TSource>(ParallelQuery<TSource>) LastOr
Default<TSource>(ParallelQuery<TSource>) Retornará o último elemento de uma sequência paralela ou
um valor padrão, se a sequência não contiver elementos.
LastOrDefault<TSource>(ParallelQuery<TSource>,
Func<TSource,Boolean>) LastOrDefault<TSource>
Retorna o último elemento de uma sequência em paralelo que satisfaz a uma condição ou um valor padrão, caso esse
public static TSource LastOrDefault<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member LastOrDefault : System.Linq.ParallelQuery<'Source> * Func<'Source, bool> -> 'Source
Type Parameters
TSource
Parameters
Returns
TSource TSource
default() se a sequência for vazia ou se nenhum elemento passar no teste na função de predicado; caso contrário, o
último elemento que passar no teste na função de predicado.
Exceptions
Remarks
PLINQ.
Also
Retornará o último elemento de uma sequência paralela ou um valor padrão, se a sequência não contiver elementos.
public static TSource LastOrDefault<TSource> (this System.Linq.ParallelQuery<TSource> source);
static member LastOrDefault : System.Linq.ParallelQuery<'Source> -> 'Source
Type Parameters
TSource
Parameters
Returns
TSource TSource
default() se a sequência de origem estiver vazia; caso contrário, o último elemento na sequência.
Exceptions
Remarks
PLINQ.
Also
ParallelEnumerable.LongCount ParallelEnumerable.Long
Count
I n this Article
Overloads
LongCount<TSource>(ParallelQuery<TSource>) LongCount<
TSource>(ParallelQuery<TSource>) Retorna um Int64 que representa o número total de
elementos em uma sequência paralela.
LongCount<TSource>(ParallelQuery<TSource>, Func<
TSource,Boolean>) LongCount<TSource>(ParallelQuery< Retorna um Int64 que representa quantos elementos em uma
TSource>, Func<TSource,Boolean>) sequência paralela satisfazem a uma condição.
Retorna um Int64 que representa o número total de elementos em uma sequência paralela.
public static long LongCount<TSource> (this System.Linq.ParallelQuery<TSource> source);

static member LongCount : System.Linq.ParallelQuery<'Source> -> int64
Type Parameters
TSource
Parameters
Returns
Int64 Int64
Exceptions
O número de elementos na origem é maior do que MaxValue. -ou- Uma ou mais exceções ocorreram durante a
avaliação da consulta.
O resultado calculado é maior do que MaxValue.
Also
LongCount<TSource>(ParallelQuery<TSource>,
Func<TSource,Boolean>) LongCount<TSource>
Retorna um Int64 que representa quantos elementos em uma sequência paralela satisfazem a uma condição.
public static long LongCount<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member LongCount : System.Linq.ParallelQuery<'Source> * Func<'Source, bool> -> int64
Type Parameters
TSource
Parameters
Returns
Int64 Int64
Exceptions
O número de elementos na origem é maior do que MaxValue. -ou- Uma ou mais exceções ocorreram durante a
avaliação da consulta.
O resultado calculado é maior do que MaxValue.
Also
ParallelEnumerable.Max ParallelEnumerable.Max
I n this Article
Overloads
Max(ParallelQuery<Nullable<Single>>) Max(ParallelQuery<
Nullable<Single>>) Retorna o valor máximo em uma sequência paralela de
valores.
Max(ParallelQuery<Single>) Max(ParallelQuery<Single>)
Retorna o valor máximo em uma sequência paralela de
valores.
Max(ParallelQuery<Nullable<Int64>>) Max(ParallelQuery<
Nullable<Int64>>) Retorna o valor máximo em uma sequência paralela de
valores.
Max(ParallelQuery<Nullable<Int32>>) Max(ParallelQuery<
Nullable<Int32>>) Retorna o valor máximo em uma sequência paralela de
valores.
Max(ParallelQuery<Nullable<Double>>) Max(ParallelQuery<
Nullable<Double>>) Retorna o valor máximo em uma sequência paralela de
valores.
Max(ParallelQuery<Double>) Max(ParallelQuery<Double>)
valores.
Max(ParallelQuery<Int64>) Max(ParallelQuery<Int64>)
valores.
valores.
Max(ParallelQuery<Decimal>) Max(ParallelQuery<Decimal>)
valores.
Max(ParallelQuery<Nullable<Decimal>>) Max(ParallelQuery<
Nullable<Decimal>>) Retorna o valor máximo em uma sequência paralela de
valores.
Max<TSource,TResult>(ParallelQuery<TSource>, Func<
TSource,TResult>) Max<TSource,TResult>(ParallelQuery< Invoca em paralelo uma função de transformação em cada
TSource>, Func<TSource,TResult>) elemento de uma sequência e retorna o valor máximo.
Max<TSource>(ParallelQuery<TSource>, Func<TSource,
Nullable<Int64>>) Max<TSource>(ParallelQuery<TSource>, Invoca em paralelo uma função de transformação em cada
Func<TSource,Nullable<Int64>>) elemento de uma sequência e retorna o valor máximo.
Single>) Max<TSource>(ParallelQuery<TSource>, Func< Invoca em paralelo uma função de transformação em cada
TSource,Single>) elemento de uma sequência e retorna o valor máximo.
Nullable<Single>>) Max<TSource>(ParallelQuery<TSource>, Invoca em paralelo uma função de transformação em cada
Func<TSource,Nullable<Single>>) elemento de uma sequência e retorna o valor máximo.
Nullable<Int32>>) Max<TSource>(ParallelQuery<TSource>, Invoca em paralelo uma função de transformação em cada
Func<TSource,Nullable<Int32>>) elemento de uma sequência e retorna o valor máximo.
Nullable<Double>>) Max<TSource>(ParallelQuery<TSource>, Invoca em paralelo uma função de transformação em cada
Func<TSource,Nullable<Double>>) elemento de uma sequência e retorna o valor máximo.
Nullable<Decimal>>) Max<TSource>(ParallelQuery< Invoca em paralelo uma função de transformação em cada
TSource>, Func<TSource,Nullable<Decimal>>) elemento de uma sequência e retorna o valor máximo.
Int64>) Max<TSource>(ParallelQuery<TSource>, Func< Invoca em paralelo uma função de transformação em cada
TSource,Int64>) elemento de uma sequência e retorna o valor máximo.
Int32>) Max<TSource>(ParallelQuery<TSource>, Func< Invoca em paralelo uma função de transformação em cada
TSource,Int32>) elemento de uma sequência e retorna o valor máximo.
Double>) Max<TSource>(ParallelQuery<TSource>, Func< Invoca em paralelo uma função de transformação em cada
TSource,Double>) elemento de uma sequência e retorna o valor máximo.
Decimal>) Max<TSource>(ParallelQuery<TSource>, Func< Invoca em paralelo uma função de transformação em cada
TSource,Decimal>) elemento de uma sequência e retorna o valor máximo.
Max<TSource>(ParallelQuery<TSource>) Max<TSource>(
ParallelQuery<TSource>) Retorna o valor máximo em uma sequência paralela de
valores.
public static Nullable<float> Max (this System.Linq.ParallelQuery<Nullable<float>> source);

static member Max : System.Linq.ParallelQuery<Nullable<single>> -> Nullable<single>
Parameters
Returns
Nullable<Single>
Exceptions

Also
Max(ParallelQuery<Single>) Max(ParallelQuery<Single>)
public static float Max (this System.Linq.ParallelQuery<float> source);

static member Max : System.Linq.ParallelQuery<single> -> single
Parameters
Returns
Single Single
Exceptions
Also
public static Nullable<long> Max (this System.Linq.ParallelQuery<Nullable<long>> source);

static member Max : System.Linq.ParallelQuery<Nullable<int64>> -> Nullable<int64>
Parameters
Returns
Nullable<Int64>
Exceptions

Also
public static Nullable<int> Max (this System.Linq.ParallelQuery<Nullable<int>> source);
static member Max : System.Linq.ParallelQuery<Nullable<int>> -> Nullable<int>
Parameters
Returns
Nullable<Int32>
Exceptions
Also
public static Nullable<double> Max (this System.Linq.ParallelQuery<Nullable<double>> source);

static member Max : System.Linq.ParallelQuery<Nullable<double>> -> Nullable<double>
Parameters
Returns
Nullable<Double>
Exceptions

Also
Max(ParallelQuery<Double>) Max(ParallelQuery<Double>)
public static double Max (this System.Linq.ParallelQuery<double> source);

static member Max : System.Linq.ParallelQuery<double> -> double
Parameters
Returns
Double Double
Exceptions

Also
public static long Max (this System.Linq.ParallelQuery<long> source);

static member Max : System.Linq.ParallelQuery<int64> -> int64
Parameters
Returns
Int64 Int64
Exceptions
Also
public static int Max (this System.Linq.ParallelQuery<int> source);

static member Max : System.Linq.ParallelQuery<int> -> int
Parameters
Returns
Int32 Int32
Exceptions
Also
Max(ParallelQuery<Decimal>) Max(ParallelQuery<Decimal>)
public static decimal Max (this System.Linq.ParallelQuery<decimal> source);

static member Max : System.Linq.ParallelQuery<decimal> -> decimal
Parameters
Returns
Decimal Decimal
Exceptions

Also
public static Nullable<decimal> Max (this System.Linq.ParallelQuery<Nullable<decimal>> source);

static member Max : System.Linq.ParallelQuery<Nullable<decimal>> -> Nullable<decimal>
Parameters
Returns
Nullable<Decimal>
Exceptions

Also
Max<TSource,TResult>(ParallelQuery<TSource>,
Func<TSource,TResult>) Max<TSource,TResult>
(ParallelQuery<TSource>, Func<TSource,TResult>)
public static TResult Max<TSource,TResult> (this System.Linq.ParallelQuery<TSource> source,

Func<TSource,TResult> selector);
static member Max : System.Linq.ParallelQuery<'Source> * Func<'Source, 'Result> -> 'Result
Type Parameters
TSource
TResult
Parameters
Returns
TResult TResult
Exceptions
source não contém elementos e TSource é um tipo de valor não anulável.

Also
Max<TSource>(ParallelQuery<TSource>,
public static Nullable<long> Max<TSource> (this System.Linq.ParallelQuery<TSource> source,

static member Max : System.Linq.ParallelQuery<'Source> * Func<'Source, Nullable<int64>> ->
Nullable<int64>
Type Parameters
TSource
Parameters
Returns
Nullable<Int64>
Exceptions

Also
public static float Max<TSource> (this System.Linq.ParallelQuery<TSource> source,

static member Max : System.Linq.ParallelQuery<'Source> * Func<'Source, single> -> single
Type Parameters
TSource
Parameters
Returns
Single Single
Exceptions
Also
Func<TSource,Nullable<Single>>) Max<TSource>
public static Nullable<float> Max<TSource> (this System.Linq.ParallelQuery<TSource> source,

static member Max : System.Linq.ParallelQuery<'Source> * Func<'Source, Nullable<single>> ->
Nullable<single>
Type Parameters
TSource
Parameters
Returns
Nullable<Single>
Exceptions
Also
public static Nullable<int> Max<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member Max : System.Linq.ParallelQuery<'Source> * Func<'Source, Nullable<int>> ->
Nullable<int>
Type Parameters
TSource
Parameters
Returns
Nullable<Int32>
Exceptions

Also
Func<TSource,Nullable<Double>>) Max<TSource>
public static Nullable<double> Max<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member Max : System.Linq.ParallelQuery<'Source> * Func<'Source, Nullable<double>> ->
Nullable<double>
Type Parameters
TSource
Parameters
Returns
Nullable<Double>
Exceptions
Also
Func<TSource,Nullable<Decimal>>) Max<TSource>
public static Nullable<decimal> Max<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member Max : System.Linq.ParallelQuery<'Source> * Func<'Source, Nullable<decimal>> ->
Nullable<decimal>
Type Parameters
TSource
Parameters
Returns
Nullable<Decimal>
Exceptions

Also
public static long Max<TSource> (this System.Linq.ParallelQuery<TSource> source, Func<TSource,long>
selector);
static member Max : System.Linq.ParallelQuery<'Source> * Func<'Source, int64> -> int64
Type Parameters
TSource
Parameters
Returns
Int64 Int64
Exceptions
Also
public static int Max<TSource> (this System.Linq.ParallelQuery<TSource> source, Func<TSource,int>

selector);
static member Max : System.Linq.ParallelQuery<'Source> * Func<'Source, int> -> int
Type Parameters
TSource
Parameters
Returns
Int32 Int32
Exceptions

Also
public static double Max<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member Max : System.Linq.ParallelQuery<'Source> * Func<'Source, double> -> double
Type Parameters
TSource
Parameters
Returns
Double Double
Exceptions
Also
Func<TSource,Decimal>) Max<TSource>
public static decimal Max<TSource> (this System.Linq.ParallelQuery<TSource> source,

static member Max : System.Linq.ParallelQuery<'Source> * Func<'Source, decimal> -> decimal
Type Parameters
TSource
Parameters
Returns
Decimal Decimal
Exceptions

Also
Max<TSource>(ParallelQuery<TSource>) Max<TSource>
public static TSource Max<TSource> (this System.Linq.ParallelQuery<TSource> source);
static member Max : System.Linq.ParallelQuery<'Source> -> 'Source
Type Parameters
TSource
O tipo dos elementos na sequência de origem.
Parameters
Returns
TSource TSource
Exceptions
Also
ParallelEnumerable.Min ParallelEnumerable.Min
I n this Article
Overloads
Min(ParallelQuery<Single>) Min(ParallelQuery<Single>)
Min(ParallelQuery<Nullable<Single>>) Min(ParallelQuery<
Nullable<Single>>) Retorna o valor mínimo em uma sequência paralela de valores.
Min(ParallelQuery<Nullable<Int64>>) Min(ParallelQuery<
Nullable<Int64>>) Retorna o valor mínimo em uma sequência paralela de valores.
Min(ParallelQuery<Nullable<Int32>>) Min(ParallelQuery<
Nullable<Int32>>) Retorna o valor mínimo em uma sequência paralela de valores.
Min(ParallelQuery<Nullable<Double>>) Min(ParallelQuery<
Nullable<Double>>) Retorna o valor mínimo em uma sequência paralela de valores.
Min(ParallelQuery<Nullable<Decimal>>) Min(ParallelQuery<
Nullable<Decimal>>) Retorna o valor mínimo em uma sequência paralela de valores.
Min(ParallelQuery<Int64>) Min(ParallelQuery<Int64>)
Min(ParallelQuery<Double>) Min(ParallelQuery<Double>)
Min(ParallelQuery<Decimal>) Min(ParallelQuery<Decimal>)
Min<TSource,TResult>(ParallelQuery<TSource>, Func<
TSource,TResult>) Min<TSource,TResult>(ParallelQuery< Invoca em paralelo uma função de transformação em cada
TSource>, Func<TSource,TResult>) elemento de uma sequência e retorna o valor mínimo.
Min<TSource>(ParallelQuery<TSource>, Func<TSource,
Single>) Min<TSource>(ParallelQuery<TSource>, Func< Invoca em paralelo uma função de transformação em cada
TSource,Single>) elemento de uma sequência e retorna o valor mínimo.
Nullable<Single>>) Min<TSource>(ParallelQuery<TSource>, Invoca em paralelo uma função de transformação em cada
Func<TSource,Nullable<Single>>) elemento de uma sequência e retorna o valor mínimo.
Nullable<Int32>>) Min<TSource>(ParallelQuery<TSource>, Invoca em paralelo uma função de transformação em cada
Func<TSource,Nullable<Int32>>) elemento de uma sequência e retorna o valor mínimo.
Nullable<Double>>) Min<TSource>(ParallelQuery<TSource>, Invoca em paralelo uma função de transformação em cada
Func<TSource,Nullable<Double>>) elemento de uma sequência e retorna o valor mínimo.
Nullable<Int64>>) Min<TSource>(ParallelQuery<TSource>, Invoca em paralelo uma função de transformação em cada
Func<TSource,Nullable<Int64>>) elemento de uma sequência e retorna o valor mínimo.
Int64>) Min<TSource>(ParallelQuery<TSource>, Func< Invoca em paralelo uma função de transformação em cada
TSource,Int64>) elemento de uma sequência e retorna o valor mínimo.
Int32>) Min<TSource>(ParallelQuery<TSource>, Func< Invoca em paralelo uma função de transformação em cada
TSource,Int32>) elemento de uma sequência e retorna o valor mínimo.
Nullable<Decimal>>) Min<TSource>(ParallelQuery<TSource>, Invoca em paralelo uma função de transformação em cada
Func<TSource,Nullable<Decimal>>) elemento de uma sequência e retorna o valor mínimo.
Double>) Min<TSource>(ParallelQuery<TSource>, Func< Invoca em paralelo uma função de transformação em cada
TSource,Double>) elemento de uma sequência e retorna o valor mínimo.
Decimal>) Min<TSource>(ParallelQuery<TSource>, Func< Invoca em paralelo uma função de transformação em cada
TSource,Decimal>) elemento de uma sequência e retorna o valor mínimo.
Min<TSource>(ParallelQuery<TSource>) Min<TSource>(
ParallelQuery<TSource>) Retorna o valor mínimo em uma sequência paralela de valores.
Min(ParallelQuery<Single>) Min(ParallelQuery<Single>)
public static float Min (this System.Linq.ParallelQuery<float> source);
static member Min : System.Linq.ParallelQuery<single> -> single
Parameters
Returns
Single Single
Exceptions

Also
public static Nullable<float> Min (this System.Linq.ParallelQuery<Nullable<float>> source);

static member Min : System.Linq.ParallelQuery<Nullable<single>> -> Nullable<single>
Parameters
Returns
Nullable<Single>
Exceptions

Also
public static Nullable<long> Min (this System.Linq.ParallelQuery<Nullable<long>> source);
static member Min : System.Linq.ParallelQuery<Nullable<int64>> -> Nullable<int64>
Parameters
Returns
Nullable<Int64>
Exceptions
Also
public static Nullable<int> Min (this System.Linq.ParallelQuery<Nullable<int>> source);

static member Min : System.Linq.ParallelQuery<Nullable<int>> -> Nullable<int>
Parameters
Returns
Nullable<Int32>
Exceptions

Also
public static Nullable<double> Min (this System.Linq.ParallelQuery<Nullable<double>> source);
static member Min : System.Linq.ParallelQuery<Nullable<double>> -> Nullable<double>
Parameters
Returns
Nullable<Double>
Exceptions

Also
public static Nullable<decimal> Min (this System.Linq.ParallelQuery<Nullable<decimal>> source);
static member Min : System.Linq.ParallelQuery<Nullable<decimal>> -> Nullable<decimal>
Parameters
Returns
Nullable<Decimal>
Exceptions

Also
public static long Min (this System.Linq.ParallelQuery<long> source);

static member Min : System.Linq.ParallelQuery<int64> -> int64
Parameters
Returns
Int64 Int64
Exceptions

Also
public static int Min (this System.Linq.ParallelQuery<int> source);

static member Min : System.Linq.ParallelQuery<int> -> int
Parameters
Returns
Int32 Int32
Exceptions

Also
Min(ParallelQuery<Double>) Min(ParallelQuery<Double>)
public static double Min (this System.Linq.ParallelQuery<double> source);

static member Min : System.Linq.ParallelQuery<double> -> double
Parameters
Returns
Double Double
Exceptions
Also
Min(ParallelQuery<Decimal>) Min(ParallelQuery<Decimal>)
public static decimal Min (this System.Linq.ParallelQuery<decimal> source);
static member Min : System.Linq.ParallelQuery<decimal> -> decimal
Parameters
Returns
Decimal Decimal
Exceptions
Also
Min<TSource,TResult>(ParallelQuery<TSource>,
Func<TSource,TResult>) Min<TSource,TResult>
public static TResult Min<TSource,TResult> (this System.Linq.ParallelQuery<TSource> source,

Func<TSource,TResult> selector);
static member Min : System.Linq.ParallelQuery<'Source> * Func<'Source, 'Result> -> 'Result
Type Parameters
TSource
TResult
Parameters
Uma sequência de valores da qual será determinado o valor mínimo.
Returns
TResult TResult
Exceptions
Also
public static float Min<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member Min : System.Linq.ParallelQuery<'Source> * Func<'Source, single> -> single
Type Parameters
TSource
Parameters
Returns
Single Single
Exceptions
Also
Min<TSource>(ParallelQuery<TSource>,
Func<TSource,Nullable<Single>>) Min<TSource>
public static Nullable<float> Min<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member Min : System.Linq.ParallelQuery<'Source> * Func<'Source, Nullable<single>> ->
Nullable<single>
Type Parameters
TSource
Parameters
Returns
Nullable<Single>
Exceptions
Also
public static Nullable<int> Min<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member Min : System.Linq.ParallelQuery<'Source> * Func<'Source, Nullable<int>> ->
Nullable<int>
Type Parameters
TSource
Parameters
Returns
Nullable<Int32>
Exceptions
Also
Func<TSource,Nullable<Double>>) Min<TSource>
public static Nullable<double> Min<TSource> (this System.Linq.ParallelQuery<TSource> source,

static member Min : System.Linq.ParallelQuery<'Source> * Func<'Source, Nullable<double>> ->
Nullable<double>
Type Parameters
TSource
Parameters
Returns
Nullable<Double>
Exceptions
Also
public static Nullable<long> Min<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member Min : System.Linq.ParallelQuery<'Source> * Func<'Source, Nullable<int64>> ->
Nullable<int64>
Type Parameters
TSource
Parameters
Returns
Nullable<Int64>
Exceptions
Also
public static long Min<TSource> (this System.Linq.ParallelQuery<TSource> source, Func<TSource,long>
selector);
static member Min : System.Linq.ParallelQuery<'Source> * Func<'Source, int64> -> int64
Type Parameters
TSource
Parameters
Returns
Int64 Int64
Exceptions

Also
public static int Min<TSource> (this System.Linq.ParallelQuery<TSource> source, Func<TSource,int>
selector);
static member Min : System.Linq.ParallelQuery<'Source> * Func<'Source, int> -> int
Type Parameters
TSource
Parameters
Returns
Int32 Int32
Exceptions
Also
Func<TSource,Nullable<Decimal>>) Min<TSource>
public static Nullable<decimal> Min<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member Min : System.Linq.ParallelQuery<'Source> * Func<'Source, Nullable<decimal>> ->
Nullable<decimal>
Type Parameters
TSource
Parameters
Returns
Nullable<Decimal>
Exceptions

Also
public static double Min<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member Min : System.Linq.ParallelQuery<'Source> * Func<'Source, double> -> double
Type Parameters
TSource
Parameters
Returns
Double Double
Exceptions
Also
public static decimal Min<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member Min : System.Linq.ParallelQuery<'Source> * Func<'Source, decimal> -> decimal
Type Parameters
TSource
Parameters
Returns
Decimal Decimal
Exceptions

Also
Min<TSource>(ParallelQuery<TSource>) Min<TSource>
public static TSource Min<TSource> (this System.Linq.ParallelQuery<TSource> source);
static member Min : System.Linq.ParallelQuery<'Source> -> 'Source
Type Parameters
TSource
Parameters
Returns
TSource TSource
Exceptions
Also
ParallelEnumerable.OfType ParallelEnumerable.OfType
I n this Article
Filtra os elementos de uma ParallelQuery com base em um tipo especificado.
public static System.Linq.ParallelQuery<TResult> OfType<TResult> (this System.Linq.ParallelQuery
source);
static member OfType : System.Linq.ParallelQuery -> System.Linq.ParallelQuery<'Result>
Type Parameters
TResult
Parameters
A sequência com os elementos a filtrar.
Returns
Uma sequência que contém elementos da sequência de entrada filtrada por tipo.
Exceptions
Also
ParallelEnumerable.OrderBy ParallelEnumerable.OrderBy
I n this Article
Overloads
OrderBy<TSource,TKey>(ParallelQuery<TSource>, Func<
TSource,TKey>) OrderBy<TSource,TKey>(ParallelQuery< Classifica em paralelo os elementos de uma sequência em
TSource>, Func<TSource,TKey>) ordem crescente de acordo com uma chave.
OrderBy<TSource,TKey>(ParallelQuery<TSource>, Func<
TSource,TKey>, IComparer<TKey>) OrderBy<TSource,TKey>( Classifica em paralelo os elementos de uma sequência em
ParallelQuery<TSource>, Func<TSource,TKey>, IComparer< ordem crescente usando um comparador especificado.
TKey>)
OrderBy<TSource,TKey>(ParallelQuery<TSource>,
Func<TSource,TKey>) OrderBy<TSource,TKey>
Classifica em paralelo os elementos de uma sequência em ordem crescente de acordo com uma chave.
public static System.Linq.OrderedParallelQuery<TSource> OrderBy<TSource,TKey> (this
System.Linq.ParallelQuery<TSource> source, Func<TSource,TKey> keySelector);
static member OrderBy : System.Linq.ParallelQuery<'Source> * Func<'Source, 'Key> ->
System.Linq.OrderedParallelQuery<'Source>
Type Parameters
TSource
TKey
Parameters
Returns
OrderedParallelQuery<TSource> OrderedParallelQuery<TSource>
Um OrderedParallelQuery{TSource} cujos elementos são classificados de acordo com uma chave.
Exceptions
source ou keySelector é uma referência nula (Nothing no Visual Basic).
Remarks
Em contraste com a implementação sequencial, isso não é uma classificação estável. Para obter uma classificação
estável, alterar uma consulta do formulário: var ordenado = fonte. Select((e,i) = > Novo {eletrônico = eletrônico, eu =
i}). OrderBy((v) = > v.e). ThenBy (v = > v.i). Select((v) = > v.e);
Also
Classifica em paralelo os elementos de uma sequência em ordem crescente usando um comparador especificado.
public static System.Linq.OrderedParallelQuery<TSource> OrderBy<TSource,TKey> (this
static member OrderBy : System.Linq.ParallelQuery<'Source> * Func<'Source, 'Key> *
System.Collections.Generic.IComparer<'Key> -> System.Linq.OrderedParallelQuery<'Source>
Type Parameters
TSource
TKey
Parameters
Um IComparer{TKey} para comparar chaves.
Returns
Exceptions
Remarks
Em contraste com a implementação sequencial, isso não é uma classificação estável. Consulte os comentários para
OrderBy para uma abordagem para implementar uma classificação estável.
Also
ParallelEnumerable.OrderByDescending Parallel
Enumerable.OrderByDescending
I n this Article
Overloads
OrderByDescending<TSource,TKey>(ParallelQuery<TSource>,
Func<TSource,TKey>) OrderByDescending<TSource,TKey>( Classifica em paralelo os elementos de uma sequência em
ParallelQuery<TSource>, Func<TSource,TKey>) ordem decrescente de acordo com uma chave.
Func<TSource,TKey>, IComparer<TKey>) OrderBy Classifica os elementos de uma sequência em ordem
Descending<TSource,TKey>(ParallelQuery<TSource>, Func< decrescente usando um comparador especificado.
TSource,TKey>, IComparer<TKey>)
Func<TSource,TKey>) OrderByDescending<TSource,TKey>
Classifica em paralelo os elementos de uma sequência em ordem decrescente de acordo com uma chave.
public static System.Linq.OrderedParallelQuery<TSource> OrderByDescending<TSource,TKey> (this
static member OrderByDescending : System.Linq.ParallelQuery<'Source> * Func<'Source, 'Key> ->
Type Parameters
TSource
TKey
Parameters
Returns
Uma OrderedParallelQuery{TSource} cujos elementos são classificados em ordem decrescente de acordo com uma
chave.
Exceptions
Remarks
Also
public static System.Linq.OrderedParallelQuery<TSource> OrderByDescending<TSource,TKey> (this

static member OrderByDescending : System.Linq.ParallelQuery<'Source> * Func<'Source, 'Key> *
Type Parameters
TSource
TKey
Parameters
Returns
Uma OrderedParallelQuery{TSource} cujos elementos são classificados em ordem decrescente de acordo com uma
chave.
Exceptions
source ou KeySelector é uma referência nula (Nothing no Visual Basic).
Remarks
Also
ParallelEnumerable.Range ParallelEnumerable.Range
I n this Article
Gera uma sequência paralela de números integrais dentro de um intervalo especificado.
public static System.Linq.ParallelQuery<int> Range (int start, int count);
static member Range : int * int -> System.Linq.ParallelQuery<int>
Parameters
start Int32 Int32
O valor do primeiro inteiro na sequência.
count Int32 Int32
O número de inteiros sequenciais a serem gerados.
Returns
ParallelQuery<Int32>
Um IEnumerable<Int32> em C# ou IEnumerable(Of Int32) no Visual Basic que contém um intervalo de números
inteiros sequenciais.
Exceptions
count é menor que 0 -ou- start + count -1 é maior do que MaxValue.
Also
ParallelEnumerable.Repeat ParallelEnumerable.Repeat
I n this Article
Gera uma sequência paralela que contém um valor repetido.
public static System.Linq.ParallelQuery<TResult> Repeat<TResult> (TResult element, int count);
static member Repeat : 'Result * int -> System.Linq.ParallelQuery<'Result>
Type Parameters
TResult
O tipo do valor a ser repetido na sequência de resultado.
Parameters
element TResult TResult
O valor a ser repetido.
count Int32 Int32
O número de vezes para repetir o valor na sequência gerada.
Returns
Uma sequência que contém um valor repetido.
Exceptions
Also
ParallelEnumerable.Reverse ParallelEnumerable.Reverse
I n this Article
Inverte a ordem dos elementos em uma sequência paralela.
public static System.Linq.ParallelQuery<TSource> Reverse<TSource> (this
static member Reverse : System.Linq.ParallelQuery<'Source> -> System.Linq.ParallelQuery<'Source>
Type Parameters
TSource
Parameters
Returns
Uma sequência cujos elementos correspondem aos elementos da sequência de entrada em ordem inversa.
Exceptions
Also
ParallelEnumerable.Select ParallelEnumerable.Select
I n this Article
Overloads
Select<TSource,TResult>(ParallelQuery<TSource>, Func<
TSource,Int32,TResult>) Select<TSource,TResult>(Parallel Projeta em paralelo cada elemento de uma sequência em um
Query<TSource>, Func<TSource,Int32,TResult>) novo formulário incorporando o índice do elemento.
Select<TSource,TResult>(ParallelQuery<TSource>, Func<
TSource,TResult>) Select<TSource,TResult>(ParallelQuery< Projeta em paralelo cada elemento de uma sequência em um
TSource>, Func<TSource,TResult>) novo formulário.
Select<TSource,TResult>(ParallelQuery<TSource>,
Func<TSource,Int32,TResult>) Select<TSource,TResult>
(ParallelQuery<TSource>, Func<TSource,Int32,TResult>)
Projeta em paralelo cada elemento de uma sequência em um novo formulário incorporando o índice do elemento.
public static System.Linq.ParallelQuery<TResult> Select<TSource,TResult> (this
System.Linq.ParallelQuery<TSource> source, Func<TSource,int,TResult> selector);
static member Select : System.Linq.ParallelQuery<'Source> * Func<'Source, int, 'Result> ->
Type Parameters
TSource
TResult
O tipo dos elementos retornado pelo seletor.
Parameters
selector Func<TSource,Int32,TResult>
Returns
Uma sequência cujos elementos são o resultado de invocar a função de transformação em cada elemento de source
com base no índice fornecido para selector .
Exceptions
Mais de MaxValue elementos são enumerados pela consulta. Essa condição pode ocorrer em cenários de streaming.
Also
Select<TSource,TResult>(ParallelQuery<TSource>,
Func<TSource,TResult>) Select<TSource,TResult>
Projeta em paralelo cada elemento de uma sequência em um novo formulário.
public static System.Linq.ParallelQuery<TResult> Select<TSource,TResult> (this
System.Linq.ParallelQuery<TSource> source, Func<TSource,TResult> selector);
static member Select : System.Linq.ParallelQuery<'Source> * Func<'Source, 'Result> ->
Type Parameters
TSource
TResult
O tipo dos elementos retornado pelo seletor.
Parameters
Returns
Uma sequência cujos elementos são o resultado da invocação da função de transformação em cada elemento de
source .
Exceptions
Also
ParallelEnumerable.SelectMany ParallelEnumerable.
SelectMany
I n this Article
Overloads
SelectMany<TSource,TCollection,TResult>(ParallelQuery<
TSource>, Func<TSource,IEnumerable<TCollection>>, Func< Projeta cada elemento de uma sequência em um
TSource,TCollection,TResult>) SelectMany<TSource, IEnumerable<T>, mescla as sequências resultantes em uma
TCollection,TResult>(ParallelQuery<TSource>, Func<TSource, sequência e chama uma função de seletor de resultado em
IEnumerable<TCollection>>, Func<TSource,TCollection, cada elemento contido nele.
TResult>)
SelectMany<TSource,TCollection,TResult>(ParallelQuery<
TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Projeta cada elemento de uma sequência em um
Func<TSource,TCollection,TResult>) SelectMany<TSource, IEnumerable<T>, mescla as sequências resultantes em uma
TCollection,TResult>(ParallelQuery<TSource>, Func<TSource, sequência e chama uma função de seletor de resultado em
Int32,IEnumerable<TCollection>>, Func<TSource,TCollection, cada elemento contido nele. O índice de cada elemento de
TResult>) origem é usado no formulário projetado intermediário do
elemento.
SelectMany<TSource,TResult>(ParallelQuery<TSource>,
Func<TSource,IEnumerable<TResult>>) SelectMany<TSource, Projeta em paralelo em cada elemento de uma sequência para
TResult>(ParallelQuery<TSource>, Func<TSource, um IEnumerable<T> e mescla as sequências resultantes em
IEnumerable<TResult>>) uma sequência.
Func<TSource,Int32,IEnumerable<TResult>>) SelectMany< Projeta em paralelo em cada elemento de uma sequência para
TSource,TResult>(ParallelQuery<TSource>, Func<TSource, um IEnumerable<T> e mescla as sequências resultantes em
Int32,IEnumerable<TResult>>) uma sequência. O índice de cada elemento de origem é usado
no formulário projetado desse elemento.
(ParallelQuery<TSource>,
public static System.Linq.ParallelQuery<TResult> SelectMany<TSource,TCollection,TResult> (this
System.Linq.ParallelQuery<TSource> source,
Func<TSource,System.Collections.Generic.IEnumerable<TCollection>> collectionSelector,
static member SelectMany : System.Linq.ParallelQuery<'Source> * Func<'Source, seq<'Collection>> *
Func<'Source, 'Collection, 'Result> -> System.Linq.ParallelQuery<'Result>
Type Parameters
TSource
TCollection
TResult
O tipo dos elementos na sequência de resultado.
Parameters
Returns
Uma sequência cujos elementos são o resultado de chamar a função de transformação de um para muitos
collectionSelector em cada elemento de source com base no índice fornecido para collectionSelector e então
mapear cada um desses elementos de sequência para seus elementos de origem correspondentes para um elemento
de resultado.
Exceptions
Mais de MaxValue elementos são enumerados pela consulta.
Also
sequência e chama uma função de seletor de resultado em cada elemento contido nele. O índice de cada elemento de
origem é usado no formulário projetado intermediário do elemento.
public static System.Linq.ParallelQuery<TResult> SelectMany<TSource,TCollection,TResult> (this
Func<TSource,int,System.Collections.Generic.IEnumerable<TCollection>> collectionSelector,
static member SelectMany : System.Linq.ParallelQuery<'Source> * Func<'Source, int, seq<'Collection>>
* Func<'Source, 'Collection, 'Result> -> System.Linq.ParallelQuery<'Result>
Type Parameters
TSource
TCollection
TResult
O tipo de elementos a serem retornados.
Parameters
collectionSelector Func<TSource,Int32,IEnumerable<TCollection>>
Returns
Uma sequência cujos elementos são o resultado de chamar a função de transformação de um para muitos
collectionSelector em cada elemento de source com base no índice fornecido para collectionSelector e então
mapear cada um desses elementos de sequência para seus elementos de origem correspondentes para um elemento
de resultado.
Exceptions
Also
resultantes em uma sequência.
public static System.Linq.ParallelQuery<TResult> SelectMany<TSource,TResult> (this

Func<TSource,System.Collections.Generic.IEnumerable<TResult>> selector);
static member SelectMany : System.Linq.ParallelQuery<'Source> * Func<'Source, seq<'Result>> ->
Type Parameters
TSource
TResult
O tipo dos elementos da sequência retornada pelo seletor.
Parameters
selector Func<TSource,IEnumerable<TResult>>
Returns
Uma sequência cujos elementos são o resultado de invocar a função de transformação de um para muitos em cada
Exceptions
Also
resultantes em uma sequência. O índice de cada elemento de origem é usado no formulário projetado desse elemento.
public static System.Linq.ParallelQuery<TResult> SelectMany<TSource,TResult> (this

Func<TSource,int,System.Collections.Generic.IEnumerable<TResult>> selector);
static member SelectMany : System.Linq.ParallelQuery<'Source> * Func<'Source, int, seq<'Result>> ->
Type Parameters
TSource
TResult
O tipo dos elementos da sequência retornada pelo seletor.
Parameters
selector Func<TSource,Int32,IEnumerable<TResult>>
Returns
Uma sequência cujos elementos são o resultado de invocar a função de transformação de um para muitos em cada
Exceptions
Also
ParallelEnumerable.SequenceEqual ParallelEnumerable.
SequenceEqual
I n this Article
Overloads
SequenceEqual<TSource>(ParallelQuery<TSource>,
IEnumerable<TSource>) SequenceEqual<TSource>(Parallel Essa sobrecarga SequenceEqual nunca deve ser chamada. Esse
Query<TSource>, IEnumerable<TSource>) método está marcado como obsoleto e sempre gera
SequenceEqual<TSource>(ParallelQuery<TSource>, Parallel
Query<TSource>) SequenceEqual<TSource>(ParallelQuery< Determina se duas sequências paralelas são iguais
TSource>, ParallelQuery<TSource>) comparando os elementos usando o comparador de igualdade
IEnumerable<TSource>, IEqualityComparer<TSource>) Essa sobrecarga SequenceEqual nunca deve ser chamada. Esse
SequenceEqual<TSource>(ParallelQuery<TSource>, método está marcado como obsoleto e sempre gera
IEnumerable<TSource>, IEqualityComparer<TSource>) NotSupportedException quando chamado.
SequenceEqual<TSource>(ParallelQuery<TSource>, Parallel
Query<TSource>, IEqualityComparer<TSource>) Sequence Determina se duas sequências paralelas são iguais
Equal<TSource>(ParallelQuery<TSource>, ParallelQuery< comparando seus elementos usando um IEqualityComparer{T}
TSource>, IEqualityComparer<TSource>) especificado.
Essa sobrecarga SequenceEqual nunca deve ser chamada. Esse método está marcado como obsoleto e sempre gera

public static bool SequenceEqual<TSource> (this System.Linq.ParallelQuery<TSource> first,
static member SequenceEqual : System.Linq.ParallelQuery<'Source> * seq<'Source> -> bool
Type Parameters
TSource
Parameters
Returns
Boolean Boolean
Exceptions
Gerada toda vez que esse método é chamado.
Remarks
Essa sobrecarga existe para não permitir o uso de SequenceEqual com uma fonte de dados à esquerda do tipo
ParallelQuery<TSource> e uma fonte de dados à direita do tipo IEnumerable<T>. Caso contrário, o operador
SequenceEqual apareceria a ligação com a implementação paralela, mas na realidade associaria na implementação
sequencial.
Also
ParallelQuery<TSource>) SequenceEqual<TSource>
Determina se duas sequências paralelas são iguais comparando os elementos usando o comparador de igualdade

System.Linq.ParallelQuery<TSource> second);
static member SequenceEqual : System.Linq.ParallelQuery<'Source> *
System.Linq.ParallelQuery<'Source> -> bool
Type Parameters
TSource
Parameters
Uma sequência à qual comparar em segundo lugar.
Uma sequência a comparar com a primeira sequência de entrada.
Returns
Boolean Boolean
True se duas sequências de origem forem de comprimento igual e seus elementos correspondentes forem iguais de
acordo com o comparador de igualdade padrão para seu tipo; caso contrário, false.
Exceptions
Also
Essa sobrecarga SequenceEqual nunca deve ser chamada. Esse método está marcado como obsoleto e sempre gera
static member SequenceEqual : System.Linq.ParallelQuery<'Source> * seq<'Source> *
Type Parameters
TSource
Parameters
Returns
Boolean Boolean
Exceptions
Gerada toda vez que esse método é chamado.
Remarks
Essa sobrecarga existe para não permitir o uso de SequenceEqual com uma fonte de dados à esquerda do tipo
ParallelQuery<TSource> e uma fonte de dados à direita do tipo IEnumerable<T>. Caso contrário, o operador
SequenceEqual apareceria a ligação com a implementação paralela, mas na realidade associaria a implementação
sequencial.
Also
Determina se duas sequências paralelas são iguais comparando seus elementos usando um IEqualityComparer{T}
especificado.

System.Linq.ParallelQuery<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>
comparer);
static member SequenceEqual : System.Linq.ParallelQuery<'Source> *
System.Linq.ParallelQuery<'Source> * System.Collections.Generic.IEqualityComparer<'Source> -> bool
Type Parameters
TSource
Parameters
Uma sequência à qual comparar com second .

Uma sequência a comparar com a primeira sequência de entrada.
Returns
Boolean Boolean
True se duas sequências de origem forem de comprimento igual e seus elementos correspondentes forem iguais de
acordo com o comparador de igualdade padrão para seu tipo; caso contrário, false.
Exceptions
Also
ParallelEnumerable.Single ParallelEnumerable.Single
I n this Article
Overloads
Single<TSource>(ParallelQuery<TSource>) Single<TSource>(
ParallelQuery<TSource>) Retorna o único elemento de uma sequência paralela e gerará
uma exceção se não houver exatamente um elemento na
sequência.
Single<TSource>(ParallelQuery<TSource>, Func<TSource,
Boolean>) Single<TSource>(ParallelQuery<TSource>, Func< Retorna o único elemento de uma sequência paralela que
TSource,Boolean>) satisfaz uma condição especificada e gera uma exceção se
houver mais de um desses elementos.
Single<TSource>(ParallelQuery<TSource>) Single<TSource>
Retorna o único elemento de uma sequência paralela e gerará uma exceção se não houver exatamente um elemento na
sequência.
public static TSource Single<TSource> (this System.Linq.ParallelQuery<TSource> source);
static member Single : System.Linq.ParallelQuery<'Source> -> 'Source
Type Parameters
TSource
Parameters
A sequência para retornar o único elemento.
Returns
TSource TSource
Exceptions
A sequência de entrada contém mais de um elemento. -ou- A sequência de entrada está vazia.
Also
Single<TSource>(ParallelQuery<TSource>,
Func<TSource,Boolean>) Single<TSource>
Retorna o único elemento de uma sequência paralela que satisfaz uma condição especificada e gera uma exceção se
houver mais de um desses elementos.
public static TSource Single<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member Single : System.Linq.ParallelQuery<'Source> * Func<'Source, bool> -> 'Source
Type Parameters
TSource
Parameters
Returns
TSource TSource
O único elemento da sequência de entrada que atende a uma condição.
Exceptions
Nenhum elemento satisfaz a condição na predicate . -ou- mais de um elemento satisfaz a condição em predicate .
Also
ParallelEnumerable.SingleOrDefault ParallelEnumerable.
SingleOrDefault
I n this Article
Overloads
SingleOrDefault<TSource>(ParallelQuery<TSource>) SingleOr
Default<TSource>(ParallelQuery<TSource>) Retorna o único elemento de uma sequência paralela ou um
valor padrão, se a sequência estiver vazia. Esse método gerará
uma exceção se houver mais de um elemento na sequência.
SingleOrDefault<TSource>(ParallelQuery<TSource>, Func<
TSource,Boolean>) SingleOrDefault<TSource>(ParallelQuery< Retorna o único elemento de uma sequência paralela que
TSource>, Func<TSource,Boolean>) satisfaz uma condição especificada ou um valor padrão se esse
elemento não existir. Esse método lançará uma exceção se
mais de um elemento satisfizer a condição.
Retorna o único elemento de uma sequência paralela ou um valor padrão, se a sequência estiver vazia. Esse método
gerará uma exceção se houver mais de um elemento na sequência.
public static TSource SingleOrDefault<TSource> (this System.Linq.ParallelQuery<TSource> source);
static member SingleOrDefault : System.Linq.ParallelQuery<'Source> -> 'Source
Type Parameters
TSource
Parameters
Returns
TSource TSource
O único elemento de sequência de entrada ou default() se a sequência não contiver elementos.
Exceptions
O source tem mais de um elemento.
Also
SingleOrDefault<TSource>(ParallelQuery<TSource>,
Func<TSource,Boolean>) SingleOrDefault<TSource>
Retorna o único elemento de uma sequência paralela que satisfaz uma condição especificada ou um valor padrão se
esse elemento não existir. Esse método lançará uma exceção se mais de um elemento satisfizer a condição.
public static TSource SingleOrDefault<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member SingleOrDefault : System.Linq.ParallelQuery<'Source> * Func<'Source, bool> -> 'Source
Type Parameters
TSource
Parameters
Returns
TSource TSource
O único elemento de sequência de entrada que satisfaz a condição ou default() se esse elemento não for encontrado.
Exceptions
source está vazio ou vários elementos são retornados.
Also
ParallelEnumerable.Skip ParallelEnumerable.Skip
I n this Article
Ignora um número especificado de elementos em uma sequência paralela e retorna os elementos restantes.
public static System.Linq.ParallelQuery<TSource> Skip<TSource> (this
System.Linq.ParallelQuery<TSource> source, int count);
static member Skip : System.Linq.ParallelQuery<'Source> * int -> System.Linq.ParallelQuery<'Source>
Type Parameters
TSource
Parameters
count Int32 Int32
Returns
Uma sequência que contém os elementos que ocorrem após o índice especificado na sequência de entrada.
Exceptions
A contagem é maior que MaxValue
Remarks
Se count > origem. Count (), nenhum elemento é retornado.
Also
ParallelEnumerable.SkipWhile ParallelEnumerable.Skip
While
I n this Article
Overloads
SkipWhile<TSource>(ParallelQuery<TSource>, Func<TSource,
Boolean>) SkipWhile<TSource>(ParallelQuery<TSource>, Ignora elementos em uma sequência paralela, contanto que
Func<TSource,Boolean>) uma condição especificada seja verdadeira e retorne os
SkipWhile<TSource>(ParallelQuery<TSource>, Func<TSource,
Int32,Boolean>) SkipWhile<TSource>(ParallelQuery< Ignora elementos em uma sequência paralela, contanto que
TSource>, Func<TSource,Int32,Boolean>) uma condição especificada seja verdadeira e retorne os
elementos restantes. O índice do elemento é usado na lógica
da função de predicado.
SkipWhile<TSource>(ParallelQuery<TSource>,
Func<TSource,Boolean>) SkipWhile<TSource>
Ignora elementos em uma sequência paralela, contanto que uma condição especificada seja verdadeira e retorne os
public static System.Linq.ParallelQuery<TSource> SkipWhile<TSource> (this
System.Linq.ParallelQuery<TSource> source, Func<TSource,bool> predicate);
static member SkipWhile : System.Linq.ParallelQuery<'Source> * Func<'Source, bool> ->
Type Parameters
TSource
Parameters
Returns
Uma sequência que contém os elementos da sequência de entrada iniciando no primeiro elemento da série linear que
não passa no teste especificado pelo predicado.
Exceptions
Also
SkipWhile<TSource>(ParallelQuery<TSource>,
Func<TSource,Int32,Boolean>) SkipWhile<TSource>
(ParallelQuery<TSource>, Func<TSource,Int32,Boolean>)
Ignora elementos em uma sequência paralela, contanto que uma condição especificada seja verdadeira e retorne os
public static System.Linq.ParallelQuery<TSource> SkipWhile<TSource> (this
System.Linq.ParallelQuery<TSource> source, Func<TSource,int,bool> predicate);
static member SkipWhile : System.Linq.ParallelQuery<'Source> * Func<'Source, int, bool> ->
Type Parameters
TSource
Parameters
Returns
Uma sequência que contém os elementos da sequência de entrada iniciando no primeiro elemento da série linear que
não passa no teste especificado pelo predicado.
Exceptions
Also
ParallelEnumerable.Sum ParallelEnumerable.Sum
I n this Article
Overloads
Sum(ParallelQuery<Nullable<Single>>) Sum(ParallelQuery<
Nullable<Single>>) Calcula em paralelo a soma de uma sequência de valores.
Sum(ParallelQuery<Nullable<Int64>>) Sum(ParallelQuery<
Nullable<Int64>>) Calcula em paralelo a soma de uma sequência de valores.
Sum(ParallelQuery<Nullable<Int32>>) Sum(ParallelQuery<
Nullable<Int32>>) Calcula em paralelo a soma de uma sequência de valores.
Sum(ParallelQuery<Nullable<Double>>) Sum(ParallelQuery<
Nullable<Double>>) Calcula em paralelo a soma de uma sequência de valores.
Sum(ParallelQuery<Single>) Sum(ParallelQuery<Single>)
Sum(ParallelQuery<Int64>) Sum(ParallelQuery<Int64>)
Sum(ParallelQuery<Double>) Sum(ParallelQuery<Double>)
Sum(ParallelQuery<Decimal>) Sum(ParallelQuery<Decimal>)
Sum(ParallelQuery<Nullable<Decimal>>) Sum(ParallelQuery<
Nullable<Decimal>>) Calcula em paralelo a soma de uma sequência de valores.
Sum<TSource>(ParallelQuery<TSource>, Func<TSource,
Single>) Sum<TSource>(ParallelQuery<TSource>, Func< Calcula em paralelo a soma da sequência de valores obtidos
TSource,Single>) chamando uma função de transformação em cada elemento
Decimal>) Sum<TSource>(ParallelQuery<TSource>, Func< Calcula em paralelo a soma da sequência de valores obtidos
TSource,Decimal>) chamando uma função de transformação em cada elemento
Double>) Sum<TSource>(ParallelQuery<TSource>, Func< Calcula em paralelo a soma da sequência de valores obtidos
TSource,Double>) chamando uma função de transformação em cada elemento
Int32>) Sum<TSource>(ParallelQuery<TSource>, Func< Calcula em paralelo a soma da sequência de valores obtidos
TSource,Int32>) chamando uma função de transformação em cada elemento
Int64>) Sum<TSource>(ParallelQuery<TSource>, Func< Calcula em paralelo a soma da sequência de valores obtidos
TSource,Int64>) chamando uma função de transformação em cada elemento
Nullable<Decimal>>) Sum<TSource>(ParallelQuery< Calcula em paralelo a soma da sequência de valores obtidos
TSource>, Func<TSource,Nullable<Decimal>>) chamando uma função de transformação em cada elemento
Nullable<Double>>) Sum<TSource>(ParallelQuery<TSource>, Calcula em paralelo a soma da sequência de valores obtidos
Func<TSource,Nullable<Double>>) chamando uma função de transformação em cada elemento
Nullable<Int32>>) Sum<TSource>(ParallelQuery<TSource>, Calcula em paralelo a soma da sequência de valores obtidos
Func<TSource,Nullable<Int32>>) chamando uma função de transformação em cada elemento
Nullable<Int64>>) Sum<TSource>(ParallelQuery<TSource>, Calcula em paralelo a soma da sequência de valores obtidos
Func<TSource,Nullable<Int64>>) chamando uma função de transformação em cada elemento
Nullable<Single>>) Sum<TSource>(ParallelQuery<TSource>, Calcula em paralelo a soma da sequência de valores obtidos
Func<TSource,Nullable<Single>>) chamando uma função de transformação em cada elemento
public static Nullable<float> Sum (this System.Linq.ParallelQuery<Nullable<float>> source);

static member Sum : System.Linq.ParallelQuery<Nullable<single>> -> Nullable<single>
Parameters
Uma sequência de valores para calcular a soma.
Returns
Nullable<Single>
A soma dos valores projetados na sequência.
Exceptions
A soma é maior que MaxValue. -ou- uma ou mais exceções ocorreram durante a avaliação da consulta.
Also
public static Nullable<long> Sum (this System.Linq.ParallelQuery<Nullable<long>> source);
static member Sum : System.Linq.ParallelQuery<Nullable<int64>> -> Nullable<int64>
Parameters
Returns
Nullable<Int64>
Exceptions
A soma é maior que MaxValue. -ou- Uma ou mais exceções ocorreram durante a avaliação da consulta.
Also
public static Nullable<int> Sum (this System.Linq.ParallelQuery<Nullable<int>> source);
static member Sum : System.Linq.ParallelQuery<Nullable<int>> -> Nullable<int>
Parameters
Returns
Nullable<Int32>
Exceptions
Also
public static Nullable<double> Sum (this System.Linq.ParallelQuery<Nullable<double>> source);

static member Sum : System.Linq.ParallelQuery<Nullable<double>> -> Nullable<double>
Parameters
Returns
Nullable<Double>
Exceptions
Also
Sum(ParallelQuery<Single>) Sum(ParallelQuery<Single>)
public static float Sum (this System.Linq.ParallelQuery<float> source);

static member Sum : System.Linq.ParallelQuery<single> -> single
Parameters
Returns
Single Single
Exceptions
Also
public static long Sum (this System.Linq.ParallelQuery<long> source);

static member Sum : System.Linq.ParallelQuery<int64> -> int64
Parameters
Returns
Int64 Int64
Exceptions
Also
public static int Sum (this System.Linq.ParallelQuery<int> source);

static member Sum : System.Linq.ParallelQuery<int> -> int
Parameters
Returns
Int32 Int32
Exceptions
Also
Sum(ParallelQuery<Double>) Sum(ParallelQuery<Double>)
public static double Sum (this System.Linq.ParallelQuery<double> source);

static member Sum : System.Linq.ParallelQuery<double> -> double
Parameters
Returns
Double Double
Exceptions
Also
Sum(ParallelQuery<Decimal>) Sum(ParallelQuery<Decimal>)
public static decimal Sum (this System.Linq.ParallelQuery<decimal> source);

static member Sum : System.Linq.ParallelQuery<decimal> -> decimal
Parameters
Returns
Decimal Decimal
Exceptions
Also
public static Nullable<decimal> Sum (this System.Linq.ParallelQuery<Nullable<decimal>> source);

static member Sum : System.Linq.ParallelQuery<Nullable<decimal>> -> Nullable<decimal>
Parameters
Returns
Nullable<Decimal>
Exceptions
Also
public static float Sum<TSource> (this System.Linq.ParallelQuery<TSource> source,

static member Sum : System.Linq.ParallelQuery<'Source> * Func<'Source, single> -> single
Type Parameters
TSource
Parameters
Returns
Single Single
Exceptions
Also
Sum<TSource>(ParallelQuery<TSource>,
Func<TSource,Decimal>) Sum<TSource>
public static decimal Sum<TSource> (this System.Linq.ParallelQuery<TSource> source,

static member Sum : System.Linq.ParallelQuery<'Source> * Func<'Source, decimal> -> decimal
Type Parameters
TSource
Parameters
Returns
Decimal Decimal
Exceptions
Also
public static double Sum<TSource> (this System.Linq.ParallelQuery<TSource> source,

static member Sum : System.Linq.ParallelQuery<'Source> * Func<'Source, double> -> double
Type Parameters
TSource
Parameters
Returns
Double Double
Exceptions
Also
public static int Sum<TSource> (this System.Linq.ParallelQuery<TSource> source, Func<TSource,int>

selector);
static member Sum : System.Linq.ParallelQuery<'Source> * Func<'Source, int> -> int
Type Parameters
TSource
O tipo dos elementos na sequência de origem.
Parameters
Returns
Int32 Int32
Exceptions
Also
public static long Sum<TSource> (this System.Linq.ParallelQuery<TSource> source, Func<TSource,long>

selector);
static member Sum : System.Linq.ParallelQuery<'Source> * Func<'Source, int64> -> int64
Type Parameters
TSource
Parameters
Returns
Int64 Int64
Exceptions
Also
Func<TSource,Nullable<Decimal>>) Sum<TSource>
public static Nullable<decimal> Sum<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member Sum : System.Linq.ParallelQuery<'Source> * Func<'Source, Nullable<decimal>> ->
Nullable<decimal>
Type Parameters
TSource
Parameters
Returns
Nullable<Decimal>
Exceptions
Also
Func<TSource,Nullable<Double>>) Sum<TSource>
public static Nullable<double> Sum<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member Sum : System.Linq.ParallelQuery<'Source> * Func<'Source, Nullable<double>> ->
Nullable<double>
Type Parameters
TSource
Parameters
Returns
Nullable<Double>
Exceptions
Also
public static Nullable<int> Sum<TSource> (this System.Linq.ParallelQuery<TSource> source,

static member Sum : System.Linq.ParallelQuery<'Source> * Func<'Source, Nullable<int>> ->
Nullable<int>
Type Parameters
TSource
Parameters
Returns
Nullable<Int32>
Exceptions
Also
public static Nullable<long> Sum<TSource> (this System.Linq.ParallelQuery<TSource> source,

static member Sum : System.Linq.ParallelQuery<'Source> * Func<'Source, Nullable<int64>> ->
Nullable<int64>
Type Parameters
TSource
Parameters
Returns
Nullable<Int64>
Exceptions
Also
Func<TSource,Nullable<Single>>) Sum<TSource>
public static Nullable<float> Sum<TSource> (this System.Linq.ParallelQuery<TSource> source,
static member Sum : System.Linq.ParallelQuery<'Source> * Func<'Source, Nullable<single>> ->
Nullable<single>
Type Parameters
TSource
Parameters
Returns
Nullable<Single>
Exceptions
A soma é maior que MaxValue. -ou- uma ou mais exceções ocorreram durante a avaliação da consulta.
Also
ParallelEnumerable.Take ParallelEnumerable.Take
I n this Article
Retorna um número especificado de elementos contíguos do início de uma sequência paralela.
public static System.Linq.ParallelQuery<TSource> Take<TSource> (this
System.Linq.ParallelQuery<TSource> source, int count);
static member Take : System.Linq.ParallelQuery<'Source> * int -> System.Linq.ParallelQuery<'Source>
Type Parameters
TSource
Parameters
count Int32 Int32
Returns
Uma sequência que contém o número especificado de elementos do início da sequência de entrada.
Exceptions
Also
ParallelEnumerable.TakeWhile ParallelEnumerable.Take
While
I n this Article
Overloads
TakeWhile<TSource>(ParallelQuery<TSource>, Func<TSource,
Int32,Boolean>) TakeWhile<TSource>(ParallelQuery< Retorna os elementos de uma sequência paralela, contanto
TSource>, Func<TSource,Int32,Boolean>) que uma condição especificada seja verdadeira. O índice do
TakeWhile<TSource>(ParallelQuery<TSource>, Func<TSource,
Boolean>) TakeWhile<TSource>(ParallelQuery<TSource>, Retorna os elementos de uma sequência paralela, contanto
Func<TSource,Boolean>) que uma condição especificada seja verdadeira.
TakeWhile<TSource>(ParallelQuery<TSource>,
Func<TSource,Int32,Boolean>) TakeWhile<TSource>
Retorna os elementos de uma sequência paralela, contanto que uma condição especificada seja verdadeira. O índice do
public static System.Linq.ParallelQuery<TSource> TakeWhile<TSource> (this
static member TakeWhile : System.Linq.ParallelQuery<'Source> * Func<'Source, int, bool> ->
Type Parameters
TSource
Parameters
Returns
Uma sequência que contém elementos da sequência de entrada que ocorrem antes do elemento no qual o teste não é
mais aprovado.
Exceptions
Mais de MaxValue elementos são enumerados por essa consulta.
Also
TakeWhile<TSource>(ParallelQuery<TSource>,
Func<TSource,Boolean>) TakeWhile<TSource>
Retorna os elementos de uma sequência paralela, contanto que uma condição especificada seja verdadeira.
public static System.Linq.ParallelQuery<TSource> TakeWhile<TSource> (this
static member TakeWhile : System.Linq.ParallelQuery<'Source> * Func<'Source, bool> ->
Type Parameters
TSource
Parameters
Returns
Uma sequência que contém elementos da sequência de entrada que ocorrem antes do elemento no qual o teste não é
mais aprovado.
Exceptions
Also
ParallelEnumerable.ThenBy ParallelEnumerable.ThenBy
I n this Article
Overloads
ThenBy<TSource,TKey>(OrderedParallelQuery<TSource>,
Func<TSource,TKey>) ThenBy<TSource,TKey>(OrderedParallel Executa em paralelo uma ordenação subsequente dos
Query<TSource>, Func<TSource,TKey>) elementos em uma sequência em ordem crescente de acordo
com uma chave.
Func<TSource,TKey>, IComparer<TKey>) ThenBy<TSource, Executa em paralelo uma ordenação posterior dos elementos
TKey>(OrderedParallelQuery<TSource>, Func<TSource,TKey>, em uma sequência em ordem crescente usando um
IComparer<TKey>) comparador especificado.
Func<TSource,TKey>) ThenBy<TSource,TKey>
(OrderedParallelQuery<TSource>, Func<TSource,TKey>)
Executa em paralelo uma ordenação subsequente dos elementos em uma sequência em ordem crescente de acordo
com uma chave.
public static System.Linq.OrderedParallelQuery<TSource> ThenBy<TSource,TKey> (this
System.Linq.OrderedParallelQuery<TSource> source, Func<TSource,TKey> keySelector);
static member ThenBy : System.Linq.OrderedParallelQuery<'Source> * Func<'Source, 'Key> ->
Type Parameters
TSource
TKey
Parameters
source OrderedParallelQuery<TSource> OrderedParallelQuery<TSource>
Returns
Exceptions
Remarks
Also
Func<TSource,TKey>, IComparer<TKey>) ThenBy<TSource,TKey>
(OrderedParallelQuery<TSource>, Func<TSource,TKey>,
IComparer<TKey>)
Executa em paralelo uma ordenação posterior dos elementos em uma sequência em ordem crescente usando um
public static System.Linq.OrderedParallelQuery<TSource> ThenBy<TSource,TKey> (this
System.Linq.OrderedParallelQuery<TSource> source, Func<TSource,TKey> keySelector,
static member ThenBy : System.Linq.OrderedParallelQuery<'Source> * Func<'Source, 'Key> *
Type Parameters
TSource
TKey
Parameters
Returns
Exceptions
Remarks
Also
ParallelEnumerable.ThenByDescending Parallel
Enumerable.ThenByDescending
I n this Article
Overloads
ThenByDescending<TSource,TKey>(OrderedParallelQuery<
TSource>, Func<TSource,TKey>) ThenByDescending<TSource, Executa em paralelo uma ordenação subsequente dos
TKey>(OrderedParallelQuery<TSource>, Func<TSource,TKey>) elementos em uma sequência em ordem decrescente de
ThenByDescending<TSource,TKey>(OrderedParallelQuery<
TSource>, Func<TSource,TKey>, IComparer<TKey>) ThenBy Executa em paralelo uma ordenação posterior dos elementos
Descending<TSource,TKey>(OrderedParallelQuery<TSource>, em uma sequência em ordem decrescente usando um
Func<TSource,TKey>, IComparer<TKey>) comparador especificado.
Executa em paralelo uma ordenação subsequente dos elementos em uma sequência em ordem decrescente de acordo
com uma chave.
public static System.Linq.OrderedParallelQuery<TSource> ThenByDescending<TSource,TKey> (this
System.Linq.OrderedParallelQuery<TSource> source, Func<TSource,TKey> keySelector);
static member ThenByDescending : System.Linq.OrderedParallelQuery<'Source> * Func<'Source, 'Key> ->
Type Parameters
TSource
TKey
Parameters
Returns
Uma sequência cujos elementos são classificados em ordem decrescente de acordo com uma chave.
Exceptions
Remarks
Also
IComparer<TKey>) ThenByDescending<TSource,TKey>
IComparer<TKey>)
Executa em paralelo uma ordenação posterior dos elementos em uma sequência em ordem decrescente usando um
public static System.Linq.OrderedParallelQuery<TSource> ThenByDescending<TSource,TKey> (this
System.Linq.OrderedParallelQuery<TSource> source, Func<TSource,TKey> keySelector,
static member ThenByDescending : System.Linq.OrderedParallelQuery<'Source> * Func<'Source, 'Key> *
Type Parameters
TSource
TKey
Parameters
Returns
Uma sequência cujos elementos são classificados em ordem decrescente de acordo com uma chave.
Exceptions
Remarks
Also
ParallelEnumerable.ToArray ParallelEnumerable.ToArray
I n this Article
Cria uma matriz de um ParallelQuery<TSource>.
public static TSource[] ToArray<TSource> (this System.Linq.ParallelQuery<TSource> source);
static member ToArray : System.Linq.ParallelQuery<'Source> -> 'Source[]
Type Parameters
TSource
Parameters
Uma sequência da qual criar uma matriz.
Returns
TSource[]
Uma matriz que contém os elementos da sequência de entrada.
Exceptions
Also
ParallelEnumerable.ToDictionary ParallelEnumerable.To
Dictionary
I n this Article
Overloads
ToDictionary<TSource,TKey,TElement>(ParallelQuery<
TSource>, Func<TSource,TKey>, Func<TSource,TElement>) To Cria um Dictionary<TKey,TValue> de um
Dictionary<TSource,TKey,TElement>(ParallelQuery<TSource>, ParallelQuery<TSource> de acordo com as funções
Func<TSource,TKey>, Func<TSource,TElement>) especificadas de seletor de chave e seletor de elemento.
ToDictionary<TSource,TKey,TElement>(ParallelQuery<
TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Cria um Dictionary<TKey,TValue> de um
IEqualityComparer<TKey>) ToDictionary<TSource,TKey, ParallelQuery<TSource> de acordo com uma função de
TElement>(ParallelQuery<TSource>, Func<TSource,TKey>, seletor de chave, um comparador e uma função de seletor de
Func<TSource,TElement>, IEqualityComparer<TKey>) elemento especificados.
ToDictionary<TSource,TKey>(ParallelQuery<TSource>, Func<
TSource,TKey>) ToDictionary<TSource,TKey>(ParallelQuery< Cria um Dictionary<TKey,TValue> de um
TSource>, Func<TSource,TKey>) ParallelQuery<TSource> de acordo com uma função de
seletor de chave especificada.
ToDictionary<TSource,TKey>(ParallelQuery<TSource>, Func<
TSource,TKey>, IEqualityComparer<TKey>) ToDictionary< Cria um Dictionary<TKey,TValue> de um
TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>, ParallelQuery<TSource> de acordo com uma função de
IEqualityComparer<TKey>) seletor de chave e um comparador de chaves especificados.
ToDictionary<TSource,TKey,TElement>(ParallelQuery<TSource>,
Cria um Dictionary<TKey,TValue> de um ParallelQuery<TSource> de acordo com as funções especificadas de seletor
de chave e seletor de elemento.
ToDictionary<TSource,TKey,TElement> (this System.Linq.ParallelQuery<TSource> source,
static member ToDictionary : System.Linq.ParallelQuery<'Source> * Func<'Source, 'Key> *
Func<'Source, 'Element> -> System.Collections.Generic.Dictionary<'Key, 'Element>
Type Parameters
TSource
TKey
TElement
Parameters
Uma sequência da qual criar um Dictionary<TKey,TValue>.
Returns
Um Dictionary<TKey,TValue> que contém os valores do tipo TElement selecionados da sequência de entrada
Exceptions
source ou keySelector ou elementSelector é uma referência nula (Nothing no Visual Basic).
keySelector gera uma chave que é uma referência nula (Nothing no Visual Basic). -ou- keySelector produz chaves
duplicadas para os dois elementos. -ou- Uma ou mais exceções ocorreram durante a avaliação da consulta.
Also
Cria um Dictionary<TKey,TValue> de um ParallelQuery<TSource> de acordo com uma função de seletor de chave, um
ToDictionary<TSource,TKey,TElement> (this System.Linq.ParallelQuery<TSource> source,
Func<'Source, 'Element> * System.Collections.Generic.IEqualityComparer<'Key> ->
Type Parameters
TSource
TKey
TElement
Parameters
Returns
Um Dictionary<TKey,TValue> que contém os valores do tipo TElement selecionados da sequência de entrada
Exceptions
Also
ToDictionary<TSource,TKey>(ParallelQuery<TSource>,
Func<TSource,TKey>) ToDictionary<TSource,TKey>
Cria um Dictionary<TKey,TValue> de um ParallelQuery<TSource> de acordo com uma função de seletor de chave
especificada.
static member ToDictionary : System.Linq.ParallelQuery<'Source> * Func<'Source, 'Key> ->
System.Collections.Generic.Dictionary<'Key, 'Source>
Type Parameters
TSource
TKey
Parameters
Returns
Exceptions
Also
Cria um Dictionary<TKey,TValue> de um ParallelQuery<TSource> de acordo com uma função de seletor de chave e
um comparador de chaves especificados.
'Source>
Type Parameters
TSource
TKey
Parameters
Returns
Exceptions
Also
ParallelEnumerable.ToList ParallelEnumerable.ToList
I n this Article
Cria um List<T> de um ParallelQuery<TSource>.
public static System.Collections.Generic.List<TSource> ToList<TSource> (this
static member ToList : System.Linq.ParallelQuery<'Source> ->
System.Collections.Generic.List<'Source>
Type Parameters
TSource
Parameters
Uma sequência da qual criar um List<T>.
Returns
List<TSource>
Um List<T> que contém elementos da sequência de entrada.
Exceptions
Also
ParallelEnumerable.ToLookup ParallelEnumerable.To
Lookup
I n this Article
Overloads
ToLookup<TSource,TKey,TElement>(ParallelQuery<TSource>,
Func<TSource,TKey>, Func<TSource,TElement>, IEquality Cria um ILookup<TKey,TElement> de um
Comparer<TKey>) ToLookup<TSource,TKey,TElement>( ParallelQuery<TSource> de acordo com uma função de
ParallelQuery<TSource>, Func<TSource,TKey>, Func<TSource, seletor de chave, um comparador e uma função de seletor de
TElement>, IEqualityComparer<TKey>) elemento especificados.
Func<TSource,TKey>, Func<TSource,TElement>) ToLookup< Cria um ILookup<TKey,TElement> de um
TSource,TKey,TElement>(ParallelQuery<TSource>, Func< ParallelQuery<TSource> de acordo com as funções
TSource,TKey>, Func<TSource,TElement>) especificadas de seletor de chave e seletor de elemento.
ToLookup<TSource,TKey>(ParallelQuery<TSource>, Func<
TSource,TKey>, IEqualityComparer<TKey>) ToLookup< Cria um ILookup<TKey,TElement> de um
TSource,TKey>(ParallelQuery<TSource>, Func<TSource,TKey>, ParallelQuery<TSource> de acordo com uma função de
IEqualityComparer<TKey>) seletor de chave e um comparador de chaves especificados.
ToLookup<TSource,TKey>(ParallelQuery<TSource>, Func<
TSource,TKey>) ToLookup<TSource,TKey>(ParallelQuery< Cria um ILookup<TKey,TElement> de um
TSource>, Func<TSource,TKey>) ParallelQuery<TSource> de acordo com uma função de
seletor de chave especificada.
IEqualityComparer<TKey>) ToLookup<TSource,TKey,TElement>
Cria um ILookup<TKey,TElement> de um ParallelQuery<TSource> de acordo com uma função de seletor de chave,
um comparador e uma função de seletor de elemento especificados.
elementSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer);
static member ToLookup : System.Linq.ParallelQuery<'Source> * Func<'Source, 'Key> * Func<'Source,
'Element> * System.Collections.Generic.IEqualityComparer<'Key> -> System.Linq.ILookup<'Key,
'Element>
Type Parameters
TSource
TKey
TElement
Parameters
A sequência da qual criar um ILookup<TKey,TElement>.
Returns
Uma Lookup<(Of <(TKey, TElement>)>) que contém os valores do tipo TElement selecionado da sequência de
entrada.
Exceptions
Also
Cria um ILookup<TKey,TElement> de um ParallelQuery<TSource> de acordo com as funções especificadas de seletor
de chave e seletor de elemento.

elementSelector);
static member ToLookup : System.Linq.ParallelQuery<'Source> * Func<'Source, 'Key> * Func<'Source,
'Element> -> System.Linq.ILookup<'Key, 'Element>
Type Parameters
TSource
TKey
TElement
Parameters
Returns
Um ILookup<TKey,TElement> que contém valores do tipo TElement selecionados da sequência de entrada.
Exceptions
Also
ToLookup<TSource,TKey>(ParallelQuery<TSource>,
Cria um ILookup<TKey,TElement> de um ParallelQuery<TSource> de acordo com uma função de seletor de chave e
um comparador de chaves especificados.
static member ToLookup : System.Linq.ParallelQuery<'Source> * Func<'Source, 'Key> *
System.Collections.Generic.IEqualityComparer<'Key> -> System.Linq.ILookup<'Key, 'Source>
Type Parameters
TSource
TKey
Parameters
Returns
Um ILookup<TKey,TElement> que contém chaves e valores.
Exceptions
source ou keySelector ou é uma referência nula (Nothing no Visual Basic).
Also
Func<TSource,TKey>) ToLookup<TSource,TKey>
Cria um ILookup<TKey,TElement> de um ParallelQuery<TSource> de acordo com uma função de seletor de chave
especificada.
static member ToLookup : System.Linq.ParallelQuery<'Source> * Func<'Source, 'Key> ->
System.Linq.ILookup<'Key, 'Source>
Type Parameters
TSource
TKey
Parameters
Returns
Um ILookup<TKey,TElement> que contém chaves e valores.
Exceptions
Also
ParallelEnumerable.Union ParallelEnumerable.Union
I n this Article
Overloads
Union<TSource>(ParallelQuery<TSource>, IEnumerable<
TSource>) Union<TSource>(ParallelQuery<TSource>, Essa sobrecarga Union nunca deve ser chamada. Esse método
IEnumerable<TSource>) está marcado como obsoleto e sempre gera
Union<TSource>(ParallelQuery<TSource>, ParallelQuery<
TSource>) Union<TSource>(ParallelQuery<TSource>, Parallel Produz a união de conjunto de duas sequências paralelas
Query<TSource>) usando o comparador de igualdade padrão.
Union<TSource>(ParallelQuery<TSource>, IEnumerable<
TSource>, IEqualityComparer<TSource>) Union<TSource>( Essa sobrecarga Union nunca deve ser chamada. Esse método
ParallelQuery<TSource>, IEnumerable<TSource>, IEquality está marcado como obsoleto e sempre gera
Union<TSource>(ParallelQuery<TSource>, ParallelQuery<
TSource>, IEqualityComparer<TSource>) Union<TSource>( Produz a união de conjunto de duas sequências paralelas
ParallelQuery<TSource>, ParallelQuery<TSource>, IEquality usando um IEqualityComparer{T} especificado.
Comparer<TSource>)
Union<TSource>(ParallelQuery<TSource>,
IEnumerable<TSource>) Union<TSource>

public static System.Linq.ParallelQuery<TSource> Union<TSource> (this
static member Union : System.Linq.ParallelQuery<'Source> * seq<'Source> ->
Type Parameters
TSource
Parameters
Returns
Exceptions
Remarks
Essa sobrecarga existe para não permitir o uso de união com uma fonte de dados à esquerda do tipo
ParallelQuery<TSource> e uma fonte de dados à direita do tipo IEnumerable<T>. Caso contrário, o operador de união
apareceria a ligação com a implementação paralela, mas na realidade associaria a implementação sequencial.
Also
ParallelQuery<TSource>) Union<TSource>
Produz a união de conjunto de duas sequências paralelas usando o comparador de igualdade padrão.

static member Union : System.Linq.ParallelQuery<'Source> * System.Linq.ParallelQuery<'Source> ->
Type Parameters
TSource
Parameters
Uma sequência cujos elementos distintos formam o primeiro conjunto da união.
Uma sequência cujos elementos distintos formam o segundo conjunto da união.
Returns
Uma sequência que contém os elementos de ambas as sequências de entrada, exceto as duplicatas.
Exceptions
Also

static member Union : System.Linq.ParallelQuery<'Source> * seq<'Source> *
Type Parameters
TSource
Parameters
Returns
Exceptions
Remarks
Essa sobrecarga existe para não permitir o uso de união com uma fonte de dados à esquerda do tipo
ParallelQuery<TSource> e uma fonte de dados à direita do tipo IEnumerable<T>. Caso contrário, o operador de união
Also
Produz a união de conjunto de duas sequências paralelas usando um IEqualityComparer{T} especificado.

static member Union : System.Linq.ParallelQuery<'Source> * System.Linq.ParallelQuery<'Source> *
Type Parameters
TSource
Parameters
Uma sequência cujos elementos distintos formam o primeiro conjunto da união.
Uma sequência cujos elementos distintos formam o segundo conjunto da união.
Returns
Uma sequência que contém os elementos de ambas as sequências de entrada, exceto as duplicatas.
Exceptions
Also
ParallelEnumerable.Where ParallelEnumerable.Where
I n this Article
Overloads
Where<TSource>(ParallelQuery<TSource>, Func<TSource,
Boolean>) Where<TSource>(ParallelQuery<TSource>, Func< Filtra uma sequência paralela de valores com base em um
TSource,Boolean>) predicado.
Where<TSource>(ParallelQuery<TSource>, Func<TSource,
Int32,Boolean>) Where<TSource>(ParallelQuery<TSource>, Filtra uma sequência paralela de valores com base em um
Func<TSource,Int32,Boolean>) predicado. O índice de cada elemento é usado na lógica da
Where<TSource>(ParallelQuery<TSource>,
Func<TSource,Boolean>) Where<TSource>
Filtra uma sequência paralela de valores com base em um predicado.
public static System.Linq.ParallelQuery<TSource> Where<TSource> (this
static member Where : System.Linq.ParallelQuery<'Source> * Func<'Source, bool> ->
Type Parameters
TSource
Parameters
Uma sequência para filtrar.
Returns
Uma sequência que contém elementos da sequência de entrada que satisfazem à condição.
Exceptions
Also
Where<TSource>(ParallelQuery<TSource>,
Func<TSource,Int32,Boolean>) Where<TSource>
Filtra uma sequência paralela de valores com base em um predicado. O índice de cada elemento é usado na lógica da
public static System.Linq.ParallelQuery<TSource> Where<TSource> (this
static member Where : System.Linq.ParallelQuery<'Source> * Func<'Source, int, bool> ->
Type Parameters
TSource
Parameters
Uma sequência para filtrar.
Returns
Uma sequência que contém elementos da sequência de entrada que satisfazem à condição.
Exceptions
Also
ParallelEnumerable.WithCancellation ParallelEnumerable.
WithCancellation
I n this Article
Define o CancellationToken a associar à consulta.
public static System.Linq.ParallelQuery<TSource> WithCancellation<TSource> (this

System.Linq.ParallelQuery<TSource> source, System.Threading.CancellationToken cancellationToken);
static member WithCancellation : System.Linq.ParallelQuery<'Source> *
System.Threading.CancellationToken -> System.Linq.ParallelQuery<'Source>
Type Parameters
TSource
Parameters
Um ParallelQuery no qual definir a opção.
cancellationToken CancellationToken CancellationToken
Um token de cancelamento.
Returns
O ParallelQuery que representa a mesma consulta como origem, mas com o token de cancelamento registrado.
Exceptions
ObjectDisposedException ObjectDisposedException
O CancellationTokenSource associados ao cancellationToken foi descartado.
WithCancellation é usado várias vezes na consulta.
Also Como cancelar uma consulta PLINQHow to: Cancel a PLINQ Query
CancelamentoCancellation
ParallelEnumerable.WithDegreeOfParallelism Parallel
Enumerable.WithDegreeOfParallelism
I n this Article
Define o grau de paralelismo a ser usado em uma consulta. O grau de paralelismo é o número máximo de tarefas que
serão usadas simultaneamente para processar a consulta.
public static System.Linq.ParallelQuery<TSource> WithDegreeOfParallelism<TSource> (this
System.Linq.ParallelQuery<TSource> source, int degreeOfParallelism);
static member WithDegreeOfParallelism : System.Linq.ParallelQuery<'Source> * int ->
Type Parameters
TSource
Parameters
Um ParallelQuery no qual definir o limite em graus de paralelismo.
degreeOfParallelism Int32 Int32
O grau de paralelismo para a consulta. O valor padrão é Math.Min(ProcessorCount, MAX_SUPPORTED_DOP ) em que
MAX_SUPPORTED_DOP é 512.
Returns
ParallelQuery representa a mesma consulta que a origem, com a limitação no grau de paralelismo definido.
Exceptions
degreeOfParallelism é menor que 1 ou maior que 511.
WithDegreeOfParallelism é usado várias vezes na consulta.
Also
ParallelEnumerable.WithExecutionMode Parallel
Enumerable.WithExecutionMode
I n this Article
Define o modo de execução da consulta.
public static System.Linq.ParallelQuery<TSource> WithExecutionMode<TSource> (this

System.Linq.ParallelQuery<TSource> source, System.Linq.ParallelExecutionMode executionMode);
static member WithExecutionMode : System.Linq.ParallelQuery<'Source> *
System.Linq.ParallelExecutionMode -> System.Linq.ParallelQuery<'Source>
Type Parameters
TSource
Parameters
executionMode ParallelExecutionMode ParallelExecutionMode
O modo no qual executar a consulta.
Returns
O ParallelQuery que representa a mesma consulta como fonte, mas com o modo de execução registrado.
Exceptions
executionMode não é um valor ParallelExecutionMode válido.
WithExecutionMode é usado várias vezes na consulta.
Remarks
O modo de execução Especifica se a PLINQ tentará voltar à execução sequencial se ele detectar determinadas formas
de consulta. Para obter mais informações e exemplos, consulte como: Especificar o modo de execução em PLINQ.
Also
ParallelEnumerable.WithMergeOptions Parallel
Enumerable.WithMergeOptions
I n this Article
Define as opções de mesclagem para essa consulta, que especifica como a consulta armazenará em buffer a saída.
public static System.Linq.ParallelQuery<TSource> WithMergeOptions<TSource> (this

System.Linq.ParallelQuery<TSource> source, System.Linq.ParallelMergeOptions mergeOptions);
static member WithMergeOptions : System.Linq.ParallelQuery<'Source> *
System.Linq.ParallelMergeOptions -> System.Linq.ParallelQuery<'Source>
Type Parameters
TSource
Parameters
mergeOptions ParallelMergeOptions ParallelMergeOptions
As opções de mesclagem definidas para esta consulta.
Returns
O ParallelQuery que representa a mesma consulta como fonte, mas com opções de mesclagem registradas.
Exceptions
mergeOptions não é um valor ParallelMergeOptions válido.
WithMergeOptions é usado várias vezes na consulta.
Also Opções de mesclagem em PLINQMerge Options in PLINQ
Como especificar opções de mesclagem em PLINQHow to: Specify Merge Options in PLINQ
ParallelEnumerable.Zip ParallelEnumerable.Zip
I n this Article
Overloads
Zip<TFirst,TSecond,TResult>(ParallelQuery<TFirst>,
IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>) Zip< Essa sobrecarga de Zip nunca deve ser chamada. Esse método
TFirst,TSecond,TResult>(ParallelQuery<TFirst>, IEnumerable< está marcado como obsoleto e sempre gera
TSecond>, Func<TFirst,TSecond,TResult>) NotSupportedException quando invocado.
Zip<TFirst,TSecond,TResult>(ParallelQuery<TFirst>, Parallel
Query<TSecond>, Func<TFirst,TSecond,TResult>) Zip<TFirst, Mescla em paralelo duas sequências usando a função de
TSecond,TResult>(ParallelQuery<TFirst>, ParallelQuery< predicado especificada.
TSecond>, Func<TFirst,TSecond,TResult>)
IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)
IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)
Essa sobrecarga de Zip nunca deve ser chamada. Esse método está marcado como obsoleto e sempre gera
public static System.Linq.ParallelQuery<TResult> Zip<TFirst,TSecond,TResult> (this
System.Linq.ParallelQuery<TFirst> first, System.Collections.Generic.IEnumerable<TSecond> second,
Func<TFirst,TSecond,TResult> resultSelector);
static member Zip : System.Linq.ParallelQuery<'First> * seq<'Second> * Func<'First, 'Second,
'Result> -> System.Linq.ParallelQuery<'Result>
Type Parameters
TFirst
TSecond
TResult
Parameters
first ParallelQuery<TFirst>
second IEnumerable<TSecond>
Returns
Exceptions
Remarks
Essa sobrecarga existe para não permitir o uso do Zip com uma fonte de dados à esquerda do tipo
ParallelQuery<TSource> e uma fonte de dados à direita do tipo IEnumerable<T>. Caso contrário, o operador de Zip
parece ser associados à implementação paralela, mas na realidade associaria na implementação sequencial.
Also
ParallelQuery<TSecond>, Func<TFirst,TSecond,TResult>)
ParallelQuery<TSecond>, Func<TFirst,TSecond,TResult>)
Mescla em paralelo duas sequências usando a função de predicado especificada.
public static System.Linq.ParallelQuery<TResult> Zip<TFirst,TSecond,TResult> (this
System.Linq.ParallelQuery<TFirst> first, System.Linq.ParallelQuery<TSecond> second,
Func<TFirst,TSecond,TResult> resultSelector);
static member Zip : System.Linq.ParallelQuery<'First> * System.Linq.ParallelQuery<'Second> *
Func<'First, 'Second, 'Result> -> System.Linq.ParallelQuery<'Result>
Type Parameters
TFirst
TSecond
TResult
O tipo dos elementos de retorno.
Parameters
first ParallelQuery<TFirst>
A primeira sequência a compactar.
second ParallelQuery<TSecond>
A segunda sequência a compactar.
Returns
Uma sequência com elementos do tipo TResult que são obtidos pela execução de resultSelector par a par em duas
sequências. Se os comprimentos de sequência forem diferentes, isso truncará o comprimento da sequência mais curta.
Exceptions
first ou second ou resultSelector é uma referência nula (Nothing no Visual Basic).
ParallelExecutionMode ParallelExecutionMode Enum
O modo de execução de consulta é uma dica que especifica como o sistema deve tratar as compensações de
desempenho ao paralelizar consultas.
D eclaration
public enum ParallelExecutionMode
type ParallelExecutionMode =
Object Object
ValueType ValueType
Enum Enum
Fields
Default Default Essa é a configuração padrão. O PLINQ examinará a estrutura da consulta e paralelizará a consulta
apenas se provavelmente isso resultará no aumento de velocidade. Se a estrutura de consulta indicar
que não é provável que esse aumento de velocidade seja obtido, o PLINQ executará a consulta como
uma consulta LINQ to Objects comum.
ForceParallelism Paralelizar toda a consulta, mesmo que isso signifique usar algoritmos de alta sobrecarga. Use esse
ForceParallelism sinalizador nos casos em que você sabe que a execução paralela da consulta resultará no aumento de
velocidade, mas o PLINQ no modo Atual executaria como sequencial.
See Also
ParallelMergeOptions ParallelMergeOptions Enum
Especifica o tipo preferencial de mesclagem de saída a ser usado em uma consulta. Em outras palavras, ele indica
como o PLINQ deve mesclar os resultados de várias partições novamente em uma sequência de resultados. Isso é
apenas uma dica e pode não ser respeitado pelo sistema ao paralelizar todas as consultas.
D eclaration
public enum ParallelMergeOptions
type ParallelMergeOptions =
Object Object
ValueType ValueType
Enum Enum
Remarks
Use NotBuffered para consultas que serão consumidas e como fluxos de saída, isso tem a menor latência entre a
execução da consulta inicial e os elementos que está sendo gerados. Para algumas consultas, como aquelas que
envolvem uma classificação (OrderBy, OrderByDescending), o buffer é essencial e uma dica de NotBuffered ou
AutoBuffered será ignorada. No entanto, as consultas que são criadas usando o operador AsOrdered podem ser
transmitidas desde que nenhuma classificação adicional é executada na própria consulta.
Use AutoBuffered na maioria dos casos; esse é o padrão. Ela atinge um equilíbrio entre a latência e o desempenho
geral.
Use FullyBuffered para consultas quando toda a saída pode ser processada antes que as informações são
necessárias. Essa opção oferece o melhor desempenho quando toda a saída pode ser acumulada antes produzindo
todas as informações que não seja adequado para o fluxo de processamento ou mostrando parcial resultados de
consulta intermediária.
Fields
AutoBuffered Usar uma mesclagem com buffers de saída de um tamanho escolhido pelo sistema. Os resultados
AutoBuffered acumularão em um buffer de saída antes de estarem disponíveis para o consumidor da consulta.
Default Usar o tipo de mesclagem padrão, que é AutoBuffered.

Default
FullyBuffered Usar uma mesclagem com buffers de saída cheios. O sistema acumulará todos os resultados antes de
FullyBuffered disponibilizá-los para o consumidor da consulta.
NotBuffered Usar uma mesclagem sem buffers de saída. Assim que os elementos de resultado tiverem sido
NotBuffered computados, disponibilizar esse elemento para o consumidor na consulta.
See Also
ParallelQuery ParallelQuery Class
D eclaration
public class ParallelQuery : System.Collections.IEnumerable
type ParallelQuery = class
Object Object
See Also
ParallelQuery.IEnumerable.GetEnumerator
I n this Article
Returns
IEnumerator
Also
ParallelQuery<TSource> ParallelQuery<TSource> Class
D eclaration
public class ParallelQuery<TSource> : System.Linq.ParallelQuery,
System.Collections.Generic.IEnumerable<TSource>
type ParallelQuery<'Source> = class
inherit ParallelQuery
interface seq<'Source>
Object Object
Methods
GetEnumerator()
GetEnumerator()
See Also
ParallelQuery<TSource>.GetEnumerator ParallelQuery<
TSource>.GetEnumerator
I n this Article
public virtual System.Collections.Generic.IEnumerator<TSource> GetEnumerator ();

abstract member GetEnumerator : unit -> System.Collections.Generic.IEnumerator<'Source>
override this.GetEnumerator : unit -> System.Collections.Generic.IEnumerator<'Source>
Returns
IEnumerator<TSource>
Also
Queryable Queryable Class
Fornece um conjunto de métodos static ( Shared no Visual Basic) para consultar estruturas de dados que
implementam IQueryable<T>.
D eclaration
public static class Queryable
type Queryable = class
Object Object
Remarks
O conjunto de métodos declarados na Queryable classe fornece uma implementação de operadores de consulta
padrão para consultar dados de fontes que implementam IQueryable<T>. Operadores de consulta padrão são os
métodos de finalidade geral que seguem o LINQ padrão e lhe permitem expressar operações de passagem, filtro e
projeção sobre dados em qualquer um. Linguagem de programação baseado em NET.
A maioria dos métodos nessa classe são definidos como métodos de extensão que estendem o IQueryable<T> tipo.
Isso significa que eles podem ser chamados como um método de instância em qualquer objeto que implementa
IQueryable<T>. Esses métodos que estendem IQueryable<T> não executam qualquer consulta direta. Em vez disso,
sua funcionalidade é criar um Expression objeto, que é uma árvore de expressão que representa a consulta cumulativa.
Os métodos, em seguida, passam a nova árvore de expressão para qualquer um de Execute<TResult>(Expression)
método ou o CreateQuery<TElement>(Expression) método de entrada IQueryable<T>. O método que é chamado
depende se o Queryable método retorna um valor de singleton, caso em que Execute<TResult>(Expression) é
chamado ou tem resultados enumeráveis, caso em que CreateQuery<TElement>(Expression) é chamado.
A execução de consulta real nos dados de destino é realizada por uma classe que implementa IQueryable<T>. A
expectativa de qualquer IQueryable<T> implementação é que o resultado da execução de uma árvore de expressão
que foi criada por um Queryable método de operador de consulta padrão é equivalente ao resultado de chamar o
método correspondente no Enumerable classe, se a fonte de dados fosse uma IEnumerable<T>.
Além dos métodos de operador de consulta padrão que operam em IQueryable<T> objetos, essa classe também
contém um método AsQueryable, que tipos IEnumerable objetos como IQueryable objetos.
Methods
Aggregate<TSource,TAccumulate,TResult>(IQueryable<TSource>, TAccumulate,
Expression<Func<TAccumulate,TSource,TAccumulate>>, Expression<Func<TAccumulate,TResult>>)
Aggregate<TSource,TAccumulate,TResult>(IQueryable<TSource>, TAccumulate,
Expression<Func<TAccumulate,TSource,TAccumulate>>, Expression<Func<TAccumulate,TResult>>)
do acumulador e a função especificada é usada para selecionar o valor do resultado.
Aggregate<TSource,TAccumulate>(IQueryable<TSource>, TAccumulate,
Expression<Func<TAccumulate,TSource,TAccumulate>>)
Aggregate<TSource,TAccumulate>(IQueryable<TSource>, TAccumulate,
do acumulador.
Aggregate<TSource>(IQueryable<TSource>, Expression<Func<TSource,TSource,TSource>>)
Aggregate<TSource>(IQueryable<TSource>, Expression<Func<TSource,TSource,TSource>>)
All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
Any<TSource>(IQueryable<TSource>)
Any<TSource>(IQueryable<TSource>)
Any<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
Any<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
Append<TSource>(IQueryable<TSource>, TSource)
Append<TSource>(IQueryable<TSource>, TSource)
AsQueryable(IEnumerable)
AsQueryable(IEnumerable)
Converte um IEnumerable em um IQueryable.
AsQueryable<TElement>(IEnumerable<TElement>)
Converte um IEnumerable<T> genérico em um IQueryable<T> genérico.
Average(IQueryable<Single>)
Average(IQueryable<Single>)
Average(IQueryable<Nullable<Single>>)
Average(IQueryable<Nullable<Int64>>)
Average(IQueryable<Nullable<Double>>)
Average(IQueryable<Int64>)
Average(IQueryable<Double>)
Average(IQueryable<Double>)
Average(IQueryable<Decimal>)
Average(IQueryable<Decimal>)
Average(IQueryable<Nullable<Decimal>>)
Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Single>>)
Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Single>>)
Calcula a média de uma sequência de valores Single obtida invocando uma função de projeção em cada elemento
Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Single>>>)
Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Single>>>)
Calcula a média de uma sequência de valores Single anuláveis obtida invocando uma função de projeção em cada
Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int64>>>)
Calcula a média de uma sequência de valores Int64 anuláveis obtida invocando uma função de projeção em cada
Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Double>>>)
Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Double>>>)
Calcula a média de uma sequência de valores Double anuláveis obtida invocando uma função de projeção em
Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int64>>)
Calcula a média de uma sequência de valores Int64 obtida invocando uma função de projeção em cada elemento
Calcula a média de uma sequência de valores Int32 obtida invocando uma função de projeção em cada elemento
Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Double>>)
Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Double>>)
Calcula a média de uma sequência de valores Double obtida invocando uma função de projeção em cada
Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Decimal>>)
Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Decimal>>)
Calcula a média de uma sequência de valores Decimal obtida invocando uma função de projeção em cada
Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Decimal>>>)
Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Decimal>>>)
Calcula a média de uma sequência de valores Decimal anuláveis obtida invocando uma função de projeção em
Cast<TResult>(IQueryable)
Cast<TResult>(IQueryable)
Converte os elementos de um IQueryable para o tipo especificado.
Concat<TSource>(IQueryable<TSource>, IEnumerable<TSource>)
Concat<TSource>(IQueryable<TSource>, IEnumerable<TSource>)
Contains<TSource>(IQueryable<TSource>, TSource, IEqualityComparer<TSource>)

Contains<TSource>(IQueryable<TSource>, TSource, IEqualityComparer<TSource>)
Contains<TSource>(IQueryable<TSource>, TSource)
Count<TSource>(IQueryable<TSource>)
Count<TSource>(IQueryable<TSource>)
Count<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
Count<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
Retorna o número de elementos na sequência especificada que atendem a uma condição.
DefaultIfEmpty<TSource>(IQueryable<TSource>)
DefaultIfEmpty<TSource>(IQueryable<TSource>, TSource)
Retorna os elementos da sequência especificada ou o valor especificado em uma coleção de singletons se a

sequência está vazia.
Distinct<TSource>(IQueryable<TSource>)
Distinct<TSource>(IQueryable<TSource>)
Retorna os elementos distintos de uma sequência usando o comparador de igualdade padrão para comparar
valores.
Distinct<TSource>(IQueryable<TSource>, IEqualityComparer<TSource>)
Distinct<TSource>(IQueryable<TSource>, IEqualityComparer<TSource>)
valores.
ElementAt<TSource>(IQueryable<TSource>, Int32)
ElementAt<TSource>(IQueryable<TSource>, Int32)
ElementAtOrDefault<TSource>(IQueryable<TSource>, Int32)
ElementAtOrDefault<TSource>(IQueryable<TSource>, Int32)
intervalo.
Except<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Except<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
Produz a diferença de conjunto de duas sequências usando o IEqualityComparer<T> especificado para comparar
os valores.
Except<TSource>(IQueryable<TSource>, IEnumerable<TSource>)
valores.
First<TSource>(IQueryable<TSource>)
First<TSource>(IQueryable<TSource>)
First<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
First<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
Retorna o primeiro elemento de uma sequência que satisfaz uma condição especificada.
FirstOrDefault<TSource>(IQueryable<TSource>)
FirstOrDefault<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
FirstOrDefault<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
Retorna o primeiro elemento de uma sequência que atende a uma condição especificada ou um valor padrão se
esse elemento não é encontrado.
GroupBy<TSource,TKey,TElement,TResult>(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
Expression<Func<TSource,TElement>>, Expression<Func<TKey,IEnumerable<TElement>,TResult>>,
valor de resultado de cada grupo e sua chave. As chaves são comparadas usando um comparador especificado e
os elementos de cada grupo são projetados usando uma função especificada.
Expression<Func<TSource,TElement>>, Expression<Func<TKey,IEnumerable<TElement>,TResult>>)
Expression<Func<TSource,TElement>>, Expression<Func<TKey,IEnumerable<TElement>,TResult>>)
valor de resultado de cada grupo e sua chave. Os elementos de cada grupo são projetados usando uma função
especificada.
GroupBy<TSource,TKey,TElement>(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
Expression<Func<TSource,TElement>>)
Expression<Func<TSource,TElement>>, IEqualityComparer<TKey>)
Expression<Func<TSource,TElement>>, IEqualityComparer<TKey>)
Agrupa os elementos de uma sequência e projeta os elementos para cada grupo usando uma função especificada.
Os valores de chave são comparados usando um comparador especificado.
GroupBy<TSource,TKey,TResult>(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
Expression<Func<TKey,IEnumerable<TSource>,TResult>>)
Expression<Func<TKey,IEnumerable<TSource>,TResult>>, IEqualityComparer<TKey>)
Expression<Func<TKey,IEnumerable<TSource>,TResult>>, IEqualityComparer<TKey>)
valor de resultado de cada grupo e sua chave. As chaves são comparadas usando um comparador especificado.
GroupBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, IEqualityComparer<TKey>)

GroupBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, IEqualityComparer<TKey>)
GroupBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>)
GroupBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>)
GroupJoin<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>, IEnumerable<TInner>,
Expression<Func<TOuter,TKey>>, Expression<Func<TInner,TKey>>,
Expression<Func<TOuter,IEnumerable<TInner>,TResult>>)
Expression<Func<TOuter,IEnumerable<TInner>,TResult>>, IEqualityComparer<TKey>)
Expression<Func<TOuter,IEnumerable<TInner>,TResult>>, IEqualityComparer<TKey>)
Intersect<TSource>(IQueryable<TSource>, IEnumerable<TSource>)
Intersect<TSource>(IQueryable<TSource>, IEnumerable<TSource>)
valores.
Intersect<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Intersect<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
Produz a interseção de conjunto de duas sequências usando o IEqualityComparer<T> especificado para comparar
os valores.
Join<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>, IEnumerable<TInner>,
Expression<Func<TOuter,TKey>>, Expression<Func<TInner,TKey>>, Expression<Func<TOuter,TInner,TResult>>)
Correlaciona os elementos de duas sequências com base em chaves de correspondência. O comparador de

igualdade padrão é usado para comparar chaves.
Expression<Func<TOuter,TKey>>, Expression<Func<TInner,TKey>>, Expression<Func<TOuter,TInner,TResult>>,
Correlaciona os elementos de duas sequências com base em chaves de correspondência. Um

Last<TSource>(IQueryable<TSource>)
Last<TSource>(IQueryable<TSource>)
Retorna o último elemento em uma sequência.
Last<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
Last<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
LastOrDefault<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
LastOrDefault<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
LastOrDefault<TSource>(IQueryable<TSource>)
LongCount<TSource>(IQueryable<TSource>)
LongCount<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
LongCount<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
Retorna um Int64 que representa o número de elementos em uma sequência que atendem a uma condição.
Max<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,TResult>>)
Max<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,TResult>>)
Invoca uma função de projeção em cada elemento de um IQueryable<T> genérico e retorna o valor resultante
máximo.
Max<TSource>(IQueryable<TSource>)
Max<TSource>(IQueryable<TSource>)
Retorna o valor máximo em um IQueryable<T> genérico.
Min<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,TResult>>)
Min<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,TResult>>)
mínimo.
Min<TSource>(IQueryable<TSource>)
Min<TSource>(IQueryable<TSource>)
Retorna o valor mínimo de um IQueryable<T> genérico.
OfType<TResult>(IQueryable)
OfType<TResult>(IQueryable)
Filtra os elementos de um IQueryable com base em um tipo especificado.

OrderBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, IComparer<TKey>)
OrderBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, IComparer<TKey>)
OrderBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>)
OrderBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>)
OrderByDescending<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>)
OrderByDescending<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>)
OrderByDescending<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, IComparer<TKey>)

Prepend<TSource>(IQueryable<TSource>, TSource)
Prepend<TSource>(IQueryable<TSource>, TSource)
Reverse<TSource>(IQueryable<TSource>)
Reverse<TSource>(IQueryable<TSource>)
Select<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,TResult>>)
Select<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,TResult>>)
Select<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,TResult>>)
Select<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,TResult>>)
SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>,
Expression<Func<TSource,Int32,IEnumerable<TCollection>>>,
Expression<Func<TSource,TCollection,TResult>>)
Projeta cada elemento de uma sequência em um IEnumerable<T> que incorpora o índice do elemento de origem
que o produziu. Uma função seletora de resultados é invocada em cada elemento de cada sequência intermediária
e os valores resultantes são combinados em uma única sequência unidimensional e retornados.
Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>)
Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>)
Projeta cada elemento de uma sequência em um IEnumerable<T> e invoca uma função de seletor de resultado
em cada elemento contido nele. Os valores resultantes de cada sequência intermediária são combinados em uma
única sequência unidimensional e retornada.
SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>)
SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>)
Projeta cada elemento de uma sequência em um IEnumerable<T> e combina as sequências resultantes em uma
SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>)
SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>)
sequência.
SequenceEqual<TSource>(IQueryable<TSource>, IEnumerable<TSource>)
SequenceEqual<TSource>(IQueryable<TSource>, IEnumerable<TSource>)
Determina se duas sequências são iguais usando o comparador de igualdade padrão para comparar elementos.
SequenceEqual<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

SequenceEqual<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
Determina se duas sequências são iguais usando um IEqualityComparer<T> especificado para comparar
elementos.
Single<TSource>(IQueryable<TSource>)
Single<TSource>(IQueryable<TSource>)
sequência.
Single<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
Single<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
SingleOrDefault<TSource>(IQueryable<TSource>)
SingleOrDefault<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
SingleOrDefault<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
Skip<TSource>(IQueryable<TSource>, Int32)
Skip<TSource>(IQueryable<TSource>, Int32)
SkipLast<TSource>(IQueryable<TSource>, Int32)
SkipLast<TSource>(IQueryable<TSource>, Int32)
SkipWhile<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
SkipWhile<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
SkipWhile<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32,Boolean>>)
SkipWhile<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32,Boolean>>)
Sum(IQueryable<Single>)
Sum(IQueryable<Single>)
Sum(IQueryable<Nullable<Single>>)
Sum(IQueryable<Nullable<Int64>>)
Sum(IQueryable<Nullable<Double>>)
Sum(IQueryable<Double>)
Sum(IQueryable<Double>)
Sum(IQueryable<Int64>)
Sum(IQueryable<Nullable<Decimal>>)
Sum(IQueryable<Decimal>)
Sum(IQueryable<Decimal>)
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Single>>>)
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Single>>>)
Calcula a soma da sequência de valores Single anuláveis obtida invocando uma função de projeção em cada
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int64>>>)
Calcula a soma da sequência de valores Int64 anuláveis obtida invocando uma função de projeção em cada
Calcula a soma da sequência de valores Int32 anuláveis obtida invocando uma função de projeção em cada
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Double>>>)
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Double>>>)
Calcula a soma da sequência de valores Double anuláveis obtida invocando uma função de projeção em cada
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Single>>)
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Single>>)
Calcula a soma da sequência de valores Single que é obtida invocando uma função de projeção em cada elemento
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int64>>)
Calcula a soma da sequência de valores Int64 que é obtida invocando uma função de projeção em cada elemento
Calcula a soma da sequência de valores Int32 que é obtida invocando uma função de projeção em cada elemento
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Double>>)
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Double>>)
Calcula a soma da sequência de valores Double que é obtida invocando uma função de projeção em cada
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Decimal>>)
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Decimal>>)
Calcula a soma da sequência de valores Decimal que é obtida invocando uma função de projeção em cada
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Decimal>>>)
Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Decimal>>>)
Calcula a soma da sequência de valores Decimal anuláveis obtida invocando uma função de projeção em cada
Take<TSource>(IQueryable<TSource>, Int32)
Take<TSource>(IQueryable<TSource>, Int32)
TakeLast<TSource>(IQueryable<TSource>, Int32)
TakeLast<TSource>(IQueryable<TSource>, Int32)
TakeWhile<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32,Boolean>>)
TakeWhile<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32,Boolean>>)
TakeWhile<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
TakeWhile<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
ThenBy<TSource,TKey>(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>)
ThenBy<TSource,TKey>(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>)
Executa uma ordenação posterior dos elementos em uma sequência em ordem crescente de acordo com uma
chave.
ThenBy<TSource,TKey>(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>, IComparer<TKey>)

ThenBy<TSource,TKey>(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>, IComparer<TKey>)
especificado.
ThenByDescending<TSource,TKey>(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>)
ThenByDescending<TSource,TKey>(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>)
chave.
ThenByDescending<TSource,TKey>(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>,
IComparer<TKey>)
ThenByDescending<TSource,TKey>(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>,
IComparer<TKey>)
Executa uma ordenação posterior dos elementos em uma sequência em ordem decrescente usando um
Union<TSource>(IQueryable<TSource>, IEnumerable<TSource>)
Union<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Union<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
Where<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32,Boolean>>)
Where<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32,Boolean>>)
Filtra uma sequência de valores com base em um predicado. O índice de cada elemento é usado na lógica da
Where<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
Where<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
Zip<TFirst,TSecond,TResult>(IQueryable<TFirst>, IEnumerable<TSecond>,
Expression<Func<TFirst,TSecond,TResult>>)
Zip<TFirst,TSecond,TResult>(IQueryable<TFirst>, IEnumerable<TSecond>,
Expression<Func<TFirst,TSecond,TResult>>)
Mescla duas sequências usando a função de predicado especificada.
See Also
Queryable.Aggregate Queryable.Aggregate
I n this Article
Overloads
Aggregate<TSource,TAccumulate,TResult>(IQueryable<
TSource>, TAccumulate, Expression<Func<TAccumulate, Aplica uma função de acumulador a uma sequência. O valor
TSource,TAccumulate>>, Expression<Func<TAccumulate, de semente especificado é usado como o valor inicial do
TResult>>) Aggregate<TSource,TAccumulate,TResult>( acumulador e a função especificada é usada para selecionar o
IQueryable<TSource>, TAccumulate, Expression<Func< valor do resultado.
TAccumulate,TSource,TAccumulate>>, Expression<Func<
TAccumulate,TResult>>)
Aggregate<TSource,TAccumulate>(IQueryable<TSource>,
TAccumulate, Expression<Func<TAccumulate,TSource, Aplica uma função de acumulador a uma sequência. O valor
TAccumulate>>) Aggregate<TSource,TAccumulate>( de semente especificado é usado como o valor inicial do
IQueryable<TSource>, TAccumulate, Expression<Func< acumulador.
TAccumulate,TSource,TAccumulate>>)
Aggregate<TSource>(IQueryable<TSource>, Expression<
Func<TSource,TSource,TSource>>) Aggregate<TSource>( Aplica uma função de acumulador a uma sequência.
IQueryable<TSource>, Expression<Func<TSource,TSource,
TSource>>)
Aggregate<TSource,TAccumulate,TResult>(IQueryable<TSource>,
TAccumulate,
Expression<Func<TAccumulate,TSource,TAccumulate>>,
Expression<Func<TAccumulate,TResult>>)
Aggregate<TSource,TAccumulate,TResult>(IQueryable<TSource>,
TAccumulate,
Expression<Func<TAccumulate,TSource,TAccumulate>>,
Expression<Func<TAccumulate,TResult>>)
acumulador e a função especificada é usada para selecionar o valor do resultado.
public static TResult Aggregate<TSource,TAccumulate,TResult> (this System.Linq.IQueryable<TSource>
source, TAccumulate seed, System.Linq.Expressions.Expression<Func<TAccumulate,TSource,TAccumulate>>
func, System.Linq.Expressions.Expression<Func<TAccumulate,TResult>> selector);
static member Aggregate : System.Linq.IQueryable<'Source> * 'Accumulate *
System.Linq.Expressions.Expression<Func<'Accumulate, 'Source, 'Accumulate>> *
System.Linq.Expressions.Expression<Func<'Accumulate, 'Result>> -> 'Result
Type Parameters
TSource
TAccumulate
TResult
Parameters
source IQueryable<TSource>
func Expression<Func<TAccumulate,TSource,TAccumulate>>
selector Expression<Func<TAccumulate,TResult>>
Returns
TResult TResult
Exceptions
source , func ou selector é null .
Examples
O exemplo de código a seguir demonstra como usar Aggregate<TSource,TAccumulate,TResult>
(IQueryable<TSource>, TAccumulate, Expression<Func<TAccumulate,TSource,TAccumulate>>,
Expression<Func<TAccumulate,TResult>>) para aplicar uma função de acumulador e um seletor de resultado.
string[] fruits = { "apple", "mango", "orange", "passionfruit", "grape" };
// Determine whether any string in the array is longer than "banana".

string longestName =
fruits.AsQueryable().Aggregate(
"banana",
(longest, next) => next.Length > longest.Length ? next : longest,
// Return the final result as an uppercase string.
fruit => fruit.ToUpper()
);
Console.WriteLine(
"The fruit with the longest name is {0}.",
longestName);

//
// The fruit with the longest name is PASSIONFRUIT.
Remarks
Esse método tem pelo menos um parâmetro do tipo Expression<TDelegate> cujo argumento de tipo é um do
Func<T,TResult> tipos. Para esses parâmetros, você pode passar em uma expressão lambda e ele será compilado em
um Expression<TDelegate>.
O Aggregate<TSource,TAccumulate,TResult>(IQueryable<TSource>, TAccumulate,
Expression<Func<TAccumulate,TSource,TAccumulate>>, Expression<Func<TAccumulate,TResult>>) método gera
uma MethodCallExpression que representa a chamada Aggregate<TSource,TAccumulate,TResult>
(IQueryable<TSource>, TAccumulate, Expression<Func<TAccumulate,TSource,TAccumulate>>,
Expression<Func<TAccumulate,TResult>>) a próprio como um método genérico construído. Em seguida, ele passa a
MethodCallExpression para o Execute<TResult>(Expression) método da IQueryProvider representado pela Provider
propriedade do source parâmetro.
O comportamento de consulta que ocorre como resultado da execução de uma árvore de expressão que representa a
chamada Aggregate<TSource,TAccumulate,TResult>(IQueryable<TSource>, TAccumulate,
Expression<Func<TAccumulate,TSource,TAccumulate>>, Expression<Func<TAccumulate,TResult>>) depende da
implementação do tipo do source parâmetro. O comportamento esperado é que a função especificada, func , é
aplicada a cada valor na sequência de origem e o acumulado valor é retornado. O seed parâmetro é usado como o
valor de semente para o valor acumulado, que corresponde ao primeiro parâmetro no func . O valor acumulado final é
passado para selector para obter o valor do resultado.
Para simplificar operações comuns de agregação, o conjunto de operadores de consulta padrão também inclui dois
métodos de contagem Count e LongCounte quatro métodos de agregação numéricas, ou seja, Max, Min, Sume
Average.
TAccumulate,
TAccumulate,
acumulador.
public static TAccumulate Aggregate<TSource,TAccumulate> (this System.Linq.IQueryable<TSource>

source, TAccumulate seed, System.Linq.Expressions.Expression<Func<TAccumulate,TSource,TAccumulate>>
func);
static member Aggregate : System.Linq.IQueryable<'Source> * 'Accumulate *
System.Linq.Expressions.Expression<Func<'Accumulate, 'Source, 'Accumulate>> -> 'Accumulate
Type Parameters
TSource
TAccumulate
Parameters
func Expression<Func<TAccumulate,TSource,TAccumulate>>
Returns
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Aggregate<TSource,TAccumulate>(IQueryable<TSource>,
TAccumulate, Expression<Func<TAccumulate,TSource,TAccumulate>>) para aplicar uma função de acumulador
quando um valor de semente é fornecido para a função.
int[] ints = { 4, 8, 8, 3, 9, 0, 7, 8, 2 };
// Count the even numbers in the array, using a seed value of 0.

int numEven =
ints.AsQueryable().Aggregate(
0,
(total, next) => next % 2 == 0 ? total + 1 : total
);
Console.WriteLine("The number of even integers is: {0}", numEven);

//
// The number of even integers is: 6
Remarks
O Aggregate<TSource,TAccumulate>(IQueryable<TSource>, TAccumulate,
Expression<Func<TAccumulate,TSource,TAccumulate>>) método gera uma MethodCallExpression que representa a
chamada Aggregate<TSource,TAccumulate>(IQueryable<TSource>, TAccumulate,
Expression<Func<TAccumulate,TSource,TAccumulate>>) a próprio como um método genérico construído. Em
seguida, ele passa a MethodCallExpression para o Execute<TResult>(Expression) método da IQueryProvider
representado pela Provider propriedade do source parâmetro.
chamada Aggregate<TSource,TAccumulate>(IQueryable<TSource>, TAccumulate,
Expression<Func<TAccumulate,TSource,TAccumulate>>) depende da implementação do tipo do source parâmetro.
O comportamento esperado é que a função especificada, func , é aplicada a cada valor na sequência de origem e o
acumulado valor é retornado. O seed parâmetro é usado como o valor de semente para o valor acumulado, que
corresponde ao primeiro parâmetro no func .
Average.
Aggregate<TSource>(IQueryable<TSource>,
Expression<Func<TSource,TSource,TSource>>)
Aggregate<TSource>(IQueryable<TSource>,
Expression<Func<TSource,TSource,TSource>>)
public static TSource Aggregate<TSource> (this System.Linq.IQueryable<TSource> source,

System.Linq.Expressions.Expression<Func<TSource,TSource,TSource>> func);
static member Aggregate : System.Linq.IQueryable<'Source> *
System.Linq.Expressions.Expression<Func<'Source, 'Source, 'Source>> -> 'Source
Type Parameters
TSource
Parameters
func Expression<Func<TSource,TSource,TSource>>
Uma função do acumulador a ser aplicada a cada elemento.
Returns
TSource TSource
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Aggregate<TSource>(IQueryable<TSource>,
Expression<Func<TSource,TSource,TSource>>) para criar uma frase de uma matriz de cadeias de caracteres.
string sentence = "the quick brown fox jumps over the lazy dog";
// Split the string into individual words.

string[] words = sentence.Split(' ');
// Use Aggregate() to prepend each word to the beginning of the

// new sentence to reverse the word order.
string reversed =
words.AsQueryable().Aggregate(
(workingSentence, next) => next + " " + workingSentence
);
Console.WriteLine(reversed);

//
// dog lazy the over jumps fox brown quick the
Remarks
O Aggregate<TSource>(IQueryable<TSource>, Expression<Func<TSource,TSource,TSource>>) método gera uma
MethodCallExpression que representa a chamada Aggregate<TSource>(IQueryable<TSource>,
Expression<Func<TSource,TSource,TSource>>) a próprio como um método genérico construído. Em seguida, ele
passa a MethodCallExpression para o Execute<TResult>(Expression) método da IQueryProvider representado pela
Provider propriedade do source parâmetro.
chamada Aggregate<TSource>(IQueryable<TSource>, Expression<Func<TSource,TSource,TSource>>) depende da
implementação do tipo do source parâmetro. O comportamento esperado é que a função especificada, func , é
aplicada a cada valor na sequência de origem e o acumulado valor é retornado. O primeiro valor em source é usado
como o valor de semente para o valor acumulado, que corresponde ao primeiro parâmetro no func .
Average.
Queryable.All Queryable.All
I n this Article
public static bool All<TSource> (this System.Linq.IQueryable<TSource> source,
System.Linq.Expressions.Expression<Func<TSource,bool>> predicate);
static member All : System.Linq.IQueryable<'Source> *
System.Linq.Expressions.Expression<Func<'Source, bool>> -> bool
Type Parameters
TSource
Parameters
A sequência cujos elementos testar quanto a uma condição.
predicate Expression<Func<TSource,Boolean>>
Returns
Boolean Boolean
for vazia; caso contrário, false .
Exceptions
Examples
O exemplo de código a seguir demonstra como usar All<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) para determinar se todos os elementos em uma sequência satisfazem uma
condição.
class Pet
{
}

{
// Determine whether all pet names in the array start with 'B'.
bool allStartWithB =
pets.AsQueryable().All(pet => pet.Name.StartsWith("B"));
Console.WriteLine(
"{0} pet names start with 'B'.",
allStartWithB ? "All" : "Not all");
}

//
// Not all pet names start with 'B'.
O valor booleano que o All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) método

retorna, normalmente é usada no predicado de um where cláusula ( Where cláusula no Visual Basic) ou uma chamada
direta para o Where método. O exemplo a seguir demonstra o uso do All método.
class Pet
{
}
class Person
{
}

{
Pets = new Pet[] { new Pet { Name = "Belle", Age = 8} }},
};
// Determine which people have pets that are all older than 5.
where person.Pets.AsQueryable().All(pet => pet.Age > 5)


*
* Haas
* Antebi
*/
}
Remarks
O All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) método gera uma
MethodCallExpression que representa a chamada All<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) depende da implementação
do source tipo do parâmetro. O comportamento esperado é que ele determina se todos os elementos na source
atendem à condição em predicate .
Queryable.Any Queryable.Any
I n this Article
Overloads
Any<TSource>(IQueryable<TSource>) Any<TSource>(
IQueryable<TSource>) Determina se uma sequência contém elementos.
Any<TSource>(IQueryable<TSource>, Expression<Func<
TSource,Boolean>>) Any<TSource>(IQueryable<TSource>, Determina se algum elemento de uma sequência atende a
Expression<Func<TSource,Boolean>>) uma condição.
Any<TSource>(IQueryable<TSource>) Any<TSource>
(IQueryable<TSource>)
public static bool Any<TSource> (this System.Linq.IQueryable<TSource> source);
static member Any : System.Linq.IQueryable<'Source> -> bool
Type Parameters
TSource
Parameters
Uma sequência para verificar se está vazia.
Returns
Boolean Boolean
true se a sequência de origem contiver elementos; caso contrário, false .
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Any<TSource>(IQueryable<TSource>) para determinar se uma
sequência contém elementos.
List<int> numbers = new List<int> { 1, 2 };
// Determine if the list contains any elements.

bool hasElements = numbers.AsQueryable().Any();
Console.WriteLine("The list {0} empty.",

hasElements ? "is not" : "is");

//
// The list is not empty.
O valor booleano que o Any<TSource>(IQueryable<TSource>) método retorna, normalmente é usada no predicado

de um where cláusula ( Where cláusula no Visual Basic) ou uma chamada direta para o Where<TSource>
(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) método. O exemplo a seguir demonstra o uso do Any
método.
class Pet
{
}
class Person
{
}

{
Pets = new Pet[] { }},
};
// Determine which people have a non-empty Pet array.

where person.Pets.AsQueryable().Any()

Haas
Fakhouri
Philips
*/
}
Remarks
O Any<TSource>(IQueryable<TSource>) método gera uma MethodCallExpression que representa a chamada
Any<TSource>(IQueryable<TSource>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Any<TSource>(IQueryable<TSource>) depende da implementação do tipo do source parâmetro. O
comportamento esperado é que ele determina se source contiver elementos.
Any<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) Any<TSource>
(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)
public static bool Any<TSource> (this System.Linq.IQueryable<TSource> source,
static member Any : System.Linq.IQueryable<'Source> *
System.Linq.Expressions.Expression<Func<'Source, bool>> -> bool
Type Parameters
TSource
Parameters
A sequência cujos elementos testar quanto a uma condição.
Returns
Boolean Boolean
true se algum elemento na sequência de origem for aprovado no teste do predicado especificado; caso contrário,
false .
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Any<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) para determinar se qualquer elemento em uma sequência satisfazem uma
condição.
class Pet
{
}

{
// Create an array of Pet objects.
Pet[] pets =
{ new Pet { Name="Barley", Age=8, Vaccinated=true },
new Pet { Name="Boots", Age=4, Vaccinated=false },
new Pet { Name="Whiskers", Age=1, Vaccinated=false } };
// Determine whether any pets over age 1 are also unvaccinated.

bool unvaccinated =
pets.AsQueryable().Any(p => p.Age > 1 && p.Vaccinated == false);
Console.WriteLine(
"There {0} unvaccinated animals over age one.",
unvaccinated ? "are" : "are not any");
}

//
// There are unvaccinated animals over age one.
Remarks
O Any<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) método gera uma
MethodCallExpression que representa a chamada Any<TSource>(IQueryable<TSource>,
chamada Any<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) depende da implementação
do tipo do source parâmetro. O comportamento esperado é que ele determina se qualquer um dos elementos da
source satisfazem a condição especificada pelo predicate .
Queryable.Append Queryable.Append
I n this Article
public static System.Linq.IQueryable<TSource> Append<TSource> (this System.Linq.IQueryable<TSource>
source, TSource element);
static member Append : System.Linq.IQueryable<'Source> * 'Source -> System.Linq.IQueryable<'Source>
Type Parameters
TSource
Parameters
Returns
IQueryable<TSource>
Queryable.AsQueryable Queryable.AsQueryable
I n this Article
Overloads
AsQueryable(IEnumerable) AsQueryable(IEnumerable)
AsQueryable<TElement>(IEnumerable<TElement>) As
Queryable<TElement>(IEnumerable<TElement>) Converte um IEnumerable<T> genérico em um
IQueryable<T> genérico.
AsQueryable(IEnumerable) AsQueryable(IEnumerable)
public static System.Linq.IQueryable AsQueryable (this System.Collections.IEnumerable source);
static member AsQueryable : System.Collections.IEnumerable -> System.Linq.IQueryable
Parameters
Uma sequência a ser convertida.
Returns
IQueryable IQueryable
Um IQueryable que representa a sequência de entrada.
Exceptions
source não implementa IEnumerable<T> para alguns T .
source é null .
Remarks
Se o tipo de source implementa IQueryable<T>, AsQueryable(IEnumerable) retorna-a diretamente. Caso contrário,
retornará um IQueryable<T> que executa consultas chamando métodos de operador de consulta equivalente
Enumerable em vez no Queryable.
Este método presume que source implementa IEnumerable<T> para alguns T . Em tempo de execução, o resultado é
do tipo IQueryable<T> para o mesmo T . Esse método é útil em cenários dinâmicos quando você não souber o tipo de
estaticamente T .
Converte um IEnumerable<T> genérico em um IQueryable<T> genérico.
public static System.Linq.IQueryable<TElement> AsQueryable<TElement> (this
System.Collections.Generic.IEnumerable<TElement> source);
static member AsQueryable : seq<'Element> -> System.Linq.IQueryable<'Element>
Type Parameters
TElement
Parameters
source IEnumerable<TElement>
Uma sequência a ser convertida.
Returns
IQueryable<TElement>
Um IQueryable<T> que representa a sequência de entrada.
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar AsQueryable<TElement>(IEnumerable<TElement>) para
converter um IEnumerable<T> para um IQueryable<T>.
// Convert the List to an IQueryable<int>.

IQueryable<int> iqueryable = grades.AsQueryable();
// Get the Expression property of the IQueryable object.

System.Linq.Expressions.Expression expressionTree =
iqueryable.Expression;
Console.WriteLine("The NodeType of the expression tree is: "

+ expressionTree.NodeType.ToString());
Console.WriteLine("The Type of the expression tree is: "
+ expressionTree.Type.Name);
/*
The NodeType of the expression tree is: Constant

The Type of the expression tree is: EnumerableQuery`1
*/
Remarks
Se o tipo de source implementa IQueryable<T>, AsQueryable<TElement>(IEnumerable<TElement>) retorna-a
diretamente. Caso contrário, retornará um IQueryable<T> que executa consultas chamando métodos de operador de
consulta equivalente Enumerable em vez no Queryable.
Queryable.Average Queryable.Average
I n this Article
Overloads
Average(IQueryable<Single>) Average(IQueryable<Single>)
Average(IQueryable<Nullable<Single>>) Average(
IQueryable<Nullable<Single>>) Computa a média de uma sequência de valores Single que
Average(IQueryable<Nullable<Int64>>) Average(IQueryable<
Nullable<Int64>>) Computa a média de uma sequência de valores Int64 que
Average(IQueryable<Nullable<Double>>) Average(
IQueryable<Nullable<Double>>) Computa a média de uma sequência de valores Double que
Average(IQueryable<Nullable<Int32>>) Average(IQueryable<
Nullable<Int32>>) Computa a média de uma sequência de valores Int32 que
Average(IQueryable<Int64>) Average(IQueryable<Int64>)
Average(IQueryable<Double>) Average(IQueryable<Double>)
Average(IQueryable<Decimal>) Average(IQueryable<
Decimal>) Computa a média de uma sequência de valores Decimal.
Average(IQueryable<Nullable<Decimal>>) Average(
IQueryable<Nullable<Decimal>>) Computa a média de uma sequência de valores Decimal que
Average<TSource>(IQueryable<TSource>, Expression<Func<
TSource,Single>>) Average<TSource>(IQueryable<TSource>, Calcula a média de uma sequência de valores Single obtida
Expression<Func<TSource,Single>>) invocando uma função de projeção em cada elemento da
sequência de entrada.
TSource,Nullable<Single>>>) Average<TSource>(IQueryable< Calcula a média de uma sequência de valores Single anuláveis
TSource>, Expression<Func<TSource,Nullable<Single>>>) obtida invocando uma função de projeção em cada elemento
TSource,Nullable<Int64>>>) Average<TSource>(IQueryable< Calcula a média de uma sequência de valores Int64 anuláveis
TSource>, Expression<Func<TSource,Nullable<Int64>>>) obtida invocando uma função de projeção em cada elemento
TSource,Nullable<Int32>>>) Average<TSource>(IQueryable< Calcula a média de uma sequência de valores Int32 anuláveis
TSource>, Expression<Func<TSource,Nullable<Int32>>>) obtida invocando uma função de projeção em cada elemento
TSource,Nullable<Double>>>) Average<TSource>( Calcula a média de uma sequência de valores Double anuláveis
IQueryable<TSource>, Expression<Func<TSource,Nullable< obtida invocando uma função de projeção em cada elemento
Double>>>) da sequência de entrada.
TSource,Int64>>) Average<TSource>(IQueryable<TSource>, Calcula a média de uma sequência de valores Int64 obtida
Expression<Func<TSource,Int64>>) invocando uma função de projeção em cada elemento da
TSource,Int32>>) Average<TSource>(IQueryable<TSource>, Calcula a média de uma sequência de valores Int32 obtida
TSource,Double>>) Average<TSource>(IQueryable<TSource>, Calcula a média de uma sequência de valores Double obtida
Expression<Func<TSource,Double>>) invocando uma função de projeção em cada elemento da
TSource,Decimal>>) Average<TSource>(IQueryable< Calcula a média de uma sequência de valores Decimal obtida
TSource>, Expression<Func<TSource,Decimal>>) invocando uma função de projeção em cada elemento da
TSource,Nullable<Decimal>>>) Average<TSource>( Calcula a média de uma sequência de valores Decimal
IQueryable<TSource>, Expression<Func<TSource,Nullable< anuláveis obtida invocando uma função de projeção em cada
Decimal>>>) elemento da sequência de entrada.
Average(IQueryable<Single>) Average(IQueryable<Single>)
public static float Average (this System.Linq.IQueryable<float> source);

static member Average : System.Linq.IQueryable<single> -> single
Parameters
source IQueryable<Single>
Uma sequência de valores Single para realizar o cálculo da média.
Returns
Single Single
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Average(IQueryable<Int32>) para calcular a média de uma
Note
double average = grades.AsQueryable().Average();

//
Remarks
O Average(IQueryable<Single>) método gera uma MethodCallExpression que representa a chamada
Average(IQueryable<Single>) em si. Em seguida, ele passa a MethodCallExpression para o Execute<TResult>
(Expression) método da IQueryProvider representado pela Provider propriedade do source parâmetro.
chamada Average(IQueryable<Single>) depende da implementação do tipo do source parâmetro. O comportamento
esperado é que ele calcula a média dos valores em source .
public static Nullable<float> Average (this System.Linq.IQueryable<Nullable<float>> source);

static member Average : System.Linq.IQueryable<Nullable<single>> -> Nullable<single>
Parameters
source IQueryable<Nullable<Single>>
Uma sequência de valores Single que permitem valores nulos para cálculo da média.
Returns
Nullable<Single>
A média da sequência de valores ou null , se a sequência de origem estiver vazia ou contiver somente valores null .
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Average(IQueryable<Nullable<Int64>>) para calcular a média de
uma sequência de valores.
Note
double? average = longs.AsQueryable().Average();

//
// The average is 133282081426.333.
Remarks
O Average(IQueryable<Nullable<Single>>) método gera uma MethodCallExpression que representa a chamada
Average(IQueryable<Nullable<Single>>) em si. Em seguida, ele passa a MethodCallExpression para o
Execute<TResult>(Expression) método da IQueryProvider representado pela Provider propriedade do source
parâmetro.
chamada Average(IQueryable<Nullable<Single>>) depende da implementação do tipo do source parâmetro. O
comportamento esperado é que ele calcula a média dos valores em source .
public static Nullable<double> Average (this System.Linq.IQueryable<Nullable<long>> source);
static member Average : System.Linq.IQueryable<Nullable<int64>> -> Nullable<double>
Parameters
source IQueryable<Nullable<Int64>>
Returns
Nullable<Double>
Exceptions
source é null .
Examples

//
// The average is 133282081426.333.
Remarks
O Average(IQueryable<Nullable<Int64>>) método gera uma MethodCallExpression que representa a chamada
Average(IQueryable<Nullable<Int64>>) em si. Em seguida, ele passa a MethodCallExpression para o
parâmetro.
chamada Average(IQueryable<Nullable<Int64>>) depende da implementação do tipo do source parâmetro. O
public static Nullable<double> Average (this System.Linq.IQueryable<Nullable<double>> source);

static member Average : System.Linq.IQueryable<Nullable<double>> -> Nullable<double>
Parameters
source IQueryable<Nullable<Double>>
Uma sequência de valores Double que permitem valores nulos para cálculo da média.
Returns
Nullable<Double>
Exceptions
source é null .
Examples
Note

//
// The average is 133282081426.333.
Remarks
O Average(IQueryable<Nullable<Double>>) método gera uma MethodCallExpression que representa a chamada
Average(IQueryable<Nullable<Double>>) em si. Em seguida, ele passa a MethodCallExpression para o
parâmetro.
chamada Average(IQueryable<Nullable<Double>>) depende da implementação do tipo do source parâmetro. O
public static Nullable<double> Average (this System.Linq.IQueryable<Nullable<int>> source);

static member Average : System.Linq.IQueryable<Nullable<int>> -> Nullable<double>
Parameters
Returns
Nullable<Double>
Exceptions
source é null .
Examples
Note

//
// The average is 133282081426.333.
Remarks
O Average(IQueryable<Nullable<Int32>>) método gera uma MethodCallExpression que representa a chamada
Average(IQueryable<Nullable<Int32>>) em si. Em seguida, ele passa a MethodCallExpression para o
parâmetro.
chamada Average(IQueryable<Nullable<Int32>>) depende da implementação do tipo do source parâmetro. O
public static double Average (this System.Linq.IQueryable<long> source);

static member Average : System.Linq.IQueryable<int64> -> double
Parameters
source IQueryable<Int64>
Returns
Double Double
Exceptions
source é null .
Examples
Note

//
Remarks
O Average(IQueryable<Int64>) método gera uma MethodCallExpression que representa a chamada
Average(IQueryable<Int64>) em si. Em seguida, ele passa a MethodCallExpression para o Execute<TResult>
chamada Average(IQueryable<Int64>) depende da implementação do tipo do source parâmetro. O comportamento
public static double Average (this System.Linq.IQueryable<int> source);

static member Average : System.Linq.IQueryable<int> -> double
Parameters
Returns
Double Double
Exceptions
source é null .
Examples

//
Remarks
O Average(IQueryable<Int32>) método gera uma MethodCallExpression que representa a chamada
Average(IQueryable<Int32>) em si. Em seguida, ele passa a MethodCallExpression para o Execute<TResult>
chamada Average(IQueryable<Int32>) depende da implementação do tipo do source parâmetro. O comportamento
Average(IQueryable<Double>) Average(IQueryable<Double>)
public static double Average (this System.Linq.IQueryable<double> source);

static member Average : System.Linq.IQueryable<double> -> double
Parameters
source IQueryable<Double>
Uma sequência de valores Double para realizar o cálculo da média.
Returns
Double Double
Exceptions
source é null .
Examples
Note

//
Remarks
O Average(IQueryable<Double>) método gera uma MethodCallExpression que representa a chamada
Average(IQueryable<Double>) em si. Em seguida, ele passa a MethodCallExpression para o Execute<TResult>
chamada Average(IQueryable<Double>) depende da implementação do tipo do source parâmetro. O
Average(IQueryable<Decimal>) Average(IQueryable<Decimal>)
public static decimal Average (this System.Linq.IQueryable<decimal> source);

static member Average : System.Linq.IQueryable<decimal> -> decimal
Parameters
source IQueryable<Decimal>
Uma sequência de valores Decimal para realizar o cálculo da média.
Returns
Decimal Decimal
Exceptions
source é null .
Examples
Note

//
Remarks
O Average(IQueryable<Decimal>) método gera uma MethodCallExpression que representa a chamada
Average(IQueryable<Decimal>) em si. Em seguida, ele passa a MethodCallExpression para o Execute<TResult>
chamada Average(IQueryable<Decimal>) depende da implementação do tipo do source parâmetro. O
public static Nullable<decimal> Average (this System.Linq.IQueryable<Nullable<decimal>> source);

static member Average : System.Linq.IQueryable<Nullable<decimal>> -> Nullable<decimal>
Parameters
source IQueryable<Nullable<Decimal>>
Uma sequência de valores Decimal que permitem valores nulos para cálculo da média.
Returns
Nullable<Decimal>
Exceptions
source é null .
Examples
Note

//
// The average is 133282081426.333.
Remarks
O Average(IQueryable<Nullable<Decimal>>) método gera uma MethodCallExpression que representa a chamada
Average(IQueryable<Nullable<Decimal>>) em si. Em seguida, ele passa a MethodCallExpression para o
parâmetro.
chamada Average(IQueryable<Nullable<Decimal>>) depende da implementação do tipo do source parâmetro. O
Average<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Single>>) Average<TSource>
(IQueryable<TSource>, Expression<Func<TSource,Single>>)
Calcula a média de uma sequência de valores Single obtida invocando uma função de projeção em cada elemento da
public static float Average<TSource> (this System.Linq.IQueryable<TSource> source,

System.Linq.Expressions.Expression<Func<TSource,float>> selector);
static member Average : System.Linq.IQueryable<'Source> *
System.Linq.Expressions.Expression<Func<'Source, single>> -> single
Type Parameters
TSource
Parameters
selector Expression<Func<TSource,Single>>
Uma função de projeção a ser aplicada a cada elemento.
Returns
Single Single
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Average<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Int32>>) para calcular a média String comprimento em uma sequência de valores do tipo
String.
Note
// Determine the average string length in the array.

double average = fruits.AsQueryable().Average(s => s.Length);

//
Remarks
O Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Single>>) método gera uma
MethodCallExpression que representa a chamada Average<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Single>>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Single>>) depende da
implementação do tipo do source parâmetro. O comportamento esperado é que ele calcula a média dos valores em
source depois de invocar selector em cada valor.
Expression<Func<TSource,Nullable<Single>>>)
Calcula a média de uma sequência de valores Single anuláveis obtida invocando uma função de projeção em cada
public static Nullable<float> Average<TSource> (this System.Linq.IQueryable<TSource> source,
System.Linq.Expressions.Expression<Func<TSource,Nullable<float>>> selector);
System.Linq.Expressions.Expression<Func<'Source, Nullable<single>>> -> Nullable<single>
Type Parameters
TSource
Parameters
selector Expression<Func<TSource,Nullable<Single>>>
Returns
Nullable<Single>
A média da sequência de valores ou null se a sequência source estiver vazia ou contiver somente valores null .
Exceptions
Examples
String.
Note


//
Remarks
O Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Single>>>) método gera uma
Expression<Func<TSource,Nullable<Single>>>) a próprio como um método genérico construído. Em seguida, ele
passa a MethodCallExpression para o Execute<TResult>(Expression) método da IQueryProvider representado pelo
chamada Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Single>>>) depende da
Expression<Func<TSource,Nullable<Int64>>>)
public static Nullable<double> Average<TSource> (this System.Linq.IQueryable<TSource> source,

System.Linq.Expressions.Expression<Func<TSource,Nullable<long>>> selector);
System.Linq.Expressions.Expression<Func<'Source, Nullable<int64>>> -> Nullable<double>
Type Parameters
TSource
Parameters
selector Expression<Func<TSource,Nullable<Int64>>>
Returns
Nullable<Double>
Exceptions
Examples
String.
Note


//
Remarks
O Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int64>>>) método gera uma
Expression<Func<TSource,Nullable<Int64>>>) a próprio como um método genérico construído. Em seguida, ele
chamada Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int64>>>) depende da

System.Linq.Expressions.Expression<Func<TSource,Nullable<int>>> selector);
System.Linq.Expressions.Expression<Func<'Source, Nullable<int>>> -> Nullable<double>
Type Parameters
TSource
Parameters
Returns
Nullable<Double>
Exceptions
Examples
String.
Note


//
Remarks
O Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int32>>>) método gera uma
passa a MethodCallExpression para o Execute<TResult>(Expression) método da IQueryProvider representado pelo
chamada Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int32>>>) depende da
Expression<Func<TSource,Nullable<Double>>>)
Calcula a média de uma sequência de valores Double anuláveis obtida invocando uma função de projeção em cada

System.Linq.Expressions.Expression<Func<TSource,Nullable<double>>> selector);
System.Linq.Expressions.Expression<Func<'Source, Nullable<double>>> -> Nullable<double>
Type Parameters
TSource
Parameters
selector Expression<Func<TSource,Nullable<Double>>>
Returns
Nullable<Double>
Exceptions
Examples
String.
Note


//
Remarks
O Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Double>>>) método gera uma
Expression<Func<TSource,Nullable<Double>>>) a próprio como um método genérico construído. Em seguida, ele
chamada Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Double>>>) depende da
Expression<Func<TSource,Int64>>) Average<TSource>
(IQueryable<TSource>, Expression<Func<TSource,Int64>>)
Calcula a média de uma sequência de valores Int64 obtida invocando uma função de projeção em cada elemento da
public static double Average<TSource> (this System.Linq.IQueryable<TSource> source,

System.Linq.Expressions.Expression<Func<TSource,long>> selector);
System.Linq.Expressions.Expression<Func<'Source, int64>> -> double
Type Parameters
TSource
Parameters
selector Expression<Func<TSource,Int64>>
Returns
Double Double
Exceptions
Examples
String.
Note


//
Remarks
O Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int64>>) método gera uma
Expression<Func<TSource,Int64>>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int64>>) depende da implementação
do tipo do source parâmetro. O comportamento esperado é que ele calcula a média dos valores em source depois
de invocar selector em cada valor.
Expression<Func<TSource,Int32>>) Average<TSource>
Calcula a média de uma sequência de valores Int32 obtida invocando uma função de projeção em cada elemento da

System.Linq.Expressions.Expression<Func<TSource,int>> selector);
System.Linq.Expressions.Expression<Func<'Source, int>> -> double
Type Parameters
TSource
Parameters
Returns
Double Double
Exceptions
Examples
String.


//
Remarks
O Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32>>) método gera uma
chamada Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32>>) depende da implementação
do tipo do source parâmetro. O comportamento esperado é que ele calcula a média dos valores em source depois
de invocar selector em cada valor.
Expression<Func<TSource,Double>>) Average<TSource>
(IQueryable<TSource>, Expression<Func<TSource,Double>>)
Calcula a média de uma sequência de valores Double obtida invocando uma função de projeção em cada elemento da
System.Linq.Expressions.Expression<Func<TSource,double>> selector);
System.Linq.Expressions.Expression<Func<'Source, double>> -> double
Type Parameters
TSource
Parameters
selector Expression<Func<TSource,Double>>
Returns
Double Double
Exceptions
Examples
String.
Note


//
Remarks
O Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Double>>) método gera uma
Expression<Func<TSource,Double>>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Double>>) depende da
Expression<Func<TSource,Decimal>>) Average<TSource>
(IQueryable<TSource>, Expression<Func<TSource,Decimal>>)
Calcula a média de uma sequência de valores Decimal obtida invocando uma função de projeção em cada elemento da
public static decimal Average<TSource> (this System.Linq.IQueryable<TSource> source,
System.Linq.Expressions.Expression<Func<TSource,decimal>> selector);
System.Linq.Expressions.Expression<Func<'Source, decimal>> -> decimal
Type Parameters
TSource
Parameters
selector Expression<Func<TSource,Decimal>>
Returns
Decimal Decimal
Exceptions
Examples
String.
Note


//
Remarks
O Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Decimal>>) método gera uma
Expression<Func<TSource,Decimal>>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Decimal>>) depende da
Expression<Func<TSource,Nullable<Decimal>>>)
Calcula a média de uma sequência de valores Decimal anuláveis obtida invocando uma função de projeção em cada
public static Nullable<decimal> Average<TSource> (this System.Linq.IQueryable<TSource> source,
System.Linq.Expressions.Expression<Func<TSource,Nullable<decimal>>> selector);
System.Linq.Expressions.Expression<Func<'Source, Nullable<decimal>>> -> Nullable<decimal>
Type Parameters
TSource
Parameters
selector Expression<Func<TSource,Nullable<Decimal>>>
Returns
Nullable<Decimal>
Exceptions
Examples
String.
Note


//
Remarks
O Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Decimal>>>) método gera uma
Expression<Func<TSource,Nullable<Decimal>>>) a próprio como um método genérico construído. Em seguida, ele
chamada Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Decimal>>>) depende da
Queryable.Cast Queryable.Cast
I n this Article
Converte os elementos de um IQueryable para o tipo especificado.
public static System.Linq.IQueryable<TResult> Cast<TResult> (this System.Linq.IQueryable source);
static member Cast : System.Linq.IQueryable -> System.Linq.IQueryable<'Result>
Type Parameters
TResult
O tipo para o qual os elementos de source deverão ser convertidos.
Parameters
source IQueryable IQueryable
O IQueryable que contém os elementos a serem convertidos.
Returns
IQueryable<TResult>
Um IQueryable<T> que contém cada elemento da sequência de origem convertido para o tipo especificado.
Exceptions
source é null .
Um elemento na sequência não pode ser convertido para o tipo TResult .
Examples
O exemplo de código a seguir demonstra como usar Cast<TResult>(IQueryable) para converter objetos em uma
sequência para o tipo String.
// Create a list of objects.
List<object> words =
new List<object> { "green", "blue", "violet" };
// Cast the objects in the list to type 'string'

// and project the first letter of each string.
words.AsQueryable()
.Cast<string>()
.Select(str => str.Substring(0, 1));
foreach (string s in query)

Console.WriteLine(s);
g
b
v
*/
Remarks
O Cast<TResult>(IQueryable) método gera uma MethodCallExpression que representa a chamada Cast<TResult>
(IQueryable) a próprio como um método genérico construído. Em seguida, ele passa a MethodCallExpression para o
CreateQuery(Expression) método da IQueryProvider representado pela Provider propriedade do source parâmetro.
chamada Cast<TResult>(IQueryable) depende da implementação do tipo do source parâmetro. O comportamento
esperado é que ele converte os valores em source digitar TResult .
Queryable.Concat Queryable.Concat
I n this Article
public static System.Linq.IQueryable<TSource> Concat<TSource> (this System.Linq.IQueryable<TSource>
source1, System.Collections.Generic.IEnumerable<TSource> source2);
static member Concat : System.Linq.IQueryable<'Source> * seq<'Source> ->
System.Linq.IQueryable<'Source>
Type Parameters
TSource
Parameters
source1 IQueryable<TSource>
source2 IEnumerable<TSource>
Returns
IQueryable<TSource>
Um IQueryable<T> que contém os elementos concatenados das duas sequências de entrada.
Exceptions
source1 ou source2 é null .
Examples
O exemplo de código a seguir demonstra como usar Concat<TSource>(IQueryable<TSource>,
IEnumerable<TSource>) para concatenar duas sequências.
class Pet
{
}
// This method creates and returns an array of Pet objects.

static Pet[] GetCats()
{
Pet[] cats = { new Pet { Name="Barley", Age=8 },
return cats;
}
// This method creates and returns an array of Pet objects.

static Pet[] GetDogs()
{
Pet[] dogs = { new Pet { Name="Bounder", Age=3 },
new Pet { Name="Snoopy", Age=14 },
new Pet { Name="Fido", Age=9 } };
return dogs;
}
public static void ConcatEx1()

{
// Concatenate a collection of cat names to a

// collection of dog names by using Concat().
cats.AsQueryable()
.Select(cat => cat.Name)
.Concat(dogs.Select(dog => dog.Name));

}

//
// Barley
// Boots
// Whiskers
// Bounder
// Snoopy
// Fido
Remarks
O Concat<TSource>(IQueryable<TSource>, IEnumerable<TSource>) método gera uma MethodCallExpression que
representa a chamada Concat<TSource>(IQueryable<TSource>, IEnumerable<TSource>) a próprio como um método
genérico construído. Em seguida, ele passa a MethodCallExpression para o CreateQuery<TElement>(Expression)
método da IQueryProvider representado pela Provider propriedade do source1 parâmetro.
chamada Concat<TSource>(IQueryable<TSource>, IEnumerable<TSource>) depende da implementação do tipo do
source1 parâmetro. O comportamento esperado é que os elementos na source2 são concatenados para aqueles de
source1 para criar uma nova sequência.
Queryable.Contains Queryable.Contains
I n this Article
Overloads
Contains<TSource>(IQueryable<TSource>, TSource, IEquality
Comparer<TSource>) Contains<TSource>(IQueryable< Determina se uma sequência contém um elemento
TSource>, TSource, IEqualityComparer<TSource>) especificado usando um IEqualityComparer<T> especificado.
Contains<TSource>(IQueryable<TSource>, TSource) Determina se uma sequência contém um elemento
especificado usando o comparador de igualdade padrão.
Contains<TSource>(IQueryable<TSource>, TSource,
(IQueryable<TSource>, TSource, IEqualityComparer<TSource>)
public static bool Contains<TSource> (this System.Linq.IQueryable<TSource> source, TSource item,
static member Contains : System.Linq.IQueryable<'Source> * 'Source *
Type Parameters
TSource
Parameters
Um IQueryable<T> no qual item será localizado.
item TSource TSource
O objeto a ser localizado na sequência.
Returns
Boolean Boolean
true se a sequência de entrada contiver um elemento que tem o valor especificado; caso contrário, false .
Exceptions
source é null .
Remarks
O Contains<TSource>(IQueryable<TSource>, TSource, IEqualityComparer<TSource>) método gera uma
MethodCallExpression que representa a chamada Contains<TSource>(IQueryable<TSource>, TSource,
IEqualityComparer<TSource>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Contains<TSource>(IQueryable<TSource>, TSource, IEqualityComparer<TSource>) depende da
implementação do tipo do source parâmetro. O comportamento esperado é que ele determina se source contém
item usando comparer para comparar valores.
public static bool Contains<TSource> (this System.Linq.IQueryable<TSource> source, TSource item);
static member Contains : System.Linq.IQueryable<'Source> * 'Source -> bool
Type Parameters
TSource
Parameters
Um IQueryable<T> no qual item será localizado.
item TSource TSource
O objeto a ser localizado na sequência.
Returns
Boolean Boolean
true se a sequência de entrada contiver um elemento que tem o valor especificado; caso contrário, false .
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Contains<TSource>(IQueryable<TSource>, TSource) para
determinar se uma sequência contém um elemento específico.
// The string to search for in the array.

string mango = "mango";
bool hasMango = fruits.AsQueryable().Contains(mango);
Console.WriteLine(
"The array {0} contain '{1}'.",
hasMango ? "does" : "does not",
mango);

//
// The array does contain 'mango'.
Remarks
O Contains<TSource>(IQueryable<TSource>, TSource) método gera uma MethodCallExpression que representa a
chamada Contains<TSource>(IQueryable<TSource>, TSource) a próprio como um método genérico construído. Em
chamada Contains<TSource>(IQueryable<TSource>, TSource) depende da implementação do tipo do source
parâmetro. O comportamento esperado é que ele determina se source contém item .
Queryable.Count Queryable.Count
I n this Article
Overloads
Count<TSource>(IQueryable<TSource>) Count<TSource>(
IQueryable<TSource>) Retorna o número de elementos em uma sequência.
Count<TSource>(IQueryable<TSource>, Expression<Func<
TSource,Boolean>>) Count<TSource>(IQueryable<TSource>, Retorna o número de elementos na sequência especificada
Expression<Func<TSource,Boolean>>) que atendem a uma condição.
Count<TSource>(IQueryable<TSource>) Count<TSource>
public static int Count<TSource> (this System.Linq.IQueryable<TSource> source);
static member Count : System.Linq.IQueryable<'Source> -> int
Type Parameters
TSource
Parameters
O IQueryable<T> que contém os elementos a serem contados.
Returns
Int32 Int32
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Count<TSource>(IQueryable<TSource>) para contar os
int numberOfFruits = fruits.AsQueryable().Count();
Console.WriteLine(
"There are {0} items in the array.",
numberOfFruits);

//
// There are 6 items in the array.
Remarks
O Count<TSource>(IQueryable<TSource>) método gera uma MethodCallExpression que representa a chamada
Count<TSource>(IQueryable<TSource>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Count<TSource>(IQueryable<TSource>) depende da implementação do tipo do source parâmetro. O
comportamento esperado é que ela conta o número de itens na source .
Count<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) Count<TSource>
Retorna o número de elementos na sequência especificada que atendem a uma condição.
public static int Count<TSource> (this System.Linq.IQueryable<TSource> source,
static member Count : System.Linq.IQueryable<'Source> *
System.Linq.Expressions.Expression<Func<'Source, bool>> -> int
Type Parameters
TSource
Parameters
Um IQueryable<T> que contém os elementos a serem contados.
Returns
Int32 Int32
O número de elementos na sequência que atende à condição na função de predicado.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Count<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) para contar os elementos em uma sequência que satisfazem uma condição.
class Pet
{
}
public static void CountEx2()

{
// Create an array of Pet objects.
Pet[] pets = { new Pet { Name="Barley", Vaccinated=true },
new Pet { Name="Boots", Vaccinated=false },
new Pet { Name="Whiskers", Vaccinated=false } };
// Count the number of unvaccinated pets in the array.

int numberUnvaccinated =
pets.AsQueryable().Count(p => p.Vaccinated == false);
Console.WriteLine(
"There are {0} unvaccinated animals.",
numberUnvaccinated);
}

//
// There are 2 unvaccinated animals.
Remarks
O Count<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) método gera uma
MethodCallExpression que representa a chamada Count<TSource>(IQueryable<TSource>,
chamada Count<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) depende da
implementação do tipo do source parâmetro. O comportamento esperado é que ela conta o número de itens na
source que satisfazem a condição especificada pelo predicate .
Queryable.DefaultIfEmpty Queryable.DefaultIfEmpty
I n this Article
Overloads
DefaultIfEmpty<TSource>(IQueryable<TSource>) DefaultIf
Empty<TSource>(IQueryable<TSource>) Retornará os elementos da sequência especificada ou o valor
padrão do parâmetro de tipo em uma coleção de singletons se
DefaultIfEmpty<TSource>(IQueryable<TSource>, TSource) Retorna os elementos da sequência especificada ou o valor
especificado em uma coleção de singletons se a sequência está
vazia.
public static System.Linq.IQueryable<TSource> DefaultIfEmpty<TSource> (this
System.Linq.IQueryable<TSource> source);
static member DefaultIfEmpty : System.Linq.IQueryable<'Source> -> System.Linq.IQueryable<'Source>
Type Parameters
TSource
Parameters
O IQueryable<T> para o qual será retornado um valor padrão se estiver vazio.
Returns
IQueryable<TSource>
Um IQueryable<T> que contém default ( TSource ) se source estiver vazio; caso contrário, source .
Exceptions
source é null .
Examples
Os exemplos de código a seguir demonstram como usar DefaultIfEmpty<TSource>(IQueryable<TSource>) para
fornecer um valor padrão caso a sequência de origem está vazia.
class Pet
{
}

{
// Create a list of Pet objects.
List<Pet> pets =
// Call DefaultIfEmtpy() on the collection that Select()

// returns, so that if the initial list is empty, there
// will always be at least one item in the returned array.
string[] names =
pets.AsQueryable()
.Select(pet => pet.Name)
.DefaultIfEmpty()
.ToArray();
string first = names[0];

}
/*
Barley
*/
Remarks
O DefaultIfEmpty<TSource>(IQueryable<TSource>) método gera uma MethodCallExpression que representa a
chamada DefaultIfEmpty<TSource>(IQueryable<TSource>) a próprio como um método genérico construído. Em
seguida, ele passa a MethodCallExpression para o CreateQuery<TElement>(Expression) método da IQueryProvider
chamada DefaultIfEmpty<TSource>(IQueryable<TSource>) depende da implementação do tipo do source
parâmetro. O comportamento esperado é que ele retorna source se não estiver vazia. Caso contrário, retornará um
IQueryable<T> que contém default(TSource) .
Retorna os elementos da sequência especificada ou o valor especificado em uma coleção de singletons se a sequência
está vazia.
public static System.Linq.IQueryable<TSource> DefaultIfEmpty<TSource> (this

System.Linq.IQueryable<TSource> source, TSource defaultValue);
static member DefaultIfEmpty : System.Linq.IQueryable<'Source> * 'Source ->
Type Parameters
TSource
Parameters
O IQueryable<T> para o qual será retornado o valor especificado se ele estiver vazio.
Returns
IQueryable<TSource>
Um IQueryable<T> que contém defaultValue se source está vazio; caso contrário, source .
Exceptions
source é null .
Examples
O exemplo de código a seguir mostra uma situação em que ele é útil chamar DefaultIfEmpty<TSource>
(IQueryable<TSource>, TSource) em um LINQ consulta. Um valor padrão é passado para DefaultIfEmpty<TSource>
(IQueryable<TSource>, TSource) neste exemplo.
List<Pet> pets =
// This query selects only those pets that are 10 or older.

// In case there are no pets that meet that criteria, call
// DefaultIfEmpty(). This code passes an (optional) default
// value to DefaultIfEmpty().
string[] oldPets =
pets.AsQueryable()
.Where(pet => pet.Age >= 10)
.DefaultIfEmpty("[EMPTY]")
.ToArray();
Console.WriteLine("First query: " + oldPets[0]);
// This query selects only those pets that are 10 or older.

// This code does not call DefaultIfEmpty().
string[] oldPets2 =
pets.AsQueryable()
.Where(pet => pet.Age >= 10)
.ToArray();
// There may be no elements in the array, so directly

// accessing element 0 may throw an exception.
try
{
Console.WriteLine("Second query: " + oldPets2[0]);
}
catch (Exception e)
{
Console.WriteLine("Second query: An exception was thrown: " + e.Message);
}
/*
First query: [EMPTY]

Second query: An exception was thrown: Index was outside the bounds of the array.
*/
Remarks
O DefaultIfEmpty<TSource>(IQueryable<TSource>, TSource) método gera uma MethodCallExpression que
representa a chamada DefaultIfEmpty<TSource>(IQueryable<TSource>, TSource) a próprio como um método
método da IQueryProvider representado pela Provider propriedade do source parâmetro.
chamada DefaultIfEmpty<TSource>(IQueryable<TSource>, TSource) depende da implementação do tipo do source
parâmetro. O comportamento esperado é que ele retorna source se não estiver vazia. Caso contrário, retornará um
IQueryable<T> que contém defaultValue .
Queryable.Distinct Queryable.Distinct
I n this Article
Overloads
Distinct<TSource>(IQueryable<TSource>) Distinct<TSource>(
IQueryable<TSource>) Retorna os elementos distintos de uma sequência usando o
comparador de igualdade padrão para comparar valores.
Distinct<TSource>(IQueryable<TSource>, IEqualityComparer<
TSource>) Distinct<TSource>(IQueryable<TSource>, IEquality Retorna os elementos distintos de uma sequência usando um
Comparer<TSource>) IEqualityComparer<T> especificado para comparar valores.
Distinct<TSource>(IQueryable<TSource>) Distinct<TSource>
Retorna os elementos distintos de uma sequência usando o comparador de igualdade padrão para comparar valores.
public static System.Linq.IQueryable<TSource> Distinct<TSource> (this
System.Linq.IQueryable<TSource> source);
static member Distinct : System.Linq.IQueryable<'Source> -> System.Linq.IQueryable<'Source>
Type Parameters
TSource
Parameters
O IQueryable<T> do qual as duplicatas serão removidas.
Returns
IQueryable<TSource>
Um IQueryable<T> que contém elementos distintos do source .
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Distinct<TSource>(IQueryable<TSource>) para retornar os
elementos distintos de uma sequência.
List<int> ages = new List<int> { 21, 46, 46, 55, 17, 21, 55, 55 };
IEnumerable<int> distinctAges = ages.AsQueryable().Distinct();
Console.WriteLine("Distinct ages:");
foreach (int age in distinctAges)

Console.WriteLine(age);
/*
Distinct ages:
21
46
55
17
*/
Remarks
O Distinct<TSource>(IQueryable<TSource>) método gera uma MethodCallExpression que representa a chamada
Distinct<TSource>(IQueryable<TSource>) a próprio como um método genérico construído. Em seguida, ele passa a
MethodCallExpression para o CreateQuery<TElement>(Expression) método da IQueryProvider representado pela
chamada Distinct<TSource>(IQueryable<TSource>) depende da implementação do tipo do source parâmetro. O
comportamento esperado é que ele retorna uma sequência não ordenada de itens exclusivos em source .
Distinct<TSource>(IQueryable<TSource>,
(IQueryable<TSource>, IEqualityComparer<TSource>)
valores.
public static System.Linq.IQueryable<TSource> Distinct<TSource> (this

System.Linq.IQueryable<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>
comparer);
static member Distinct : System.Linq.IQueryable<'Source> *
System.Collections.Generic.IEqualityComparer<'Source> -> System.Linq.IQueryable<'Source>
Type Parameters
TSource
Parameters
O IQueryable<T> do qual as duplicatas serão removidas.
Returns
IQueryable<TSource>
Um IQueryable<T> que contém elementos distintos do source .
Exceptions
source ou comparer é null .
Remarks
O Distinct<TSource>(IQueryable<TSource>, IEqualityComparer<TSource>) método gera uma MethodCallExpression
que representa a chamada Distinct<TSource>(IQueryable<TSource>, IEqualityComparer<TSource>) a próprio como
um método genérico construído. Em seguida, ele passa a MethodCallExpression para o CreateQuery<TElement>
chamada Distinct<TSource>(IQueryable<TSource>, IEqualityComparer<TSource>) depende da implementação do
tipo do source parâmetro. O comportamento esperado é que ele retorna uma sequência não ordenada de itens
exclusivos na source usando comparer para comparar valores.
Queryable.ElementAt Queryable.ElementAt
I n this Article
public static TSource ElementAt<TSource> (this System.Linq.IQueryable<TSource> source, int index);
static member ElementAt : System.Linq.IQueryable<'Source> * int -> 'Source
Type Parameters
TSource
Parameters
Um IQueryable<T> do qual um elemento será retornado.
index Int32 Int32
Returns
TSource TSource
O elemento na posição especificada em source .
Exceptions
source é null .
index é menor que zero.
Examples
O exemplo de código a seguir demonstra como usar ElementAt<TSource>(IQueryable<TSource>, Int32) para
retornar um elemento em uma posição específica em uma sequência.
Random random = new Random(DateTime.Now.Millisecond);
string name =
names.AsQueryable().ElementAt(random.Next(0, names.Length));
Console.WriteLine("The name chosen at random is '{0}'.", name);
/*
This code produces the following sample output.
Yours may be different due to the use of Random.
The name chosen at random is 'Ito, Shu'.

*/
Remarks
O ElementAt<TSource>(IQueryable<TSource>, Int32) método gera uma MethodCallExpression que representa a
chamada ElementAt<TSource>(IQueryable<TSource>, Int32) a próprio como um método genérico construído. Em
chamada ElementAt<TSource>(IQueryable<TSource>, Int32) depende da implementação do tipo do source
parâmetro. O comportamento esperado é que ele retorna o item na posição index em source .
Queryable.ElementAtOrDefault Queryable.ElementAtOr
Default
I n this Article
intervalo.
public static TSource ElementAtOrDefault<TSource> (this System.Linq.IQueryable<TSource> source, int
index);
static member ElementAtOrDefault : System.Linq.IQueryable<'Source> * int -> 'Source
Type Parameters
TSource
Parameters
index Int32 Int32
Returns
TSource TSource
default ( TSource ) se index estiver fora dos limites de source ; caso contrário, o elemento na posição especificada
em source .
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar ElementAtOrDefault<TSource>(IQueryable<TSource>, Int32).
Este exemplo usa um valor para index que está fora dos limites da sequência de origem.
int index = 20;
string name = names.AsQueryable().ElementAtOrDefault(index);
Console.WriteLine(
"The name chosen at index {0} is '{1}'.",
index,
String.IsNullOrEmpty(name) ? "[NONE AT THIS INDEX]" : name);
/*
The name chosen at index 20 is '[NONE AT THIS INDEX]'.

*/
Remarks
O ElementAtOrDefault<TSource>(IQueryable<TSource>, Int32) método gera uma MethodCallExpression que
representa a chamada ElementAtOrDefault<TSource>(IQueryable<TSource>, Int32) a próprio como um método
genérico construído. Em seguida, ele passa a MethodCallExpression para o Execute<TResult>(Expression) método da
IQueryProvider representado pela Provider propriedade do source parâmetro.
chamada ElementAtOrDefault<TSource>(IQueryable<TSource>, Int32) depende da implementação do tipo do
source parâmetro. O comportamento esperado é que ele retorna o item na posição index na source , ou
default(TSource) se index está fora dos limites do source .
Queryable.Except Queryable.Except
I n this Article
Overloads
Except<TSource>(IQueryable<TSource>, IEnumerable<
TSource>, IEqualityComparer<TSource>) Except<TSource>( Produz a diferença de conjunto de duas sequências usando o
IQueryable<TSource>, IEnumerable<TSource>, IEquality IEqualityComparer<T> especificado para comparar os valores.
Comparer<TSource>)
Except<TSource>(IQueryable<TSource>, IEnumerable<
TSource>) Except<TSource>(IQueryable<TSource>, Produz a diferença de conjunto de duas sequências usando o
Except<TSource>(IQueryable<TSource>, IEnumerable<TSource>,
IEqualityComparer<TSource>) Except<TSource>
(IQueryable<TSource>, IEnumerable<TSource>,
Produz a diferença de conjunto de duas sequências usando o IEqualityComparer<T> especificado para comparar os
valores.
public static System.Linq.IQueryable<TSource> Except<TSource> (this System.Linq.IQueryable<TSource>
source1, System.Collections.Generic.IEnumerable<TSource> source2,
static member Except : System.Linq.IQueryable<'Source> * seq<'Source> *
Type Parameters
TSource
Parameters
Um IQueryable<T> cujos elementos que não estão presentes também no source2 serão retornados.
Um IEnumerable<T> cujos elementos que também ocorrem na primeira sequência não aparecerão na sequência
retornada.
Returns
IQueryable<TSource>
Um IQueryable<T> que contém a diferença de conjunto das duas sequências.
Exceptions
Remarks
O Except<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) método gera
uma MethodCallExpression que representa a chamada Except<TSource>(IQueryable<TSource>,
IEnumerable<TSource>, IEqualityComparer<TSource>) a próprio como um método genérico construído. Em seguida,
ele passa a MethodCallExpression para o CreateQuery<TElement>(Expression) método da IQueryProvider
representado pela Provider propriedade do source1 parâmetro.
chamada Except<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) depende
da implementação do tipo do source1 parâmetro. O comportamento esperado é que todos os elementos em source1
são retornados, exceto aquelas que estão presentes também no source2 , e comparer é usado para comparar valores.
valores.
public static System.Linq.IQueryable<TSource> Except<TSource> (this System.Linq.IQueryable<TSource>

static member Except : System.Linq.IQueryable<'Source> * seq<'Source> ->
Type Parameters
TSource
Parameters
Um IQueryable<T> cujos elementos que não estão presentes também no source2 serão retornados.
Um IEnumerable<T> cujos elementos que também ocorrem na primeira sequência não aparecerão na sequência
retornada.
Returns
IQueryable<TSource>
Um IQueryable<T> que contém a diferença de conjunto das duas sequências.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Except<TSource>(IQueryable<TSource>,
IEnumerable<TSource>) para retornar os elementos que aparecem somente na primeira sequência de origem.
double[] numbers1 = { 2.0, 2.1, 2.2, 2.3, 2.4, 2.5 };

double[] numbers2 = { 2.2 };
// Get the numbers from the first array that

// are NOT in the second array.
IEnumerable<double> onlyInFirstSet =
numbers1.AsQueryable().Except(numbers2);
foreach (double number in onlyInFirstSet)

/*
2
2.1
2.3
2.4
2.5
*/
Remarks
O Except<TSource>(IQueryable<TSource>, IEnumerable<TSource>) método gera uma MethodCallExpression que
representa a chamada Except<TSource>(IQueryable<TSource>, IEnumerable<TSource>) a próprio como um método
chamada Except<TSource>(IQueryable<TSource>, IEnumerable<TSource>) depende da implementação do tipo do
source1 parâmetro. O comportamento esperado é que todos os elementos em source1 são retornados, exceto
aquelas que estão presentes também no source2 .
Queryable.First Queryable.First
I n this Article
Overloads
First<TSource>(IQueryable<TSource>) First<TSource>(
IQueryable<TSource>) Retorna o primeiro elemento de uma sequência.
First<TSource>(IQueryable<TSource>, Expression<Func<
TSource,Boolean>>) First<TSource>(IQueryable<TSource>, Retorna o primeiro elemento de uma sequência que satisfaz
Expression<Func<TSource,Boolean>>) uma condição especificada.
First<TSource>(IQueryable<TSource>) First<TSource>
public static TSource First<TSource> (this System.Linq.IQueryable<TSource> source);
static member First : System.Linq.IQueryable<'Source> -> 'Source
Type Parameters
TSource
Parameters
O IQueryable<T> do qual o primeiro elemento será retornado.
Returns
TSource TSource
O primeiro elemento em source .
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar First<TSource>(IQueryable<TSource>) para retornar o primeiro
elemento em uma sequência.
int[] numbers = { 9, 34, 65, 92, 87, 435, 3, 54,
83, 23, 87, 435, 67, 12, 19 };
int first = numbers.AsQueryable().First();
/*
9
*/
Remarks
O First<TSource>(IQueryable<TSource>) método gera uma MethodCallExpression que representa a chamada
First<TSource>(IQueryable<TSource>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada First<TSource>(IQueryable<TSource>) depende da implementação do tipo do source parâmetro. O
comportamento esperado é que ele retorna o primeiro elemento em source .
First<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) First<TSource>
Retorna o primeiro elemento de uma sequência que satisfaz uma condição especificada.
public static TSource First<TSource> (this System.Linq.IQueryable<TSource> source,
static member First : System.Linq.IQueryable<'Source> *
System.Linq.Expressions.Expression<Func<'Source, bool>> -> 'Source
Type Parameters
TSource
Parameters
Returns
TSource TSource
O primeiro elemento em source que é aprovado no teste em predicate .
Exceptions
Examples
O exemplo de código a seguir demonstra como usar First<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) para retornar o primeiro elemento de uma sequência que satisfaz uma
condição.
int[] numbers = { 9, 34, 65, 92, 87, 435, 3, 54,

83, 23, 87, 435, 67, 12, 19 };
// Get the first number in the array that is greater than 80.
int first = numbers.AsQueryable().First(number => number > 80);
/*
92
*/
Remarks
O First<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) método gera uma
MethodCallExpression que representa a chamada First<TSource>(IQueryable<TSource>,
chamada First<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) depende da implementação
do tipo do source parâmetro. O comportamento esperado é que ele retorna o primeiro elemento em source que
satisfaz a condição especificada pelo predicate .
Queryable.FirstOrDefault Queryable.FirstOrDefault
I n this Article
Overloads
FirstOrDefault<TSource>(IQueryable<TSource>) FirstOr
Default<TSource>(IQueryable<TSource>) Retorna o primeiro elemento de uma sequência ou um valor
FirstOrDefault<TSource>(IQueryable<TSource>, Expression<
Func<TSource,Boolean>>) FirstOrDefault<TSource>( Retorna o primeiro elemento de uma sequência que atende a
IQueryable<TSource>, Expression<Func<TSource,Boolean>>) uma condição especificada ou um valor padrão se esse
elemento não é encontrado.
public static TSource FirstOrDefault<TSource> (this System.Linq.IQueryable<TSource> source);

static member FirstOrDefault : System.Linq.IQueryable<'Source> -> 'Source
Type Parameters
TSource
Parameters
O IQueryable<T> do qual o primeiro elemento será retornado.
Returns
TSource TSource
default ( TSource ) se source estiver vazio; caso contrário, o primeiro elemento em source .
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar FirstOrDefault<TSource>(IQueryable<TSource>) em uma
sequência vazia.
// Create an empty array.
int[] numbers = { };
// Get the first item in the array, or else the
// default value for type int (0).
int first = numbers.AsQueryable().FirstOrDefault();
/*
0
*/
pode usar o DefaultIfEmpty<TSource>(IQueryable<TSource>, TSource) método para especificar o valor padrão que
você deseja usar, se a coleção está vazia. Em seguida, chame First<TSource>(IQueryable<TSource>) para obter o
primeiro elemento. O exemplo de código a seguir usa ambas as técnicas para obter um valor padrão de 1 se uma
coleção de meses numéricos está vazia. Como o valor padrão para um número inteiro é 0, o que não corresponde a
qualquer mês, o valor padrão deve ser especificado como 1 em vez disso. A primeira variável de resultado é verificada
para o valor padrão não desejados depois que a consulta for concluída. A segunda variável de resultado é obtida
chamando DefaultIfEmpty<TSource>(IQueryable<TSource>, TSource) para especificar um valor padrão de 1.
List<int> months = new List<int> { };

int firstMonth1 = months.AsQueryable().FirstOrDefault();
if (firstMonth1 == 0)
{
firstMonth1 = 1;
}

int firstMonth2 = months.AsQueryable().DefaultIfEmpty(1).First();
/*

*/
Remarks
O FirstOrDefault<TSource>(IQueryable<TSource>) método gera uma MethodCallExpression que representa a
chamada FirstOrDefault<TSource>(IQueryable<TSource>) a próprio como um método genérico construído. Em
chamada FirstOrDefault<TSource>(IQueryable<TSource>) depende da implementação do tipo do source parâmetro.
O comportamento esperado é que ele retorna o primeiro elemento em source , ou um valor padrão se source está
vazio.
O FirstOrDefault método não fornece uma maneira de especificar o valor padrão a ser retornado se source está vazio.
Se você quiser especificar um valor padrão diferente de default(TSource) , use o DefaultIfEmpty<TSource>
(IQueryable<TSource>, TSource) método conforme descrito na seção de exemplo.
FirstOrDefault<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) FirstOrDefault<TSource>
Retorna o primeiro elemento de uma sequência que atende a uma condição especificada ou um valor padrão se esse
elemento não é encontrado.
public static TSource FirstOrDefault<TSource> (this System.Linq.IQueryable<TSource> source,
static member FirstOrDefault : System.Linq.IQueryable<'Source> *
Type Parameters
TSource
Parameters
Returns
TSource TSource
default ( TSource ) se source estiver vazio ou se nenhum elemento for aprovado no teste especificado por
predicate ; caso contrário, o primeiro elemento em source aprovado no teste especificado por predicate .
Exceptions
Examples
O exemplo de código a seguir demonstra como usar FirstOrDefault<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) , passando um predicado. Na segunda consulta, há nenhum elemento na
sequência que satisfaz a condição.
// Get the first string in the array that is longer

// than 20 characters, or the default value for type
// string (null) if none exists.
string firstLongName =
names.AsQueryable().FirstOrDefault(name => name.Length > 20);
Console.WriteLine("The first long name is '{0}'.", firstLongName);
// Get the first string in the array that is longer

// than 30 characters, or the default value for type
// string (null) if none exists.
string firstVeryLongName =
names.AsQueryable().FirstOrDefault(name => name.Length > 30);
Console.WriteLine(
"There is {0} name that is longer than 30 characters.",
string.IsNullOrEmpty(firstVeryLongName) ? "NOT a" : "a");
/*
The first long name is 'Andersen, Henriette Thaulow'.

There is NOT a name that is longer than 30 characters.
*/
Remarks
O FirstOrDefault<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) método gera uma
MethodCallExpression que representa a chamada FirstOrDefault<TSource>(IQueryable<TSource>,
chamada FirstOrDefault<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) depende da
implementação do tipo do source parâmetro. O comportamento esperado é que ele retorna o primeiro elemento em
source que atende à condição em predicate , ou um valor padrão se nenhum elemento satisfaz a condição.
Queryable.GroupBy Queryable.GroupBy
I n this Article
Overloads
GroupBy<TSource,TKey,TElement,TResult>(IQueryable<
TSource>, Expression<Func<TSource,TKey>>, Expression< Agrupa os elementos de uma sequência de acordo com uma
Func<TSource,TElement>>, Expression<Func<TKey, função do seletor de chave especificada e cria um valor de
IEnumerable<TElement>,TResult>>, IEqualityComparer< resultado de cada grupo e sua chave. As chaves são
TKey>) GroupBy<TSource,TKey,TElement,TResult>( comparadas usando um comparador especificado e os
IQueryable<TSource>, Expression<Func<TSource,TKey>>, elementos de cada grupo são projetados usando uma função
Expression<Func<TSource,TElement>>, Expression<Func< especificada.
TKey,IEnumerable<TElement>,TResult>>, IEqualityComparer<
TKey>)
GroupBy<TSource,TKey,TElement,TResult>(IQueryable<
TSource>, Expression<Func<TSource,TKey>>, Expression< Agrupa os elementos de uma sequência de acordo com uma
Func<TSource,TElement>>, Expression<Func<TKey, função do seletor de chave especificada e cria um valor de
IEnumerable<TElement>,TResult>>) GroupBy<TSource,TKey, resultado de cada grupo e sua chave. Os elementos de cada
TElement,TResult>(IQueryable<TSource>, Expression<Func< grupo são projetados usando uma função especificada.
TSource,TKey>>, Expression<Func<TSource,TElement>>,
Expression<Func<TKey,IEnumerable<TElement>,TResult>>)
GroupBy<TSource,TKey,TElement>(IQueryable<TSource>,
Expression<Func<TSource,TKey>>, Expression<Func< Agrupa os elementos de uma sequência de acordo com a
TSource,TElement>>) GroupBy<TSource,TKey,TElement>( função de seletor de chave especificada e projeta os elementos
IQueryable<TSource>, Expression<Func<TSource,TKey>>, de cada grupo usando uma função especificada.
Expression<Func<TSource,TKey>>, Expression<Func< Agrupa os elementos de uma sequência e projeta os
TSource,TElement>>, IEqualityComparer<TKey>) GroupBy< elementos para cada grupo usando uma função especificada.
TSource,TKey,TElement>(IQueryable<TSource>, Expression< Os valores de chave são comparados usando um comparador
Func<TSource,TKey>>, Expression<Func<TSource, especificado.
TElement>>, IEqualityComparer<TKey>)
GroupBy<TSource,TKey,TResult>(IQueryable<TSource>,
Expression<Func<TSource,TKey>>, Expression<Func<TKey, Agrupa os elementos de uma sequência de acordo com uma
IEnumerable<TSource>,TResult>>) GroupBy<TSource,TKey, função do seletor de chave especificada e cria um valor de
TResult>(IQueryable<TSource>, Expression<Func<TSource, resultado de cada grupo e sua chave.
TKey>>, Expression<Func<TKey,IEnumerable<TSource>,
TResult>>)
Expression<Func<TSource,TKey>>, Expression<Func<TKey, Agrupa os elementos de uma sequência de acordo com uma
IEnumerable<TSource>,TResult>>, IEqualityComparer< função do seletor de chave especificada e cria um valor de
TKey>) GroupBy<TSource,TKey,TResult>(IQueryable< resultado de cada grupo e sua chave. As chaves são
TSource>, Expression<Func<TSource,TKey>>, Expression< comparadas usando um comparador especificado.
Func<TKey,IEnumerable<TSource>,TResult>>, IEquality
Comparer<TKey>)
GroupBy<TSource,TKey>(IQueryable<TSource>, Expression<
Func<TSource,TKey>>, IEqualityComparer<TKey>) GroupBy< Agrupa os elementos de uma sequência de acordo com uma
TSource,TKey>(IQueryable<TSource>, Expression<Func< função do seletor de chave especificada e compara as chaves
TSource,TKey>>, IEqualityComparer<TKey>) usando um comparador especificado.
GroupBy<TSource,TKey>(IQueryable<TSource>, Expression<
Func<TSource,TKey>>) GroupBy<TSource,TKey>(IQueryable< Agrupa os elementos de uma sequência de acordo com uma
TSource>, Expression<Func<TSource,TKey>>) função de seletor de chave especificada.
GroupBy<TSource,TKey,TElement,TResult>(IQueryable<TSource>,
Expression<Func<TSource,TKey>>,
Expression<Func<TSource,TElement>>,
Expression<Func<TKey,IEnumerable<TElement>,TResult>>,
Expression<Func<TKey,IEnumerable<TElement>,TResult>>,
resultado de cada grupo e sua chave. As chaves são comparadas usando um comparador especificado e os elementos
de cada grupo são projetados usando uma função especificada.
public static System.Linq.IQueryable<TResult> GroupBy<TSource,TKey,TElement,TResult> (this
System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,TKey>>
keySelector, System.Linq.Expressions.Expression<Func<TSource,TElement>> elementSelector,
System.Linq.Expressions.Expression<Func<TKey,System.Collections.Generic.IEnumerable<TElement>,TResul
t>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer);
static member GroupBy : System.Linq.IQueryable<'Source> *
System.Linq.Expressions.Expression<Func<'Source, 'Key>> *
System.Linq.Expressions.Expression<Func<'Source, 'Element>> *
System.Linq.Expressions.Expression<Func<'Key, seq<'Element>, 'Result>> *
System.Collections.Generic.IEqualityComparer<'Key> -> System.Linq.IQueryable<'Result>
Type Parameters
TSource
TKey
O tipo da chave retornada pela função representada em keySelector .
TElement
TResult
Parameters
Um IQueryable<T> cujos elementos serão agrupados.
keySelector Expression<Func<TSource,TKey>>
elementSelector Expression<Func<TSource,TElement>>
resultSelector Expression<Func<TKey,IEnumerable<TElement>,TResult>>
Returns
IQueryable<TResult>
Um T:System.Linq.IQueryable`1 que tem um argumento de tipo de TResult e no qual cada elemento representa
uma projeção sobre um grupo e sua chave.
Exceptions
source ou keySelector ou elementSelector ou resultSelector ou comparer é null .
Remarks
O GroupBy<TSource,TKey,TElement,TResult>(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
IEqualityComparer<TKey>) método gera uma MethodCallExpression que representa a chamada
IEqualityComparer<TKey>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada GroupBy<TSource,TKey,TElement,TResult>(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
IEqualityComparer<TKey>) depende da implementação do tipo do source parâmetro. O comportamento esperado é
que ela agrupa os elementos de source pelos valores de chave que são obtidos pela invocação keySelector em cada
elemento. O comparer parâmetro é usado para comparar valores de chave. O elementSelector parâmetro é usado
para projetar os elementos de cada grupo e o resultSelector parâmetro é usado para obter um valor de resultado de
cada grupo e sua chave.
resultado de cada grupo e sua chave. Os elementos de cada grupo são projetados usando uma função especificada.
public static System.Linq.IQueryable<TResult> GroupBy<TSource,TKey,TElement,TResult> (this

keySelector, System.Linq.Expressions.Expression<Func<TSource,TElement>> elementSelector,
System.Linq.Expressions.Expression<Func<TKey,System.Collections.Generic.IEnumerable<TElement>,TResul
t>> resultSelector);
System.Linq.Expressions.Expression<Func<'Key, seq<'Element>, 'Result>> ->
System.Linq.IQueryable<'Result>
Type Parameters
TSource
TKey
TElement
TResult
Parameters
resultSelector Expression<Func<TKey,IEnumerable<TElement>,TResult>>
Returns
IQueryable<TResult>
Exceptions
source ou keySelector ou elementSelector ou resultSelector é null .
Examples
O exemplo de código a seguir demonstra como usar GroupBy<TSource,TKey,TElement,TResult>
(IQueryable<TSource>, Expression<Func<TSource,TKey>>, Expression<Func<TSource,TElement>>,
Expression<Func<TKey,IEnumerable<TElement>,TResult>>) para agrupar os elementos de uma sequência e uma
sequência de resultados do tipo de projeto TResult .
class Pet
{
}

{
// Group Pet.Age values by the Math.Floor of the age.

var query = petsList.AsQueryable().GroupBy(
pet => pet.Age,
(baseAge, ages) => new
{
Key = baseAge,
Count = ages.Count(),
Min = ages.Min(),
Max = ages.Max()
});

{
Console.WriteLine("
}
Age group: 8
Minimum age: 8.3
Maximum age: 8.3
Age group: 4
Minimum age: 4.3
Maximum age: 4.9
Age group: 1
Minimum age: 1.5
Maximum age: 1.5
*/
}
Remarks
O GroupBy<TSource,TKey,TElement,TResult>(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
Expression<Func<TSource,TElement>>, Expression<Func<TKey,IEnumerable<TElement>,TResult>>) método gera
uma MethodCallExpression que representa a chamada GroupBy<TSource,TKey,TElement,TResult>
(IQueryable<TSource>, Expression<Func<TSource,TKey>>, Expression<Func<TSource,TElement>>,
Expression<Func<TKey,IEnumerable<TElement>,TResult>>) a próprio como um método genérico construído. Em
chamada GroupBy<TSource,TKey,TElement,TResult>(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
Expression<Func<TSource,TElement>>, Expression<Func<TKey,IEnumerable<TElement>,TResult>>) depende da
implementação do tipo do source parâmetro. O comportamento esperado é que ela agrupa os elementos de source
pelos valores de chave que são obtidos pela invocação keySelector em cada elemento. O elementSelector
parâmetro é usado para projetar os elementos de cada grupo e o resultSelector parâmetro é usado para obter um
public static System.Linq.IQueryable<System.Linq.IGrouping<TKey,TElement>>

GroupBy<TSource,TKey,TElement> (this System.Linq.IQueryable<TSource> source,
System.Linq.Expressions.Expression<Func<TSource,TKey>> keySelector,
System.Linq.Expressions.Expression<Func<TSource,TElement>> elementSelector);
System.Linq.Expressions.Expression<Func<'Source, 'Element>> ->
System.Linq.IQueryable<System.Linq.IGrouping<'Key, 'Element>>
Type Parameters
TSource
TKey
TElement
Parameters
Returns
IQueryable<IGrouping<TKey,TElement>>
Um IQueryable<IGrouping<TKey, TElement>> em C# ou IQueryable(Of IGrouping(Of TKey, TElement)) no
Visual Basic em que cada IGrouping<TKey,TElement> contém uma sequência de objetos de tipo TElement e uma
chave.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar GroupBy<TSource,TKey,TElement>(IQueryable<TSource>,
Expression<Func<TSource,TKey>>, Expression<Func<TSource,TElement>>) para agrupar os elementos de uma
sequência.
class Pet
{
}

{
List<Pet> pets =
// Group the pets using Pet.Age as the key.

// Use Pet.Name as the value for each entry.
pets.AsQueryable().GroupBy(pet => pet.Age, pet => pet.Name);

foreach (IGrouping<int, string> petGroup in query)
{
Console.WriteLine(petGroup.Key);
// Iterate over each value in the
// IGrouping and print the value.
foreach (string name in petGroup)
Console.WriteLine(" {0}", name);
}
}
/*
8
Barley
4
Boots
Daisy
1
Whiskers
*/
Remarks
O GroupBy<TSource,TKey,TElement>(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
Expression<Func<TSource,TElement>>) método gera uma MethodCallExpression que representa a chamada
Expression<Func<TSource,TElement>>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada GroupBy<TSource,TKey,TElement>(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
Expression<Func<TSource,TElement>>) depende da implementação do tipo do source parâmetro. O
comportamento esperado é que ela agrupa os elementos de source por um valor de chave que é obtido invocando
keySelector em cada elemento. Ele invoca elementSelector em cada elemento para obter um elemento de
resultado.
(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
Agrupa os elementos de uma sequência e projeta os elementos para cada grupo usando uma função especificada. Os
valores de chave são comparados usando um comparador especificado.
public static System.Linq.IQueryable<System.Linq.IGrouping<TKey,TElement>>

GroupBy<TSource,TKey,TElement> (this System.Linq.IQueryable<TSource> source,
System.Linq.Expressions.Expression<Func<TSource,TElement>> elementSelector,
System.Linq.IQueryable<System.Linq.IGrouping<'Key, 'Element>>
Type Parameters
TSource
TKey
TElement
Parameters
Returns
IQueryable<IGrouping<TKey,TElement>>
Um IQueryable<IGrouping<TKey, TElement>> em C# ou IQueryable(Of IGrouping(Of TKey, TElement)) no
Visual Basic em que cada IGrouping<TKey,TElement> contém uma sequência de objetos de tipo TElement e uma
chave.
Exceptions
source ou keySelector ou elementSelector ou comparer é null .
Remarks
O GroupBy<TSource,TKey,TElement>(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
Expression<Func<TSource,TElement>>, IEqualityComparer<TKey>) método gera uma MethodCallExpression que
representa a chamada GroupBy<TSource,TKey,TElement>(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
Expression<Func<TSource,TElement>>, IEqualityComparer<TKey>) a próprio como um método genérico construído.
Em seguida, ele passa a MethodCallExpression para o CreateQuery<TElement>(Expression) método da
chamada GroupBy<TSource,TKey,TElement>(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
Expression<Func<TSource,TElement>>, IEqualityComparer<TKey>) depende da implementação do tipo do source
parâmetro. O comportamento esperado é que ela agrupa os elementos de source por um valor de chave que é obtido
invocando keySelector em cada elemento. Valores de chave são comparados usando comparer . O elementSelector
parâmetro é chamado em cada elemento para obter um elemento de resultado.
resultado de cada grupo e sua chave.
public static System.Linq.IQueryable<TResult> GroupBy<TSource,TKey,TResult> (this

keySelector,
System.Linq.Expressions.Expression<Func<TKey,System.Collections.Generic.IEnumerable<TSource>,TResult
>> resultSelector);
System.Linq.Expressions.Expression<Func<'Key, seq<'Source>, 'Result>> ->
Type Parameters
TSource
TKey
TResult
Parameters
resultSelector Expression<Func<TKey,IEnumerable<TSource>,TResult>>
Returns
IQueryable<TResult>
Exceptions
source , keySelector ou resultSelector é null .
Examples
O exemplo de código a seguir demonstra como usar GroupBy<TSource,TKey,TResult>(IQueryable<TSource>,
Expression<Func<TSource,TKey>>, Expression<Func<TKey,IEnumerable<TSource>,TResult>>) para agrupar os
elementos de uma sequência e uma sequência de resultados do tipo de projeto TResult .
class Pet
{
}

{
// Group Pet objects by the Math.Floor of their age.

var query = petsList.AsQueryable().GroupBy(
(age, pets) => new
{
Key = age,
Count = pets.Count(),
Min = pets.Min(pet => pet.Age),
Max = pets.Max(pet => pet.Age)
});

{
Console.WriteLine("
}
Age group: 8
Minimum age: 8.3
Maximum age: 8.3
Age group: 4
Minimum age: 4.3
Maximum age: 4.9
Age group: 1
Minimum age: 1.5
Maximum age: 1.5
*/
}
Remarks
O GroupBy<TSource,TKey,TResult>(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
Expression<Func<TKey,IEnumerable<TSource>,TResult>>) método gera uma MethodCallExpression que representa
a chamada GroupBy<TSource,TKey,TResult>(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
Expression<Func<TKey,IEnumerable<TSource>,TResult>>) a próprio como um método genérico construído. Em
chamada GroupBy<TSource,TKey,TResult>(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
Expression<Func<TKey,IEnumerable<TSource>,TResult>>) depende da implementação do tipo do source
parâmetro. O comportamento esperado é que ela agrupa os elementos de source por um valor de chave que é obtido
invocando keySelector em cada elemento. O resultSelector parâmetro é usado para obter um valor de resultado
de cada grupo e sua chave.
Expression<Func<TKey,IEnumerable<TSource>,TResult>>,
(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
Expression<Func<TKey,IEnumerable<TSource>,TResult>>,
resultado de cada grupo e sua chave. As chaves são comparadas usando um comparador especificado.
public static System.Linq.IQueryable<TResult> GroupBy<TSource,TKey,TResult> (this
keySelector,
System.Linq.Expressions.Expression<Func<TKey,System.Collections.Generic.IEnumerable<TSource>,TResult
>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer);
System.Linq.Expressions.Expression<Func<'Key, seq<'Source>, 'Result>> *
Type Parameters
TSource
TKey
TResult
Parameters
resultSelector Expression<Func<TKey,IEnumerable<TSource>,TResult>>
Returns
IQueryable<TResult>
Exceptions
source ou keySelector ou resultSelector ou comparer é null .
Remarks
O GroupBy<TSource,TKey,TResult>(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
Expression<Func<TKey,IEnumerable<TSource>,TResult>>, IEqualityComparer<TKey>) método gera uma
MethodCallExpression que representa a chamada GroupBy<TSource,TKey,TResult>(IQueryable<TSource>,
Expression<Func<TSource,TKey>>, Expression<Func<TKey,IEnumerable<TSource>,TResult>>,
IEqualityComparer<TKey>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada GroupBy<TSource,TKey,TResult>(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
Expression<Func<TKey,IEnumerable<TSource>,TResult>>, IEqualityComparer<TKey>) depende da implementação
do tipo do source parâmetro. O comportamento esperado é que ela agrupa os elementos de source pelos valores de
chave que são obtidos pela invocação keySelector em cada elemento. O comparer parâmetro é usado para comparar
as chaves e o resultSelector parâmetro é usado para obter um valor de resultado de cada grupo e sua chave.
GroupBy<TSource,TKey>(IQueryable<TSource>,
Expression<Func<TSource,TKey>>, IEqualityComparer<TKey>)
Expression<Func<TSource,TKey>>, IEqualityComparer<TKey>)
public static System.Linq.IQueryable<System.Linq.IGrouping<TKey,TSource>> GroupBy<TSource,TKey>
(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,TKey>>
keySelector, System.Collections.Generic.IEqualityComparer<TKey> comparer);
System.Linq.IQueryable<System.Linq.IGrouping<'Key, 'Source>>
Type Parameters
TSource
TKey
Parameters
Returns
IQueryable<IGrouping<TKey,TSource>>
Um IQueryable<IGrouping<TKey, TSource>> em C# ou IQueryable(Of IGrouping(Of TKey, TSource)) no Visual
Basic em que cada IGrouping<TKey,TElement> contém uma sequência de objetos e uma chave.
Exceptions
source , keySelector ou comparer é null .
Remarks
O GroupBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, IEqualityComparer<TKey>)
método gera uma MethodCallExpression que representa a chamada GroupBy<TSource,TKey>(IQueryable<TSource>,
Expression<Func<TSource,TKey>>, IEqualityComparer<TKey>) a próprio como um método genérico construído. Em
chamada GroupBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
IEqualityComparer<TKey>) depende da implementação do tipo do source parâmetro. O comportamento esperado é
que ela agrupa os elementos de source por um valor de chave. O valor da chave é obtido invocando keySelector em
cada elemento, e valores de chave são comparados usando comparer .
Expression<Func<TSource,TKey>>) GroupBy<TSource,TKey>
(IQueryable<TSource>, Expression<Func<TSource,TKey>>)
public static System.Linq.IQueryable<System.Linq.IGrouping<TKey,TSource>> GroupBy<TSource,TKey>

(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,TKey>>
keySelector);
System.Linq.Expressions.Expression<Func<'Source, 'Key>> ->
System.Linq.IQueryable<System.Linq.IGrouping<'Key, 'Source>>
Type Parameters
TSource
TKey
Parameters
Returns
IQueryable<IGrouping<TKey,TSource>>
Um IQueryable<IGrouping<TKey, TSource>> em C# ou IQueryable(Of IGrouping(Of TKey, TSource)) no Visual
Basic em que cada objeto IGrouping<TKey,TElement> contém uma sequência de objetos e uma chave.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar GroupBy<TSource,TKey>(IQueryable<TSource>,
Expression<Func<TSource,TKey>>) para agrupar os elementos de uma sequência.
class Pet
{
}

{
List<Pet> pets =
// Group the pets using Pet.Age as the key.

// Use Pet.Name as the value for each entry.
var query = pets.AsQueryable().GroupBy(pet => pet.Age);

foreach (var ageGroup in query)
{
Console.WriteLine("Age group: {0} Number of pets: {1}", ageGroup.Key, ageGroup.Count());
}
}
/*
Age group: 8 Number of pets: 1

*/
Remarks
O GroupBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>) método gera uma
MethodCallExpression que representa a chamada GroupBy<TSource,TKey>(IQueryable<TSource>,
Expression<Func<TSource,TKey>>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada GroupBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>) depende da
implementação do tipo do source parâmetro. O comportamento esperado é que ela agrupa os elementos de source
por um valor de chave que é obtido invocando keySelector em cada elemento.
Queryable.GroupJoin Queryable.GroupJoin
I n this Article
Overloads
GroupJoin<TOuter,TInner,TKey,TResult>(IQueryable<
TOuter>, IEnumerable<TInner>, Expression<Func<TOuter, Correlaciona os elementos de duas sequências com base na
TKey>>, Expression<Func<TInner,TKey>>, Expression<Func< igualdade de chaves e agrupa os resultados. O comparador de
TOuter,IEnumerable<TInner>,TResult>>) GroupJoin<TOuter, igualdade padrão é usado para comparar chaves.
TInner,TKey,TResult>(IQueryable<TOuter>, IEnumerable<
TInner>, Expression<Func<TOuter,TKey>>, Expression<
Func<TInner,TKey>>, Expression<Func<TOuter,IEnumerable<
TInner>,TResult>>)
GroupJoin<TOuter,TInner,TKey,TResult>(IQueryable<
TOuter>, IEnumerable<TInner>, Expression<Func<TOuter, Correlaciona os elementos de duas sequências com base na
TKey>>, Expression<Func<TInner,TKey>>, Expression<Func< igualdade de chaves e agrupa os resultados. Um
TOuter,IEnumerable<TInner>,TResult>>, IEqualityComparer< IEqualityComparer<T> especificado é usado para comparar
TKey>) GroupJoin<TOuter,TInner,TKey,TResult>(IQueryable< chaves.
TOuter>, IEnumerable<TInner>, Expression<Func<TOuter,
TKey>>, Expression<Func<TInner,TKey>>, Expression<Func<
TOuter,IEnumerable<TInner>,TResult>>, IEqualityComparer<
TKey>)
GroupJoin<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>,
IEnumerable<TInner>, Expression<Func<TOuter,TKey>>,
Expression<Func<TInner,TKey>>,
public static System.Linq.IQueryable<TResult> GroupJoin<TOuter,TInner,TKey,TResult> (this
System.Linq.IQueryable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner,
System.Linq.Expressions.Expression<Func<TOuter,TKey>> outerKeySelector,
System.Linq.Expressions.Expression<Func<TInner,TKey>> innerKeySelector,
System.Linq.Expressions.Expression<Func<TOuter,System.Collections.Generic.IEnumerable<TInner>,TResul
t>> resultSelector);
static member GroupJoin : System.Linq.IQueryable<'Outer> * seq<'Inner> *
System.Linq.Expressions.Expression<Func<'Outer, 'Key>> *
System.Linq.Expressions.Expression<Func<'Inner, 'Key>> *
System.Linq.Expressions.Expression<Func<'Outer, seq<'Inner>, 'Result>> ->
Type Parameters
TOuter
TInner
TKey
TResult
Parameters
outer IQueryable<TOuter>
outerKeySelector Expression<Func<TOuter,TKey>>
innerKeySelector Expression<Func<TInner,TKey>>
resultSelector Expression<Func<TOuter,IEnumerable<TInner>,TResult>>
Returns
IQueryable<TResult>
Um IQueryable<T> que contém elementos do tipo TResult obtidos pela execução de uma junção agrupada em duas
sequências.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar GroupJoin<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>,
IEnumerable<TInner>, Expression<Func<TOuter,TKey>>, Expression<Func<TInner,TKey>>,
Expression<Func<TOuter,IEnumerable<TInner>,TResult>>) para realizar uma junção agrupada em duas sequências.
class Person
{
}
class Pet
{
}
public static void GroupJoinEx1()

{


// Create a list where each element is an anonymous

// type that contains a person's name and a collection
// of names of the pets that are owned by them.
var query =
people.AsQueryable().GroupJoin(pets,
person => person,
pet => pet.Owner,
(person, petCollection) =>
new
{
OwnerName = person.Name,
Pets = petCollection.Select(pet => pet.Name)
});

{
// Output the owner's name.
Console.WriteLine("{0}:", obj.OwnerName);
// Output each of the owner's pet's names.
foreach (string pet in obj.Pets)
Console.WriteLine(" {0}", pet);
}
}
/*
Hedlund, Magnus:
Daisy
Adams, Terry:
Barley
Boots
Weiss, Charlotte:
Whiskers
*/
Remarks
O GroupJoin<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>, IEnumerable<TInner>,
Expression<Func<TOuter,IEnumerable<TInner>,TResult>>) método gera uma MethodCallExpression que representa
a chamada GroupJoin<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>, IEnumerable<TInner>,
Expression<Func<TOuter,IEnumerable<TInner>,TResult>>) a próprio como um método genérico construído. Em
representado pela Provider propriedade do outer parâmetro.
chamada GroupJoin<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>, IEnumerable<TInner>,
Expression<Func<TOuter,IEnumerable<TInner>,TResult>>) depende da implementação do tipo do outer parâmetro.
O comportamento esperado é que o outerKeySelector e innerKeySelector funções são usadas para extrair as
chaves de outer e inner , respectivamente. Essas chaves são comparadas quanto à igualdade corresponder a cada
elemento na outer com zero ou mais elementos de inner . Em seguida, a resultSelector função é invocada para
projetar um objeto de resultado de cada grupo de elementos correlacionados.
Expression<Func<TOuter,IEnumerable<TInner>,TResult>>,
Expression<Func<TOuter,IEnumerable<TInner>,TResult>>,
public static System.Linq.IQueryable<TResult> GroupJoin<TOuter,TInner,TKey,TResult> (this

System.Linq.Expressions.Expression<Func<TOuter,System.Collections.Generic.IEnumerable<TInner>,TResul
t>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer);
static member GroupJoin : System.Linq.IQueryable<'Outer> * seq<'Inner> *
System.Linq.Expressions.Expression<Func<'Outer, seq<'Inner>, 'Result>> *
Type Parameters
TOuter
TInner
TKey
TResult
Parameters
resultSelector Expression<Func<TOuter,IEnumerable<TInner>,TResult>>
Um comparador para executar hash e comparar chaves.
Returns
IQueryable<TResult>
Um IQueryable<T> que contém elementos do tipo TResult obtidos pela execução de uma junção agrupada em duas
sequências.
Exceptions
Remarks
O GroupJoin<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>, IEnumerable<TInner>,
Expression<Func<TOuter,IEnumerable<TInner>,TResult>>, IEqualityComparer<TKey>) método gera uma
MethodCallExpression que representa a chamada GroupJoin<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>,
Expression<Func<TOuter,IEnumerable<TInner>,TResult>>, IEqualityComparer<TKey>) a próprio como um método
método da IQueryProvider representado pela Provider propriedade do outer parâmetro.
chamada GroupJoin<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>, IEnumerable<TInner>,
Expression<Func<TOuter,IEnumerable<TInner>,TResult>>, IEqualityComparer<TKey>) depende da implementação
do tipo do outer parâmetro. O comportamento esperado é que o outerKeySelector e innerKeySelector funções
são usadas para extrair as chaves de outer e inner , respectivamente. Essas chaves são comparadas quanto à
igualdade usando comparer . O resultado das comparações é usado para corresponder cada elemento na outer com
zero ou mais elementos de inner . Em seguida, a resultSelector função é invocada para projetar um objeto de
resultado de cada grupo de elementos correlacionados.
Queryable.Intersect Queryable.Intersect
I n this Article
Overloads
Intersect<TSource>(IQueryable<TSource>, IEnumerable<
TSource>) Intersect<TSource>(IQueryable<TSource>, Produz a interseção de conjunto de duas sequências usando o
Intersect<TSource>(IQueryable<TSource>, IEnumerable<
TSource>, IEqualityComparer<TSource>) Intersect<TSource>( Produz a interseção de conjunto de duas sequências usando o
IQueryable<TSource>, IEnumerable<TSource>, IEquality IEqualityComparer<T> especificado para comparar os valores.
Comparer<TSource>)
Intersect<TSource>(IQueryable<TSource>,
(IQueryable<TSource>, IEnumerable<TSource>)
valores.
public static System.Linq.IQueryable<TSource> Intersect<TSource> (this
System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2);
static member Intersect : System.Linq.IQueryable<'Source> * seq<'Source> ->
Type Parameters
TSource
Parameters
Uma sequência cujos elementos distintos que também aparecem em source2 são retornados.
Uma sequência cujos elementos distintos que também aparecem na primeira sequência são retornados.
Returns
IQueryable<TSource>
Uma sequência que contém a interseção de conjunto das duas sequências.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Intersect<TSource>(IQueryable<TSource>,
IEnumerable<TSource>) para retornar os elementos que aparecem em cada uma das duas sequências.
int[] id1 = { 44, 26, 92, 30, 71, 38 };
int[] id2 = { 39, 59, 83, 47, 26, 4, 30 };
// Get the numbers that occur in both arrays (id1 and id2).
IEnumerable<int> both = id1.AsQueryable().Intersect(id2);
foreach (int id in both)

Console.WriteLine(id);
/*
26
30
*/
Remarks
O Intersect<TSource>(IQueryable<TSource>, IEnumerable<TSource>) método gera uma MethodCallExpression que
representa a chamada Intersect<TSource>(IQueryable<TSource>, IEnumerable<TSource>) a próprio como um
método genérico construído. Em seguida, ele passa a MethodCallExpression para o CreateQuery<TElement>
(Expression) método da IQueryProvider representado pela Provider propriedade do source1 parâmetro.
chamada Intersect<TSource>(IQueryable<TSource>, IEnumerable<TSource>) depende da implementação do tipo do
source1 parâmetro. O comportamento esperado é que todos os elementos em source1 que também estejam no
source2 são retornados.
Produz a interseção de conjunto de duas sequências usando o IEqualityComparer<T> especificado para comparar os
valores.
public static System.Linq.IQueryable<TSource> Intersect<TSource> (this
System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2,
static member Intersect : System.Linq.IQueryable<'Source> * seq<'Source> *
Type Parameters
TSource
Parameters
Um IQueryable<T> cujos elementos distintos que também aparecem em source2 são retornados.
Um IEnumerable<T> cujos elementos distintos que também aparecem na primeira sequência são retornados.
Returns
IQueryable<TSource>
Um IQueryable<T> que contém a interseção de conjunto de duas sequências.
Exceptions
Remarks
O Intersect<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) método gera
uma MethodCallExpression que representa a chamada Intersect<TSource>(IQueryable<TSource>,
chamada Intersect<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
depende da implementação do tipo do source1 parâmetro. O comportamento esperado é que todos os elementos em
source1 que também estejam no source2 são retornados. O comparer parâmetro é usado para comparar elementos.
Queryable.Join Queryable.Join
I n this Article
Overloads
Join<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>,
IEnumerable<TInner>, Expression<Func<TOuter,TKey>>, Correlaciona os elementos de duas sequências com base em
Expression<Func<TInner,TKey>>, Expression<Func<TOuter, chaves de correspondência. O comparador de igualdade
TInner,TResult>>) Join<TOuter,TInner,TKey,TResult>( padrão é usado para comparar chaves.
IQueryable<TOuter>, IEnumerable<TInner>, Expression<
Func<TOuter,TKey>>, Expression<Func<TInner,TKey>>,
Expression<Func<TOuter,TInner,TResult>>)
IEnumerable<TInner>, Expression<Func<TOuter,TKey>>, Correlaciona os elementos de duas sequências com base em
Expression<Func<TInner,TKey>>, Expression<Func<TOuter, chaves de correspondência. Um IEqualityComparer<T>
TInner,TResult>>, IEqualityComparer<TKey>) Join<TOuter, especificado é usado para comparar chaves.
TInner,TKey,TResult>(IQueryable<TOuter>, IEnumerable<
TInner>, Expression<Func<TOuter,TKey>>, Expression<
Func<TInner,TKey>>, Expression<Func<TOuter,TInner,
TResult>>, IEqualityComparer<TKey>)
Correlaciona os elementos de duas sequências com base em chaves de correspondência. O comparador de igualdade
padrão é usado para comparar chaves.
public static System.Linq.IQueryable<TResult> Join<TOuter,TInner,TKey,TResult> (this
System.Linq.Expressions.Expression<Func<TOuter,TInner,TResult>> resultSelector);
static member Join : System.Linq.IQueryable<'Outer> * seq<'Inner> *
System.Linq.Expressions.Expression<Func<'Outer, 'Inner, 'Result>> -> System.Linq.IQueryable<'Result>
Type Parameters
TOuter
TInner
TKey
TResult
Parameters
resultSelector Expression<Func<TOuter,TInner,TResult>>
Returns
IQueryable<TResult>
Um IQueryable<T> com elementos do tipo TResult obtidos pela execução de uma junção interna em duas
sequências.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Join<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>,
Expression<Func<TOuter,TInner,TResult>>) para realizar uma junção interna de duas sequências com base em uma
chave comum.
class Person
{
}
class Pet
{
}
public static void JoinEx1()

{


// Join the list of Person objects and the list of Pet objects
// to create a list of person-pet pairs where each element is
// an anonymous type that contains the name of pet and the name
// of the person that owns the pet.
var query = people.AsQueryable().Join(pets,
person => person,
pet => pet.Owner,
(person, pet) =>
new { OwnerName = person.Name, Pet = pet.Name });

{
Console.WriteLine(
"{0} - {1}",
obj.OwnerName,
obj.Pet);
}
}
/*
Hedlund, Magnus - Daisy

Adams, Terry - Barley
Adams, Terry - Boots
Weiss, Charlotte - Whiskers
*/
Remarks
O Join<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>, IEnumerable<TInner>,
método gera uma MethodCallExpression que representa a chamada Join<TOuter,TInner,TKey,TResult>
(IQueryable<TOuter>, IEnumerable<TInner>, Expression<Func<TOuter,TKey>>, Expression<Func<TInner,TKey>>,
Expression<Func<TOuter,TInner,TResult>>) a próprio como um método genérico construído. Em seguida, ele passa a
Provider propriedade do outer parâmetro.
chamada Join<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>, IEnumerable<TInner>,
depende da implementação do tipo do outer parâmetro. O comportamento esperado é de uma junção interna. O
outerKeySelector e innerKeySelector funções são usadas para extrair as chaves de outer e inner ,
respectivamente. Essas chaves são comparadas quanto à igualdade corresponder os elementos de cada sequência. Um
par de elementos é armazenado para cada elemento na inner que corresponde a um elemento em outer . Em
seguida, a resultSelector função é invocada para projetar um objeto de resultado de cada par de elementos
correspondentes.
Expression<Func<TOuter,TInner,TResult>>,
IEqualityComparer<TKey>) Join<TOuter,TInner,TKey,TResult>
(IQueryable<TOuter>, IEnumerable<TInner>,
Expression<Func<TOuter,TKey>>,
Expression<Func<TOuter,TInner,TResult>>,
Correlaciona os elementos de duas sequências com base em chaves de correspondência. Um IEqualityComparer<T>
especificado é usado para comparar chaves.
public static System.Linq.IQueryable<TResult> Join<TOuter,TInner,TKey,TResult> (this
System.Linq.Expressions.Expression<Func<TOuter,TInner,TResult>> resultSelector,
static member Join : System.Linq.IQueryable<'Outer> * seq<'Inner> *
System.Linq.Expressions.Expression<Func<'Outer, 'Inner, 'Result>> *
Type Parameters
TOuter
TInner
TKey
TResult
Parameters
resultSelector Expression<Func<TOuter,TInner,TResult>>
Returns
IQueryable<TResult>
Um IQueryable<T> com elementos do tipo TResult obtidos pela execução de uma junção interna em duas
sequências.
Exceptions
Remarks
O Join<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>, IEnumerable<TInner>,
IEqualityComparer<TKey>) método gera uma MethodCallExpression que representa a chamada
Join<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>, IEnumerable<TInner>, Expression<Func<TOuter,TKey>>,
Expression<Func<TInner,TKey>>, Expression<Func<TOuter,TInner,TResult>>, IEqualityComparer<TKey>) a próprio
como um método genérico construído. Em seguida, ele passa a MethodCallExpression para o
CreateQuery<TElement>(Expression) método da IQueryProvider representado pela Provider propriedade do outer
parâmetro.
chamada Join<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>, IEnumerable<TInner>,
IEqualityComparer<TKey>) depende da implementação do tipo do outer parâmetro. O comportamento esperado é
de uma junção interna. O outerKeySelector e innerKeySelector funções são usadas para extrair as chaves de
outer e inner , respectivamente. Essas chaves são comparadas quanto à igualdade usando comparer . O resultado
das comparações é usado para criar um par correspondente para cada elemento na inner que corresponde a um
elemento em outer . Em seguida, a resultSelector função é invocada para projetar um objeto de resultado de cada
par de elementos correspondentes.
Queryable.Last Queryable.Last
I n this Article
Overloads
Last<TSource>(IQueryable<TSource>) Last<TSource>(
IQueryable<TSource>) Retorna o último elemento em uma sequência.
Last<TSource>(IQueryable<TSource>, Expression<Func<
TSource,Boolean>>) Last<TSource>(IQueryable<TSource>, Retorna o último elemento de uma sequência que satisfaz
Expression<Func<TSource,Boolean>>) uma condição especificada.
Last<TSource>(IQueryable<TSource>) Last<TSource>
Retorna o último elemento em uma sequência.
public static TSource Last<TSource> (this System.Linq.IQueryable<TSource> source);
static member Last : System.Linq.IQueryable<'Source> -> 'Source
Type Parameters
TSource
Parameters
Um IQueryable<T> do qual o último elemento será retornado.
Returns
TSource TSource
O valor na última posição no source .
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Last<TSource>(IQueryable<TSource>) para retornar o último
int[] numbers = { 9, 34, 65, 92, 87, 435, 3, 54,
83, 23, 87, 67, 12, 19 };
int last = numbers.AsQueryable().Last();
/*
19
*/
Remarks
O Last<TSource>(IQueryable<TSource>) método gera uma MethodCallExpression que representa a chamada
Last<TSource>(IQueryable<TSource>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Last<TSource>(IQueryable<TSource>) depende da implementação do tipo do source parâmetro. O
comportamento esperado é que ele retorna o último elemento em source .
Last<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) Last<TSource>
public static TSource Last<TSource> (this System.Linq.IQueryable<TSource> source,
static member Last : System.Linq.IQueryable<'Source> *
Type Parameters
TSource
Parameters
Returns
TSource TSource
O último elemento em source aprovado no teste especificado por predicate .
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Last<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) para retornar o último elemento de uma matriz que satisfaz uma condição.
int[] numbers = { 9, 34, 65, 92, 87, 435, 3, 54,
83, 23, 87, 67, 12, 19 };
// Get the last number in the array that is greater than 80.
int last = numbers.AsQueryable().Last(num => num > 80);
/*
87
*/
Remarks
O Last<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) método gera uma
MethodCallExpression que representa a chamada Last<TSource>(IQueryable<TSource>,
chamada Last<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) depende da implementação
do tipo do source parâmetro. O comportamento esperado é que ele retorna o último elemento em source que
satisfaz a condição especificada pelo predicate .
Queryable.LastOrDefault Queryable.LastOrDefault
I n this Article
Overloads
LastOrDefault<TSource>(IQueryable<TSource>, Expression<
Func<TSource,Boolean>>) LastOrDefault<TSource>( Retorna o último elemento de uma sequência que satisfaz
IQueryable<TSource>, Expression<Func<TSource,Boolean>>) uma condição ou um valor padrão, caso esse elemento não
seja encontrado.
LastOrDefault<TSource>(IQueryable<TSource>) LastOr
Default<TSource>(IQueryable<TSource>) Retorna o último elemento de uma sequência ou um valor
LastOrDefault<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) LastOrDefault<TSource>
seja encontrado.
public static TSource LastOrDefault<TSource> (this System.Linq.IQueryable<TSource> source,
static member LastOrDefault : System.Linq.IQueryable<'Source> *
Type Parameters
TSource
Parameters
Returns
TSource TSource
default ( TSource ) se source for vazio ou se nenhum elemento for aprovado no teste na função de predicado; caso
contrário, o último elemento de source aprovado no teste na função de predicado.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar LastOrDefault<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) , passando um predicado. A segunda chamada para o método, há nenhum
elemento na sequência que satisfaz a condição.
double[] numbers = { 49.6, 52.3, 51.0, 49.4, 50.2, 48.3 };
// Get the last number in the array that rounds to 50.0,

// or else the default value for type double (0.0).
double last50 =
numbers.AsQueryable().LastOrDefault(n => Math.Round(n) == 50.0);
Console.WriteLine("The last number that rounds to 50 is {0}.", last50);
// Get the last number in the array that rounds to 40.0,

// or else the default value for type double (0.0).
double last40 =
numbers.AsQueryable().LastOrDefault(n => Math.Round(n) == 40.0);
Console.WriteLine(
"The last number that rounds to 40 is {0}.",
last40 == 0.0 ? "[DOES NOT EXIST]" : last40.ToString());
/*
The last number that rounds to 50 is 50.2.

The last number that rounds to 40 is [DOES NOT EXIST].
*/
Remarks
O LastOrDefault<TSource>(IQueryable<TSource>) método gera uma MethodCallExpression que representa a
chamada LastOrDefault<TSource>(IQueryable<TSource>) a próprio como um método genérico construído. Em
chamada LastOrDefault<TSource>(IQueryable<TSource>) depende da implementação do tipo do source parâmetro.
O comportamento esperado é que ele retorna o último elemento em source que satisfaz a condição especificada pelo
predicate . Ele retorna um valor padrão se não houver nenhum tal elemento no source .
public static TSource LastOrDefault<TSource> (this System.Linq.IQueryable<TSource> source);

static member LastOrDefault : System.Linq.IQueryable<'Source> -> 'Source
Type Parameters
TSource
Parameters
Um IQueryable<T> do qual o último elemento será retornado.
Returns
TSource TSource
default ( TSource ) se source estiver vazio; caso contrário, o último elemento em source .
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar LastOrDefault<TSource>(IQueryable<TSource>) em uma matriz
vazia.
// Create an empty array.
string[] fruits = { };
// Get the last item in the array, or else the default

// value for type string (null).
string last = fruits.AsQueryable().LastOrDefault();
Console.WriteLine(
String.IsNullOrEmpty(last) ? "[STRING IS NULL OR EMPTY]" : last);
/*
[STRING IS NULL OR EMPTY]

*/
você deseja usar, se a coleção está vazia. Em seguida, chame Last<TSource>(IQueryable<TSource>) para obter o
último elemento. O exemplo de código a seguir usa ambas as técnicas para obter um valor padrão de 1, se uma
coleção de numéricos dias do mês está vazia. Como o valor padrão para um número inteiro é 0, o que não
corresponde a qualquer dia do mês, o valor padrão deve ser especificado como 1 em vez disso. A primeira variável de
resultado é verificada para o valor padrão não desejados depois que a consulta for concluída. A segunda variável de
resultado é obtida chamando DefaultIfEmpty<TSource>(IQueryable<TSource>, TSource) para especificar um valor
padrão de 1.
List<int> daysOfMonth = new List<int> { };

int lastDay1 = daysOfMonth.AsQueryable().LastOrDefault();
if (lastDay1 == 0)
{
lastDay1 = 1;
}

int lastDay2 = daysOfMonth.AsQueryable().DefaultIfEmpty(1).Last();
/*

*/
Remarks
O LastOrDefault<TSource>(IQueryable<TSource>) método gera uma MethodCallExpression que representa a
chamada LastOrDefault<TSource>(IQueryable<TSource>) a próprio como um método genérico construído. Em
chamada LastOrDefault<TSource>(IQueryable<TSource>) depende da implementação do tipo do source parâmetro.
O comportamento esperado é que ele retorna o último elemento em source , ou um valor padrão se source está
vazio.
O LastOrDefault método não fornece uma maneira de especificar um valor padrão. Se você quiser especificar um valor
padrão diferente de default(TSource) , use o DefaultIfEmpty<TSource>(IQueryable<TSource>, TSource) método
conforme descrito na seção de exemplo.
Queryable.LongCount Queryable.LongCount
I n this Article
Overloads
LongCount<TSource>(IQueryable<TSource>) LongCount<
TSource>(IQueryable<TSource>) Retorna um Int64 que representa o número total de
LongCount<TSource>(IQueryable<TSource>, Expression<
Func<TSource,Boolean>>) LongCount<TSource>( Retorna um Int64 que representa o número de elementos em
IQueryable<TSource>, Expression<Func<TSource,Boolean>>) uma sequência que atendem a uma condição.
public static long LongCount<TSource> (this System.Linq.IQueryable<TSource> source);
static member LongCount : System.Linq.IQueryable<'Source> -> int64
Type Parameters
TSource
Parameters
Returns
Int64 Int64
O número de elementos em source .
Exceptions
source é null .
O número de elementos excede MaxValue.
Examples
O exemplo de código a seguir demonstra como usar LongCount<TSource>(IQueryable<TSource>) para contar os
long count = fruits.AsQueryable().LongCount();
Console.WriteLine("There are {0} fruits in the collection.", count);
/*
There are 6 fruits in the collection.

*/
Remarks
O LongCount<TSource>(IQueryable<TSource>) método gera uma MethodCallExpression que representa a chamada
LongCount<TSource>(IQueryable<TSource>) a próprio como um método genérico construído. Em seguida, ele passa
a MethodCallExpression para o Execute<TResult>(Expression) método da IQueryProvider representado pela Provider
chamada LongCount<TSource>(IQueryable<TSource>) depende da implementação do tipo do source parâmetro. O
comportamento esperado é que ela conta o número de itens na source e retorna um Int64.
LongCount<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) LongCount<TSource>
Retorna um Int64 que representa o número de elementos em uma sequência que atendem a uma condição.
public static long LongCount<TSource> (this System.Linq.IQueryable<TSource> source,
static member LongCount : System.Linq.IQueryable<'Source> *
System.Linq.Expressions.Expression<Func<'Source, bool>> -> int64
Type Parameters
TSource
Parameters
Returns
Int64 Int64
O número de elementos em source que atendem à condição na função de predicado.
Exceptions
O número de elementos correspondentes excede MaxValue.
Examples
O exemplo de código a seguir demonstra como usar LongCount<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) para contar os elementos em uma matriz que satisfazem uma condição.
class Pet
{
}
public static void LongCountEx2()

{
const int Age = 3;
// Count the number of Pet objects where Pet.Age is greater than 3.

long count = pets.AsQueryable().LongCount(pet => pet.Age > Age);
Console.WriteLine("There are {0} animals over age {1}.", count, Age);

}
/*
There are 2 animals over age 3.

*/
Remarks
O LongCount<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) método gera uma
MethodCallExpression que representa a chamada LongCount<TSource>(IQueryable<TSource>,
chamada LongCount<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) depende da
implementação do tipo do source parâmetro. O comportamento esperado é que ela conta o número de itens na
source que satisfazem a condição especificada por predicate e retorna um Int64.
Queryable.Max Queryable.Max
I n this Article
Overloads
Max<TSource,TResult>(IQueryable<TSource>, Expression<
Func<TSource,TResult>>) Max<TSource,TResult>( Invoca uma função de projeção em cada elemento de um
IQueryable<TSource>, Expression<Func<TSource,TResult>>) IQueryable<T> genérico e retorna o valor resultante máximo.
Max<TSource>(IQueryable<TSource>) Max<TSource>(
IQueryable<TSource>) Retorna o valor máximo em um IQueryable<T> genérico.
Max<TSource,TResult>(IQueryable<TSource>,
Expression<Func<TSource,TResult>>) Max<TSource,TResult>
(IQueryable<TSource>, Expression<Func<TSource,TResult>>)
máximo.
public static TResult Max<TSource,TResult> (this System.Linq.IQueryable<TSource> source,
System.Linq.Expressions.Expression<Func<TSource,TResult>> selector);
static member Max : System.Linq.IQueryable<'Source> *
System.Linq.Expressions.Expression<Func<'Source, 'Result>> -> 'Result
Type Parameters
TSource
TResult
O tipo do valor retornado pela função representada por selector .
Parameters
Uma sequência de valores da qual será determinado o valor máximo.
selector Expression<Func<TSource,TResult>>
Returns
TResult TResult
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Max<TSource,TResult>(IQueryable<TSource>,
Expression<Func<TSource,TResult>>) para determinar o valor máximo em uma sequência de valores projetados.
class Pet
{
}

{
// Add Pet.Age to the length of Pet.Name

// to determine the "maximum" Pet object in the array.
int max =
pets.AsQueryable().Max(pet => pet.Age + pet.Name.Length);
Console.WriteLine(
max);
}
/*

*/
Remarks
O Max<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,TResult>>) método gera uma
MethodCallExpression que representa a chamada Max<TSource,TResult>(IQueryable<TSource>,
Expression<Func<TSource,TResult>>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Max<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,TResult>>) depende da
implementação do tipo do source parâmetro. O comportamento esperado é que ela invoca selector em cada
elemento em source e retorna o valor máximo.
Max<TSource>(IQueryable<TSource>) Max<TSource>
Retorna o valor máximo em um IQueryable<T> genérico.
public static TSource Max<TSource> (this System.Linq.IQueryable<TSource> source);
static member Max : System.Linq.IQueryable<'Source> -> 'Source
Type Parameters
TSource
Parameters
Uma sequência de valores da qual será determinado o valor máximo.
Returns
TSource TSource
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Max<TSource>(IQueryable<TSource>) para determinar o valor
long max = longs.AsQueryable().Max();
/*

*/
Remarks
O Max<TSource>(IQueryable<TSource>) método gera uma MethodCallExpression que representa a chamada
Max<TSource>(IQueryable<TSource>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Max<TSource>(IQueryable<TSource>) depende da implementação do tipo do source parâmetro. O
comportamento esperado é que ele retorna o valor máximo na source .
Queryable.Min Queryable.Min
I n this Article
Overloads
Min<TSource,TResult>(IQueryable<TSource>, Expression<
Func<TSource,TResult>>) Min<TSource,TResult>(IQueryable< Invoca uma função de projeção em cada elemento de um
TSource>, Expression<Func<TSource,TResult>>) IQueryable<T> genérico e retorna o valor resultante mínimo.
Min<TSource>(IQueryable<TSource>) Min<TSource>(
IQueryable<TSource>) Retorna o valor mínimo de um IQueryable<T> genérico.
Min<TSource,TResult>(IQueryable<TSource>,
Expression<Func<TSource,TResult>>) Min<TSource,TResult>
mínimo.
public static TResult Min<TSource,TResult> (this System.Linq.IQueryable<TSource> source,
System.Linq.Expressions.Expression<Func<TSource,TResult>> selector);
static member Min : System.Linq.IQueryable<'Source> *
System.Linq.Expressions.Expression<Func<'Source, 'Result>> -> 'Result
Type Parameters
TSource
TResult
Parameters
Uma sequência de valores para determinar o mínimo.
Returns
TResult TResult
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Min<TSource,TResult>(IQueryable<TSource>,
Expression<Func<TSource,TResult>>) para determinar o valor mínimo em uma sequência de valores projetados.
class Pet
{
}

{
// Get the Pet object that has the smallest Age value.
int min = pets.AsQueryable().Min(pet => pet.Age);

}
/*

*/
Remarks
O Min<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,TResult>>) método gera uma
MethodCallExpression que representa a chamada Min<TSource,TResult>(IQueryable<TSource>,
chamada Min<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,TResult>>) depende da
elemento em source e retorna o valor mínimo.
Min<TSource>(IQueryable<TSource>) Min<TSource>
Retorna o valor mínimo de um IQueryable<T> genérico.
public static TSource Min<TSource> (this System.Linq.IQueryable<TSource> source);

static member Min : System.Linq.IQueryable<'Source> -> 'Source
Type Parameters
TSource
Parameters
Uma sequência de valores para determinar o mínimo.
Returns
TSource TSource
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Min<TSource>(IQueryable<TSource>) para determinar o valor
double min = doubles.AsQueryable().Min();
/*

*/
Remarks
O Min<TSource>(IQueryable<TSource>) método gera uma MethodCallExpression que representa a chamada
Min<TSource>(IQueryable<TSource>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Min<TSource>(IQueryable<TSource>) depende da implementação do tipo do source parâmetro. O
comportamento esperado é que ele retorna o valor mínimo em source .
Queryable.OfType Queryable.OfType
I n this Article
Filtra os elementos de um IQueryable com base em um tipo especificado.
public static System.Linq.IQueryable<TResult> OfType<TResult> (this System.Linq.IQueryable source);
static member OfType : System.Linq.IQueryable -> System.Linq.IQueryable<'Result>
Type Parameters
TResult
Parameters
source IQueryable IQueryable
Um IQueryable cujos elementos devem ser filtrados.
Returns
IQueryable<TResult>
Uma coleção que contém os elementos de source que tem o tipo TResult .
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar OfType para filtrar os elementos que não são do tipo
PropertyInfo de uma lista de elementos do tipo MemberInfo.
// Create a list of MemberInfo objects.
List<System.Reflection.MemberInfo> members = typeof(String).GetMembers().ToList();
// Return only those items that can be cast to type PropertyInfo.

IQueryable<System.Reflection.PropertyInfo> propertiesOnly =
members.AsQueryable().OfType<System.Reflection.PropertyInfo>();
Console.WriteLine("Members of type 'PropertyInfo' are:");

foreach (System.Reflection.PropertyInfo pi in propertiesOnly)
Console.WriteLine(pi.Name);
/*
Members of type 'PropertyInfo' are:

Chars
Length
*/
Remarks
O OfType método gera uma MethodCallExpression que representa a chamada OfType a próprio como um método
genérico construído. Em seguida, ele passa a MethodCallExpression para o CreateQuery(Expression) método da
chamada OfType depende da implementação do tipo do source parâmetro. O comportamento esperado é que ele
filtra os elementos em source que não são do tipo TResult .
Queryable.OrderBy Queryable.OrderBy
I n this Article
Overloads
OrderBy<TSource,TKey>(IQueryable<TSource>, Expression<
Func<TSource,TKey>>, IComparer<TKey>) OrderBy<TSource, Classifica os elementos de uma sequência em ordem crescente
TKey>(IQueryable<TSource>, Expression<Func<TSource, usando um comparador especificado.
TKey>>, IComparer<TKey>)
OrderBy<TSource,TKey>(IQueryable<TSource>, Expression<
Func<TSource,TKey>>) OrderBy<TSource,TKey>(IQueryable< Classifica os elementos de uma sequência em ordem crescente
TSource>, Expression<Func<TSource,TKey>>) de acordo com uma chave.
OrderBy<TSource,TKey>(IQueryable<TSource>,
Expression<Func<TSource,TKey>>, IComparer<TKey>)
public static System.Linq.IOrderedQueryable<TSource> OrderBy<TSource,TKey> (this
keySelector, System.Collections.Generic.IComparer<TKey> comparer);
static member OrderBy : System.Linq.IQueryable<'Source> *
System.Linq.Expressions.Expression<Func<'Source, 'Key>> * System.Collections.Generic.IComparer<'Key>
-> System.Linq.IOrderedQueryable<'Source>
Type Parameters
TSource
TKey
O tipo da chave retornada pela função que é representada por keySelector .
Parameters
Returns
IOrderedQueryable<TSource>
Um IOrderedQueryable<T> cujos elementos são classificados de acordo com uma chave.
Exceptions
Remarks
O OrderBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, IComparer<TKey>) método
gera uma MethodCallExpression que representa a chamada OrderBy<TSource,TKey>(IQueryable<TSource>,
Expression<Func<TSource,TKey>>, IComparer<TKey>) a próprio como um método genérico construído. Em seguida,
representado pela Provider propriedade do source parâmetro. O resultado da chamada CreateQuery<TElement>
(Expression) é convertido para o tipo IOrderedQueryable<T> e retornado.
chamada OrderBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, IComparer<TKey>)
depende da implementação do tipo do source parâmetro. O comportamento esperado é que ele classifica os
elementos de source com base na chave obtida invocando keySelector em cada elemento de source . O comparer
parâmetro é usado para comparar chaves.
Expression<Func<TSource,TKey>>) OrderBy<TSource,TKey>
(IQueryable<TSource>, Expression<Func<TSource,TKey>>)
public static System.Linq.IOrderedQueryable<TSource> OrderBy<TSource,TKey> (this
keySelector);
static member OrderBy : System.Linq.IQueryable<'Source> *
System.Linq.Expressions.Expression<Func<'Source, 'Key>> -> System.Linq.IOrderedQueryable<'Source>
Type Parameters
TSource
TKey
Parameters
Returns
Exceptions
Examples
O exemplo de código a seguir demonstra como usar OrderBy<TSource,TKey>(IQueryable<TSource>,
Expression<Func<TSource,TKey>>) para classificar os elementos de uma sequência.
class Pet
{
}
public static void OrderByEx1()

{
// Sort the Pet objects in the array by Pet.Age.

IEnumerable<Pet> query =
pets.AsQueryable().OrderBy(pet => pet.Age);
foreach (Pet pet in query)

Console.WriteLine("{0} - {1}", pet.Name, pet.Age);
}
/*
Whiskers - 1
Boots - 4
Barley - 8
*/
Remarks
O OrderBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>) método gera uma
MethodCallExpression que representa a chamada OrderBy<TSource,TKey>(IQueryable<TSource>,
Provider propriedade do source parâmetro. O resultado da chamada CreateQuery<TElement>(Expression) é
convertido para o tipo IOrderedQueryable<T> e retornado.
chamada OrderBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>) depende da
implementação do tipo do source parâmetro. O comportamento esperado é que ele classifica os elementos de
source com base na chave obtida invocando keySelector em cada elemento de source .
Queryable.OrderByDescending Queryable.OrderBy
Descending
I n this Article
Overloads
OrderByDescending<TSource,TKey>(IQueryable<TSource>,
Expression<Func<TSource,TKey>>) OrderByDescending< Classifica os elementos de uma sequência em ordem
TSource,TKey>(IQueryable<TSource>, Expression<Func< decrescente de acordo com uma chave.
TSource,TKey>>)
Expression<Func<TSource,TKey>>, IComparer<TKey>) Order Classifica os elementos de uma sequência em ordem
ByDescending<TSource,TKey>(IQueryable<TSource>, decrescente usando um comparador especificado.
Expression<Func<TSource,TKey>>)
public static System.Linq.IOrderedQueryable<TSource> OrderByDescending<TSource,TKey> (this
keySelector);
static member OrderByDescending : System.Linq.IQueryable<'Source> *
Type Parameters
TSource
TKey
Parameters
Returns
Um IOrderedQueryable<T> cujos elementos são classificados em ordem decrescente de acordo com uma chave.
Exceptions
Remarks
O OrderByDescending<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>) método gera uma
MethodCallExpression que representa a chamada OrderByDescending<TSource,TKey>(IQueryable<TSource>,
chamada OrderByDescending<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>) depende
da implementação do tipo do source parâmetro. O comportamento esperado é que ele classifica os elementos de
source em ordem decrescente, com base na chave obtida invocando keySelector em cada elemento de source .
public static System.Linq.IOrderedQueryable<TSource> OrderByDescending<TSource,TKey> (this

keySelector, System.Collections.Generic.IComparer<TKey> comparer);
static member OrderByDescending : System.Linq.IQueryable<'Source> *
Type Parameters
TSource
TKey
Parameters
Returns
Exceptions
Examples
O exemplo de código a seguir demonstra como usar OrderByDescending<TSource,TKey>(IQueryable<TSource>,
Expression<Func<TSource,TKey>>, IComparer<TKey>) para classificar os elementos de uma sequência em ordem
decrescente usando um comparador personalizado.
/// <summary>
/// This IComparer class sorts by the fractional part of the decimal number.
/// </summary>
public class SpecialComparer : IComparer<decimal>
{
/// <summary>
/// Compare two decimal numbers by their fractional parts.
/// </summary>
/// <param name="d1">The first decimal to compare.</param>
/// <param name="d2">The second decimal to compare.</param>
/// <returns>1 if the first decimal's fractional part
/// is greater than the second decimal's fractional part,
/// -1 if the first decimal's fractional
/// part is less than the second decimal's fractional part,
/// or the result of calling Decimal.Compare()
/// if the fractional parts are equal.</returns>
public int Compare(decimal d1, decimal d2)
{
decimal fractional1, fractional2;
// Get the fractional part of the first number.

try
{
}
{
fractional1 = d1;
}
// Get the fractional part of the second number.
try
{
}
{
fractional2 = d2;
}
if (fractional1 == fractional2)
return Decimal.Compare(d1, d2);
else if (fractional1 > fractional2)
return 1;
else
return -1;
}
}
public static void OrderByDescendingEx1()

{
List<decimal> decimals =
new List<decimal> { 6.2m, 8.3m, 0.5m, 1.3m, 6.3m, 9.7m };
// Sort the decimal values in descending order

// by using a custom comparer.
IEnumerable<decimal> query =
decimals.AsQueryable()
.OrderByDescending(num => num, new SpecialComparer());
foreach (decimal num in query)

}
/*
9.7
0.5
8.3
6.3
1.3
6.2
*/
Remarks
O OrderByDescending<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
IComparer<TKey>) método gera uma MethodCallExpression que representa a chamada
a próprio como um método genérico construído. Em seguida, ele passa a MethodCallExpression para o
CreateQuery<TElement>(Expression) método da IQueryProvider representado pela Provider propriedade do source
parâmetro. O resultado da chamada CreateQuery<TElement>(Expression) é convertido para o tipo
IOrderedQueryable<T> e retornado.
chamada OrderByDescending<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>,
IComparer<TKey>) depende da implementação do tipo do source parâmetro. O comportamento esperado é que ele
classifica os elementos de source em ordem decrescente, com base na chave obtida invocando keySelector em cada
elemento de source . O comparer parâmetro é usado para comparar chaves.
Queryable.Prepend Queryable.Prepend
I n this Article
public static System.Linq.IQueryable<TSource> Prepend<TSource> (this System.Linq.IQueryable<TSource>
source, TSource element);
static member Prepend : System.Linq.IQueryable<'Source> * 'Source -> System.Linq.IQueryable<'Source>
Type Parameters
TSource
Parameters
Returns
IQueryable<TSource>
Queryable.Reverse Queryable.Reverse
I n this Article
public static System.Linq.IQueryable<TSource> Reverse<TSource> (this System.Linq.IQueryable<TSource>
source);
static member Reverse : System.Linq.IQueryable<'Source> -> System.Linq.IQueryable<'Source>
Type Parameters
TSource
Parameters
Returns
IQueryable<TSource>
Um IQueryable<T> cujos elementos correspondem aos da sequência de entrada em ordem inversa.
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Reverse<TSource>(IQueryable<TSource>) para inverter a ordem
dos elementos em uma matriz.
char[] apple = { 'a', 'p', 'p', 'l', 'e' };
// Reverse the order of the characters in the collection.

IQueryable<char> reversed = apple.AsQueryable().Reverse();
foreach (char chr in reversed)

Console.Write(chr + " ");
/*
e l p p a
*/
Remarks
O Reverse<TSource>(IQueryable<TSource>) método gera uma MethodCallExpression que representa a chamada
Reverse<TSource>(IQueryable<TSource>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Reverse<TSource>(IQueryable<TSource>) depende da implementação do tipo do source parâmetro. O
comportamento esperado é que ele inverte a ordem dos elementos no source .
Queryable.Select Queryable.Select
I n this Article
Overloads
Select<TSource,TResult>(IQueryable<TSource>, Expression<
Func<TSource,Int32,TResult>>) Select<TSource,TResult>( Projeta cada elemento de uma sequência em um novo
IQueryable<TSource>, Expression<Func<TSource,Int32, formulário, incorporando o índice do elemento.
TResult>>)
Select<TSource,TResult>(IQueryable<TSource>, Expression<
Func<TSource,TResult>>) Select<TSource,TResult>( Projeta cada elemento de uma sequência em um novo
IQueryable<TSource>, Expression<Func<TSource,TResult>>) formulário.
Select<TSource,TResult>(IQueryable<TSource>,
Expression<Func<TSource,Int32,TResult>>)
Expression<Func<TSource,Int32,TResult>>)
public static System.Linq.IQueryable<TResult> Select<TSource,TResult> (this
System.Linq.IQueryable<TSource> source,
System.Linq.Expressions.Expression<Func<TSource,int,TResult>> selector);
static member Select : System.Linq.IQueryable<'Source> *
System.Linq.Expressions.Expression<Func<'Source, int, 'Result>> -> System.Linq.IQueryable<'Result>
Type Parameters
TSource
TResult
Parameters
selector Expression<Func<TSource,Int32,TResult>>
Returns
IQueryable<TResult>
Um IQueryable<T> cujos elementos são o resultado da invocação de uma função de transformação em cada elemento
de source .
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Select<TSource,TResult>(IQueryable<TSource>,
Expression<Func<TSource,Int32,TResult>>) em uma sequência de valores de projeto e usar o índice de cada elemento
no formulário projetado.
// Project an anonymous type that contains the

// index of the string in the source array, and
// a string that contains the same number of characters
// as the string's index in the source array.
var query =
fruits.AsQueryable()
.Select((fruit, index) =>
new { index, str = fruit.Substring(0, index) });

Console.WriteLine("{0}", obj);
/*
{ index = 0, str = }
{ index = 1, str = b }
{ index = 2, str = ma }
{ index = 3, str = ora }
{ index = 4, str = pass }
{ index = 5, str = grape }
*/
Remarks
O Select<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,TResult>>) método gera uma
MethodCallExpression que representa a chamada Select<TSource,TResult>(IQueryable<TSource>,
Expression<Func<TSource,Int32,TResult>>) a próprio como um método genérico construído. Em seguida, ele passa a
MethodCallExpression para o CreateQuery(Expression) método da IQueryProvider representado pela Provider
chamada Select<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,TResult>>) dependem da
elemento de source para projetá-lo em um formato diferente.
Expression<Func<TSource,TResult>>) Select<TSource,TResult>
public static System.Linq.IQueryable<TResult> Select<TSource,TResult> (this
System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,TResult>>
selector);
static member Select : System.Linq.IQueryable<'Source> *
System.Linq.Expressions.Expression<Func<'Source, 'Result>> -> System.Linq.IQueryable<'Result>
Type Parameters
TSource
TResult
Parameters
Returns
IQueryable<TResult>
Um IQueryable<T> cujos elementos são o resultado da invocação de uma função de transformação em cada elemento
de source .
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Select<TSource,TResult>(IQueryable<TSource>,
Expression<Func<TSource,TResult>>) ao projeto em uma sequência de valores.
List<int> range =
new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
// Project the square of each int value.

IEnumerable<int> squares =
range.AsQueryable().Select(x => x * x);

/*
1
4
9
16
25
36
49
64
81
100
*/
Remarks
O Select<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,TResult>>) método gera uma
MethodCallExpression que representa a chamada Select<TSource,TResult>(IQueryable<TSource>,
chamada Select<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,TResult>>) depende da
elemento de source para projetá-lo em um formato diferente.
Queryable.SelectMany Queryable.SelectMany
I n this Article
Overloads
SelectMany<TSource,TCollection,TResult>(IQueryable<
TSource>, Expression<Func<TSource,Int32,IEnumerable< Projeta cada elemento de uma sequência em um
TCollection>>>, Expression<Func<TSource,TCollection, IEnumerable<T> que incorpora o índice do elemento de
TResult>>) SelectMany<TSource,TCollection,TResult>( origem que o produziu. Uma função seletora de resultados é
IQueryable<TSource>, Expression<Func<TSource,Int32, invocada em cada elemento de cada sequência intermediária e
IEnumerable<TCollection>>>, Expression<Func<TSource, os valores resultantes são combinados em uma única
TCollection,TResult>>) sequência unidimensional e retornados.
SelectMany<TSource,TCollection,TResult>(IQueryable<
TSource>, Expression<Func<TSource,IEnumerable< Projeta cada elemento de uma sequência em um
TCollection>>>, Expression<Func<TSource,TCollection, IEnumerable<T> e invoca uma função de seletor de resultado
TResult>>) SelectMany<TSource,TCollection,TResult>( em cada elemento contido nele. Os valores resultantes de
IQueryable<TSource>, Expression<Func<TSource, cada sequência intermediária são combinados em uma única
IEnumerable<TCollection>>>, Expression<Func<TSource, sequência unidimensional e retornada.
TCollection,TResult>>)
SelectMany<TSource,TResult>(IQueryable<TSource>,
Expression<Func<TSource,Int32,IEnumerable<TResult>>>) Projeta cada elemento de uma sequência em um
SelectMany<TSource,TResult>(IQueryable<TSource>, IEnumerable<T> e combina as sequências resultantes em uma
Expression<Func<TSource,Int32,IEnumerable<TResult>>>) sequência. O índice de cada elemento de origem é usado no
formulário projetado desse elemento.
Expression<Func<TSource,IEnumerable<TResult>>>) Select Projeta cada elemento de uma sequência em um
Many<TSource,TResult>(IQueryable<TSource>, Expression< IEnumerable<T> e combina as sequências resultantes em uma
Func<TSource,IEnumerable<TResult>>>) sequência.
Projeta cada elemento de uma sequência em um IEnumerable<T> que incorpora o índice do elemento de origem que
o produziu. Uma função seletora de resultados é invocada em cada elemento de cada sequência intermediária e os
valores resultantes são combinados em uma única sequência unidimensional e retornados.
public static System.Linq.IQueryable<TResult> SelectMany<TSource,TCollection,TResult> (this
System.Linq.Expressions.Expression<Func<TSource,int,System.Collections.Generic.IEnumerable<TCollecti
on>>> collectionSelector, System.Linq.Expressions.Expression<Func<TSource,TCollection,TResult>>
resultSelector);
static member SelectMany : System.Linq.IQueryable<'Source> *
System.Linq.Expressions.Expression<Func<'Source, int, seq<'Collection>>> *
System.Linq.Expressions.Expression<Func<'Source, 'Collection, 'Result>> ->
Type Parameters
TSource
TCollection
O tipo dos elementos intermediários coletados pela função representada por collectionSelector .
TResult
Parameters
collectionSelector Expression<Func<TSource,Int32,IEnumerable<TCollection>>>
Uma função de projeção a ser aplicada a cada elemento da sequência de entrada; o segundo parâmetro dessa função
resultSelector Expression<Func<TSource,TCollection,TResult>>
Uma função de projeção a ser aplicada a cada elemento de cada sequência intermediária.
Returns
IQueryable<TResult>
Um IQueryable<T> cujos elementos são o resultado de invocar a função de projeção de um para muitos
seu elemento source correspondente para um elemento de resultado.
Exceptions
Remarks
O SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>,
Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>)
método gera uma MethodCallExpression que representa a chamada SelectMany<TSource,TCollection,TResult>
(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TCollection>>>,
Expression<Func<TSource,TCollection,TResult>>) a próprio como um método genérico construído. Em seguida, ele
passa a MethodCallExpression para o CreateQuery(Expression) método da IQueryProvider representado pela Provider
chamada SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>,
Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>)
depende da implementação do tipo do source parâmetro. O comportamento esperado é que ela invoca
collectionSelector em cada elemento de source para projetá-lo em um formulário enumerável. Cada resultado
enumerável incorpora o índice do elemento de origem. Em seguida, a função representada por resultSelector é
invocado em cada elemento em cada sequência intermediária. Os valores resultantes são concatenados em uma única
sequência unidimensional.
Expression<Func<TSource,IEnumerable<TCollection>>>,
Expression<Func<TSource,IEnumerable<TCollection>>>,
Projeta cada elemento de uma sequência em um IEnumerable<T> e invoca uma função de seletor de resultado em
cada elemento contido nele. Os valores resultantes de cada sequência intermediária são combinados em uma única
sequência unidimensional e retornada.
public static System.Linq.IQueryable<TResult> SelectMany<TSource,TCollection,TResult> (this

System.Linq.Expressions.Expression<Func<TSource,System.Collections.Generic.IEnumerable<TCollection>>
> collectionSelector, System.Linq.Expressions.Expression<Func<TSource,TCollection,TResult>>
resultSelector);
System.Linq.Expressions.Expression<Func<'Source, seq<'Collection>>> *
System.Linq.Expressions.Expression<Func<'Source, 'Collection, 'Result>> ->
Type Parameters
TSource
TCollection
O tipo dos elementos intermediários coletados pela função representada por collectionSelector .
TResult
Parameters
collectionSelector Expression<Func<TSource,IEnumerable<TCollection>>>
Uma função de projeção a ser aplicada a cada elemento da sequência de entrada.
resultSelector Expression<Func<TSource,TCollection,TResult>>
Uma função de projeção a ser aplicada a cada elemento de cada sequência intermediária.
Returns
IQueryable<TResult>
Um IQueryable<T> cujos elementos são o resultado de invocar a função de projeção de um para muitos
seu elemento source correspondente para um elemento de resultado.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar SelectMany<TSource,TCollection,TResult>
(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>,
Expression<Func<TSource,TCollection,TResult>>) para realizar uma projeção um-para-muitos em uma matriz. Este
exemplo usa uma função de seletor de resultado para manter o elemento de código-fonte que corresponde a cada
sequência intermediária no escopo para a chamada final para Select .
class PetOwner
{
public List<Pet> Pets { get; set; }
}
class Pet
{
public string Breed { get; set; }
}

{
{ new PetOwner { Name="Higa",
Pets = new List<Pet>{
new Pet { Name="Scruffy", Breed="Poodle" },
new Pet { Name="Sam", Breed="Hound" } } },
new PetOwner { Name="Ashkenazi",
new Pet { Name="Walker", Breed="Collie" },
new Pet { Name="Sugar", Breed="Poodle" } } },
new PetOwner { Name="Price",
new Pet { Name="Scratches", Breed="Dachshund" },
new Pet { Name="Diesel", Breed="Collie" } } },
new PetOwner { Name="Hines",
new Pet { Name="Dusty", Breed="Collie" } } }
};
// This query demonstrates how to obtain a sequence of

// the names of all the pets whose breed is "Collie", while
// keeping an association with the owner that owns the pet.
var query =
petOwners.AsQueryable()
// Create a sequence of ALL the Pet objects. Then
// project an anonymous type that consists of each
// Pet in the new sequence and the PetOwner object
// from the initial array that corresponds to that pet.
.SelectMany(owner => owner.Pets,
(owner, pet) => new { owner, pet })
// Filter the sequence of anonymous types to only
// keep pets whose breed is "Collie".
.Where(ownerAndPet => ownerAndPet.pet.Breed == "Collie")
// Project an anonymous type that consists
// Project an anonymous type that consists
// of the pet owner's name and the pet's name.
.Select(ownerAndPet => new
{
Owner = ownerAndPet.owner.Name,
Pet = ownerAndPet.pet.Name
});
// Print the results.

Console.WriteLine(obj);
}
{ Owner = Ashkenazi, Pet = Walker }

{ Owner = Price, Pet = Diesel }
{ Owner = Hines, Pet = Dusty }
*/
Remarks
O SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>,
Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) método
gera uma MethodCallExpression que representa a chamada SelectMany<TSource,TCollection,TResult>
(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>,
Expression<Func<TSource,TCollection,TResult>>) a próprio como um método genérico construído. Em seguida, ele
passa a MethodCallExpression para o CreateQuery(Expression) método da IQueryProvider representado pela Provider
chamada SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>,
Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) depende
da implementação do tipo do source parâmetro. O comportamento esperado é que ela invoca collectionSelector
em cada elemento de source para projetá-lo em um formulário enumerável. Em seguida, a função representada por
resultSelector é invocado em cada elemento em cada sequência intermediária. Os valores resultantes são
concatenados em uma única sequência unidimensional.
Expression<Func<TSource,Int32,IEnumerable<TResult>>>)
Expression<Func<TSource,Int32,IEnumerable<TResult>>>)
public static System.Linq.IQueryable<TResult> SelectMany<TSource,TResult> (this
System.Linq.Expressions.Expression<Func<TSource,int,System.Collections.Generic.IEnumerable<TResult>>
> selector);
System.Linq.Expressions.Expression<Func<'Source, int, seq<'Result>>> ->
Type Parameters
TSource
TResult
O tipo dos elementos da sequência retornada pela função representada por selector .
Parameters
selector Expression<Func<TSource,Int32,IEnumerable<TResult>>>
Uma função de projeção a ser aplicada a cada elemento; o segundo parâmetro dessa função representa o índice do
elemento de origem.
Returns
IQueryable<TResult>
Um IQueryable<T> cujos elementos são resultado da invocação de uma função de projeção de um para muitos em
Exceptions
Examples
O exemplo de código a seguir demonstra como usar SelectMany<TSource,TResult>(IQueryable<TSource>,
Expression<Func<TSource,Int32,IEnumerable<TResult>>>) para realizar uma projeção um-para-muitos em uma
matriz e usar o índice de cada elemento de origem.
class PetOwner
{
}

{
new PetOwner { Name="Hines, Patrick",
// For each PetOwner element in the source array,

// project a sequence of strings where each string
// consists of the index of the PetOwner element in the
// source array and the name of each pet in PetOwner.Pets.
petOwners.AsQueryable()
.SelectMany(
(petOwner, index) => petOwner.Pets.Select(pet => index + pet)
);
foreach (string pet in query)

}

//
// 0Scruffy
// 0Sam
// 1Walker
// 1Sugar
// 2Scratches
// 2Diesel
// 3Dusty
Remarks
O SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>)
método gera uma MethodCallExpression que representa a chamada SelectMany<TSource,TResult>
(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) a próprio como um método
genérico construído. Em seguida, ele passa a MethodCallExpression para o CreateQuery(Expression) método da
chamada SelectMany<TSource,TResult>(IQueryable<TSource>,
Expression<Func<TSource,Int32,IEnumerable<TResult>>>) depende da implementação do tipo do source
parâmetro. O comportamento esperado é que ela invoca selector em cada elemento de source para projetá-lo em
um formulário enumerável. Cada resultado enumerável incorpora o índice do elemento de origem. Ele, em seguida,
concatena os resultados enumeráveis em uma única sequência unidimensional.
Expression<Func<TSource,IEnumerable<TResult>>>)
Expression<Func<TSource,IEnumerable<TResult>>>)
sequência.
public static System.Linq.IQueryable<TResult> SelectMany<TSource,TResult> (this

System.Linq.Expressions.Expression<Func<TSource,System.Collections.Generic.IEnumerable<TResult>>>
selector);
System.Linq.Expressions.Expression<Func<'Source, seq<'Result>>> -> System.Linq.IQueryable<'Result>
Type Parameters
TSource
TResult
O tipo dos elementos da sequência retornada pela função representada por selector .
Parameters
selector Expression<Func<TSource,IEnumerable<TResult>>>
Returns
IQueryable<TResult>
Um IQueryable<T> cujos elementos são resultado da invocação de uma função de projeção de um para muitos em
Exceptions
Examples
O exemplo de código a seguir demonstra como usar SelectMany<TSource,TResult>(IQueryable<TSource>,
Expression<Func<TSource,IEnumerable<TResult>>>) para realizar uma projeção um-para-muitos em uma matriz.
class PetOwner
{
public List<String> Pets { get; set; }
}

{
Pets = new List<string>{ "Scratches", "Diesel" } } };
// Query using SelectMany().

petOwners.AsQueryable().SelectMany(petOwner => petOwner.Pets);
Console.WriteLine("Using SelectMany():");
// Only one foreach loop is required to iterate through the

// results because it is a one-dimensional collection.
foreach (string pet in query1)
// This code shows how to use Select() instead of SelectMany().

IEnumerable<List<String>> query2 =
petOwners.AsQueryable().Select(petOwner => petOwner.Pets);
Console.WriteLine("
Using Select():");
// Notice that two foreach loops are required to iterate through

// the results because the query returns a collection of arrays.
foreach (List<String> petList in query2)
{
foreach (string pet in petList)
{
}
}
}
/*
Using SelectMany():
Scruffy
Sam
Walker
Sugar
Scratches
Diesel
Using Select():
Scruffy
Sam
Walker
Sugar
Scratches
Diesel
*/
Remarks
O SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>)
método gera uma MethodCallExpression que representa a chamada SelectMany<TSource,TResult>
(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) a próprio como um método genérico
construído. Em seguida, ele passa a MethodCallExpression para o CreateQuery(Expression) método da IQueryProvider
chamada SelectMany<TSource,TResult>(IQueryable<TSource>,
Expression<Func<TSource,IEnumerable<TResult>>>) depende da implementação do tipo do source parâmetro. O
comportamento esperado é que ela invoca selector em cada elemento de source para projetá-lo em um formulário
enumerável. Ele, em seguida, concatena os resultados enumeráveis em uma única sequência unidimensional.
Queryable.SequenceEqual Queryable.SequenceEqual
I n this Article
Overloads
SequenceEqual<TSource>(IQueryable<TSource>,
IEnumerable<TSource>) SequenceEqual<TSource>( Determina se duas sequências são iguais usando o
IQueryable<TSource>, IEnumerable<TSource>) comparador de igualdade padrão para comparar elementos.
IEnumerable<TSource>, IEqualityComparer<TSource>) Determina se duas sequências são iguais usando um
SequenceEqual<TSource>(IQueryable<TSource>, IEqualityComparer<T> especificado para comparar elementos.
(IQueryable<TSource>, IEnumerable<TSource>)
Determina se duas sequências são iguais usando o comparador de igualdade padrão para comparar elementos.
public static bool SequenceEqual<TSource> (this System.Linq.IQueryable<TSource> source1,
System.Collections.Generic.IEnumerable<TSource> source2);
static member SequenceEqual : System.Linq.IQueryable<'Source> * seq<'Source> -> bool
Type Parameters
TSource
Parameters
Um IQueryable<T> cujos elementos são comparados com os de source2 .
Um IEnumerable<T> cujos elementos são comparados com os da primeira sequência.
Returns
Boolean Boolean
comparados como iguais; caso contrário, false .
Exceptions
Examples
O exemplo de código a seguir demonstra como usar SequenceEqual<TSource>(IQueryable<TSource>,
IEnumerable<TSource>) para determinar se duas sequências são iguais. Neste exemplo, as sequências são iguais.
class Pet
{
}

{
Pet pet1 = new Pet { Name = "Turbo", Age = 2 };
Pet pet2 = new Pet { Name = "Peanut", Age = 8 };

// Determine if the lists are equal.

bool equal = pets1.AsQueryable().SequenceEqual(pets2);
Console.WriteLine(
"The lists {0} equal.",
equal ? "are" : "are not");
}
/*
The lists are equal.

*/
O exemplo de código a seguir compara duas sequências que não são iguais.
class Pet
{
}

{
Pet pet1 = new Pet() { Name = "Turbo", Age = 2 };
Pet pet2 = new Pet() { Name = "Peanut", Age = 8 };

List<Pet> pets2 = new List<Pet> {
new Pet { Name = "Turbo", Age = 2 },
new Pet { Name = "Peanut", Age = 8 }
};
// Determine if the lists are equal.

bool equal = pets1.AsQueryable().SequenceEqual(pets2);
Console.WriteLine("The lists {0} equal.", equal ? "are" : "are NOT");

}
/*
The lists are NOT equal.

*/
Remarks
O SequenceEqual<TSource>(IQueryable<TSource>, IEnumerable<TSource>) método gera uma
MethodCallExpression que representa a chamada SequenceEqual<TSource>(IQueryable<TSource>,
IEnumerable<TSource>) a próprio como um método genérico construído. Em seguida, ele passa a
propriedade do source1 parâmetro.
chamada SequenceEqual<TSource>(IQueryable<TSource>, IEnumerable<TSource>) depende da implementação do
tipo do source1 parâmetro. O comportamento esperado é que ele determina se duas sequências de origem são
iguais.
Determina se duas sequências são iguais usando um IEqualityComparer<T> especificado para comparar elementos.
public static bool SequenceEqual<TSource> (this System.Linq.IQueryable<TSource> source1,
System.Collections.Generic.IEnumerable<TSource> source2,
static member SequenceEqual : System.Linq.IQueryable<'Source> * seq<'Source> *
Type Parameters
TSource
Parameters
Um IQueryable<T> cujos elementos são comparados com os de source2 .
Um IEnumerable<T> cujos elementos são comparados com os da primeira sequência.
Returns
Boolean Boolean
comparados como iguais; caso contrário, false .
Exceptions
Remarks
O SequenceEqual<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) método
gera uma MethodCallExpression que representa a chamada SequenceEqual<TSource>(IQueryable<TSource>,
ele passa a MethodCallExpression para o Execute<TResult>(Expression) método da IQueryProvider representado pela
Provider propriedade do source1 parâmetro.
chamada SequenceEqual<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
depende da implementação do tipo do source1 parâmetro. O comportamento esperado é que ele determina se os
dois fonte sequências são iguais usando comparer para comparar elementos.
Queryable.Single Queryable.Single
I n this Article
Overloads
Single<TSource>(IQueryable<TSource>) Single<TSource>(
IQueryable<TSource>) Retornará o único elemento de uma sequência e lançará uma
sequência.
Single<TSource>(IQueryable<TSource>, Expression<Func<
TSource,Boolean>>) Single<TSource>(IQueryable<TSource>, Retorna o único elemento de uma sequência que satisfaz uma
Expression<Func<TSource,Boolean>>) condição especificada e gera uma exceção se houver mais de
um tal elemento.
Single<TSource>(IQueryable<TSource>) Single<TSource>
sequência.
public static TSource Single<TSource> (this System.Linq.IQueryable<TSource> source);
static member Single : System.Linq.IQueryable<'Source> -> 'Source
Type Parameters
TSource
Parameters
Um IQueryable<T> do qual o único elemento será retornado.
Returns
TSource TSource
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Single<TSource>(IQueryable<TSource>) para selecionar o único
// Create two arrays.
string[] fruits2 = { "orange", "apple" };
// Get the only item in the first array.

string fruit1 = fruits1.AsQueryable().Single();
Console.WriteLine("First query: " + fruit1);
try
{
// Try to get the only item in the second array.
string fruit2 = fruits2.AsQueryable().Single();
Console.WriteLine("Second query: " + fruit2);
}
{
Console.WriteLine(
"Second query: The collection does not contain exactly one element."
);
}
/*
First query: orange

Second query: The collection does not contain exactly one element
*/
Remarks
O Single<TSource>(IQueryable<TSource>) método gera uma MethodCallExpression que representa a chamada
Single<TSource>(IQueryable<TSource>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Single<TSource>(IQueryable<TSource>) depende da implementação do tipo do source parâmetro. O
comportamento esperado é que ele retorna o único elemento no source .
Single<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) Single<TSource>
public static TSource Single<TSource> (this System.Linq.IQueryable<TSource> source,

static member Single : System.Linq.IQueryable<'Source> *
Type Parameters
TSource
Parameters
Um IQueryable<T> do qual retornar um único elemento.
Returns
TSource TSource
O único elemento da sequência de entrada que atende à condição em predicate .
Exceptions
- ou - Mais de um elemento satisfaz a condição na predicate .

Examples
O exemplo de código a seguir demonstra como usar Single<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) para selecionar o único elemento de uma matriz que satisfaz uma condição.

// Get the only string in the array whose length is greater than 10.
string fruit1 = fruits.AsQueryable().Single(fruit => fruit.Length > 10);
Console.WriteLine("First Query: " + fruit1);
try
{
// Try to get the only string in the array
// whose length is greater than 15.
string fruit2 = fruits.AsQueryable().Single(fruit => fruit.Length > 15);
Console.WriteLine("Second Query: " + fruit2);
}
{
Console.Write("Second Query: The collection does not contain ");
Console.WriteLine("exactly one element whose length is greater than 15.");
}
/*
First Query: passionfruit

Second Query: The collection does not contain exactly one
element whose length is greater than 15.
*/
Remarks
O Single<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) método gera uma
MethodCallExpression que representa a chamada Single<TSource>(IQueryable<TSource>,
chamada Single<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) depende da
implementação do tipo do source parâmetro. O comportamento esperado é que ele retorna o único elemento no
source que satisfaz a condição especificada pelo predicate .
Queryable.SingleOrDefault Queryable.SingleOrDefault
I n this Article
Overloads
SingleOrDefault<TSource>(IQueryable<TSource>) SingleOr
Default<TSource>(IQueryable<TSource>) Retorna o único elemento de uma sequência ou um valor
padrão se a sequência é vazia; esse método gera uma exceção
se há mais de um elemento na sequência.
SingleOrDefault<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) SingleOrDefault< Retorna o único elemento de uma sequência que satisfaz uma
TSource>(IQueryable<TSource>, Expression<Func<TSource, condição especificada ou um valor padrão se esse elemento
Boolean>>) não existir. Esse método lança uma exceção se mais de um
public static TSource SingleOrDefault<TSource> (this System.Linq.IQueryable<TSource> source);
static member SingleOrDefault : System.Linq.IQueryable<'Source> -> 'Source
Type Parameters
TSource
Parameters
Um IQueryable<T> do qual o único elemento será retornado.
Returns
TSource TSource
O único elemento de sequência de entrada ou default ( TSource ) se a sequência não contiver elementos.
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar SingleOrDefault<TSource>(IQueryable<TSource>) para
selecionar o único elemento de uma matriz. A segunda consulta demonstra que SingleOrDefault<TSource>
(IQueryable<TSource>) retorna um valor padrão quando a sequência não contém exatamente um elemento.
// Create two arrays. The second is empty.

string[] fruits2 = { };
// Get the only item in the first array, or else

// the default value for type string (null).
string fruit1 = fruits1.AsQueryable().SingleOrDefault();
// Get the only item in the second array, or else

// the default value for type string (null).
string fruit2 = fruits2.AsQueryable().SingleOrDefault();
Console.WriteLine("Second Query: " +
(String.IsNullOrEmpty(fruit2) ? "No such string!" : fruit2));
/*
First Query: orange

Second Query: No such string!
*/
você deseja usar, se a coleção está vazia. Em seguida, chame Single<TSource>(IQueryable<TSource>) para obter o
elemento. O exemplo de código a seguir usa ambas as técnicas para obter um valor padrão de 1, se uma coleção de
números de página está vazia. Porque o valor padrão para um número inteiro é 0, que não é um número válido de
página geralmente, o valor padrão deve ser especificado como 1 em vez disso. A primeira variável de resultado é
verificada para o valor padrão não desejados depois que a consulta for concluída. A segunda variável de resultado é
obtida chamando DefaultIfEmpty<TSource>(IQueryable<TSource>, TSource) para especificar um valor padrão de 1.
int[] pageNumbers = { };

int pageNumber1 = pageNumbers.AsQueryable().SingleOrDefault();
if (pageNumber1 == 0)
{
pageNumber1 = 1;
}

int pageNumber2 = pageNumbers.AsQueryable().DefaultIfEmpty(1).Single();
/*

*/
Remarks
O SingleOrDefault<TSource>(IQueryable<TSource>) método gera uma MethodCallExpression que representa a
chamada SingleOrDefault<TSource>(IQueryable<TSource>) a próprio como um método genérico construído. Em
chamada SingleOrDefault<TSource>(IQueryable<TSource>) depende da implementação do tipo do source
parâmetro. O comportamento esperado é que ele retorna o único elemento no source , ou um valor padrão se source
está vazio.
O SingleOrDefault método não fornece uma maneira de especificar um valor padrão. Se você quiser especificar um
valor padrão diferente de default(TSource) , use o DefaultIfEmpty<TSource>(IQueryable<TSource>, TSource)
SingleOrDefault<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) SingleOrDefault<TSource>
public static TSource SingleOrDefault<TSource> (this System.Linq.IQueryable<TSource> source,
static member SingleOrDefault : System.Linq.IQueryable<'Source> *
Type Parameters
TSource
Parameters
Um IQueryable<T> do qual retornar um único elemento.
Returns
TSource TSource
O único elemento da sequência de entrada que atende à condição em predicate ou default ( TSource ) se nenhum
elemento for encontrado.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar SingleOrDefault<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) para selecionar o único elemento de uma matriz que satisfaz uma condição. A
segunda consulta demonstra que SingleOrDefault<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) retorna um valor padrão quando a sequência não contém exatamente um
elemento que satisfaz a condição.

// Get the single string in the array whose length is greater

// than 10, or else the default value for type string (null).
string fruit1 =
fruits.AsQueryable().SingleOrDefault(fruit => fruit.Length > 10);
// Get the single string in the array whose length is greater

// than 15, or else the default value for type string (null).
string fruit2 =
fruits.AsQueryable().SingleOrDefault(fruit => fruit.Length > 15);
Console.WriteLine("Second Query: " +
(String.IsNullOrEmpty(fruit2) ? "No such string!" : fruit2));
/*
First Query: passionfruit

Second Query: No such string!
*/
Remarks
O SingleOrDefault<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) método gera uma
MethodCallExpression que representa a chamada SingleOrDefault<TSource>(IQueryable<TSource>,
chamada SingleOrDefault<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) depende da
implementação do tipo do source parâmetro. O comportamento esperado é que ele retorna o único elemento no
source que satisfaz a condição especificada pelo predicate , ou um valor padrão se não houver tal elemento.
Queryable.Skip Queryable.Skip
I n this Article
public static System.Linq.IQueryable<TSource> Skip<TSource> (this System.Linq.IQueryable<TSource>
source, int count);
static member Skip : System.Linq.IQueryable<'Source> * int -> System.Linq.IQueryable<'Source>
Type Parameters
TSource
Parameters
Um IQueryable<T> do qual os elementos serão retornados.
count Int32 Int32
Returns
IQueryable<TSource>
Um IQueryable<T> que contém elementos que ocorrem após o índice especificado na sequência de entrada.
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Skip<TSource>(IQueryable<TSource>, Int32) para ignorar um
número especificado de elementos em uma matriz classificada e retornar os elementos restantes.
int[] grades = { 59, 82, 70, 56, 92, 98, 85 };
// Sort the grades in descending order and

// get all except the first three.
grades.AsQueryable().OrderByDescending(g => g).Skip(3);
Console.WriteLine("All grades except the top three are:");

/*
All grades except the top three are:

82
70
59
56
*/
Remarks
O Skip<TSource>(IQueryable<TSource>, Int32) método gera uma MethodCallExpression que representa a chamada
Skip<TSource>(IQueryable<TSource>, Int32) a próprio como um método genérico construído. Em seguida, ele passa
a MethodCallExpression para o CreateQuery(Expression) método da IQueryProvider representado pela Provider
chamada Skip<TSource>(IQueryable<TSource>, Int32) depende da implementação do tipo do source parâmetro. O
comportamento esperado é que ela ignora os primeiros count elementos em source e retorna os elementos
restantes.
Queryable.SkipLast Queryable.SkipLast
I n this Article
public static System.Linq.IQueryable<TSource> SkipLast<TSource> (this
System.Linq.IQueryable<TSource> source, int count);
static member SkipLast : System.Linq.IQueryable<'Source> * int -> System.Linq.IQueryable<'Source>
Type Parameters
TSource
Parameters
count Int32 Int32
Returns
IQueryable<TSource>
Queryable.SkipWhile Queryable.SkipWhile
I n this Article
Overloads
SkipWhile<TSource>(IQueryable<TSource>, Expression<
Func<TSource,Boolean>>) SkipWhile<TSource>(IQueryable< Ignora elementos em uma sequência, contanto que uma
TSource>, Expression<Func<TSource,Boolean>>) condição especificada seja verdadeira e retorne os elementos
restantes.
SkipWhile<TSource>(IQueryable<TSource>, Expression<
Func<TSource,Int32,Boolean>>) SkipWhile<TSource>( Ignora elementos em uma sequência, contanto que uma
IQueryable<TSource>, Expression<Func<TSource,Int32, condição especificada seja verdadeira e retorne os elementos
Boolean>>) restantes. O índice do elemento é usado na lógica da função
de predicado.
SkipWhile<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) SkipWhile<TSource>
restantes.
public static System.Linq.IQueryable<TSource> SkipWhile<TSource> (this
System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,bool>>
predicate);
static member SkipWhile : System.Linq.IQueryable<'Source> *
System.Linq.Expressions.Expression<Func<'Source, bool>> -> System.Linq.IQueryable<'Source>
Type Parameters
TSource
Parameters
Returns
IQueryable<TSource>
Um IQueryable<T> que contém elementos de source começando no primeiro elemento na série linear não aprovada
no teste especificado por predicate .
Exceptions
Examples
O exemplo de código a seguir demonstra como usar SkipWhile<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) para ignorar os elementos de uma matriz como uma condição seja verdadeira.
int[] grades = { 59, 82, 70, 56, 92, 98, 85 };
// Get all grades less than 80 by first

// sorting the grades in descending order and then
// taking all the grades after the first grade
// that is less than 80.
grades.AsQueryable()
.OrderByDescending(grade => grade)
.SkipWhile(grade => grade >= 80);
Console.WriteLine("All grades below 80:");

/*
All grades below 80:

70
59
56
*/
Remarks
O SkipWhile<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) método gera uma
MethodCallExpression que representa a chamada SkipWhile<TSource>(IQueryable<TSource>,
chamada SkipWhile<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) depende da
implementação do tipo do source parâmetro. O comportamento esperado é que ele se aplica predicate a cada
elemento em source até encontrar um elemento para o qual predicate retorna false. Esse elemento e todos os
elementos restantes são retornados.
SkipWhile<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Int32,Boolean>>) SkipWhile<TSource>
(IQueryable<TSource>,
Expression<Func<TSource,Int32,Boolean>>)
restantes. O índice do elemento é usado na lógica da função de predicado.
public static System.Linq.IQueryable<TSource> SkipWhile<TSource> (this
System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,int,bool>>
predicate);
static member SkipWhile : System.Linq.IQueryable<'Source> *
System.Linq.Expressions.Expression<Func<'Source, int, bool>> -> System.Linq.IQueryable<'Source>
Type Parameters
TSource
Parameters
predicate Expression<Func<TSource,Int32,Boolean>>
Uma função para testar cada elemento de uma condição; o segundo parâmetro dessa função representa o índice do
elemento de origem.
Returns
IQueryable<TSource>
Um IQueryable<T> que contém elementos de source começando no primeiro elemento na série linear não aprovada
no teste especificado por predicate .
Exceptions
Examples
O exemplo de código a seguir demonstra como usar SkipWhile<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Int32,Boolean>>) para ignorar os elementos de uma matriz como uma condição que
depende do índice do elemento é verdadeira.
int[] amounts = { 5000, 2500, 9000, 8000,

6500, 4000, 1500, 5500 };
// Skip over amounts in the array until the first amount

// that is less than or equal to the product of its
// index in the array and 1000. Take the remaining items.
amounts.AsQueryable()
.SkipWhile((amount, index) => amount > index * 1000);
foreach (int amount in query)

Console.WriteLine(amount);
/*
4000
1500
5500
*/
Remarks
O SkipWhile<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32,Boolean>>) método gera uma
MethodCallExpression que representa a chamada SkipWhile<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Int32,Boolean>>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada SkipWhile<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32,Boolean>>) depende da
elemento em source até encontrar um elemento para o qual predicate retorna false. Esse elemento e todos os
elementos restantes são retornados. O índice de cada elemento de código-fonte é fornecido como o segundo
argumento para predicate .
Queryable.Sum Queryable.Sum
I n this Article
Overloads
Sum(IQueryable<Single>) Sum(IQueryable<Single>)
Sum(IQueryable<Nullable<Single>>) Sum(IQueryable<
Nullable<Single>>) Computa a soma de uma sequência de valores Single que
Sum(IQueryable<Nullable<Int64>>) Sum(IQueryable<
Sum(IQueryable<Nullable<Int32>>) Sum(IQueryable<
Sum(IQueryable<Nullable<Double>>) Sum(IQueryable<
Nullable<Double>>) Computa a soma de uma sequência de valores Double que
Sum(IQueryable<Double>) Sum(IQueryable<Double>)
Sum(IQueryable<Int64>) Sum(IQueryable<Int64>)
Sum(IQueryable<Nullable<Decimal>>) Sum(IQueryable<
Nullable<Decimal>>) Computa a soma de uma sequência de valores Decimal que
Sum(IQueryable<Decimal>) Sum(IQueryable<Decimal>)
Sum<TSource>(IQueryable<TSource>, Expression<Func<
TSource,Nullable<Single>>>) Sum<TSource>(IQueryable< Calcula a soma da sequência de valores Single anuláveis obtida
TSource>, Expression<Func<TSource,Nullable<Single>>>) invocando uma função de projeção em cada elemento da
TSource,Nullable<Int64>>>) Sum<TSource>(IQueryable< Calcula a soma da sequência de valores Int64 anuláveis obtida
TSource>, Expression<Func<TSource,Nullable<Int64>>>) invocando uma função de projeção em cada elemento da
TSource,Nullable<Int32>>>) Sum<TSource>(IQueryable< Calcula a soma da sequência de valores Int32 anuláveis obtida
TSource>, Expression<Func<TSource,Nullable<Int32>>>) invocando uma função de projeção em cada elemento da
TSource,Nullable<Double>>>) Sum<TSource>(IQueryable< Calcula a soma da sequência de valores Double anuláveis
TSource>, Expression<Func<TSource,Nullable<Double>>>) obtida invocando uma função de projeção em cada elemento
TSource,Single>>) Sum<TSource>(IQueryable<TSource>, Calcula a soma da sequência de valores Single que é obtida
Expression<Func<TSource,Single>>) invocando uma função de projeção em cada elemento da
TSource,Int64>>) Sum<TSource>(IQueryable<TSource>, Calcula a soma da sequência de valores Int64 que é obtida
TSource,Int32>>) Sum<TSource>(IQueryable<TSource>, Calcula a soma da sequência de valores Int32 que é obtida
TSource,Double>>) Sum<TSource>(IQueryable<TSource>, Calcula a soma da sequência de valores Double que é obtida
Expression<Func<TSource,Double>>) invocando uma função de projeção em cada elemento da
TSource,Decimal>>) Sum<TSource>(IQueryable<TSource>, Calcula a soma da sequência de valores Decimal que é obtida
Expression<Func<TSource,Decimal>>) invocando uma função de projeção em cada elemento da
TSource,Nullable<Decimal>>>) Sum<TSource>(IQueryable< Calcula a soma da sequência de valores Decimal anuláveis
TSource>, Expression<Func<TSource,Nullable<Decimal>>>) obtida invocando uma função de projeção em cada elemento
Sum(IQueryable<Single>) Sum(IQueryable<Single>)
public static float Sum (this System.Linq.IQueryable<float> source);

static member Sum : System.Linq.IQueryable<single> -> single
Parameters
source IQueryable<Single>
Uma sequência de valores Single para cálculo da soma.
Returns
Single Single
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Sum(IQueryable<Single>) para somar os valores de uma
sequência.
float sum = numbers.AsQueryable().Sum();
/*

*/
Remarks
O Sum(IQueryable<Single>) método gera uma MethodCallExpression que representa a chamada
Sum(IQueryable<Single>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Sum(IQueryable<Single>) depende da implementação do tipo do source parâmetro. O comportamento
esperado é que ele retorna a soma dos valores em source .
public static Nullable<float> Sum (this System.Linq.IQueryable<Nullable<float>> source);
static member Sum : System.Linq.IQueryable<Nullable<single>> -> Nullable<single>
Parameters
source IQueryable<Nullable<Single>>
Uma sequência de valores Single que permitem valores nulos para cálculo da soma.
Returns
Nullable<Single>
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Sum(IQueryable<Nullable<Single>>) para somar os valores de
uma sequência.
float? sum = points.AsQueryable().Sum();
/*

*/
Remarks
O Sum(IQueryable<Nullable<Single>>) método gera uma MethodCallExpression que representa a chamada
Sum(IQueryable<Nullable<Single>>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Sum(IQueryable<Nullable<Single>>) depende da implementação do tipo do source parâmetro. O
comportamento esperado é que ele retorna a soma dos valores em source .
public static Nullable<long> Sum (this System.Linq.IQueryable<Nullable<long>> source);

static member Sum : System.Linq.IQueryable<Nullable<int64>> -> Nullable<int64>
Parameters
Returns
Nullable<Int64>
Exceptions
source é null .
Examples
uma sequência.
Note
/*

*/
Remarks
O Sum(IQueryable<Nullable<Int64>>) método gera uma MethodCallExpression que representa a chamada
Sum(IQueryable<Nullable<Int64>>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Sum(IQueryable<Nullable<Int64>>) depende da implementação do tipo do source parâmetro. O
public static Nullable<int> Sum (this System.Linq.IQueryable<Nullable<int>> source);

static member Sum : System.Linq.IQueryable<Nullable<int>> -> Nullable<int>
Parameters
Returns
Nullable<Int32>
Exceptions
source é null .
Examples
uma sequência.
Note
/*

*/
Remarks
O Sum(IQueryable<Nullable<Int32>>) método gera uma MethodCallExpression que representa a chamada
Sum(IQueryable<Nullable<Int32>>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Sum(IQueryable<Nullable<Int32>>) depende da implementação do tipo do source parâmetro. O
public static Nullable<double> Sum (this System.Linq.IQueryable<Nullable<double>> source);

static member Sum : System.Linq.IQueryable<Nullable<double>> -> Nullable<double>
Parameters
source IQueryable<Nullable<Double>>
Uma sequência de valores Double que permitem valores nulos para cálculo da soma.
Returns
Nullable<Double>
Exceptions
source é null .
Examples
uma sequência.
Note
/*

*/
Remarks
O Sum(IQueryable<Nullable<Double>>) método gera uma MethodCallExpression que representa a chamada
Sum(IQueryable<Nullable<Double>>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Sum(IQueryable<Nullable<Double>>) depende da implementação do tipo do source parâmetro. O
Sum(IQueryable<Double>) Sum(IQueryable<Double>)
public static double Sum (this System.Linq.IQueryable<double> source);

static member Sum : System.Linq.IQueryable<double> -> double
Parameters
source IQueryable<Double>
Uma sequência de valores Double para cálculo da soma.
Returns
Double Double
Exceptions
source é null .
Examples
sequência.
Note
/*

*/
Remarks
O Sum(IQueryable<Double>) método gera uma MethodCallExpression que representa a chamada
Sum(IQueryable<Double>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Sum(IQueryable<Double>) depende da implementação do tipo do source parâmetro. O comportamento
public static long Sum (this System.Linq.IQueryable<long> source);

static member Sum : System.Linq.IQueryable<int64> -> int64
Parameters
Returns
Int64 Int64
Exceptions
source é null .
Examples
sequência.
Note
/*

*/
Remarks
O Sum(IQueryable<Int64>) método gera uma MethodCallExpression que representa a chamada
Sum(IQueryable<Int64>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Sum(IQueryable<Int64>) depende da implementação do tipo do source parâmetro. O comportamento
public static int Sum (this System.Linq.IQueryable<int> source);
static member Sum : System.Linq.IQueryable<int> -> int
Parameters
Returns
Int32 Int32
Exceptions
source é null .
Examples
sequência.
Note
/*

*/
Remarks
O Sum(IQueryable<Int32>) método gera uma MethodCallExpression que representa a chamada
Sum(IQueryable<Int32>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Sum(IQueryable<Int32>) depende da implementação do tipo do source parâmetro. O comportamento
public static Nullable<decimal> Sum (this System.Linq.IQueryable<Nullable<decimal>> source);

static member Sum : System.Linq.IQueryable<Nullable<decimal>> -> Nullable<decimal>
Parameters
source IQueryable<Nullable<Decimal>>
Uma sequência de valores Decimal que permitem valores nulos para cálculo da soma.
Returns
Nullable<Decimal>
Exceptions
source é null .
Examples
uma sequência.
Note
/*

*/
Remarks
O Sum(IQueryable<Nullable<Decimal>>) método gera uma MethodCallExpression que representa a chamada
Sum(IQueryable<Nullable<Decimal>>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Sum(IQueryable<Nullable<Decimal>>) depende da implementação do tipo do source parâmetro. O
Sum(IQueryable<Decimal>) Sum(IQueryable<Decimal>)
public static decimal Sum (this System.Linq.IQueryable<decimal> source);

static member Sum : System.Linq.IQueryable<decimal> -> decimal
Parameters
source IQueryable<Decimal>
Uma sequência de valores Decimal para cálculo da soma.
Returns
Decimal Decimal
Exceptions
source é null .
Examples
sequência.
Note
/*

*/
Remarks
O Sum(IQueryable<Decimal>) método gera uma MethodCallExpression que representa a chamada
Sum(IQueryable<Decimal>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Sum(IQueryable<Decimal>) depende da implementação do tipo do source parâmetro. O comportamento
Sum<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Nullable<Single>>>) Sum<TSource>
Calcula a soma da sequência de valores Single anuláveis obtida invocando uma função de projeção em cada elemento
public static Nullable<float> Sum<TSource> (this System.Linq.IQueryable<TSource> source,

System.Linq.Expressions.Expression<Func<TSource,Nullable<float>>> selector);
static member Sum : System.Linq.IQueryable<'Source> *
System.Linq.Expressions.Expression<Func<'Source, Nullable<single>>> -> Nullable<single>
Type Parameters
TSource
Parameters
Uma sequência de valores do tipo TSource .
selector Expression<Func<TSource,Nullable<Single>>>
Returns
Nullable<Single>
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Sum<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Double>>) para somar os valores previstos de uma sequência.
Note
class Package
{
}

{
new List<Package>
// Calculate the sum of all package weights.

double totalWeight = packages.AsQueryable().Sum(pkg => pkg.Weight);

}
/*

*/
Remarks
O Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Single>>>) método gera uma
MethodCallExpression que representa a chamada Sum<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Nullable<Single>>>) a próprio como um método genérico construído. Em seguida, ele
chamada Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Single>>>) depende da
elemento de source e retorna a soma dos valores resultantes.
Expression<Func<TSource,Nullable<Int64>>>) Sum<TSource>
Calcula a soma da sequência de valores Int64 anuláveis obtida invocando uma função de projeção em cada elemento
public static Nullable<long> Sum<TSource> (this System.Linq.IQueryable<TSource> source,
System.Linq.Expressions.Expression<Func<TSource,Nullable<long>>> selector);
System.Linq.Expressions.Expression<Func<'Source, Nullable<int64>>> -> Nullable<int64>
Type Parameters
TSource
Parameters
Returns
Nullable<Int64>
Exceptions
Examples
Note
class Package
{
}

{
new List<Package>


}
/*

*/
Remarks
O Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int64>>>) método gera uma
chamada Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int64>>>) depende da
Expression<Func<TSource,Nullable<Int32>>>) Sum<TSource>
Calcula a soma da sequência de valores Int32 anuláveis obtida invocando uma função de projeção em cada elemento
public static Nullable<int> Sum<TSource> (this System.Linq.IQueryable<TSource> source,
System.Linq.Expressions.Expression<Func<TSource,Nullable<int>>> selector);
System.Linq.Expressions.Expression<Func<'Source, Nullable<int>>> -> Nullable<int>
Type Parameters
TSource
Parameters
Returns
Nullable<Int32>
Exceptions
Examples
Note
class Package
{
}

{
new List<Package>


}
/*

*/
Remarks
O Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int32>>>) método gera uma
chamada Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int32>>>) depende da
Expression<Func<TSource,Nullable<Double>>>) Sum<TSource>
Calcula a soma da sequência de valores Double anuláveis obtida invocando uma função de projeção em cada elemento
public static Nullable<double> Sum<TSource> (this System.Linq.IQueryable<TSource> source,

System.Linq.Expressions.Expression<Func<TSource,Nullable<double>>> selector);
System.Linq.Expressions.Expression<Func<'Source, Nullable<double>>> -> Nullable<double>
Type Parameters
TSource
Parameters
selector Expression<Func<TSource,Nullable<Double>>>
Returns
Nullable<Double>
Exceptions
Examples
Note
class Package
{
}

{
new List<Package>


}
/*

*/
Remarks
O Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Double>>>) método gera uma
Expression<Func<TSource,Nullable<Double>>>) a próprio como um método genérico construído. Em seguida, ele
chamada Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Double>>>) depende da
Expression<Func<TSource,Single>>) Sum<TSource>
(IQueryable<TSource>, Expression<Func<TSource,Single>>)
Calcula a soma da sequência de valores Single que é obtida invocando uma função de projeção em cada elemento da
public static float Sum<TSource> (this System.Linq.IQueryable<TSource> source,
System.Linq.Expressions.Expression<Func<TSource,float>> selector);
System.Linq.Expressions.Expression<Func<'Source, single>> -> single
Type Parameters
TSource
Parameters
selector Expression<Func<TSource,Single>>
Returns
Single Single
Exceptions
Examples
Note
class Package
{
}

{
new List<Package>


}
/*

*/
Remarks
O Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Single>>) método gera uma
Expression<Func<TSource,Single>>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Single>>) depende da implementação
do tipo do source parâmetro. O comportamento esperado é que ela invoca selector em cada elemento de source e
retorna a soma dos valores resultantes.
Expression<Func<TSource,Int64>>) Sum<TSource>
Calcula a soma da sequência de valores Int64 que é obtida invocando uma função de projeção em cada elemento da
public static long Sum<TSource> (this System.Linq.IQueryable<TSource> source,
System.Linq.Expressions.Expression<Func<TSource,long>> selector);
System.Linq.Expressions.Expression<Func<'Source, int64>> -> int64
Type Parameters
TSource
Parameters
Returns
Int64 Int64
Exceptions
Examples
Note
class Package
{
}

{
new List<Package>


}
/*

*/
Remarks
O Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int64>>) método gera uma
chamada Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int64>>) depende da implementação do
tipo do source parâmetro. O comportamento esperado é que ela invoca selector em cada elemento de source e
Expression<Func<TSource,Int32>>) Sum<TSource>
Calcula a soma da sequência de valores Int32 que é obtida invocando uma função de projeção em cada elemento da
public static int Sum<TSource> (this System.Linq.IQueryable<TSource> source,
System.Linq.Expressions.Expression<Func<TSource,int>> selector);
System.Linq.Expressions.Expression<Func<'Source, int>> -> int
Type Parameters
TSource
Parameters
Returns
Int32 Int32
Exceptions
Examples
Note
class Package
{
}

{
new List<Package>


}
/*

*/
Remarks
O Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32>>) método gera uma
chamada Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32>>) depende da implementação do
tipo do source parâmetro. O comportamento esperado é que ela invoca selector em cada elemento de source e
Expression<Func<TSource,Double>>) Sum<TSource>
(IQueryable<TSource>, Expression<Func<TSource,Double>>)
Calcula a soma da sequência de valores Double que é obtida invocando uma função de projeção em cada elemento da
public static double Sum<TSource> (this System.Linq.IQueryable<TSource> source,

System.Linq.Expressions.Expression<Func<TSource,double>> selector);
System.Linq.Expressions.Expression<Func<'Source, double>> -> double
Type Parameters
TSource
Parameters
selector Expression<Func<TSource,Double>>
Returns
Double Double
Exceptions
Examples
Note
class Package
{
}

{
new List<Package>


}
/*

*/
Remarks
O Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Double>>) método gera uma
Expression<Func<TSource,Double>>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Double>>) depende da implementação
do tipo de ele source parâmetro. O comportamento esperado é que ela invoca selector em cada elemento de
source e retorna a soma dos valores resultantes.
Expression<Func<TSource,Decimal>>) Sum<TSource>
(IQueryable<TSource>, Expression<Func<TSource,Decimal>>)
Calcula a soma da sequência de valores Decimal que é obtida invocando uma função de projeção em cada elemento da
public static decimal Sum<TSource> (this System.Linq.IQueryable<TSource> source,
System.Linq.Expressions.Expression<Func<TSource,decimal>> selector);
System.Linq.Expressions.Expression<Func<'Source, decimal>> -> decimal
Type Parameters
TSource
Parameters
selector Expression<Func<TSource,Decimal>>
Returns
Decimal Decimal
Exceptions
Examples
Note
class Package
{
}

{
new List<Package>


}
/*

*/
Remarks
O Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Decimal>>) método gera uma
Expression<Func<TSource,Decimal>>) a próprio como um método genérico construído. Em seguida, ele passa a
chamada Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Decimal>>) depende da implementação
do tipo do source parâmetro. O comportamento esperado é que ela invoca selector em cada elemento de source e
Expression<Func<TSource,Nullable<Decimal>>>) Sum<TSource>
Calcula a soma da sequência de valores Decimal anuláveis obtida invocando uma função de projeção em cada
public static Nullable<decimal> Sum<TSource> (this System.Linq.IQueryable<TSource> source,

System.Linq.Expressions.Expression<Func<TSource,Nullable<decimal>>> selector);
System.Linq.Expressions.Expression<Func<'Source, Nullable<decimal>>> -> Nullable<decimal>
Type Parameters
TSource
Parameters
selector Expression<Func<TSource,Nullable<Decimal>>>
Returns
Nullable<Decimal>
Exceptions
Examples
Note
class Package
{
}

{
new List<Package>


}
/*

*/
Remarks
O Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Decimal>>>) método gera uma
Expression<Func<TSource,Nullable<Decimal>>>) a próprio como um método genérico construído. Em seguida, ele
chamada Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Decimal>>>) depende da
Queryable.Take Queryable.Take
I n this Article
public static System.Linq.IQueryable<TSource> Take<TSource> (this System.Linq.IQueryable<TSource>
source, int count);
static member Take : System.Linq.IQueryable<'Source> * int -> System.Linq.IQueryable<'Source>
Type Parameters
TSource
Parameters
count Int32 Int32
Returns
IQueryable<TSource>
Um IQueryable<T> que contém o número especificado de elementos do início de source .
Exceptions
source é null .
Examples
O exemplo de código a seguir demonstra como usar Take<TSource>(IQueryable<TSource>, Int32) para retornar os
elementos desde o início de uma sequência.
int[] grades = { 59, 82, 70, 56, 92, 98, 85 };
// Sort the grades in descending order and take the first three.
IEnumerable<int> topThreeGrades =
grades.AsQueryable().OrderByDescending(grade => grade).Take(3);
Console.WriteLine("The top three grades are:");

foreach (int grade in topThreeGrades)
/*
The top three grades are:

98
92
85
*/
Remarks
O Take<TSource>(IQueryable<TSource>, Int32) método gera uma MethodCallExpression que representa a chamada
Take<TSource>(IQueryable<TSource>, Int32) a próprio como um método genérico construído. Em seguida, ele passa
a MethodCallExpression para o CreateQuery(Expression) método da IQueryProvider representado pela Provider
chamada Take<TSource>(IQueryable<TSource>, Int32) depende da implementação do tipo do source parâmetro. O
comportamento esperado é que leva a primeira count elementos desde o início do source .
Queryable.TakeLast Queryable.TakeLast
I n this Article
public static System.Linq.IQueryable<TSource> TakeLast<TSource> (this
System.Linq.IQueryable<TSource> source, int count);
static member TakeLast : System.Linq.IQueryable<'Source> * int -> System.Linq.IQueryable<'Source>
Type Parameters
TSource
Parameters
count Int32 Int32
Returns
IQueryable<TSource>
Queryable.TakeWhile Queryable.TakeWhile
I n this Article
Overloads
TakeWhile<TSource>(IQueryable<TSource>, Expression<
Func<TSource,Int32,Boolean>>) TakeWhile<TSource>( Retorna os elementos de uma sequência contanto que uma
IQueryable<TSource>, Expression<Func<TSource,Int32, condição especificada seja verdadeira. O índice do elemento é
Boolean>>) usado na lógica da função de predicado.
TakeWhile<TSource>(IQueryable<TSource>, Expression<
Func<TSource,Boolean>>) TakeWhile<TSource>(IQueryable< Retorna os elementos de uma sequência contanto que uma
TSource>, Expression<Func<TSource,Boolean>>) condição especificada seja verdadeira.
TakeWhile<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Int32,Boolean>>) TakeWhile<TSource>
public static System.Linq.IQueryable<TSource> TakeWhile<TSource> (this
System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,int,bool>>
predicate);
static member TakeWhile : System.Linq.IQueryable<'Source> *
Type Parameters
TSource
Parameters
Uma função para testar cada elemento em relação a uma condição; o segundo parâmetro da função representa o
índice do elemento na sequência de origem.
Returns
IQueryable<TSource>
Um IQueryable<T> que contém elementos da sequência de entrada que ocorrem antes do elemento no qual o teste
especificado por predicate não é mais aprovado.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar TakeWhile<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Int32,Boolean>>) para retornar elementos desde o início de uma sequência, desde que
uma condição que usa o índice do elemento é verdadeira.
// Take strings from the array until a string whose length

// is less than its index in the array is found.
.TakeWhile((fruit, index) => fruit.Length >= index);

/*
apple
passionfruit
banana
mango
orange
blueberry
*/
Remarks
O TakeWhile<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32,Boolean>>) método gera uma
MethodCallExpression que representa a chamada TakeWhile<TSource>(IQueryable<TSource>,
chamada TakeWhile<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32,Boolean>>) depende da
elemento em source até encontrar um elemento para o qual predicate retorna false . Ela retorna todos os
elementos até que esse ponto. O índice de cada elemento de código-fonte é fornecido como o segundo argumento
para predicate .
TakeWhile<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) TakeWhile<TSource>
public static System.Linq.IQueryable<TSource> TakeWhile<TSource> (this
System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,bool>>
predicate);
static member TakeWhile : System.Linq.IQueryable<'Source> *
Type Parameters
TSource
Parameters
Returns
IQueryable<TSource>
Um IQueryable<T> que contém elementos da sequência de entrada que ocorrem antes do elemento no qual o teste
especificado por predicate não é mais aprovado.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar TakeWhile<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) para retornar elementos desde o início de uma sequência, desde que uma
condição seja verdadeira.

// Take strings from the array until a string

// that is equal to "orange" is found.
.TakeWhile(fruit => String.Compare("orange", fruit, true) != 0);

/*
apple
banana
mango
*/
Remarks
O TakeWhile<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) método gera uma
MethodCallExpression que representa a chamada TakeWhile<TSource>(IQueryable<TSource>,
chamada TakeWhile<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) depende da
elemento em source até encontrar um elemento para o qual predicate retorna false . Ela retorna todos os
elementos até que esse ponto.
Queryable.ThenBy Queryable.ThenBy
I n this Article
Overloads
ThenBy<TSource,TKey>(IOrderedQueryable<TSource>,
Expression<Func<TSource,TKey>>) ThenBy<TSource,TKey>( Executa uma ordenação posterior dos elementos em uma
IOrderedQueryable<TSource>, Expression<Func<TSource, sequência em ordem crescente de acordo com uma chave.
TKey>>)
Expression<Func<TSource,TKey>>, IComparer<TKey>) Then Executa uma ordenação posterior dos elementos em uma
By<TSource,TKey>(IOrderedQueryable<TSource>, sequência em ordem crescente usando um comparador
Expression<Func<TSource,TKey>>, IComparer<TKey>) especificado.
Expression<Func<TSource,TKey>>) ThenBy<TSource,TKey>
(IOrderedQueryable<TSource>,
Executa uma ordenação posterior dos elementos em uma sequência em ordem crescente de acordo com uma chave.
public static System.Linq.IOrderedQueryable<TSource> ThenBy<TSource,TKey> (this
System.Linq.IOrderedQueryable<TSource> source,
System.Linq.Expressions.Expression<Func<TSource,TKey>> keySelector);
static member ThenBy : System.Linq.IOrderedQueryable<'Source> *
Type Parameters
TSource
TKey
O tipo da chave retornada pela função representada por keySelector .
Parameters
source IOrderedQueryable<TSource>
Um IOrderedQueryable<T> que contém elementos a ser classificados.
Returns
Exceptions
Examples
O exemplo de código a seguir demonstra como usar ThenBy<TSource,TKey>(IOrderedQueryable<TSource>,
Expression<Func<TSource,TKey>>) para executar uma classificação secundária dos elementos em uma sequência.
string[] fruits = { "grape", "passionfruit", "banana", "apple",
"orange", "raspberry", "mango", "blueberry" };
// Sort the strings first by their length and then

// alphabetically by passing the identity selector function.
.OrderBy(fruit => fruit.Length).ThenBy(fruit => fruit);

/*
apple
grape
mango
banana
orange
blueberry
raspberry
passionfruit
*/
Remarks
O ThenBy<TSource,TKey>(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>) método gera uma
MethodCallExpression que representa a chamada ThenBy<TSource,TKey>(IOrderedQueryable<TSource>,
chamada ThenBy<TSource,TKey>(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>) depende da
implementação do tipo do source parâmetro. O comportamento esperado é que ele executa uma classificação
secundária dos elementos da source com base na chave obtida invocando keySelector em cada elemento de
source . Todos os estabelecido anteriormente como ordens de classificação são preservadas.
especificado.
public static System.Linq.IOrderedQueryable<TSource> ThenBy<TSource,TKey> (this

static member ThenBy : System.Linq.IOrderedQueryable<'Source> *
Type Parameters
TSource
TKey
Parameters
Returns
Exceptions
Remarks
O ThenBy<TSource,TKey>(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>, IComparer<TKey>)
método gera uma MethodCallExpression que representa a chamada ThenBy<TSource,TKey>
(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>, IComparer<TKey>) a próprio como um método
método da IQueryProvider representado pela Provider propriedade do source parâmetro. O resultado da chamada
CreateQuery<TElement>(Expression) é convertido para o tipo IOrderedQueryable<T> e retornado.
chamada ThenBy<TSource,TKey>(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>,
executa uma classificação secundária dos elementos da source com base na chave obtida invocando keySelector em
cada elemento de source . Todos os estabelecido anteriormente como ordens de classificação são preservadas. O
comparer parâmetro é usado para comparar valores de chave.
Queryable.ThenByDescending Queryable.ThenBy
Descending
I n this Article
Overloads
ThenByDescending<TSource,TKey>(IOrderedQueryable<
TSource>, Expression<Func<TSource,TKey>>) ThenBy Executa uma ordenação posterior dos elementos em uma
Descending<TSource,TKey>(IOrderedQueryable<TSource>, sequência em ordem decrescente, de acordo com uma chave.
ThenByDescending<TSource,TKey>(IOrderedQueryable<
TSource>, Expression<Func<TSource,TKey>>, IComparer< Executa uma ordenação posterior dos elementos em uma
TKey>) ThenByDescending<TSource,TKey>(IOrdered sequência em ordem decrescente usando um comparador
Queryable<TSource>, Expression<Func<TSource,TKey>>, especificado.
IComparer<TKey>)
chave.
public static System.Linq.IOrderedQueryable<TSource> ThenByDescending<TSource,TKey> (this
System.Linq.Expressions.Expression<Func<TSource,TKey>> keySelector);
static member ThenByDescending : System.Linq.IOrderedQueryable<'Source> *
Type Parameters
TSource
TKey
Parameters
Returns
Exceptions
Remarks
O ThenByDescending<TSource,TKey>(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>) método
gera uma MethodCallExpression que representa a chamada ThenByDescending<TSource,TKey>
(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>) a próprio como um método genérico construído.
Em seguida, ele passa a MethodCallExpression para o CreateQuery<TElement>(Expression) método da
IQueryProvider representado pela Provider propriedade do source parâmetro. O resultado da chamada
chamada ThenByDescending<TSource,TKey>(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>)
depende da implementação do tipo do source parâmetro. O comportamento esperado é que ele executa uma
classificação secundária dos elementos da source em ordem decrescente, com base na chave obtida invocando
keySelector em cada elemento de source . Todos os estabelecido anteriormente como ordens de classificação são
preservadas.
Executa uma ordenação posterior dos elementos em uma sequência em ordem decrescente usando um comparador
especificado.
public static System.Linq.IOrderedQueryable<TSource> ThenByDescending<TSource,TKey> (this

static member ThenByDescending : System.Linq.IOrderedQueryable<'Source> *
Type Parameters
TSource
TKey
O tipo da chave que é retornado pelo keySelector função.
Parameters
Returns
Uma coleção cujos elementos são classificados em ordem decrescente de acordo com uma chave.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar ThenByDescending<TSource,TKey>
(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>, IComparer<TKey>) para executar uma
classificação secundária dos elementos em uma sequência em ordem decrescente usando um comparador
personalizado.
public class CaseInsensitiveComparer : IComparer<string>
{
public int Compare(string x, string y)
{
return string.Compare(x, y, true);
}
}
public static void ThenByDescendingEx1()

{
string[] fruits =
{ "apPLe", "baNanA", "apple", "APple", "orange", "BAnana", "ORANGE", "apPLE" };
// Sort the strings first ascending by their length and

// then descending using a custom case insensitive comparer.
.OrderBy(fruit => fruit.Length)
.ThenByDescending(fruit => fruit, new CaseInsensitiveComparer());

}
/*
apPLe
apple
APple
apPLE
orange
ORANGE
baNanA
BAnana
*/
Remarks
O ThenBy<TSource,TKey>(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>, IComparer<TKey>)
método gera uma MethodCallExpression que representa a chamada ThenBy<TSource,TKey>
(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>, IComparer<TKey>) a próprio como um método
método da IQueryProvider representado pela Provider propriedade do source parâmetro. O resultado da chamada
chamada ThenBy<TSource,TKey>(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>,
executa uma classificação secundária dos elementos da source em ordem decrescente, com base na chave obtida
invocando keySelector em cada elemento de source . Todos os estabelecido anteriormente como ordens de
classificação são preservadas. O comparer parâmetro é usado para comparar valores de chave.
Queryable.Union Queryable.Union
I n this Article
Overloads
Union<TSource>(IQueryable<TSource>, IEnumerable<
TSource>) Union<TSource>(IQueryable<TSource>, Produz a união de conjunto de duas sequências usando o
IEnumerable<TSource>) comparador de igualdade padrão.
Union<TSource>(IQueryable<TSource>, IEnumerable<
TSource>, IEqualityComparer<TSource>) Union<TSource>( Produz a união de conjunto de duas sequências usando o
IQueryable<TSource>, IEnumerable<TSource>, IEquality IEqualityComparer<T> especificado.
Comparer<TSource>)
public static System.Linq.IQueryable<TSource> Union<TSource> (this System.Linq.IQueryable<TSource>
static member Union : System.Linq.IQueryable<'Source> * seq<'Source> ->
Type Parameters
TSource
Parameters
Uma sequência cujos elementos distintos formam o primeiro conjunto da operação de união.
Uma sequência cujos elementos distintos formam o segundo conjunto da operação de união.
Returns
IQueryable<TSource>
Um IQueryable<T> que contém os elementos de ambas as sequências de entrada, excluindo as duplicatas.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Union<TSource>(IQueryable<TSource>,
IEnumerable<TSource>) para obter a união de conjunto de duas sequências.
int[] ints1 = { 5, 3, 9, 7, 5, 9, 3, 7 };
int[] ints2 = { 8, 3, 6, 4, 4, 9, 1, 0 };
// Get the set union of the items in the two arrays.

IEnumerable<int> union = ints1.AsQueryable().Union(ints2);
foreach (int num in union)

Console.Write("{0} ", num);
/*
5 3 9 7 8 6 4 1 0
*/
Remarks
O Union<TSource>(IQueryable<TSource>, IEnumerable<TSource>) método gera uma MethodCallExpression que
representa a chamada Union<TSource>(IQueryable<TSource>, IEnumerable<TSource>) a próprio como um método
chamada Union<TSource>(IQueryable<TSource>, IEnumerable<TSource>) depende da implementação do tipo do
source1 parâmetro. O comportamento esperado é que a união de conjunto de elementos na source1 e source2 é
retornado.
Union<TSource>(IQueryable<TSource>, IEnumerable<TSource>,
IEqualityComparer<TSource>) Union<TSource>
(IQueryable<TSource>, IEnumerable<TSource>,
public static System.Linq.IQueryable<TSource> Union<TSource> (this System.Linq.IQueryable<TSource>

source1, System.Collections.Generic.IEnumerable<TSource> source2,
static member Union : System.Linq.IQueryable<'Source> * seq<'Source> *
Type Parameters
TSource
Parameters
Uma sequência cujos elementos distintos formam o primeiro conjunto da operação de união.
Uma sequência cujos elementos distintos formam o segundo conjunto da operação de união.
Returns
IQueryable<TSource>
Um IQueryable<T> que contém os elementos de ambas as sequências de entrada, excluindo as duplicatas.
Exceptions
Remarks
O Union<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) método gera
uma MethodCallExpression que representa a chamada Union<TSource>(IQueryable<TSource>,
chamada Union<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) depende
da implementação do tipo do source1 parâmetro. O comportamento esperado é que a união de conjunto de
elementos na source1 e source2 é retornado. O comparer parâmetro é usado para comparar valores.
Queryable.Where Queryable.Where
I n this Article
Overloads
Where<TSource>(IQueryable<TSource>, Expression<Func<
TSource,Int32,Boolean>>) Where<TSource>(IQueryable< Filtra uma sequência de valores com base em um predicado. O
TSource>, Expression<Func<TSource,Int32,Boolean>>) índice de cada elemento é usado na lógica da função de
predicado.
Where<TSource>(IQueryable<TSource>, Expression<Func<
TSource,Boolean>>) Where<TSource>(IQueryable<TSource>, Filtra uma sequência de valores com base em um predicado.
Expression<Func<TSource,Boolean>>)
Where<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Int32,Boolean>>) Where<TSource>
Filtra uma sequência de valores com base em um predicado. O índice de cada elemento é usado na lógica da função de
predicado.
public static System.Linq.IQueryable<TSource> Where<TSource> (this System.Linq.IQueryable<TSource>
source, System.Linq.Expressions.Expression<Func<TSource,int,bool>> predicate);
static member Where : System.Linq.IQueryable<'Source> *
Type Parameters
TSource
Parameters
Um IQueryable<T> a ser filtrado.
Uma função para testar cada elemento em relação a uma condição; o segundo parâmetro da função representa o
índice do elemento na sequência de origem.
Returns
IQueryable<TSource>
Um IQueryable<T> que contém elementos da sequência de entrada que atendem à condição especificada por
predicate .
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Where<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Int32,Boolean>>) para filtrar uma sequência com base em um predicado que incorpora o
índice de cada elemento.
int[] numbers = { 0, 30, 20, 15, 90, 85, 40, 75 };
// Get all the numbers that are less than or equal to

// the product of their index in the array and 10.
numbers.AsQueryable()
.Where((number, index) => number <= index * 10);
foreach (int number in query)

/*
0
20
15
40
*/
Remarks
O Where<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32,Boolean>>) método gera uma
MethodCallExpression que representa a chamada Where<TSource>(IQueryable<TSource>,
chamada Where<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32,Boolean>>) depende da
implementação do tipo do source parâmetro. O comportamento esperado é que ele retorna os elementos de source
que satisfazem a condição especificada pelo predicate . O índice de cada elemento de código-fonte é fornecido como
o segundo argumento para predicate .
Where<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) Where<TSource>
public static System.Linq.IQueryable<TSource> Where<TSource> (this System.Linq.IQueryable<TSource>

source, System.Linq.Expressions.Expression<Func<TSource,bool>> predicate);
static member Where : System.Linq.IQueryable<'Source> *
Type Parameters
TSource
Parameters
Um IQueryable<T> a ser filtrado.
Returns
IQueryable<TSource>
Um IQueryable<T> que contém elementos da sequência de entrada que atendem à condição especificada por
predicate .
Exceptions
Examples
O exemplo de código a seguir demonstra como usar Where<TSource>(IQueryable<TSource>,
Expression<Func<TSource,Boolean>>) para filtrar uma sequência.
List<string> fruits =
new List<string> { "apple", "passionfruit", "banana", "mango",
// Get all strings whose length is less than 6.

fruits.AsQueryable().Where(fruit => fruit.Length < 6);

/*
apple
mango
grape
*/
Remarks
O Where<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) método gera uma
MethodCallExpression que representa a chamada Where<TSource>(IQueryable<TSource>,
chamada Where<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>) depende da
implementação do tipo do source parâmetro. O comportamento esperado é que ele retorna os elementos de source
que satisfazem a condição especificada pelo predicate .
Queryable.Zip Queryable.Zip
I n this Article
Mescla duas sequências usando a função de predicado especificada.
public static System.Linq.IQueryable<TResult> Zip<TFirst,TSecond,TResult> (this
System.Linq.IQueryable<TFirst> source1, System.Collections.Generic.IEnumerable<TSecond> source2,
System.Linq.Expressions.Expression<Func<TFirst,TSecond,TResult>> resultSelector);
static member Zip : System.Linq.IQueryable<'First> * seq<'Second> *
System.Linq.Expressions.Expression<Func<'First, 'Second, 'Result>> ->
Type Parameters
TFirst
O tipo de elementos na primeira sequência de entrada.
TSecond
O tipo de elementos na segunda sequência de entrada.
TResult
O tipo de elementos na sequência de resultado.
Parameters
source1 IQueryable<TFirst>
A primeira sequência a ser mesclada.
source2 IEnumerable<TSecond>
A segunda sequência a ser mesclada.
resultSelector Expression<Func<TFirst,TSecond,TResult>>
Uma função que especifica como mesclar os elementos das duas sequências.
Returns
IQueryable<TResult>
Um IQueryable<T> que contém elementos mesclados de duas sequências de entrada.
Exceptions
Examples
O exemplo de código a seguir demonstra como usar o Zip método para mesclar duas sequências.
int[] numbers = { 1, 2, 3, 4 };
string[] words = { "one", "two", "three" };
var numbersAndWords = numbers.AsQueryable().Zip(words, (first, second) => first + " " + second);
foreach (var item in numbersAndWords)

Console.WriteLine(item);
// 1 one
// 2 two
// 3 three
Remarks
O Zip método gera uma MethodCallExpression que representa a chamada Zip a próprio como um método genérico
construído. Em seguida, ele passa a MethodCallExpression para o CreateQuery<TElement>(Expression) método da
IQueryProvider representado pela Provider propriedade do source1 parâmetro.
O método mescla cada elemento da primeira sequência com um elemento que tem o mesmo índice na segunda
sequência. Se as sequências não tiverem o mesmo número de elementos, o método mescla as sequências até atingir o
final de um deles. Por exemplo, se uma sequência tem três elementos e o outro é tem quatro, a sequência resultante
terá apenas três elementos.

LINQ

Diunggah oleh

Informasi Dokumen

Deskripsi Asli:

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

LINQ

Diunggah oleh

Hak Cipta:

Format Tersedia

Contents

Aplica uma função de acumulador a uma sequência.

Determina se todos os elementos de uma sequência atendem a uma condição.

Determina se uma sequência contém elementos.

Determina se algum elemento de uma sequência atende a uma condição.

Acrescenta um valor ao final da sequência.

Retorna a entrada digitada como IEnumerable<T>.

Computa a média de uma sequência de valores Single.

Computa a média de uma sequência de valores Int64.

Computa a média de uma sequência de valores Int32.

Computa a média de uma sequência de valores Double.

Computa a média de uma sequência de valores Decimal.

Converte os elementos de um IEnumerable para o tipo especificado.

Concatena duas sequências.

Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)

Determina se uma sequência contém um elemento especificado usando um IEqualityComparer<T> especificado.

Retorna o número de elementos em uma sequência.

Retorna os elementos da sequência especificada ou o valor especificado em uma coleção de singletons se a

Retorna o elemento de um índice especificado em uma sequência.

Retorna um IEnumerable<T> vazio que tem o argumento do tipo especificado.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Retorna o primeiro elemento de uma sequência.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>,

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>,

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>,

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>,

Correlaciona os elementos de duas sequências com base em chaves de correspondência. O comparador de

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>,

Correlaciona os elementos de duas sequências com base em chaves de correspondência. Um

Retorna o último elemento de uma sequência.

Retorna um Int64 que representa o número total de elementos em uma sequência.

Retorna o valor máximo em uma sequência de valores Single anuláveis.

Retorna o valor máximo em uma sequência de valores Int32.

Retorna o valor máximo em uma sequência de valores Int64 anuláveis.

Retorna o valor máximo em uma sequência de valores Single.

Retorna o valor máximo em uma sequência de valores Int32 anuláveis.

Retorna o valor máximo em uma sequência de valores Decimal.

Retorna o valor máximo em uma sequência de valores Decimal anuláveis.

Retorna o valor máximo em uma sequência de valores Int64.

Retorna o valor máximo em uma sequência de valores Double.

Retorna o valor máximo em uma sequência de valores Double anuláveis.

Retorna o valor máximo em uma sequência genérica.

Retorna o valor mínimo em uma sequência de valores Int64 anuláveis.

Retorna o valor mínimo em uma sequência de valores Int32 anuláveis.

Retorna o valor mínimo em uma sequência de valores Single.

Retorna o valor mínimo em uma sequência de valores Single anuláveis.

Retorna o valor mínimo em uma sequência de valores Double anuláveis.

Retorna o valor mínimo em uma sequência de valores Double.

Retorna o valor mínimo em uma sequência de valores Int64.

Retorna o valor mínimo em uma sequência de valores Int32.

Retorna o valor mínimo em uma sequência de valores Decimal anuláveis.

Retorna o valor mínimo em uma sequência de valores Decimal.

Retorna o valor mínimo em uma sequência genérica.

Filtra os elementos de um IEnumerable com base em um tipo especificado.

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Classifica os elementos de uma sequência em ordem crescente usando um comparador especificado.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Classifica os elementos de uma sequência em ordem decrescente usando um comparador especificado.

Adiciona um valor ao início da sequência.

Gera uma sequência de números integrais dentro de um intervalo especificado.