AYUDA .NET

Cola de prioridades en C# (Cómo funciona para desarrolladores)

Publicado en 18 de febrero, 2024

Introducción

La programación en C# es bastante flexible, e IronPDF es una potente biblioteca que facilita el trabajo con documentos, especialmente a la hora de crear y modificar archivos PDF. Este post explicará la idea de una cola de prioridad en C# y le mostrará cómo utilizarla eficazmente con IronPDF para optimizar los procedimientos de procesamiento de documentos. En el artículo, vamos a utilizar la cola de prioridad de C# junto con IronPDF.

Cómo usar la cola de prioridades en C

Cree un nuevo proyecto en C# y cree un objeto Priority Queue.
Ponga en cola elementos con prioridades.
Elemento de cola con mayor prioridad.
Eche un vistazo al elemento de mayor prioridad.
Compruebe si la cola de prioridades está vacía.
Ejecuta el código y deshazte de los objetos.

Cola prioritaria

Una estructura de datos llamada cola de prioridad lleva la cuenta de varios componentes, cada uno de los cuales tiene asignada una prioridad. La característica esencial de una cola prioritaria es que permite una recuperación eficaz, ya que el elemento con mayor prioridad(o el valor de prioridad más bajo, en función de la aplicación) está siempre al frente. En situaciones en las que las tareas o los elementos deben tratarse en una secuencia determinada según su prioridad, se utilizan con frecuencia las colas de prioridad.

Aunque no existe una clase PriorityQueue en la biblioteca estándar de C#, puede crear una usted mismo o utilizar bibliotecas de terceros que ofrezcan esta estructura de datos. El array heap tiene una capacidad inicial, y se forma un nuevo heap con mayor capacidad cuando se llena, e intentamos poner en cola un nuevo elemento. Dos componentes se sirven en el mismo orden en que se pusieron en cola si comparten la misma prioridad. Para evitar situaciones de carrera, necesita desarrollar su propio código para manejar la seguridad de los hilos.

Cuando los componentes tienen prioridades correspondientes y deben manejarse de acuerdo con esas prioridades, una cola de prioridad en C# ofrece varias ventajas.

A continuación se enumeran algunas ventajas de emplear una cola prioritaria en C#

Ordenación por prioridad: Los elementos se mantienen automáticamente en orden según su prioridad utilizando una cola de prioridad. Esto hace que el procesamiento basado en prioridades sea más eficiente al garantizar que los componentes con prioridades más altas se traten antes que los que tienen prioridades más bajas.
Comparaciones personalizables: Las colas prioritarias permiten utilizar clases comparadoras personalizadas o construir comparaciones personalizadas, lo que hace posible ordenar los datos según estándares intrincados. Esto resulta útil cuando se trabaja con objetos que tienen varias características o una lógica de prioridad personalizada.
Recuperación rápida: En la mayoría de los casos, recuperar el elemento con mayor prioridad -o menor, dependiendo de cómo se implemente- requiere una cantidad de tiempo consistente. Esto es especialmente útil para los algoritmos que necesitan obtener rápidamente el elemento más importante.

Implementación de una cola prioritaria en C#

Utilicemos un montón binario para construir un sistema básico de colas prioritarias en C#. Tenga en cuenta que puede que desee aprovechar bibliotecas preexistentes o pensar en un enfoque más complejo para su uso en producción.

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

Con la ayuda de la biblioteca .NET IronPDF, los programadores pueden utilizar el lenguaje C# para generar, editar y modificar documentos PDF. El software ofrece una amplia gama de herramientas y funciones para facilitar diversas operaciones con archivos PDF, entre las que se incluyen la creación de PDF a partir de HTML, la conversión de HTML a PDF, la combinación o división de documentos PDF y la adición de texto, fotos y anotaciones a PDF preexistentes. Para obtener más información sobre IronPDF, consulte la página webDocumentación en IronPDF.

La principal característica de IronPDF es suConversión de HTML a PDF que mantiene los diseños y estilos. Convierte contenidos web en PDF, ideales para informes, facturas y documentación. Esto incluye la conversión de archivos HTML, URL y cadenas HTML a PDF.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

VB C#

Características de IronPDF

