Lookup<TKey,TElement> Classe

Definição

Representa uma coleção de chaves mapeadas para um ou mais valores.

generic <typename TKey, typename TElement>
public ref class Lookup : System::Collections::Generic::IEnumerable<System::Linq::IGrouping<TKey, TElement> ^>, System::Linq::ILookup<TKey, TElement>
public class Lookup<TKey,TElement> : System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey,TElement>>, System.Linq.ILookup<TKey,TElement>
type Lookup<'Key, 'Element> = class
    interface ILookup<'Key, 'Element>
    interface seq<IGrouping<'Key, 'Element>>
    interface IEnumerable
type Lookup<'Key, 'Element> = class
    interface seq<IGrouping<'Key, 'Element>>
    interface IEnumerable
    interface ILookup<'Key, 'Element>
Public Class Lookup(Of TKey, TElement)
Implements IEnumerable(Of IGrouping(Of TKey, TElement)), ILookup(Of TKey, TElement)

Parâmetros de tipo

TKey

O tipo das chaves no Lookup<TKey,TElement>.

TElement

O tipo dos elementos de cada valor IEnumerable<T> no Lookup<TKey,TElement>.

Herança
Lookup<TKey,TElement>
Implementações

Exemplos

O exemplo a seguir cria um Lookup<TKey,TElement> de uma coleção de objetos. Em seguida, ele enumera o Lookup<TKey,TElement> e gera cada chave e cada valor na coleção de valores associada da chave. Ele também demonstra como usar as propriedades Count e Item[] e os métodos Contains e GetEnumerator.

class Package
{
    public string Company;
    public double Weight;
    public long TrackingNumber;
}

public static void LookupExample()
{
    // Create a list of Packages to put into a Lookup data structure.
    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 for each element value in the Lookup.
    Lookup<char, string> lookup = (Lookup<char, string>)packages.ToLookup(p => p.Company[0],
                                                    p => p.Company + " " + p.TrackingNumber);

    // Iterate through each IGrouping in the Lookup and output the contents.
    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

    // Get the number of key-collection pairs in the Lookup.
    int count = lookup.Count;

    // Select a collection of Packages by indexing directly into the Lookup.
    IEnumerable<string> cgroup = lookup['C'];

    // Output the results.
    Console.WriteLine("\nPackages that have a key of 'C':");
    foreach (string str in cgroup)
        Console.WriteLine(str);

    // This code produces the following output:
    //
    // Packages that have a key of 'C'
    // Coho Vineyard 89453312
    // Contoso Pharmaceuticals 670053128

    // Determine if there is a key with the value 'G' in the Lookup.
    bool hasG = lookup.Contains('G');
}
Structure Package
    Public Company As String
    Public Weight As Double
    Public TrackingNumber As Long
End Structure

