1. IronPDF
  2. IronPDF Blog
  3. .NET Help
  4. csharp-priority-queue-guide

Published February 19, 2024

C# Priority Queue (How It Works For Developers)

Introduction

Programming in C# is quite flexible, and IronPDF is a strong library that makes working with documents easier, especially when creating and modifying PDF files. This post will explain the idea of a priority queue in C# and show you how to effectively utilize it with IronPDF to optimize document processing procedures. In the article, we are going to use the c# priority queue along with IronPDF.

How to Use C# Priority queue

  1. Create a new c# project and Create a Priority Queue object.
  2. Enqueue Elements with Priorities.
  3. Dequeue Element with Highest Priority.
  4. Peek at the Highest Priority Element.
  5. Check if the Priority Queue is Empty.
  6. Execute the code and dispose of the objects.

Priority Queue

A data structure called a priority queue keeps track of several components, each of which has a priority assigned to it. The essential characteristic of a priority queue is that it allows for efficient retrieval as the element with the highest priority (or lowest priority value, depending on the implementation) priority is always at the front. In situations where tasks or items must be handled in a certain sequence according to their priority, priority queues are frequently utilized.

Although there isn't a PriorityQueue class in the C# standard library, you may create one yourself or utilize third-party libraries that offer this data structure. The array heap has an initial capacity, and a new heap with a bigger capacity is formed when it fills up, and we attempt to enqueue a new element. Two components are served in the same order that they were queued if they share equal priority. To prevent race situations, you need to develop your unique code to handle thread safety.

When components have corresponding priorities and must be handled according to those priorities, a priority queue in C# offers several benefits.

The following are some benefits of employing a priority queue in C#

  • Priority Ordering: Elements are automatically kept in order according to their priority using a priority queue. This makes priority-based processing more efficient by guaranteeing that components with higher priorities are handled before those with lower priorities.
  • Customizable Comparisons: Priority queues let you use custom comparer classes or construct custom comparisons, which makes it possible to sort data according to intricate standards. When working with objects that have several characteristics or custom priority logic, this is helpful.
  • Fast Retrieval: In most cases, retrieving the element with the greatest priority—or lowest, depending on how it is implemented—requires a consistent amount of time. This is especially useful for algorithms that need to get the most important piece quickly.

Implementing a Priority Queue in C#

Let's use a binary heap to build a basic C# priority queue system. Keep in mind that you might wish to leverage pre-existing libraries or think about a more complex approach for production use.

