You are on page 1of 919

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>
EnumerableExecutor<T>
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
IEnumerable.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
IEnumerable.GetEnumerator
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.

EnumerableExecutor<T>
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>
Representa uma sequência paralela.

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>
Representa o resultado de uma operação de classificação.

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,
Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)

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,
Func<TAccumulate,TSource,TAccumulate>)

Aplica uma função de acumulador a uma sequência. O valor de semente especificado é usado como o valor inicial
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>)
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>>)
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 permitem valores nulos.

Average(IEnumerable<Nullable<Int32>>)
Average(IEnumerable<Nullable<Int32>>)

Computa a média de uma sequência de valores Int32 que permitem valores nulos.
Average(IEnumerable<Nullable<Double>>)
Average(IEnumerable<Nullable<Double>>)

Computa a média de uma sequência de valores Double que permitem valores nulos.

Average(IEnumerable<Int64>)
Average(IEnumerable<Int64>)

Computa a média de uma sequência de valores Int64.

Average(IEnumerable<Int32>)
Average(IEnumerable<Int32>)

Computa a média de uma sequência de valores Int32.

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 permitem valores nulos.

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 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
função de transformação em cada elemento da sequência de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Calcula a média de uma sequência de valores Int64 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,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 de transformação em cada elemento da sequência de entrada.

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
função de transformação em cada elemento da sequência de entrada.

Average<TSource>(IEnumerable<TSource>, 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 elemento da sequência de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)
Average<TSource>(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 elemento da sequência de entrada.

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
cada elemento da sequência de entrada.

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)
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)
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>)
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>)
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>)
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>)
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.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>,
Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>, IEqualityComparer<TKey>)
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>,
Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>, IEqualityComparer<TKey>)

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


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>,
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.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>,
Func<TKey,IEnumerable<TSource>,TResult>)
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>,
Func<TKey,IEnumerable<TSource>,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.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>,
Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>,
Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)

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. 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>)
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.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<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>)

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>)
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.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>,


Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>,
Func<TInner,TKey>, 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.

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<TSource,Boolean>)

Retorna o último elemento de uma sequência que satisfaz uma condição especificada.

LastOrDefault<TSource>(IEnumerable<TSource>)
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
não seja encontrado.

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>)
LongCount<TSource>(IEnumerable<TSource>)

Retorna um Int64 que representa o número total de elementos em uma sequência.

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

Retorna o valor máximo em uma sequência de valores 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>)

Retorna o valor máximo em uma sequência de valores 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<Int64>)
Max(IEnumerable<Int64>)

Retorna o valor máximo em uma sequência de valores Int64.


Max(IEnumerable<Double>)
Max(IEnumerable<Double>)

Retorna o valor máximo em uma sequência de valores 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<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>)
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>>)
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.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int32 máximo que
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>)
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,Int32>)
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int32 máximo.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)
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>)
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>>)
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>)

Retorna o valor mínimo em uma sequência de valores 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>)

Retorna o valor mínimo em uma sequência de valores Double.

Min(IEnumerable<Int64>)
Min(IEnumerable<Int64>)

Retorna o valor mínimo em uma sequência de valores Int64.

Min(IEnumerable<Int32>)
Min(IEnumerable<Int32>)

Retorna o valor mínimo em uma sequência de valores Int32.

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

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>)
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>>)
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.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

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>)
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,Int32>)
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int32 mínimo.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)
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>)
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)
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>>,
Func<TSource,TCollection,TResult>)

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>)
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>,
Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

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. 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>>)

Projeta cada elemento de uma sequência em um IEnumerable<T> e nivela as sequências resultantes em uma
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>)
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>)

Ignora elementos em uma sequência, 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(IEnumerable<Nullable<Int32>>)
Sum(IEnumerable<Nullable<Int32>>)

Computa a soma de uma sequência de valores Int32 que permitem valores nulos.

Sum(IEnumerable<Nullable<Single>>)
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<Int64>>)
Sum(IEnumerable<Nullable<Int64>>)

Computa a soma de uma sequência de valores Int64 que permitem valores nulos.

Sum(IEnumerable<Nullable<Double>>)
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>)
Sum(IEnumerable<Int64>)

Calcula a soma de uma sequência de valores Int64.


Sum(IEnumerable<Int32>)
Sum(IEnumerable<Int32>)

Calcula a soma de uma sequência de valores Int32.

Sum(IEnumerable<Decimal>)
Sum(IEnumerable<Decimal>)

Calcula a soma de uma sequência de valores Decimal.

Sum(IEnumerable<Nullable<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>)
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
em cada elemento da sequência de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)
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
em cada elemento da sequência de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Calcula a soma da sequência de valores Int32 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<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
transformação em cada elemento da sequência de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)
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
elemento da sequência de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Calcula a soma da sequência de valores Int32 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,Double>)
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
elemento da sequência de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)
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
elemento da sequência de entrada.

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>,


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

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

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


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


chave e seletor de elemento.

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


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

Cria um Lookup<TKey,TElement> 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.

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

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


especificada e um comparador de chaves.

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>,
Func<TAccumulate,TResult>)
Aggregate<TSource,TAccumulate,TResult>
(IEnumerable<TSource>, TAccumulate,
Func<TAccumulate,TSource,TAccumulate>,
Func<TAccumulate,TResult>)
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.

Aggregate<TSource,TAccumulate>(IEnumerable<TSource>,
TAccumulate, Func<TAccumulate,TSource,TAccumulate>)
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>,
TAccumulate, Func<TAccumulate,TSource,TAccumulate>)
Aplica uma função de acumulador a uma sequência. O valor de semente especificado é usado como o valor inicial do
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
O tipo dos elementos de source .
TAccumulate
O tipo do valor do acumulador.
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.
Returns
TAccumulate TAccumulate
O valor final do acumulador.
Exceptions
ArgumentNullException ArgumentNullException
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);

// This code produces the following output:


//
// 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 .

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.

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.
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
O tipo dos elementos de source .

Parameters
source IEnumerable<TSource>
Um IEnumerable<T> no qual será feita a agregação.
func Func<TSource,TSource,TSource>
Uma função de acumulador a ser invocada em cada elemento.
Returns
TSource TSource
O valor final do acumulador.
Exceptions
ArgumentNullException ArgumentNullException
source ou func é null .
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);

// This code produces the following output:


//
// 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.
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.
Enumerable.All Enumerable.All
I n this Article
Determina se todos os elementos de uma sequência atendem a uma condição.
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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
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
ArgumentNullException ArgumentNullException
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");
}

// This code produces the following output:


//
// 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
{
public string Name { get; set; }
public int Age { get; set; }
}
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="Boots", Age=14 },
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>)
Determina se uma sequência contém elementos.
public static bool Any<TSource> (this System.Collections.Generic.IEnumerable<TSource> source);
static member Any : seq<'Source> -> bool

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
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
ArgumentNullException ArgumentNullException
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");

// This code produces the following output:


//
// 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
{
public string Name { get; set; }
public int Age { get; set; }
}
class Person
{
public string LastName { get; set; }
public Pet[] Pets { get; set; }
}

public static void AnyEx2()


{
List<Person> people = new List<Person>
{ new Person { LastName = "Haas",
Pets = new Pet[] { new Pet { Name="Barley", Age=10 },
new Pet { Name="Boots", Age=14 },
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 Person { LastName = "Philips",
Pets = new Pet[] { new Pet { Name = "Sweetie", Age = 2},
new Pet { Name = "Rover", Age = 13}} }
};

// Determine which people have a non-empty Pet array.


IEnumerable<string> names = from person in people
where person.Pets.Any()
select person.LastName;

foreach (string name in names)


{
Console.WriteLine(name);
}

/* This code produces the following output:

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.
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 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)

Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Determina se algum elemento de uma sequência atende a uma condição.

public static bool Any<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,


Func<TSource,bool> predicate);
static member Any : seq<'Source> * Func<'Source, bool> -> bool

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Um IEnumerable<T> a cujos elementos 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 algum elemento na sequência de origem for aprovado no teste do predicado especificado; caso contrário,
false .

Exceptions
ArgumentNullException ArgumentNullException
source ou predicate é null .
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 string Name { get; set; }
public int Age { get; set; }
public bool Vaccinated { get; set; }
}

public static void AnyEx3()


{
// Create an array of Pets.
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");
}

// This code produces the following output:


//
// 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.
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 Any() cláusula se traduz em uma
invocação de Any.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
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
ArgumentNullException ArgumentNullException
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));

// This code produces the following output:


//
// 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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
A sequência a ser digitada como IEnumerable<T>.
Returns
IEnumerable<TSource>
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.
IEnumerable<string> query2 =
fruitClump.AsEnumerable().Where(fruit => fruit.Contains("o"));

// Display the output.


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

// This code produces the following output:


//
// 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
permitem valores nulos.

Average(IEnumerable<Nullable<Int32>>) Average(
IEnumerable<Nullable<Int32>>) Computa a média de uma sequência de valores Int32 que
permitem valores nulos.

Average(IEnumerable<Nullable<Double>>) Average(
IEnumerable<Nullable<Double>>) Computa a média de uma sequência de valores Double que
permitem valores nulos.

Average(IEnumerable<Int64>) Average(IEnumerable<Int64>)
Computa a média de uma sequência de valores Int64.

Average(IEnumerable<Int32>) Average(IEnumerable<Int32>)
Computa a média de uma sequência de valores Int32.

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
permitem valores nulos.

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
transformação em cada elemento da sequência de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,
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
elemento da sequência de entrada.
Average<TSource>(IEnumerable<TSource>, Func<TSource,
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
transformação em cada elemento da sequência de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,
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
transformação em cada elemento da sequência de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,
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
transformação em cada elemento da sequência de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,
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
transformação em cada elemento da sequência de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,
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
elemento da sequência de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,
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
elemento da sequência de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,
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
elemento da sequência de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,
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
elemento da sequência de entrada.

Average(IEnumerable<Single>) Average(IEnumerable<Single>)
Computa a média de uma sequência de valores 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
ArgumentNullException ArgumentNullException
source é null .
InvalidOperationException InvalidOperationException
source não contém elementos.
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);

// This code produces the following output:


//
// 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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Average(IEnumerable<Nullable<Single>>)
Average(IEnumerable<Nullable<Single>>)
Computa a média de uma sequência de valores Single que permitem valores nulos.

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
ArgumentNullException ArgumentNullException
source é null .
Examples
O exemplo de código a seguir demonstra como usar Average(IEnumerable<Nullable<Int64>>) 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.

long?[] longs = { null, 10007L, 37L, 399846234235L };

double? average = longs.Average();

Console.WriteLine("The average is {0}.", average);

// This code produces the following output:


//
// The average is 133282081426.333.

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Average(IEnumerable<Nullable<Int64>>)
Average(IEnumerable<Nullable<Int64>>)
Computa a média de uma sequência de valores Int64 que permitem valores nulos.

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>
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
ArgumentNullException ArgumentNullException
source é null .

OverflowException OverflowException
A soma dos elementos na sequência é maior do que MaxValue.
Examples
O exemplo de código a seguir demonstra como usar Average(IEnumerable<Nullable<Int64>>) para calcular uma
média.

long?[] longs = { null, 10007L, 37L, 399846234235L };

double? average = longs.Average();

Console.WriteLine("The average is {0}.", average);

// This code produces the following output:


//
// The average is 133282081426.333.

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Average(IEnumerable<Nullable<Int32>>)
Average(IEnumerable<Nullable<Int32>>)
Computa a média de uma sequência de valores Int32 que permitem valores nulos.

public static Nullable<double> Average (this System.Collections.Generic.IEnumerable<Nullable<int>>


source);
static member Average : seq<Nullable<int>> -> Nullable<double>

Parameters
source IEnumerable<Nullable<Int32>>
Uma sequência de valores Int32 que permitem valores nulos para cálculo da média.
Returns
Nullable<Double>
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
ArgumentNullException ArgumentNullException
source é null .

OverflowException OverflowException
A soma dos elementos na sequência é maior do que MaxValue.
Examples
O exemplo de código a seguir demonstra como usar Average(IEnumerable<Nullable<Int64>>) 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.

long?[] longs = { null, 10007L, 37L, 399846234235L };

double? average = longs.Average();

Console.WriteLine("The average is {0}.", average);

// This code produces the following output:


//
// The average is 133282081426.333.

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Average(IEnumerable<Nullable<Double>>)
Average(IEnumerable<Nullable<Double>>)
Computa a média de uma sequência de valores Double que permitem valores nulos.

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>
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
ArgumentNullException ArgumentNullException
source é null .
Examples
O exemplo de código a seguir demonstra como usar Average(IEnumerable<Nullable<Int64>>) 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.

long?[] longs = { null, 10007L, 37L, 399846234235L };

double? average = longs.Average();

Console.WriteLine("The average is {0}.", average);

// This code produces the following output:


//
// 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.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Average() cláusula se traduz em uma
invocação de Average.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Average(IEnumerable<Int64>) Average(IEnumerable<Int64>)
Computa a média de uma sequência de valores Int64.

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
A média da sequência de valores.
Exceptions
ArgumentNullException ArgumentNullException
source é null .

InvalidOperationException InvalidOperationException
source não contém elementos.
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);

// This code produces the following output:


//
// 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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Average(IEnumerable<Int32>) Average(IEnumerable<Int32>)
Computa a média de uma sequência de valores Int32.

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


static member Average : seq<int> -> double

Parameters
source IEnumerable<Int32>
Uma sequência de valores Int32 para realizar o cálculo da média.
Returns
Double Double
A média da sequência de valores.
Exceptions
ArgumentNullException ArgumentNullException
source é null .

InvalidOperationException InvalidOperationException
source não contém elementos.
Examples
O exemplo de código a seguir demonstra como usar Average(IEnumerable<Int32>) para calcular uma média.
List<int> grades = new List<int> { 78, 92, 100, 37, 81 };

double average = grades.Average();

Console.WriteLine("The average grade is {0}.", average);

// This code produces the following output:


//
// 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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Average(IEnumerable<Double>) Average(IEnumerable<Double>)
Computa a média de uma sequência de valores 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
A média da sequência de valores.
Exceptions
ArgumentNullException ArgumentNullException
source é null .

InvalidOperationException InvalidOperationException
source não contém elementos.
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);

// This code produces the following output:


//
// The average grade is 77.6.

Remarks
Se a soma dos elementos é muito grande para ser representado como um Double, esse método retorna infinito
positivo ou negativo.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Average() cláusula se traduz em uma
invocação de Average.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Average(IEnumerable<Decimal>)
Average(IEnumerable<Decimal>)
Computa a média de uma sequência de valores Decimal.

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
A média da sequência de valores.
Exceptions
ArgumentNullException ArgumentNullException
source é null .

InvalidOperationException InvalidOperationException
source não contém elementos.
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

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

// This code produces the following output:


//
// 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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Average(IEnumerable<Nullable<Decimal>>)
Average(IEnumerable<Nullable<Decimal>>)
Computa a média de uma sequência de valores Decimal que permitem valores nulos.

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>
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
ArgumentNullException ArgumentNullException
source é null .
OverflowException OverflowException
A soma dos elementos na sequência é maior do que MaxValue.
Examples
O exemplo de código a seguir demonstra como usar Average(IEnumerable<Nullable<Int64>>) 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.
long?[] longs = { null, 10007L, 37L, 399846234235L };

double? average = longs.Average();

Console.WriteLine("The average is {0}.", average);

// This code produces the following output:


//
// The average is 133282081426.333.

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
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
transformação em cada elemento da sequência de entrada.

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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
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>
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
ArgumentNullException ArgumentNullException
source ou selector é null .

OverflowException OverflowException
A soma dos elementos na sequência é maior do que MaxValue.
Examples
O exemplo de código a seguir demonstra como usar Average<TSource>(IEnumerable<TSource>,
Func<TSource,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 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);

// This code produces the following output:


//
// The average string length is 6.5.

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

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.
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
O tipo dos elementos de source .

Parameters
source IEnumerable<TSource>
Uma sequência de valores para cálculo da média.
selector Func<TSource,Single>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Single Single
A média da sequência de valores.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
InvalidOperationException InvalidOperationException
source não contém elementos.
Examples
O exemplo de código a seguir demonstra como usar Average<TSource>(IEnumerable<TSource>,
Func<TSource,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 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);

// This code produces the following output:


//
// The average string length is 6.5.

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

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 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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para cálculo da média.
selector Func<TSource,Nullable<Single>>
Uma função de transformação a ser aplicada a cada elemento.
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
ArgumentNullException ArgumentNullException
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

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

// This code produces the following output:


//
// The average string length is 6.5.

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Average<TSource>(IEnumerable<TSource>,
Func<TSource,Nullable<Int64>>) Average<TSource>
(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)
Calcula a média de uma sequência de valores Int64 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<double> Average<TSource> (this
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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para cálculo da média.
selector Func<TSource,Nullable<Int64>>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Nullable<Double>
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 .

Examples
O exemplo de código a seguir demonstra como usar Average<TSource>(IEnumerable<TSource>,
Func<TSource,Int64>) 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 a este tópico, altere o corpo da função selector .

string[] numbers = { "10007", "37", "299846234235" };

double average = numbers.Average(num => Convert.ToInt64(num));

Console.WriteLine("The average is {0}.", average);

// This code produces the following output:


//
// The average is 99948748093.

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

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 função
de transformação em cada elemento da sequência de entrada.

public static Nullable<double> Average<TSource> (this


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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para cálculo da média.
selector Func<TSource,Nullable<Double>>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Nullable<Double>
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
ArgumentNullException ArgumentNullException
source ou selector é null .
Examples
O exemplo de código a seguir demonstra como usar Average<TSource>(IEnumerable<TSource>,
Func<TSource,Int64>) 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 a este tópico, altere o corpo da função selector .

string[] numbers = { "10007", "37", "299846234235" };

double average = numbers.Average(num => Convert.ToInt64(num));

Console.WriteLine("The average is {0}.", average);

// This code produces the following output:


//
// The average is 99948748093.

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

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 função
de transformação em cada elemento da sequência de entrada.
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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para cálculo da média.
selector Func<TSource,Nullable<Decimal>>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Nullable<Decimal>
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
ArgumentNullException ArgumentNullException
source ou selector é null .

OverflowException OverflowException
A soma dos elementos na sequência é maior do que MaxValue.
Examples
O exemplo de código a seguir demonstra como usar Average<TSource>(IEnumerable<TSource>,
Func<TSource,Int64>) 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 a este tópico, altere o corpo da função selector .

string[] numbers = { "10007", "37", "299846234235" };

double average = numbers.Average(num => Convert.ToInt64(num));

Console.WriteLine("The average is {0}.", average);

// This code produces the following output:


//
// The average is 99948748093.

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Average<TSource>(IEnumerable<TSource>,
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
elemento da sequência de entrada.
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
source IEnumerable<TSource>
Uma sequência de valores para cálculo da média.
selector Func<TSource,Int64>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Double Double
A média da sequência de valores.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
InvalidOperationException InvalidOperationException
source não contém elementos.
OverflowException OverflowException
A soma dos elementos na sequência é maior do que MaxValue.
Examples
O exemplo de código a seguir demonstra como usar Average<TSource>(IEnumerable<TSource>,
Func<TSource,Int64>) para calcular uma média.
string[] numbers = { "10007", "37", "299846234235" };

double average = numbers.Average(num => Convert.ToInt64(num));

Console.WriteLine("The average is {0}.", average);

// This code produces the following output:


//
// The average is 99948748093.

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Average<TSource>(IEnumerable<TSource>,
Func<TSource,Int32>) Average<TSource>
(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
elemento da sequência de entrada.
public static double Average<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,int> selector);
static member Average : seq<'Source> * Func<'Source, int> -> double

Type Parameters
TSource
O tipo dos elementos de source .

Parameters
source IEnumerable<TSource>
Uma sequência de valores para cálculo da média.
selector Func<TSource,Int32>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Double Double
A média da sequência de valores.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
InvalidOperationException InvalidOperationException
source não contém elementos.
OverflowException OverflowException
A soma dos elementos na sequência é maior do que MaxValue.
Examples
O exemplo de código a seguir demonstra como usar Average<TSource>(IEnumerable<TSource>,
Func<TSource,Int32>) para calcular uma média.

string[] fruits = { "apple", "banana", "mango", "orange", "passionfruit", "grape" };

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

Console.WriteLine("The average string length is {0}.", average);

// This code produces the following output:


//
// The average string length is 6.5.

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

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
cada elemento da sequência de entrada.

public static double Average<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,


Func<TSource,double> selector);
static member Average : seq<'Source> * Func<'Source, double> -> double

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para cálculo da média.
selector Func<TSource,Double>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Double Double
A média da sequência de valores.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
InvalidOperationException InvalidOperationException
source não contém elementos.
Examples
O exemplo de código a seguir demonstra como usar Average<TSource>(IEnumerable<TSource>,
Func<TSource,Int64>) 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 a este tópico, altere o corpo da função selector .

string[] numbers = { "10007", "37", "299846234235" };

double average = numbers.Average(num => Convert.ToInt64(num));

Console.WriteLine("The average is {0}.", average);

// This code produces the following output:


//
// The average is 99948748093.

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

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.
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
O tipo dos elementos de source .

Parameters
source IEnumerable<TSource>
Uma sequência de valores usados para calcular uma média.
selector Func<TSource,Decimal>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Decimal Decimal
A média da sequência de valores.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
InvalidOperationException InvalidOperationException
source não contém elementos.
OverflowException OverflowException
A soma dos elementos na sequência é maior do que MaxValue.
Examples
O exemplo de código a seguir demonstra como usar Average<TSource>(IEnumerable<TSource>,
Func<TSource,Int64>) 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 a este tópico, altere o corpo da função selector .

string[] numbers = { "10007", "37", "299846234235" };

double average = numbers.Average(num => Convert.ToInt64(num));

Console.WriteLine("The average is {0}.", average);

// This code produces the following output:


//
// The average is 99948748093.

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
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
ArgumentNullException ArgumentNullException
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);
}

// This code produces the following output:


//
// 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
Concatena duas sequências.
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
IEnumerable<TSource>
Um IEnumerable<T> que contém os elementos concatenados das duas sequências de entrada.
Exceptions
ArgumentNullException ArgumentNullException
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
{
public string Name { get; set; }
public int Age { get; set; }
}

static Pet[] GetCats()


{
Pet[] cats = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };
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();

IEnumerable<string> query =
cats.Select(cat => cat.Name).Concat(dogs.Select(dog => dog.Name));

foreach (string name in query)


{
Console.WriteLine(name);
}
}

// This code produces the following output:


//
// 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.
Pet[] cats = GetCats();
Pet[] dogs = GetDogs();

IEnumerable<string> query =
new[] { cats.Select(cat => cat.Name), dogs.Select(dog => dog.Name) }
.SelectMany(name => name);

foreach (string name in query)


{
Console.WriteLine(name);
}

// This code produces the following output:


//
// Barley
// Boots
// Whiskers
// Bounder
// Snoopy
// Fido

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

Contains<TSource>(IEnumerable<TSource>, TSource)
Contains<TSource>(IEnumerable<TSource>, TSource)
Determina se uma sequência contém um elemento especificado usando o comparador de igualdade padrão.
public static bool Contains<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
TSource value);
static member Contains : seq<'Source> * 'Source -> bool

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
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
ArgumentNullException ArgumentNullException
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[] fruits = { "apple", "banana", "mango", "orange", "passionfruit", "grape" };

string fruit = "mango";

bool hasMango = fruits.Contains(fruit);

Console.WriteLine(
"The array {0} contain '{1}'.",
hasMango ? "does" : "does not",
fruit);

// This code produces the following output:


//
// 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>)
Determina se uma sequência contém um elemento especificado usando um IEqualityComparer<T> especificado.

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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência na qual um valor será localizado.
value TSource TSource
O valor a ser localizado na sequência.
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
ArgumentNullException ArgumentNullException
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 string Name { get; set; }
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>
(IEnumerable<TSource>)
Retorna o número de elementos em uma sequência.
public static int Count<TSource> (this System.Collections.Generic.IEnumerable<TSource> source);
static member Count : seq<'Source> -> int

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
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
ArgumentNullException ArgumentNullException
source é null .
OverflowException OverflowException
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.
string[] fruits = { "apple", "banana", "mango", "orange", "passionfruit", "grape" };

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

// This code produces the following output:


//
// 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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
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,
Func<TSource,bool> predicate);
static member Count : seq<'Source> * Func<'Source, bool> -> int

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência que contém os elementos a serem testados e contados.
predicate Func<TSource,Boolean>
Uma função para testar cada elemento em relação a uma condição.
Returns
Int32 Int32
Um número que representa quantos elementos na sequência atendem à condição na função de predicado.
Exceptions
ArgumentNullException ArgumentNullException
source ou predicate é null .
OverflowException OverflowException
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>,
Func<TSource,Boolean>) para contar os elementos em uma matriz que satisfazem uma condição.
class Pet
{
public string Name { get; set; }
public bool Vaccinated { get; set; }
}

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

// This code produces the following output:


//
// 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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also
Enumerable.DefaultIfEmpty Enumerable.DefaultIfEmpty
I n this Article

Overloads
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)
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.

DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)
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.
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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
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
IEnumerable<TSource>
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 string Name { get; set; }
public int Age { get; set; }
}

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 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

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

/*
This code produces the following output:

Name: Barley
Name: Boots
Name: Whiskers

Name: Default Pet


*/

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.

Esse método pode ser usado para produzir uma junção externa esquerda quando ele é combinado com o GroupJoin)
método.
See IngressandoJoining
Also

DefaultIfEmpty<TSource>(IEnumerable<TSource>)
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.
public static System.Collections.Generic.IEnumerable<TSource> DefaultIfEmpty<TSource> (this
System.Collections.Generic.IEnumerable<TSource> source);
static member DefaultIfEmpty : seq<'Source> -> seq<'Source>

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
A sequência para a qual será retornado um valor padrão se ela estiver vazia.
Returns
IEnumerable<TSource>
Um objeto IEnumerable<T> que contém o valor padrão do tipo TSource se source estiver vazio; caso contrário,
source .

Exceptions
ArgumentNullException ArgumentNullException
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
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void DefaultIfEmptyEx1()


{
List<Pet> pets =
new List<Pet>{ new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

foreach (Pet pet in pets.DefaultIfEmpty())


{
Console.WriteLine(pet.Name);
}
}

/*
This code produces the following output:

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

/*
This code produces the following output:

0
*/

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 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.
See IngressandoJoining
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>
(IEnumerable<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
System.Collections.Generic.IEnumerable<TSource> source);
static member Distinct : seq<'Source> -> seq<'Source>

Type Parameters
TSource
O tipo dos elementos de source .

Parameters
source IEnumerable<TSource>
A sequência da qual os elementos duplicados serão removidos.
Returns
IEnumerable<TSource>
Um IEnumerable<T> que contém elementos distintos da sequência de origem.
Exceptions
ArgumentNullException ArgumentNullException
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);
}

/*
This code produces the following output:

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 string Name { get; set; }
public int Code { get; set; }

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;

//Check whether the products' properties are equal.


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

// If Equals() returns true for a pair of objects


// then GetHashCode() must return the same value for these objects.

public override int GetHashCode()


{

//Get hash code for the Name field if it is not null.


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

//Get hash code for the Code field.


int hashProductCode = Code.GetHashCode();

//Calculate the hash code for the product.


return hashProductName ^ hashProductCode;
}
}

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 = "orange", Code = 4 },
new Product { Name = "apple", Code = 9 },
new Product { Name = "lemon", Code = 12 } };

//Exclude duplicates.

IEnumerable<Product> noduplicates =
products.Distinct();

foreach (var product in noduplicates)


Console.WriteLine(product.Name + " " + product.Code);

/*
This code produces the following output:
apple 9
orange 4
lemon 12
*/

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 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>)
Retorna os elementos distintos de uma sequência usando um IEqualityComparer<T> especificado para comparar
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
O tipo dos elementos de source .

