What is a C# Queue and how does it function?

A C# Queue is a data structure that follows the First-In-First-Out (FIFO) principle, making it ideal for processing tasks or requests in a specific, sequential order. It is particularly useful in scenarios requiring fairness and resource allocation based on the order of entry.

How can I implement a priority queue in C#?

C# does not have a built-in priority queue, but you can implement one using a sorted collection or a custom data structure. This allows elements to be processed based on specified criteria like urgency or importance.

What are the different types of queues available in C#?

C# offers various types of queues, including the standard queue, priority queue, and circular queue. Each has unique characteristics suited for specific data handling needs, such as ensuring strict order in processing or optimizing memory usage.

What is the role of IronPDF in integrating C# Queue with PDF generation?

IronPDF is a C# library that facilitates the creation and manipulation of PDF documents from HTML, ASPX, or plain text. When used with C# Queue, it allows for the orderly processing of requests, enabling the systematic generation of dynamic and organized PDF documents.

Can you provide an example of using a C# Queue with IronPDF?

Certainly! In a web application that needs to generate PDF reports based on user inputs, a C# Queue can store the requests. The `GeneratePdf` method can then be used to dequeue each request, utilize IronPDF to create the PDF, and save the document systematically.

How does a circular queue differ from a standard queue in C#?

A circular queue connects the last element to the first, creating a circular loop. This design is advantageous when dealing with a fixed-size queue, as it efficiently replaces old elements with new ones and optimizes memory usage, unlike a standard queue that doesn't wrap around.

Why is the FIFO principle important in a C# Queue?

The FIFO (First-In-First-Out) principle ensures that the first element added to the queue is the first one processed and removed. This is crucial for applications where tasks or requests need to be processed in the exact sequence they were received, maintaining order and fairness.

What are some real-world applications of a C# Queue?

A C# Queue can be used in various applications, such as managing task scheduling systems, handling web server requests, or collaborating with libraries like IronPDF to generate PDFs in order based on user requests.

How does the standard queue's `Enqueue` and `Dequeue` methods work?

In a standard queue, the `Enqueue` method adds an element to the end of the queue, while the `Dequeue` method removes the element at the front. These methods ensure data is processed in a sequential and orderly manner.

The C# PDF Library

Explore IronPDF Start Free Trial

HTML to PDF

Online Demo See All Code Examples

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

.NET HELP

C# Queue (How it Works For Developers)

Jacob Mellor

Updated: April 21, 2026

1. Introduction

In the realm of programming, efficient data handling is a cornerstone of successful software development. One essential data structure that plays a crucial role in managing and organizing information is the queue. In the context of C#, a powerful and versatile programming language, the C# Queue stands out as a fundamental tool for managing data sequentially. To know more about the Queues in C#, here are the recommended articles on Queues in C# and Generic Queue class in .NET.

A queue follows the First-In-First-Out (FIFO) principle, where the first element added is the first one to be removed. This characteristic makes it particularly useful in scenarios where data or objects need to be processed in a specific order, such as handling tasks in a systematic way or managing requests in a web server.

In this article, we will use the C# PDF Library IronPDF with the C# Queue.

2. Types and Uses of C# Queue

2.1. Standard Queue

