C# Queue (Cómo funciona para desarrolladores)

1. Introducción

En el ámbito de la programación, el tratamiento eficaz de los datos es la piedra angular del éxito en el desarrollo de software. Una estructura de datos esencial que desempeña un papel crucial en la gestión y organización de la información es la cola. En el contexto de C#, un lenguaje de programación potente y versátil, la cola de C# destaca como una herramienta fundamental para gestionar datos de forma secuencial. Para saber más sobre las Colas en C# aquí están los artículos recomendados aquí y aquí.

Una cola sigue el principio de "primero en entrar, primero en salir (FIFO) donde el primer elemento que se añade es el primero que se elimina. Esta característica lo hace especialmente útil en escenarios en los que es necesario procesar datos u objetos en un orden específico, como la gestión de tareas de forma sistemática o la gestión de peticiones en un servidor web.

En este artículo vamos a utilizar C# PDF Library IronPDF con la cola de C#.

2. Tipos y usos de C# Cola de espera

2.1. Cola estándar

La cola estándar en C# es una clase genérica que permite a los desarrolladores crear una cola de cualquier tipo de datos. Proporciona métodos como Enqueue para añadir elementos al objeto especificado al principio o al final de la cola y Dequeue para eliminar elementos del frente. Este tipo de cola se utiliza ampliamente en escenarios en los que el procesamiento de datos sigue un orden estricto, garantizando la equidad en la asignación de recursos.

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {   //  crear una cola vacía
        Queue<int> standardQueue = new Queue<int>();
        standardQueue.Enqueue(10);
        standardQueue.Enqueue(20);
        standardQueue.Enqueue(30);
        while (standardQueue.Count > 0)
        {
            int element = standardQueue.Dequeue();
            Console.WriteLine($"Dequeued: {element}");
        }}}

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {   //  crear una cola vacía
        Queue<int> standardQueue = new Queue<int>();
        standardQueue.Enqueue(10);
        standardQueue.Enqueue(20);
        standardQueue.Enqueue(30);
        while (standardQueue.Count > 0)
        {
            int element = standardQueue.Dequeue();
            Console.WriteLine($"Dequeued: {element}");
        }}}

Imports System
Imports System.Collections.Generic
Friend Class Program
	Shared Sub Main() '  crear una cola vacía
		Dim standardQueue As New Queue(Of Integer)()
		standardQueue.Enqueue(10)
		standardQueue.Enqueue(20)
		standardQueue.Enqueue(30)
		Do While standardQueue.Count > 0
			Dim element As Integer = standardQueue.Dequeue()
			Console.WriteLine($"Dequeued: {element}")
		Loop
	End Sub
End Class

Salida

2.2. Cola prioritaria

En determinadas situaciones, la priorización de elementos en la cola resulta crucial. C# no tiene una cola de prioridad incorporada, pero los desarrolladores pueden implementarla utilizando una colección ordenada o una estructura de datos personalizada. Este tipo de cola es beneficioso cuando determinados elementos deben procesarse antes que otros en función de criterios específicos, como la urgencia o la importancia. Comprueba si el elemento existe y utiliza el estilo FIFO para disponer el elemento más antiguo al final de la cola, también determina si un elemento debe ser el principio de la cola en función del número de elementos que contenga.

using System;
using System.Collections.Generic;
class Program
{    static void Main()
    {
        SortedSet<int> priorityQueue = new SortedSet<int>();
        priorityQueue.Add(30);
        priorityQueue.Add(10);
        priorityQueue.Add(20);
        while (priorityQueue.Count > 0)
        {
            int element = priorityQueue.Min;
            priorityQueue.Remove(element);
            Console.WriteLine($"Priority Queue Dequeued: {element}");
        }
    }
}

