ConcurrentStack<T> Class

Definition

Represents a thread-safe last in-first out (LIFO) collection.

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

The type of the elements contained in the stack.

Inheritance
ConcurrentStack<T>
Implements

Inherited Members

System.Object

Examples

The following example shows how to use a ConcurrentStack<T> to push and pop individual items:

class CS_Singles
{
        // Demonstrates:
        //      ConcurrentStack<T>.Push();
        //      ConcurrentStack<T>.TryPeek();
        //      ConcurrentStack<T>.TryPop();
        //      ConcurrentStack<T>.Clear();
        //      ConcurrentStack<T>.IsEmpty;
        static void Main ()
        {
            int errorCount = 0;

            // Construct a ConcurrentStack
            ConcurrentStack<int> cs = new ConcurrentStack<int>();

            // Push some elements onto the stack
            cs.Push(1);
            cs.Push(2);

            int result;

            // Peek at the top of the stack
            if (!cs.TryPeek(out result))
            {
                Console.WriteLine("CS: TryPeek() failed when it should have succeeded");
                errorCount++;
            }
            else if (result != 2)
            {
                Console.WriteLine("CS: TryPeek() saw {0} instead of 2", result);
                errorCount++;
            }

            // Pop a number off of the stack
            if (!cs.TryPop(out result))
            {
                Console.WriteLine("CS: TryPop() failed when it should have succeeded");
                errorCount++;
            }
            else if (result != 2)
            {
                Console.WriteLine("CS: TryPop() saw {0} instead of 2", result);
                errorCount++;
            }

            // Clear the stack, and verify that it is empty
            cs.Clear();
            if (!cs.IsEmpty)
            {
                Console.WriteLine("CS: IsEmpty not true after Clear()");
                errorCount++;
            }

            if (errorCount == 0) Console.WriteLine("  OK!");
        }
}
' Imports System.Collections.Concurrent
Class CS_Singles

    ' Demonstrates:
    ' ConcurrentStack<T>.Push();
    ' ConcurrentStack<T>.TryPeek();
    ' ConcurrentStack<T>.TryPop();
    ' ConcurrentStack<T>.Clear();
    ' ConcurrentStack<T>.IsEmpty;
    Shared Sub Main()
        Dim errorCount As Integer = 0

        ' Construct a ConcurrentStack
        Dim cs As New ConcurrentStack(Of Integer)()

        ' Push some elements onto the stack
        cs.Push(1)
        cs.Push(2)

        Dim result As Integer

        ' Peek at the top of the stack
        If Not cs.TryPeek(result) Then
            Console.WriteLine("CS: TryPeek() failed when it should have succeeded")
            errorCount += 1
        ElseIf result <> 2 Then
            Console.WriteLine("CS: TryPeek() saw {0} instead of 2", result)
            errorCount += 1
        End If

        ' Pop a number off of the stack
        If Not cs.TryPop(result) Then
            Console.WriteLine("CS: TryPop() failed when it should have succeeded")
            errorCount += 1
        ElseIf result <> 2 Then
            Console.WriteLine("CS: TryPop() saw {0} instead of 2", result)
            errorCount += 1
        End If

        ' Clear the stack, and verify that it is empty
        cs.Clear()
        If Not cs.IsEmpty Then
            Console.WriteLine("CS: IsEmpty not true after Clear()")
            errorCount += 1
        End If

        If errorCount = 0 Then
            Console.WriteLine(" OK!")
        End If
    End Sub
End Class

The following example shows how to use a ConcurrentStack<T> to push and pop ranges of items:

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

