IProducerConsumerCollection<T> Interface

Definição

Espaço de Nomes:: System.Collections.Concurrent

Assemblagens:: mscorlib.dll, System.Collections.Concurrent.dll

Assemblagem:: mscorlib.dll

Assemblagem:: System.Collections.Concurrent.dll

Assemblagem:: netstandard.dll

Importante

Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.

Define métodos para manipular coleções thread-safe destinadas ao uso de produtores/consumidores. Esta interface fornece uma representação unificada para coleções produtor/consumidor, permitindo que abstrações de nível superior, como a BlockingCollection<T> , possam usar a coleção como mecanismo de armazenamento subjacente.

generic <typename T>
public interface class IProducerConsumerCollection : System::Collections::Generic::IEnumerable<T>, System::Collections::ICollection

public interface IProducerConsumerCollection<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.ICollection

type IProducerConsumerCollection<'T> = interface
    interface seq<'T>
    interface IEnumerable
    interface ICollection

type IProducerConsumerCollection<'T> = interface
    interface seq<'T>
    interface ICollection
    interface IEnumerable

Public Interface IProducerConsumerCollection(Of T)
Implements ICollection, IEnumerable(Of T)

Parâmetros de Tipo Genérico

T

Especifica o tipo de elementos na coleção.

Derivado: System.Collections.Concurrent.ConcurrentBag<T>

System.Collections.Concurrent.ConcurrentQueue<T>

System.Collections.Concurrent.ConcurrentStack<T>

Implementações: IEnumerable<T> ICollection IEnumerable

Exemplos

O exemplo seguinte mostra uma estrutura de dados de pilha que implementa System.Collections.Concurrent.IProducerConsumerCollection<T>.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Concurrent;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

// Sample implementation of IProducerConsumerCollection(T)
// -- in this case, a thread-safe stack.
public class SafeStack<T> : IProducerConsumerCollection<T>
{
    // Used for enforcing thread-safety
    private object m_lockObject = new object();

    // We'll use a regular old Stack for our core operations
    private Stack<T> m_sequentialStack = null;

    //
    // Constructors
    //
    public SafeStack()
    {
        m_sequentialStack = new Stack<T>();
    }

    public SafeStack(IEnumerable<T> collection)
    {
        m_sequentialStack = new Stack<T>(collection);
    }

    //
    // Safe Push/Pop support
    //
    public void Push(T item)
    {
        lock (m_lockObject) m_sequentialStack.Push(item);
    }

    public bool TryPop(out T item)
    {
        bool rval = true;
        lock (m_lockObject)
        {
            if (m_sequentialStack.Count == 0) { item = default(T); rval = false; }
            else
            {
                item = m_sequentialStack.Pop();
            }
        }
        return rval;
    }

    //
    // IProducerConsumerCollection(T) support
    //
    public bool TryTake(out T item)
    {
        return TryPop(out item);
    }

    public bool TryAdd(T item)
    {
        Push(item);
        return true; // Push doesn't fail
    }

    public T[] ToArray()
    {
        T[] rval = null;
        lock (m_lockObject) rval = m_sequentialStack.ToArray();
        return rval;
    }

    public void CopyTo(T[] array, int index)
    {
        lock (m_lockObject) m_sequentialStack.CopyTo(array, index);
    }

    //
    // Support for IEnumerable(T)
    //
    public IEnumerator<T> GetEnumerator()
    {
        // The performance here will be unfortunate for large stacks,
        // but thread-safety is effectively implemented.
        Stack<T> stackCopy = null;
        lock (m_lockObject) stackCopy = new Stack<T>(m_sequentialStack);
        return stackCopy.GetEnumerator();
    }

    //
    // Support for IEnumerable
    //
    IEnumerator IEnumerable.GetEnumerator()
    {
        return ((IEnumerable<T>)this).GetEnumerator();
    }

    //
    // Support for ICollection
    //
    public bool IsSynchronized
    {
        get { return true; }
    }

    public object SyncRoot
    {
        get { return m_lockObject; }
    }

    public int Count
    {
        get { return m_sequentialStack.Count; }
    }

    public void CopyTo(Array array, int index)
    {
        lock (m_lockObject) ((ICollection)m_sequentialStack).CopyTo(array, index);
    }
}

public class Program
{
    static void Main()
    {
        TestSafeStack();

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }

