IDictionary<TKey,TValue> Interface

Referência

Definição

Namespace:: System.Collections.Generic

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Representa uma coleção genérica de pares chave/valor.

generic <typename TKey, typename TValue>
public interface class IDictionary : System::Collections::Generic::ICollection<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IEnumerable<System::Collections::Generic::KeyValuePair<TKey, TValue>>

public interface IDictionary<TKey,TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>

type IDictionary<'Key, 'Value> = interface
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IEnumerable

Public Interface IDictionary(Of TKey, TValue)
Implements ICollection(Of KeyValuePair(Of TKey, TValue)), IEnumerable(Of KeyValuePair(Of TKey, TValue))

Parâmetros de tipo

TKey

O tipo de chaves no dicionário.

TValue

O tipo de valores no dicionário.

Derivado: System.Activities.Hosting.SymbolResolver

System.Activities.Presentation.Model.ModelItemDictionary

System.Collections.Concurrent.ConcurrentDictionary<TKey,TValue>

System.Collections.Frozen.FrozenDictionary<TKey,TValue>

System.Collections.Generic.Dictionary<TKey,TValue>

Mais…

Implementações: ICollection<KeyValuePair<TKey,TValue>> IEnumerable<KeyValuePair<TKey,TValue>> IEnumerable<T> IEnumerable

Exemplos

O exemplo de código a seguir cria um vazio Dictionary<TKey,TValue> de cadeias de caracteres, com chaves de cadeia de caracteres, e o acessa por meio da IDictionary<TKey,TValue> interface .

O exemplo de código usa o Add método para adicionar alguns elementos. O exemplo demonstra que o Add método é lançado ArgumentException ao tentar adicionar uma chave duplicada.