class CS_Ranges
{
        // Demonstrates:
        //      ConcurrentStack<T>.PushRange();
        //      ConcurrentStack<T>.TryPopRange();
        //      ConcurrentStack<T>.IsEmpty;
        static void Main ()
        {
            int errorCount = 0;

            // Construct a ConcurrentStack
            ConcurrentStack<int> cs = new ConcurrentStack<int>();

            // Push some consecutively numbered ranges
            cs.PushRange(new int[] { 1, 2, 3, 4, 5, 6, 7 });
            cs.PushRange(new int[] { 8, 9, 10 });
            cs.PushRange(new int[] { 11, 12, 13, 14 });
            cs.PushRange(new int[] { 15, 16, 17, 18, 19, 20 });
            cs.PushRange(new int[] { 21, 22 });
            cs.PushRange(new int[] { 23, 24, 25, 26, 27, 28, 29, 30 });

            // Now read them back, 3 at a time, concurrently
            Parallel.For(0, 10, i =>
            {
                int[] range = new int[3];
                if (cs.TryPopRange(range) != 3)
                {
                    Console.WriteLine("CS: TryPopRange failed unexpectedly");
                    Interlocked.Increment(ref errorCount);
                }

                // Each range should be consecutive integers, if the range was extracted atomically
                // And it should be reverse of the original order...
                if (!range.Skip(1).SequenceEqual(range.Take(range.Length - 1).Select(x => x - 1)))
                {
                    Console.WriteLine("CS: Expected consecutive ranges.  range[0]={0}, range[1]={1}", range[0], range[1]);
                    Interlocked.Increment(ref errorCount);
                }
            });

            // We should have emptied the thing
            if (!cs.IsEmpty)
            {
                Console.WriteLine("CS: Expected IsEmpty to be true after emptying");
                errorCount++;
            }

            if (errorCount == 0) Console.WriteLine("  OK!");
        }
}

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

Class CS_Ranges
    ' Demonstrates:
    ' ConcurrentStack<T>.PushRange();
    ' ConcurrentStack<T>.TryPopRange();
    ' ConcurrentStack<T>.IsEmpty;
    Shared Sub Main()
        Dim errorCount As Integer = 0

        ' Construct a ConcurrentStack
        Dim cs As New ConcurrentStack(Of Integer)()

        ' Push some consecutively numbered ranges
        cs.PushRange(New Integer() {1, 2, 3, 4, 5, 6, 7})
        cs.PushRange(New Integer() {8, 9, 10})
        cs.PushRange(New Integer() {11, 12, 13, 14})
        cs.PushRange(New Integer() {15, 16, 17, 18, 19, 20})
        cs.PushRange(New Integer() {21, 22})
        cs.PushRange(New Integer() {23, 24, 25, 26, 27, 28, 29, 30})

        ' Now read them back, 3 at a time, concurrently
        Parallel.For(0, 10,
                       Sub(i)
                           Dim range As Integer() = New Integer(2) {}
                           If cs.TryPopRange(range) <> 3 Then
                               Console.WriteLine("CS: TryPopRange failed unexpectedly")
                               Interlocked.Increment(errorCount)
                           End If

                           ' Each range should be consecutive integers, if the range was extracted atomically
                           ' And it should be reverse of the original order...
                           If Not range.Skip(1).SequenceEqual(range.Take(range.Length - 1).[Select](Function(x) x - 1)) Then
                               Console.WriteLine("CS: Expected consecutive ranges. range[0]={0}, range[1]={1}", range(0), range(1))
                               Interlocked.Increment(errorCount)
                           End If
                       End Sub)

        ' We should have emptied the thing
        If Not cs.IsEmpty Then
            Console.WriteLine("CS: Expected IsEmpty to be true after emptying")
            errorCount += 1
        End If

        If errorCount = 0 Then
            Console.WriteLine(" OK!")
        End If
    End Sub
End Class

Remarks

Note

ConcurrentStack<T> implements the IReadOnlyCollection<T> interface starting with the .NET Framework 4.6; in previous versions of the .NET Framework, the ConcurrentStack<T> class did not implement this interface.

ConcurrentStack<T> provides a few main operations:

Constructors

ConcurrentStack<T>()

Initializes a new instance of the ConcurrentStack<T> class.

ConcurrentStack<T>(IEnumerable<T>)