    // Test our implementation of IProducerConsumerCollection(T)
    // Demonstrates:
    //      IPCC(T).TryAdd()
    //      IPCC(T).TryTake()
    //      IPCC(T).CopyTo()
    static void TestSafeStack()
    {
        SafeStack<int> stack = new SafeStack<int>();
        IProducerConsumerCollection<int> ipcc = (IProducerConsumerCollection<int>)stack;

        // Test Push()/TryAdd()
        stack.Push(10); Console.WriteLine("Pushed 10");
        ipcc.TryAdd(20); Console.WriteLine("IPCC.TryAdded 20");
        stack.Push(15); Console.WriteLine("Pushed 15");

        int[] testArray = new int[3];

        // Try CopyTo() within boundaries
        try
        {
            ipcc.CopyTo(testArray, 0);
            Console.WriteLine("CopyTo() within boundaries worked, as expected");
        }
        catch (Exception e)
        {
            Console.WriteLine("CopyTo() within boundaries unexpectedly threw an exception: {0}", e.Message);
        }

        // Try CopyTo() that overflows
        try
        {
            ipcc.CopyTo(testArray, 1);
            Console.WriteLine("CopyTo() with index overflow worked, and it SHOULD NOT HAVE");
        }
        catch (Exception e)
        {
            Console.WriteLine("CopyTo() with index overflow threw an exception, as expected: {0}", e.Message);
        }

        // Test enumeration
        Console.Write("Enumeration (should be three items): ");
        foreach (int item in stack) Console.Write("{0} ", item);
        Console.WriteLine("");

        // Test TryPop()
        int popped = 0;
        if (stack.TryPop(out popped))
        {
            Console.WriteLine("Successfully popped {0}", popped);
        }
        else
        {
            Console.WriteLine("FAILED to pop!!");
        }

        // Test Count
        Console.WriteLine("stack count is {0}, should be 2", stack.Count);

        // Test TryTake()
        if (ipcc.TryTake(out popped))
        {
            Console.WriteLine("Successfully IPCC-TryTaked {0}", popped);
        }
        else
        {
            Console.WriteLine("FAILED to IPCC.TryTake!!");
        }
    }
}

Imports System.Collections.Concurrent

