ConcurrentStack<T> Klas

Definitie

Naamruimte:: System.Collections.Concurrent

Assembly's:: mscorlib.dll, System.Collections.Concurrent.dll

Assembly:: mscorlib.dll

Assembly:: System.Collections.Concurrent.dll

Assembly:: netstandard.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Vertegenwoordigt een thread-safe laatste in-first out verzameling (LIFO).

generic <typename T>
public ref class ConcurrentStack : System::Collections::Concurrent::IProducerConsumerCollection<T>, System::Collections::Generic::IEnumerable<T>, System::Collections::Generic::IReadOnlyCollection<T>, System::Collections::ICollection

generic <typename T>
public ref class ConcurrentStack : System::Collections::Concurrent::IProducerConsumerCollection<T>, System::Collections::Generic::IEnumerable<T>

generic <typename T>
public ref class ConcurrentStack : System::Collections::Concurrent::IProducerConsumerCollection<T>, System::Collections::Generic::IEnumerable<T>, System::Collections::Generic::IReadOnlyCollection<T>

generic <typename T>
public ref class ConcurrentStack : System::Collections::Concurrent::IProducerConsumerCollection<T>, System::Collections::Generic::IEnumerable<T>, System::Collections::ICollection

public class ConcurrentStack<T> : System.Collections.Concurrent.IProducerConsumerCollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection

[System.Serializable]
public class ConcurrentStack<T> : System.Collections.Concurrent.IProducerConsumerCollection<T>, System.Collections.Generic.IEnumerable<T>

[System.Serializable]
public class ConcurrentStack<T> : System.Collections.Concurrent.IProducerConsumerCollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>

public class ConcurrentStack<T> : System.Collections.Concurrent.IProducerConsumerCollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.ICollection

public class ConcurrentStack<T> : System.Collections.Concurrent.IProducerConsumerCollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>

type ConcurrentStack<'T> = class
    interface IProducerConsumerCollection<'T>
    interface seq<'T>
    interface IEnumerable
    interface ICollection
    interface IReadOnlyCollection<'T>

[<System.Serializable>]
type ConcurrentStack<'T> = class
    interface IProducerConsumerCollection<'T>
    interface seq<'T>
    interface ICollection
    interface IEnumerable

[<System.Serializable>]
type ConcurrentStack<'T> = class
    interface IProducerConsumerCollection<'T>
    interface seq<'T>
    interface IEnumerable
    interface ICollection
    interface IReadOnlyCollection<'T>

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

Public Class ConcurrentStack(Of T)
Implements ICollection, IEnumerable(Of T), IProducerConsumerCollection(Of T), IReadOnlyCollection(Of T)

Public Class ConcurrentStack(Of T)
Implements IEnumerable(Of T), IProducerConsumerCollection(Of T)

Public Class ConcurrentStack(Of T)
Implements IEnumerable(Of T), IProducerConsumerCollection(Of T), IReadOnlyCollection(Of T)

Public Class ConcurrentStack(Of T)
Implements ICollection, IEnumerable(Of T), IProducerConsumerCollection(Of T)

Type parameters

T

Het type elementen in de stapel.

Overname: Object
ConcurrentStack<T>

Kenmerken: SerializableAttribute

Implementeringen: IProducerConsumerCollection<T> IEnumerable<T> IReadOnlyCollection<T> ICollection IEnumerable

Voorbeelden

In het volgende voorbeeld ziet u hoe u een ConcurrentStack<T> item kunt gebruiken om afzonderlijke items te pushen en te popen:

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

class Example
{
    // Demonstrates:
    //      ConcurrentStack<T>.Push();
    //      ConcurrentStack<T>.TryPeek();
    //      ConcurrentStack<T>.TryPop();
    //      ConcurrentStack<T>.Clear();
    //      ConcurrentStack<T>.IsEmpty;
    static async Task Main()
    {
        int items = 10000;

        ConcurrentStack<int> stack = new ConcurrentStack<int>();

        // Create an action to push items onto the stack
        Action pusher = () =>
        {
            for (int i = 0; i < items; i++)
            {
                stack.Push(i);
            }
        };

        // Run the action once
        pusher();

        if (stack.TryPeek(out int result))
        {
            Console.WriteLine($"TryPeek() saw {result} on top of the stack.");
        }
        else
        {
            Console.WriteLine("Could not peek most recently added number.");
        }

        // Empty the stack
        stack.Clear();

        if (stack.IsEmpty)
        {
            Console.WriteLine("Cleared the stack.");
        }

        // Create an action to push and pop items
        Action pushAndPop = () =>
        {
            Console.WriteLine($"Task started on {Task.CurrentId}");

            int item;
            for (int i = 0; i < items; i++)
                stack.Push(i);
            for (int i = 0; i < items; i++)
                stack.TryPop(out item);

            Console.WriteLine($"Task ended on {Task.CurrentId}");
        };

        // Spin up five concurrent tasks of the action
        var tasks = new Task[5];
        for (int i = 0; i < tasks.Length; i++)
            tasks[i] = Task.Factory.StartNew(pushAndPop);

        // Wait for all the tasks to finish up
        await Task.WhenAll(tasks);

        if (!stack.IsEmpty)
        {
            Console.WriteLine("Did not take all the items off the stack");
        }
    }
}

open System
open System.Collections.Concurrent
open System.Threading.Tasks

// Demonstrates:
//      ConcurrentStack<T>.Push();
//      ConcurrentStack<T>.TryPeek();
//      ConcurrentStack<T>.TryPop();
//      ConcurrentStack<T>.Clear();
//      ConcurrentStack<T>.IsEmpty;