Conversión de HTML a PDF: IronPDF puede convertir cualquier tipo de datos HTML, como archivos, URL y cadenas de código HTML, en documentos PDF.
Generación de PDF: El lenguaje de programación C# puede utilizarse para añadir texto, gráficos y otros objetos mediante programación a documentos PDF.
Manipulación de PDF: IronPDF puede modificar archivos PDF existentes y dividir un archivo PDF en varios archivos. Puede combinar muchos archivos PDF en un único archivo.
Formularios PDF: La biblioteca es útil en situaciones en las que es necesario recopilar y procesar datos de formularios, ya que permite a los usuarios crear y rellenar formularios PDF.
Funciones de seguridad: IronPDF es compatible con la seguridad de contraseñas y permisos, así como con el cifrado de documentos PDF.

Cola prioritaria con IronPDF

Ahora que conocemos los fundamentos de una cola prioritaria, veamos cómo IronPDF y ésta pueden trabajar juntos para procesar documentos más rápidamente. Imagine una situación en la que tiene que producir documentos PDF con diferentes prioridades o niveles de urgencia.

Ventajas de la cola prioritaria con IronPDF

Creación dinámica de documentos: Podrá producir documentos PDF de forma dinámica según distintos grados de urgencia o prioridad utilizando una nueva cola de prioridad.
Gestión eficaz del flujo de trabajo: Para maximizar la eficiencia en la generación de documentos, la cola de prioridad se asegura de que los trabajos con mayor prioridad se completen antes que los de menor prioridad.
Priorización ajustable: Cambiando los valores/niveles de prioridad y los criterios, puede modificar rápidamente la cola de prioridades para adaptarla a diversas circunstancias.
Integración sencilla: La generación de documentos basada en prioridades puede integrarse fácilmente en su aplicación utilizando IronPDF junto con la misma cola de prioridades.
Escalabilidad: La nueva cola de prioridad se expande a medida que el programa crece y puede gestionar más acciones relacionadas con la creación de PDF.
A continuación se muestra el código de ejemplo para la cola de prioridad utilizando 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#

En este caso, los trabajos PDF con distintas prioridades asociadas se ponen en cola en la cola de prioridad(pdfTaskQueue) por la clase PdfGenerator. Los trabajos de mayor prioridad se procesan primero gracias a la PriorityQueue. Utilizamos el método Enqueue para añadir el elemento a la cola de prioridad. También podemos utilizar el método Dequeue para eliminar y recuperar los valores de mayor prioridad. Podemos utilizar el método peek para ver la prioridad más alta sin eliminar el elemento.

Cola de prioridades en C#(Cómo funciona para los desarrolladores): Figura 1

Archivo de salida de ejemplo:

Cola de prioridades en C#(Cómo funciona para los desarrolladores): Figura 2

Basándose en el contenido del trabajo, la función GeneratePdf utiliza IronPDF para crear un documento PDF, que luego se guarda en un archivo. Para obtener más información sobre el código IronPDF, consulte el documentoEjemplos de conversión de HTML a PDF de IronPDF.

Conclusión

Cuando IronPDF y una cola de prioridad se combinan en una aplicación C#, es posible generar documentos de forma rápida y dinámica según diferentes prioridades o niveles de urgencia. Este método funciona especialmente bien en situaciones en las que algunos documentos deben procesarse y entregarse antes que otros.

Su aplicación puede gestionar los trabajos de creación de documentos de forma flexible, escalable y priorizada utilizando las capacidades de conversión de HTML a PDF de IronPDF e integrando una cola de prioridad para la gestión de tareas. En este artículo se ofrece el marco para integrar estas ideas; puede recurrirse a una personalización adicional para adaptarse a las necesidades particulares de sus operaciones de tratamiento de documentos. Combinando IronPDF con una cola de prioridad se puede obtener una solución eficaz y priorizada de gestión de documentos para C#, tanto si está diseñando una herramienta de generación de informes, un sistema de gestión de documentos o cualquier otra aplicación que genere archivos PDF.

La edición Lite $749 de IronPDF incluye un año de mantenimiento del software, opciones de actualización y una licencia permanente. Los usuarios pueden evaluar el producto en situaciones reales durante el periodo de prueba con marca de agua. Para obtener más información sobre el coste, la licencia y la versión de prueba gratuita de IronPDF, consulte el sitio web**Información sobre licencias IronPDF. Para más información sobre Iron Software, consulte la página web**Sitio web de Iron Software.

< ANTERIOR
C# LINQ Distinct (Cómo funciona para desarrolladores)

SIGUIENTE >
C# Sealed Class (Cómo funciona para los desarrolladores)