Sub LookupExample()
    ' Create a list of Packages to put into a Lookup data structure.
    Dim packages As New System.Collections.Generic.List(Of Package)(New Package() _
        {New Package With {.Company = "Coho Vineyard", .Weight = 25.2, .TrackingNumber = 89453312L}, _
          New Package With {.Company = "Lucerne Publishing", .Weight = 18.7, .TrackingNumber = 89112755L}, _
          New Package With {.Company = "Wingtip Toys", .Weight = 6.0, .TrackingNumber = 299456122L}, _
          New Package With {.Company = "Contoso Pharmaceuticals", .Weight = 9.3, .TrackingNumber = 670053128L}, _
          New Package With {.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 for each element value in the Lookup.
    Dim lookup As ILookup(Of Char, String) = _
        packages.ToLookup(Function(ByVal p) Convert.ToChar(p.Company.Substring(0, 1)), _
                          Function(ByVal p) p.Company & " " & p.TrackingNumber)

    Dim output As New System.Text.StringBuilder
    ' Iterate through each IGrouping in the Lookup and output the contents.
    For Each packageGroup As IGrouping(Of Char, String) In lookup
        ' Print the key value of the IGrouping.
        output.AppendLine(packageGroup.Key)
        ' Iterate through each value in the IGrouping and print its value.
        For Each str As String In packageGroup
            output.AppendLine(String.Format("    {0}", str))
        Next
    Next

    ' Display the output.
    MsgBox(output.ToString())

    ' 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

    ' Get the number of key-collection pairs in the Lookup.
    Dim count As Integer = lookup.Count

    ' Select a collection of Packages by indexing directly into the Lookup.
    Dim cgroup As System.Collections.Generic.IEnumerable(Of String) = lookup("C"c)

    output = New System.Text.StringBuilder
    ' Output the results.
    output.AppendLine(vbCrLf & "Packages that have a key of 'C':")
    For Each str As String In cgroup
        output.AppendLine(str)
    Next

    ' Display the output.
    MsgBox(output.ToString())

    ' This code produces the following output:
    '
    ' Packages that have a key of 'C'
    ' Coho Vineyard 89453312
    ' Contoso Pharmaceuticals 670053128

    ' Determine if there is a key with the value 'G' in the Lookup.
    Dim hasG As Boolean = lookup.Contains("G"c)
End Sub

Comentários

Um Lookup<TKey,TElement> se assemelha a um Dictionary<TKey,TValue>. A diferença é que um Dictionary<TKey,TValue> mapeia chaves para valores únicos, enquanto um Lookup<TKey,TElement> mapeia chaves para coleções de valores.

Você pode criar uma instância de um Lookup<TKey,TElement> chamando ToLookup em um objeto que implementa IEnumerable<T>.

Nota

Não há construtor público para criar uma nova instância de um Lookup<TKey,TElement>. Além disso, Lookup<TKey,TElement> objetos são imutáveis, ou seja, você não pode adicionar ou remover elementos ou chaves de um objeto Lookup<TKey,TElement> depois que ele foi criado.

Propriedades

Count

Obtém o número de pares de coleção chave/valor no Lookup<TKey,TElement>.

Item[TKey]

Obtém a coleção de valores indexados pela chave especificada.

Métodos

ApplyResultSelector<TResult>(Func<TKey,IEnumerable<TElement>,TResult>)

Aplica uma função de transformação a cada chave e seus valores associados e retorna os resultados.

Contains(TKey)

Determina se uma chave especificada está no Lookup<TKey,TElement>.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.

(Herdado de Object)
GetEnumerator()

Retorna um enumerador genérico que itera por meio do Lookup<TKey,TElement>.

GetHashCode()

Serve como a função de hash padrão.

(Herdado de Object)
GetType()

Obtém o Type da instância atual.

(Herdado de Object)
MemberwiseClone()

Cria uma cópia superficial do Objectatual.

(Herdado de Object)
ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.

(Herdado de Object)

Implantações explícitas de interface

IEnumerable.GetEnumerator()

Retorna um enumerador que itera por meio do Lookup<TKey,TElement>. Essa classe não pode ser herdada.

Métodos de Extensão

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

Cria um FrozenDictionary<TKey,TValue> de uma IEnumerable<T> de acordo com a função de seletor de chave especificada.

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

Cria um FrozenDictionary<TKey,TValue> de uma IEnumerable<T> de acordo com as funções de seletor de elemento e seletor de elemento especificadas.

ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>)

Cria um FrozenSet<T> com os valores especificados.

ToImmutableArray<TSource>(IEnumerable<TSource>)

Cria uma matriz imutável da coleção especificada.

ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Constrói um dicionário imutável a partir de uma coleção existente de elementos, aplicando uma função de transformação às chaves de origem.

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

Constrói um dicionário imutável com base em alguma transformação de uma sequência.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)

Enumera e transforma uma sequência e produz um dicionário imutável de seu conteúdo.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)

Enumera e transforma uma sequência e produz um dicionário imutável de seu conteúdo usando o comparador de chave especificado.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)

Enumera e transforma uma sequência e produz um dicionário imutável de seu conteúdo usando os comparadores de chave e valor especificados.

ToImmutableHashSet<TSource>(IEnumerable<TSource>)

Enumera uma sequência e produz um conjunto de hash imutável de seu conteúdo.

ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Enumera uma sequência, produz um conjunto de hash imutável de seu conteúdo e usa o comparador de igualdade especificado para o tipo de conjunto.

ToImmutableList<TSource>(IEnumerable<TSource>)

Enumera uma sequência e produz uma lista imutável de seu conteúdo.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)

Enumera e transforma uma sequência e produz um dicionário classificado imutável de seu conteúdo.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)

Enumera e transforma uma sequência e produz um dicionário classificado imutável de seu conteúdo usando o comparador de chave especificado.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)