Parameters
source IEnumerable<TSource>
A sequência da qual os elementos duplicados serão removidos.
comparer IEqualityComparer<TSource>
Um IEqualityComparer<T> para comparar valores.
Returns
IEnumerable<TSource>
Um IEnumerable<T> que contém elementos distintos da sequência de origem.
Exceptions
ArgumentNullException ArgumentNullException
source é null .
Examples
O exemplo a seguir mostra como implementar um comparador de igualdade que pode ser usado no Distinct método.
public class Product
{
public string Name { get; set; }
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 Distinct método,
conforme mostrado no exemplo a seguir.
Product[] products = { new Product { Name = "apple", Code = 9 },
new Product { Name = "orange", Code = 4 },
new Product { Name = "apple", Code = 9 },
new Product { Name = "lemon", Code = 12 } };

//Exclude duplicates.

IEnumerable<Product> noduplicates =
products.Distinct(new ProductComparer());

foreach (var product in noduplicates)


Console.WriteLine(product.Name + " " + product.Code);

/*
This code produces the following output:
apple 9
orange 4
lemon 12
*/

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 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
Retorna o elemento de um índice especificado em uma sequência.
public static TSource ElementAt<TSource> (this System.Collections.Generic.IEnumerable<TSource>
source, int index);
static member ElementAt : seq<'Source> * int -> 'Source

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
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
ArgumentNullException ArgumentNullException
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
Retorna o elemento em um índice especificado em uma sequência ou um valor padrão se o índice estiver fora do
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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
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
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
ArgumentNullException ArgumentNullException
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",
"Hedlund, Magnus", "Ito, Shu" };

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

/*
This code produces the following output:

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.
O valor padrão para referência e tipos que permitem valor nulos é null .
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
IEnumerable<TResult>
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",
"Hedlund, Magnus", "Ito, Shu" };
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)


{
Console.WriteLine(name);
}

/*
This code produces the following output:

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>)
Produz a diferença de conjunto de duas sequências usando o comparador de igualdade padrão para comparar os
valores.
public static System.Collections.Generic.IEnumerable<TSource> Except<TSource> (this
System.Collections.Generic.IEnumerable<TSource> first,
System.Collections.Generic.IEnumerable<TSource> second);
static member Except : seq<'Source> * seq<'Source> -> seq<'Source>

Type Parameters
TSource
O tipo dos elementos das sequências de entrada.
Parameters
first IEnumerable<TSource>
Um IEnumerable<T> cujos elementos que não estão presentes também no second serão retornados.
second IEnumerable<TSource>
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
IEnumerable<TSource>
Uma sequência que contém a diferença de conjunto dos elementos das duas sequências.
Exceptions
ArgumentNullException ArgumentNullException
first ou second é null .
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)


Console.WriteLine(number);

/*
This code produces the following output:

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
implementar essa interface em um tipo de dados personalizadas e fornecer GetHashCode e Equals métodos.
public class ProductA: IEquatable<ProductA>
{
public string Name { get; set; }
public int Code { get; set; }

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)


Console.WriteLine(product.Name + " " + product.Code);

/*
This code produces the following output:

orange 4
lemon 12
*/

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.

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 .
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.

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.
public static System.Collections.Generic.IEnumerable<TSource> Except<TSource> (this
System.Collections.Generic.IEnumerable<TSource> first,
System.Collections.Generic.IEnumerable<TSource> second,
System.Collections.Generic.IEqualityComparer<TSource> comparer);
static member Except : seq<'Source> * seq<'Source> *
System.Collections.Generic.IEqualityComparer<'Source> -> seq<'Source>

Type Parameters
TSource
O tipo dos elementos das sequências de entrada.
Parameters
first IEnumerable<TSource>
Um IEnumerable<T> cujos elementos que não estão presentes também no second serão retornados.

second IEnumerable<TSource>
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.
comparer IEqualityComparer<TSource>
Um IEqualityComparer<T> para comparar valores.
Returns
IEnumerable<TSource>
Uma sequência que contém a diferença de conjunto dos elementos das duas sequências.
Exceptions
ArgumentNullException ArgumentNullException
first ou second é null .
Examples
O exemplo a seguir mostra como implementar um comparador de igualdade que pode ser usado no Except método.
public class Product
{
public string Name { get; set; }
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 sequências de Product objetos no Except método, conforme
mostrado no exemplo a seguir.
Product[] fruits1 = { new Product { Name = "apple", Code = 9 },
new Product { Name = "orange", Code = 4 },
new Product { Name = "lemon", Code = 12 } };

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)


Console.WriteLine(product.Name + " " + product.Code);

/*
This code produces the following output:

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>
(IEnumerable<TSource>)
Retorna o primeiro elemento de uma sequência.
public static TSource First<TSource> (this System.Collections.Generic.IEnumerable<TSource> source);
static member First : seq<'Source> -> 'Source

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
O IEnumerable<T> do qual o primeiro elemento será retornado.
Returns
TSource TSource
O primeiro elemento na sequência especificada.
Exceptions
ArgumentNullException ArgumentNullException
source é null .
InvalidOperationException InvalidOperationException
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);

/*
This code produces the following output:

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.

First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Retorna o primeiro elemento em uma sequência que satisfaz uma condição especificada.

public static TSource First<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,


Func<TSource,bool> predicate);
static member First : seq<'Source> * Func<'Source, bool> -> 'Source

Type Parameters
TSource
O tipo dos elementos de source .

Parameters
source IEnumerable<TSource>
Um IEnumerable<T> do qual um elemento será retornado.
predicate Func<TSource,Boolean>
Uma função para testar cada elemento em relação a uma condição.
Returns
TSource TSource
O primeiro elemento na sequência que passa o teste na função de predicado especificada.
Exceptions
ArgumentNullException ArgumentNullException
source ou predicate é null .

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

Console.WriteLine(first);

/*
This code produces the following output:

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>
(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.
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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Um IEnumerable<T> do qual um elemento será retornado.
predicate Func<TSource,Boolean>
Uma função para testar cada elemento em relação a uma condição.
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
ArgumentNullException ArgumentNullException
source ou predicate é null .
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",
"Andersen, Henriette Thaulow",
"Hedlund, Magnus", "Ito, Shu" };

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

/*
This code produces the following output:

The first long name is 'Andersen, Henriette Thaulow'.


There is not a name longer than 30 characters.
*/

Remarks
O valor padrão para referência e tipos que permitem valor nulos é null .

FirstOrDefault<TSource>(IEnumerable<TSource>)
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.

public static TSource FirstOrDefault<TSource> (this System.Collections.Generic.IEnumerable<TSource>


source);
static member FirstOrDefault : seq<'Source> -> 'Source

Type Parameters
TSource
O tipo dos elementos de source .

Parameters
source IEnumerable<TSource>
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
ArgumentNullException ArgumentNullException
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();
Console.WriteLine(first);

/*
This code produces the following output:

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();
Console.WriteLine("The value of the firstMonth2 variable is {0}", firstMonth2);

/*
This code produces the following output:

The value of the firstMonth1 variable is 1


The value of the firstMonth2 variable is 1
*/

Remarks
O valor padrão para referência e tipos que permitem valor nulos é null .
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<
TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Agrupa os elementos de uma sequência de acordo com uma
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.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>,
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>)

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>, 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>)
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
O tipo dos elementos de source .
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
source IEnumerable<TSource>
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
IEnumerable<TResult>
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 string Name { get; set; }
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);
}

/* This code produces the following output:

Age group: 8
Number of pets in this age group: 1
Minimum age: 8.3
Maximum age: 8.3

Age group: 4
Number of pets in this age group: 2
Minimum age: 4.3
Maximum age: 4.9

Age group: 1
Number of pets in this 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)

GroupBy<TSource,TKey,TElement,TResult>
(IEnumerable<TSource>, Func<TSource,TKey>,
Func<TSource,TElement>,
Func<TKey,IEnumerable<TElement>,TResult>,
IEqualityComparer<TKey>)
GroupBy<TSource,TKey,TElement,TResult>
(IEnumerable<TSource>, Func<TSource,TKey>,
Func<TSource,TElement>,
Func<TKey,IEnumerable<TElement>,TResult>,
IEqualityComparer<TKey>)
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 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
O tipo dos elementos de source .
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
source IEnumerable<TSource>
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.
comparer IEqualityComparer<TKey>
Um IEqualityComparer<T> com o qual as chaves serão comparadas.
Returns
IEnumerable<TResult>
Uma coleção de elementos do tipo TResult , em que cada elemento representa uma projeção em um grupo e sua
chave.
See Cláusula group (Referência de C#)group clause (C# Reference)
Also Cláusula Group By (Visual Basic)Group By Clause (Visual Basic)

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>,
Func<TSource,TKey>, Func<TSource,TElement>)
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.

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
O tipo dos elementos de source .
TKey
O tipo da chave retornada por keySelector .
TElement
O tipo dos elementos no IGrouping<TKey,TElement>.
Parameters
source IEnumerable<TSource>
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 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
ArgumentNullException ArgumentNullException
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
{
public string Name { get; set; }
public int Age { get; set; }
}

// Uses method-based query syntax.


public static void GroupByEx1()
{
// Create a list of pets.
List<Pet> pets =
new List<Pet>{ new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
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);
}
}

/*
This code produces the following output:

8
Barley
4
Boots
Daisy
1
Whiskers
*/
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. A conversão da expressão de consulta no exemplo a seguir é equivalente à consulta no
exemplo acima.

IEnumerable<IGrouping<int, string>> query =


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
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 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.


See Cláusula group (Referência de C#)group clause (C# Reference)
Also Cláusula Group By (Visual Basic)Group By Clause (Visual Basic)

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>, 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,
System.Collections.Generic.IEqualityComparer<TKey> comparer);
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
O tipo dos elementos de source .

TKey
O tipo da chave retornada por keySelector .

TElement
O tipo dos elementos no IGrouping<TKey,TElement>.
Parameters
source IEnumerable<TSource>
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>.
comparer IEqualityComparer<TKey>
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
ArgumentNullException ArgumentNullException
source , keySelector ou elementSelector é null .
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.
Note

Para obter exemplos de GroupBy , consulte os tópicos a seguir.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)


GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>,
Func<TKey,IEnumerable<TSource>,TResult>)
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>,
Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)
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.
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 .

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.
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. Para obter mais informações e exemplos de uso, consulte cláusula group e por
cláusula Group.
See Cláusula group (Referência de C#)group clause (C# Reference)
Also Cláusula Group By (Visual Basic)Group By Clause (Visual Basic)

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>,
Func<TSource,TKey>,
Func<TKey,IEnumerable<TSource>,TResult>)
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>,
Func<TSource,TKey>,
Func<TKey,IEnumerable<TSource>,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.

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
O tipo dos elementos de source .

TKey
O tipo da chave retornada por keySelector .

TResult
O tipo do valor de resultado retornado por resultSelector .

Parameters
source IEnumerable<TSource>
Um IEnumerable<T> cujos elementos serão agrupados.
keySelector Func<TSource,TKey>
Uma função para extrair a chave de cada elemento.
resultSelector Func<TKey,IEnumerable<TSource>,TResult>
Uma função para criar um valor de resultado de cada grupo.
Returns
IEnumerable<TResult>
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,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
{
public string Name { get; set; }
public double Age { get; set; }
}

public static void GroupByEx3()


{
// 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 objects by the Math.Floor of their 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),
(age, pets) => new
{
Key = age,
Count = pets.Count(),
Min = pets.Min(pet => pet.Age),
Max = pets.Max(pet => pet.Age)
});

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

/* This code produces the following output:

Age group: 8
Number of pets in this age group: 1
Minimum age: 8.3
Maximum age: 8.3

Age group: 4
Number of pets in this age group: 2
Minimum age: 4.3
Maximum age: 4.9

Age group: 1
Number of pets in this 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)

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>,
Func<TSource,TKey>,
Func<TKey,IEnumerable<TSource>,TResult>,
IEqualityComparer<TKey>) GroupBy<TSource,TKey,TResult>
(IEnumerable<TSource>, Func<TSource,TKey>,
Func<TKey,IEnumerable<TSource>,TResult>,
IEqualityComparer<TKey>)
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. As chaves são comparadas usando um comparador especificado.
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,
System.Collections.Generic.IEqualityComparer<TKey> comparer);
static member GroupBy : seq<'Source> * Func<'Source, 'Key> * Func<'Key, seq<'Source>, 'Result> *
System.Collections.Generic.IEqualityComparer<'Key> -> seq<'Result>

Type Parameters
TSource
O tipo dos elementos de source .

TKey
O tipo da chave retornada por keySelector .

TResult
O tipo do valor de resultado retornado por resultSelector .

Parameters
source IEnumerable<TSource>
Um IEnumerable<T> cujos elementos serão agrupados.
keySelector Func<TSource,TKey>
Uma função para extrair a chave de cada elemento.
resultSelector Func<TKey,IEnumerable<TSource>,TResult>
Uma função para criar um valor de resultado de cada grupo.
comparer IEqualityComparer<TKey>
Um IEqualityComparer<T> com o qual as chaves serão comparadas.
Returns
IEnumerable<TResult>
Uma coleção de elementos do tipo TResult , em que cada elemento representa uma projeção em um grupo e sua
chave.
See Cláusula group (Referência de C#)group clause (C# Reference)
Also Cláusula Group By (Visual Basic)Group By Clause (Visual Basic)

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.

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
O tipo dos elementos de source .

TKey
O tipo da chave retornada por keySelector .

Parameters
source IEnumerable<TSource>
Um IEnumerable<T> cujos elementos serão agrupados.
keySelector Func<TSource,TKey>
Uma função para extrair a chave de cada elemento.
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
ArgumentNullException ArgumentNullException
source ou keySelector é null .
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.
Note

Para obter exemplos de GroupBy , consulte os tópicos a seguir.


GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>,
Func<TKey,IEnumerable<TSource>,TResult>)
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>,
Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)
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.
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 aparecem no source .
O comparador de igualdade padrão Default é usado para comparar chaves.
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. Para obter mais informações e exemplos de uso, consulte cláusula group e por
cláusula Group.
See Cláusula group (Referência de C#)group clause (C# Reference)
Also Cláusula Group By (Visual Basic)Group By Clause (Visual Basic)

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.
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
O tipo dos elementos de source .
TKey
O tipo da chave retornada por keySelector .
Parameters
source IEnumerable<TSource>
Um IEnumerable<T> cujos elementos serão agrupados.
keySelector Func<TSource,TKey>
Uma função para extrair a chave de cada elemento.
comparer IEqualityComparer<TKey>
Um IEqualityComparer<T> para comparar chaves.
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
ArgumentNullException ArgumentNullException
source ou keySelector é null .
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.
Note

Para obter exemplos de GroupBy , consulte os tópicos a seguir.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)


GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>,
Func<TKey,IEnumerable<TSource>,TResult>)
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>,
Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)
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.
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 aparecem no 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.
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. Para obter mais informações e exemplos de uso, consulte cláusula group e por
cláusula Group.
See Cláusula group (Referência de C#)group clause (C# Reference)
Also Cláusula Group By (Visual Basic)Group By Clause (Visual Basic)
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>,
IEqualityComparer<TKey>)
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.
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,
System.Collections.Generic.IEqualityComparer<TKey> comparer);
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.
comparer IEqualityComparer<TKey>
Um IEqualityComparer<T> para executar hash e comparar chaves.
Returns
IEnumerable<TResult>
Um IEnumerable<T> que contém elementos do tipo TResult obtidos pela execução de uma junção agrupada em
duas sequências.
Exceptions
ArgumentNullException ArgumentNullException
outer ou inner ou outerKeySelector ou innerKeySelector ou resultSelector é null .
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.

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

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<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>)
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.
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
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.
Returns
IEnumerable<TResult>
Um IEnumerable<T> que contém elementos do tipo TResult obtidos pela execução de uma junção agrupada em
duas sequências.
Exceptions
ArgumentNullException ArgumentNullException
outer ou inner ou outerKeySelector ou innerKeySelector ou resultSelector é null .
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
{
public string Name { get; set; }
}

class Pet
{
public string Name { get; set; }
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);
}
}
}

/*
This code produces the following output:

Hedlund, Magnus:
Daisy
Adams, Terry:
Barley
Boots
Weiss, Charlotte:
Whiskers
*/

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 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
IEnumerable<TSource>) comparador de igualdade padrão para comparar os valores.

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.
public static System.Collections.Generic.IEnumerable<TSource> Intersect<TSource> (this
System.Collections.Generic.IEnumerable<TSource> first,
System.Collections.Generic.IEnumerable<TSource> second,
System.Collections.Generic.IEqualityComparer<TSource> comparer);
static member Intersect : seq<'Source> * seq<'Source> *
System.Collections.Generic.IEqualityComparer<'Source> -> seq<'Source>