Module IProdCon
    ' Sample implementation of IProducerConsumerCollection(T) -- in this case,
    ' a thread-safe stack.
    Public Class SafeStack(Of T)
        Implements IProducerConsumerCollection(Of T)

        ' Used for enforcing thread-safety
        Private m_lockObject As New Object()

        ' We'll use a regular old Stack for our core operations
        Private m_sequentialStack As Stack(Of T) = Nothing

        '
        ' Constructors
        '
        Public Sub New()
            m_sequentialStack = New Stack(Of T)()
        End Sub

        Public Sub New(ByVal collection As IEnumerable(Of T))
            m_sequentialStack = New Stack(Of T)(collection)
        End Sub

        '
        ' Safe Push/Pop support
        '
        Public Sub Push(ByVal item As T)
            SyncLock m_lockObject
                m_sequentialStack.Push(item)
            End SyncLock
        End Sub

        Public Function TryPop(ByRef item As T) As Boolean
            Dim rval As Boolean = True
            SyncLock m_lockObject
                If m_sequentialStack.Count = 0 Then
                    item = Nothing
                    rval = False
                Else
                    item = m_sequentialStack.Pop()
                End If
            End SyncLock
            Return rval
        End Function

        '
        ' IProducerConsumerCollection(T) support
        '
        Public Function TryTake(ByRef item As T) As Boolean Implements IProducerConsumerCollection(Of T).TryTake
            Return TryPop(item)
        End Function

        Public Function TryAdd(ByVal item As T) As Boolean Implements IProducerConsumerCollection(Of T).TryAdd
            Push(item)
            ' Push doesn't fail
            Return True
        End Function

        Public Function ToArray() As T() Implements IProducerConsumerCollection(Of T).ToArray
            Dim rval As T() = Nothing
            SyncLock m_lockObject
                rval = m_sequentialStack.ToArray()
            End SyncLock
            Return rval
        End Function

        Public Sub CopyTo(ByVal array As T(), ByVal index As Integer) Implements IProducerConsumerCollection(Of T).CopyTo
            SyncLock m_lockObject
                m_sequentialStack.CopyTo(array, index)
            End SyncLock
        End Sub



        '
        ' Support for IEnumerable(T)
        '
        Public Function GetEnumerator() As IEnumerator(Of T) Implements IEnumerable(Of T).GetEnumerator
            ' The performance here will be unfortunate for large stacks,
            ' but thread-safety is effectively implemented.
            Dim stackCopy As Stack(Of T) = Nothing
            SyncLock m_lockObject
                stackCopy = New Stack(Of T)(m_sequentialStack)
            End SyncLock
            Return stackCopy.GetEnumerator()
        End Function


        '
        ' Support for IEnumerable
        '
        Private Function GetEnumerator2() As IEnumerator Implements IEnumerable.GetEnumerator
            Return DirectCast(Me, IEnumerable(Of T)).GetEnumerator()
        End Function

        ' 
        ' Support for ICollection
        '
        Public ReadOnly Property IsSynchronized() As Boolean Implements ICollection.IsSynchronized
            Get
                Return True
            End Get
        End Property

        Public ReadOnly Property SyncRoot() As Object Implements ICollection.SyncRoot
            Get
                Return m_lockObject
            End Get
        End Property

        Public ReadOnly Property Count() As Integer Implements ICollection.Count
            Get
                Return m_sequentialStack.Count
            End Get
        End Property

        Public Sub CopyTo(ByVal array As Array, ByVal index As Integer) Implements ICollection.CopyTo
            SyncLock m_lockObject
                DirectCast(m_sequentialStack, ICollection).CopyTo(array, index)
            End SyncLock
        End Sub
    End Class

    ' Test our implementation of IProducerConsumerCollection(T)
    ' Demonstrates:
    ' IPCC(T).TryAdd()
    ' IPCC(T).TryTake()
    ' IPCC(T).CopyTo()
    Private Sub TestSafeStack()
        Dim stack As New SafeStack(Of Integer)()
        Dim ipcc As IProducerConsumerCollection(Of Integer) = DirectCast(stack, IProducerConsumerCollection(Of Integer))

        ' Test Push()/TryAdd()
        stack.Push(10)
        Console.WriteLine("Pushed 10")
        ipcc.TryAdd(20)
        Console.WriteLine("IPCC.TryAdded 20")
        stack.Push(15)
        Console.WriteLine("Pushed 15")

        Dim testArray As Integer() = New Integer(2) {}

        ' Try CopyTo() within boundaries
        Try
            ipcc.CopyTo(testArray, 0)
            Console.WriteLine("CopyTo() within boundaries worked, as expected")
        Catch e As Exception
            Console.WriteLine("CopyTo() within boundaries unexpectedly threw an exception: {0}", e.Message)
        End Try

        ' Try CopyTo() that overflows
        Try
            ipcc.CopyTo(testArray, 1)
            Console.WriteLine("CopyTo() with index overflow worked, and it SHOULD NOT HAVE")
        Catch e As Exception
            Console.WriteLine("CopyTo() with index overflow threw an exception, as expected: {0}", e.Message)
        End Try

        ' Test enumeration
        Console.Write("Enumeration (should be three items): ")
        For Each item As Integer In stack
            Console.Write("{0} ", item)
        Next
        Console.WriteLine("")

        ' Test TryPop()
        Dim popped As Integer = 0
        If stack.TryPop(popped) Then
            Console.WriteLine("Successfully popped {0}", popped)
        Else
            Console.WriteLine("FAILED to pop!!")
        End If

        ' Test Count
        Console.WriteLine("stack count is {0}, should be 2", stack.Count)

        ' Test TryTake()
        If ipcc.TryTake(popped) Then
            Console.WriteLine("Successfully IPCC-TryTaked {0}", popped)
        Else
            Console.WriteLine("FAILED to IPCC.TryTake!!")
        End If
    End Sub

    Sub Main()
        TestSafeStack()

        ' Keep the console window open in debug mode
        Console.WriteLine("Press any key to exit.")
        Console.ReadKey()

    End Sub

End Module

Observações

Para mais informações, consulte Thread-Safe Coleção e Visão Geral da Coleção de Bloqueio.

Propriedades

Name	Description
Count	Obtém o número de elementos contidos no ICollection. (Herdado de ICollection)
IsSynchronized	Recebe um valor que indica se o acesso ao ICollection é sincronizado (thread safe). (Herdado de ICollection)
SyncRoot	Obtém um objeto que pode ser usado para sincronizar o acesso ao ICollection. (Herdado de ICollection)