Enumera e transforma uma sequência e produz um dicionário classificado imutável de seu conteúdo usando os comparadores de chave e valor especificados.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>)

Enumera uma sequência e produz um conjunto classificado imutável de seu conteúdo.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)

Enumera uma sequência, produz um conjunto classificado imutável de seu conteúdo e usa o comparador especificado.

CopyToDataTable<T>(IEnumerable<T>)

Retorna um DataTable que contém cópias dos objetos DataRow, dado um objeto de IEnumerable<T> de entrada em que o parâmetro genérico T é DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Copia DataRow objetos para o DataTableespecificado, considerando um objeto de IEnumerable<T> de entrada em que o parâmetro genérico T é DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Copia DataRow objetos para o DataTableespecificado, considerando um objeto de IEnumerable<T> de entrada em que o parâmetro genérico T é DataRow.

Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)

Aplica uma função de acumulador em uma sequência.

Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)

Aplica uma função de acumulador em uma sequência. O valor de semente especificado é usado como o valor inicial do acumulador.

Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)

Aplica uma função de acumulador em uma sequência. O valor de semente especificado é usado como o valor inicial do acumulador e a função especificada é usada para selecionar o valor do resultado.

AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>)

Representa uma coleção de chaves mapeadas para um ou mais valores.

AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey,TAccumulate>, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>)

Representa uma coleção de chaves mapeadas para um ou mais valores.

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

Determina se uma sequência contém elementos.

Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Determina se qualquer elemento de uma sequência satisfaz uma condição.

Append<TSource>(IEnumerable<TSource>, TSource)

Acrescenta um valor ao final da sequência.

AsEnumerable<TSource>(IEnumerable<TSource>)

Retorna a entrada digitada como IEnumerable<T>.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Calcula a média de uma sequência de valores Decimal obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Calcula a média de uma sequência de valores Double obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a média de uma sequência de valores Int32 obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a média de uma sequência de valores Int64 obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a média de uma sequência de valores Decimal anuláveis obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a média de uma sequência de valores Double anuláveis obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a média de uma sequência de valores Int32 anuláveis obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a média de uma sequência de valores Int64 anuláveis obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a média de uma sequência de valores Single anuláveis obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Calcula a média de uma sequência de valores Single obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

Cast<TResult>(IEnumerable)

Converte os elementos de um IEnumerable para o tipo especificado.

Chunk<TSource>(IEnumerable<TSource>, Int32)

Divide os elementos de uma sequência em partes de tamanho no máximo size.

Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Concatena duas sequências.

Contains<TSource>(IEnumerable<TSource>, TSource)

Determina se uma sequência contém um elemento especificado usando o comparador de igualdade padrão.

Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)

Determina se uma sequência contém um elemento especificado usando um IEqualityComparer<T>especificado.

Count<TSource>(IEnumerable<TSource>)

Retorna o número de elementos em uma sequência.

Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Retorna um número que representa quantos elementos na sequência especificada atendem a uma condição.

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

Representa uma coleção de chaves mapeadas para um ou mais valores.

DefaultIfEmpty<TSource>(IEnumerable<TSource>)

Retorna os elementos da sequência especificada ou o valor padrão do parâmetro de tipo em uma coleção singleton se a sequência estiver vazia.

DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)

Retorna os elementos da sequência especificada ou o valor especificado em uma coleção singleton se a sequência estiver vazia.

Distinct<TSource>(IEnumerable<TSource>)

Retorna elementos distintos de uma sequência usando o comparador de igualdade padrão para comparar valores.

Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Retorna elementos distintos de uma sequência usando um IEqualityComparer<T> especificado para comparar valores.

DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Retorna elementos distintos de uma sequência de acordo com uma função de seletor de chave especificada.

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

Retorna elementos distintos de uma sequência de acordo com uma função de seletor de chave especificada e usando um comparador especificado para comparar chaves.

ElementAt<TSource>(IEnumerable<TSource>, Index)

Retorna o elemento em um índice especificado em uma sequência.

ElementAt<TSource>(IEnumerable<TSource>, Int32)

Retorna o elemento em um índice especificado em uma sequência.

ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index)

