AIDE .NET

File d'attente C# (Comment ça marche pour les développeurs)

Kannapat Udonpant

janvier 4, 2024

1. Introduction

Dans le domaine de la programmation, le traitement efficace des données est la pierre angulaire d'un développement logiciel réussi. La file d'attente est une structure de données essentielle qui joue un rôle crucial dans la gestion et l'organisation des informations. Dans le contexte de C#, un langage de programmation puissant et polyvalent, la file d'attente C# se distingue comme un outil fondamental pour la gestion séquentielle des données. Pour en savoir plus sur les files d'attente en C#, voici les articles recommandés sur Files d'attente en C# etClasse de file d'attente générique dans .NET.

Une file d'attente suit le principe du "premier entré, premier sorti"(FIFO) où le premier élément ajouté est le premier à être retiré. Cette caractéristique le rend particulièrement utile dans les scénarios où les données ou les objets doivent être traités dans un ordre spécifique, comme le traitement des tâches de manière systématique ou la gestion des demandes dans un serveur web.

Dans cet article, nous utiliserons la bibliothèque PDF C#IronPDF avec la file d'attente C#.

2. Types et utilisations de la file d'attente C

2.1. File d'attente standard

La file d'attente standard en C# est une classe générique qui permet aux développeurs de créer une file d'attente de n'importe quel type de données. Il fournit des méthodes telles que Enqueue pour ajouter des éléments à l'objet spécifié au début ou à la fin de la file d'attente et Dequeue pour retirer des éléments du front. Ce type de file d'attente est largement utilisé dans les scénarios où le traitement des données suit un ordre strict, garantissant l'équité dans l'allocation des ressources.

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

Sortie

File d'attente C# (Comment ça marche pour les développeurs) : Figure 1 - SORTIE : File d'attente standard

2.2. File d'attente prioritaire

Dans certaines situations, la hiérarchisation des éléments dans la file d'attente devient cruciale. C# ne possède pas de file d'attente prioritaire intégrée, mais les développeurs peuvent en mettre une en place en utilisant une collection triée ou une structure de données personnalisée. Ce type de file d'attente est utile lorsque certains éléments doivent être traités avant d'autres sur la base de critères spécifiques, tels que l'urgence ou l'importance. Il vérifie si l'élément existe et utilise le style FIFO pour placer l'élément le plus ancien à la fin de la file d'attente, en déterminant également si un élément doit être au début de la file d'attente en fonction du nombre d'éléments qu'il contient.

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

File d'attente C# (Comment ça marche pour les développeurs) : Figure 2 - SORTIE : File d'attente prioritaire

2.3. File d'attente circulaire

Une file d'attente circulaire est une variante dans laquelle le dernier élément est relié au premier, créant ainsi une structure circulaire. Cela peut être avantageux dans les scénarios où la file d'attente a une taille fixe et où les anciens éléments de la file d'attente doivent être remplacés par de nouveaux de manière cyclique. La mise en œuvre d'une file d'attente circulaire en C# permet d'optimiser l'utilisation de la mémoire et de garantir un traitement efficace des données.

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

File d'attente C# (Comment ça marche pour les développeurs) : Figure 3 - SORTIE : File d'attente circulaire

3. Présentation d'IronPDF au C# ;

Alors que nous nous penchons sur les fonctionnalités et les applications de la file d'attente C#, il est essentiel d'explorer la façon dont elle peut être intégrée de manière transparente dans les applications du monde réel. IronPDF est l'un de ces outils puissants qui améliorent les capacités de C#.

IronPDF est une bibliothèque C# qui simplifie la création, la manipulation et le rendu des documents PDF. Son API intuitive permet aux développeurs de générer des PDF à partir de HTML, ASPX ou même de texte brut. Avec IronPDF, le processus d'incorporation de la queue C# dans une application générant des PDF devient rationalisé et efficace.

3.1. Utilisation de la file d'attente C# avec le code IronPDF

Examinons de plus près la manière dont la file d'attente C# peut être utilisée conjointement avec IronPDF pour créer des documents PDF dynamiques et organisés. Prenons le cas d'une application web qui doit générer un rapport PDF en fonction des entrées et des demandes de l'utilisateur.

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

Dans cet exemple, une file d'attente C#(userRequests) est utilisé pour stocker les demandes des utilisateurs pour la génération de PDF. La méthode GeneratePdf prend une requête de l'utilisateur, utilise IronPDF pour convertir le contenu HTML en un document PDF, et enregistre le fichier PDF généré sous un nom approprié.

Cette méthode d'intégration met également en évidence la synergie entre C# Queue et IronPDF, où le traitement ordonné des demandes des utilisateurs aboutit à la création systématique de documents PDF.

3.2. Résultat #1

File d'attente C#(Comment cela fonctionne pour les développeurs) : Figure 4 - SORTIE 1 : Génération d'un fichier PDF à l'aide d'IronPDF et de la file d'attente C#

3.3. Résultat #2

File d'attente C#(Comment ça marche pour les développeurs) : Figure 5 - SORTIE 2 : Génération d'un fichier PDF à l'aide d'IronPDF et de la file d'attente C#

3.4. Résultat #3

File d'attente C#(Comment ça marche pour les développeurs) : Figure 6 - SORTIE 3 : Génération d'un fichier PDF à l'aide d'IronPDF et de la file d'attente C#

4. Conclusion

En conclusion, la file d'attente C# s'avère être un atout précieux dans la gestion et le traitement séquentiel des données. Son adhésion au principe FIFO lui permet de s'adapter à un large éventail d'applications, de l'ordonnancement des tâches au traitement des requêtes dans les serveurs web. Combiné à des bibliothèques puissantes telles queIronPDFla file d'attente C# devient encore plus puissante, permettant aux développeurs de créer des documents PDF organisés et dynamiques de manière efficace.

Comprendre les nuances de C# Queue et explorer son intégration avec des outils comme IronPDF permet aux développeurs de concevoir des solutions robustes et efficaces pour la gestion et le traitement des données. À mesure que la technologie continue d'évoluer, la synergie entre des structures de données fondamentales comme la Queue C# et des bibliothèques innovantes jouera un rôle essentiel dans le façonnement du paysage du développement logiciel.

Pour obtenir des informations sur les licences, visitez le siteDétails de la licence IronPDF. Pour en savoir plus sur la conversion de HTML en PDF, visitez le site web de la Commission européenneTutoriel de conversion de HTML en PDF.

Kannapat Udonpant

Discutez avec l'équipe d'ingénierie maintenant

Ingénieur logiciel

Avant de devenir ingénieur logiciel, Kannapat a obtenu un doctorat en ressources environnementales à l'université d'Hokkaido au Japon. Tout en poursuivant ses études, Kannapat est également devenu membre du Vehicle Robotics Laboratory, qui fait partie du Department of Bioproduction Engineering (département d'ingénierie de la bioproduction). En 2022, il a mis à profit ses compétences en C# pour rejoindre l'équipe d'ingénieurs d'Iron Software, où il se concentre sur IronPDF. Kannapat apprécie son travail car il apprend directement auprès du développeur qui écrit la majeure partie du code utilisé dans IronPDF. Outre l'apprentissage par les pairs, Kannapat apprécie l'aspect social du travail chez Iron Software. Lorsqu'il n'écrit pas de code ou de documentation, Kannapat peut généralement être trouvé en train de jouer sur sa PS5 ou de revoir The Last of Us.

< PRÉCÉDENT
Hangfire .NET Core (Comment cela fonctionne pour les développeurs)

SUIVANT >
Déclaration de cas C# (Comment cela fonctionne pour les développeurs)