O exemplo usa a Item[] propriedade (o indexador em C#) para recuperar valores, demonstrando que um KeyNotFoundException é gerado quando uma chave solicitada não está presente e mostrando que o valor associado a uma chave pode ser substituído.

O exemplo mostra como usar o TryGetValue método como uma maneira mais eficiente de recuperar valores se um programa geralmente precisar experimentar valores de chave que não estão no dicionário e como usar o ContainsKey método para testar se existe uma chave antes de chamar o Add método.

Por fim, o exemplo mostra como enumerar as chaves e os valores no dicionário e como enumerar os valores sozinhos usando a Values propriedade .

using namespace System;
using namespace System::Collections::Generic;

public ref class Example
{
public:
    static void Main()
    {
        // Create a new dictionary of strings, with string keys,
        // and access it through the IDictionary generic interface.
        IDictionary<String^, String^>^ openWith =
            gcnew Dictionary<String^, String^>();

        // Add some elements to the dictionary. There are no
        // duplicate keys, but some of the values are duplicates.
        openWith->Add("txt", "notepad.exe");
        openWith->Add("bmp", "paint.exe");
        openWith->Add("dib", "paint.exe");
        openWith->Add("rtf", "wordpad.exe");

        // The Add method throws an exception if the new key is
        // already in the dictionary.
        try
        {
            openWith->Add("txt", "winword.exe");
        }
        catch (ArgumentException^)
        {
            Console::WriteLine("An element with Key = \"txt\" already exists.");
        }

        // The Item property is another name for the indexer, so you
        // can omit its name when accessing elements.
        Console::WriteLine("For key = \"rtf\", value = {0}.",
            openWith["rtf"]);

        // The indexer can be used to change the value associated
        // with a key.
        openWith["rtf"] = "winword.exe";
        Console::WriteLine("For key = \"rtf\", value = {0}.",
            openWith["rtf"]);

        // If a key does not exist, setting the indexer for that key
        // adds a new key/value pair.
        openWith["doc"] = "winword.exe";

        // The indexer throws an exception if the requested key is
        // not in the dictionary.
        try
        {
            Console::WriteLine("For key = \"tif\", value = {0}.",
                openWith["tif"]);
        }
        catch (KeyNotFoundException^)
        {
            Console::WriteLine("Key = \"tif\" is not found.");
        }

        // When a program often has to try keys that turn out not to
        // be in the dictionary, TryGetValue can be a more efficient
        // way to retrieve values.
        String^ value = "";
        if (openWith->TryGetValue("tif", value))
        {
            Console::WriteLine("For key = \"tif\", value = {0}.", value);
        }
        else
        {
            Console::WriteLine("Key = \"tif\" is not found.");
        }

        // ContainsKey can be used to test keys before inserting
        // them.
        if (!openWith->ContainsKey("ht"))
        {
            openWith->Add("ht", "hypertrm.exe");
            Console::WriteLine("Value added for key = \"ht\": {0}",
                openWith["ht"]);
        }

        // When you use foreach to enumerate dictionary elements,
        // the elements are retrieved as KeyValuePair objects.
        Console::WriteLine();
        for each( KeyValuePair<String^, String^> kvp in openWith )
        {
            Console::WriteLine("Key = {0}, Value = {1}",
                kvp.Key, kvp.Value);
        }

        // To get the values alone, use the Values property.
        ICollection<String^>^ icoll = openWith->Values;

        // The elements of the ValueCollection are strongly typed
        // with the type that was specified for dictionary values.
        Console::WriteLine();
        for each( String^ s in icoll )
        {
            Console::WriteLine("Value = {0}", s);
        }

        // To get the keys alone, use the Keys property.
        icoll = openWith->Keys;

        // The elements of the ValueCollection are strongly typed
        // with the type that was specified for dictionary values.
        Console::WriteLine();
        for each( String^ s in icoll )
        {
            Console::WriteLine("Key = {0}", s);
        }

        // Use the Remove method to remove a key/value pair.
        Console::WriteLine("\nRemove(\"doc\")");
        openWith->Remove("doc");

        if (!openWith->ContainsKey("doc"))
        {
            Console::WriteLine("Key \"doc\" is not found.");
        }
    }
};

int main()
{
    Example::Main();
}

/* This code example produces the following output:

An element with Key = "txt" already exists.
For key = "rtf", value = wordpad.exe.
For key = "rtf", value = winword.exe.
Key = "tif" is not found.
Key = "tif" is not found.
Value added for key = "ht": hypertrm.exe

Key = txt, Value = notepad.exe
Key = bmp, Value = paint.exe
Key = dib, Value = paint.exe
Key = rtf, Value = winword.exe
Key = doc, Value = winword.exe
Key = ht, Value = hypertrm.exe

Value = notepad.exe
Value = paint.exe
Value = paint.exe
Value = winword.exe
Value = winword.exe
Value = hypertrm.exe

Key = txt
Key = bmp
Key = dib
Key = rtf
Key = doc
Key = ht

Remove("doc")
Key "doc" is not found.
 */

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        // Create a new dictionary of strings, with string keys,
        // and access it through the IDictionary generic interface.
        IDictionary<string, string> openWith =
            new Dictionary<string, string>();

        // Add some elements to the dictionary. There are no
        // duplicate keys, but some of the values are duplicates.
        openWith.Add("txt", "notepad.exe");
        openWith.Add("bmp", "paint.exe");
        openWith.Add("dib", "paint.exe");
        openWith.Add("rtf", "wordpad.exe");

        // The Add method throws an exception if the new key is
        // already in the dictionary.
        try
        {
            openWith.Add("txt", "winword.exe");
        }
        catch (ArgumentException)
        {
            Console.WriteLine("An element with Key = \"txt\" already exists.");
        }

        // The Item property is another name for the indexer, so you
        // can omit its name when accessing elements.
        Console.WriteLine("For key = \"rtf\", value = {0}.",
            openWith["rtf"]);

        // The indexer can be used to change the value associated
        // with a key.
        openWith["rtf"] = "winword.exe";
        Console.WriteLine("For key = \"rtf\", value = {0}.",
            openWith["rtf"]);

        // If a key does not exist, setting the indexer for that key
        // adds a new key/value pair.
        openWith["doc"] = "winword.exe";

        // The indexer throws an exception if the requested key is
        // not in the dictionary.
        try
        {
            Console.WriteLine("For key = \"tif\", value = {0}.",
                openWith["tif"]);
        }
        catch (KeyNotFoundException)
        {
            Console.WriteLine("Key = \"tif\" is not found.");
        }

        // When a program often has to try keys that turn out not to
        // be in the dictionary, TryGetValue can be a more efficient
        // way to retrieve values.
        string value = "";
        if (openWith.TryGetValue("tif", out value))
        {
            Console.WriteLine("For key = \"tif\", value = {0}.", value);
        }
        else
        {
            Console.WriteLine("Key = \"tif\" is not found.");
        }

        // ContainsKey can be used to test keys before inserting
        // them.
        if (!openWith.ContainsKey("ht"))
        {
            openWith.Add("ht", "hypertrm.exe");
            Console.WriteLine("Value added for key = \"ht\": {0}",
                openWith["ht"]);
        }

        // When you use foreach to enumerate dictionary elements,
        // the elements are retrieved as KeyValuePair objects.
        Console.WriteLine();
        foreach( KeyValuePair<string, string> kvp in openWith )
        {
            Console.WriteLine("Key = {0}, Value = {1}",
                kvp.Key, kvp.Value);
        }

        // To get the values alone, use the Values property.
        ICollection<string> icoll = openWith.Values;

        // The elements of the ValueCollection are strongly typed
        // with the type that was specified for dictionary values.
        Console.WriteLine();
        foreach( string s in icoll )
        {
            Console.WriteLine("Value = {0}", s);
        }

        // To get the keys alone, use the Keys property.
        icoll = openWith.Keys;

        // The elements of the ValueCollection are strongly typed
        // with the type that was specified for dictionary values.
        Console.WriteLine();
        foreach( string s in icoll )
        {
            Console.WriteLine("Key = {0}", s);
        }

        // Use the Remove method to remove a key/value pair.
        Console.WriteLine("\nRemove(\"doc\")");
        openWith.Remove("doc");

        if (!openWith.ContainsKey("doc"))
        {
            Console.WriteLine("Key \"doc\" is not found.");
        }
    }
}