public class PriorityQueue<T>
{
    private List<T> elements;
    private readonly IComparer<T> comparer;
    public PriorityQueue(IComparer<T> comparer)
    {
        this.elements = new List<T>();
        this.comparer = comparer;
    }
    public int Count => elements.Count;
    public void Enqueue(T item)
    {
        elements.Add(item);
        int index = Count - 1;
        while (index > 0)
        {
            int parentIndex = (index - 1) / 2;
            if (comparer.Compare(elements[parentIndex], elements[index]) <= 0)
                break;
            Swap(index, parentIndex);
            index = parentIndex;
        }
    }
    public T Dequeue()
    {
        if (Count == 0)
            throw new InvalidOperationException("Queue is empty.");
        T front = elements[0];
        elements[0] = elements[Count - 1];
        elements.RemoveAt(Count - 1);
        int index = 0;
        while (true)
        {
            int leftChild = 2 * index + 1;
            if (leftChild >= Count)
                break;
            int rightChild = leftChild + 1;
            int minChild = (rightChild < Count && comparer.Compare(elements[rightChild], elements[leftChild]) < 0)
                ? rightChild
                : leftChild;
            if (comparer.Compare(elements[index], elements[minChild]) <= 0)
                break;
            Swap(index, minChild);
            index = minChild;
        }
        return front;
    }
    private void Swap(int i, int j)
    {
        T temp = elements[i];
        elements[i] = elements[j];
        elements[j] = temp;
    }
}
public class PriorityQueue<T>
{
    private List<T> elements;
    private readonly IComparer<T> comparer;
    public PriorityQueue(IComparer<T> comparer)
    {
        this.elements = new List<T>();
        this.comparer = comparer;
    }
    public int Count => elements.Count;
    public void Enqueue(T item)
    {
        elements.Add(item);
        int index = Count - 1;
        while (index > 0)
        {
            int parentIndex = (index - 1) / 2;
            if (comparer.Compare(elements[parentIndex], elements[index]) <= 0)
                break;
            Swap(index, parentIndex);
            index = parentIndex;
        }
    }
    public T Dequeue()
    {
        if (Count == 0)
            throw new InvalidOperationException("Queue is empty.");
        T front = elements[0];
        elements[0] = elements[Count - 1];
        elements.RemoveAt(Count - 1);
        int index = 0;
        while (true)
        {
            int leftChild = 2 * index + 1;
            if (leftChild >= Count)
                break;
            int rightChild = leftChild + 1;
            int minChild = (rightChild < Count && comparer.Compare(elements[rightChild], elements[leftChild]) < 0)
                ? rightChild
                : leftChild;
            if (comparer.Compare(elements[index], elements[minChild]) <= 0)
                break;
            Swap(index, minChild);
            index = minChild;
        }
        return front;
    }
    private void Swap(int i, int j)
    {
        T temp = elements[i];
        elements[i] = elements[j];
        elements[j] = temp;
    }
}
Public Class PriorityQueue(Of T)
	Private elements As List(Of T)
	Private ReadOnly comparer As IComparer(Of T)
	Public Sub New(ByVal comparer As IComparer(Of T))
		Me.elements = New List(Of T)()
		Me.comparer = comparer
	End Sub
	Public ReadOnly Property Count() As Integer
		Get
			Return elements.Count
		End Get
	End Property
	Public Sub Enqueue(ByVal item As T)
		elements.Add(item)
		Dim index As Integer = Count - 1
		Do While index > 0
			Dim parentIndex As Integer = (index - 1) \ 2
			If comparer.Compare(elements(parentIndex), elements(index)) <= 0 Then
				Exit Do
			End If
			Swap(index, parentIndex)
			index = parentIndex
		Loop
	End Sub
	Public Function Dequeue() As T
		If Count = 0 Then
			Throw New InvalidOperationException("Queue is empty.")
		End If
		Dim front As T = elements(0)
		elements(0) = elements(Count - 1)
		elements.RemoveAt(Count - 1)
		Dim index As Integer = 0
		Do
			Dim leftChild As Integer = 2 * index + 1
			If leftChild >= Count Then
				Exit Do
			End If
			Dim rightChild As Integer = leftChild + 1
			Dim minChild As Integer = If(rightChild < Count AndAlso comparer.Compare(elements(rightChild), elements(leftChild)) < 0, rightChild, leftChild)
			If comparer.Compare(elements(index), elements(minChild)) <= 0 Then
				Exit Do
			End If
			Swap(index, minChild)
			index = minChild
		Loop
		Return front
	End Function
	Private Sub Swap(ByVal i As Integer, ByVal j As Integer)
		Dim temp As T = elements(i)
		elements(i) = elements(j)
		elements(j) = temp
	End Sub
End Class
VB   C#

IronPDF

With the help of the .NET library IronPDF, programmers may use the C# language to generate, edit, and modify PDF documents. The software offers an array of tools and features to facilitate diverse operations with PDF files, including but not limited to creating PDFs from HTML, converting HTML to PDF, combining or dividing PDF documents, and appending text, photos, and annotations to pre-existing PDFs. To know more about IronPDF refer here.

Features Of IronPDF

  • HTML to PDF conversion: IronPDF can convert any type of HTML data, such as files, URLs, and HTML code strings, into PDF documents.
  • PDF Generation: The C# programming language may be used to add text, graphics, and other objects programmatically to PDF documents.
  • PDF Manipulation: IronPDF can modify existing PDF files and split a PDF file into several files. It may combine many PDF files into a single file.
  • PDF Forms: The library is helpful in situations where form data needs to be collected and processed since it allows users to create and finish PDF forms.
  • Security Features: Password and permission security are supported by IronPDF, along with PDF document encryption.

Priority Queue with IronPDF

Now that we know the fundamentals of a priority queue, let's look at how IronPDF and it can work together to process documents more quickly. Imagine a situation where you have to produce PDF documents with different priorities or levels of urgency.