Initializes a new instance of the ConcurrentStack<T> class that contains elements copied from the specified collection

Properties

Count

Gets the number of elements contained in the ConcurrentStack<T>.

IsEmpty

Gets a value that indicates whether the ConcurrentStack<T> is empty.

Methods

Clear()

Removes all objects from the ConcurrentStack<T>.

CopyTo(T[], Int32)

Copies the ConcurrentStack<T> elements to an existing one-dimensional Array, starting at the specified array index.

GetEnumerator()

Returns an enumerator that iterates through the ConcurrentStack<T>.

Push(T)

Inserts an object at the top of the ConcurrentStack<T>.

PushRange(T[])

Inserts multiple objects at the top of the ConcurrentStack<T> atomically.

PushRange(T[], Int32, Int32)

Inserts multiple objects at the top of the ConcurrentStack<T> atomically.

ToArray()

Copies the items stored in the ConcurrentStack<T> to a new array.

TryPeek(T)

Attempts to return an object from the top of the ConcurrentStack<T> without removing it.

TryPop(T)

Attempts to pop and return the object at the top of the ConcurrentStack<T>.

TryPopRange(T[], Int32, Int32)

Attempts to pop and return multiple objects from the top of the ConcurrentStack<T> atomically.

TryPopRange(T[])

Attempts to pop and return multiple objects from the top of the ConcurrentStack<T> atomically.

Explicit Interface Implementations

IProducerConsumerCollection<T>.TryAdd(T)

Attempts to add an object to the IProducerConsumerCollection<T>.

IProducerConsumerCollection<T>.TryTake(T)

Attempts to remove and return an object from the IProducerConsumerCollection<T>.

ICollection.CopyTo(Array, Int32)

Copies the elements of the ICollection to an Array, starting at a particular Array index.

ICollection.IsSynchronized

Gets a value indicating whether access to the ICollection is synchronized with the SyncRoot.

ICollection.SyncRoot

Gets an object that can be used to synchronize access to the ICollection. This property is not supported.

IEnumerable.GetEnumerator()

Returns an enumerator that iterates through a collection.

Extension Methods