/* This code example produces the following output:

An element with Key = "txt" already exists.
For key = "rtf", value = wordpad.exe.
For key = "rtf", value = winword.exe.
Key = "tif" is not found.
Key = "tif" is not found.
Value added for key = "ht": hypertrm.exe

Key = txt, Value = notepad.exe
Key = bmp, Value = paint.exe
Key = dib, Value = paint.exe
Key = rtf, Value = winword.exe
Key = doc, Value = winword.exe
Key = ht, Value = hypertrm.exe

Value = notepad.exe
Value = paint.exe
Value = paint.exe
Value = winword.exe
Value = winword.exe
Value = hypertrm.exe

Key = txt
Key = bmp
Key = dib
Key = rtf
Key = doc
Key = ht

Remove("doc")
Key "doc" is not found.
 */

Imports System.Collections.Generic

Public Class Example
    
    Public Shared Sub Main() 

        ' Create a new dictionary of strings, with string keys, 
        ' and access it through the IDictionary generic interface.
        Dim openWith As IDictionary(Of String, String) = _
            New Dictionary(Of String, String)
        
        ' Add some elements to the dictionary. There are no 
        ' duplicate keys, but some of the values are duplicates.
        openWith.Add("txt", "notepad.exe")
        openWith.Add("bmp", "paint.exe")
        openWith.Add("dib", "paint.exe")
        openWith.Add("rtf", "wordpad.exe")
        
        ' The Add method throws an exception if the new key is 
        ' already in the dictionary.
        Try
            openWith.Add("txt", "winword.exe")
        Catch 
            Console.WriteLine("An element with Key = ""txt"" already exists.")
        End Try

        ' The Item property is the default property, so you 
        ' can omit its name when accessing elements. 
        Console.WriteLine("For key = ""rtf"", value = {0}.", _
            openWith("rtf"))
        
        ' The default Item property can be used to change the value
        ' associated with a key.
        openWith("rtf") = "winword.exe"
        Console.WriteLine("For key = ""rtf"", value = {0}.", _
            openWith("rtf"))
        
        ' If a key does not exist, setting the default item property
        ' for that key adds a new key/value pair.
        openWith("doc") = "winword.exe"

        ' The default Item property throws an exception if the requested
        ' key is not in the dictionary.
        Try
            Console.WriteLine("For key = ""tif"", value = {0}.", _
                openWith("tif"))
        Catch 
            Console.WriteLine("Key = ""tif"" is not found.")
        End Try

        ' When a program often has to try keys that turn out not to
        ' be in the dictionary, TryGetValue can be a more efficient 
        ' way to retrieve values.
        Dim value As String = ""
        If openWith.TryGetValue("tif", value) Then
            Console.WriteLine("For key = ""tif"", value = {0}.", value)
        Else
            Console.WriteLine("Key = ""tif"" is not found.")
        End If

        ' ContainsKey can be used to test keys before inserting 
        ' them.
        If Not openWith.ContainsKey("ht") Then
            openWith.Add("ht", "hypertrm.exe")
            Console.WriteLine("Value added for key = ""ht"": {0}", _
                openWith("ht"))
        End If

        ' When you use foreach to enumerate dictionary elements,
        ' the elements are retrieved as KeyValuePair objects.
        Console.WriteLine()
        For Each kvp As KeyValuePair(Of String, String) In openWith
            Console.WriteLine("Key = {0}, Value = {1}", _
                kvp.Key, kvp.Value)
        Next kvp

        ' To get the values alone, use the Values property.
        Dim icoll As ICollection(Of String) = openWith.Values
        
        ' The elements of the ValueCollection are strongly typed
        ' with the type that was specified for dictionary values.
        Console.WriteLine()
        For Each s As String In  icoll
            Console.WriteLine("Value = {0}", s)
        Next s

        ' To get the keys alone, use the Keys property.
        icoll = openWith.Keys
        
        ' The elements of the ValueCollection are strongly typed
        ' with the type that was specified for dictionary values.
        Console.WriteLine()
        For Each s As String In  icoll
            Console.WriteLine("Key = {0}", s)
        Next s

        ' Use the Remove method to remove a key/value pair.
        Console.WriteLine(vbLf + "Remove(""doc"")")
        openWith.Remove("doc")
        
        If Not openWith.ContainsKey("doc") Then
            Console.WriteLine("Key ""doc"" is not found.")
        End If

    End Sub