Benefits of Priority Queue with IronPDF

  • Dynamic Creation of Documents: You may dynamically produce PDF documents according to varying degrees of urgency or priority by utilizing a new priority queue.
  • Effective Workflow Management: To maximize document-generating efficiency, the priority queue makes sure that jobs with higher priority are completed before ones with lower priority.
  • Adjustable Prioritization: By changing the priority values/levels and criteria, you may quickly modify the priority queue to fit various circumstances.
  • Smooth Integration: Priority-based document generation may be easily integrated into your application by using IronPDF in conjunction with the same priority queue.
  • Scalability: The new priority queue expands as the program gets bigger and can handle more actions related to creating PDFs.

Below is the example code for the priority queue using IronPDF.

using IronPdf;
using System;
public class PdfGenerator
{
    static void Main()
    {
        // Create a priority queue of PDF tasks
        PriorityQueue<PdfTask> pdfTaskQueue = new PriorityQueue<PdfTask>(new PdfTaskComparer());
        // Enqueue PDF tasks with different priorities
        pdfTaskQueue.Enqueue(new PdfTask("High Priority Document", Priority.High));
        pdfTaskQueue.Enqueue(new PdfTask("Medium Priority Document", Priority.Medium));
        pdfTaskQueue.Enqueue(new PdfTask("Low Priority Document", Priority.Low));
        // Process PDF tasks in priority order
        while (pdfTaskQueue.Count > 0)
        {
            PdfTask nextTask = pdfTaskQueue.Dequeue();
            GeneratePdf(nextTask);
        }
    }
    static void GeneratePdf(PdfTask pdfTask)
    {
        // Create a new PDF document using IronPDF
        IronPdf.HtmlToPdf renderer = new IronPdf.HtmlToPdf();
        PdfDocument pdf = renderer.RenderHtmlAsPdf($"<h1>{pdfTask.Content}</h1>");
        // Save the PDF to a file
        string pdfFilePath = $"{pdfTask.Priority}_{Guid.NewGuid()}.pdf";
        pdf.SaveAs(pdfFilePath);
        // Display a message with the file path
        Console.WriteLine($"PDF generated successfully. File saved at: {pdfFilePath}");
    }
}
public class PdfTask
{
    public string Content { get; }
    public Priority Priority { get; }
    public PdfTask(string content, Priority priority)
    {
        Content = content;
        Priority = priority;
    }
}
public enum Priority
{
    Low,
    Medium,
    High
}
public class PdfTaskComparer : IComparer<PdfTask>
{
    public int Compare(PdfTask x, PdfTask y)
    {
        // Higher priority should come first
        return y.Priority.CompareTo(x.Priority);
    }
}
using IronPdf;
using System;
public class PdfGenerator
{
    static void Main()
    {
        // Create a priority queue of PDF tasks
        PriorityQueue<PdfTask> pdfTaskQueue = new PriorityQueue<PdfTask>(new PdfTaskComparer());
        // Enqueue PDF tasks with different priorities
        pdfTaskQueue.Enqueue(new PdfTask("High Priority Document", Priority.High));
        pdfTaskQueue.Enqueue(new PdfTask("Medium Priority Document", Priority.Medium));
        pdfTaskQueue.Enqueue(new PdfTask("Low Priority Document", Priority.Low));
        // Process PDF tasks in priority order
        while (pdfTaskQueue.Count > 0)
        {
            PdfTask nextTask = pdfTaskQueue.Dequeue();
            GeneratePdf(nextTask);
        }
    }
    static void GeneratePdf(PdfTask pdfTask)
    {
        // Create a new PDF document using IronPDF
        IronPdf.HtmlToPdf renderer = new IronPdf.HtmlToPdf();
        PdfDocument pdf = renderer.RenderHtmlAsPdf($"<h1>{pdfTask.Content}</h1>");
        // Save the PDF to a file
        string pdfFilePath = $"{pdfTask.Priority}_{Guid.NewGuid()}.pdf";
        pdf.SaveAs(pdfFilePath);
        // Display a message with the file path
        Console.WriteLine($"PDF generated successfully. File saved at: {pdfFilePath}");
    }
}
public class PdfTask
{
    public string Content { get; }
    public Priority Priority { get; }
    public PdfTask(string content, Priority priority)
    {
        Content = content;
        Priority = priority;
    }
}
public enum Priority
{
    Low,
    Medium,
    High
}
public class PdfTaskComparer : IComparer<PdfTask>
{
    public int Compare(PdfTask x, PdfTask y)
    {
        // Higher priority should come first
        return y.Priority.CompareTo(x.Priority);
    }
}
Imports IronPdf
Imports System
Public Class PdfGenerator
	Shared Sub Main()
		' Create a priority queue of PDF tasks
		Dim pdfTaskQueue As New PriorityQueue(Of PdfTask)(New PdfTaskComparer())
		' Enqueue PDF tasks with different priorities
		pdfTaskQueue.Enqueue(New PdfTask("High Priority Document", Priority.High))
		pdfTaskQueue.Enqueue(New PdfTask("Medium Priority Document", Priority.Medium))
		pdfTaskQueue.Enqueue(New PdfTask("Low Priority Document", Priority.Low))
		' Process PDF tasks in priority order
		Do While pdfTaskQueue.Count > 0
			Dim nextTask As PdfTask = pdfTaskQueue.Dequeue()
			GeneratePdf(nextTask)
		Loop
	End Sub
	Private Shared Sub GeneratePdf(ByVal pdfTask As PdfTask)
		' Create a new PDF document using IronPDF
		Dim renderer As New IronPdf.HtmlToPdf()
		Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf($"<h1>{pdfTask.Content}</h1>")
		' Save the PDF to a file
		Dim pdfFilePath As String = $"{pdfTask.Priority}_{Guid.NewGuid()}.pdf"
		pdf.SaveAs(pdfFilePath)
		' Display a message with the file path
		Console.WriteLine($"PDF generated successfully. File saved at: {pdfFilePath}")
	End Sub