Type Parameters
TSource
O tipo dos elementos das sequências de entrada.
Parameters
first IEnumerable<TSource>
Um IEnumerable<T> cujos elementos distintos que também aparecem em second serão retornados.
second IEnumerable<TSource>
Um IEnumerable<T> cujos elementos distintos que também aparecem na primeira sequência serão retornados.
comparer IEqualityComparer<TSource>
Um IEqualityComparer<T> para comparar valores.
Returns
IEnumerable<TSource>
Uma sequência que contém os elementos que formam a interseção de conjunto de duas sequências.
Exceptions
ArgumentNullException ArgumentNullException
first ou second é null .
Examples
O exemplo a seguir mostra como implementar um comparador de igualdade que pode ser usado no Intersect método.
public class Product
{
public string Name { get; set; }
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 sequências de Product objetos no Intersect método,
conforme mostrado no exemplo a seguir.

Product[] store1 = { new Product { Name = "apple", Code = 9 },


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

Product[] store2 = { new Product { Name = "apple", Code = 9 },


new Product { Name = "lemon", Code = 12 } };
// 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)


Console.WriteLine(product.Name + " " + product.Code);

/*
This code produces the following output:
apple 9
*/

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.

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 .
Se comparer está null , o comparador de igualdade padrão, Default, é usado para comparar 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.

public static System.Collections.Generic.IEnumerable<TSource> Intersect<TSource> (this


System.Collections.Generic.IEnumerable<TSource> first,
System.Collections.Generic.IEnumerable<TSource> second);
static member Intersect : seq<'Source> * seq<'Source> -> seq<'Source>

Type Parameters
TSource
O tipo dos elementos das sequências de entrada.
Parameters
first IEnumerable<TSource>
Um IEnumerable<T> cujos elementos distintos que também aparecem em second serão retornados.

second IEnumerable<TSource>
Um IEnumerable<T> cujos elementos distintos que também aparecem na primeira sequência serão retornados.
Returns
IEnumerable<TSource>
Uma sequência que contém os elementos que formam a interseção de conjunto de duas sequências.
Exceptions
ArgumentNullException ArgumentNullException
first ou second é null .
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);

/*
This code produces the following output:

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
implementar essa interface em um tipo de dados personalizadas e fornecer GetHashCode e Equals métodos.
public class ProductA: IEquatable<ProductA>
{
public string Name { get; set; }
public int Code { get; set; }

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 Intersect método, conforme
mostrado no exemplo a seguir.

ProductA[] store1 = { new ProductA { Name = "apple", Code = 9 },


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

ProductA[] store2 = { new ProductA { Name = "apple", Code = 9 },


new ProductA { Name = "lemon", Code = 12 } };
// 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)


Console.WriteLine(product.Name + " " + product.Code);

/*
This code produces the following output:
apple 9
*/

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.

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 .

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.
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.
Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,
TInner,TResult>)

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>, IEqualityComparer< chaves de correspondência. Um IEqualityComparer<T>
TKey>) Join<TOuter,TInner,TKey,TResult>(IEnumerable< especificado é usado para comparar chaves.
TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<
TInner,TKey>, Func<TOuter,TInner,TResult>, IEquality
Comparer<TKey>)

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>,
IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,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
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,TInner,TResult>
Uma função para criar um elemento de resultado de dois elementos correspondentes.
Returns
IEnumerable<TResult>
Um IEnumerable<T> com elementos do tipo TResult obtidos pela execução de uma junção interna em duas
sequências.
Exceptions
ArgumentNullException ArgumentNullException
outer ou inner ou outerKeySelector ou innerKeySelector ou resultSelector é null .
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
{
public string Name { get; set; }
}

class Pet
{
public string Name { get; set; }
public Person Owner { get; set; }
}

public static void JoinEx1()


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

foreach (var obj in query)


{
Console.WriteLine(
"{0} - {1}",
obj.OwnerName,
obj.Pet);
}
}

/*
This code produces the following output:

Hedlund, Magnus - Daisy


Adams, Terry - Barley
Adams, Terry - Boots
Weiss, Charlotte - Whiskers
*/

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 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.
See IngressandoJoining
Also Cláusula join (Referência de C#)join clause (C# Reference)
Cláusula Join (Visual Basic)Join Clause (Visual Basic)

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>,
IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>,
Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>,
IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>,
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
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,TInner,TResult>
Uma função para criar um elemento de resultado de dois elementos correspondentes.
comparer IEqualityComparer<TKey>
Um IEqualityComparer<T> para executar hash e comparar chaves.
Returns
IEnumerable<TResult>
Um IEnumerable<T> com elementos do tipo TResult obtidos pela execução de uma junção interna em duas
sequências.
Exceptions
ArgumentNullException ArgumentNullException
outer ou inner ou outerKeySelector ou innerKeySelector ou resultSelector é null .
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.

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.
See IngressandoJoining
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>
(IEnumerable<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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
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
ArgumentNullException ArgumentNullException
source é null .
InvalidOperationException InvalidOperationException
Uma sequência de origem está vazia.
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);

/*
This code produces the following output:

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.

Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Retorna o último elemento de uma sequência que satisfaz uma condição especificada.

public static TSource Last<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,


Func<TSource,bool> predicate);
static member Last : seq<'Source> * Func<'Source, bool> -> 'Source

Type Parameters
TSource
O tipo dos elementos de source .

Parameters
source IEnumerable<TSource>
Um IEnumerable<T> do qual um elemento será retornado.
predicate Func<TSource,Boolean>
Uma função para testar cada elemento em relação a uma condição.
Returns
TSource TSource
O último elemento na sequência que passa o teste na função de predicado especificada.
Exceptions
ArgumentNullException ArgumentNullException
source ou predicate é null .

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

Console.WriteLine(last);

/*
This code produces the following output:

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
padrão se a sequência não contém elementos.

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.

LastOrDefault<TSource>(IEnumerable<TSource>)
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.

public static TSource LastOrDefault<TSource> (this System.Collections.Generic.IEnumerable<TSource>


source);
static member LastOrDefault : seq<'Source> -> 'Source

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
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
ArgumentNullException ArgumentNullException
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);

/*
This code produces the following output:

<string is null or empty>


*/

À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 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> { };

// Setting the default value to 1 after the query.


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

// Setting the default value to 1 by using DefaultIfEmpty() in the query.


int lastDay2 = daysOfMonth.DefaultIfEmpty(1).Last();
Console.WriteLine("The value of the lastDay2 variable is {0}", lastDay2);

/*
This code produces the following output:

The value of the lastDay1 variable is 1


The value of the lastDay2 variable is 1
*/

Remarks
O valor padrão para referência e tipos que permitem valor nulos é null .
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>
(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 não
seja encontrado.
public static TSource LastOrDefault<TSource> (this System.Collections.Generic.IEnumerable<TSource>
source, Func<TSource,bool> predicate);
static member LastOrDefault : seq<'Source> * Func<'Source, bool> -> 'Source

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Um IEnumerable<T> do qual um elemento será retornado.
predicate Func<TSource,Boolean>
Uma função para testar cada elemento em relação a uma condição.
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
ArgumentNullException ArgumentNullException
source ou predicate é null .
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());

/*
This code produces the following output:

The last number that rounds to 50 is 50.2.


The last number that rounds to 40 is <DOES NOT EXIST>.
*/

Remarks
O valor padrão para referência e tipos que permitem valor nulos é null .
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>
(IEnumerable<TSource>, Func<TSource,Boolean>)
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,
Func<TSource,bool> predicate);
static member LongCount : seq<'Source> * Func<'Source, bool> -> int64

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Um IEnumerable<T> que contém os elementos a serem contados.
predicate Func<TSource,Boolean>
Uma função para testar cada elemento em relação a uma condição.
Returns
Int64 Int64
Um número que representa quantos elementos na sequência atendem à condição na função de predicado.
Exceptions
ArgumentNullException ArgumentNullException
source ou predicate é null .
OverflowException OverflowException
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 string Name { get; set; }
public int Age { get; set; }
}

public static void LongCountEx2()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

const int Age = 3;

long count = pets.LongCount(pet => pet.Age > Age);

Console.WriteLine("There are {0} animals over age {1}.", count, Age);


}

/*
This code produces the following output:

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

LongCount<TSource>(IEnumerable<TSource>)
LongCount<TSource>(IEnumerable<TSource>)
Retorna um Int64 que representa o número total de elementos em uma sequência.
public static long LongCount<TSource> (this System.Collections.Generic.IEnumerable<TSource> source);
static member LongCount : seq<'Source> -> int64

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
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
ArgumentNullException ArgumentNullException
source é null .

OverflowException OverflowException
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
elementos em uma matriz.

string[] fruits = { "apple", "banana", "mango",


"orange", "passionfruit", "grape" };

long count = fruits.LongCount();

Console.WriteLine("There are {0} fruits in the collection.", count);

/*
This code produces the following output:

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
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>)
Retorna o valor máximo em uma sequência de valores 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>)
Retorna o valor máximo em uma sequência de valores 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<Int64>) Max(IEnumerable<Int64>)
Retorna o valor máximo em uma sequência de valores Int64.

Max(IEnumerable<Double>) Max(IEnumerable<Double>)
Retorna o valor máximo em uma sequência de valores 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.
Max<TSource>(IEnumerable<TSource>, Func<TSource,
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.

Max<TSource>(IEnumerable<TSource>, Func<TSource,
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.

Max<TSource>(IEnumerable<TSource>, Func<TSource,
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.

Max<TSource>(IEnumerable<TSource>, Func<TSource,
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.

Max<TSource>(IEnumerable<TSource>, Func<TSource,
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.

Max<TSource>(IEnumerable<TSource>, Func<TSource,
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.

Max<TSource>(IEnumerable<TSource>, Func<TSource,
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.

Max<TSource>(IEnumerable<TSource>, Func<TSource,
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.

Max<TSource>(IEnumerable<TSource>, Func<TSource,
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.

Max(IEnumerable<Nullable<Single>>)
Max(IEnumerable<Nullable<Single>>)
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
source IEnumerable<Nullable<Single>>
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
ArgumentNullException ArgumentNullException
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

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.

double?[] doubles = { null, 1.5E+104, 9E+103, -2E+103 };

double? max = doubles.Max();

Console.WriteLine("The largest number is {0}.", max);

/*
This code produces the following output:

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Max(IEnumerable<Int32>) Max(IEnumerable<Int32>)
Retorna o valor máximo em uma sequência de valores Int32.

public static int Max (this System.Collections.Generic.IEnumerable<int> source);


static member Max : seq<int> -> int

Parameters
source IEnumerable<Int32>
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
ArgumentNullException ArgumentNullException
source é null .

InvalidOperationException InvalidOperationException
source não contém elementos.
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

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<long> longs = new List<long> { 4294967296L, 466855135L, 81125L };

long max = longs.Max();

Console.WriteLine("The largest number is {0}.", max);

/*
This code produces the following output:

The largest number is 4294967296.


*/

Remarks
O Max(IEnumerable<Int32>) usa o Int32 implementação de IComparable<T> para comparar valores.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Max() cláusula se traduz em uma
invocação de Max.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Max(IEnumerable<Nullable<Int64>>)
Max(IEnumerable<Nullable<Int64>>)
Retorna o valor máximo em uma sequência de valores Int64 anuláveis.

public static Nullable<long> Max (this System.Collections.Generic.IEnumerable<Nullable<long>>


source);
static member Max : seq<Nullable<int64>> -> Nullable<int64>
Parameters
source IEnumerable<Nullable<Int64>>
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
ArgumentNullException ArgumentNullException
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

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.

double?[] doubles = { null, 1.5E+104, 9E+103, -2E+103 };

double? max = doubles.Max();

Console.WriteLine("The largest number is {0}.", max);

/*
This code produces the following output:

The largest number is 1.5E+104.


*/

Remarks
O Max(IEnumerable<Nullable<Int64>>) usa o Int64 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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Max(IEnumerable<Single>) Max(IEnumerable<Single>)
Retorna o valor máximo em uma sequência de valores Single.

public static float Max (this System.Collections.Generic.IEnumerable<float> source);


static member Max : seq<single> -> single

Parameters
source IEnumerable<Single>
Uma sequência de valores Single da qual será determinado o valor máximo.
Returns
Single Single
O valor máximo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source é null .

InvalidOperationException InvalidOperationException
source não contém elementos.
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

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<long> longs = new List<long> { 4294967296L, 466855135L, 81125L };

long max = longs.Max();

Console.WriteLine("The largest number is {0}.", max);

/*
This code produces the following output:

The largest number is 4294967296.


*/

Remarks
O Max(IEnumerable<Single>) usa o Single implementação de IComparable<T> para comparar valores.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Max() cláusula se traduz em uma
invocação de Max.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Max(IEnumerable<Nullable<Int32>>)
Max(IEnumerable<Nullable<Int32>>)
Retorna o valor máximo em uma sequência de valores Int32 anuláveis.

public static Nullable<int> Max (this System.Collections.Generic.IEnumerable<Nullable<int>> source);


static member Max : seq<Nullable<int>> -> Nullable<int>

Parameters
source IEnumerable<Nullable<Int32>>
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
ArgumentNullException ArgumentNullException
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

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.

double?[] doubles = { null, 1.5E+104, 9E+103, -2E+103 };

double? max = doubles.Max();

Console.WriteLine("The largest number is {0}.", max);

/*
This code produces the following output:

The largest number is 1.5E+104.


*/

Remarks
O Max(IEnumerable<Nullable<Int32>>) usa o Int32 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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
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
source IEnumerable<Decimal>
Uma sequência de valores Decimal da qual será determinado o valor máximo.
Returns
Decimal Decimal
O valor máximo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source é null .

InvalidOperationException InvalidOperationException
source não contém elementos.
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

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<long> longs = new List<long> { 4294967296L, 466855135L, 81125L };

long max = longs.Max();

Console.WriteLine("The largest number is {0}.", max);

/*
This code produces the following output:

The largest number is 4294967296.


*/

Remarks
O Max(IEnumerable<Decimal>) usa o Decimal implementação de IComparable<T> para comparar valores.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Max() cláusula se traduz em uma
invocação de Max.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Max(IEnumerable<Nullable<Decimal>>)
Max(IEnumerable<Nullable<Decimal>>)
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
source IEnumerable<Nullable<Decimal>>
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
máximo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
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

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.

double?[] doubles = { null, 1.5E+104, 9E+103, -2E+103 };

double? max = doubles.Max();

Console.WriteLine("The largest number is {0}.", max);

/*
This code produces the following output:

The largest number is 1.5E+104.


*/

Remarks
O Max(IEnumerable<Nullable<Decimal>>) usa o Decimal 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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Max(IEnumerable<Int64>) Max(IEnumerable<Int64>)
Retorna o valor máximo em uma sequência de valores Int64.

public static long Max (this System.Collections.Generic.IEnumerable<long> source);


static member Max : seq<int64> -> int64

Parameters
source IEnumerable<Int64>
Uma sequência de valores Int64 da qual será determinado o valor máximo.
Returns
Int64 Int64
O valor máximo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source é null .
InvalidOperationException InvalidOperationException
source não contém elementos.
Examples
O exemplo de código a seguir demonstra como usar Max(IEnumerable<Int64>) para determinar o valor máximo em
uma sequência.

List<long> longs = new List<long> { 4294967296L, 466855135L, 81125L };

long max = longs.Max();

Console.WriteLine("The largest number is {0}.", max);

/*
This code produces the following output:

The largest number is 4294967296.


*/

Remarks
O Max(IEnumerable<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 Max() cláusula se traduz em uma
invocação de Max.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Max(IEnumerable<Double>) Max(IEnumerable<Double>)
Retorna o valor máximo em uma sequência de valores Double.

public static double Max (this System.Collections.Generic.IEnumerable<double> source);


static member Max : seq<double> -> double

Parameters
source IEnumerable<Double>
Uma sequência de valores Double da qual será determinado o valor máximo.
Returns
Double Double
O valor máximo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source é null .

InvalidOperationException InvalidOperationException
source não contém elementos.
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

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<long> longs = new List<long> { 4294967296L, 466855135L, 81125L };

long max = longs.Max();

Console.WriteLine("The largest number is {0}.", max);

/*
This code produces the following output:

The largest number is 4294967296.


*/

Remarks
O Max(IEnumerable<Double>) usa o Double implementação de IComparable<T> para comparar valores.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Max() cláusula se traduz em uma
invocação de Max.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Max(IEnumerable<Nullable<Double>>)
Max(IEnumerable<Nullable<Double>>)
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
source IEnumerable<Nullable<Double>>
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
máximo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
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.
double?[] doubles = { null, 1.5E+104, 9E+103, -2E+103 };

double? max = doubles.Max();

Console.WriteLine("The largest number is {0}.", max);

/*
This code produces the following output:

The largest number is 1.5E+104.


*/

Remarks
O Max(IEnumerable<Nullable<Double>>) usa o Double 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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
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
O tipo dos elementos de source .

TResult
O tipo do valor retornado por selector .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor máximo.
selector Func<TSource,TResult>
Uma função de transformação a ser aplicada a cada elemento.
Returns
TResult TResult
O valor máximo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
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

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 a este tópico, altere o corpo da função selector .

class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MaxEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int max = pets.Max(pet => pet.Age + pet.Name.Length);

Console.WriteLine(
"The maximum pet age plus name length is {0}.",
max);
}

/*
This code produces the following output:

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.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Max() cláusula se traduz em uma
invocação de Max.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)
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.
public static float Max<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,float> selector);
static member Max : seq<'Source> * Func<'Source, single> -> single

Type Parameters
TSource
O tipo dos elementos de source .

Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor máximo.
selector Func<TSource,Single>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Single Single
O valor máximo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .

InvalidOperationException InvalidOperationException
source não contém elementos.
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

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 a este tópico, altere o corpo da função selector .
class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MaxEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int max = pets.Max(pet => pet.Age + pet.Name.Length);

Console.WriteLine(
"The maximum pet age plus name length is {0}.",
max);
}

/*
This code produces the following output:

The maximum pet age plus name length is 14.


*/

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.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Max() cláusula se traduz em uma
invocação de Max.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

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.

public static Nullable<float> Max<TSource> (this System.Collections.Generic.IEnumerable<TSource>


source, Func<TSource,Nullable<float>> selector);
static member Max : seq<'Source> * Func<'Source, Nullable<single>> -> Nullable<single>

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor máximo.
selector Func<TSource,Nullable<Single>>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Nullable<Single>
O valor do tipo Nullable<Single> em C# ou Nullable(Of Single) no Visual Basic que corresponde ao valor
máximo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
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

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 a este tópico, altere o corpo da função selector .

class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MaxEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int max = pets.Max(pet => pet.Age + pet.Name.Length);

Console.WriteLine(
"The maximum pet age plus name length is {0}.",
max);
}

/*
This code produces the following output:

The maximum pet age plus name length is 14.


*/