End Class

' This code example produces the following output:
'
'An element with Key = "txt" already exists.
'For key = "rtf", value = wordpad.exe.
'For key = "rtf", value = winword.exe.
'Key = "tif" is not found.
'Key = "tif" is not found.
'Value added for key = "ht": hypertrm.exe
'
'Key = txt, Value = notepad.exe
'Key = bmp, Value = paint.exe
'Key = dib, Value = paint.exe
'Key = rtf, Value = winword.exe
'Key = doc, Value = winword.exe
'Key = ht, Value = hypertrm.exe
'
'Value = notepad.exe
'Value = paint.exe
'Value = paint.exe
'Value = winword.exe
'Value = winword.exe
'Value = hypertrm.exe
'
'Key = txt
'Key = bmp
'Key = dib
'Key = rtf
'Key = doc
'Key = ht
'
'Remove("doc")
'Key "doc" is not found.
'

Comentários

A IDictionary<TKey,TValue> interface é a interface base para coleções genéricas de pares chave/valor.

Cada elemento é um par chave/valor armazenado em um KeyValuePair<TKey,TValue> objeto .

Cada par deve ter uma chave exclusiva. As implementações podem variar se permitem key ser null. O valor pode ser null e não precisa ser exclusivo. A IDictionary<TKey,TValue> interface permite que as chaves e os valores contidos sejam enumerados, mas não implica nenhuma ordem de classificação específica.