Retorna o elemento em um índice especificado em uma sequência ou um valor padrão se o índice estiver fora do intervalo.

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.

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

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Produz a diferença de conjunto de duas sequências usando a IEqualityComparer<T> especificada para comparar valores.

ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)

Produz a diferença de conjunto de duas sequências de acordo com uma função de seletor de chave especificada.

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

Produz a diferença de conjunto de duas sequências de acordo com uma função de seletor de chave especificada.

First<TSource>(IEnumerable<TSource>)

Retorna o primeiro elemento de uma sequência.

First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Retorna o primeiro elemento em uma sequência que satisfaz uma condição especificada.

FirstOrDefault<TSource>(IEnumerable<TSource>)

Retorna o primeiro elemento de uma sequência ou um valor padrão se a sequência não contiver elementos.

FirstOrDefault<TSource>(IEnumerable<TSource>, TSource)

Retorna o primeiro elemento de uma sequência ou um valor padrão especificado se a sequência não contiver elementos.

FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Retorna o primeiro elemento da sequência que satisfaz uma condição ou um valor padrão se nenhum elemento desse tipo for encontrado.

FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

Retorna o primeiro elemento da sequência que satisfaz uma condição ou um valor padrão especificado se nenhum elemento desse tipo for encontrado.

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

Agrupa os elementos de uma sequência de acordo com uma função de seletor de chave especificada e compara as chaves usando um comparador especificado.

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

Agrupa os elementos de uma sequência de acordo com uma função de seletor de chave especificada e projeta os elementos para cada grupo usando uma função especificada.

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

Agrupa os elementos de uma sequência de acordo com uma função de 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>)

Agrupa os elementos de uma sequência de acordo com uma função de 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,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 de 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>)

Agrupa os elementos de uma sequência de acordo com uma função de seletor de chave especificada e cria um valor de resultado de cada grupo e sua chave. Os valores de chave são comparados usando um comparador especificado e os elementos de cada grupo são projetados usando uma função especificada.

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.

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 chave e agrupa os resultados. Um IEqualityComparer<T> especificado é usado para comparar chaves.

Index<TSource>(IEnumerable<TSource>)

Retorna um enumerável que incorpora o índice do elemento em uma tupla.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Produz a interseção definida de duas sequências usando o comparador de igualdade padrão para comparar valores.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Produz a interseção definida de duas sequências usando a IEqualityComparer<T> especificada para comparar valores.

IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)

Produz a interseção definida de duas sequências de acordo com uma função de seletor de chave especificada.

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

Produz a interseção definida de duas sequências de acordo com uma função de seletor de chave especificada.

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

Correlaciona os elementos de duas sequências com base em chaves correspondentes. Um IEqualityComparer<T> especificado é usado para comparar chaves.

Last<TSource>(IEnumerable<TSource>)

Retorna o último elemento de uma sequência.

Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

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

LastOrDefault<TSource>(IEnumerable<TSource>)

Retorna o último elemento de uma sequência ou um valor padrão se a sequência não contiver elementos.

LastOrDefault<TSource>(IEnumerable<TSource>, TSource)

Retorna o último elemento de uma sequência ou um valor padrão especificado se a sequência não contiver elementos.

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 se nenhum elemento desse tipo for encontrado.

LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

Retorna o último elemento de uma sequência que satisfaz uma condição ou um valor padrão especificado se nenhum elemento desse tipo for encontrado.

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

Retorna um Int64 que representa quantos elementos em uma sequência atendem a uma condição.

Max<TSource>(IEnumerable<TSource>)

Retorna o valor máximo em uma sequência genérica.

Max<TSource>(IEnumerable<TSource>, IComparer<TSource>)

Retorna o valor máximo em uma sequência genérica.

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 máximo Decimal.

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 máximo Double.

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 máximo Int32.

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 máximo Int64.

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 máximo de Decimal anulável.

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 máximo de Double anulável.

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 máximo de Int32 anulável.

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 máximo de Int64 anulável.

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 máximo de Single anulável.

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 máximo Single.

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 valor máximo resultante.

MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Retorna o valor máximo em uma sequência genérica de acordo com uma função de seletor de chave especificada.

MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Retorna o valor máximo em uma sequência genérica de acordo com uma função de seletor de chave especificada e um comparador de chave.

Min<TSource>(IEnumerable<TSource>)

Retorna o valor mínimo em uma sequência genérica.