Remarks
O Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<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 Nullable<Single> em c# ou
Nullable(Of Single) no Visual Basic.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Max() cláusula se traduz em uma
invocação de Max.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Max<TSource>(IEnumerable<TSource>,
Func<TSource,Nullable<Int64>>) 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.

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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor máximo.
selector Func<TSource,Nullable<Int64>>
Uma função de transformação a ser aplicada a cada elemento.
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
ArgumentNullException ArgumentNullException
source ou selector é null .
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

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 a este tópico, altere o corpo da função selector .
class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MaxEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int max = pets.Max(pet => pet.Age + pet.Name.Length);

Console.WriteLine(
"The maximum pet age plus name length is {0}.",
max);
}

/*
This code produces the following output:

The maximum pet age plus name length is 14.


*/

Remarks
O Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) usa o Int64 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 Nullable<Int64> em c# ou
Nullable(Of Int64) no Visual Basic.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Max() cláusula se traduz em uma
invocação de Max.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Max<TSource>(IEnumerable<TSource>,
Func<TSource,Nullable<Int32>>) Max<TSource>
(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int32 máximo que
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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor máximo.
selector Func<TSource,Nullable<Int32>>
Uma função de transformação a ser aplicada a cada elemento.
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
ArgumentNullException ArgumentNullException
source ou selector é null .
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

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 a este tópico, altere o corpo da função selector .

class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MaxEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int max = pets.Max(pet => pet.Age + pet.Name.Length);

Console.WriteLine(
"The maximum pet age plus name length is {0}.",
max);
}

/*
This code produces the following output:

The maximum pet age plus name length is 14.


*/

Remarks
O Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) usa o Int32 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 Nullable<Int32> em c# ou
Nullable(Of Int32) no Visual Basic.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Max() cláusula se traduz em uma
invocação de Max.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

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.

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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor máximo.
selector Func<TSource,Nullable<Double>>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Nullable<Double>
O valor do tipo Nullable<Double> em C# ou Nullable(Of Double) no Visual Basic que corresponde ao valor
máximo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
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

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 a este tópico, altere o corpo da função selector .
class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MaxEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int max = pets.Max(pet => pet.Age + pet.Name.Length);

Console.WriteLine(
"The maximum pet age plus name length is {0}.",
max);
}

/*
This code produces the following output:

The maximum pet age plus name length is 14.


*/

Remarks
O Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) usa o Double 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 Nullable<Double> em c# ou
Nullable(Of Double) no Visual Basic.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Max() cláusula se traduz em uma
invocação de Max.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)
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.

public static long Max<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,


Func<TSource,long> selector);
static member Max : seq<'Source> * Func<'Source, int64> -> int64

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor máximo.
selector Func<TSource,Int64>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Int64 Int64
O valor máximo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
InvalidOperationException InvalidOperationException
source não contém elementos.
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

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 a este tópico, altere o corpo da função selector .

class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MaxEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int max = pets.Max(pet => pet.Age + pet.Name.Length);

Console.WriteLine(
"The maximum pet age plus name length is {0}.",
max);
}

/*
This code produces the following output:

The maximum pet age plus name length is 14.


*/

Remarks
O Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) usa o Int64 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 Int64.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Max() cláusula se traduz em uma
invocação de Max.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int32 máximo.
public static int Max<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,int> selector);
static member Max : seq<'Source> * Func<'Source, int> -> int

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor máximo.
selector Func<TSource,Int32>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Int32 Int32
O valor máximo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
InvalidOperationException InvalidOperationException
source não contém elementos.
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.
class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MaxEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int max = pets.Max(pet => pet.Age + pet.Name.Length);

Console.WriteLine(
"The maximum pet age plus name length is {0}.",
max);
}

/*
This code produces the following output:

The maximum pet age plus name length is 14.


*/

Remarks
O Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) usa o Int32 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 Int32.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Max() cláusula se traduz em uma
invocação de Max.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)
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.
public static double Max<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,double> selector);
static member Max : seq<'Source> * Func<'Source, double> -> double

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor máximo.
selector Func<TSource,Double>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Double Double
O valor máximo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
InvalidOperationException InvalidOperationException
source não contém elementos.
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

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 a este tópico, altere o corpo da função selector .

class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MaxEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int max = pets.Max(pet => pet.Age + pet.Name.Length);

Console.WriteLine(
"The maximum pet age plus name length is {0}.",
max);
}

/*
This code produces the following output:

The maximum pet age plus name length is 14.


*/

Remarks
O Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>) usa o Double 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 Double.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Max() cláusula se traduz em uma
invocação de Max.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)
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.
public static decimal Max<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,decimal> selector);
static member Max : seq<'Source> * Func<'Source, decimal> -> decimal

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor máximo.
selector Func<TSource,Decimal>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Decimal Decimal
O valor máximo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .

InvalidOperationException InvalidOperationException
source não contém elementos.
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

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 a este tópico, altere o corpo da função selector .
class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MaxEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int max = pets.Max(pet => pet.Age + pet.Name.Length);

Console.WriteLine(
"The maximum pet age plus name length is {0}.",
max);
}

/*
This code produces the following output:

The maximum pet age plus name length is 14.


*/

Remarks
O Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) usa o Decimal 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 Decimal.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Max() cláusula se traduz em uma
invocação de Max.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Max<TSource>(IEnumerable<TSource>) Max<TSource>
(IEnumerable<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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor máximo.
Returns
TSource TSource
O valor máximo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
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>
{
public string Name { get; set; }
public int Age { get; set; }

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

public static void MaxEx3()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

Pet max = pets.Max();

Console.WriteLine(
"The 'maximum' animal is {0}.",
max.Name);
}

/*
This code produces the following output:

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 .
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Max() cláusula se traduz em uma
invocação de Max.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

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.
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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor máximo.
selector Func<TSource,Nullable<Decimal>>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Nullable<Decimal>
O valor do tipo Nullable<Decimal> em C# ou Nullable(Of Decimal) no Visual Basic que corresponde ao valor
máximo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
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

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 a este tópico, altere o corpo da função selector .

class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MaxEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int max = pets.Max(pet => pet.Age + pet.Name.Length);

Console.WriteLine(
"The maximum pet age plus name length is {0}.",
max);
}

/*
This code produces the following output:

The maximum pet age plus name length is 14.


*/

Remarks
O Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) usa o Decimal 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 Nullable<Decimal> em c# ou
Nullable(Of Decimal) no Visual Basic.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Max() cláusula se traduz em uma
invocação de Max.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
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>)
Retorna o valor mínimo em uma sequência de valores 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>)
Retorna o valor mínimo em uma sequência de valores Double.

Min(IEnumerable<Int64>) Min(IEnumerable<Int64>)
Retorna o valor mínimo em uma sequência de valores Int64.

Min(IEnumerable<Int32>) Min(IEnumerable<Int32>)
Retorna o valor mínimo em uma sequência de valores Int32.

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>)
Retorna o valor mínimo em uma sequência de valores 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.
Min<TSource>(IEnumerable<TSource>, Func<TSource,
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.

Min<TSource>(IEnumerable<TSource>, Func<TSource,
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.

Min<TSource>(IEnumerable<TSource>, Func<TSource,
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.

Min<TSource>(IEnumerable<TSource>, Func<TSource,
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.

Min<TSource>(IEnumerable<TSource>, Func<TSource,
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.

Min<TSource>(IEnumerable<TSource>, Func<TSource,
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.

Min<TSource>(IEnumerable<TSource>, Func<TSource,
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.

Min<TSource>(IEnumerable<TSource>, Func<TSource,
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.

Min<TSource>(IEnumerable<TSource>, Func<TSource,
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.

Min(IEnumerable<Nullable<Int64>>)
Min(IEnumerable<Nullable<Int64>>)
Retorna o valor mínimo em uma sequência de valores Int64 anuláveis.

public static Nullable<long> Min (this System.Collections.Generic.IEnumerable<Nullable<long>>


source);
static member Min : seq<Nullable<int64>> -> Nullable<int64>
Parameters
source IEnumerable<Nullable<Int64>>
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
ArgumentNullException ArgumentNullException
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

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.

int?[] grades = { 78, 92, null, 99, 37, 81 };

int? min = grades.Min();

Console.WriteLine("The lowest grade is {0}.", min);

/*
This code produces the following output:

The lowest grade is 37.


*/

Remarks
O Min(IEnumerable<Nullable<Int64>>) usa o Int64 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 Min() cláusula se traduz em uma
invocação de Min.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Min(IEnumerable<Nullable<Int32>>)
Min(IEnumerable<Nullable<Int32>>)
Retorna o valor mínimo em uma sequência de valores Int32 anuláveis.

public static Nullable<int> Min (this System.Collections.Generic.IEnumerable<Nullable<int>> source);


static member Min : seq<Nullable<int>> -> Nullable<int>
Parameters
source IEnumerable<Nullable<Int32>>
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
ArgumentNullException ArgumentNullException
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.

int?[] grades = { 78, 92, null, 99, 37, 81 };

int? min = grades.Min();

Console.WriteLine("The lowest grade is {0}.", min);

/*
This code produces the following output:

The lowest grade is 37.


*/

Remarks
O Min(IEnumerable<Nullable<Int32>>) usa o Int32 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 Min() cláusula se traduz em uma
invocação de Min.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Min(IEnumerable<Single>) Min(IEnumerable<Single>)
Retorna o valor mínimo em uma sequência de valores Single.

public static float Min (this System.Collections.Generic.IEnumerable<float> source);


static member Min : seq<single> -> single

Parameters
source IEnumerable<Single>
Uma sequência de valores Single para determinação do valor mínimo.
Returns
Single Single
O valor mínimo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source é null .

InvalidOperationException InvalidOperationException
source não contém elementos.
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

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.

double[] doubles = { 1.5E+104, 9E+103, -2E+103 };

double min = doubles.Min();

Console.WriteLine("The smallest number is {0}.", min);

/*
This code produces the following output:

The smallest number is -2E+103.


*/

Remarks
O Min(IEnumerable<Single>) usa o Single 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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Min(IEnumerable<Nullable<Single>>)
Min(IEnumerable<Nullable<Single>>)
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
source IEnumerable<Nullable<Single>>
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
ArgumentNullException ArgumentNullException
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

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.

int?[] grades = { 78, 92, null, 99, 37, 81 };

int? min = grades.Min();

Console.WriteLine("The lowest grade is {0}.", min);

/*
This code produces the following output:

The lowest grade is 37.


*/

Remarks
O Min(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 Min() cláusula se traduz em uma
invocação de Min.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Min(IEnumerable<Nullable<Double>>)
Min(IEnumerable<Nullable<Double>>)
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
source IEnumerable<Nullable<Double>>
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
mínimo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
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

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.
int?[] grades = { 78, 92, null, 99, 37, 81 };

int? min = grades.Min();

Console.WriteLine("The lowest grade is {0}.", min);

/*
This code produces the following output:

The lowest grade is 37.


*/

Remarks
O Min(IEnumerable<Nullable<Double>>) usa o Double 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 Min() cláusula se traduz em uma
invocação de Min.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Min(IEnumerable<Double>) Min(IEnumerable<Double>)
Retorna o valor mínimo em uma sequência de valores Double.

public static double Min (this System.Collections.Generic.IEnumerable<double> source);


static member Min : seq<double> -> double

Parameters
source IEnumerable<Double>
Uma sequência de valores Double para determinação do valor mínimo.
Returns
Double Double
O valor mínimo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source é null .
InvalidOperationException InvalidOperationException
source não contém elementos.
Examples
O exemplo de código a seguir demonstra como usar Min(IEnumerable<Double>) para determinar o valor mínimo em
uma sequência.

double[] doubles = { 1.5E+104, 9E+103, -2E+103 };

double min = doubles.Min();

Console.WriteLine("The smallest number is {0}.", min);

/*
This code produces the following output:

The smallest number is -2E+103.


*/

Remarks
O Min(IEnumerable<Double>) usa o Double 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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Min(IEnumerable<Int64>) Min(IEnumerable<Int64>)
Retorna o valor mínimo em uma sequência de valores Int64.

public static long Min (this System.Collections.Generic.IEnumerable<long> source);


static member Min : seq<int64> -> int64

Parameters
source IEnumerable<Int64>
Uma sequência de valores Int64 para determinação do valor mínimo.
Returns
Int64 Int64
O valor mínimo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source é null .

InvalidOperationException InvalidOperationException
source não contém elementos.
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

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.

double[] doubles = { 1.5E+104, 9E+103, -2E+103 };

double min = doubles.Min();

Console.WriteLine("The smallest number is {0}.", min);

/*
This code produces the following output:

The smallest number is -2E+103.


*/

Remarks
O Min(IEnumerable<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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Min(IEnumerable<Int32>) Min(IEnumerable<Int32>)
Retorna o valor mínimo em uma sequência de valores Int32.

public static int Min (this System.Collections.Generic.IEnumerable<int> source);


static member Min : seq<int> -> int

Parameters
source IEnumerable<Int32>
Uma sequência de valores Int32 para determinação do valor mínimo.
Returns
Int32 Int32
O valor mínimo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source é null .
InvalidOperationException InvalidOperationException
source não contém elementos.
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

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.

double[] doubles = { 1.5E+104, 9E+103, -2E+103 };

double min = doubles.Min();

Console.WriteLine("The smallest number is {0}.", min);

/*
This code produces the following output:

The smallest number is -2E+103.


*/

Remarks
O Min(IEnumerable<Int32>) usa o Int32 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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Min(IEnumerable<Nullable<Decimal>>)
Min(IEnumerable<Nullable<Decimal>>)
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
source IEnumerable<Nullable<Decimal>>
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
mínimo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
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

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.

int?[] grades = { 78, 92, null, 99, 37, 81 };

int? min = grades.Min();

Console.WriteLine("The lowest grade is {0}.", min);

/*
This code produces the following output:

The lowest grade is 37.


*/

Remarks
O Min(IEnumerable<Nullable<Decimal>>) usa o Decimal 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 Min() cláusula se traduz em uma
invocação de Min.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Min(IEnumerable<Decimal>) Min(IEnumerable<Decimal>)
Retorna o valor mínimo em uma sequência de valores Decimal.
public static decimal Min (this System.Collections.Generic.IEnumerable<decimal> source);
static member Min : seq<decimal> -> decimal

Parameters
source IEnumerable<Decimal>
Uma sequência de valores Decimal para determinação do valor mínimo.
Returns
Decimal Decimal
O valor mínimo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source é null .
InvalidOperationException InvalidOperationException
source não contém elementos.
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

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.
double[] doubles = { 1.5E+104, 9E+103, -2E+103 };

double min = doubles.Min();

Console.WriteLine("The smallest number is {0}.", min);

/*
This code produces the following output:

The smallest number is -2E+103.


*/

Remarks
O Min(IEnumerable<Decimal>) usa o Decimal 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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

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.

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
O tipo dos elementos de source .
TResult
O tipo do valor retornado por selector .
Parameters
source IEnumerable<TSource>
Uma sequência de valores da qual será determinado o valor mínimo.
selector Func<TSource,TResult>
Uma função de transformação a ser aplicada a cada elemento.
Returns
TResult TResult
O valor mínimo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
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

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 a este tópico, altere o corpo da função selector .

class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MinEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int min = pets.Min(pet => pet.Age);

Console.WriteLine("The youngest animal is age {0}.", min);


}

/*
This code produces the following output:

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.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Min() cláusula se traduz em uma
invocação de Min.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)
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.

public static float Min<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,


Func<TSource,float> selector);
static member Min : seq<'Source> * Func<'Source, single> -> single

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor mínimo.
selector Func<TSource,Single>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Single Single
O valor mínimo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .

InvalidOperationException InvalidOperationException
source não contém elementos.
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

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 a este tópico, altere o corpo da função selector .
class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MinEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int min = pets.Min(pet => pet.Age);

Console.WriteLine("The youngest animal is age {0}.", min);


}

/*
This code produces the following output:

The youngest animal is age 1.


*/

Remarks
O Min<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.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Min() cláusula se traduz em uma
invocação de Min.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

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.

public static Nullable<float> Min<TSource> (this System.Collections.Generic.IEnumerable<TSource>


source, Func<TSource,Nullable<float>> selector);
static member Min : seq<'Source> * Func<'Source, Nullable<single>> -> Nullable<single>

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor mínimo.
selector Func<TSource,Nullable<Single>>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Nullable<Single>
O valor do tipo Nullable<Single> em C# ou Nullable(Of Single) no Visual Basic que corresponde ao valor
mínimo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
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

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 a este tópico, altere o corpo da função selector .

class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MinEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int min = pets.Min(pet => pet.Age);

Console.WriteLine("The youngest animal is age {0}.", min);


}

/*
This code produces the following output:

The youngest animal is age 1.


*/

Remarks
O Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<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 Nullable<Single> em c# ou
Nullable(Of Single) no Visual Basic.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Min() cláusula se traduz em uma
invocação de Min.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also
Min<TSource>(IEnumerable<TSource>,
Func<TSource,Nullable<Int64>>) 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.

public static Nullable<long> Min<TSource> (this System.Collections.Generic.IEnumerable<TSource>


source, Func<TSource,Nullable<long>> selector);
static member Min : seq<'Source> * Func<'Source, Nullable<int64>> -> Nullable<int64>

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor mínimo.
selector Func<TSource,Nullable<Int64>>
Uma função de transformação a ser aplicada a cada elemento.
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
ArgumentNullException ArgumentNullException
source ou selector é null .
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

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 a este tópico, altere o corpo da função selector .
class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MinEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int min = pets.Min(pet => pet.Age);

Console.WriteLine("The youngest animal is age {0}.", min);


}

/*
This code produces the following output:

The youngest animal is age 1.


*/

Remarks
O Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) usa o Int64 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 Nullable<Int64> em c# ou
Nullable(Of Int64) no Visual Basic.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Min() cláusula se traduz em uma
invocação de Min.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Min<TSource>(IEnumerable<TSource>,
Func<TSource,Nullable<Int32>>) Min<TSource>
(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)
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>
source, Func<TSource,Nullable<int>> selector);
static member Min : seq<'Source> * Func<'Source, Nullable<int>> -> Nullable<int>

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor mínimo.
selector Func<TSource,Nullable<Int32>>
Uma função de transformação a ser aplicada a cada elemento.
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
ArgumentNullException ArgumentNullException
source ou selector é null .
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

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 a este tópico, altere o corpo da função selector .

class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MinEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int min = pets.Min(pet => pet.Age);

Console.WriteLine("The youngest animal is age {0}.", min);


}

/*
This code produces the following output:

The youngest animal is age 1.


*/

Remarks
O Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) usa o Int32 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
projeta os membros de origem em um tipo numérico, especificamente Nullable<Int32> em c# ou
Nullable(Of Int32) no Visual Basic.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Min() cláusula se traduz em uma
invocação de Min.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

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.
public static Nullable<double> Min<TSource> (this System.Collections.Generic.IEnumerable<TSource>
source, Func<TSource,Nullable<double>> selector);
static member Min : seq<'Source> * Func<'Source, Nullable<double>> -> Nullable<double>

Type Parameters
TSource
O tipo dos elementos de source .

Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor mínimo.
selector Func<TSource,Nullable<Double>>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Nullable<Double>
O valor do tipo Nullable<Double> em C# ou Nullable(Of Double) no Visual Basic que corresponde ao valor
mínimo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
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

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 a este tópico, altere o corpo da função selector .
class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MinEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int min = pets.Min(pet => pet.Age);

Console.WriteLine("The youngest animal is age {0}.", min);


}

/*
This code produces the following output:

The youngest animal is age 1.


*/

Remarks
O Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) usa o Double 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 Nullable<Double> em c# ou
Nullable(Of Double) no Visual Basic.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Min() cláusula se traduz em uma
invocação de Min.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)
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.
public static long Min<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,long> selector);
static member Min : seq<'Source> * Func<'Source, int64> -> int64

Type Parameters
TSource
O tipo dos elementos de source .

Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor mínimo.
selector Func<TSource,Int64>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Int64 Int64
O valor mínimo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .

InvalidOperationException InvalidOperationException
source não contém elementos.
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

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 a este tópico, altere o corpo da função selector .

class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MinEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int min = pets.Min(pet => pet.Age);

Console.WriteLine("The youngest animal is age {0}.", min);


}

/*
This code produces the following output:

The youngest animal is age 1.


*/

Remarks
O Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) usa o Int64 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 Int64.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Min() cláusula se traduz em uma
invocação de Min.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)
Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int32 mínimo.

public static int Min<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,


Func<TSource,int> selector);
static member Min : seq<'Source> * Func<'Source, int> -> int

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor mínimo.
selector Func<TSource,Int32>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Int32 Int32
O valor mínimo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
InvalidOperationException InvalidOperationException
source não contém elementos.
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.
class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MinEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int min = pets.Min(pet => pet.Age);

Console.WriteLine("The youngest animal is age {0}.", min);


}

/*
This code produces the following output:

The youngest animal is age 1.


*/

Remarks
O Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) usa o Int32 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 Int32.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Min() cláusula se traduz em uma
invocação de Min.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)
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.

public static double Min<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,


Func<TSource,double> selector);
static member Min : seq<'Source> * Func<'Source, double> -> double

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor mínimo.
selector Func<TSource,Double>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Double Double
O valor mínimo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
InvalidOperationException InvalidOperationException
source não contém elementos.
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

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 a este tópico, altere o corpo da função selector .

class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MinEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int min = pets.Min(pet => pet.Age);

Console.WriteLine("The youngest animal is age {0}.", min);


}

/*
This code produces the following output:

The youngest animal is age 1.


*/

