C# Queue

The `Queue<T>` class in C# is a part of the `System.Collections.Generic` namespace and represents a first-in, first-out (FIFO) collection of objects. It is ideal for scenarios where you need to process items in the order they were added. Understanding `Queue<T>` is essential for implementing efficient data processing, task scheduling, and managing workflows in C# applications.

Table of Contents

1. Introduction to Queue<T>
- What is Queue<T>?
- Benefits of Using Queue<T>

2. Declaring and Initializing Queue<T>
- Declaration Syntax
- Initialization Methods
- Collection Initializers

3. Adding and Removing Elements
- Enqueue
- Dequeue
- Peek
- TryDequeue and TryPeek
- Clear

4. Accessing Elements
- Access by Index
- Converting to Array

5. Iterating Through Queue<T>
- Using foreach Loop
- Using LINQ Queries

6. Searching Elements
- Contains Method
- Find Methods (using LINQ)

7. Capacity and Performance
- Understanding Capacity vs. Count
- Managing Capacity
- Performance Considerations

8. Common Methods and Properties
- Key Methods
- Important Properties

9. Best Practices
- Choosing the Right Queue<T> Usage
- Handling Exceptions Gracefully
- Minimizing Locking Overhead in Multi-threaded Scenarios

10. Common Mistakes with Queue<T>
- Attempting to Dequeue from an Empty Queue
- Modifying the Queue During Iteration
- Using Incorrect Key Types

11. Advanced Topics
- Thread-Safe Queues with ConcurrentQueue<T>
- Implementing Custom Queue Behavior
- Serialization of Queues

12. Real-World Example
13. Summary

1. Introduction to Queue<T>

What is Queue<T>?

using System.Collections.Generic;

Queue<T> queue = new Queue<T>();

Benefits of Using Queue<T>

2. Declaring and Initializing Queue<T>

2.1 Declaration Syntax

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Queue<int> numbersQueue = new Queue<int>();
    }
}

2.2 Initialization Methods

Queue<string> fruitsQueue = new Queue<string>();

Queue<string> fruitsQueue = new Queue<string>(100);

2.3 Collection Initializers

Queue<string> fruitsQueue = new Queue<string>(new[] { "Apple", "Banana", "Cherry" });

3. Adding and Removing Elements

3.1 Enqueue

Queue<string> fruitsQueue = new Queue<string>();
fruitsQueue.Enqueue("Apple");
fruitsQueue.Enqueue("Banana");

3.2 Dequeue

string firstFruit = fruitsQueue.Dequeue(); // "Apple"

3.3 Peek

string nextFruit = fruitsQueue.Peek(); // "Banana"

3.4 TryDequeue and TryPeek

if(fruitsQueue.TryDequeue(out string dequeuedFruit))
{
    Console.WriteLine($"Dequeued: {dequeuedFruit}");
}
else
{
    Console.WriteLine("Queue is empty.");
}

if(fruitsQueue.TryPeek(out string peekedFruit))
{
    Console.WriteLine($"Next in Queue: {peekedFruit}");
}
else
{
    Console.WriteLine("Queue is empty.");
}

3.5 Clear

fruitsQueue.Clear();

4. Accessing Elements

4.1 Access by Index

string[] fruitsArray = fruitsQueue.ToArray();
string firstFruit = fruitsArray[0];

4.2 Converting to Array

Queue<string> fruitsQueue = new Queue<string>();
fruitsQueue.Enqueue("Apple");
fruitsQueue.Enqueue("Banana");
fruitsQueue.Enqueue("Cherry");

string[] fruitsArray = fruitsQueue.ToArray();

Console.WriteLine("Fruits Array:");
foreach(var fruit in fruitsArray)
{
    Console.WriteLine(fruit);
}

Sample Output:
Fruits Array:
Apple
Banana
Cherry

5. Iterating Through Queue<T>

5.1 Using foreach Loop

Queue<string> fruitsQueue = new Queue<string>();
fruitsQueue.Enqueue("Apple");
fruitsQueue.Enqueue("Banana");
fruitsQueue.Enqueue("Cherry");

