Topic 9718 min readStructured Tutorial

Understanding Queue<T> in C# Collections

Quick Answer

Queue<T> in C# is a generic collection that represents a first-in, first-out (FIFO) data structure. It allows you to enqueue items at the end and dequeue items from the front, making it ideal for scenarios like task scheduling and buffering.

Learning Objectives

Explain the purpose of Queue<T> in a practical learning context.
Identify the main ideas, terms, and decisions involved in Queue<T>.
Apply Queue<T> in a simple real-world scenario or practice task.

Introduction to Queue<T> in C#

In C#, collections provide various ways to store and manipulate groups of objects. One important collection type is Queue<T>, which follows the FIFO (First-In, First-Out) principle.

Queues are useful when you need to process items in the order they arrive, such as print jobs, task scheduling, or buffering data streams.

First In, First Out (FIFO) - The core principle of Queue<T>

What is Queue<T>?

Queue<T> is a generic collection in the System.Collections.Generic namespace that stores elements in a FIFO order. The first element added is the first one to be removed.

It provides methods to add elements (Enqueue), remove elements (Dequeue), and peek at the next element without removing it (Peek).

Implements IEnumerable<T> for easy iteration.
Dynamic resizing as elements are added or removed.
Thread-safe operations require additional synchronization.

Core Operations of Queue<T>

Understanding the main operations of Queue<T> is essential to using it effectively.

Enqueue(T item): Adds an item to the end of the queue.
Dequeue(): Removes and returns the item at the front of the queue.
Peek(): Returns the item at the front without removing it.
Count: Property to get the number of elements in the queue.
Clear(): Removes all elements from the queue.

Example: Using Queue<T> in C#

Let's look at a simple example demonstrating how to create a queue, add elements, and process them.

Practical Example

This example creates a queue of strings, adds three items, peeks at the next item to be processed, and then dequeues all items while printing them.

Examples

Basic Queue<T> Example in C#

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Queue<string> queue = new Queue<string>();

        // Enqueue elements
        queue.Enqueue("First");
        queue.Enqueue("Second");
        queue.Enqueue("Third");

        // Peek at the first element
        Console.WriteLine("Next item: " + queue.Peek());

        // Dequeue and process elements
        while (queue.Count > 0)
        {
            string item = queue.Dequeue();
            Console.WriteLine("Processing: " + item);
        }
    }
}

This example creates a queue of strings, adds three items, peeks at the next item to be processed, and then dequeues all items while printing them.

Best Practices

Use Queue<T> when order of processing matters and you want FIFO behavior.
Avoid modifying the queue while enumerating it to prevent exceptions.
Check Count before calling Dequeue or Peek to avoid InvalidOperationException.
Consider thread synchronization if accessing Queue<T> from multiple threads.

Common Mistakes

Calling Dequeue or Peek on an empty queue without checking Count.
Using Queue<T> when LIFO behavior (stack) is needed instead.
Modifying the queue during enumeration causing runtime errors.
Assuming thread safety without explicit synchronization.

Hands-on Exercise

Implement a Print Queue

Create a Queue<string> to simulate a print job queue. Enqueue several print jobs, then dequeue and print each job name until the queue is empty.

Expected output: Print job names printed in the order they were added.

Hint: Use Enqueue to add jobs and Dequeue to process them.

Peek vs Dequeue

Write a program that enqueues three integers, uses Peek to display the next item, then dequeues all items while printing them.

Expected output: Next item displayed, followed by all items printed in order.

Hint: Peek does not remove the item, Dequeue does.

Interview Questions

What is the difference between Queue<T> and Stack<T> in C#?

Interview

Queue<T> implements FIFO (First-In, First-Out) behavior, where elements are processed in the order they were added. Stack<T> implements LIFO (Last-In, First-Out) behavior, where the most recently added element is processed first.

How do you safely check if a Queue<T> is empty before dequeuing?

Interview

You should check the Count property of the queue. If Count is greater than zero, it is safe to call Dequeue; otherwise, calling Dequeue will throw an InvalidOperationException.

What is Queue<T>, and why is it useful?

Beginner

Queue<T> in C# is a generic collection that represents a first-in, first-out (FIFO) data structure.