.NET HELP

C# Queue (How it Works For Developers)

Name: IronPDF
Brand: Iron Software
Availability: InStock
Rating: 4.87 (307 reviews)

Chipego Kalinda

January 4, 2024

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 dequeue of any data type. It provides methods like Enqueue for adding elements to the specified object at the beginning or 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>();
        standardQueue.Enqueue(10);
        standardQueue.Enqueue(20);
        standardQueue.Enqueue(30);
        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>();
        standardQueue.Enqueue(10);
        standardQueue.Enqueue(20);
        standardQueue.Enqueue(30);
        while (standardQueue.Count > 0)
        {
            int element = standardQueue.Dequeue();
            Console.WriteLine($"Dequeued: {element}");
        }
    }
}

Imports System
Imports System.Collections.Generic
Friend Class Program
	Shared Sub Main()
		' create an empty queue
		Dim standardQueue As New Queue(Of Integer)()
		standardQueue.Enqueue(10)
		standardQueue.Enqueue(20)
		standardQueue.Enqueue(30)
		Do While standardQueue.Count > 0
			Dim element As Integer = standardQueue.Dequeue()
			Console.WriteLine($"Dequeued: {element}")
		Loop
	End Sub
End Class

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. It checks if the element exists and uses FIFO style to arrange the oldest element to the end of the queue, also determining whether an element should be the beginning of the queue based on the number of elements contained.

using System;
using System.Collections.Generic;
class Program
{    
    static void Main()
    {
        SortedSet<int> priorityQueue = new SortedSet<int>();
        priorityQueue.Add(30);
        priorityQueue.Add(10);
        priorityQueue.Add(20);
        while (priorityQueue.Count > 0)
        {
            int element = priorityQueue.Min;
            priorityQueue.Remove(element);
            Console.WriteLine($"Priority Queue Dequeued: {element}");
        }
    }
}

using System;
using System.Collections.Generic;
class Program
{    
    static void Main()
    {
        SortedSet<int> priorityQueue = new SortedSet<int>();
        priorityQueue.Add(30);
        priorityQueue.Add(10);
        priorityQueue.Add(20);
        while (priorityQueue.Count > 0)
        {
            int element = priorityQueue.Min;
            priorityQueue.Remove(element);
            Console.WriteLine($"Priority Queue Dequeued: {element}");
        }
    }
}

Imports System
Imports System.Collections.Generic
Friend Class Program
	Shared Sub Main()
		Dim priorityQueue As New SortedSet(Of Integer)()
		priorityQueue.Add(30)
		priorityQueue.Add(10)
		priorityQueue.Add(20)
		Do While priorityQueue.Count > 0
			Dim element As Integer = AddressOf priorityQueue.Min
			priorityQueue.Remove(element)
			Console.WriteLine($"Priority Queue Dequeued: {element}")
		Loop
	End Sub
End Class

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;
// Queue class
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
    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)
        {
            front = rear = 0;
            array[rear] = item;
        }
        else if (rear == size - 1 && front != 0)
        {
            rear = 0;
            array[rear] = item;
        }
        else
        {
            rear++;
            array[rear] = item;
        }
    }
    public int Dequeue()
    {
        if (front == -1)
        {
            Console.WriteLine("Queue is empty");
            return -1;
        }
        int item = array[front];
        array[front] = -1;
        if (front == rear)
            front = rear = -1;
        else if (front == size - 1)
            front = 0;
        else
            front++;
        return item;
    }
}
class Program
{
    static void Main()
    {   
        // specified initial capacity 5
        CircularQueue circularQueue = new CircularQueue(5);
        circularQueue.Enqueue(10);
        circularQueue.Enqueue(20);
        circularQueue.Enqueue(30);
        Console.WriteLine($"Circular Queue Dequeued: {circularQueue.Dequeue()}");
        Console.WriteLine($"Circular Queue Dequeued: {circularQueue.Dequeue()}");
    }
}