End Class
Public Class PdfTask
	Public ReadOnly Property Content() As String
	Public ReadOnly Property Priority() As Priority
	Public Sub New(ByVal content As String, ByVal priority As Priority)
		Me.Content = content
		Me.Priority = priority
	End Sub
End Class
Public Enum Priority
	Low
	Medium
	High
End Enum
Public Class PdfTaskComparer
	Implements IComparer(Of PdfTask)

	Public Function Compare(ByVal x As PdfTask, ByVal y As PdfTask) As Integer Implements IComparer(Of PdfTask).Compare
		' Higher priority should come first
		Return y.Priority.CompareTo(x.Priority)
	End Function
End Class
VB   C#

In this instance, PDF jobs with varying associated priority is queued up in the priority queue (pdfTaskQueue) by the PdfGenerator class. Higher priority jobs are processed first thanks to the PriorityQueue. We are using the Enqueue method help us to add the element to the priority queue. We can also use the Dequeue method to remove and retrieve the highest priority values. We can use the peek method to view the highest priority without removing the item.

C# Priority Queue (How It Works For Developers): Figure 1

Sample output file:

C# Priority Queue (How It Works For Developers): Figure 2

Based on the content of the job, the GeneratePdf function utilizes IronPDF to build a PDF document, which is then saved to a file. To learn more about IronPDF code refer here.

Conclusion

When IronPDF and a priority queue are combined in a C# application, it is possible to generate documents quickly and dynamically according to different priorities or levels of urgency. This method works especially well in situations when some papers must be processed and provided before others.

Your application may manage document creation jobs in a flexible, scalable, and prioritized way by utilizing IronPDF's HTML to PDF conversion capabilities and integrating a priority queue for task management. The framework for integrating these ideas has been given in this article; additional customization may be used to suit the particular requirements of your document processing operations. An effective and prioritized document handling solution for C# may be obtained by combining IronPDF with a priority queue, whether you are designing a reporting tool, a document management system, or any other application that generates PDFs.

Ironpdf's $749 Lite edition includes a year of software maintenance, upgrade options, and a permanent license. Users get to evaluate the product in real-world situations during the watermarked trial period. For further information on IronPDF's cost, licensing, and free trial, see the given link. For further information about Iron Software, see this website.