Remarks
O Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>) usa o Double 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 Double.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Min() cláusula se traduz em uma
invocação de Min.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also
Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)
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.
public static decimal Min<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,decimal> selector);
static member Min : seq<'Source> * Func<'Source, decimal> -> decimal

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor mínimo.
selector Func<TSource,Decimal>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Decimal Decimal
O valor mínimo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
InvalidOperationException InvalidOperationException
source não contém elementos.
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

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 a este tópico, altere o corpo da função selector .
class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MinEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int min = pets.Min(pet => pet.Age);

Console.WriteLine("The youngest animal is age {0}.", min);


}

/*
This code produces the following output:

The youngest animal is age 1.


*/

Remarks
O Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) usa o Decimal 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 Decimal.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Min() cláusula se traduz em uma
invocação de Min.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Min<TSource>(IEnumerable<TSource>) Min<TSource>
(IEnumerable<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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor mínimo.
Returns
TSource TSource
O valor mínimo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
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>
{
public string Name { get; set; }
public int Age { get; set; }

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

public static void MinEx3()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

Pet min = pets.Min();

Console.WriteLine(
"The 'minimum' animal is {0}.",
min.Name);
}

/*
This code produces the following output:

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 .
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Min() cláusula se traduz em uma
invocação de Min.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

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.

public static Nullable<decimal> Min<TSource> (this System.Collections.Generic.IEnumerable<TSource>


source, Func<TSource,Nullable<decimal>> selector);
static member Min : seq<'Source> * Func<'Source, Nullable<decimal>> -> Nullable<decimal>

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores para determinação do valor mínimo.
selector Func<TSource,Nullable<Decimal>>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Nullable<Decimal>
O valor do tipo Nullable<Decimal> em C# ou Nullable(Of Decimal) no Visual Basic que corresponde ao valor
mínimo na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
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

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 a este tópico, altere o corpo da função selector .
class Pet
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void MinEx4()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

int min = pets.Min(pet => pet.Age);

Console.WriteLine("The youngest animal is age {0}.", min);


}

/*
This code produces the following output:

The youngest animal is age 1.


*/

Remarks
O Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) usa o Decimal 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 Nullable<Decimal> em c# ou
Nullable(Of Decimal) no Visual Basic.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Min() cláusula se traduz em uma
invocação de Min.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
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
source IEnumerable IEnumerable
O IEnumerable cujos elementos serão filtrados.
Returns
IEnumerable<TResult>
Um IEnumerable<T> que contém elementos da sequência de entrada de tipo TResult .

Exceptions
ArgumentNullException ArgumentNullException
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)
{
Console.WriteLine(fruit);
}

// The following query shows that the standard query operators such as
// Where() can be applied to the ArrayList type after calling OfType().
IEnumerable<string> query2 =
fruits.OfType<string>().Where(fruit => fruit.ToLower().Contains("n"));

Console.WriteLine("
The following strings contain 'n':");
foreach (string fruit in query2)
{
Console.WriteLine(fruit);
}

// This code produces the following output:


//
// Elements of type 'string' are:
// Mango
// Orange
// Apple
// Banana
//
// The following strings contain 'n':
// Mango
// Orange
// Banana

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 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>
(IEnumerable<TSource>, Func<TSource,TKey>)
Classifica os elementos de uma sequência em ordem crescente de acordo com uma chave.
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
O tipo dos elementos de source .
TKey
O tipo da chave retornada por keySelector .

Parameters
source IEnumerable<TSource>
Uma sequência de valores a serem ordenados.
keySelector Func<TSource,TKey>
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
ArgumentNullException ArgumentNullException
source ou keySelector é null .
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 string Name { get; set; }
public int Age { get; set; }
}

public static void OrderByEx1()


{
Pet[] pets = { new Pet { Name="Barley", Age=8 },
new Pet { Name="Boots", Age=4 },
new Pet { Name="Whiskers", Age=1 } };

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

foreach (Pet pet in query)


{
Console.WriteLine("{0} - {1}", pet.Name, pet.Age);
}
}

/*
This code produces the following output:

Whiskers - 1
Boots - 4
Barley - 8
*/

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.

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)

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.
public static System.Linq.IOrderedEnumerable<TSource> OrderBy<TSource,TKey> (this
System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector,
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
O tipo dos elementos de source .

TKey
O tipo da chave retornada por keySelector .
Parameters
source IEnumerable<TSource>
Uma sequência de valores a serem ordenados.
keySelector Func<TSource,TKey>
Uma função para extrair uma chave de um elemento.
comparer IComparer<TKey>
Um IComparer<T> para comparar chaves.
Returns
IOrderedEnumerable<TSource>
Um IOrderedEnumerable<TElement> cujos elementos são classificados de acordo com uma chave.
Exceptions
ArgumentNullException ArgumentNullException
source ou keySelector é null .
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.

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.
Se comparer está null , o comparador padrão Default é usado para comparar chaves.
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.
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>)
Enumerable.OrderByDescending Enumerable.OrderBy
Descending
I n this Article

Overloads
OrderByDescending<TSource,TKey>(IEnumerable<TSource>,
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>)

OrderByDescending<TSource,TKey>(IEnumerable<TSource>,
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.

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.
public static System.Linq.IOrderedEnumerable<TSource> OrderByDescending<TSource,TKey> (this
System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector,
System.Collections.Generic.IComparer<TKey> comparer);
static member OrderByDescending : seq<'Source> * Func<'Source, 'Key> *
System.Collections.Generic.IComparer<'Key> -> System.Linq.IOrderedEnumerable<'Source>

Type Parameters
TSource
O tipo dos elementos de source .
TKey
O tipo da chave retornada por keySelector .
Parameters
source IEnumerable<TSource>
Uma sequência de valores a serem ordenados.
keySelector Func<TSource,TKey>
Uma função para extrair uma chave de um elemento.
comparer IComparer<TKey>
Um IComparer<T> para comparar chaves.
Returns
IOrderedEnumerable<TSource>
Um IOrderedEnumerable<TElement> cujos elementos são classificados em ordem decrescente de acordo com uma
chave.
Exceptions
ArgumentNullException ArgumentNullException
source ou keySelector é null .
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 = decimal.Remainder(d2, decimal.Floor(d2));
}
catch (DivideByZeroException)
{
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);
}
}

/*
This code produces the following output:

9.7
0.5
8.3
6.3
1.3
6.2
*/

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.

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.
Se comparer está null , o comparador padrão Default é usado para comparar chaves.
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.
See
Also
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)OrderBy<TSource,TKey>
(IEnumerable<TSource>, Func<TSource,TKey>)
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>,
IComparer<TKey>)OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>,
IComparer<TKey>)
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.

public static System.Linq.IOrderedEnumerable<TSource> OrderByDescending<TSource,TKey> (this


System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector);
static member OrderByDescending : seq<'Source> * Func<'Source, 'Key> ->
System.Linq.IOrderedEnumerable<'Source>

Type Parameters
TSource
O tipo dos elementos de source .

TKey
O tipo da chave retornada por keySelector .

Parameters
source IEnumerable<TSource>
Uma sequência de valores a serem ordenados.
keySelector Func<TSource,TKey>
Uma função para extrair uma chave de um elemento.
Returns
IOrderedEnumerable<TSource>
Um IOrderedEnumerable<TElement> cujos elementos são classificados em ordem decrescente de acordo com uma
chave.
Exceptions
ArgumentNullException ArgumentNullException
source ou keySelector é null .
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.

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 .

Para obter um exemplo desse método, consulte OrderByDescending<TSource,TKey>(IEnumerable<TSource>,


Func<TSource,TKey>, IComparer<TKey>).
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 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>
(IEnumerable<TSource>, Func<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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores.
element TSource TSource
O valor a ser precedido a source .
Returns
IEnumerable<TSource>
Uma nova sequência que começa com element .
Exceptions
ArgumentNullException ArgumentNullException
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));

// This code produces the following output:


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


{
Console.WriteLine(num);
}

/*
This code produces the following output:

1
4
9
16
25
36
49
64
81
100
*/
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.
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
IEnumerable<TResult>
Um IEnumerable<T> que contém um valor repetido.
Exceptions
ArgumentOutOfRangeException ArgumentOutOfRangeException
count é menor que 0.

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

/*
This code produces the following output:

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
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.
Enumerable.Reverse Enumerable.Reverse
I n this Article
Inverte a ordem dos elementos em uma sequência.
public static System.Collections.Generic.IEnumerable<TSource> Reverse<TSource> (this
System.Collections.Generic.IEnumerable<TSource> source);
static member Reverse : seq<'Source> -> seq<'Source>

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores a ser revertida.
Returns
IEnumerable<TSource>
Uma sequência cujos elementos correspondem aos elementos da sequência de entrada em ordem inversa.
Exceptions
ArgumentNullException ArgumentNullException
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();

/*
This code produces the following output:

e l p p a
*/

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.
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>)
Projeta cada elemento de uma sequência em um novo formulário, incorporando o índice do elemento.
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
O tipo dos elementos de source .
TResult
O tipo do valor retornado por selector .

Parameters
source IEnumerable<TSource>
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
IEnumerable<TResult>
Um IEnumerable<T> cujos elementos são o resultado da invocação da função de transformação em cada elemento de
source .

Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
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) });

foreach (var obj in query)


{
Console.WriteLine("{0}", obj);
}

/*
This code produces the following output:

{index=0, str=}
{index=1, str=b}
{index=2, str=ma}
{index=3, str=ora}
{index=4, str=pass}
{index=5, str=grape}
*/

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 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>
(IEnumerable<TSource>, Func<TSource,TResult>)
Projeta cada elemento de uma sequência em um novo formulário.
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
O tipo dos elementos de source .
TResult
O tipo do valor retornado por selector .

Parameters
source IEnumerable<TSource>
Uma sequência de valores na qual uma função de transformação será invocada.
selector Func<TSource,TResult>
Uma função de transformação a ser aplicada a cada elemento.
Returns
IEnumerable<TResult>
Um IEnumerable<T> cujos elementos são o resultado da invocação da função de transformação em cada elemento de
source .

Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
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);

foreach (int num in squares)


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

1
4
9
16
25
36
49
64
81
100
*/

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.
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>>,
Func<TSource,TCollection,TResult>)
SelectMany<TSource,TCollection,TResult>
(IEnumerable<TSource>,
Func<TSource,IEnumerable<TCollection>>,
Func<TSource,TCollection,TResult>)
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.
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
O tipo dos elementos de source .
TCollection
O tipo dos elementos intermediários coletados por collectionSelector .
TResult
O tipo dos elementos da sequência resultante.
Parameters
source IEnumerable<TSource>
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
IEnumerable<TResult>
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
ArgumentNullException ArgumentNullException
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 string Name { get; set; }
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.


foreach (var obj in query)
{
Console.WriteLine(obj);
}
}

// This code produces the following output:


//
// {Owner=Higa, Pet=Scruffy}
// {Owner=Higa, Pet=Sam}
// {Owner=Ashkenazi, Pet=Sugar}
// {Owner=Price, Pet=Scratches}

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 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.
See Cláusula from (Referência de C#)from clause (C# Reference)
Also Cláusula From (Visual Basic)From Clause (Visual Basic)

SelectMany<TSource,TCollection,TResult>
(IEnumerable<TSource>,
Func<TSource,Int32,IEnumerable<TCollection>>,
Func<TSource,TCollection,TResult>)
SelectMany<TSource,TCollection,TResult>
(IEnumerable<TSource>,
Func<TSource,Int32,IEnumerable<TCollection>>,
Func<TSource,TCollection,TResult>)
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. O índice de cada elemento de
origem é usado no formulário projetado intermediário do elemento.

public static System.Collections.Generic.IEnumerable<TResult>


SelectMany<TSource,TCollection,TResult> (this System.Collections.Generic.IEnumerable<TSource>
source, Func<TSource,int,System.Collections.Generic.IEnumerable<TCollection>> collectionSelector,
Func<TSource,TCollection,TResult> resultSelector);
static member SelectMany : seq<'Source> * Func<'Source, int, seq<'Collection>> * Func<'Source,
'Collection, 'Result> -> seq<'Result>

Type Parameters
TSource
O tipo dos elementos de source .

TCollection
O tipo dos elementos intermediários coletados por collectionSelector .

TResult
O tipo dos elementos da sequência resultante.
Parameters
source IEnumerable<TSource>
Uma sequência de valores a serem projetados.
collectionSelector Func<TSource,Int32,IEnumerable<TCollection>>
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.
resultSelector Func<TSource,TCollection,TResult>
Uma função de transformação a ser aplicada a cada elemento da sequência intermediária.
Returns
IEnumerable<TResult>
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
ArgumentNullException ArgumentNullException
source , collectionSelector ou resultSelector é null .
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 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
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>,
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>>)
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.

public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TResult> (this


System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,System.Collections.Generic.IEnumerable<TResult>> selector);
static member SelectMany : seq<'Source> * Func<'Source, seq<'Result>> -> seq<'Result>

Type Parameters
TSource
O tipo dos elementos de source .

TResult
O tipo dos elementos da sequência retornada por selector .
Parameters
source IEnumerable<TSource>
Uma sequência de valores a serem projetados.
selector Func<TSource,IEnumerable<TResult>>
Uma função de transformação a ser aplicada a cada elemento.
Returns
IEnumerable<TResult>
Um IEnumerable<T> cujos elementos são resultado da invocação da função de transformação de um para muitos em
cada elemento da sequência de entrada.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
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 string Name { get; set; }
public List<String> Pets { get; set; }
}

public static void SelectManyEx1()


{
PetOwner[] petOwners =
{ new PetOwner { Name="Higa, Sidney",
Pets = new List<string>{ "Scruffy", "Sam" } },
new PetOwner { Name="Ashkenazi, Ronen",
Pets = new List<string>{ "Walker", "Sugar" } },
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)
{
Console.WriteLine(pet);
}
Console.WriteLine();
}
}

/*
This code produces the following output:

Using SelectMany():
Scruffy
Sam
Walker
Sugar
Scratches
Diesel

Using Select():
Scruffy
Sam

Walker
Sugar

Scratches
Diesel
*/

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 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.
See Cláusula from (Referência de C#)from clause (C# Reference)
Also Cláusula From (Visual Basic)From Clause (Visual Basic)
SelectMany<TSource,TResult>(IEnumerable<TSource>,
Func<TSource,Int32,IEnumerable<TResult>>)
SelectMany<TSource,TResult>(IEnumerable<TSource>,
Func<TSource,Int32,IEnumerable<TResult>>)
Projeta cada elemento de uma sequência em um IEnumerable<T> e nivela as sequências resultantes em uma
sequência. O índice de cada elemento de origem é usado no formulário projetado desse elemento.

public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TResult> (this


System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,int,System.Collections.Generic.IEnumerable<TResult>> selector);
static member SelectMany : seq<'Source> * Func<'Source, int, seq<'Result>> -> seq<'Result>

Type Parameters
TSource
O tipo dos elementos de source .

TResult
O tipo dos elementos da sequência retornada por selector .

Parameters
source IEnumerable<TSource>
Uma sequência de valores a serem projetados.
selector Func<TSource,Int32,IEnumerable<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
IEnumerable<TResult>
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
ArgumentNullException ArgumentNullException
source ou selector é null .
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
{
public string Name { get; set; }
public List<string> Pets { get; set; }
}

public static void SelectManyEx2()


{
PetOwner[] petOwners =
{ new PetOwner { Name="Higa, Sidney",
Pets = new List<string>{ "Scruffy", "Sam" } },
new PetOwner { Name="Ashkenazi, Ronen",
Pets = new List<string>{ "Walker", "Sugar" } },
new PetOwner { Name="Price, Vernette",
Pets = new List<string>{ "Scratches", "Diesel" } },
new PetOwner { Name="Hines, Patrick",
Pets = new List<string>{ "Dusty" } } };

// 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.
IEnumerable<string> query =
petOwners.SelectMany((petOwner, index) =>
petOwner.Pets.Select(pet => index + pet));

foreach (string pet in query)


{
Console.WriteLine(pet);
}
}

// This code produces the following output:


//
// 0Scruffy
// 0Sam
// 1Walker
// 1Sugar
// 2Scratches
// 2Diesel
// 3Dusty

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 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.

SequenceEqual<TSource>(IEnumerable<TSource>,
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>, IEqualityComparer<TSource>)

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.
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
O tipo dos elementos das sequências de entrada.
Parameters
first IEnumerable<TSource>
Um IEnumerable<T> para comparar com second .
second IEnumerable<TSource>
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
ArgumentNullException ArgumentNullException
first ou second é null .
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 string Name { get; set; }
public int Age { get; set; }
}

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 };
List<Pet> pets2 = new List<Pet> { pet1, pet2 };

bool equal = pets1.SequenceEqual(pets2);

Console.WriteLine(
"The lists {0} equal.",
equal ? "are" : "are not");
}

/*
This code produces the following output:

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
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void SequenceEqualEx2()


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


}

/*
This code produces the following output:

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.
public class ProductA: IEquatable<ProductA>
{
public string Name { get; set; }
public int Code { get; set; }

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 SequenceEqual<TSource>
(IEnumerable<TSource>, IEnumerable<TSource>) método, conforme mostrado no exemplo a seguir.
ProductA[] storeA = { new ProductA { Name = "apple", Code = 9 },
new ProductA { Name = "orange", Code = 4 } };

ProductA[] storeB = { new ProductA { Name = "apple", Code = 9 },


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

bool equalAB = storeA.SequenceEqual(storeB);

Console.WriteLine("Equal? " + equalAB);

/*
This code produces the following output:

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.

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.

public static bool SequenceEqual<TSource> (this System.Collections.Generic.IEnumerable<TSource>


first, System.Collections.Generic.IEnumerable<TSource> second,
System.Collections.Generic.IEqualityComparer<TSource> comparer);
static member SequenceEqual : seq<'Source> * seq<'Source> *
System.Collections.Generic.IEqualityComparer<'Source> -> bool

Type Parameters
TSource
O tipo dos elementos das sequências de entrada.
Parameters
first IEnumerable<TSource>
Um IEnumerable<T> para comparar com second .
second IEnumerable<TSource>
Um IEnumerable<T> para comparar com a primeira sequência.
comparer IEqualityComparer<TSource>
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
ArgumentNullException ArgumentNullException
first ou second é null .
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.

public class Product


{
public string Name { get; set; }
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 sequências de Product objetos no
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) método,
conforme mostrado no exemplo a seguir.
Product[] storeA = { new Product { Name = "apple", Code = 9 },
new Product { Name = "orange", Code = 4 } };

Product[] storeB = { new Product { Name = "apple", Code = 9 },


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

bool equalAB = storeA.SequenceEqual(storeB, new ProductComparer());

Console.WriteLine("Equal? " + equalAB);

/*
This code produces the following output:

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>
(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.
public static TSource Single<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,bool> predicate);
static member Single : seq<'Source> * Func<'Source, bool> -> 'Source

Type Parameters
TSource
O tipo dos elementos de source .

Parameters
source IEnumerable<TSource>
Um IEnumerable<T> do qual retornar um único elemento.
predicate Func<TSource,Boolean>
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
ArgumentNullException ArgumentNullException
source ou predicate é null .
InvalidOperationException InvalidOperationException
Nenhum elemento satisfaz a condição na predicate .
- ou - Mais de um 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 Single<TSource>(IEnumerable<TSource>,
Func<TSource,Boolean>) para selecionar o único elemento de uma matriz que satisfaz uma condição.
string[] fruits = { "apple", "banana", "mango",
"orange", "passionfruit", "grape" };

string fruit1 = fruits.Single(fruit => fruit.Length > 10);

Console.WriteLine(fruit1);

/*
This code produces the following output:

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

Console.WriteLine(fruit2);

// This code produces the following output:


//
// 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>
(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.
public static TSource Single<TSource> (this System.Collections.Generic.IEnumerable<TSource> source);
static member Single : seq<'Source> -> 'Source

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Um IEnumerable<T> do qual o único elemento será retornado.
Returns
TSource TSource
O único elemento de uma sequência de entrada.
Exceptions
ArgumentNullException ArgumentNullException
source é null .
InvalidOperationException InvalidOperationException
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();

Console.WriteLine(fruit1);

/*
This code produces the following output:

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();
}
catch (System.InvalidOperationException)
{
Console.WriteLine("The collection does not contain exactly one element.");
}

Console.WriteLine(fruit2);

/*
This code produces the following output:

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.

SingleOrDefault<TSource>(IEnumerable<TSource>)
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.
public static TSource SingleOrDefault<TSource> (this System.Collections.Generic.IEnumerable<TSource>
source);
static member SingleOrDefault : seq<'Source> -> 'Source

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
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
ArgumentNullException ArgumentNullException
source é null .
InvalidOperationException InvalidOperationException
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[] fruits1 = { "orange" };

string fruit1 = fruits1.SingleOrDefault();

Console.WriteLine(fruit1);

/*
This code produces the following output:

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

/*
This code produces the following output:

No such string!
*/

À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 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 = { };

// Setting the default value to 1 after the query.


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

// Setting the default value to 1 by using DefaultIfEmpty() in the query.


int pageNumber2 = pageNumbers.DefaultIfEmpty(1).Single();
Console.WriteLine("The value of the pageNumber2 variable is {0}", pageNumber2);