Min<TSource>(IEnumerable<TSource>, IComparer<TSource>)

Retorna o valor mínimo em uma sequência genérica.

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 mínimo de Decimal.

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 mínimo de Double.

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 mínimo de Int32.

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 mínimo de Int64.

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 mínimo de Decimal anulável.

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 mínimo de Double anulável.

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 mínimo de Int32 anulável.

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 mínimo de Int64 anulável.

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 mínimo de Single anulável.

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 mínimo de Single.

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 valor mínimo resultante.

MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Retorna o valor mínimo em uma sequência genérica de acordo com uma função de seletor de chave especificada.

MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Retorna o valor mínimo em uma sequência genérica de acordo com uma função de seletor de chave especificada e um comparador de chave.

OfType<TResult>(IEnumerable)

Filtra os elementos de um IEnumerable com base em um tipo especificado.

Order<T>(IEnumerable<T>)

Classifica os elementos de uma sequência em ordem crescente.

Order<T>(IEnumerable<T>, IComparer<T>)

Classifica os elementos de uma sequência em ordem crescente.

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

Classifica os elementos de uma sequência em ordem crescente usando um comparador especificado.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Classifica os elementos de uma sequência em ordem decrescente de acordo com uma chave.

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

Classifica os elementos de uma sequência em ordem decrescente usando um comparador especificado.

OrderDescending<T>(IEnumerable<T>)

Classifica os elementos de uma sequência em ordem decrescente.

OrderDescending<T>(IEnumerable<T>, IComparer<T>)

Classifica os elementos de uma sequência em ordem decrescente.

Prepend<TSource>(IEnumerable<TSource>, TSource)

Adiciona um valor ao início da sequência.

Reverse<TSource>(IEnumerable<TSource>)

Inverte a ordem dos elementos em uma sequência.

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Projeta cada elemento de uma sequência em um novo formulário.

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.

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

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 na forma projetada desse elemento.

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>, nivela as sequências resultantes em uma sequência e invoca uma função de seletor de resultados em cada elemento nela.

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>, nivela as sequências resultantes em uma sequência e invoca uma função de seletor de resultados em cada elemento nela. O índice de cada elemento de origem é usado na forma projetada intermediária desse elemento.

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

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

Retorna o único elemento de uma sequência e gera uma exceção se não houver exatamente um elemento na sequência.

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

SingleOrDefault<TSource>(IEnumerable<TSource>)

Retorna o único elemento de uma sequência ou um valor padrão se a sequência estiver vazia; esse método gerará uma exceção se houver mais de um elemento na sequência.

SingleOrDefault<TSource>(IEnumerable<TSource>, TSource)

Retorna o único elemento de uma sequência ou um valor padrão especificado se a sequência estiver vazia; esse método gerará uma exceção se houver mais de um elemento na sequência.

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 nenhum elemento desse tipo existir; esse método gerará uma exceção se mais de um elemento atender à condição.

SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

Retorna o único elemento de uma sequência que satisfaz uma condição especificada ou um valor padrão especificado se nenhum elemento desse tipo existir; esse método gerará uma exceção se mais de um elemento atender à condição.

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)

Retorna uma nova coleção enumerável que contém os elementos de source com os últimos elementos count da coleção de origem omitida.

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Ignora elementos em uma sequência, desde que uma condição especificada seja verdadeira e, em seguida, retorna os elementos restantes.

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Ignora elementos em uma sequência, desde que uma condição especificada seja verdadeira e, em seguida, retorna os elementos restantes. O índice do elemento é usado na lógica da função de predicado.

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

Calcula a soma da sequência de valores Decimal obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a soma da sequência de valores Double obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a soma da sequência de valores Int32 obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a soma da sequência de valores Int64 obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a soma da sequência de valores Decimal anuláveis obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a soma da sequência de valores Double anuláveis obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a soma da sequência de valores Int32 anuláveis obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a soma da sequência de valores Int64 anuláveis obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a soma da sequência de valores Single anuláveis obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a soma da sequência de valores Single obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

Take<TSource>(IEnumerable<TSource>, Int32)

Retorna um número especificado de elementos contíguos desde o início de uma sequência.

Take<TSource>(IEnumerable<TSource>, Range)

Retorna um intervalo especificado de elementos contíguos de uma sequência.