A foreach instrução da linguagem C# (For Each no Visual Basic, for each em C++) retorna um objeto do tipo dos elementos na coleção. Como cada elemento do IDictionary<TKey,TValue> é um par chave/valor, o tipo de elemento não é o tipo da chave ou o tipo do valor. Em vez disso, o tipo de elemento é KeyValuePair<TKey,TValue>. Por exemplo:

for each(KeyValuePair<int, String^> kvp in myDictionary)
{
    Console::WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);
}

foreach (KeyValuePair<int, string> kvp in myDictionary)
{
    Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);
}

For Each kvp As KeyValuePair(Of Integer, String) In myDictionary
    Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value)
Next kvp

A foreach instrução é um wrapper em torno do enumerador, que só permite a leitura, não a gravação em, a coleção.

Observação

Como as chaves podem ser herdadas e seu comportamento foi alterado, sua exclusividade absoluta não pode ser garantida por comparações usando o Equals método .

Notas aos Implementadores

A classe de implementação deve ter um meio de comparar chaves.

Propriedades

Count	Obtém o número de elementos contidos no ICollection<T>. (Herdado de ICollection<T>)
IsReadOnly	Obtém um valor que indica se o ICollection<T> é somente leitura. (Herdado de ICollection<T>)
Item[TKey]	Obtém ou define o elemento com a chave especificada.
Keys	Obtém um ICollection<T> que contém as chaves do IDictionary<TKey,TValue>.
Values	Obtém um ICollection<T> que contém os valores no IDictionary<TKey,TValue>.

Métodos

Add(T)	Adiciona um item ao ICollection<T>. (Herdado de ICollection<T>)
Add(TKey, TValue)	Adiciona um elemento com a chave fornecida e o valor para o IDictionary<TKey,TValue>.
Clear()	Remove todos os itens do ICollection<T>. (Herdado de ICollection<T>)
Contains(T)	Determinará se o ICollection<T> contiver um valor específico. (Herdado de ICollection<T>)
ContainsKey(TKey)	Determina se o IDictionary<TKey,TValue> contém um elemento com a chave especificada.
CopyTo(T[], Int32)	Copia os elementos do ICollection<T> para um Array, começando em um determinado índice Array. (Herdado de ICollection<T>)
GetEnumerator()	Retorna um enumerador que itera em uma coleção. (Herdado de IEnumerable)
Remove(TKey)	Remove o elemento com a chave especificada do IDictionary<TKey,TValue>.
TryGetValue(TKey, TValue)	Obtém o valor associado à chave especificada.

Métodos de Extensão

ToFrozenDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Cria um FrozenDictionary<TKey,TValue> de uma IEnumerable<T> 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 um IEnumerable<T>, de acordo com as funções especificadas de seletor de chave e seletor de elemento.
ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>)	Cria um FrozenSet<T> com os valores especificados.
AsReadOnly<TKey,TValue>(IDictionary<TKey,TValue>)	Retorna um wrapper somente ReadOnlyDictionary<TKey,TValue> leitura para o dicionário atual.
Remove<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue)	Tenta remover o valor com o `key` especificado do `dictionary`.
TryAdd<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue)	Tenta adicionar o `key` e o `value` especificados ao `dictionary`.
ToImmutableArray<TSource>(IEnumerable<TSource>)	Cria uma matriz imutável com base na coleção especificada.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Constrói um dicionário imutável de uma coleção existente de elementos, aplicando uma função de transformação nas 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 com base em 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 com base em 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 com base em 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 com base em 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 com base em 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 com base em 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 IEnumerable<T> de entrada em que o parâmetro genérico `T` é DataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)	Copia objetos DataRow no DataTable especificado, dado um objeto IEnumerable<T> de entrada em que o parâmetro genérico `T` é DataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)	Copia objetos DataRow no DataTable especificado, dado um objeto 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 a uma sequência.
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,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.
AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>)	Representa uma coleção genérica de pares chave/valor.
AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey,TAccumulate>, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>)	Representa uma coleção genérica de pares chave/valor.
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 algum elemento de uma sequência atende a 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 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>)	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,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,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,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,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<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,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<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,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.
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 genérica de pares chave/valor.
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.
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.
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>)	Retorna os 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 de um índice especificado em uma sequência.
ElementAt<TSource>(IEnumerable<TSource>, Int32)	Retorna o elemento de 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 os valores.
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.
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 contém 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, caso esse elemento não seja encontrado.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Retorna o primeiro elemento da sequência que atende a 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 do 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 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>)	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 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>)	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,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>)	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.
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 chaves e agrupa os resultados. Um IEqualityComparer<T> especificado é usado para comparar chaves.
Index<TSource>(IEnumerable<TSource>)	Representa uma coleção genérica de pares chave/valor.
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.
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.
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 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>)	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>)	Retorna o último elemento de uma sequência.
Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retorna o último elemento de uma sequência que satisfaz uma condição especificada.
LastOrDefault<TSource>(IEnumerable<TSource>)	Retorna o último elemento de uma sequência ou um valor padrão se a sequência não contém elementos.
LastOrDefault<TSource>(IEnumerable<TSource>, 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, caso esse elemento não seja encontrado.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Retorna o último elemento de uma sequência que atende a 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 na 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 Decimal máximo.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Double máximo.
Max<TSource>(IEnumerable<TSource>, Func<TSource,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,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,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.
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,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<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<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,Single>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Single máximo.
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.
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 Decimal mínimo.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Double mínimo.
Min<TSource>(IEnumerable<TSource>, Func<TSource,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,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,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.
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,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<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<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,Single>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Single mínimo.
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.
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 no formulário projetado 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>, 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>)	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.
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>)	Determina se duas sequências são iguais, comparando seus elementos usando um IEqualityComparer<T> especificado.
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>)	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<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>, 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 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>, Func<TSource,Boolean>, TSource)	Retorna o único elemento de uma sequência que atende a uma condição especificada ou um valor padrão especificado se esse elemento não 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 de `count` da coleção de origem omitidos.
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>)	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<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.
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,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,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,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,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<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<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<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,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.
Take<TSource>(IEnumerable<TSource>, Int32)	Retorna um número especificado de elementos contíguos do 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 de `count` de `source`.
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>)	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.
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 chaves.
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>)	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.
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 chaves.
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>)	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.
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 de conjunto de duas sequências usando o comparador de igualdade padrão.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Produz a união de conjunto de duas sequências usando o 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 para os 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 um XName correspondente são incluídos na coleção.
DescendantNodes<T>(IEnumerable<T>)	Retorna uma coleção dos nós descendentes de todos os documentos e elementos 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 o 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 o documento na coleção de origem. Somente os elementos que têm um XName correspondente são incluídos na coleção.
Elements<T>(IEnumerable<T>)	Retorna uma coleção dos filhos elementos de cada elemento e o 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 um 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, classificados em ordem segundo o documento.
Nodes<T>(IEnumerable<T>)	Retorna uma coleção dos nós filhos de todos os documentos e elementos na coleção de origem.
Remove<T>(IEnumerable<T>)	Remove todos os nós na coleção de origem do respectivo nó pai.

Aplica-se a

IDictionary<TKey,TValue> Interface

Definição

Parâmetros de tipo

Exemplos

Comentários

Notas aos Implementadores

Propriedades

Métodos

Métodos de Extensão

Aplica-se a

Confira também

Comentários

Recursos adicionais