/*
This code produces the following output:

The value of the pageNumber1 variable is 1


The value of the pageNumber2 variable is 1
*/
Remarks
O valor padrão para referência e tipos que permitem valor nulos é null .

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)
método conforme descrito na seção de exemplo.

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.

public static TSource SingleOrDefault<TSource> (this System.Collections.Generic.IEnumerable<TSource>


source, Func<TSource,bool> predicate);
static member SingleOrDefault : seq<'Source> * Func<'Source, bool> -> 'Source

Type Parameters
TSource
O tipo dos elementos de source .

Parameters
source IEnumerable<TSource>
Um IEnumerable<T> do qual retornar um único elemento.
predicate Func<TSource,Boolean>
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 à condição ou default ( TSource ) se esse elemento não for
encontrado.
Exceptions
ArgumentNullException ArgumentNullException
source ou predicate é null .

InvalidOperationException InvalidOperationException
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[] fruits = { "apple", "banana", "mango",
"orange", "passionfruit", "grape" };

string fruit1 = fruits.SingleOrDefault(fruit => fruit.Length > 10);

Console.WriteLine(fruit1);

/*
This code produces the following output:

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

/*
This code produces the following output:

No such string!
*/

Remarks
O valor padrão para referência e tipos que permitem valor nulos é null .
Enumerable.Skip Enumerable.Skip
I n this Article
Ignora um número especificado de elementos em uma sequência e retorna os elementos restantes.
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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
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
IEnumerable<TSource>
Um IEnumerable<T> que contém os elementos que ocorrem após o índice especificado na sequência de entrada.
Exceptions
ArgumentNullException ArgumentNullException
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);
}

/*
This code produces the following output:

All grades except the top three are:


82
70
59
56
*/

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.

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
System.Collections.Generic.IEnumerable<TSource> source, int count);
static member SkipLast : seq<'Source> * int -> seq<'Source>

Type Parameters
TSource
Parameters
source IEnumerable<TSource>
count Int32 Int32
Returns
IEnumerable<TSource>
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>
(IEnumerable<TSource>, Func<TSource,Boolean>)
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
O tipo dos elementos de source .

Parameters
source IEnumerable<TSource>
Um IEnumerable<T> do qual os elementos serão retornados.
predicate Func<TSource,Boolean>
Uma função para testar cada elemento em relação a uma condição.
Returns
IEnumerable<TSource>
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
ArgumentNullException ArgumentNullException
source ou predicate é null .
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 };

IEnumerable<int> lowerGrades =
grades
.OrderByDescending(grade => grade)
.SkipWhile(grade => grade >= 80);

Console.WriteLine("All grades below 80:");


foreach (int grade in lowerGrades)
{
Console.WriteLine(grade);
}

/*
This code produces the following output:

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>)
Ignora elementos em uma sequência, 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.
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
O tipo dos elementos de source .

Parameters
source IEnumerable<TSource>
Um IEnumerable<T> do qual os elementos serão retornados.
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
IEnumerable<TSource>
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
ArgumentNullException ArgumentNullException
source ou predicate é null .
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);
}

/*
This code produces the following output:

4000
1500
5500
*/

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 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 .

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
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
permitem valores nulos.

Sum(IEnumerable<Nullable<Single>>) 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<Int64>>) Sum(IEnumerable<
Nullable<Int64>>) Computa a soma de uma sequência de valores Int64 que
permitem valores nulos.

Sum(IEnumerable<Nullable<Double>>) 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>) Sum(IEnumerable<Int64>)
Calcula a soma de uma sequência de valores Int64.

Sum(IEnumerable<Int32>) Sum(IEnumerable<Int32>)
Calcula a soma de uma sequência de valores Int32.

Sum(IEnumerable<Decimal>) Sum(IEnumerable<Decimal>)
Calcula a soma de uma sequência de valores Decimal.

Sum(IEnumerable<Nullable<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>) 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.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,
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
cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,
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
cada elemento da sequência de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,
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
cada elemento da sequência de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,
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
cada elemento da sequência de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,
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
cada elemento da sequência de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,
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
da sequência de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,
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
da sequência de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,
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
da sequência de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,
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
da sequência de entrada.

Sum(IEnumerable<Nullable<Int32>>)
Sum(IEnumerable<Nullable<Int32>>)
Computa a soma de uma sequência de valores Int32 que permitem valores nulos.
public static Nullable<int> Sum (this System.Collections.Generic.IEnumerable<Nullable<int>> source);
static member Sum : seq<Nullable<int>> -> Nullable<int>

Parameters
source IEnumerable<Nullable<Int32>>
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
ArgumentNullException ArgumentNullException
source é null .

OverflowException OverflowException
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

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.

float?[] points = { null, 0, 92.83F, null, 100.0F, 37.46F, 81.1F };

float? sum = points.Sum();

Console.WriteLine("Total points earned: {0}", sum);

/*
This code produces the following output:

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Sum(IEnumerable<Nullable<Single>>)
Sum(IEnumerable<Nullable<Single>>)
Computa a soma de uma sequência de valores Single que permitem valores nulos.

public static Nullable<float> Sum (this System.Collections.Generic.IEnumerable<Nullable<float>>


source);
static member Sum : seq<Nullable<single>> -> Nullable<single>

Parameters
source IEnumerable<Nullable<Single>>
Uma sequência de valores Single que permitem valores nulos para cálculo da soma.
Returns
Nullable<Single>
A soma dos valores na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source é null .
Examples
O exemplo de código a seguir demonstra como usar Sum(IEnumerable<Nullable<Single>>) para somar os valores de
uma sequência.

float?[] points = { null, 0, 92.83F, null, 100.0F, 37.46F, 81.1F };

float? sum = points.Sum();

Console.WriteLine("Total points earned: {0}", sum);

/*
This code produces the following output:

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Sum(IEnumerable<Single>) Sum(IEnumerable<Single>)
Calcula a soma de uma sequência de valores Single.
public static float Sum (this System.Collections.Generic.IEnumerable<float> source);
static member Sum : seq<single> -> single

Parameters
source IEnumerable<Single>
Uma sequência de valores Single para cálculo da soma.
Returns
Single Single
A soma dos valores na sequência.
Exceptions
ArgumentNullException ArgumentNullException
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);

/*
This code produces the following output:

The sum of the numbers is 635.13.


*/

Remarks
Esse método retornará zero se source não contiver elementos.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula se traduz em uma
invocação de Sum.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Sum(IEnumerable<Nullable<Int64>>)
Sum(IEnumerable<Nullable<Int64>>)
Computa a soma de uma sequência de valores Int64 que permitem valores nulos.

public static Nullable<long> Sum (this System.Collections.Generic.IEnumerable<Nullable<long>>


source);
static member Sum : seq<Nullable<int64>> -> Nullable<int64>

Parameters
source IEnumerable<Nullable<Int64>>
Uma sequência de valores Int64 que permitem valores nulos para cálculo da soma.
Returns
Nullable<Int64>
A soma dos valores na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source é null .
OverflowException OverflowException
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

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.

float?[] points = { null, 0, 92.83F, null, 100.0F, 37.46F, 81.1F };

float? sum = points.Sum();

Console.WriteLine("Total points earned: {0}", sum);

/*
This code produces the following output:

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Sum(IEnumerable<Nullable<Double>>)
Sum(IEnumerable<Nullable<Double>>)
Computa a soma de uma sequência de valores Double que permitem valores nulos.

public static Nullable<double> Sum (this System.Collections.Generic.IEnumerable<Nullable<double>>


source);
static member Sum : seq<Nullable<double>> -> Nullable<double>

Parameters
source IEnumerable<Nullable<Double>>
Uma sequência de valores Double que permitem valores nulos para cálculo da soma.
Returns
Nullable<Double>
A soma dos valores na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source é null .
Examples
O exemplo de código a seguir demonstra como usar Sum(IEnumerable<Nullable<Single>>) para somar os valores de
uma sequência.
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.

float?[] points = { null, 0, 92.83F, null, 100.0F, 37.46F, 81.1F };

float? sum = points.Sum();

Console.WriteLine("Total points earned: {0}", sum);

/*
This code produces the following output:

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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Sum(IEnumerable<Double>) Sum(IEnumerable<Double>)
Calcula a soma de uma sequência de valores Double.
public static double Sum (this System.Collections.Generic.IEnumerable<double> source);
static member Sum : seq<double> -> double

Parameters
source IEnumerable<Double>
Uma sequência de valores Double para cálculo da soma.
Returns
Double Double
A soma dos valores na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source é null .
Examples
O exemplo de código a seguir demonstra como usar Sum(IEnumerable<Single>) para somar os valores de uma
sequência.
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<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);

/*
This code produces the following output:

The sum of the numbers is 635.13.


*/

Remarks
Esse método retornará zero se source não contiver elementos.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula se traduz em uma
invocação de Sum.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Sum(IEnumerable<Int64>) Sum(IEnumerable<Int64>)
Calcula a soma de uma sequência de valores Int64.

public static long Sum (this System.Collections.Generic.IEnumerable<long> source);


static member Sum : seq<int64> -> int64

Parameters
source IEnumerable<Int64>
Uma sequência de valores Int64 para cálculo da soma.
Returns
Int64 Int64
A soma dos valores na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source é null .
OverflowException OverflowException
A soma é maior que MaxValue.
Examples
O exemplo de código a seguir demonstra como usar Sum(IEnumerable<Single>) para somar os valores de uma
sequência.
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<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);

/*
This code produces the following output:

The sum of the numbers is 635.13.


*/

Remarks
Esse método retornará zero se source não contiver elementos.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula se traduz em uma
invocação de Sum.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Sum(IEnumerable<Int32>) Sum(IEnumerable<Int32>)
Calcula a soma de uma sequência de valores Int32.

public static int Sum (this System.Collections.Generic.IEnumerable<int> source);


static member Sum : seq<int> -> int

Parameters
source IEnumerable<Int32>
Uma sequência de valores Int32 para cálculo da soma.
Returns
Int32 Int32
A soma dos valores na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source é null .
OverflowException OverflowException
A soma é maior que MaxValue.
Examples
O exemplo de código a seguir demonstra como usar Sum(IEnumerable<Single>) para somar os valores de uma
sequência.
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<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);

/*
This code produces the following output:

The sum of the numbers is 635.13.


*/

Remarks
Esse método retornará zero se source não contiver elementos.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula se traduz em uma
invocação de Sum.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Sum(IEnumerable<Decimal>) Sum(IEnumerable<Decimal>)
Calcula a soma de uma sequência de valores Decimal.

public static decimal Sum (this System.Collections.Generic.IEnumerable<decimal> source);


static member Sum : seq<decimal> -> decimal

Parameters
source IEnumerable<Decimal>
Uma sequência de valores Decimal para cálculo da soma.
Returns
Decimal Decimal
A soma dos valores na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source é null .

OverflowException OverflowException
A soma é maior que MaxValue.
Examples
O exemplo de código a seguir demonstra como usar Sum(IEnumerable<Single>) para somar os valores de uma
sequência.
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<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);

/*
This code produces the following output:

The sum of the numbers is 635.13.


*/

Remarks
O Sum(IEnumerable<Decimal>) método retorna zero se source não contiver elementos.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula se traduz em uma
invocação de Sum.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Sum(IEnumerable<Nullable<Decimal>>)
Sum(IEnumerable<Nullable<Decimal>>)
Computa a soma de uma sequência de valores Decimal que permitem valores nulos.

public static Nullable<decimal> Sum (this System.Collections.Generic.IEnumerable<Nullable<decimal>>


source);
static member Sum : seq<Nullable<decimal>> -> Nullable<decimal>

Parameters
source IEnumerable<Nullable<Decimal>>
Uma sequência de valores Decimal que permitem valores nulos para cálculo da soma.
Returns
Nullable<Decimal>
A soma dos valores na sequência.
Exceptions
ArgumentNullException ArgumentNullException
source é null .

OverflowException OverflowException
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

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.

float?[] points = { null, 0, 92.83F, null, 100.0F, 37.46F, 81.1F };

float? sum = points.Sum();

Console.WriteLine("Total points earned: {0}", sum);

/*
This code produces the following output:

Total points earned: 311.39


*/

Remarks
Esse método retornará zero se source não contiver elementos.

O resultado incluem 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.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)
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.

public static float Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,


Func<TSource,float> selector);
static member Sum : seq<'Source> * Func<'Source, single> -> single

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores usados para calcular uma soma.
selector Func<TSource,Single>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Single Single
A soma dos valores projetados.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
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

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 a este tópico, altere o corpo da função selector .

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


}

/*
This code produces the following output:

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.
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.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula se traduz em uma
invocação de Sum.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

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 em
cada elemento da sequência de entrada.

public static Nullable<float> Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource>


source, Func<TSource,Nullable<float>> selector);
static member Sum : seq<'Source> * Func<'Source, Nullable<single>> -> Nullable<single>

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores usados para calcular uma soma.
selector Func<TSource,Nullable<Single>>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Nullable<Single>
A soma dos valores projetados.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
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

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 a este tópico, altere o corpo da função selector .
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);


}

/*
This code produces the following output:

The total weight of the packages is: 83.7


*/

Remarks
Esse método retornará zero se source não contiver elementos.
O resultado não inclui valores que são null .
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 Nullable<Single> em c# ou
Nullable(Of Single) no Visual Basic.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula se traduz em uma
invocação de Sum.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Sum<TSource>(IEnumerable<TSource>,
Func<TSource,Nullable<Int64>>) 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 em
cada elemento da sequência de entrada.
public static Nullable<long> Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource>
source, Func<TSource,Nullable<long>> selector);
static member Sum : seq<'Source> * Func<'Source, Nullable<int64>> -> Nullable<int64>

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores usados para calcular uma soma.
selector Func<TSource,Nullable<Int64>>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Nullable<Int64>
A soma dos valores projetados.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
OverflowException OverflowException
A soma é maior que MaxValue.
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

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 a este tópico, altere o corpo da função selector .

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


}

/*
This code produces the following output:

The total weight of the packages is: 83.7


*/

Remarks
Esse método retornará zero se source não contiver elementos.
O resultado não inclui valores que são null .
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 Nullable<Int64> em c# ou
Nullable(Of Int64) no Visual Basic

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula se traduz em uma
invocação de Sum.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Sum<TSource>(IEnumerable<TSource>,
Func<TSource,Nullable<Int32>>) Sum<TSource>
(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)
Calcula a soma da sequência de valores Int32 anuláveis obtidos pela invocação de uma função de transformação em
cada elemento da sequência de entrada.
public static Nullable<int> Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource>
source, Func<TSource,Nullable<int>> selector);
static member Sum : seq<'Source> * Func<'Source, Nullable<int>> -> Nullable<int>

Type Parameters
TSource
O tipo dos elementos de source .

Parameters
source IEnumerable<TSource>
Uma sequência de valores usados para calcular uma soma.
selector Func<TSource,Nullable<Int32>>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Nullable<Int32>
A soma dos valores projetados.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .

OverflowException OverflowException
A soma é maior que MaxValue.
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

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 a este tópico, altere o corpo da função selector .

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


}

/*
This code produces the following output:

The total weight of the packages is: 83.7


*/

Remarks
Esse método retornará zero se source não contiver elementos.
O resultado não inclui valores que são null .
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 Nullable<Int32> em c# ou
Nullable(Of Int32) no Visual Basic.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula se traduz em uma
invocação de Sum.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

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.
public static Nullable<double> Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource>
source, Func<TSource,Nullable<double>> selector);
static member Sum : seq<'Source> * Func<'Source, Nullable<double>> -> Nullable<double>

Type Parameters
TSource
O tipo dos elementos de source .

Parameters
source IEnumerable<TSource>
Uma sequência de valores usados para calcular uma soma.
selector Func<TSource,Nullable<Double>>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Nullable<Double>
A soma dos valores projetados.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
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

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 a este tópico, altere o corpo da função selector .

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


}

/*
This code produces the following output:

The total weight of the packages is: 83.7


*/

Remarks
Esse método retornará zero se source não contiver elementos.
O resultado não inclui valores que são null .
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 Nullable<Double> em c# ou
Nullable(Of Double) no Visual Basic.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula se traduz em uma
invocação de Sum.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

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 transformação
em cada elemento da sequência de entrada.

public static Nullable<decimal> Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource>


source, Func<TSource,Nullable<decimal>> selector);
static member Sum : seq<'Source> * Func<'Source, Nullable<decimal>> -> Nullable<decimal>

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores usados para calcular uma soma.
selector Func<TSource,Nullable<Decimal>>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Nullable<Decimal>
A soma dos valores projetados.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .

OverflowException OverflowException
A soma é maior que MaxValue.
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

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 a este tópico, altere o corpo da função selector .

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


}

/*
This code produces the following output:

The total weight of the packages is: 83.7


*/

Remarks
Esse método retornará zero se source não contiver elementos.
O resultado não incluía valores que são null .

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 Nullable<Decimal> em c# ou
Nullable(Of Decimal) no Visual Basic.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula se traduz em uma
invocação de Sum.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)
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
elemento da sequência de entrada.
public static long Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,long> selector);
static member Sum : seq<'Source> * Func<'Source, int64> -> int64

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores usados para calcular uma soma.
selector Func<TSource,Int64>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Int64 Int64
A soma dos valores projetados.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
OverflowException OverflowException
A soma é maior que MaxValue.
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

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 a este tópico, altere o corpo da função selector .

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


}

/*
This code produces the following output:

The total weight of the packages is: 83.7


*/

Remarks
Esse método retornará zero se source não contiver elementos.
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 Int64.

Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula se traduz em uma
invocação de Sum.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)
Calcula a soma da sequência de valores Int32 obtidos pela invocação de uma função de transformação em cada
elemento da sequência de entrada.
public static int Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,int> selector);
static member Sum : seq<'Source> * Func<'Source, int> -> int

Type Parameters
TSource
O tipo dos elementos de source .

Parameters
source IEnumerable<TSource>
Uma sequência de valores usados para calcular uma soma.
selector Func<TSource,Int32>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Int32 Int32
A soma dos valores projetados.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
OverflowException OverflowException
A soma é maior que MaxValue.
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

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 a este tópico, altere o corpo da função selector .
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);


}

/*
This code produces the following output:

The total weight of the packages is: 83.7


*/

Remarks
Esse método retornará zero se source não contiver elementos.
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 Int32.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula se traduz em uma
invocação de Sum.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)
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
elemento da sequência de entrada.

public static double Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,


Func<TSource,double> selector);
static member Sum : seq<'Source> * Func<'Source, double> -> double

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores usados para calcular uma soma.
selector Func<TSource,Double>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Double Double
A soma dos valores projetados.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
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.
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);


}

/*
This code produces the following output:

The total weight of the packages is: 83.7


*/

Remarks
Esse método retornará zero se source não contiver elementos.
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 Double.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula se traduz em uma
invocação de Sum.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)
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
Calcula a soma da sequência de valores Decimal obtidos pela invocação de uma função de transformação em cada
elemento da sequência de entrada.

public static decimal Sum<TSource> (this System.Collections.Generic.IEnumerable<TSource> source,


Func<TSource,decimal> selector);
static member Sum : seq<'Source> * Func<'Source, decimal> -> decimal

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência de valores usados para calcular uma soma.
selector Func<TSource,Decimal>
Uma função de transformação a ser aplicada a cada elemento.
Returns
Decimal Decimal
A soma dos valores projetados.
Exceptions
ArgumentNullException ArgumentNullException
source ou selector é null .
OverflowException OverflowException
A soma é maior que MaxValue.
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

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 a este tópico, altere o corpo da função selector .
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);


}

/*
This code produces the following output:

The total weight of the packages is: 83.7


*/

Remarks
Esse método retornará zero se source não contiver elementos.

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 Decimal.
Na sintaxe de expressão de consulta do Visual Basic, uma Aggregate Into Sum() cláusula se traduz em uma
invocação de Sum.
See Cláusula Aggregate (Visual Basic)Aggregate Clause (Visual Basic)
Also
Enumerable.Take Enumerable.Take
I n this Article
Retorna um número especificado de elementos contíguos do início de uma sequência.
public static System.Collections.Generic.IEnumerable<TSource> Take<TSource> (this
System.Collections.Generic.IEnumerable<TSource> source, int count);
static member Take : seq<'Source> * int -> seq<'Source>

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
A sequência da qual os elementos serão retornados.
count Int32 Int32
O número de elementos a serem retornados.
Returns
IEnumerable<TSource>
Um IEnumerable<T> que contém o número especificado de elementos do início da sequência de entrada.
Exceptions
ArgumentNullException ArgumentNullException
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)
{
Console.WriteLine(grade);
}
/*
This code produces the following output:

The top three grades are:


98
92
85
*/
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.

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
System.Collections.Generic.IEnumerable<TSource> source, int count);
static member TakeLast : seq<'Source> * int -> seq<'Source>

Type Parameters
TSource
Parameters
source IEnumerable<TSource>
count Int32 Int32
Returns
IEnumerable<TSource>
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>
(IEnumerable<TSource>, Func<TSource,Boolean>)
Retorna os elementos de uma sequência contanto que uma condição especificada seja verdadeira.
public static System.Collections.Generic.IEnumerable<TSource> TakeWhile<TSource> (this
System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,bool> predicate);
static member TakeWhile : seq<'Source> * Func<'Source, bool> -> seq<'Source>

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Uma sequência a qual retornar os elementos.
predicate Func<TSource,Boolean>
Uma função para testar cada elemento em relação a uma condição.
Returns
IEnumerable<TSource>
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
ArgumentNullException ArgumentNullException
source ou predicate é null .
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.
string[] fruits = { "apple", "banana", "mango", "orange",
"passionfruit", "grape" };