using System;
using System.Collections.Generic;
class Program
{    static void Main()
    {
        SortedSet<int> priorityQueue = new SortedSet<int>();
        priorityQueue.Add(30);
        priorityQueue.Add(10);
        priorityQueue.Add(20);
        while (priorityQueue.Count > 0)
        {
            int element = priorityQueue.Min;
            priorityQueue.Remove(element);
            Console.WriteLine($"Priority Queue Dequeued: {element}");
        }
    }
}

Imports System
Imports System.Collections.Generic
Friend Class Program
	Shared Sub Main()
		Dim priorityQueue As New SortedSet(Of Integer)()
		priorityQueue.Add(30)
		priorityQueue.Add(10)
		priorityQueue.Add(20)
		Do While priorityQueue.Count > 0
			Dim element As Integer = AddressOf priorityQueue.Min
			priorityQueue.Remove(element)
			Console.WriteLine($"Priority Queue Dequeued: {element}")
		Loop
	End Sub
End Class

2.3. Cola circular

Una cola circular es una variante en la que el último elemento está conectado al primero, creando una estructura circular. Esto puede ser ventajoso en escenarios en los que la cola tiene un tamaño fijo, y los elementos antiguos de la cola deben ser sustituidos por otros nuevos de forma cíclica. La implementación de una cola circular en C# puede optimizar el uso de la memoria y garantizar un procesamiento eficaz de los datos.

using System;
//  Clase de cola
class CircularQueue
{
    private int [] array;
    private int front, rear, size;
    public CircularQueue(int size)
    {
        this.size = size;
        array = new int [size];
        front = rear = -1;
    }
    //  método enqueue
    public void Enqueue(int item)
    {
        if ((front == 0 && rear == size - 1) 
 (rear == (front - 1) % (size - 1)))
        {
            Console.WriteLine("Queue is full");
            return;
        }
        else if (front == -1)
        {
            front = rear = 0;
            array [rear] = item;
        }
        else if (rear == size - 1 && front != 0)
        {
            rear = 0;
            array [rear] = item;
        }
        else
        {
            rear++;
            array [rear] = item;
        }
    }
    public int Dequeue()
    {
        if (front == -1)
        {
            Console.WriteLine("Queue is empty");
            return -1;
        }
        int item = array [front];
        array [front] = -1;
        if (front == rear)
            front = rear = -1;
        else if (front == size - 1)
            front = 0;
        else
            front++;
        return item;
    }
}
class Program
{
    static void Main()
    {   //  capacidad inicial especificada 5
        CircularQueue circularQueue = new CircularQueue(5);
        circularQueue.Enqueue(10);
        circularQueue.Enqueue(20);
        circularQueue.Enqueue(30);
        Console.WriteLine($"Circular Queue Dequeued: {circularQueue.Dequeue()}");
        Console.WriteLine($"Circular Queue Dequeued: {circularQueue.Dequeue()}");
    }
}

using System;
//  Clase de cola
class CircularQueue
{
    private int [] array;
    private int front, rear, size;
    public CircularQueue(int size)
    {
        this.size = size;
        array = new int [size];
        front = rear = -1;
    }
    //  método enqueue
    public void Enqueue(int item)
    {
        if ((front == 0 && rear == size - 1) 
 (rear == (front - 1) % (size - 1)))
        {
            Console.WriteLine("Queue is full");
            return;
        }
        else if (front == -1)
        {
            front = rear = 0;
            array [rear] = item;
        }
        else if (rear == size - 1 && front != 0)
        {
            rear = 0;
            array [rear] = item;
        }
        else
        {
            rear++;
            array [rear] = item;
        }
    }
    public int Dequeue()
    {
        if (front == -1)
        {
            Console.WriteLine("Queue is empty");
            return -1;
        }
        int item = array [front];
        array [front] = -1;
        if (front == rear)
            front = rear = -1;
        else if (front == size - 1)
            front = 0;
        else
            front++;
        return item;
    }
}
class Program
{
    static void Main()
    {   //  capacidad inicial especificada 5
        CircularQueue circularQueue = new CircularQueue(5);
        circularQueue.Enqueue(10);
        circularQueue.Enqueue(20);
        circularQueue.Enqueue(30);
        Console.WriteLine($"Circular Queue Dequeued: {circularQueue.Dequeue()}");
        Console.WriteLine($"Circular Queue Dequeued: {circularQueue.Dequeue()}");
    }
}

