Queue in C# ~ FIFO Collection

What is Queue<T> in C#?

The Queue<T> class in C# is a generic collection that stores elements in the exact order they’re added, following the First-In, First-Out (FIFO) rule. In simple terms, the first item you add is the first one that comes out , just like people waiting in a line.

Behind the scenes, Queue<T> keeps track of elements in the order they arrive, making sure each one is processed in a fair and predictable way. It’s perfect for situations where the order really matters , such as scheduling jobs, managing background tasks or handling requests in a queue-based system.

Key Characteristics of Queue<T>

• FIFO Order (First-In, First-Out) : In a queue, items are handled in the same order they were added. The first one that goes in, is always the first one to come out. This makes it easy to manage things that need to be processed in order like print jobs, background tasks or any real-world queue system.
• Allows Duplicate Elements : A Queue<T> doesn’t restrict duplicate values. You can add the same item more than once because it only cares about the order in which elements are added, not whether they’re unique.
• Supports Null Values (for Reference Types) : When you’re using reference types, Queue<T> lets you add null values as well. This can be useful when you want to represent missing data or mark something as “pending” without removing it from the queue.
• Automatically Resizes When Needed : Under the hood, Queue<T> uses a circular array to store its elements. When the existing capacity runs out, it automatically grows (usually doubling in size) so you don’t have to worry about managing capacity yourself. This keeps performance smooth and consistent as the queue grows.
• Indexed Internally, But Not Randomly Accessible : Even though Queue<T> stores its elements in an internal array, you can’t access them directly using an index (like queue[0]). Instead, you can look at the first element with Peek() or remove it using Dequeue() method.
• Efficient Operations : Both Enqueue() and Dequeue() run in constant time O(1) on average so they stay fast no matter how many elements you add. This makes Queue<T> a reliable choice when performance and order both matter.
• Not Thread-Safe : Queue<T> isn’t thread-safe, which means it shouldn’t be used by multiple threads at the same time without protection. If you’re working in a multi-threaded environment, you can handle this by using locks or by switching to ConcurrentQueue<T> from System.Collections.Concurrent, which is designed for safe concurrent access.
• Predictable Enumeration : When you loop through a Queue<T>, the elements are returned in the same order they were added from the oldest to the newest. This means the FIFO order is always preserved while iterating through the collection.

Internal Working of Queue<T>

The Queue<T> class in C# uses a circular array to store its elements. It keeps track of two positions the head for removing items and the tail for adding new ones. Instead of shifting elements each time, it simply adjusts these positions in a circular way, which helps the queue run efficiently.

Time and Space Complexity

Constructors of Queue<T>

public Queue<T>();

var queue = new Queue<string>();

public Queue<T>(int capacity);

var queue = new Queue<int>(100);

public Queue (System.Collections.Generic.IEnumerable<T> collection);

var initialList = new List<string> { "A", "B", "C" };
var queue = new Queue<string>(initialList);

Queue<T> Properties

int Count { get; }

var queue = new Queue<string>();
Console.WriteLine(queue.Count);  // Output: 0

Creating and adding element in Queue<T>

using System;
using System.Collections.Generic;

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

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

using System;
using System.Collections.Generic;

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

Go
Rust
Kotlin

Conclusion

The Queue<T> collection in C# is a simple yet powerful way to handle data in the exact order it arrives, following the First-In, First-Out (FIFO) approach. Whenever the order of processing matters like in task scheduling, message handling or stream processing a queue ensures that everything is managed fairly and predictably.

If you’re building a job scheduler, a message queue or even a real-time data pipeline, understanding how Queue<T> works can make a big difference. Its operations, Enqueue() and Dequeue(), are fast typically running in constant time so performance remains solid even as your workload increases. And because it’s built on a circular array internally, memory use stays efficient and easy to reason about.

In short, Queue<T> gives you a clean and reliable way to process data in order without extra complexity. Once you get comfortable with it, you’ll find it’s one of the most practical tools for keeping workflows smooth, predictable and well-organized.