AYUDA .NET

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

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

Chipego Kalinda

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 utilizar C# Cola prioritaria

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 de prioridad es que permite la recuperación eficiente, ya que el elemento con la mayor prioridad (o el valor de prioridad más bajo, dependiendo de la implementación) siempre está 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#, puedes crear una tú mismo o utilizar bibliotecas de terceros que ofrecen 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#

Orden de 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 de prioridad te permiten usar clases de comparer 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 la mayor prioridad—o la menor, dependiendo de cómo esté implementado—requiere una cantidad de tiempo constante. Esto es especialmente útil para algoritmos que necesitan obtener rápidamente la parte 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

$vbLabelText $csharpLabel

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 saber más sobre IronPDF, consulte la Documentación de IronPDF.

La característica principal de IronPDF es su función de Conversió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

$vbLabelText $csharpLabel

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# se puede utilizar para agregar texto, gráficos y otros objetos programáticamente 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 donde se necesita recopilar y procesar datos de formularios, ya que permite a los usuarios crear y completar formularios PDF.
Características de seguridad: IronPDF admite la seguridad de contraseñas y permisos, junto 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: Puede producir documentos PDF dinámicamente según distintos grados de urgencia o prioridad utilizando una nueva cola de prioridades.
Gestión Efectiva del Flujo de Trabajo: Para maximizar la eficiencia de generación de documentos, la cola de prioridad asegura que los trabajos con mayor prioridad se completen antes que aquellos con menor prioridad.
Priorización Ajustable: Al cambiar los valores/niveles de prioridad y criterios, puede modificar rápidamente la cola de prioridades para adaptarse a diversas circunstancias.
Integración fluida: La generación de documentos basada en prioridades puede integrarse fácilmente en su aplicación utilizando IronPDF en conjunto con la misma cola de prioridad.
Escalabilidad: La nueva cola de prioridades se expande a medida que el programa crece y puede manejar más acciones relacionadas con la creación de PDFs.
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

$vbLabelText $csharpLabel

En este caso, los trabajos PDF con prioridades asociadas variables se encolan 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 Prioridad en C# (Cómo Funciona para los Desarrolladores): Figura 1

Archivo de salida de ejemplo:

Cola de Prioridad en C# (Cómo Funciona para Desarrolladores): Figura 2

Basado en el contenido del trabajo, la función GeneratePdf utiliza IronPDF para construir un documento PDF, que posteriormente se guarda en un archivo. Para obtener más información sobre el código de IronPDF, consulte los Ejemplos de IronPDF de HTML a PDF.

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 de $749 de IronPDF incluye un año de mantenimiento de 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 costo, licencias y prueba gratuita de IronPDF, consulte la Información de Licencias de IronPDF. Para obtener más información sobre Iron Software, visite el Sitio web de Iron Software.

Chipego Kalinda

Chatea con el equipo de ingeniería ahora

Ingeniero de software

Chipego tiene una habilidad natural para escuchar que le ayuda a comprender los problemas de los clientes y a ofrecer soluciones inteligentes. Se unió al equipo de Iron Software en 2023, después de estudiar una licenciatura en Tecnología de la Información. IronPDF e IronOCR son los dos productos en los que Chipego se ha centrado, pero su conocimiento de todos los productos crece día a día, a medida que encuentra nuevas formas de ayudar a los clientes. Disfruta de lo colaborativa que es la vida en Iron Software, con miembros del equipo de toda la empresa que aportan su variada experiencia para contribuir a soluciones eficaces e innovadoras. Cuando Chipego está lejos de su escritorio, a menudo se le puede encontrar disfrutando de un buen libro o jugando al fútbol.

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

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