Stack in C# : Understanding the LIFO Collection in Depth

Key Characteristics of Stack<T>

• LIFO Order (Last-In, First-Out) : In a stack, the last item you add is always the first one to be removed (using Pop()). This behavior makes it perfect for situations like backtracking, undo/redo features and handling nested or recursive operations.
• Allows Duplicate Elements : You can push the same value onto a Stack<T> more than once. It doesn’t check for duplicates since what really matters is the order of items and how they’re stacked, not whether each value is unique.
• Supports Null Values (Reference Types) : If T is a reference type, you can push null onto the stack just like any other item. This can be useful when you need to represent missing or placeholder values in your collection.
• Internal Dynamic Resizing : The Stack<T> collection stores its elements in an internal array. When that array fills up, it automatically expands (usually by doubling its size), so you don’t have to worry about managing the capacity yourself.
• No Random Index Access : Unlike lists or arrays, Stack<T> does not allow accessing or modifying elements at arbitrary positions. You can only interact with the top element using Push, Peek or Pop operations.
• Enumerator Doesn’t Modify State : You can use a foreach loop to iterate through a Stack<T> and the elements are returned in LIFO order (from the top of the stack downwards). What’s great is that this process is non-destructive meaning the stack remains completely unchanged after enumeration. You’re simply viewing the elements, not altering them.
• Not Thread-Safe by Default : The Stack<T> collection is not inherently synchronized for multi-threaded use. This means that if multiple threads try to push or pop items at the same time, unexpected behavior or data corruption can occur. In such cases, you should either apply your own locking mechanism or use ConcurrentStack<T>, which is designed specifically for safe, concurrent operations.
• Memory Efficiency for LIFO Scenarios : Because of its simple internal array implementation and the absence of complex node structures (as in linked lists), Stack<T> is often more memory-efficient when you only need push/pop behavior rather than random access or heavy insertion/deletion in the middle.

1. Stack<T>()

public Stack<T>();

Initializes a new instance of the Stack<T> class that is empty and uses the default initial capacity.

var stack = new Stack<string>();

Usage : Use this when you need an empty stack and don’t know how many items you’ll push.

2. Stack<T>(int capacity)

public Stack<T>(int capacity);

Initializes a new empty instance of the Stack<T> class with the specified initial capacity (or the default if the provided value is less).

var stack = new Stack<int>(100);

Usage : Use this when you know an approximate number of items that will be pushed and want to avoid multiple internal array resizes.

3. Stack<T>(IEnumerable<T> collection)

public Stack<T>(IEnumerable<T> collection);

Initializes a new instance of the Stack<T> class that contains elements copied from the specified collection and has sufficient capacity to accommodate those elements.

var existingList = new List<string> { "A", "B", "C" };
var stack = new Stack<string>(existingList);

Usage : Use this when you already have a collection and want to create a stack pre-populated with its items.

1. Count

public int Count { get; }

Retrieves the number of elements currently stored in the Stack<T>. This value reflects how many items are in the stack, not how many it can hold (i.e., capacity).

var stack = new Stack<string>();
stack.Push("A");
stack.Push("B");
Console.WriteLine(stack.Count); // Output: 2

Step-by-Step Visualization Example

Initial Setup: Capacity = 4 (usually default capacity), Size = 0, Array = [_, _, _, _]

Example 1: Basic Stack<T> Operations

This example shows how to create an empty Stack<T>, push several elements onto it, then use Peek() and Pop() to inspect and remove the topmost elements in LIFO (Last-In, First-Out) order.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var stack = new Stack<string>();
        stack.Push("Python");
        stack.Push("Java");
        stack.Push("C#");
        stack.Push("React");
        stack.Push("C++");
        Console.WriteLine("Peek element: " + stack.Peek());
        Console.WriteLine("Pop: " + stack.Pop());
        Console.WriteLine("After Pop, Peek element: " + stack.Peek());
        Console.WriteLine("\nRemaining elements:");
        foreach (var item in stack)
            Console.WriteLine(item);
    }
}

Peek element: C++
Pop: C++
After Pop, Peek element: React
Remaining elements:
React
C#
Java
Python

Example 2: Initializing Stack<T> from a Collection

Creating a Stack<T> directly from an existing collection. Elements from the source list are pushed onto the stack in their original order, and then enumeration shows the stack contents from top to bottom (i.e., most recent item first).

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var languages = new List<string> { "Go", "Rust", "Kotlin" };
        var stack = new Stack<string>(languages);
        foreach (var item in stack)
            Console.WriteLine(item);
    }
}

Kotlin
Rust
Go

Note: While the source collection is ordered Go -> Rust -> Kotlin, the stack pushes those in that order and therefore Kotlin ends up at the top, so enumeration appears Kotlin -> Rust -> Go.