let main =
    task {
        let items = 10000
        let stack = ConcurrentStack<int>()

        // Create an action to push items onto the stack
        let pusher =
            Action(fun () ->
                for i = 0 to items - 1 do
                    stack.Push i)

        // Run the action once
        pusher.Invoke()
        let mutable result = 0

        if stack.TryPeek &result then
            printfn $"TryPeek() saw {result} on top of the stack."
        else
            printfn "Could not peek most recently added number."

        // Empty the stack
        stack.Clear()

        if stack.IsEmpty then
            printfn "Cleared the stack."

        // Create an action to push and pop items
        let pushAndPop =
            Action(fun () ->
                printfn $"Task started on {Task.CurrentId}"

                let mutable item = 0

                for i = 0 to items - 1 do
                    stack.Push i

                for i = 0 to items - 1 do
                    stack.TryPop &item |> ignore

                printfn $"Task ended on {Task.CurrentId}")
        // Spin up five concurrent tasks of the action
        let tasks =
            [| for i = 0 to 4 do
                   Task.Run pushAndPop |]

        // Wait for all the tasks to finish up
        do! Task.WhenAll tasks

        if not stack.IsEmpty then
            printfn "Did not take all the items off the stack"
    }

main.Wait()

Imports System.Collections.Concurrent
Imports System.Threading.Tasks

Class Example
    ' Demonstrates:
    '   ConcurrentStack<T>.Push();
    '   ConcurrentStack<T>.TryPeek();
    '   ConcurrentStack<T>.TryPop();
    '   ConcurrentStack<T>.Clear();
    '   ConcurrentStack<T>.IsEmpty;
    Shared Sub Main()
        Dim items As Integer = 10000
        Dim stack As ConcurrentStack(Of Integer) = New ConcurrentStack(Of Integer)()

        ' Create an action to push items onto the stack
        Dim pusher As Action = Function()
                                   For i As Integer = 0 To items - 1
                                       stack.Push(i)
                                   Next
                               End Function

        ' Run the action once
        pusher()

        Dim result As Integer = Nothing

        If stack.TryPeek(result) Then
            Console.WriteLine($"TryPeek() saw {result} on top of the stack.")
        Else
            Console.WriteLine("Could not peek most recently added number.")
        End If

        ' Empty the stack
        stack.Clear()

        If stack.IsEmpty Then
            Console.WriteLine("Cleared the stack.")
        End If

        ' Create an action to push and pop items
        Dim pushAndPop As Action = Function()
                                       Console.WriteLine($"Task started on {Task.CurrentId}")
                                       Dim item As Integer

                                       For i As Integer = 0 To items - 1
                                           stack.Push(i)
                                       Next

                                       For i As Integer = 0 To items - 1
                                           stack.TryPop(item)
                                       Next

                                       Console.WriteLine($"Task ended on {Task.CurrentId}")
                                   End Function

        ' Spin up five concurrent tasks of the action
        Dim tasks = New Task(4) {}
        For i As Integer = 0 To tasks.Length - 1
            tasks(i) = Task.Factory.StartNew(pushAndPop)
        Next

        ' Wait for all the tasks to finish up
        Task.WaitAll(tasks)

        If Not stack.IsEmpty Then
            Console.WriteLine("Did not take all the items off the stack")
        End If
    End Sub
End Class

In het volgende voorbeeld ziet u hoe u een ConcurrentStack<T> bereik met items pusht en pop-up gebruikt:

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

class Example
{
    // Demonstrates:
    //      ConcurrentStack<T>.PushRange();
    //      ConcurrentStack<T>.TryPopRange();
    static async Task Main()
    {
        int numParallelTasks = 4;
        int numItems = 1000;
        var stack = new ConcurrentStack<int>();

        // Push a range of values onto the stack concurrently
        await Task.WhenAll(Enumerable.Range(0, numParallelTasks).Select(i => Task.Factory.StartNew((state) =>
        {
            // state = i * numItems
            int index = (int)state;
            int[] array = new int[numItems];
            for (int j = 0; j < numItems; j++)
            {
                array[j] = index + j;
            }

            Console.WriteLine($"Pushing an array of ints from {array[0]} to {array[numItems - 1]}");
            stack.PushRange(array);
        }, i * numItems, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default)).ToArray());

        int numTotalElements = 4 * numItems;
        int[] resultBuffer = new int[numTotalElements];
        await Task.WhenAll(Enumerable.Range(0, numParallelTasks).Select(i => Task.Factory.StartNew(obj =>
        {
            int index = (int)obj;
            int result = stack.TryPopRange(resultBuffer, index, numItems);

            Console.WriteLine($"TryPopRange expected {numItems}, got {result}.");
        }, i * numItems, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default)).ToArray());

        for (int i = 0; i < numParallelTasks; i++)
        {
            // Create a sequence we expect to see from the stack taking the last number of the range we inserted
            var expected = Enumerable.Range(resultBuffer[i*numItems + numItems - 1], numItems);

            // Take the range we inserted, reverse it, and compare to the expected sequence
            var areEqual = expected.SequenceEqual(resultBuffer.Skip(i * numItems).Take(numItems).Reverse());
            if (areEqual)
            {
                Console.WriteLine($"Expected a range of {expected.First()} to {expected.Last()}. Got {resultBuffer[i * numItems + numItems - 1]} to {resultBuffer[i * numItems]}");
            }
            else
            {
                Console.WriteLine($"Unexpected consecutive ranges.");
            }
        }
    }
}