Console.WriteLine("Iterating using foreach:");
foreach(string fruit in fruitsQueue)
{
    Console.WriteLine(fruit);
}

Sample Output:
Iterating using foreach:
Apple
Banana
Cherry

5.2 Using LINQ Queries

using System.Linq;

var selectedFruits = fruitsQueue.Where(f => f.StartsWith("B"));

Console.WriteLine("Fruits starting with 'B':");
foreach(var fruit in selectedFruits)
{
    Console.WriteLine(fruit);
}

Sample Output:
Fruits starting with 'B':
Banana

6. Searching Elements

6.1 Contains Method

bool hasBanana = fruitsQueue.Contains("Banana");
Console.WriteLine($"Contains Banana: {hasBanana}"); // Output: True

6.2 Finding Elements with LINQ

using System.Linq;

string firstC = fruitsQueue.FirstOrDefault(f => f.StartsWith("C"));
Console.WriteLine($"First fruit starting with 'C': {firstC}"); // Output: Cherry

6.3 Finding All Matching Elements

using System.Linq;

var fruitsWithA = fruitsQueue.Where(f => f.Contains("a") || f.Contains("A"));

Console.WriteLine("Fruits containing 'a' or 'A':");
foreach(var fruit in fruitsWithA)
{
    Console.WriteLine(fruit);
}

Sample Output:
Fruits containing 'a' or 'A':
Apple
Banana
Cherry

7. Capacity and Performance

7.1 Understanding Capacity vs. Count

Queue<int> numbersQueue = new Queue<int>();
Console.WriteLine($"Initial Count: {numbersQueue.Count}"); // Output: 0

numbersQueue.Enqueue(1);
Console.WriteLine($"Count after adding one element: {numbersQueue.Count}"); // Output: 1

7.2 Managing Capacity

numbersQueue.TrimExcess();

7.3 Performance Considerations

8. Common Methods and Properties

8.1 Key Methods

8.2 Important Properties

9. Best Practices

9.1 Choosing the Right Queue<T> Usage

9.2 Handling Exceptions Gracefully

if(numbersQueue.TryDequeue(out int number))
{
  Console.WriteLine($"Dequeued: {number}");
}
else
{
  Console.WriteLine("Queue is empty.");
}

9.3 Minimizing Locking Overhead in Multi-threaded Scenarios

using System.Collections.Concurrent;

ConcurrentQueue<int> concurrentQueue = new ConcurrentQueue<int>();
concurrentQueue.Enqueue(1);
if(concurrentQueue.TryDequeue(out int result))
{
  Console.WriteLine($"Dequeued: {result}");
}

9.4 Avoiding Unnecessary Operations

if(fruitsQueue.Count > 0)
{
  string fruit = fruitsQueue.Dequeue();
  Console.WriteLine($"Dequeued: {fruit}");
}
else
{
  Console.WriteLine("Queue is empty.");
}

9.5 Using Appropriate Data Types

10. Common Mistakes with Queue<T>

10.1 Attempting to Dequeue from an Empty Queue

Queue<int> numbersQueue = new Queue<int>();
int number = numbersQueue.Dequeue(); // Throws InvalidOperationException

if(numbersQueue.TryDequeue(out int number))
{
    Console.WriteLine($"Dequeued: {number}");
}
else
{
    Console.WriteLine("Queue is empty.");
}

10.2 Modifying the Queue During Iteration

foreach(var item in fruitsQueue)
{
    if(item == "Banana")
    {
        fruitsQueue.Dequeue(); // InvalidOperationException
    }
}

while(fruitsQueue.Count > 0)
{
    var fruit = fruitsQueue.Dequeue();
    if(fruit == "Banana")
    {
        // Handle Banana
    }
}

10.3 Using Incorrect Key Types

11. Advanced Topics

11.1 Thread-Safe Queues with ConcurrentQueue<T>

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

class Program
{
    static ConcurrentQueue<int> concurrentQueue = new ConcurrentQueue<int>();

    static void Main()
    {
        Parallel.For(0, 1000, i =>
        {
            concurrentQueue.Enqueue(i);
        });

        Console.WriteLine($"Total Items Enqueued: {concurrentQueue.Count}"); // Output: 1000

        int result;
        while(concurrentQueue.TryDequeue(out result))
        {
            // Process result
        }
    }
}