using System;
// Queue class
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
    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)
        {
            front = rear = 0;
            array[rear] = item;
        }
        else if (rear == size - 1 && front != 0)
        {
            rear = 0;
            array[rear] = item;
        }
        else
        {
            rear++;
            array[rear] = item;
        }
    }
    public int Dequeue()
    {
        if (front == -1)
        {
            Console.WriteLine("Queue is empty");
            return -1;
        }
        int item = array[front];
        array[front] = -1;
        if (front == rear)
            front = rear = -1;
        else if (front == size - 1)
            front = 0;
        else
            front++;
        return item;
    }
}
class Program
{
    static void Main()
    {   
        // specified initial capacity 5
        CircularQueue circularQueue = new CircularQueue(5);
        circularQueue.Enqueue(10);
        circularQueue.Enqueue(20);
        circularQueue.Enqueue(30);
        Console.WriteLine($"Circular Queue Dequeued: {circularQueue.Dequeue()}");
        Console.WriteLine($"Circular Queue Dequeued: {circularQueue.Dequeue()}");
    }
}

Imports System
' Queue class
Friend Class CircularQueue
	Private array() As Integer
	Private front, rear, size As Integer
	Public Sub New(ByVal size As Integer)
		Me.size = size
		array = New Integer(size - 1){}
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: front = rear = -1;
		rear = -1
		front = rear
	End Sub

	' enqueue method
	Public Sub Enqueue(ByVal 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
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: front = rear = 0;
			rear = 0
			front = rear
			array(rear) = item
		ElseIf rear = size - 1 AndAlso front <> 0 Then
			rear = 0
			array(rear) = item
		Else
			rear += 1
			array(rear) = item
		End If
	End Sub
	Public Function Dequeue() As Integer
		If front = -1 Then
			Console.WriteLine("Queue is empty")
			Return -1
		End If
		Dim item As Integer = array(front)
		array(front) = -1
		If front = rear Then
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: front = rear = -1;
			rear = -1
			front = rear
		ElseIf front = size - 1 Then
			front = 0
		Else
			front += 1
		End If
		Return item
	End Function
End Class
Friend Class Program
	Shared Sub Main()
		' specified initial capacity 5
		Dim circularQueue As New CircularQueue(5)
		circularQueue.Enqueue(10)
		circularQueue.Enqueue(20)
		circularQueue.Enqueue(30)
		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);
        }
    }
    static void GeneratePdf(string userRequest)
    {
        // Use IronPDF to generate PDF based on user request
        var Renderer = new HtmlToPdf();
        var PDF = Renderer.RenderHtmlAsPdf($"<h1>{userRequest}</h1>");

        // Save the generated PDF
        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);
        }
    }
    static void GeneratePdf(string userRequest)
    {
        // Use IronPDF to generate PDF based on user request
        var Renderer = new HtmlToPdf();
        var PDF = Renderer.RenderHtmlAsPdf($"<h1>{userRequest}</h1>");

        // Save the generated PDF
        PDF.SaveAs($"{userRequest.Replace(" ", "_")}.pdf");
    }
}

Imports IronPdf
Imports System
Imports System.Collections.Generic
Friend Class PdfGenerator
	Shared Sub Main()
		' Create a C# 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
		Do While userRequests.Count > 0
			Dim request As String = userRequests.Dequeue()
			GeneratePdf(request)
		Loop
	End Sub
	Private Shared Sub GeneratePdf(ByVal userRequest As String)
		' Use IronPDF to generate PDF based on user request
		Dim Renderer = New HtmlToPdf()
		Dim PDF = Renderer.RenderHtmlAsPdf($"<h1>{userRequest}</h1>")

		' Save the generated PDF
		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.

Chipego Kalinda

Chat with engineering team now

Software Engineer

Chipego has a natural skill for listening that helps him to comprehend customer issues, and offer intelligent solutions. He joined the Iron Software team in 2023, after studying a Bachelor of Science in Information Technology. IronPDF and IronOCR are the two products Chipego has been focusing on, but his knowledge of all products is growing daily, as he finds new ways to support customers. He enjoys how collaborative life is at Iron Software, with team members from across the company bringing their varied experience to contribute to effective, innovative solutions. When Chipego is away from his desk, he can often be found enjoying a good book or playing football.

< PREVIOUS
Hangfire .NET Core (How It Works For Developers)

NEXT >
C# Case Statement (How it Works For Developers)