The standard queue in C# is a generic class that allows developers to create a queue of any data type. It provides methods like Enqueue for adding elements to the end of the queue and Dequeue for removing elements from the front. This type of queue is widely used in scenarios where data processing follows a strict order, ensuring fairness in resource allocation.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    { 
        // Create an empty queue
        Queue<int> standardQueue = new Queue<int>();
        
        // Enqueue elements into the queue
        standardQueue.Enqueue(10);
        standardQueue.Enqueue(20);
        standardQueue.Enqueue(30);
        
        // Dequeue elements from the queue until it is empty
        while (standardQueue.Count > 0)
        {
            int element = standardQueue.Dequeue();
            Console.WriteLine($"Dequeued: {element}");
        }
    }
}

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    { 
        // Create an empty queue
        Queue<int> standardQueue = new Queue<int>();
        
        // Enqueue elements into the queue
        standardQueue.Enqueue(10);
        standardQueue.Enqueue(20);
        standardQueue.Enqueue(30);
        
        // Dequeue elements from the queue until it is empty
        while (standardQueue.Count > 0)
        {
            int element = standardQueue.Dequeue();
            Console.WriteLine($"Dequeued: {element}");
        }
    }
}

Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        ' Create an empty queue
        Dim standardQueue As New Queue(Of Integer)()
        
        ' Enqueue elements into the queue
        standardQueue.Enqueue(10)
        standardQueue.Enqueue(20)
        standardQueue.Enqueue(30)
        
        ' Dequeue elements from the queue until it is empty
        While standardQueue.Count > 0
            Dim element As Integer = standardQueue.Dequeue()
            Console.WriteLine($"Dequeued: {element}")
        End While
    End Sub
End Module

Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        ' Create an empty queue
        Dim standardQueue As New Queue(Of Integer)()
        
        ' Enqueue elements into the queue
        standardQueue.Enqueue(10)
        standardQueue.Enqueue(20)
        standardQueue.Enqueue(30)
        
        ' Dequeue elements from the queue until it is empty
        While standardQueue.Count > 0
            Dim element As Integer = standardQueue.Dequeue()
            Console.WriteLine($"Dequeued: {element}")
        End While
    End Sub
End Module

Output

C# Queue (How it Works For Developers): Figure 1 - OUTPUT: Standard Queue

2.2. Priority Queue

In certain situations, prioritizing elements in the queue becomes crucial. C# does not have a built-in priority queue, but developers can implement one by using a sorted collection or a custom data structure. This type of queue is beneficial when certain elements need to be processed ahead of others based on specific criteria, such as urgency or importance.

using System;
using System.Collections.Generic;

class Program
{    
    static void Main()
    {
        // Create a priority queue using a sorted set to store elements in order
        SortedSet<int> priorityQueue = new SortedSet<int>();
        
        // Add elements to the priority queue
        priorityQueue.Add(30);
        priorityQueue.Add(10);
        priorityQueue.Add(20);
        
        // Dequeue elements from the priority queue based on their priority
        while (priorityQueue.Count > 0)
        {
            // Access the minimum element (highest priority for this example)
            int element = priorityQueue.Min;
            // Remove the element from the queue
            priorityQueue.Remove(element);
            Console.WriteLine($"Priority Queue Dequeued: {element}");
        }
    }
}

using System;
using System.Collections.Generic;

class Program
{    
    static void Main()
    {
        // Create a priority queue using a sorted set to store elements in order
        SortedSet<int> priorityQueue = new SortedSet<int>();
        
        // Add elements to the priority queue
        priorityQueue.Add(30);
        priorityQueue.Add(10);
        priorityQueue.Add(20);
        
        // Dequeue elements from the priority queue based on their priority
        while (priorityQueue.Count > 0)
        {
            // Access the minimum element (highest priority for this example)
            int element = priorityQueue.Min;
            // Remove the element from the queue
            priorityQueue.Remove(element);
            Console.WriteLine($"Priority Queue Dequeued: {element}");
        }
    }
}

Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        ' Create a priority queue using a sorted set to store elements in order
        Dim priorityQueue As New SortedSet(Of Integer)()
        
        ' Add elements to the priority queue
        priorityQueue.Add(30)
        priorityQueue.Add(10)
        priorityQueue.Add(20)
        
        ' Dequeue elements from the priority queue based on their priority
        While priorityQueue.Count > 0
            ' Access the minimum element (highest priority for this example)
            Dim element As Integer = priorityQueue.Min
            ' Remove the element from the queue
            priorityQueue.Remove(element)
            Console.WriteLine($"Priority Queue Dequeued: {element}")
        End While
    End Sub
