AYUDA .NET

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

Actualizado 18 de febrero, 2024
Compartir:

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 c# junto con IronPDF.

Cómo utilizar C# Cola prioritaria

  1. Cree un nuevo proyecto c# y cree un objeto Priority Queue.
  2. Poner en cola elementos con prioridades.
  3. Dequeue Elemento con mayor prioridad.
  4. Eche un vistazo al elemento de mayor prioridad.
  5. Compruebe si la cola prioritaria está vacía.
  6. 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) 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.

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 más información sobre IronPDF aquí.

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 finalizar 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()
    {
        //  Crear una cola prioritaria de tareas PDF
        PriorityQueue<PdfTask> pdfTaskQueue = new PriorityQueue<PdfTask>(new PdfTaskComparer());
        //  Poner en cola tareas PDF con distintas prioridades
        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));
        //  Procesar tareas PDF por orden de prioridad
        while (pdfTaskQueue.Count > 0)
        {
            PdfTask nextTask = pdfTaskQueue.Dequeue();
            GeneratePdf(nextTask);
        }
    }
    static void GeneratePdf(PdfTask pdfTask)
    {
        //  Crear un nuevo documento PDF con IronPDF
        IronPdf.HtmlToPdf renderer = new IronPdf.HtmlToPdf();
        PdfDocument pdf = renderer.RenderHtmlAsPdf($"<h1>{pdfTask.Content}</h1>");
        //  Guardar el PDF en un archivo
        string pdfFilePath = $"{pdfTask.Priority}_{Guid.NewGuid()}.pdf";
        pdf.SaveAs(pdfFilePath);
        //  Mostrar un mensaje con la ruta del archivo
        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)
    {
        //  La mayor prioridad debe ser lo primero
        return y.Priority.CompareTo(x.Priority);
    }
}
using IronPdf;
using System;
public class PdfGenerator
{
    static void Main()
    {
        //  Crear una cola prioritaria de tareas PDF
        PriorityQueue<PdfTask> pdfTaskQueue = new PriorityQueue<PdfTask>(new PdfTaskComparer());
        //  Poner en cola tareas PDF con distintas prioridades
        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));
        //  Procesar tareas PDF por orden de prioridad
        while (pdfTaskQueue.Count > 0)
        {
            PdfTask nextTask = pdfTaskQueue.Dequeue();
            GeneratePdf(nextTask);
        }
    }
    static void GeneratePdf(PdfTask pdfTask)
    {
        //  Crear un nuevo documento PDF con IronPDF
        IronPdf.HtmlToPdf renderer = new IronPdf.HtmlToPdf();
        PdfDocument pdf = renderer.RenderHtmlAsPdf($"<h1>{pdfTask.Content}</h1>");
        //  Guardar el PDF en un archivo
        string pdfFilePath = $"{pdfTask.Priority}_{Guid.NewGuid()}.pdf";
        pdf.SaveAs(pdfFilePath);
        //  Mostrar un mensaje con la ruta del archivo
        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)
    {
        //  La mayor prioridad debe ser lo primero
        return y.Priority.CompareTo(x.Priority);
    }
}
Imports IronPdf
Imports System
Public Class PdfGenerator
	Shared Sub Main()
		'  Crear una cola prioritaria de tareas PDF
		Dim pdfTaskQueue As New PriorityQueue(Of PdfTask)(New PdfTaskComparer())
		'  Poner en cola tareas PDF con distintas prioridades
		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))
		'  Procesar tareas PDF por orden de prioridad
		Do While pdfTaskQueue.Count > 0
			Dim nextTask As PdfTask = pdfTaskQueue.Dequeue()
			GeneratePdf(nextTask)
		Loop
	End Sub
	Private Shared Sub GeneratePdf(ByVal pdfTask As PdfTask)
		'  Crear un nuevo documento PDF con IronPDF
		Dim renderer As New IronPdf.HtmlToPdf()
		Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf($"<h1>{pdfTask.Content}</h1>")
		'  Guardar el PDF en un archivo
		Dim pdfFilePath As String = $"{pdfTask.Priority}_{Guid.NewGuid()}.pdf"
		pdf.SaveAs(pdfFilePath)
		'  Mostrar un mensaje con la ruta del archivo
		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
		'  La mayor prioridad debe ser lo primero
		Return y.Priority.CompareTo(x.Priority)
	End Function
End Class
VB   C#

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.

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 construir un documento PDF, que luego se guarda en un archivo. Para obtener más información sobre el código IronPDF, consulte aquí.

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 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.

< ANTERIOR
C# LINQ Distinct (Cómo funciona para desarrolladores)
SIGUIENTE >
C# Sealed Class (Cómo funciona para los desarrolladores)

¿Listo para empezar? Versión: 2024.6 recién publicada

Comenzar prueba gratuita Descargas totales: 9,541,998
Ver licencias >