C# Priority Queue (How It Works For Developers)

using System;
using System.Collections.Generic;

public class PriorityQueue<T>
{
    private List<T> elements;
    private readonly IComparer<T> comparer;

    // Constructor that sets up the priority queue with a specific comparer
    public PriorityQueue(IComparer<T> comparer)
    {
        this.elements = new List<T>();
        this.comparer = comparer;
    }

    // Property to get the number of elements in the queue
    public int Count => elements.Count;

    // Method to add an element to the priority queue
    public void Enqueue(T item)
    {
        elements.Add(item);
        int index = Count - 1;

        // Bubble up the newly added item to maintain heap property
        while (index > 0)
        {
            int parentIndex = (index - 1) / 2;
            if (comparer.Compare(elements[parentIndex], elements[index]) <= 0)
                break;
            Swap(index, parentIndex);
            index = parentIndex;
        }
    }

    // Method to remove and return the element with the highest priority
    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);

        // Push down the root element to maintain heap property
        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;
    }

    // Helper method to swap elements in the list
    private void Swap(int i, int j)
    {
        T temp = elements[i];
        elements[i] = elements[j];
        elements[j] = temp;
    }
}

Imports System
Imports System.Collections.Generic

Public Class PriorityQueue(Of T)
	Private elements As List(Of T)
	Private ReadOnly comparer As IComparer(Of T)

	' Constructor that sets up the priority queue with a specific comparer
	Public Sub New(ByVal comparer As IComparer(Of T))
		Me.elements = New List(Of T)()
		Me.comparer = comparer
	End Sub

	' Property to get the number of elements in the queue
	Public ReadOnly Property Count() As Integer
		Get
			Return elements.Count
		End Get
	End Property

	' Method to add an element to the priority queue
	Public Sub Enqueue(ByVal item As T)
		elements.Add(item)
		Dim index As Integer = Count - 1

		' Bubble up the newly added item to maintain heap property
		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

	' Method to remove and return the element with the highest priority
	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)

		' Push down the root element to maintain heap property
		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

	' Helper method to swap elements in the list
	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

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

public class PdfGenerator
{
    static void Main()
    {
        // Create a priority queue for 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 order of their priority
        while (pdfTaskQueue.Count > 0)
        {
            PdfTask nextTask = pdfTaskQueue.Dequeue();
            GeneratePdf(nextTask);
        }
    }

    // Generate PDF document using IronPDF
    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 confirmation message
        Console.WriteLine($"PDF generated successfully. File saved at: {pdfFilePath}");
    }
}

// Class to define a PDF task
public class PdfTask
{
    public string Content { get; }
    public Priority Priority { get; }

    public PdfTask(string content, Priority priority)
    {
        Content = content;
        Priority = priority;
    }
}

// Enum to define priority levels
public enum Priority
{
    Low,
    Medium,
    High
}

// Comparer to compare PDF tasks based on their priority
public class PdfTaskComparer : IComparer<PdfTask>
{
    public int Compare(PdfTask x, PdfTask y)
    {
        // Prioritize higher priority tasks
        return y.Priority.CompareTo(x.Priority);
    }
}

Imports IronPdf
Imports System
Imports System.Collections.Generic

Public Class PdfGenerator
	Shared Sub Main()
		' Create a priority queue for 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 order of their priority
		Do While pdfTaskQueue.Count > 0
			Dim nextTask As PdfTask = pdfTaskQueue.Dequeue()
			GeneratePdf(nextTask)
		Loop
	End Sub

	' Generate PDF document using IronPDF
	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 confirmation message
		Console.WriteLine($"PDF generated successfully. File saved at: {pdfFilePath}")
	End Sub
End Class

' Class to define a PDF task
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

' Enum to define priority levels
Public Enum Priority
	Low
	Medium
	High
End Enum

' Comparer to compare PDF tasks based on their priority
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
		' Prioritize higher priority tasks
		Return y.Priority.CompareTo(x.Priority)
	End Function
End Class