Métodos

Name	Description
CopyTo(Array, Int32)	Copia os elementos do ICollection para um Array, começando num índice particular Array . (Herdado de ICollection)
CopyTo(T[], Int32)	Copia os elementos do IProducerConsumerCollection<T> para um Array, começando num índice especificado.
GetEnumerator()	Devolve um enumerador que itera numa coleção. (Herdado de IEnumerable)
ToArray()	Copia os elementos contidos IProducerConsumerCollection<T> no novo array.
TryAdd(T)	Tentativas de adicionar um objeto ao IProducerConsumerCollection<T>.
TryTake(T)	Tentativas de remover e devolver um objeto do IProducerConsumerCollection<T>.

Métodos da Extensão

Name	Description
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)	Aplica uma função acumuladora sobre uma sequência. O valor semente especificado é usado como valor inicial do acumulador, e a função especificada é usada para selecionar o valor do resultado.
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)	Aplica uma função acumuladora sobre uma sequência. O valor semente especificado é usado como valor inicial do acumulador.
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)	Aplica uma função acumuladora sobre uma sequência.
All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Determina se todos os elementos de uma sequência satisfazem uma condição.
Ancestors<T>(IEnumerable<T>, XName)	Devolve uma coleção filtrada de elementos que contém os antepassados de cada nó na coleção fonte. Apenas os elementos que têm correspondência XName são incluídos na coleção.
Ancestors<T>(IEnumerable<T>)	Devolve uma coleção de elementos que contém os antepassados de cada nó na coleção de código-fonte.
Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Determina se algum elemento de uma sequência satisfaz uma condição.
Any<TSource>(IEnumerable<TSource>)	Determina se uma sequência contém algum elemento.
Append<TSource>(IEnumerable<TSource>, TSource)	Acrescenta um valor ao final da sequência.
AsEnumerable<TSource>(IEnumerable<TSource>)	Retorna a entrada digitada como IEnumerable<T>.
AsParallel(IEnumerable)	Permite a paralelização de uma consulta.
AsParallel<TSource>(IEnumerable<TSource>)	Permite a paralelização de uma consulta.
AsQueryable(IEnumerable)	Converte um IEnumerable para um IQueryable.
AsQueryable<TElement>(IEnumerable<TElement>)	Converte um genérico IEnumerable<T> num genérico IQueryable<T>.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Calcula a média de uma sequência de Decimal valores 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 Double valores 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 Int32 valores 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 Int64 valores 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 anuláveis Decimal que são 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 anuláveis Double que são 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 anuláveis Int32 que são 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 anuláveis Int64 que são 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 anuláveis Single que são 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 Single valores obtidos invocando uma função de transformação em cada elemento da sequência de entrada.
Cast<TResult>(IEnumerable)	Conjura os elementos de an IEnumerable para o tipo especificado.
Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Concatena duas sequências.
Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)	Determina se uma sequência contém um elemento especificado usando um .IEqualityComparer<T>
Contains<TSource>(IEnumerable<TSource>, TSource)	Determina se uma sequência contém um elemento especificado usando o comparador de igualdade padrão.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)	Copia DataRow objetos para o especificado DataTable, dado um objeto de entrada IEnumerable<T> onde o parâmetro `T` genérico é DataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)	Copia DataRow objetos para o especificado DataTable, dado um objeto de entrada IEnumerable<T> onde o parâmetro `T` genérico é DataRow.
CopyToDataTable<T>(IEnumerable<T>)	Devolve a DataTable que contém cópias dos DataRow objetos, dado um objeto de entrada IEnumerable<T> onde o parâmetro `T` genérico é DataRow.
Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Devolve um número que representa quantos elementos na sequência especificada satisfazem uma condição.
Count<TSource>(IEnumerable<TSource>)	Devolve o número de elementos numa sequência.
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)	Devolve os elementos da sequência especificada ou o valor especificado numa coleção singleton se a sequência estiver vazia.
DefaultIfEmpty<TSource>(IEnumerable<TSource>)	Devolve os elementos da sequência especificada ou o valor padrão do parâmetro de tipo numa coleção singleton se a sequência estiver vazia.
DescendantNodes<T>(IEnumerable<T>)	Devolve uma coleção dos nós descendentes de cada documento e elemento da coleção de origem.
Descendants<T>(IEnumerable<T>, XName)	Devolve uma coleção filtrada de elementos que contém os elementos descendentes de cada elemento e documento da coleção de origem. Apenas os elementos que têm correspondência XName são incluídos na coleção.
Descendants<T>(IEnumerable<T>)	Devolve uma coleção de elementos que contém os elementos descendentes de cada elemento e documento da coleção fonte.
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Devolve elementos distintos de uma sequência usando um especificado IEqualityComparer<T> para comparar valores.
Distinct<TSource>(IEnumerable<TSource>)	Devolve elementos distintos de uma sequência usando o comparador de igualdade padrão para comparar valores.
ElementAt<TSource>(IEnumerable<TSource>, Int32)	Devolve o elemento num índice especificado numa sequência.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)	Devolve o elemento num índice especificado numa sequência ou um valor padrão se o índice estiver fora do intervalo.
Elements<T>(IEnumerable<T>, XName)	Devolve uma coleção filtrada dos elementos filhos de cada elemento e documento da coleção de origem. Apenas os elementos que têm correspondência XName são incluídos na coleção.
Elements<T>(IEnumerable<T>)	Devolve uma coleção dos elementos filhos de cada elemento e documento da coleção de origem.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Produz a diferença de conjuntos de duas sequências usando o especificado IEqualityComparer<T> para comparar valores.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Produz a diferença de conjuntos de duas sequências usando o comparador de igualdade por defeito para comparar valores.
First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Devolve o primeiro elemento numa sequência que satisfaz uma condição especificada.
First<TSource>(IEnumerable<TSource>)	Devolve o primeiro elemento de uma sequência.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Devolve o primeiro elemento da sequência que satisfaz uma condição ou um valor padrão se tal elemento não for encontrado.
FirstOrDefault<TSource>(IEnumerable<TSource>)	Devolve o primeiro elemento de uma sequência, ou um valor padrão se a sequência não contiver elementos.
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 seletora de teclas especificada e cria um valor de resultado a partir de cada grupo e da sua chave. Os valores-chave são comparados usando um comparador especificado, e os elementos de cada grupo são projetados usando uma função especificada.
GroupBy<TSource,TKey,TElement,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 seletora de teclas especificada e cria um valor de resultado a partir de cada grupo e da sua chave. Os elementos de cada grupo são projetados usando uma função especificada.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Agrupa os elementos de uma sequência de acordo com uma função seletora de tecla. 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,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Agrupa os elementos de uma sequência de acordo com uma função seletora de teclas especificada e projeta os elementos para cada grupo usando uma função especificada.
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 seletora de teclas especificada e cria um valor de resultado a partir de cada grupo e da sua chave. As chaves são comparadas usando um comparador especificado.
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 seletora de teclas especificada e cria um valor de resultado a partir de cada grupo e da sua chave.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Agrupa os elementos de uma sequência de acordo com uma função seletora de teclas especificada e compara as chaves usando um comparador especificado.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Agrupa os elementos de uma sequência de acordo com uma função seletora de teclas especificada.
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 especificado IEqualityComparer<T> é usado para comparar tonalidades.
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 das chaves e agrupa os resultados. O comparador de igualdade por defeito é usado para comparar chaves.
InDocumentOrder<T>(IEnumerable<T>)	Devolve uma coleção de nós que contém todos os nós da coleção de código-fonte, ordenados pela ordem dos documentos.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Produz a interseção conjunta de duas sequências usando o especificado IEqualityComparer<T> para comparar valores.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Produz a interseção conjunta de duas sequências usando o comparador de igualdade padrão para comparar valores.
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 nas chaves correspondentes. Um especificado IEqualityComparer<T> é usado para comparar tonalidades.
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 nas chaves correspondentes. O comparador de igualdade por defeito é usado para comparar chaves.
Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Devolve o último elemento de uma sequência que satisfaz uma condição especificada.
Last<TSource>(IEnumerable<TSource>)	Devolve o último elemento de uma sequência.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Devolve o último elemento de uma sequência que satisfaz uma condição ou um valor padrão se tal elemento não for encontrado.
LastOrDefault<TSource>(IEnumerable<TSource>)	Devolve o último elemento de uma sequência, ou um valor padrão se a sequência não contiver elementos.
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Devolve e Int64 que representa quantos elementos numa sequência satisfazem uma condição.
LongCount<TSource>(IEnumerable<TSource>)	Retorna e Int64 que representa o número total de elementos numa sequência.
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 devolve o valor máximo resultante.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Invoca uma função de transformação em cada elemento de uma sequência e devolve 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 devolve 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 devolve 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 devolve 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 devolve o valor máximo anulável Decimal .
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor máximo anulável Double .
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor máximo anulável Int32 .
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor máximo anulável Int64 .
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor máximo anulável Single .
Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor máximo Single .
Max<TSource>(IEnumerable<TSource>)	Devolve o valor máximo numa sequência genérica.
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 devolve o valor mínimo resultante.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor mínimo Decimal .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor mínimo Double .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor mínimo Int32 .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor mínimo Int64 .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor mínimo anulável Decimal .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor mínimo anulável Double .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor mínimo anulável Int32 .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor mínimo anulável Int64 .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor mínimo anulável Single .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor mínimo Single .
Min<TSource>(IEnumerable<TSource>)	Devolve o valor mínimo numa sequência genérica.
Nodes<T>(IEnumerable<T>)	Devolve uma coleção dos nós filhos de cada documento e elemento da coleção de código-fonte.
OfType<TResult>(IEnumerable)	Filtra os elementos de um IEnumerable com base num tipo especificado.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Ordena os elementos de uma sequência por ordem crescente usando um comparador especificado.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Ordena os elementos de uma sequência por ordem crescente de acordo com uma chave.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Ordena os elementos de uma sequência por ordem decrescente usando um comparador especificado.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Ordena os elementos de uma sequência por ordem decrescente de acordo com uma chave.
Prepend<TSource>(IEnumerable<TSource>, TSource)	Acrescenta um valor ao início da sequência.
Remove<T>(IEnumerable<T>)	Remove todos os nós da coleção de origem do seu nó pai.
Reverse<TSource>(IEnumerable<TSource>)	Inverte a ordem dos elementos numa sequência.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)	Projeta cada elemento de uma sequência numa nova forma incorporando o índice do elemento.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Projeta cada elemento de uma sequência numa nova forma.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Projeta cada elemento de uma sequência para um IEnumerable<T>, achata as sequências resultantes numa sequência e invoca uma função seletora de resultados em cada elemento nelas.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Projeta cada elemento de uma sequência para um IEnumerable<T>, achata as sequências resultantes numa sequência e invoca uma função seletora de resultados em cada elemento nelas. O índice de cada elemento fonte é usado na forma intermédia projetada desse elemento.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)	Projeta cada elemento de uma sequência para um IEnumerable<T> e achata as sequências resultantes numa sequência.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)	Projeta cada elemento de uma sequência para um IEnumerable<T>, e achata as sequências resultantes numa só sequência. O índice de cada elemento fonte é usado na forma projetada desse elemento.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Determina se duas sequências são iguais comparando os seus elementos usando um especificado IEqualityComparer<T>.
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 seu tipo.
Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Devolve o único elemento de uma sequência que satisfaz uma condição especificada, e lança uma exceção se existirem mais do que um desses elementos.
Single<TSource>(IEnumerable<TSource>)	Devolve o único elemento de uma sequência e lança uma exceção se não houver exatamente um elemento na sequência.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Devolve o único elemento de uma sequência que satisfaz uma condição especificada ou um valor padrão se tal elemento não existir; este método lança uma exceção se mais do que um elemento satisfizerem a condição.
SingleOrDefault<TSource>(IEnumerable<TSource>)	Devolve o único elemento de uma sequência, ou um valor padrão se a sequência estiver vazia; este método lança uma exceção se houver mais do que um elemento na sequência.
Skip<TSource>(IEnumerable<TSource>, Int32)	Ignora um número especificado de elementos numa sequência e depois devolve os elementos restantes.
SkipLast<TSource>(IEnumerable<TSource>, Int32)	Devolve uma nova coleção enumerável que contém os elementos de `source` com os últimos `count` elementos da coleção fonte omitidos.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Ignora elementos numa sequência desde que uma condição especificada seja verdadeira e depois devolve os elementos restantes.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Ignora elementos numa sequência desde que uma condição especificada seja verdadeira e depois devolve 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 Decimal valores 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 Double valores 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 Int32 valores 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 Int64 valores 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 nulos Decimal que são obtidos ao invocar 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 nulos Double que são obtidos ao invocar 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 nulos Int32 que são obtidos ao invocar 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 nulos Int64 que são obtidos ao invocar 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 nulos Single que são obtidos ao invocar 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 Single valores obtidos invocando uma função de transformação em cada elemento da sequência de entrada.
Take<TSource>(IEnumerable<TSource>, Int32)	Devolve um número especificado de elementos contíguos do início de uma sequência.
TakeLast<TSource>(IEnumerable<TSource>, Int32)	Devolve uma nova coleção enumerável que contém os últimos `count` elementos de `source`.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Devolve elementos de uma sequência desde que uma condição especificada seja verdadeira.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Devolve 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 um array a partir de um IEnumerable<T>.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Cria a Dictionary<TKey,TValue> partir de uma IEnumerable<T> função seletora de teclas especificada, um comparador e uma função seletora de elementos.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Cria um Dictionary<TKey,TValue> a partir de um IEnumerable<T> de acordo com as funções seletoras de teclas e seletores de elementos especificadas.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Cria um Dictionary<TKey,TValue> a partir de um IEnumerable<T> de acordo com uma função seletora de teclas especificada e um comparador de chaves.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Cria um Dictionary<TKey,TValue> a partir de um IEnumerable<T> de acordo com uma função seletor de teclas especificada.
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Cria um HashSet<T> a partir de um IEnumerable<T> usando o `comparer` para comparar as chaves.
ToHashSet<TSource>(IEnumerable<TSource>)	Cria um HashSet<T> a partir de um IEnumerable<T>.
ToImmutableArray<TSource>(IEnumerable<TSource>)	Cria um array imutável a partir da coleção especificada.
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 do seu conteúdo usando os comparadores de chave e valor especificados.
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 do seu conteúdo usando o comparador de chaves especificado.
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 do seu conteúdo.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Constrói um dicionário imutável baseado numa transformação de uma sequência.
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 fonte.
ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Enumera uma sequência, produz um conjunto de hash imutável do seu conteúdo e utiliza o comparador de igualdade especificado para o tipo de conjunto.
ToImmutableHashSet<TSource>(IEnumerable<TSource>)	Enumera uma sequência e produz um conjunto de hash imutável do seu conteúdo.
ToImmutableList<TSource>(IEnumerable<TSource>)	Enumera uma sequência e produz uma lista imutável do seu conteúdo.
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 ordenado imutável do seu conteúdo usando os comparadores de chave e valor especificados.
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 ordenado imutável do seu conteúdo usando o comparador de chaves especificado.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Enumera e transforma uma sequência, produzindo um dicionário ordenado imutável do seu conteúdo.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Enumera uma sequência, produz um conjunto ordenado imutável do seu conteúdo e utiliza o comparador especificado.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>)	Enumera uma sequência e produz um conjunto ordenado imutável do seu conteúdo.
ToList<TSource>(IEnumerable<TSource>)	Cria um List<T> a partir de um IEnumerable<T>.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Cria a Lookup<TKey,TElement> partir de uma IEnumerable<T> função seletora de teclas especificada, um comparador e uma função seletor de elementos.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Cria um Lookup<TKey,TElement> a partir de um IEnumerable<T> de acordo com as funções seletoras de teclas e seletores de elementos especificadas.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Cria um Lookup<TKey,TElement> a partir de um IEnumerable<T> de acordo com uma função seletora de teclas especificada e um comparador de chaves.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Cria um Lookup<TKey,TElement> a partir de um IEnumerable<T> de acordo com uma função seletor de teclas especificada.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Produz a união de conjuntos de duas sequências usando um especificado IEqualityComparer<T>.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Produz a união conjunta de duas sequências usando o comparador de igualdade padrão.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Filtra uma sequência de valores com base num predicado.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Filtra uma sequência de valores com base num predicado. O índice de cada elemento é usado na lógica da função de predicado.
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.

Aplica-se a

Segurança de Thread

Todas as implementações desta interface devem permitir que todos os membros desta interface sejam usados simultaneamente a partir de múltiplos threads.

Ver também

Como: Adicionar funcionalidades de delimitação e bloqueio a uma classe de coleção

Comentários

Esta página foi útil?