open System.Collections.Concurrent
open System.Linq
open System.Threading
open System.Threading.Tasks

// Demonstrates:
//      ConcurrentStack<T>.PushRange();
//      ConcurrentStack<T>.TryPopRange();

let main = 
    task {
        let numParallelTasks = 4
        let numItems = 1000
        let stack = ConcurrentStack<int>()

        // Push a range of values onto the stack concurrently
        let! _ = Task.WhenAll(Enumerable.Range(0, numParallelTasks).Select(fun i -> 
            Task.Factory.StartNew((fun state ->
                // state = i * numItems
                let index: int = unbox state
                let array = 
                    [|  for j in 0 .. numItems - 1 do
                            index + j |]
                printfn $"Pushing an array of ints from {array[0]} to {array[numItems - 1]}"
                stack.PushRange array
            ), i * numItems, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default)).ToArray())

        let numTotalElements = 4 * numItems
        let resultBuffer = Array.zeroCreate numTotalElements
        let! _ = Task.WhenAll(Enumerable.Range(0, numParallelTasks).Select(fun i -> 
            Task.Factory.StartNew((fun obj ->
                let index = unbox obj
                let result = stack.TryPopRange(resultBuffer, index, numItems)
                printfn $"TryPopRange expected {numItems}, got {result}."
            ), i * numItems, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default)).ToArray())

        for i = 0 to numParallelTasks - 1 do
            // Create a sequence we expect to see from the stack taking the last number of the range we inserted
            let expected = Enumerable.Range(resultBuffer[i*numItems + numItems - 1], numItems)

            // Take the range we inserted, reverse it, and compare to the expected sequence
            let areEqual = expected.SequenceEqual(resultBuffer.Skip(i * numItems).Take(numItems).Reverse())
            if areEqual then
                printfn $"Expected a range of {expected.First()} to {expected.Last()}. Got {resultBuffer[i * numItems + numItems - 1]} to {resultBuffer[i * numItems]}"
            else
                printfn $"Unexpected consecutive ranges."
    }
main.Wait()

Imports System.Collections.Concurrent
Imports System.Linq
Imports System.Threading
Imports System.Threading.Tasks

Class Example
    ' Demonstrates:
    '   ConcurrentStack<T>.PushRange();
    '   ConcurrentStack<T>.TryPopRange();
    Shared Sub Main()
        Dim numParallelTasks As Integer = 4
        Dim numItems As Integer = 1000
        Dim stack = New ConcurrentStack(Of Integer)()

        ' Push a range of values onto the stack concurrently
        Task.WaitAll(Enumerable.Range(0, numParallelTasks).[Select](
                     Function(i) Task.Factory.StartNew(
                        Function(state)
                            Dim index As Integer = CInt(state)
                            Dim array As Integer() = New Integer(numItems - 1) {}

                            For j As Integer = 0 To numItems - 1
                                array(j) = index + j
                            Next

                            Console.WriteLine($"Pushing an array of ints from {array(0)} to {array(numItems - 1)}")
                            stack.PushRange(array)
                        End Function, i * numItems, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.[Default])).ToArray())


        Dim numTotalElements As Integer = 4 * numItems
        Dim resultBuffer As Integer() = New Integer(numTotalElements - 1) {}
        Task.WaitAll(Enumerable.Range(0, numParallelTasks).[Select](
                     Function(i) Task.Factory.StartNew(
                        Function(obj)
                            Dim index As Integer = CInt(obj)
                            Dim result As Integer = stack.TryPopRange(resultBuffer, index, numItems)
                            Console.WriteLine($"TryPopRange expected {numItems}, got {result}.")
                        End Function, i * numItems, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.[Default])).ToArray())

        For i As Integer = 0 To numParallelTasks - 1
            ' Create a sequence we expect to see from the stack taking the last number of the range we inserted
            Dim expected = Enumerable.Range(resultBuffer(i * numItems + numItems - 1), numItems)

            ' Take the range we inserted, reverse it, and compare to the expected sequence
            Dim areEqual = expected.SequenceEqual(resultBuffer.Skip(i * numItems).Take(numItems).Reverse())

            If areEqual Then
                Console.WriteLine($"Expected a range of {expected.First()} to {expected.Last()}. Got {resultBuffer(i * numItems + numItems - 1)} to {resultBuffer(i * numItems)}")
            Else
                Console.WriteLine($"Unexpected consecutive ranges.")
            End If
        Next
    End Sub
End Class

Opmerkingen

Note

ConcurrentStack<T> implementeert de interface IReadOnlyCollection<T> die begint met het .NET Framework 4.6; in eerdere versies van het .NET Framework, heeft de klasse ConcurrentStack<T> deze interface niet geïmplementeerd.

ConcurrentStack<T> biedt enkele belangrijke bewerkingen:

Push voegt een element boven aan het ConcurrentStack<T>element in.
TryPop verwijdert een element boven aan het ConcurrentStack<T>element of retourneert false als het item niet kan worden verwijderd.
TryPeek retourneert een element dat zich boven aan het ConcurrentStack<T> element bevindt, maar het niet verwijdert uit de ConcurrentStack<T>.
De TryPopRange en PushRange methoden bieden efficiënte pushing en popping van meerdere elementen in één bewerking.

Constructors

Name	Description
ConcurrentStack<T>()	Initialiseert een nieuw exemplaar van de ConcurrentStack<T> klasse.
ConcurrentStack<T>(IEnumerable<T>)	Initialiseert een nieuw exemplaar van de ConcurrentStack<T> klasse die elementen bevat die zijn gekopieerd uit de opgegeven verzameling.

