C# Stack vs Queue: LIFO and FIFO Collections Explained

A Stack gives you back what you put in last. A Queue gives you back what you put in first. The order you retrieve things is the entire point of both.

Picture two everyday situations. First: a stack of plates in a cupboard — you always take the top plate, the one most recently placed there, and new clean plates go on top too. Second: a line of people waiting at a coffee shop counter — the first person to join the line is the first one served, no matter how long the line gets. Both are "add things, then take them out later" collections. What differs completely is which item comes out.

In this lesson, you'll learn about Stack<T> and Queue<T> — two collections defined entirely by their retrieval order, and where each shows up constantly in real software.

What Is It?

The Simple Explanation

A Stack<T> is Last In, First Out (LIFO) — the most recently added item is always the first one you get back, like that pile of plates. A Queue<T> is First In, First Out (FIFO) — the earliest added item is always the first one you get back, like that coffee shop line.

The Technical Definition

Both Stack<T> and Queue<T> are generic collections in System.Collections.Generic that deliberately restrict how you access their elements — unlike List<T>, neither lets you index into an arbitrary position. Instead, each exposes only the operations needed to add one item and retrieve/remove the "next" item, where "next" is defined by their opposite ordering rules.

Why Does It Exist?

The Problem

Suppose you're building an "undo" feature for a text editor. Every action the user takes needs to be reversible, and — critically — undoing must always reverse the most recent action first. You could try to manage this with a List<T>:

This works, but nothing about a List<T> stops you from accidentally reading actions[0] instead, undoing the first action ever taken instead of the most recent one. The "must always be the last one" rule lives only in the programmer's head, not in the type itself.

The Solution

Stack<T> bakes that rule directly into the type — there's no index to get wrong, because there's no indexer at all:

Similarly, a background job processor needs to handle print jobs in the exact order they were submitted — the first job in line should print first, no exceptions. Queue<T> makes that guarantee structurally, the same way Stack<T> guarantees "most recent first."

Big Picture

How It Works

Stack<string> history = [];
history.Push("Page A");
history.Push("Page B");
history.Push("Page C");

string top = history.Peek();   // "Page C" — still there, just looked at
string popped = history.Pop(); // "Page C" — removed and returned

if (history.TryPop(out string? previous))
    Console.WriteLine($"Going back to {previous}");
else
    Console.WriteLine("No history to go back to.");

Queue<string> printJobs = [];
printJobs.Enqueue("Report.pdf");
printJobs.Enqueue("Invoice.pdf");
printJobs.Enqueue("Photo.png");

string next = printJobs.Peek();     // "Report.pdf" — the earliest one, still there
string printed = printJobs.Dequeue(); // "Report.pdf" — removed and returned

while (printJobs.Count > 0)
{
    string job = printJobs.Dequeue();
    Console.WriteLine($"Printing {job}...");
}

Simple Example

Code → Meaning → Result:

• The stack hands back the most recently pushed action first — exactly the "undo the last thing" behavior we needed.
• The queue hands back the earliest enqueued order first — exactly the "first come, first served" behavior a real line has.

Real-World Example

A background service processes print jobs submitted by many office computers, always in the order they arrived — a perfect fit for Queue<T>. Meanwhile, a document editor built alongside it needs an undo stack — a perfect fit for Stack<T>.

Analogy

Under the Hood

Common Confusion

1. Which method name goes with which type

It's genuinely easy to mix up Push/Pop (Stack) with Enqueue/Dequeue (Queue), especially early on. A memory trick: a stack is something you physically push down on and pop off of (plates, a stack of papers). A queue is a British word for a waiting line, so people queue up (enqueue) and eventually get dequeued from the front.

2. "It's just a List with different method names" — not quite

The restricted API isn't just a style choice — it's the whole point. A List<T> lets you insert or remove anywhere, which means nothing in the type itself guarantees LIFO or FIFO order; a careless RemoveAt(0) on what was meant to be a stack silently breaks the LIFO guarantee. Stack<T> and Queue<T> make that mistake impossible by never exposing the operations that could cause it.

Common Mistakes

Mistake 1 — Calling Pop/Dequeue on an empty collection

Wrong — throws InvalidOperationException:

Correct — check first, or use the Try variant:

Mistake 2 — Using a Stack when you actually need FIFO order (or vice versa)

Using Stack<T> for a print queue would print the most recently submitted job first, leaving earlier jobs waiting indefinitely if new ones keep arriving — the opposite of "first come, first served." Match the type to the ordering guarantee the problem actually needs.

Mistake 3 — Expecting indexed access

Wrong — neither type has an indexer:

If you need to inspect arbitrary positions, you likely want List<T> instead — or you can enumerate a stack/queue with foreach for read-only, order-respecting inspection.

When Should I Use It?

Mental Model

Key Takeaway

Check Your Understanding

You've seen how Stack and Queue guarantee opposite retrieval orders. Let's check your understanding.

You now know five concrete collection types and when each earns its place. Next, you'll zoom out and see the interfaces — IEnumerable, ICollection, IList, and friends — that tie all of them together.