End Module

Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        ' Create a priority queue using a sorted set to store elements in order
        Dim priorityQueue As New SortedSet(Of Integer)()
        
        ' Add elements to the priority queue
        priorityQueue.Add(30)
        priorityQueue.Add(10)
        priorityQueue.Add(20)
        
        ' Dequeue elements from the priority queue based on their priority
        While priorityQueue.Count > 0
            ' Access the minimum element (highest priority for this example)
            Dim element As Integer = priorityQueue.Min
            ' Remove the element from the queue
            priorityQueue.Remove(element)
            Console.WriteLine($"Priority Queue Dequeued: {element}")
        End While
    End Sub
End Module

C# Queue (How it Works For Developers): Figure 2 - OUTPUT: Priority Queue

2.3. Circular Queue

A circular queue is a variant where the last element is connected to the first, creating a circular structure. This can be advantageous in scenarios where the queue has a fixed size, and old queue elements need to be replaced by new ones in a cyclic manner. Implementing a circular queue in C# can optimize memory usage and ensure efficient data processing.

using System;

// CircularQueue class to implement a fixed-size circular queue
class CircularQueue
{
    private int[] array;
    private int front, rear, size;

    public CircularQueue(int size)
    {
        this.size = size;
        array = new int[size];
        front = rear = -1;
    }

    // Enqueue method to add an element to the circular queue
    public void Enqueue(int item)
    {
        if ((front == 0 && rear == size - 1) || (rear == (front - 1) % (size - 1)))
        {
            Console.WriteLine("Queue is full");
            return;
        }
        else if (front == -1)  // Initial insertion case
        {
            front = rear = 0;
            array[rear] = item;
        }
        else if (rear == size - 1 && front != 0)  // Wrap around
        {
            rear = 0;
            array[rear] = item;
        }
        else  // Normal case
        {
            rear++;
            array[rear] = item;
        }
    }

    // Dequeue method to remove an element from the circular queue
    public int Dequeue()
    {
        if (front == -1)  // Queue is empty case
        {
            Console.WriteLine("Queue is empty");
            return -1;
        }
        
        int item = array[front];
        array[front] = -1;
        
        if (front == rear)  // Single element case
            front = rear = -1;
        else if (front == size - 1)  // Wrap around
            front = 0;
        else  // Normal case
            front++;
        
        return item;
    }
}

class Program
{
    static void Main()
    {
        // Create a circular queue with a specified initial capacity
        CircularQueue circularQueue = new CircularQueue(5);
        
        // Enqueue elements
        circularQueue.Enqueue(10);
        circularQueue.Enqueue(20);
        circularQueue.Enqueue(30);
        
        // Dequeue elements
        Console.WriteLine($"Circular Queue Dequeued: {circularQueue.Dequeue()}");
        Console.WriteLine($"Circular Queue Dequeued: {circularQueue.Dequeue()}");
    }
}

using System;

// CircularQueue class to implement a fixed-size circular queue
class CircularQueue
{
    private int[] array;
    private int front, rear, size;

    public CircularQueue(int size)
    {
        this.size = size;
        array = new int[size];
        front = rear = -1;
    }

    // Enqueue method to add an element to the circular queue
    public void Enqueue(int item)
    {
        if ((front == 0 && rear == size - 1) || (rear == (front - 1) % (size - 1)))
        {
            Console.WriteLine("Queue is full");
            return;
        }
        else if (front == -1)  // Initial insertion case
        {
            front = rear = 0;
            array[rear] = item;
        }
        else if (rear == size - 1 && front != 0)  // Wrap around
        {
            rear = 0;
            array[rear] = item;
        }
        else  // Normal case
        {
            rear++;
            array[rear] = item;
        }
    }

    // Dequeue method to remove an element from the circular queue
    public int Dequeue()
    {
        if (front == -1)  // Queue is empty case
        {
            Console.WriteLine("Queue is empty");
            return -1;
        }
        
        int item = array[front];
        array[front] = -1;
        
        if (front == rear)  // Single element case
            front = rear = -1;
        else if (front == size - 1)  // Wrap around
            front = 0;
        else  // Normal case
            front++;
        
        return item;
    }
}