Imports System
'  Clase de cola
Friend Class CircularQueue
	Private array() As Integer
	Private front, rear, size As Integer
	Public Sub New(ByVal size As Integer)
		Me.size = size
		array = New Integer (size - 1){}
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: front = rear = -1;
		rear = -1
		front = rear
	End Sub
	'  método enqueue
	Public Sub Enqueue(ByVal item As Integer)
		If (front = 0 AndAlso rear = size - 1)(rear = (front - 1) Mod (size - 1)) Then
			Console.WriteLine("Queue is full")
			Return
		ElseIf front = -1 Then
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: front = rear = 0;
			rear = 0
			front = rear
			array (rear) = item
		ElseIf rear = size - 1 AndAlso front <> 0 Then
			rear = 0
			array (rear) = item
		Else
			rear += 1
			array (rear) = item
		End If
	End Sub
	Public Function Dequeue() As Integer
		If front = -1 Then
			Console.WriteLine("Queue is empty")
			Return -1
		End If
		Dim item As Integer = array (front)
		array (front) = -1
		If front = rear Then
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: front = rear = -1;
			rear = -1
			front = rear
		ElseIf front = size - 1 Then
			front = 0
		Else
			front += 1
		End If
		Return item
	End Function
End Class
Friend Class Program
	Shared Sub Main() '  capacidad inicial especificada 5
		Dim circularQueue As New CircularQueue(5)
		circularQueue.Enqueue(10)
		circularQueue.Enqueue(20)
		circularQueue.Enqueue(30)
		Console.WriteLine($"Circular Queue Dequeued: {circularQueue.Dequeue()}")
		Console.WriteLine($"Circular Queue Dequeued: {circularQueue.Dequeue()}")
	End Sub
End Class

3. Presentación de IronPDF en C#

A medida que nos adentramos en las funcionalidades y aplicaciones de la cola de C#, es esencial explorar cómo puede integrarse perfectamente en aplicaciones del mundo real. Una de estas potentes herramientas que mejora las capacidades de C# es IronPDF.

IronPDF es una biblioteca C# que simplifica la creación, manipulación y representación de documentos PDF. Su intuitiva API permite a los desarrolladores generar PDF a partir de HTML, ASPX o incluso texto sin formato. Con IronPDF, el proceso de incorporación de C# Queue a una aplicación generadora de PDF se vuelve más ágil y eficaz.

3.1. Uso de C# Cola con código IronPDF

Echemos un vistazo más de cerca a cómo se puede utilizar C# Queue junto con IronPDF para crear documentos PDF dinámicos y organizados. Consideremos un escenario en el que una aplicación web necesita generar un informe PDF basado en las entradas y peticiones del usuario.

using IronPdf;
using System;
using System.Collections.Generic;
class PdfGenerator
{
    static void Main()
    {
        //  Crear una cola en C# para almacenar las solicitudes de los usuarios
        Queue<string> userRequests = new Queue<string>();
        //  Simular las solicitudes de los usuarios que se añaden a la cola
        userRequests.Enqueue("Generate PDF for User 1");
        userRequests.Enqueue("Generate PDF for User 2");
        userRequests.Enqueue("Generate PDF for User 3");
        //  Tramitar solicitudes y generar PDF
        while (userRequests.Count > 0)
        {
            string request = userRequests.Dequeue();
            GeneratePdf(request);
        }
    }
    static void GeneratePdf(string userRequest)
    {
        //  Utilizar IronPDF para generar PDF a petición del usuario
        var Renderer = new HtmlToPdf();
        var PDF = Renderer.RenderHtmlAsPdf($"<h1>{userRequest}</h1>");
        //  Guardar el PDF generado
        PDF.SaveAs($"{userRequest.Replace(" ", "_")}.pdf");
    }
}