11.2 Implementing Custom Queue Behavior

using System;
using System.Collections.Generic;

public class LimitedQueue<T> : Queue<T>
{
    private int maxSize;

    public LimitedQueue(int maxSize)
    {
        this.maxSize = maxSize;
    }

    public new void Enqueue(T item)
    {
        base.Enqueue(item);
        while(this.Count > maxSize)
        {
            this.Dequeue();
        }
    }
}

class Program
{
    static void Main()
    {
        LimitedQueue<int> limitedQueue = new LimitedQueue<int>(3);
        limitedQueue.Enqueue(1);
        limitedQueue.Enqueue(2);
        limitedQueue.Enqueue(3);
        limitedQueue.Enqueue(4); // This will remove 1

        foreach(var item in limitedQueue)
        {
            Console.WriteLine(item); // Outputs: 2, 3, 4
        }
    }
}

11.3 Serialization of Queues

using System;
using System.Collections.Generic;
using System.Text.Json;

class Program
{
    static void Main()
    {
        Queue<string> fruitsQueue = new Queue<string>();
        fruitsQueue.Enqueue("Apple");
        fruitsQueue.Enqueue("Banana");
        fruitsQueue.Enqueue("Cherry");

        string json = JsonSerializer.Serialize(fruitsQueue);
        Console.WriteLine(json); // Output: ["Apple","Banana","Cherry"]

        // Deserialization
        Queue<string> deserializedQueue = JsonSerializer.Deserialize<Queue<string>>(json);
        foreach(var fruit in deserializedQueue)
        {
            Console.WriteLine(fruit);
        }
    }
}

Sample Output:
["Apple","Banana","Cherry"]
Apple
Banana
Cherry

12. Real-World Example

Example: Task Processing System Using Queue<T>

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static Queue<TaskItem> taskQueue = new Queue<TaskItem>();
    static object lockObj = new object();
    static bool isProcessing = false;

    static void Main()
    {
        // Enqueue tasks
        EnqueueTask(new TaskItem { Id = 1, Description = "Process Order #1001" });
        EnqueueTask(new TaskItem { Id = 2, Description = "Send Email to Client" });
        EnqueueTask(new TaskItem { Id = 3, Description = "Generate Report" });

        // Start processing tasks
        Task.Run(() => ProcessTasks());

        // Enqueue more tasks
        EnqueueTask(new TaskItem { Id = 4, Description = "Backup Database" });
        EnqueueTask(new TaskItem { Id = 5, Description = "Update Inventory" });

        // Wait for tasks to be processed
        Thread.Sleep(5000);
    }

    static void EnqueueTask(TaskItem task)
    {
        lock(lockObj)
        {
            taskQueue.Enqueue(task);
            Console.WriteLine($"Enqueued Task: {task.Description}");
            if(!isProcessing)
            {
                isProcessing = true;
                Monitor.Pulse(lockObj);
            }
        }
    }

    static void ProcessTasks()
    {
        while(true)
        {
            TaskItem task = null;
            lock(lockObj)
            {
                while(taskQueue.Count == 0)
                {
                    Monitor.Wait(lockObj);
                }
                task = taskQueue.Dequeue();
                Console.WriteLine($"Dequeued Task: {task.Description}");
            }

            // Simulate task processing
            Console.WriteLine($"Processing Task: {task.Description}");
            Thread.Sleep(1000); // Simulate work
        }
    }
}

public class TaskItem
{
    public int Id { get; set; }
    public string Description { get; set; }
}

Sample Output:
Enqueued Task: Process Order #1001
Enqueued Task: Send Email to Client
Enqueued Task: Generate Report
Dequeued Task: Process Order #1001
Processing Task: Process Order #1001
Enqueued Task: Backup Database
Enqueued Task: Update Inventory
Dequeued Task: Send Email to Client
Processing Task: Send Email to Client
Dequeued Task: Generate Report
Processing Task: Generate Report
Dequeued Task: Backup Database
Processing Task: Backup Database
Dequeued Task: Update Inventory
Processing Task: Update Inventory
...

13. Summary