class Program
{
    static void Main()
    {
        // Create a circular queue with a specified initial capacity
        CircularQueue circularQueue = new CircularQueue(5);
        
        // Enqueue elements
        circularQueue.Enqueue(10);
        circularQueue.Enqueue(20);
        circularQueue.Enqueue(30);
        
        // Dequeue elements
        Console.WriteLine($"Circular Queue Dequeued: {circularQueue.Dequeue()}");
        Console.WriteLine($"Circular Queue Dequeued: {circularQueue.Dequeue()}");
    }
}

Imports System

' CircularQueue class to implement a fixed-size circular queue
Class CircularQueue
    Private array() As Integer
    Private front, rear, size As Integer

    Public Sub New(size As Integer)
        Me.size = size
        ReDim array(size - 1)
        front = -1
        rear = -1
    End Sub

    ' Enqueue method to add an element to the circular queue
    Public Sub Enqueue(item As Integer)
        If (front = 0 AndAlso rear = size - 1) OrElse (rear = (front - 1) Mod (size - 1)) Then
            Console.WriteLine("Queue is full")
            Return
        ElseIf front = -1 Then ' Initial insertion case
            front = 0
            rear = 0
            array(rear) = item
        ElseIf rear = size - 1 AndAlso front <> 0 Then ' Wrap around
            rear = 0
            array(rear) = item
        Else ' Normal case
            rear += 1
            array(rear) = item
        End If
    End Sub

    ' Dequeue method to remove an element from the circular queue
    Public Function Dequeue() As Integer
        If front = -1 Then ' Queue is empty case
            Console.WriteLine("Queue is empty")
            Return -1
        End If

        Dim item As Integer = array(front)
        array(front) = -1

        If front = rear Then ' Single element case
            front = -1
            rear = -1
        ElseIf front = size - 1 Then ' Wrap around
            front = 0
        Else ' Normal case
            front += 1
        End If

        Return item
    End Function
End Class

Class Program
    Shared Sub Main()
        ' Create a circular queue with a specified initial capacity
        Dim circularQueue As New CircularQueue(5)

        ' Enqueue elements
        circularQueue.Enqueue(10)
        circularQueue.Enqueue(20)
        circularQueue.Enqueue(30)

        ' Dequeue elements
        Console.WriteLine($"Circular Queue Dequeued: {circularQueue.Dequeue()}")
        Console.WriteLine($"Circular Queue Dequeued: {circularQueue.Dequeue()}")
    End Sub
End Class

Imports System

' CircularQueue class to implement a fixed-size circular queue
Class CircularQueue
    Private array() As Integer
    Private front, rear, size As Integer

    Public Sub New(size As Integer)
        Me.size = size
        ReDim array(size - 1)
        front = -1
        rear = -1
    End Sub

    ' Enqueue method to add an element to the circular queue
    Public Sub Enqueue(item As Integer)
        If (front = 0 AndAlso rear = size - 1) OrElse (rear = (front - 1) Mod (size - 1)) Then
            Console.WriteLine("Queue is full")
            Return
        ElseIf front = -1 Then ' Initial insertion case
            front = 0
            rear = 0
            array(rear) = item
        ElseIf rear = size - 1 AndAlso front <> 0 Then ' Wrap around
            rear = 0
            array(rear) = item
        Else ' Normal case
            rear += 1
            array(rear) = item
        End If
    End Sub

    ' Dequeue method to remove an element from the circular queue
    Public Function Dequeue() As Integer
        If front = -1 Then ' Queue is empty case
            Console.WriteLine("Queue is empty")
            Return -1
        End If

        Dim item As Integer = array(front)
        array(front) = -1

        If front = rear Then ' Single element case
            front = -1
            rear = -1
        ElseIf front = size - 1 Then ' Wrap around
            front = 0
        Else ' Normal case
            front += 1
        End If

        Return item
    End Function
