AYUDA .NET

C# Queue (Cómo funciona para desarrolladores)

Regan Pun

4 de enero, 2024

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í tiene los artículos recomendados enColas en C# yClase genérica Queue en .NET.

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 los datos u objetos deben procesarse 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, utilizaremos la biblioteca PDF de C#IronPDF con la cola de C#.

2. Tipos y usos de C# Queue

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()
    {   
        // create an empty queue
        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()
    {   
        // create an empty queue
        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()
		' create an empty queue
		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

Cola C#(Cómo funciona para los desarrolladores): Figura 1 - SALIDA: Cola estándar

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, determinando también 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

Cola C# (Cómo funciona para los desarrolladores): Figura 2 - SALIDA: Cola prioritaria

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;
// Queue class
class CircularQueue
{
    private int[] array;
    private int front, rear, size;
    public CircularQueue(int size)
    {
        this.size = size;
        array = new int[size];
        front = rear = -1;
    }

    // enqueue method
    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()
    {   
        // specified initial capacity 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;
// Queue class
class CircularQueue
{
    private int[] array;
    private int front, rear, size;
    public CircularQueue(int size)
    {
        this.size = size;
        array = new int[size];
        front = rear = -1;
    }

    // enqueue method
    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()
    {   
        // specified initial capacity 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
' Queue class
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

	' enqueue method
	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()
		' specified initial capacity 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

Cola C# (Cómo funciona para los desarrolladores): Figura 3 - SALIDA: Cola circular

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 la cola de C# 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()
    {
        // Create a C# Queue to store user requests
        Queue<string> userRequests = new Queue<string>();

        // Simulate user requests being added to the queue
        userRequests.Enqueue("Generate PDF for User 1");
        userRequests.Enqueue("Generate PDF for User 2");
        userRequests.Enqueue("Generate PDF for User 3");

        // Process requests and generate PDFs
        while (userRequests.Count > 0)
        {
            string request = userRequests.Dequeue();
            GeneratePdf(request);
        }
    }
    static void GeneratePdf(string userRequest)
    {
        // Use IronPDF to generate PDF based on user request
        var Renderer = new HtmlToPdf();
        var PDF = Renderer.RenderHtmlAsPdf($"<h1>{userRequest}</h1>");

        // Save the generated PDF
        PDF.SaveAs($"{userRequest.Replace(" ", "_")}.pdf");
    }
}

using IronPdf;
using System;
using System.Collections.Generic;
class PdfGenerator
{
    static void Main()
    {
        // Create a C# Queue to store user requests
        Queue<string> userRequests = new Queue<string>();

        // Simulate user requests being added to the queue
        userRequests.Enqueue("Generate PDF for User 1");
        userRequests.Enqueue("Generate PDF for User 2");
        userRequests.Enqueue("Generate PDF for User 3");

        // Process requests and generate PDFs
        while (userRequests.Count > 0)
        {
            string request = userRequests.Dequeue();
            GeneratePdf(request);
        }
    }
    static void GeneratePdf(string userRequest)
    {
        // Use IronPDF to generate PDF based on user request
        var Renderer = new HtmlToPdf();
        var PDF = Renderer.RenderHtmlAsPdf($"<h1>{userRequest}</h1>");

        // Save the generated PDF
        PDF.SaveAs($"{userRequest.Replace(" ", "_")}.pdf");
    }
}

Imports IronPdf
Imports System
Imports System.Collections.Generic
Friend Class PdfGenerator
	Shared Sub Main()
		' Create a C# Queue to store user requests
		Dim userRequests As New Queue(Of String)()

		' Simulate user requests being added to the queue
		userRequests.Enqueue("Generate PDF for User 1")
		userRequests.Enqueue("Generate PDF for User 2")
		userRequests.Enqueue("Generate PDF for User 3")

		' Process requests and generate PDFs
		Do While userRequests.Count > 0
			Dim request As String = userRequests.Dequeue()
			GeneratePdf(request)
		Loop
	End Sub
	Private Shared Sub GeneratePdf(ByVal userRequest As String)
		' Use IronPDF to generate PDF based on user request
		Dim Renderer = New HtmlToPdf()
		Dim PDF = Renderer.RenderHtmlAsPdf($"<h1>{userRequest}</h1>")

		' Save the generated PDF
		PDF.SaveAs($"{userRequest.Replace(" ", "_")}.pdf")
	End Sub
End Class

En este ejemplo, una cola C(userRequests) se utiliza para almacenar las solicitudes de los usuarios 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. Resultado nº 1

Cola C#(Cómo funciona para los desarrolladores): Figura 4 - SALIDA 1: Generar PDF utilizando IronPDF y C# Queue

3.3. Resultado nº 2

Cola C#(Cómo funciona para los desarrolladores): Figura 5 - SALIDA 2: Generar PDF utilizando IronPDF y C# Queue

3.4. Resultado nº 3

Cola C#(Cómo funciona para los desarrolladores): Figura 6 - SALIDA 3: Generar PDF utilizando IronPDF y C# Queue

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

Para obtener información sobre licencias, visiteDetalles de la licencia de IronPDF. Para saber más sobre la conversión de HTML a PDF, visite la páginaTutorial de conversión de HTML a PDF.

Regan Pun

Chatea con el equipo de ingeniería ahora

Ingeniero de software

Regan se licenció en Ingeniería Electrónica por la Universidad de Reading. Antes de incorporarse a Iron Software, sus anteriores puestos de trabajo le obligaban a centrarse en tareas concretas; lo que más le gusta de Iron Software es la variedad de tareas que puede realizar, ya sea añadiendo valor a las ventas, el soporte técnico, el desarrollo de productos o el marketing. Le gusta entender cómo utilizan los desarrolladores la biblioteca de Iron Software y utilizar ese conocimiento para mejorar continuamente la documentación y desarrollar los productos.

< ANTERIOR
Hangfire .NET Core (Cómo Funciona para Desarrolladores)

SIGUIENTE >
C# Case Statement (Cómo funciona para los desarrolladores)