IEnumerable<string> query =
fruits.TakeWhile(fruit => String.Compare("orange", fruit, true) != 0);

foreach (string fruit in query)


{
Console.WriteLine(fruit);
}

/*
This code produces the following output:

apple
banana
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 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.

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 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>
(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.
public static System.Collections.Generic.IEnumerable<TSource> TakeWhile<TSource> (this
System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,int,bool> predicate);
static member TakeWhile : seq<'Source> * Func<'Source, int, bool> -> seq<'Source>

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
A sequência da qual os elementos serão retornados.
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
IEnumerable<TSource>
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
ArgumentNullException ArgumentNullException
source ou predicate é null .
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" };

IEnumerable<string> query =
fruits.TakeWhile((fruit, index) => fruit.Length >= index);

foreach (string fruit in query)


{
Console.WriteLine(fruit);
}

/*
This code produces the following output:

apple
passionfruit
banana
mango
orange
blueberry
*/

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 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.
O primeiro argumento do predicate representa o elemento a ser testado. O segundo argumento representa o índice
baseado em zero do elemento no source .

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 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.

ThenBy<TSource,TKey>(IOrderedEnumerable<TSource>,
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.

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.
public static System.Linq.IOrderedEnumerable<TSource> ThenBy<TSource,TKey> (this
System.Linq.IOrderedEnumerable<TSource> source, Func<TSource,TKey> keySelector,
System.Collections.Generic.IComparer<TKey> comparer);
static member ThenBy : System.Linq.IOrderedEnumerable<'Source> * Func<'Source, 'Key> *
System.Collections.Generic.IComparer<'Key> -> System.Linq.IOrderedEnumerable<'Source>

Type Parameters
TSource
O tipo dos elementos de source .
TKey
O tipo da chave retornada por keySelector .
Parameters
source IOrderedEnumerable<TSource>
Um IOrderedEnumerable<TElement> que contém elementos a ser classificados.
keySelector Func<TSource,TKey>
Uma função para extrair uma chave de cada elemento.
comparer IComparer<TKey>
Um IComparer<T> para comparar chaves.
Returns
IOrderedEnumerable<TSource>
Um IOrderedEnumerable<TElement> cujos elementos são classificados de acordo com uma chave.
Exceptions
ArgumentNullException ArgumentNullException
source ou keySelector é null .
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.

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 .
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

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.
Se comparer está null , o comparador padrão Default é usado para comparar chaves.

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.

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.

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> ->
System.Linq.IOrderedEnumerable<'Source>

Type Parameters
TSource
O tipo dos elementos de source .
TKey
O tipo da chave retornada por keySelector .
Parameters
source IOrderedEnumerable<TSource>
Um IOrderedEnumerable<TElement> que contém elementos a ser classificados.
keySelector Func<TSource,TKey>
Uma função para extrair uma chave de cada elemento.
Returns
IOrderedEnumerable<TSource>
Um IOrderedEnumerable<TElement> cujos elementos são classificados de acordo com uma chave.
Exceptions
ArgumentNullException ArgumentNullException
source ou keySelector é null .
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.
IEnumerable<string> query =
fruits.OrderBy(fruit => fruit.Length).ThenBy(fruit => fruit);

foreach (string fruit in query)


{
Console.WriteLine(fruit);
}

/*
This code produces the following output:

apple
grape
mango
banana
orange
blueberry
raspberry
passionfruit
*/

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.

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 .

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

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 [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>
(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.
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> ->
System.Linq.IOrderedEnumerable<'Source>

Type Parameters
TSource
O tipo dos elementos de source .
TKey
O tipo da chave retornada por keySelector .
Parameters
source IOrderedEnumerable<TSource>
Um IOrderedEnumerable<TElement> que contém elementos a ser classificados.
keySelector Func<TSource,TKey>
Uma função para extrair uma chave de cada elemento.
Returns
IOrderedEnumerable<TSource>
Um IOrderedEnumerable<TElement> cujos elementos são classificados em ordem decrescente de acordo com uma
chave.
Exceptions
ArgumentNullException ArgumentNullException
source ou keySelector é null .
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.

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 .
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

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 de classificação 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.
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)

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.
public static System.Linq.IOrderedEnumerable<TSource> ThenByDescending<TSource,TKey> (this
System.Linq.IOrderedEnumerable<TSource> source, Func<TSource,TKey> keySelector,
System.Collections.Generic.IComparer<TKey> comparer);
static member ThenByDescending : System.Linq.IOrderedEnumerable<'Source> * Func<'Source, 'Key> *
System.Collections.Generic.IComparer<'Key> -> System.Linq.IOrderedEnumerable<'Source>
Type Parameters
TSource
O tipo dos elementos de source .

TKey
O tipo da chave retornada por keySelector .
Parameters
source IOrderedEnumerable<TSource>
Um IOrderedEnumerable<TElement> que contém elementos a ser classificados.
keySelector Func<TSource,TKey>
Uma função para extrair uma chave de cada elemento.
comparer IComparer<TKey>
Um IComparer<T> para comparar chaves.
Returns
IOrderedEnumerable<TSource>
Um IOrderedEnumerable<TElement> cujos elementos são classificados em ordem decrescente de acordo com uma
chave.
Exceptions
ArgumentNullException ArgumentNullException
source ou keySelector é null .
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.
IEnumerable<string> query =
fruits
.OrderBy(fruit => fruit.Length)
.ThenByDescending(fruit => fruit, new CaseInsensitiveComparer());

foreach (string fruit in query)


{
Console.WriteLine(fruit);
}
}

/*
This code produces the following output:

apPLe
apple
APple
apPLE
orange
ORANGE
baNanA
BAnana
*/

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.

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 .

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

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.
Se comparer está null , o comparador padrão Default é usado para comparar chaves.

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.
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
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Um IEnumerable<T> para criar uma matriz.
Returns
TSource[]
Uma matriz que contém os elementos da sequência de entrada.
Exceptions
ArgumentNullException ArgumentNullException
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 string Company { get; set; }
public double Weight { get; set; }
}

public static void ToArrayEx1()


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

string[] companies = packages.Select(pkg => pkg.Company).ToArray();

foreach (string company in companies)


{
Console.WriteLine(company);
}
}

/*
This code produces the following output:

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.
Func<TSource,TElement>, IEqualityComparer<TKey>)

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>,
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.
public static System.Collections.Generic.Dictionary<TKey,TElement>
ToDictionary<TSource,TKey,TElement> (this System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,TKey> keySelector, Func<TSource,TElement> elementSelector);
static member ToDictionary : seq<'Source> * Func<'Source, 'Key> * Func<'Source, 'Element> ->
System.Collections.Generic.Dictionary<'Key, 'Element>

Type Parameters
TSource
O tipo dos elementos de source .
TKey
O tipo da chave retornada por keySelector .
TElement
O tipo do valor retornado por elementSelector .
Parameters
source IEnumerable<TSource>
Um IEnumerable<T> por meio do qual um Dictionary<TKey,TValue> será criado.
keySelector Func<TSource,TKey>
Uma função para extrair uma chave de cada elemento.
elementSelector Func<TSource,TElement>
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
ArgumentNullException ArgumentNullException
source , keySelector ou elementSelector é null .
- 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.

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>,
Func<TSource,TKey>, Func<TSource,TElement>,
IEqualityComparer<TKey>)
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>,
Func<TSource,TKey>, Func<TSource,TElement>,
IEqualityComparer<TKey>)
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.

public static System.Collections.Generic.Dictionary<TKey,TElement>


ToDictionary<TSource,TKey,TElement> (this System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,TKey> keySelector, Func<TSource,TElement> elementSelector,
System.Collections.Generic.IEqualityComparer<TKey> comparer);
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
O tipo dos elementos de source .

TKey
O tipo da chave retornada por keySelector .

TElement
O tipo do valor retornado por elementSelector .

Parameters
source IEnumerable<TSource>
Um IEnumerable<T> por meio do qual um Dictionary<TKey,TValue> será criado.
keySelector Func<TSource,TKey>
Uma função para extrair uma chave de cada elemento.
elementSelector Func<TSource,TElement>
Uma função de transformação para produzir um valor de elemento de resultado de cada elemento.
comparer IEqualityComparer<TKey>
Um IEqualityComparer<T> para comparar chaves.
Returns
Dictionary<TKey,TElement>
Um Dictionary<TKey,TValue> que contém valores do tipo TElement selecionados da sequência de entrada.

Exceptions
ArgumentNullException ArgumentNullException
source , keySelector ou elementSelector é null .
- ou - keySelector gera uma chave que é null .

ArgumentException ArgumentException
keySelector gera chaves duplicatas para dois elementos.
Remarks
Se comparer está null , o comparador de igualdade padrão Default é usado para comparar chaves.

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.

public static System.Collections.Generic.Dictionary<TKey,TSource> ToDictionary<TSource,TKey> (this


System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector);
static member ToDictionary : seq<'Source> * Func<'Source, 'Key> ->
System.Collections.Generic.Dictionary<'Key, 'Source>

Type Parameters
TSource
O tipo dos elementos de source .

TKey
O tipo da chave retornada por keySelector .

Parameters
source IEnumerable<TSource>
Um IEnumerable<T> por meio do qual um Dictionary<TKey,TValue> será criado.
keySelector Func<TSource,TKey>
Uma função para extrair uma chave de cada elemento.
Returns
Dictionary<TKey,TSource>
Um Dictionary<TKey,TValue> que contém chaves e valores.
Exceptions
ArgumentNullException ArgumentNullException
source ou keySelector é null .
- ou - keySelector gera uma chave que é null .

ArgumentException ArgumentException
keySelector gera chaves duplicatas para dois elementos.
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 string Company { get; set; }
public double Weight { get; set; }
public long TrackingNumber { get; set; }
}

public static void ToDictionaryEx1()


{
List<Package> packages =
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);
}
}

/*
This code produces the following output:

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.

ToDictionary<TSource,TKey>(IEnumerable<TSource>,
Func<TSource,TKey>, IEqualityComparer<TKey>)
ToDictionary<TSource,TKey>(IEnumerable<TSource>,
Func<TSource,TKey>, IEqualityComparer<TKey>)
Cria um Dictionary<TKey,TValue> de um IEnumerable<T>, de acordo com uma função de seletor de chave
especificada e um comparador de chaves.
public static System.Collections.Generic.Dictionary<TKey,TSource> ToDictionary<TSource,TKey> (this
System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector,
System.Collections.Generic.IEqualityComparer<TKey> comparer);
static member ToDictionary : seq<'Source> * Func<'Source, 'Key> *
System.Collections.Generic.IEqualityComparer<'Key> -> System.Collections.Generic.Dictionary<'Key,
'Source>

Type Parameters
TSource
O tipo dos elementos de source .
TKey
O tipo das chaves retornadas por keySelector .

Parameters
source IEnumerable<TSource>
Um IEnumerable<T> por meio do qual um Dictionary<TKey,TValue> será criado.
keySelector Func<TSource,TKey>
Uma função para extrair uma chave de cada elemento.
comparer IEqualityComparer<TKey>
Um IEqualityComparer<T> para comparar chaves.
Returns
Dictionary<TKey,TSource>
Um Dictionary<TKey,TValue> que contém chaves e valores.
Exceptions
ArgumentNullException ArgumentNullException
source ou keySelector é null .
- ou - keySelector gera uma chave que é null .

ArgumentException ArgumentException
keySelector gera chaves duplicatas para dois elementos.
Remarks
Se comparer está null , o comparador de igualdade padrão Default é usado para comparar chaves.
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


System.Collections.Generic.IEnumerable<TSource> source,
System.Collections.Generic.IEqualityComparer<TSource> comparer);
static member ToHashSet : seq<'Source> * System.Collections.Generic.IEqualityComparer<'Source> ->
System.Collections.Generic.HashSet<'Source>

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Um IEnumerable<T> por meio do qual um HashSet<T> será criado.
comparer IEqualityComparer<TSource>
Um IEqualityComparer<T> para comparar chaves.
Returns
HashSet<TSource>
Um HashSet<T> que contém valores do tipo TSource selecionados da sequência de entrada.

ToHashSet<TSource>(IEnumerable<TSource>)
ToHashSet<TSource>(IEnumerable<TSource>)
Cria um HashSet<T> de um IEnumerable<T>.
public static System.Collections.Generic.HashSet<TSource> ToHashSet<TSource> (this
System.Collections.Generic.IEnumerable<TSource> source);
static member ToHashSet : seq<'Source> -> System.Collections.Generic.HashSet<'Source>
Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
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
System.Collections.Generic.IEnumerable<TSource> source);
static member ToList : seq<'Source> -> System.Collections.Generic.List<'Source>

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
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
ArgumentNullException ArgumentNullException
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.
string[] fruits = { "apple", "passionfruit", "banana", "mango",
"orange", "blueberry", "grape", "strawberry" };

List<int> lengths = fruits.Select(fruit => fruit.Length).ToList();

foreach (int length in lengths)


{
Console.WriteLine(length);
}

/*
This code produces the following output:

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.

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>,
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
TSource>, Func<TSource,TKey>) acordo com uma função de seletor de chave especificada.

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.

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
chave e seletor de elemento.
public static System.Linq.ILookup<TKey,TElement> ToLookup<TSource,TKey,TElement> (this
System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector,
Func<TSource,TElement> elementSelector);
static member ToLookup : seq<'Source> * Func<'Source, 'Key> * Func<'Source, 'Element> ->
System.Linq.ILookup<'Key, 'Element>

Type Parameters
TSource
O tipo dos elementos de source .
TKey
O tipo da chave retornada por keySelector .
TElement
O tipo do valor retornado por elementSelector .
Parameters
source IEnumerable<TSource>
O IEnumerable<T> por meio do qual um Lookup<TKey,TElement> será criado.
keySelector Func<TSource,TKey>
Uma função para extrair uma chave de cada elemento.
elementSelector Func<TSource,TElement>
Uma função de transformação para produzir um valor de elemento de resultado de cada elemento.
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
ArgumentNullException ArgumentNullException
source , keySelector ou elementSelector é null .
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 string Company { get; set; }
public double Weight { get; set; }
public long TrackingNumber { get; set; }
}

public static void ToLookupEx1()


{
// Create a list of Packages.
List<Package> packages =
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 = "Contoso Pharmaceuticals",
Weight = 9.3, TrackingNumber = 670053128L },
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)
{
// Print the key value of the IGrouping.
Console.WriteLine(packageGroup.Key);
// Iterate through each value in the
// IGrouping and print its value.
foreach (string str in packageGroup)
Console.WriteLine(" {0}", str);
}
}

/*
This code produces the following output:

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.
O comparador de igualdade padrão Default é usado para comparar chaves.

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>,
Func<TSource,TKey>, Func<TSource,TElement>,
IEqualityComparer<TKey>) ToLookup<TSource,TKey,TElement>
(IEnumerable<TSource>, Func<TSource,TKey>,
Func<TSource,TElement>, IEqualityComparer<TKey>)
Cria um Lookup<TKey,TElement> 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.

public static System.Linq.ILookup<TKey,TElement> ToLookup<TSource,TKey,TElement> (this


System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector,
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
O tipo dos elementos de source .
TKey
O tipo da chave retornada por keySelector .
TElement
O tipo do valor retornado por elementSelector .
Parameters
source IEnumerable<TSource>
O IEnumerable<T> por meio do qual um Lookup<TKey,TElement> será criado.
keySelector Func<TSource,TKey>
Uma função para extrair uma chave de cada elemento.
elementSelector Func<TSource,TElement>
Uma função de transformação para produzir um valor de elemento de resultado de cada elemento.
comparer IEqualityComparer<TKey>
Um IEqualityComparer<T> para comparar chaves.
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
ArgumentNullException ArgumentNullException
source , keySelector ou elementSelector é null .
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.
Se comparer está null , o comparador de igualdade padrão Default é usado para comparar chaves.

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.
public static System.Linq.ILookup<TKey,TSource> ToLookup<TSource,TKey> (this
System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector);
static member ToLookup : seq<'Source> * Func<'Source, 'Key> -> System.Linq.ILookup<'Key, 'Source>

Type Parameters
TSource
O tipo dos elementos de source .

TKey
O tipo da chave retornada por keySelector .

Parameters
source IEnumerable<TSource>
O IEnumerable<T> por meio do qual um Lookup<TKey,TElement> será criado.
keySelector Func<TSource,TKey>
Uma função para extrair uma chave de cada elemento.
Returns
ILookup<TKey,TSource>
Um Lookup<TKey,TElement> que contém chaves e valores.
Exceptions
ArgumentNullException ArgumentNullException
source ou keySelector é null .
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.
O comparador de igualdade padrão Default é usado para comparar chaves.

ToLookup<TSource,TKey>(IEnumerable<TSource>,
Func<TSource,TKey>, IEqualityComparer<TKey>)
ToLookup<TSource,TKey>(IEnumerable<TSource>,
Func<TSource,TKey>, IEqualityComparer<TKey>)
Cria um Lookup<TKey,TElement> de um IEnumerable<T>, de acordo com uma função de seletor de chave
especificada e um comparador de chaves.
public static System.Linq.ILookup<TKey,TSource> ToLookup<TSource,TKey> (this
System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector,
System.Collections.Generic.IEqualityComparer<TKey> comparer);
static member ToLookup : seq<'Source> * Func<'Source, 'Key> *
System.Collections.Generic.IEqualityComparer<'Key> -> System.Linq.ILookup<'Key, 'Source>

Type Parameters
TSource
O tipo dos elementos de source .

TKey
O tipo da chave retornada por keySelector .

Parameters
source IEnumerable<TSource>
O IEnumerable<T> por meio do qual um Lookup<TKey,TElement> será criado.
keySelector Func<TSource,TKey>
Uma função para extrair uma chave de cada elemento.
comparer IEqualityComparer<TKey>
Um IEqualityComparer<T> para comparar chaves.
Returns
ILookup<TKey,TSource>
Um Lookup<TKey,TElement> que contém chaves e valores.
Exceptions
ArgumentNullException ArgumentNullException
source ou keySelector é null .
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.
Se comparer está null , o comparador de igualdade padrão Default é usado para comparar chaves.
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>
(IEnumerable<TSource>, IEnumerable<TSource>)
Produz a união de conjunto de duas sequências usando o comparador de igualdade padrão.
public static System.Collections.Generic.IEnumerable<TSource> Union<TSource> (this
System.Collections.Generic.IEnumerable<TSource> first,
System.Collections.Generic.IEnumerable<TSource> second);
static member Union : seq<'Source> * seq<'Source> -> seq<'Source>

Type Parameters
TSource
O tipo dos elementos das sequências de entrada.
Parameters
first IEnumerable<TSource>
Um IEnumerable<T> cujos elementos distintos formam o primeiro conjunto da união.
second IEnumerable<TSource>
Um IEnumerable<T> cujos elementos distintos formam o segundo conjunto da união.
Returns
IEnumerable<TSource>
Um IEnumerable<T> que contém os elementos de ambas as sequências de entrada, excluindo as duplicatas.
Exceptions
ArgumentNullException ArgumentNullException
first ou second é null .
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);
}

/*
This code produces the following output:

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
implementar essa interface em um tipo de dados personalizadas e fornecer GetHashCode e Equals métodos.
public class ProductA: IEquatable<ProductA>
{
public string Name { get; set; }
public int Code { get; set; }

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 Union<TSource>
(IEnumerable<TSource>, IEnumerable<TSource>) método, conforme mostrado no exemplo a seguir.

ProductA[] store1 = { new ProductA { Name = "apple", Code = 9 },


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

ProductA[] store2 = { new ProductA { Name = "apple", Code = 9 },


new ProductA { Name = "lemon", Code = 12 } };

//Get the products from the both arrays


//excluding duplicates.

IEnumerable<ProductA> union =
store1.Union(store2);

foreach (var product in union)


Console.WriteLine(product.Name + " " + product.Code);

/*
This code produces the following output:

apple 9
orange 4
lemon 12
*/
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.

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.
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.
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>)
Produz a união de conjunto de duas sequências usando o IEqualityComparer<T> especificado.
public static System.Collections.Generic.IEnumerable<TSource> Union<TSource> (this
System.Collections.Generic.IEnumerable<TSource> first,
System.Collections.Generic.IEnumerable<TSource> second,
System.Collections.Generic.IEqualityComparer<TSource> comparer);
static member Union : seq<'Source> * seq<'Source> *
System.Collections.Generic.IEqualityComparer<'Source> -> seq<'Source>