Eigenschappen

Name	Description
Count	Hiermee haalt u het aantal elementen op dat is opgenomen in de ConcurrentStack<T>.
IsEmpty	Hiermee wordt een waarde opgehaald die aangeeft of de ConcurrentStack<T> waarde leeg is.

Methoden

Name	Description
Clear()	Hiermee verwijdert u alle objecten uit de ConcurrentStack<T>.
CopyTo(T[], Int32)	Kopieert de ConcurrentStack<T> elementen naar een bestaande eendimensionale Array, beginnend bij de opgegeven matrixindex.
Equals(Object)	Bepaalt of het opgegeven object gelijk is aan het huidige object. (Overgenomen van Object)
GetEnumerator()	Retourneert een enumerator die door de ConcurrentStack<T>.
GetHashCode()	Fungeert als de standaardhashfunctie. (Overgenomen van Object)
GetType()	Hiermee haalt u de Type huidige instantie op. (Overgenomen van Object)
MemberwiseClone()	Hiermee maakt u een ondiepe kopie van de huidige Object. (Overgenomen van Object)
Push(T)	Hiermee wordt een object boven aan het ConcurrentStack<T>object ingevoegd.
PushRange(T[], Int32, Int32)	Hiermee worden meerdere objecten boven aan het ConcurrentStack<T> atomisch ingevoegd.
PushRange(T[])	Hiermee worden meerdere objecten boven aan het ConcurrentStack<T> atomisch ingevoegd.
ToArray()	Kopieert de items die zijn opgeslagen in een ConcurrentStack<T> nieuwe matrix.
ToString()	Retourneert een tekenreeks die het huidige object vertegenwoordigt. (Overgenomen van Object)
TryPeek(T)	Probeert een object vanaf de bovenkant van het ConcurrentStack<T> object te retourneren zonder het te verwijderen.
TryPop(T)	Pogingen om het object boven aan de ConcurrentStack<T>pop-up te plaatsen en te retourneren.
TryPopRange(T[], Int32, Int32)	Pogingen om meerdere objecten vanaf de bovenkant van het ConcurrentStack<T> atomisch te retourneren.
TryPopRange(T[])	Pogingen om meerdere objecten vanaf de bovenkant van het ConcurrentStack<T> atomisch te retourneren.

Expliciete interface-implementaties

Name	Description
ICollection.CopyTo(Array, Int32)	Kopieert de elementen van de ICollection elementen naar een Array, beginnend bij een bepaalde Array index.
ICollection.IsSynchronized	Hiermee wordt een waarde opgehaald die aangeeft of de toegang tot de ICollection app wordt gesynchroniseerd met de SyncRoot.
ICollection.SyncRoot	Hiermee haalt u een object op dat kan worden gebruikt om de toegang tot het ICollectionobject te synchroniseren. Deze eigenschap wordt niet ondersteund.
IEnumerable.GetEnumerator()	Retourneert een enumerator die door een verzameling wordt herhaald.
IProducerConsumerCollection<T>.TryAdd(T)	Probeert een object toe te voegen aan de IProducerConsumerCollection<T>.
IProducerConsumerCollection<T>.TryTake(T)	Probeert een object te verwijderen en te retourneren uit de IProducerConsumerCollection<T>.

Extensiemethoden

