Pruebas en un entorno real
Pruebe en producción sin marcas de agua.
Funciona donde lo necesites.
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 c# junto con IronPDF.
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) la prioridad siempre está en el 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.
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.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
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 más información sobre IronPDF aquí.
La principal característica de IronPDF es su 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
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.
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
En este caso, los trabajos PDF con prioridad asociada variable 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
. Estamos utilizando el método Enqueue nos ayuda a 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.
Archivo de salida de ejemplo:
Basándose en el contenido del trabajo, la función GeneratePdf
utiliza IronPDF para construir un documento PDF, que luego se guarda en un archivo. Para obtener más información sobre el código IronPDF, consulte aquí.
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 Ironpdf $749 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 la siguiente dirección enlace. Para más información sobre Iron Software, consulte sitio web.
9 productos API .NET para sus documentos de oficina