Type Parameters
TSource
O tipo dos elementos das sequências de entrada.
Parameters
first IEnumerable<TSource>
Um IEnumerable<T> cujos elementos distintos formam o primeiro conjunto da união.
second IEnumerable<TSource>
Um IEnumerable<T> cujos elementos distintos formam o segundo conjunto da união.
comparer IEqualityComparer<TSource>
O IEqualityComparer<T> para comparar valores.
Returns
IEnumerable<TSource>
Um IEnumerable<T> que contém os elementos de ambas as sequências de entrada, excluindo as duplicatas.
Exceptions
ArgumentNullException ArgumentNullException
first ou second é null .
Examples
O exemplo a seguir mostra como implementar um comparador de igualdade que pode ser usado no Union método.
public class Product
{
public string Name { get; set; }
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 sequências de Product objetos no Union método, conforme
mostrado no exemplo a seguir.

Product[] store1 = { new Product { Name = "apple", Code = 9 },


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

Product[] store2 = { new Product { Name = "apple", Code = 9 },


new Product { Name = "lemon", Code = 12 } };
//Get the products from the both arrays
//excluding duplicates.

IEnumerable<Product> union =
store1.Union(store2, new ProductComparer());

foreach (var product in union)


Console.WriteLine(product.Name + " " + product.Code);

/*
This code produces the following output:

apple 9
orange 4
lemon 12
*/

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.

Se comparer está null , o comparador de igualdade padrão, Default, é usado para comparar valores.
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>
(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.
public static System.Collections.Generic.IEnumerable<TSource> Where<TSource> (this
System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,int,bool> predicate);
static member Where : seq<'Source> * Func<'Source, int, bool> -> seq<'Source>

Type Parameters
TSource
O tipo dos elementos de source .
Parameters
source IEnumerable<TSource>
Um IEnumerable<T> a ser filtrado.
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
IEnumerable<TSource>
Um IEnumerable<T> que contém elementos da sequência de entrada que atendem à condição.
Exceptions
ArgumentNullException ArgumentNullException
source ou predicate é null .
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 };

IEnumerable<int> query =
numbers.Where((number, index) => number <= index * 10);

foreach (int number in query)


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

0
20
15
40
*/

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 primeiro argumento do predicate representa o elemento a ser testado. O segundo argumento representa o índice
baseado em zero do elemento no source .

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.
public static System.Collections.Generic.IEnumerable<TSource> Where<TSource> (this
System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,bool> predicate);
static member Where : seq<'Source> * Func<'Source, bool> -> seq<'Source>

Type Parameters
TSource
O tipo dos elementos de source .

Parameters
source IEnumerable<TSource>
Um IEnumerable<T> a ser filtrado.
predicate Func<TSource,Boolean>
Uma função para testar cada elemento em relação a uma condição.
Returns
IEnumerable<TSource>
Um IEnumerable<T> que contém elementos da sequência de entrada que atendem à condição.
Exceptions
ArgumentNullException ArgumentNullException
source ou predicate é null .
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",
"orange", "blueberry", "grape", "strawberry" };

IEnumerable<string> query = fruits.Where(fruit => fruit.Length < 6);

foreach (string fruit in query)


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

apple
mango
grape
*/

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.

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
IEnumerable<TResult>
Um IEnumerable<T> que contém elementos mesclados de duas sequências de entrada.
Exceptions
ArgumentNullException ArgumentNullException
first ou second é null .

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

// This code produces the following output:

// 1 one
// 2 two
// 3 three

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

I nheritance H ierarchy
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

I nheritance H ierarchy
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

I nheritance H ierarchy
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

I nheritance H ierarchy
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()
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.

IQueryable.ElementType
IQueryable.ElementType

Obtém o tipo dos dados na coleção que são representados por esta instância.

IQueryable.Expression
IQueryable.Expression

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)
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)
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)
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)
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
expression Expression Expression
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
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.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.
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 .

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>.
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
expression Expression
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
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.

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.
object IQueryProvider.Execute (System.Linq.Expressions.Expression expression);

Parameters
expression Expression
Uma árvore de expressão para executar.
Returns
Object
O valor que resulta da execução de expression .

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.
S IQueryProvider.Execute<S> (System.Linq.Expressions.Expression expression);

Type Parameters
S
O tipo de dados na coleção que expression representa.
Parameters
expression Expression
Uma árvore de expressão para executar.
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>
interface IEnumerable

I nheritance H ierarchy
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>.
ILookup<TKey,TElement> ILookup<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>>
interface IEnumerable

I nheritance H ierarchy
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

I nheritance H ierarchy
Object Object

Methods
Aggregate<T>(ImmutableArray<T>, Func<T,T,T>)
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>)

Aplica uma função a uma sequência de elementos de uma maneira cumulativa.

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

Aplica uma função a uma sequência de elementos de uma maneira cumulativa.

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>)
Any<T>(ImmutableArray<T>)

Obtém um valor que indica se a matriz contém elementos.

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.

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)

Retorna o elemento em um índice especificado em uma sequência ou um valor padrão se o índice estiver fora do
intervalo.

First<T>(ImmutableArray<T>)
First<T>(ImmutableArray<T>)

Retorna o primeiro elemento em uma matriz.

First<T>(ImmutableArray<T>)
First<T>(ImmutableArray<T>)

Retorna o primeiro elemento na coleção.

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.

FirstOrDefault<T>(ImmutableArray<T>)
FirstOrDefault<T>(ImmutableArray<T>)

Retorna o primeiro elemento de uma sequência ou um valor padrão se a sequência não contém elementos.

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>)
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.
Last<T>(ImmutableArray<T>)
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 de uma sequência que satisfaz uma condição especificada.

Last<T>(ImmutableArray<T>)
Last<T>(ImmutableArray<T>)

Retorna o último elemento da matriz.

LastOrDefault<T>(ImmutableArray<T>)
LastOrDefault<T>(ImmutableArray<T>)

Retorna 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.

LastOrDefault<T>(ImmutableArray<T>, Func<T,Boolean>)
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.

Select<T,TResult>(ImmutableArray<T>, Func<T,TResult>)
Select<T,TResult>(ImmutableArray<T>, Func<T,TResult>)

Projeta cada elemento de uma sequência em um novo formulário.

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

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.
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>)
SequenceEqual<TDerived,TBase>(ImmutableArray<TBase>, ImmutableArray<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>,
Func<TBase,TBase,Boolean>)
SequenceEqual<TDerived,TBase>(ImmutableArray<TBase>, ImmutableArray<TDerived>,
Func<TBase,TBase,Boolean>)

Determina se duas sequências são iguais de acordo com um comparador de igualdade.

Single<T>(ImmutableArray<T>)
Single<T>(ImmutableArray<T>)

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<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.

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>)
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 elemento satisfizer a condição.

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

Cria um dicionário com base no conteúdo desta matriz.

ToDictionary<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>,
IEqualityComparer<TKey>)

Cria um dicionário com base no conteúdo desta matriz.

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


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

Cria um dicionário com base no conteúdo desta matriz.

Where<T>(ImmutableArray<T>, Func<T,Boolean>)
Where<T>(ImmutableArray<T>, Func<T,Boolean>)

Filtra uma sequência de valores com base em um predicado.


ImmutableArrayExtensions.Aggregate ImmutableArray
Extensions.Aggregate
I n this Article

Overloads
Aggregate<T>(ImmutableArray<T>, Func<T,T,T>)
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>)
Aplica uma função a uma sequência de elementos de uma maneira cumulativa.
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>)
Aplica uma função a uma sequência de elementos de uma maneira cumulativa.
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
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
A coleção à qual aplicar a função.
seed TAccumulate TAccumulate
O valor inicial do acumulador.
func Func<TAccumulate,T,TAccumulate>
Uma função a ser invocada em cada elemento, de modo cumulativo.
Returns
TAccumulate TAccumulate
O valor final do acumulador.
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,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>)
Aplica uma função a uma sequência de elementos de uma maneira cumulativa.

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
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
A coleção à qual aplicar a função.
seed TAccumulate TAccumulate
O valor inicial do acumulador.
func Func<TAccumulate,T,TAccumulate>
Uma função a ser invocada em cada elemento, de modo cumulativo.
resultSelector Func<TAccumulate,TResult>
Returns
TResult TResult
O valor final do acumulador.
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 .
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
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
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>)
Obtém um valor que indica se a matriz contém elementos.

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.

Any<T>(ImmutableArray<T>) Any<T>(ImmutableArray<T>)
Obtém um valor que indica se a matriz contém elementos.
public static bool Any<T> (this System.Collections.Immutable.ImmutableArray<T> immutableArray);
static member Any : System.Collections.Immutable.ImmutableArray<'T> -> bool

Type Parameters
T
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
A matriz na qual verificar se há elementos.
Returns
Boolean Boolean
true se a matriz contém elementos; caso contrário, false .

Any<T>(ImmutableArray<T>) Any<T>(ImmutableArray<T>)
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,
Func<T,bool> predicate);
static member Any : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, bool> -> bool

Type Parameters
T
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
A matriz na qual verificar se há elementos.
predicate Func<T,Boolean>
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
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
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
Retorna o elemento em um índice especificado em uma sequência ou um valor padrão se o índice estiver fora do
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
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
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>)
Retorna o primeiro elemento em uma matriz.

First<T>(ImmutableArray<T>) First<T>(ImmutableArray<T>)
Retorna o primeiro elemento na coleção.

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.

First<T>(ImmutableArray<T>) First<T>(ImmutableArray<T>)
Retorna o primeiro elemento em uma matriz.
public static T First<T> (this System.Collections.Immutable.ImmutableArray<T> immutableArray);
static member First : System.Collections.Immutable.ImmutableArray<'T> -> 'T

Type Parameters
T
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
A matriz da qual obter um item.
Returns
TT
O primeiro item na matriz.
Exceptions
InvalidOperationException InvalidOperationException
Se a matriz está vazia.

First<T>(ImmutableArray<T>) First<T>(ImmutableArray<T>)
Retorna o primeiro elemento na coleção.
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
builder ImmutableArray<T>.Builder
O construtor do qual recuperar um item.
Returns
TT
O primeiro item na lista.
Exceptions
InvalidOperationException InvalidOperationException
Se a matriz está vazia.

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,


Func<T,bool> predicate);
static member First : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, bool> -> 'T

Type Parameters
T
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
A matriz da qual obter um item.
predicate Func<T,Boolean>
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
InvalidOperationException InvalidOperationException
Se a matriz está vazia.
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
padrão se a sequência não contém elementos.

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>)
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>)
Retorna o primeiro elemento de uma sequência ou um valor padrão se a sequência não contém elementos.
public static T FirstOrDefault<T> (this System.Collections.Immutable.ImmutableArray<T>
immutableArray);
static member FirstOrDefault : System.Collections.Immutable.ImmutableArray<'T> -> 'T

Type Parameters
T
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
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
builder ImmutableArray<T>.Builder
O construtor do qual recuperar um elemento.
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>, Func<T,Boolean>)
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.
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
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
A matriz da qual recuperar elementos.
predicate Func<T,Boolean>
O delegado que define as condições do elemento a ser pesquisado.
Returns
TT
O primeiro item na lista, se encontrado; caso contrário, o valor padrão para o tipo de item.
ImmutableArrayExtensions.Last ImmutableArray
Extensions.Last
I n this Article

Overloads
Last<T>(ImmutableArray<T>) 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 de uma sequência que satisfaz
uma condição especificada.

Last<T>(ImmutableArray<T>) Last<T>(ImmutableArray<T>)
Retorna o último elemento da matriz.

Last<T>(ImmutableArray<T>) Last<T>(ImmutableArray<T>)
Retorna o último elemento na coleção.
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
O tipo de item no construtor.
Parameters
builder ImmutableArray<T>.Builder
O construtor do qual recuperar elementos.
Returns
TT
O último elemento no construtor.
Exceptions
InvalidOperationException InvalidOperationException
Gerada se a coleção está vazia.

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> immutableArray,
Func<T,bool> predicate);
static member Last : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, bool> -> 'T

Type Parameters
T
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
A matriz da qual recuperar elementos.
predicate Func<T,Boolean>
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
InvalidOperationException InvalidOperationException
Gerada se a coleção está vazia.

Last<T>(ImmutableArray<T>) Last<T>(ImmutableArray<T>)
Retorna o último elemento da matriz.

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
immutableArray ImmutableArray<T> ImmutableArray<T>
A matriz da qual recuperar itens.
Returns
TT
O último elemento na matriz.
Exceptions
InvalidOperationException InvalidOperationException
Gerada se a coleção está vazia.
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
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.

LastOrDefault<T>(ImmutableArray<T>, Func<T,Boolean>)
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>)
Retorna o último elemento de uma sequência ou um valor padrão se a sequência não contém elementos.
public static T LastOrDefault<T> (this System.Collections.Immutable.ImmutableArray<T>
immutableArray);
static member LastOrDefault : System.Collections.Immutable.ImmutableArray<'T> -> 'T

Type Parameters
T
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
A matriz da qual recuperar itens.
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
O tipo de item no construtor.
Parameters
builder ImmutableArray<T>.Builder
O construtor do qual recuperar um elemento.
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>, Func<T,Boolean>)
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.
public static T LastOrDefault<T> (this System.Collections.Immutable.ImmutableArray<T>
immutableArray, Func<T,bool> predicate);
static member LastOrDefault : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, bool> -> 'T

Type Parameters
T
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
A matriz da qual recuperar um elemento.
predicate Func<T,Boolean>
O delegado que define as condições do elemento a ser pesquisado.
Returns
TT
O último elemento de uma sequência ou um valor padrão se a sequência não contém elementos.
ImmutableArrayExtensions.Select ImmutableArray
Extensions.Select
I n this Article
Projeta cada elemento de uma sequência em um novo formulário.

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
O tipo de elemento contido pela coleção.
TResult
O tipo de elemento de resultado.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
A matriz imutável da qual selecionar itens.
selector Func<T,TResult> Func<T,TResult>
Uma função de transformação a ser aplicada a cada elemento.
Returns
IEnumerable<TResult>
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
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.
public static System.Collections.Generic.IEnumerable<TResult>
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
O tipo dos elementos intermediários coletados por collectionSelector .

TResult
O tipo dos elementos da sequência resultante.
Parameters
immutableArray ImmutableArray<TSource>
A matriz imutável.
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
IEnumerable<TResult>
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 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>)

SequenceEqual<TDerived,TBase>(ImmutableArray<TBase>,
ImmutableArray<TDerived>, IEqualityComparer<TBase>) Determina se duas sequências são iguais de acordo com um
SequenceEqual<TDerived,TBase>(ImmutableArray<TBase>, comparador de igualdade.
ImmutableArray<TDerived>, IEqualityComparer<TBase>)

SequenceEqual<TDerived,TBase>(ImmutableArray<TBase>,
ImmutableArray<TDerived>, Func<TBase,TBase,Boolean>) Determina se duas sequências são iguais de acordo com um
SequenceEqual<TDerived,TBase>(ImmutableArray<TBase>, comparador de igualdade.
ImmutableArray<TDerived>, Func<TBase,TBase,Boolean>)

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.

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
O tipo de elemento contido pela coleção.
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 .

SequenceEqual<TDerived,TBase>(ImmutableArray<TBase>,
ImmutableArray<TDerived>, IEqualityComparer<TBase>)
SequenceEqual<TDerived,TBase>(ImmutableArray<TBase>,
ImmutableArray<TDerived>, IEqualityComparer<TBase>)
Determina se duas sequências são iguais de acordo com um comparador de igualdade.

public static bool SequenceEqual<TDerived,TBase> (this


System.Collections.Immutable.ImmutableArray<TBase> immutableArray,
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
O tipo de elemento da matriz comparado.
TBase
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<TBase>
A matriz a ser usada para comparação.
items ImmutableArray<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 .

SequenceEqual<TDerived,TBase>(ImmutableArray<TBase>,
ImmutableArray<TDerived>, Func<TBase,TBase,Boolean>)
SequenceEqual<TDerived,TBase>(ImmutableArray<TBase>,
ImmutableArray<TDerived>, Func<TBase,TBase,Boolean>)
Determina se duas sequências são iguais de acordo com um comparador de igualdade.

public static bool SequenceEqual<TDerived,TBase> (this


System.Collections.Immutable.ImmutableArray<TBase> immutableArray,
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
O tipo de elemento da matriz comparado.
TBase
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<TBase>
A matriz a ser usada para comparação.
items ImmutableArray<TDerived>
Os itens a serem usados para comparação.
predicate Func<TBase,TBase,Boolean>
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 .
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
exceção se não houver exatamente um elemento na
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>)
Retornará o único elemento de uma sequência e lançará uma exceção se não houver exatamente um elemento na
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
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
A matriz da qual recuperar o elemento.
Returns
TT
O elemento na 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.
public static T Single<T> (this System.Collections.Immutable.ImmutableArray<T> immutableArray,
Func<T,bool> predicate);
static member Single : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, bool> -> 'T

Type Parameters
T
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
predicate Func<T,Boolean>
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>)
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
elemento satisfizer a condição.

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
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
A matriz.
Returns
TT
O elemento da matriz ou o valor padrão, se a matriz está vazia.
Exceptions
InvalidOperationException InvalidOperationException
source contém mais de um elemento.

SingleOrDefault<T>(ImmutableArray<T>, Func<T,Boolean>)
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 elemento satisfizer a condição.
public static T SingleOrDefault<T> (this System.Collections.Immutable.ImmutableArray<T>
immutableArray, Func<T,bool> predicate);
static member SingleOrDefault : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, bool> ->
'T

Type Parameters
T
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
A matriz da qual obter o elemento.
predicate Func<T,Boolean>
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
InvalidOperationException InvalidOperationException
Mais de um elemento satisfaz a condição na predicate .
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
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
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>)

ToDictionary<TKey,T>(ImmutableArray<T>, Func<T,TKey>)
ToDictionary<TKey,T>(ImmutableArray<T>, Func<T,TKey>)
Cria um dicionário com base no conteúdo desta matriz.
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
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
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>)
Cria um dicionário com base no conteúdo desta matriz.
public static System.Collections.Generic.Dictionary<TKey,T> ToDictionary<TKey,T> (this
System.Collections.Immutable.ImmutableArray<T> immutableArray, Func<T,TKey> keySelector,
System.Collections.Generic.IEqualityComparer<TKey> comparer);
static member ToDictionary : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, 'Key> *
System.Collections.Generic.IEqualityComparer<'Key> -> System.Collections.Generic.Dictionary<'Key,
'T>

Type Parameters
TKey
Tipo da chave.
T
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
A matriz com base na qual criar um dicionário.
keySelector Func<T,TKey>
O seletor de chave.
comparer IEqualityComparer<TKey>
O comparador com o qual inicializar o dicionário.
Returns
Dictionary<TKey,T>
O dicionário recentemente inicializado.

ToDictionary<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>, IEqualityComparer<TKey>)
Cria um dicionário com base no conteúdo desta matriz.

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);
static member ToDictionary : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, 'Key> *
Func<'T, 'Element> * System.Collections.Generic.IEqualityComparer<'Key> ->
System.Collections.Generic.Dictionary<'Key, 'Element>
Type Parameters
TKey
Tipo da chave.
TElement
O tipo do elemento.
T
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
A matriz com base na qual criar um dicionário.
keySelector Func<T,TKey>
O seletor de chave.
elementSelector Func<T,TElement>
O seletor de elemento.
comparer IEqualityComparer<TKey>
O comparador com o qual inicializar o dicionário.
Returns
Dictionary<TKey,TElement>
O dicionário recentemente inicializado.

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

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);
static member ToDictionary : System.Collections.Immutable.ImmutableArray<'T> * Func<'T, 'Key> *
Func<'T, 'Element> -> System.Collections.Generic.Dictionary<'Key, 'Element>

Type Parameters
TKey
Tipo da chave.
TElement
O tipo do elemento.
T
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
A matriz com base na qual criar um dicionário.
keySelector Func<T,TKey>
O seletor de chave.
elementSelector Func<T,TElement>
O seletor de elemento.
Returns
Dictionary<TKey,TElement>
O dicionário recentemente inicializado.
ImmutableArrayExtensions.Where ImmutableArray
Extensions.Where
I n this Article
Filtra uma sequência de valores com base em um predicado.

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
O tipo de elemento contido pela coleção.
Parameters
immutableArray ImmutableArray<T> ImmutableArray<T>
A matriz a filtrar.
predicate Func<T,Boolean>
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>
interface IEnumerable

I nheritance H ierarchy
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.
comparer IComparer<TKey>
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>
Um IOrderedEnumerable<TElement> cujos elementos são classificados de acordo com uma chave.

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)
Console.WriteLine(fruit);

// This code produces the following output:


//
// 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
Representa o resultado de uma operação de classificação.

D eclaration
public interface IOrderedQueryable : System.Collections.IEnumerable, System.Linq.IQueryable
type IOrderedQueryable = interface
interface IQueryable
interface IEnumerable

I nheritance H ierarchy
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
Representa o resultado de uma operação de classificação.

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>
interface IQueryable
interface IEnumerable

I nheritance H ierarchy
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>.
Para obter mais informações sobre como criar seu próprio provedor LINQ, consulte LINQ: Criando um provedor
IQueryable em Blogs do MSDN.

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
interface IEnumerable

I nheritance H ierarchy
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.
Para obter mais informações sobre como criar seu próprio provedor LINQ, consulte LINQ: Criando um provedor
IQueryable em Blogs do MSDN.

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>
interface IQueryable
interface IEnumerable

I nheritance H ierarchy
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.
Para obter mais informações sobre como criar seu próprio provedor LINQ, consulte LINQ: Criando um provedor
IQueryable em Blogs do MSDN.
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

I nheritance H ierarchy
None

Remarks
O IQueryProvider interface de