End Class

Class Program
    Shared Sub Main()
        ' Create a circular queue with a specified initial capacity
        Dim circularQueue As New CircularQueue(5)

        ' Enqueue elements
        circularQueue.Enqueue(10)
        circularQueue.Enqueue(20)
        circularQueue.Enqueue(30)

        ' Dequeue elements
        Console.WriteLine($"Circular Queue Dequeued: {circularQueue.Dequeue()}")
        Console.WriteLine($"Circular Queue Dequeued: {circularQueue.Dequeue()}")
    End Sub
End Class

C# Queue (How it Works For Developers): Figure 3 - OUTPUT: Circular Queue

3. Introducing IronPDF in C#

As we delve into the functionalities and applications of the C# Queue, it's essential to explore how it can be seamlessly integrated into real-world applications. One such powerful tool that enhances C# capabilities is IronPDF.

IronPDF is a C# library that simplifies the creation, manipulation, and rendering of PDF documents. Its intuitive API allows developers to generate PDFs from HTML, ASPX, or even plain text. With IronPDF, the process of incorporating C# Queue into a PDF-generating application becomes streamlined and efficient.

3.1. Using C# Queue with IronPDF Code

Let's take a closer look at how the C# Queue can be utilized in conjunction with IronPDF to create dynamic and organized PDF documents. Consider a scenario where a web application needs to generate a PDF report based on user inputs and requests.

using IronPdf;
using System;
using System.Collections.Generic;

class PdfGenerator
{
    static void Main()
    {
        // Create a C# Queue to store user requests
        Queue<string> userRequests = new Queue<string>();
        
        // Simulate user requests being added to the queue
        userRequests.Enqueue("Generate PDF for User 1");
        userRequests.Enqueue("Generate PDF for User 2");
        userRequests.Enqueue("Generate PDF for User 3");
        
        // Process requests and generate PDFs
        while (userRequests.Count > 0)
        {
            string request = userRequests.Dequeue();
            GeneratePdf(request);
        }
    }

    // Method to generate a PDF file using IronPDF
    static void GeneratePdf(string userRequest)
    {
        // Use IronPDF to generate PDF based on user request
        var Renderer = new HtmlToPdf();
        
        // Render the provided HTML content as a PDF
        var PDF = Renderer.RenderHtmlAsPdf($"<h1>{userRequest}</h1>");
        
        // Save the generated PDF with the request name as file name
        PDF.SaveAs($"{userRequest.Replace(" ", "_")}.pdf");
    }
}

using IronPdf;
using System;
using System.Collections.Generic;

class PdfGenerator
{
    static void Main()
    {
        // Create a C# Queue to store user requests
        Queue<string> userRequests = new Queue<string>();
        
        // Simulate user requests being added to the queue
        userRequests.Enqueue("Generate PDF for User 1");
        userRequests.Enqueue("Generate PDF for User 2");
        userRequests.Enqueue("Generate PDF for User 3");
        
        // Process requests and generate PDFs
        while (userRequests.Count > 0)
        {
            string request = userRequests.Dequeue();
            GeneratePdf(request);
        }
    }

    // Method to generate a PDF file using IronPDF
    static void GeneratePdf(string userRequest)
    {
        // Use IronPDF to generate PDF based on user request
        var Renderer = new HtmlToPdf();
        
        // Render the provided HTML content as a PDF
        var PDF = Renderer.RenderHtmlAsPdf($"<h1>{userRequest}</h1>");
        
        // Save the generated PDF with the request name as file name
        PDF.SaveAs($"{userRequest.Replace(" ", "_")}.pdf");
    }
}

Imports IronPdf
Imports System
Imports System.Collections.Generic