Name	Description
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)	Hiermee past u een accumulatorfunctie toe op een reeks. De opgegeven seed-waarde wordt gebruikt als de initiële accumulatorwaarde en de opgegeven functie wordt gebruikt om de resultaatwaarde te selecteren.
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)	Hiermee past u een accumulatorfunctie toe op een reeks. De opgegeven seed-waarde wordt gebruikt als de initiële accumulatorwaarde.
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)	Hiermee past u een accumulatorfunctie toe op een reeks.
All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Bepaalt of alle elementen van een reeks aan een voorwaarde voldoen.
Ancestors<T>(IEnumerable<T>, XName)	Retourneert een gefilterde verzameling elementen die de bovenliggende elementen van elk knooppunt in de bronverzameling bevat. Alleen elementen die een overeenkomst XName hebben, worden opgenomen in de verzameling.
Ancestors<T>(IEnumerable<T>)	Retourneert een verzameling elementen die de bovenliggende elementen van elk knooppunt in de bronverzameling bevat.
Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Bepaalt of een element van een reeks voldoet aan een voorwaarde.
Any<TSource>(IEnumerable<TSource>)	Bepaalt of een reeks elementen bevat.
Append<TSource>(IEnumerable<TSource>, TSource)	Voegt een waarde toe aan het einde van de reeks.
AsEnumerable<TSource>(IEnumerable<TSource>)	Retourneert de invoer die is getypt als IEnumerable<T>.
AsParallel(IEnumerable)	Hiermee schakelt u parallelle uitvoering van een query in.
AsParallel<TSource>(IEnumerable<TSource>)	Hiermee schakelt u parallelle uitvoering van een query in.
AsQueryable(IEnumerable)	Converteert een IEnumerable naar een IQueryable.
AsQueryable<TElement>(IEnumerable<TElement>)	Converteert een algemeen IEnumerable<T> naar een algemeen IQueryable<T>.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Berekent het gemiddelde van een reeks Decimal waarden die worden verkregen door een transformatiefunctie aan te roepen op elk element van de invoerreeks.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Berekent het gemiddelde van een reeks Double waarden die worden verkregen door een transformatiefunctie aan te roepen op elk element van de invoerreeks.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Berekent het gemiddelde van een reeks Int32 waarden die worden verkregen door een transformatiefunctie aan te roepen op elk element van de invoerreeks.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Berekent het gemiddelde van een reeks Int64 waarden die worden verkregen door een transformatiefunctie aan te roepen op elk element van de invoerreeks.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Berekent het gemiddelde van een reeks null-waarden Decimal die worden verkregen door een transformatiefunctie aan te roepen op elk element van de invoerreeks.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Berekent het gemiddelde van een reeks null-waarden Double die worden verkregen door een transformatiefunctie aan te roepen op elk element van de invoerreeks.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Berekent het gemiddelde van een reeks null-waarden Int32 die worden verkregen door een transformatiefunctie aan te roepen op elk element van de invoerreeks.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Berekent het gemiddelde van een reeks null-waarden Int64 die worden verkregen door een transformatiefunctie aan te roepen op elk element van de invoerreeks.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Berekent het gemiddelde van een reeks null-waarden Single die worden verkregen door een transformatiefunctie aan te roepen op elk element van de invoerreeks.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Berekent het gemiddelde van een reeks Single waarden die worden verkregen door een transformatiefunctie aan te roepen op elk element van de invoerreeks.
Cast<TResult>(IEnumerable)	Cast de elementen van een IEnumerable naar het opgegeven type.
Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Voegt twee reeksen samen.
Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)	Bepaalt of een reeks een opgegeven element bevat met behulp van een opgegeven IEqualityComparer<T>.
Contains<TSource>(IEnumerable<TSource>, TSource)	Bepaalt of een reeks een opgegeven element bevat met behulp van de standaard gelijkheidsgelijker.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)	Hiermee kopieert u DataRow objecten naar de opgegeven DataTable, op basis van een invoerobject IEnumerable<T> waarbij de algemene parameter `T` zich bevindt DataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)	Hiermee kopieert u DataRow objecten naar de opgegeven DataTable, op basis van een invoerobject IEnumerable<T> waarbij de algemene parameter `T` zich bevindt DataRow.
CopyToDataTable<T>(IEnumerable<T>)	Retourneert een DataTable object dat kopieën van de DataRow objecten bevat, op basis van een invoerobject IEnumerable<T> waarin de algemene parameter `T` zich bevindt DataRow.
Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retourneert een getal dat aangeeft hoeveel elementen in de opgegeven reeks voldoen aan een voorwaarde.
Count<TSource>(IEnumerable<TSource>)	Retourneert het aantal elementen in een reeks.
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)	Retourneert de elementen van de opgegeven reeks of de opgegeven waarde in een singletonverzameling als de reeks leeg is.
DefaultIfEmpty<TSource>(IEnumerable<TSource>)	Retourneert de elementen van de opgegeven reeks of de standaardwaarde van de typeparameter in een singletonverzameling als de reeks leeg is.
DescendantNodes<T>(IEnumerable<T>)	Retourneert een verzameling van de onderliggende knooppunten van elk document en element in de bronverzameling.
Descendants<T>(IEnumerable<T>, XName)	Retourneert een gefilterde verzameling elementen die de onderliggende elementen van elk element en document in de bronverzameling bevat. Alleen elementen die een overeenkomst XName hebben, worden opgenomen in de verzameling.
Descendants<T>(IEnumerable<T>)	Retourneert een verzameling elementen die de onderliggende elementen van elk element en document in de bronverzameling bevat.
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Retourneert afzonderlijke elementen uit een reeks met behulp van een opgegeven IEqualityComparer<T> om waarden te vergelijken.
Distinct<TSource>(IEnumerable<TSource>)	Retourneert afzonderlijke elementen uit een reeks met behulp van de standaard gelijkheidsgelijker om waarden te vergelijken.
ElementAt<TSource>(IEnumerable<TSource>, Int32)	Retourneert het element in een opgegeven index in een reeks.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)	Retourneert het element in een opgegeven index in een reeks of een standaardwaarde als de index buiten het bereik valt.
Elements<T>(IEnumerable<T>, XName)	Retourneert een gefilterde verzameling van de onderliggende elementen van elk element en document in de bronverzameling. Alleen elementen die een overeenkomst XName hebben, worden opgenomen in de verzameling.
Elements<T>(IEnumerable<T>)	Retourneert een verzameling onderliggende elementen van elk element en document in de bronverzameling.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Produceert het setverschil van twee reeksen door de opgegeven IEqualityComparer<T> waarden te vergelijken.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Produceert het setverschil van twee reeksen met behulp van de standaard gelijkheidsgelijker om waarden te vergelijken.
First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retourneert het eerste element in een reeks die voldoet aan een opgegeven voorwaarde.
First<TSource>(IEnumerable<TSource>)	Retourneert het eerste element van een reeks.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retourneert het eerste element van de reeks die voldoet aan een voorwaarde of een standaardwaarde als er geen dergelijk element wordt gevonden.
FirstOrDefault<TSource>(IEnumerable<TSource>)	Retourneert het eerste element van een reeks of een standaardwaarde als de reeks geen elementen bevat.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)	Groepeer de elementen van een reeks op basis van een opgegeven sleutelkiezerfunctie en maakt een resultaatwaarde van elke groep en de bijbehorende sleutel. Sleutelwaarden worden vergeleken met behulp van een opgegeven vergelijkingsfunctie en de elementen van elke groep worden geprojecteerd met behulp van een opgegeven functie.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)	Groepeer de elementen van een reeks op basis van een opgegeven sleutelkiezerfunctie en maakt een resultaatwaarde van elke groep en de bijbehorende sleutel. De elementen van elke groep worden geprojecteerd met behulp van een opgegeven functie.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Hiermee worden de elementen van een reeks gegroepeerd op basis van een sleutelkiezerfunctie. De sleutels worden vergeleken met behulp van een vergelijkingsfunctie en de elementen van elke groep worden geprojecteerd met behulp van een opgegeven functie.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Groepeert de elementen van een reeks op basis van een opgegeven sleutelkiezerfunctie en projecteert de elementen voor elke groep met behulp van een opgegeven functie.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)	Groepeer de elementen van een reeks op basis van een opgegeven sleutelkiezerfunctie en maakt een resultaatwaarde van elke groep en de bijbehorende sleutel. De sleutels worden vergeleken met behulp van een opgegeven vergelijkingsfunctie.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)	Groepeer de elementen van een reeks op basis van een opgegeven sleutelkiezerfunctie en maakt een resultaatwaarde van elke groep en de bijbehorende sleutel.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Groepeert de elementen van een reeks op basis van een opgegeven sleutelkiezerfunctie en vergelijkt de sleutels met behulp van een opgegeven vergelijkingsfunctie.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Hiermee worden de elementen van een reeks gegroepeerd op basis van een opgegeven sleutelkiezerfunctie.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)	Correleert de elementen van twee reeksen op basis van sleutel gelijkheid en groepeert de resultaten. Een opgegeven IEqualityComparer<T> wordt gebruikt om sleutels te vergelijken.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>)	Correleert de elementen van twee reeksen op basis van gelijkheid van sleutels en groepeert de resultaten. De standaard gelijkheidsgelijker wordt gebruikt om sleutels te vergelijken.
InDocumentOrder<T>(IEnumerable<T>)	Retourneert een verzameling knooppunten die alle knooppunten in de bronverzameling bevat, gesorteerd in documentvolgorde.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Produceert het snijpunt van twee reeksen met behulp van het opgegeven om IEqualityComparer<T> waarden te vergelijken.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Produceert het set snijpunt van twee reeksen met behulp van de standaard gelijkheidsgelijker om waarden te vergelijken.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)	Correleert de elementen van twee reeksen op basis van overeenkomende sleutels. Een opgegeven IEqualityComparer<T> wordt gebruikt om sleutels te vergelijken.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)	Correleert de elementen van twee reeksen op basis van overeenkomende sleutels. De standaard gelijkheidsgelijker wordt gebruikt om sleutels te vergelijken.
Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retourneert het laatste element van een reeks die voldoet aan een opgegeven voorwaarde.
Last<TSource>(IEnumerable<TSource>)	Retourneert het laatste element van een reeks.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retourneert het laatste element van een reeks die voldoet aan een voorwaarde of een standaardwaarde als er geen dergelijk element wordt gevonden.
LastOrDefault<TSource>(IEnumerable<TSource>)	Retourneert het laatste element van een reeks of een standaardwaarde als de reeks geen elementen bevat.
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retourneert een Int64 waarde die aangeeft hoeveel elementen in een reeks voldoen aan een voorwaarde.
LongCount<TSource>(IEnumerable<TSource>)	Retourneert een Int64 waarde die het totale aantal elementen in een reeks vertegenwoordigt.
Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Roept een transformatiefunctie aan op elk element van een algemene reeks en retourneert de maximum resulterende waarde.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Roept een transformatiefunctie aan op elk element van een reeks en retourneert de maximumwaarde Decimal .
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Roept een transformatiefunctie aan op elk element van een reeks en retourneert de maximumwaarde Double .
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Roept een transformatiefunctie aan op elk element van een reeks en retourneert de maximumwaarde Int32 .
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Roept een transformatiefunctie aan op elk element van een reeks en retourneert de maximumwaarde Int64 .
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Roept een transformatiefunctie aan op elk element van een reeks en retourneert de maximaal null-waarde Decimal .
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Roept een transformatiefunctie aan op elk element van een reeks en retourneert de maximaal null-waarde Double .
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Roept een transformatiefunctie aan op elk element van een reeks en retourneert de maximaal null-waarde Int32 .
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Roept een transformatiefunctie aan op elk element van een reeks en retourneert de maximaal null-waarde Int64 .
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Roept een transformatiefunctie aan op elk element van een reeks en retourneert de maximaal null-waarde Single .
Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Roept een transformatiefunctie aan op elk element van een reeks en retourneert de maximumwaarde Single .
Max<TSource>(IEnumerable<TSource>)	Retourneert de maximumwaarde in een algemene reeks.
Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Roept een transformatiefunctie aan op elk element van een algemene reeks en retourneert de minimum resulterende waarde.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Roept een transformatiefunctie aan op elk element van een reeks en retourneert de minimumwaarde Decimal .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Roept een transformatiefunctie aan op elk element van een reeks en retourneert de minimumwaarde Double .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Roept een transformatiefunctie aan op elk element van een reeks en retourneert de minimumwaarde Int32 .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Roept een transformatiefunctie aan op elk element van een reeks en retourneert de minimumwaarde Int64 .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Roept een transformatiefunctie aan op elk element van een reeks en retourneert de minimaal null-waarde Decimal .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Roept een transformatiefunctie aan op elk element van een reeks en retourneert de minimaal null-waarde Double .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Roept een transformatiefunctie aan op elk element van een reeks en retourneert de minimaal null-waarde Int32 .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Roept een transformatiefunctie aan op elk element van een reeks en retourneert de minimaal null-waarde Int64 .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Roept een transformatiefunctie aan op elk element van een reeks en retourneert de minimaal null-waarde Single .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Roept een transformatiefunctie aan op elk element van een reeks en retourneert de minimumwaarde Single .
Min<TSource>(IEnumerable<TSource>)	Retourneert de minimumwaarde in een algemene reeks.
Nodes<T>(IEnumerable<T>)	Retourneert een verzameling van de onderliggende knooppunten van elk document en element in de bronverzameling.
OfType<TResult>(IEnumerable)	Hiermee filtert u de elementen van een IEnumerable op basis van een opgegeven type.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Hiermee sorteert u de elementen van een reeks in oplopende volgorde met behulp van een opgegeven vergelijkingsfunctie.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Sorteert de elementen van een reeks in oplopende volgorde op basis van een sleutel.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Hiermee sorteert u de elementen van een reeks in aflopende volgorde met behulp van een opgegeven vergelijkingsfunctie.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Sorteert de elementen van een reeks in aflopende volgorde op basis van een sleutel.
Prepend<TSource>(IEnumerable<TSource>, TSource)	Voegt een waarde toe aan het begin van de reeks.
Remove<T>(IEnumerable<T>)	Hiermee verwijdert u elk knooppunt in de bronverzameling van het bovenliggende knooppunt.
Reverse<TSource>(IEnumerable<TSource>)	Hiermee wordt de volgorde van de elementen in een reeks omgedraaid.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)	Projecteert elk element van een reeks in een nieuw formulier door de index van het element op te nemen.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Projecteert elk element van een reeks in een nieuwe vorm.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Projecteert elk element van een reeks naar een IEnumerable<T>, plat de resulterende reeksen in één reeks en roept een resultaatselectorfunctie aan op elk element daarin.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Projecteert elk element van een reeks naar een IEnumerable<T>, plat de resulterende reeksen in één reeks en roept een resultaatselectorfunctie aan op elk element daarin. De index van elk bronelement wordt gebruikt in de tussenliggende projectvorm van dat element.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)	Projecteert elk element van een reeks naar een IEnumerable<T> en plat de resulterende reeksen in één reeks.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)	Projecteert elk element van een reeks op een IEnumerable<T>, en plat de resulterende reeksen in één reeks. De index van elk bronelement wordt gebruikt in de verwachte vorm van dat element.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Bepaalt of twee reeksen gelijk zijn door hun elementen te vergelijken met behulp van een opgegeven IEqualityComparer<T>.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Bepaalt of twee reeksen gelijk zijn door de elementen te vergelijken met behulp van de standaard gelijkheidsgelijker voor hun type.
Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retourneert het enige element van een reeks die voldoet aan een opgegeven voorwaarde en genereert een uitzondering als er meer dan één dergelijk element bestaat.
Single<TSource>(IEnumerable<TSource>)	Retourneert het enige element van een reeks en genereert een uitzondering als er niet precies één element in de reeks is.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retourneert het enige element van een reeks die voldoet aan een opgegeven voorwaarde of een standaardwaarde als er geen dergelijk element bestaat; met deze methode wordt een uitzondering gegenereerd als meer dan één element voldoet aan de voorwaarde.
SingleOrDefault<TSource>(IEnumerable<TSource>)	Retourneert het enige element van een reeks of een standaardwaarde als de reeks leeg is; met deze methode wordt een uitzondering gegenereerd als er meer dan één element in de reeks staat.
Skip<TSource>(IEnumerable<TSource>, Int32)	Slaat een opgegeven aantal elementen in een reeks over en retourneert vervolgens de resterende elementen.
SkipLast<TSource>(IEnumerable<TSource>, Int32)	Retourneert een nieuwe enumerable verzameling die de elementen bevat waaruit `source` de laatste `count` elementen van de bronverzameling zijn weggelaten.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Omzeilt elementen in een reeks zolang een opgegeven voorwaarde waar is en retourneert vervolgens de resterende elementen.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Omzeilt elementen in een reeks zolang een opgegeven voorwaarde waar is en retourneert vervolgens de resterende elementen. De index van het element wordt gebruikt in de logica van de predicaatfunctie.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Berekent de som van de reeks Decimal waarden die worden verkregen door een transformatiefunctie aan te roepen op elk element van de invoerreeks.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Berekent de som van de reeks Double waarden die worden verkregen door een transformatiefunctie aan te roepen op elk element van de invoerreeks.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Berekent de som van de reeks Int32 waarden die worden verkregen door een transformatiefunctie aan te roepen op elk element van de invoerreeks.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Berekent de som van de reeks Int64 waarden die worden verkregen door een transformatiefunctie aan te roepen op elk element van de invoerreeks.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Berekent de som van de reeks null-waarden Decimal die worden verkregen door een transformatiefunctie aan te roepen op elk element van de invoerreeks.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Berekent de som van de reeks null-waarden Double die worden verkregen door een transformatiefunctie aan te roepen op elk element van de invoerreeks.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Berekent de som van de reeks null-waarden Int32 die worden verkregen door een transformatiefunctie aan te roepen op elk element van de invoerreeks.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Berekent de som van de reeks null-waarden Int64 die worden verkregen door een transformatiefunctie aan te roepen op elk element van de invoerreeks.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Berekent de som van de reeks null-waarden Single die worden verkregen door een transformatiefunctie aan te roepen op elk element van de invoerreeks.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Berekent de som van de reeks Single waarden die worden verkregen door een transformatiefunctie aan te roepen op elk element van de invoerreeks.
Take<TSource>(IEnumerable<TSource>, Int32)	Retourneert een opgegeven aantal aaneengesloten elementen vanaf het begin van een reeks.
TakeLast<TSource>(IEnumerable<TSource>, Int32)	Retourneert een nieuwe enumerable verzameling die de laatste `count` elementen van `source`bevat.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retourneert elementen uit een reeks zolang een opgegeven voorwaarde waar is.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Retourneert elementen uit een reeks zolang een opgegeven voorwaarde waar is. De index van het element wordt gebruikt in de logica van de predicaatfunctie.
ToArray<TSource>(IEnumerable<TSource>)	Hiermee maakt u een matrix van een IEnumerable<T>.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Hiermee maakt u een Dictionary<TKey,TValue> van een IEnumerable<T> op basis van een opgegeven sleutelkiezerfunctie, een vergelijkingsfunctie en een elementselectorfunctie.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Hiermee maakt u een Dictionary<TKey,TValue> van een op basis van de IEnumerable<T> opgegeven sleutelkiezer- en elementselectorfuncties.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Hiermee maakt u een Dictionary<TKey,TValue> van een IEnumerable<T> op basis van een opgegeven sleutelkiezerfunctie en sleutelkiezer.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Hiermee maakt u een Dictionary<TKey,TValue> van een IEnumerable<T> op basis van een opgegeven sleutelkiezerfunctie.
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Hiermee maakt u een HashSet<T> van een IEnumerable<T> met behulp van de `comparer` sleutels om sleutels te vergelijken.
ToHashSet<TSource>(IEnumerable<TSource>)	Hiermee maakt u een HashSet<T> van een IEnumerable<T>.
ToImmutableArray<TSource>(IEnumerable<TSource>)	Hiermee maakt u een onveranderbare matrix op basis van de opgegeven verzameling.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)	Inventariseert en transformeert een reeks en produceert een onveranderbare woordenlijst van de inhoud met behulp van de opgegeven sleutel- en waarde-vergelijkingen.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)	Inventariseert en transformeert een reeks en produceert een onveranderbare woordenlijst van de inhoud met behulp van de opgegeven sleutel-vergelijkingsfunctie.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Inventariseert en transformeert een reeks en produceert een onveranderbare woordenlijst van de inhoud.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Maakt een onveranderbare woordenlijst op basis van een bepaalde transformatie van een reeks.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Hiermee wordt een onveranderbare woordenlijst samengesteld op basis van een bestaande verzameling elementen, waarbij een transformatiefunctie wordt toegepast op de bronsleutels.
ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Inventariseert een reeks, produceert een onveranderbare hashset van de inhoud en maakt gebruik van de opgegeven gelijkheidsgelijker voor het settype.
ToImmutableHashSet<TSource>(IEnumerable<TSource>)	Inventariseert een reeks en produceert een onveranderbare hashset van de inhoud.
ToImmutableList<TSource>(IEnumerable<TSource>)	Inventariseert een reeks en produceert een onveranderbare lijst met inhoud.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)	Inventariseert en transformeert een reeks en produceert een onveranderbare gesorteerde woordenlijst van de inhoud met behulp van de opgegeven sleutel- en waarde-vergelijkingen.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)	Inventariseert en transformeert een reeks en produceert een onveranderbare gesorteerde woordenlijst van de inhoud met behulp van de opgegeven sleutel vergelijken.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Inventariseert en transformeert een reeks en produceert een onveranderbare gesorteerde woordenlijst van de inhoud.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Inventariseert een reeks, produceert een onveranderbare gesorteerde set inhoud en maakt gebruik van de opgegeven vergelijkingsfunctie.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>)	Inventariseert een reeks en produceert een onveranderbare gesorteerde set inhoud.
ToList<TSource>(IEnumerable<TSource>)	Hiermee maakt u een List<T> van een IEnumerable<T>.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Hiermee maakt u een Lookup<TKey,TElement> van een IEnumerable<T> op basis van een opgegeven sleutelkiezerfunctie, een vergelijkingsfunctie en een elementselectorfunctie.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Hiermee maakt u een Lookup<TKey,TElement> van een op basis van de IEnumerable<T> opgegeven sleutelkiezer- en elementselectorfuncties.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Hiermee maakt u een Lookup<TKey,TElement> van een IEnumerable<T> op basis van een opgegeven sleutelkiezerfunctie en sleutelkiezer.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Hiermee maakt u een Lookup<TKey,TElement> van een IEnumerable<T> op basis van een opgegeven sleutelkiezerfunctie.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Produceert de set-samenvoeging van twee reeksen met behulp van een opgegeven IEqualityComparer<T>.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Produceert de set-samenvoeging van twee reeksen met behulp van de standaard gelijkheidsgelijker.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Hiermee filtert u een reeks waarden op basis van een predicaat.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Hiermee filtert u een reeks waarden op basis van een predicaat. De index van elk element wordt gebruikt in de logica van de predicaatfunctie.
Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)	Hiermee past u een opgegeven functie toe op de bijbehorende elementen van twee reeksen, waardoor een reeks resultaten wordt geproduceerd.

Van toepassing op

Veiligheid thread

Alle openbare en beveiligde leden van ConcurrentStack<T> zijn thread-veilig en kunnen gelijktijdig worden gebruikt vanuit meerdere threads.

Zie ook

Thread-Safe Verzamelingen

Feedback

Is deze pagina nuttig?