ToImmutableArray<TSource>(IEnumerable<TSource>)
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)
ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>)
ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>)
ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)
ToImmutableHashSet<TSource>(IEnumerable<TSource>)
ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)
ToImmutableList<TSource>(IEnumerable<TSource>)
ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>)
ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IComparer<TKey>)
ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IComparer<TKey>, IEqualityComparer<TValue>)
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)
ToImmutableSortedSet<TSource>(IEnumerable<TSource>)
ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)
CopyToDataTable<T>(IEnumerable<T>)
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)
All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Any<TSource>(IEnumerable<TSource>)
Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Append<TSource>(IEnumerable<TSource>, TSource)
AsEnumerable<TSource>(IEnumerable<TSource>)
Average(IEnumerable<Decimal>)
Average(IEnumerable<Double>)
Average(IEnumerable<Int32>)
Average(IEnumerable<Int64>)
Average(IEnumerable<Nullable<Decimal>>)
Average(IEnumerable<Nullable<Double>>)
Average(IEnumerable<Nullable<Int32>>)
Average(IEnumerable<Nullable<Int64>>)
Average(IEnumerable<Nullable<Single>>)
Average(IEnumerable<Single>)
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)
Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)
Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)
Cast<TResult>(IEnumerable)
Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)
Contains<TSource>(IEnumerable<TSource>, TSource)
Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)
Count<TSource>(IEnumerable<TSource>)
Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
DefaultIfEmpty<TSource>(IEnumerable<TSource>)
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)
Distinct<TSource>(IEnumerable<TSource>)
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)
ElementAt<TSource>(IEnumerable<TSource>, Int32)
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
First<TSource>(IEnumerable<TSource>)
First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
FirstOrDefault<TSource>(IEnumerable<TSource>)
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>, IEqualityComparer<TKey>)
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>)
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>, IEqualityComparer<TKey>)
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)
Last<TSource>(IEnumerable<TSource>)
Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
LastOrDefault<TSource>(IEnumerable<TSource>)
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
LongCount<TSource>(IEnumerable<TSource>)
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Max(IEnumerable<Decimal>)
Max(IEnumerable<Double>)
Max(IEnumerable<Int32>)
Max(IEnumerable<Int64>)
Max(IEnumerable<Nullable<Decimal>>)
Max(IEnumerable<Nullable<Double>>)
Max(IEnumerable<Nullable<Int32>>)
Max(IEnumerable<Nullable<Int64>>)
Max(IEnumerable<Nullable<Single>>)
Max(IEnumerable<Single>)
Max<TSource>(IEnumerable<TSource>)
Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)
Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)
Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)
Min(IEnumerable<Decimal>)
Min(IEnumerable<Double>)
Min(IEnumerable<Int32>)
Min(IEnumerable<Int64>)
Min(IEnumerable<Nullable<Decimal>>)
Min(IEnumerable<Nullable<Double>>)
Min(IEnumerable<Nullable<Int32>>)
Min(IEnumerable<Nullable<Int64>>)
Min(IEnumerable<Nullable<Single>>)
Min(IEnumerable<Single>)
Min<TSource>(IEnumerable<TSource>)
Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)
Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)
OfType<TResult>(IEnumerable)
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)
Prepend<TSource>(IEnumerable<TSource>, TSource)
Reverse<TSource>(IEnumerable<TSource>)
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
Single<TSource>(IEnumerable<TSource>)
Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
SingleOrDefault<TSource>(IEnumerable<TSource>)
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Skip<TSource>(IEnumerable<TSource>, Int32)
SkipLast<TSource>(IEnumerable<TSource>, Int32)
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)
Sum(IEnumerable<Decimal>)
Sum(IEnumerable<Double>)
Sum(IEnumerable<Int32>)
Sum(IEnumerable<Int64>)
Sum(IEnumerable<Nullable<Decimal>>)
Sum(IEnumerable<Nullable<Double>>)
Sum(IEnumerable<Nullable<Int32>>)
Sum(IEnumerable<Nullable<Int64>>)
Sum(IEnumerable<Nullable<Single>>)
Sum(IEnumerable<Single>)
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)
Take<TSource>(IEnumerable<TSource>, Int32)
TakeLast<TSource>(IEnumerable<TSource>, Int32)
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)
ToArray<TSource>(IEnumerable<TSource>)
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)
ToHashSet<TSource>(IEnumerable<TSource>)
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)
ToList<TSource>(IEnumerable<TSource>)
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)
Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)
Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)
Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)
AsParallel(IEnumerable)
AsParallel<TSource>(IEnumerable<TSource>)
AsQueryable(IEnumerable)
AsQueryable<TElement>(IEnumerable<TElement>)
Ancestors<T>(IEnumerable<T>)
Ancestors<T>(IEnumerable<T>, XName)
AncestorsAndSelf(IEnumerable<XElement>)
AncestorsAndSelf(IEnumerable<XElement>, XName)
Attributes(IEnumerable<XElement>)
Attributes(IEnumerable<XElement>, XName)
DescendantNodes<T>(IEnumerable<T>)
DescendantNodesAndSelf(IEnumerable<XElement>)
Descendants<T>(IEnumerable<T>)
Descendants<T>(IEnumerable<T>, XName)
DescendantsAndSelf(IEnumerable<XElement>)
DescendantsAndSelf(IEnumerable<XElement>, XName)
Elements<T>(IEnumerable<T>)
Elements<T>(IEnumerable<T>, XName)
InDocumentOrder<T>(IEnumerable<T>)
Nodes<T>(IEnumerable<T>)
Remove(IEnumerable<XAttribute>)
Remove<T>(IEnumerable<T>)

Thread Safety

All public and protected members of ConcurrentStack<T> are thread-safe and may be used concurrently from multiple threads.