Class PdfGenerator
    Shared Sub Main()
        ' Create a VB.NET Queue to store user requests
        Dim userRequests As New Queue(Of String)()
        
        ' Simulate user requests being added to the queue
        userRequests.Enqueue("Generate PDF for User 1")
        userRequests.Enqueue("Generate PDF for User 2")
        userRequests.Enqueue("Generate PDF for User 3")
        
        ' Process requests and generate PDFs
        While userRequests.Count > 0
            Dim request As String = userRequests.Dequeue()
            GeneratePdf(request)
        End While
    End Sub

    ' Method to generate a PDF file using IronPDF
    Shared Sub GeneratePdf(userRequest As String)
        ' Use IronPDF to generate PDF based on user request
        Dim Renderer = New HtmlToPdf()
        
        ' Render the provided HTML content as a PDF
        Dim PDF = Renderer.RenderHtmlAsPdf($"<h1>{userRequest}</h1>")
        
        ' Save the generated PDF with the request name as file name
        PDF.SaveAs($"{userRequest.Replace(" ", "_")}.pdf")
    End Sub
End Class

Imports IronPdf
Imports System
Imports System.Collections.Generic

Class PdfGenerator
    Shared Sub Main()
        ' Create a VB.NET Queue to store user requests
        Dim userRequests As New Queue(Of String)()
        
        ' Simulate user requests being added to the queue
        userRequests.Enqueue("Generate PDF for User 1")
        userRequests.Enqueue("Generate PDF for User 2")
        userRequests.Enqueue("Generate PDF for User 3")
        
        ' Process requests and generate PDFs
        While userRequests.Count > 0
            Dim request As String = userRequests.Dequeue()
            GeneratePdf(request)
        End While
    End Sub

    ' Method to generate a PDF file using IronPDF
    Shared Sub GeneratePdf(userRequest As String)
        ' Use IronPDF to generate PDF based on user request
        Dim Renderer = New HtmlToPdf()
        
        ' Render the provided HTML content as a PDF
        Dim PDF = Renderer.RenderHtmlAsPdf($"<h1>{userRequest}</h1>")
        
        ' Save the generated PDF with the request name as file name
        PDF.SaveAs($"{userRequest.Replace(" ", "_")}.pdf")
    End Sub
End Class

In this example, a C# Queue (userRequests) is used to store user requests for PDF generation. The GeneratePdf method takes a user request, utilizes IronPDF to convert HTML content to a PDF document, and saves the generated PDF file with a relevant name.

This integration method also showcases the synergy between C# Queue and IronPDF, where the orderly processing of user requests results in the systematic creation of PDF documents.

3.2. Output #1

C# Queue (How it Works For Developers): Figure 4 - OUTPUT 1: Generate PDF using IronPDF and C# Queue

3.3. Output #2

C# Queue (How it Works For Developers): Figure 5 - OUTPUT 2: Generate PDF using IronPDF and C# Queue

3.4. Output #3

C# Queue (How it Works For Developers): Figure 6 - OUTPUT 3: Generate PDF using IronPDF and C# Queue

4. Conclusion

In conclusion, the C# Queue proves to be a valuable asset in managing and processing data sequentially. Its adherence to the FIFO principle makes it suitable for a wide range of applications, from task scheduling to request handling in web servers. When combined with powerful libraries like IronPDF, the C# Queue becomes even more potent, allowing developers to create organized and dynamic PDF documents efficiently.

Understanding the nuances of C# Queue and exploring its integration with tools like IronPDF empowers developers to design robust and efficient solutions for data management and processing. As technology continues to evolve, the synergy between fundamental data structures like the C# Queue and innovative libraries will play a pivotal role in shaping the landscape of software development.

For licensing information, visit IronPDF licensing details. To know more about the HTML to PDF conversion, visit the HTML to PDF Conversion Tutorial.

Jacob Mellor

Chat with engineering team now

Chief Technology Officer

Jacob Mellor is Chief Technology Officer at Iron Software and a visionary engineer pioneering C# PDF technology. As the original developer behind Iron Software's core codebase, he has shaped the company's product architecture since its inception, transforming it alongside CEO Cameron Rimington into a 50+ person company serving NASA, Tesla, and global government agencies.

...