using IronPdf;
using System;
using System.Collections.Generic;
class PdfGenerator
{
    static void Main()
    {
        //  Crear una cola en C# para almacenar las solicitudes de los usuarios
        Queue<string> userRequests = new Queue<string>();
        //  Simular las solicitudes de los usuarios que se añaden a la cola
        userRequests.Enqueue("Generate PDF for User 1");
        userRequests.Enqueue("Generate PDF for User 2");
        userRequests.Enqueue("Generate PDF for User 3");
        //  Tramitar solicitudes y generar PDF
        while (userRequests.Count > 0)
        {
            string request = userRequests.Dequeue();
            GeneratePdf(request);
        }
    }
    static void GeneratePdf(string userRequest)
    {
        //  Utilizar IronPDF para generar PDF a petición del usuario
        var Renderer = new HtmlToPdf();
        var PDF = Renderer.RenderHtmlAsPdf($"<h1>{userRequest}</h1>");
        //  Guardar el PDF generado
        PDF.SaveAs($"{userRequest.Replace(" ", "_")}.pdf");
    }
}

Imports IronPdf
Imports System
Imports System.Collections.Generic
Friend Class PdfGenerator
	Shared Sub Main()
		'  Crear una cola en C# para almacenar las solicitudes de los usuarios
		Dim userRequests As New Queue(Of String)()
		'  Simular las solicitudes de los usuarios que se añaden a la cola
		userRequests.Enqueue("Generate PDF for User 1")
		userRequests.Enqueue("Generate PDF for User 2")
		userRequests.Enqueue("Generate PDF for User 3")
		'  Tramitar solicitudes y generar PDF
		Do While userRequests.Count > 0
			Dim request As String = userRequests.Dequeue()
			GeneratePdf(request)
		Loop
	End Sub
	Private Shared Sub GeneratePdf(ByVal userRequest As String)
		'  Utilizar IronPDF para generar PDF a petición del usuario
		Dim Renderer = New HtmlToPdf()
		Dim PDF = Renderer.RenderHtmlAsPdf($"<h1>{userRequest}</h1>")
		'  Guardar el PDF generado
		PDF.SaveAs($"{userRequest.Replace(" ", "_")}.pdf")
	End Sub
End Class

En este ejemplo, una cola C (userRequests) devuelve el objeto utilizado para almacenar las solicitudes de usuario para la generación de PDF. El método GeneratePdf toma una petición del usuario, utiliza IronPDF para convertir el contenido HTML en un documento PDF, y guarda el archivo PDF generado con un nombre relevante.

Este método de integración también muestra la sinergia entre C# Queue e IronPDF, donde el procesamiento ordenado de las solicitudes de los usuarios da como resultado la creación sistemática de documentos PDF.

3.2. Salida # 1

3.3. Salida # 2

3.4. Salida # 3

4. Conclusión

En conclusión, la cola de C# demuestra ser un activo valioso para gestionar y procesar datos de forma secuencial. Su adhesión al principio FIFO lo hace adecuado para una amplia gama de aplicaciones, desde la programación de tareas a la gestión de peticiones en servidores web. Cuando se combina con potentes bibliotecas como IronPDF C# Queue se vuelve aún más potente, permitiendo a los desarrolladores crear documentos PDF organizados y dinámicos de forma eficaz.

Comprender los matices de C# Queue y explorar su integración con herramientas como IronPDF permite a los desarrolladores diseñar soluciones sólidas y eficaces para la gestión y el procesamiento de datos. A medida que la tecnología siga evolucionando, la sinergia entre estructuras de datos fundamentales como la cola de C# y bibliotecas innovadoras desempeñará un papel fundamental en la configuración del panorama del desarrollo de software.

IronPDF. Para obtener más información sobre la conversión de HTML a PDF, visite la siguiente página web enlace.