TakeLast<TSource>(IEnumerable<TSource>, Int32)

Retorna uma nova coleção enumerável que contém os últimos elementos count de source.

TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Retorna elementos de uma sequência desde que uma condição especificada seja verdadeira.

TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Retorna elementos de uma sequência desde que uma condição especificada seja verdadeira. O índice do elemento é usado na lógica da função de predicado.

ToArray<TSource>(IEnumerable<TSource>)

Cria uma matriz de um IEnumerable<T>.

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

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

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

Cria um Dictionary<TKey,TValue> de uma IEnumerable<T> de acordo com as funções de seletor de elemento e seletor de elemento especificadas.

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

Cria um Dictionary<TKey,TValue> de uma IEnumerable<T> de acordo com uma função de seletor de chave especificada, um comparador e uma função seletora de elemento.

ToHashSet<TSource>(IEnumerable<TSource>)

Cria um HashSet<T> de um IEnumerable<T>.

ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Cria um HashSet<T> de um IEnumerable<T> usando o comparer para comparar chaves.

ToList<TSource>(IEnumerable<TSource>)

Cria um List<T> de um IEnumerable<T>.

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

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

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

Cria um Lookup<TKey,TElement> de uma IEnumerable<T> de acordo com as funções de seletor de elemento e seletor de elemento especificadas.

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

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

TryGetNonEnumeratedCount<TSource>(IEnumerable<TSource>, Int32)

Tenta determinar o número de elementos em uma sequência sem forçar uma enumeração.

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

Produz a união definida de duas sequências usando o comparador de igualdade padrão.

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

Produz a união definida de duas sequências usando um IEqualityComparer<T>especificado.

UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>)

Produz a união definida de duas sequências de acordo com uma função de seletor de chave especificada.

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

Produz a união definida de duas sequências de acordo com uma função de seletor de chave especificada.

Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Filtra uma sequência de valores com base em um predicado.

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.

Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)

Produz uma sequência de tuplas com elementos das duas sequências especificadas.

Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>)

Produz uma sequência de tuplas com elementos das três sequências especificadas.

Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)

Aplica uma função especificada aos elementos correspondentes de duas sequências, produzindo uma sequência dos resultados.

AsParallel(IEnumerable)

Habilita a paralelização de uma consulta.

AsParallel<TSource>(IEnumerable<TSource>)

Habilita a paralelização de uma consulta.

AsQueryable(IEnumerable)

Converte um IEnumerable em um IQueryable.

AsQueryable<TElement>(IEnumerable<TElement>)

Converte um IEnumerable<T> genérico em um IQueryable<T>genérico.

Ancestors<T>(IEnumerable<T>)

Retorna uma coleção de elementos que contém os ancestrais de cada nó na coleção de origem.

Ancestors<T>(IEnumerable<T>, XName)

Retorna uma coleção filtrada de elementos que contém os ancestrais de cada nó na coleção de origem. Somente os elementos que têm uma XName correspondente são incluídos na coleção.

DescendantNodes<T>(IEnumerable<T>)

Retorna uma coleção de nós descendentes de cada documento e elemento na coleção de origem.

Descendants<T>(IEnumerable<T>)

Retorna uma coleção de elementos que contém os elementos descendentes de cada elemento e documento na coleção de origem.

Descendants<T>(IEnumerable<T>, XName)

Retorna uma coleção filtrada de elementos que contém os elementos descendentes de cada elemento e documento na coleção de origem. Somente os elementos que têm uma XName correspondente são incluídos na coleção.

Elements<T>(IEnumerable<T>)

Retorna uma coleção dos elementos filho de cada elemento e documento na coleção de origem.

Elements<T>(IEnumerable<T>, XName)

Retorna uma coleção filtrada dos elementos filho de cada elemento e documento na coleção de origem. Somente os elementos que têm uma XName correspondente são incluídos na coleção.

InDocumentOrder<T>(IEnumerable<T>)

Retorna uma coleção de nós que contém todos os nós na coleção de origem, classificada na ordem do documento.

Nodes<T>(IEnumerable<T>)

Retorna uma coleção dos nós filho de cada documento e elemento na coleção de origem.

Remove<T>(IEnumerable<T>)

Remove cada nó da coleção de origem de seu nó pai.

Aplica-se a