C# Data Structures (Comment ça fonctionne pour les développeurs)

Tableaux : les bases de l'organisation des données

Les tableaux comptent parmi les structures de données les plus basiques et les plus utilisées en C#. Ils stockent des éléments du même type de données dans des emplacements de mémoire contigus, permettant un accès efficace aux éléments via un indice. Les tableaux sont idéaux pour les situations où le nombre d'éléments est connu à l'avance et ne change pas.

int[] numbers = new int[5] {1, 2, 3, 4, 5};

int[] numbers = new int[5] {1, 2, 3, 4, 5};

Dim numbers() As Integer = {1, 2, 3, 4, 5}

En accédant aux éléments par leur indice, les tableaux facilitent la récupération des données, avec le premier élément situé à l'indice 0. Par exemple, numbers[0] accéderait au premier élément du tableau numbers, qui est 1.

Listes : collections de données dynamiques

Contrairement aux tableaux, les listes en C# offrent un redimensionnement dynamique, ce qui les rend adaptées aux scénarios où le nombre d'éléments peut changer au fil du temps. C# prend en charge divers types de données et, grâce à des structures de données comme les listes, permet un stockage sécurisé par type.

List<int> numbers = new List<int> {1, 2, 3, 4, 5};
numbers.Add(6); // Adds a new element to the list

List<int> numbers = new List<int> {1, 2, 3, 4, 5};
numbers.Add(6); // Adds a new element to the list

Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5}
numbers.Add(6) ' Adds a new element to the list

Les listes sont polyvalentes, vous permettant d'ajouter, de supprimer et d'accéder librement aux éléments sans vous soucier de la taille des données sous-jacentes.

Dictionnaires : associations clé-valeur

Les dictionnaires stockent les associations sous forme de paires clé-valeur, les rendant idéaux pour les situations où vous devez accéder aux valeurs basées sur une clé unique. C'est particulièrement utile pour gérer les sessions utilisateur, les configurations, ou tout scénario nécessitant une recherche par clé.

Dictionary<string, int> ages = new Dictionary<string, int>();
ages.Add("Alice", 30);
ages.Add("Bob", 25);

Dictionary<string, int> ages = new Dictionary<string, int>();
ages.Add("Alice", 30);
ages.Add("Bob", 25);

Dim ages As New Dictionary(Of String, Integer)()
ages.Add("Alice", 30)
ages.Add("Bob", 25)

Dans cet exemple, le nom de chaque personne est associé à son âge, permettant un accès rapide à l'âge d'un individu basé sur son nom.

Piles et files d'attente : gestion des collections

Les piles fonctionnent selon un principe dernier entré, premier sorti (LIFO), ce qui les rend parfaites pour gérer des collections où vous devez accéder d'abord à l'élément ajouté le plus récemment, comme dans les mécanismes d'annulation ou les systèmes de planification de tâches.

Stack<string> books = new Stack<string>();
books.Push("Book 1");
books.Push("Book 2");
string lastAddedBook = books.Pop(); // Removes and returns "Book 2"

Stack<string> books = new Stack<string>();
books.Push("Book 1");
books.Push("Book 2");
string lastAddedBook = books.Pop(); // Removes and returns "Book 2"

Dim books As New Stack(Of String)()
books.Push("Book 1")
books.Push("Book 2")
Dim lastAddedBook As String = books.Pop() ' Removes and returns "Book 2"

Les files d'attente, en revanche, fonctionnent sur une base de premier entré, premier sorti (FIFO). Elles sont utiles dans des scénarios comme la planification de tâches d'impression ou le traitement des demandes de service client.

Queue<string> customers = new Queue<string>();
customers.Enqueue("Customer 1");
customers.Enqueue("Customer 2");
string firstCustomer = customers.Dequeue(); // Removes and returns "Customer 1"

Queue<string> customers = new Queue<string>();
customers.Enqueue("Customer 1");
customers.Enqueue("Customer 2");
string firstCustomer = customers.Dequeue(); // Removes and returns "Customer 1"

Dim customers As New Queue(Of String)()
customers.Enqueue("Customer 1")
customers.Enqueue("Customer 2")
Dim firstCustomer As String = customers.Dequeue() ' Removes and returns "Customer 1"

Listes chaînées : structures de données personnalisées

Les listes chaînées se composent de nœuds qui contiennent des données et une référence au nœud suivant dans la séquence, permettant une insertion et une suppression efficaces des éléments. Elles sont particulièrement utiles dans les applications où la manipulation des éléments individuels est fréquente, comme une liste de contacts dans une application de médias sociaux.

public class Node
{
    public int data;
    public Node next;
    public Node(int d) { data = d; next = null; }
}

public class LinkedList
{
    public Node head;

    // Adds a new node with the given data at the head of the list
    public void Add(int data)
    {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

    // Displays the data for each node in the list
    public void Display()
    {
        Node current = head;
        while (current != null)
        {
            Console.WriteLine(current.data);
            current = current.next;
        }
    }
}

public class Node
{
    public int data;
    public Node next;
    public Node(int d) { data = d; next = null; }
}

public class LinkedList
{
    public Node head;

    // Adds a new node with the given data at the head of the list
    public void Add(int data)
    {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

    // Displays the data for each node in the list
    public void Display()
    {
        Node current = head;
        while (current != null)
        {
            Console.WriteLine(current.data);
            current = current.next;
        }
    }
}

Public Class Node
	Public data As Integer
	Public [next] As Node
	Public Sub New(ByVal d As Integer)
		data = d
		[next] = Nothing
	End Sub
End Class

Public Class LinkedList
	Public head As Node

	' Adds a new node with the given data at the head of the list
	Public Sub Add(ByVal data As Integer)
		Dim newNode As New Node(data)
		newNode.next = head
		head = newNode
	End Sub

	' Displays the data for each node in the list
	Public Sub Display()
		Dim current As Node = head
		Do While current IsNot Nothing
			Console.WriteLine(current.data)
			current = current.next
		Loop
	End Sub
End Class

Arbres et graphes : structures de données complexes

Les arbres, comme les arbres binaires, organisent les données de manière hiérarchique, permettant d'effectuer des opérations telles que la recherche, l'insertion et la suppression de manière efficace. Les arbres binaires, par exemple, sont fondamentaux dans l'implémentation d'algorithmes comme la recherche binaire et la recherche en largeur.

Les graphes, constitués de nœuds (sommets) et d'arêtes (connexions), sont utilisés pour représenter des réseaux, comme les graphes sociaux ou les cartes de transport. Les arbres et les graphes sont importants pour résoudre des problèmes complexes impliquant des données hiérarchiques ou des relations en réseau.

Critères pour choisir des structures de données

1. Complexité des opérations : Considérez la rapidité avec laquelle vous devez effectuer des opérations courantes. Par exemple, si un accès fréquent aux éléments basé sur une clé est requis, une table de hachage (implémentée en C# comme un Dictionnaire) pourrait être le choix le plus efficace.
2. Efficacité mémoire : Évaluez la quantité de mémoire consommée par la structure de données, surtout si vous travaillez avec une grande quantité de données. Des structures comme les listes chaînées peuvent être plus efficaces en termes de mémoire pour certaines opérations que les tableaux car elles n'allouent pas de mémoire pour les éléments non utilisés.
3. Facilité de mise en œuvre : Certaines structures de données peuvent offrir des implémentations plus simples pour votre cas d'utilisation spécifique. Par exemple, si vous devez fréquemment ajouter et supprimer des éléments d'un seul bout, une Pile ou une File d'attente pourrait être plus simple à utiliser et à comprendre qu'une Liste chaînée.
4. Taille des données et évolutivité : Considérez si votre taille de données est fixe ou dynamique. Les tableaux sont idéaux pour les collections de données de taille fixe, tandis que les listes ou les listes chaînées conviennent mieux aux collections de données qui doivent croître ou se réduire de manière dynamique.

Exemple : Générer un PDF à partir d'une liste de données

Considérez un scénario où vous devez générer un rapport à partir d'une liste de noms de clients et d'e-mails. Tout d'abord, vous structureriez vos données dans une Liste d'une classe personnalisée, Client, puis utiliseriez IronPDF pour créer un document PDF à partir de cette liste.

using IronPdf;
using System.Collections.Generic;

// Define a customer class with properties for name and email
public class Customer
{
    public string Name { get; set; }
    public string Email { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        // Set your IronPDF license key here. Replace "License-Key" with your actual key
        License.LicenseKey = "License-Key";

        // Create a list of customers
        List<Customer> customers = new List<Customer>
        {
            new Customer { Name = "Alice Johnson", Email = "alice@example.com" },
            new Customer { Name = "Bob Smith", Email = "bob@example.com" }
        };

        // Initialize the HTML to PDF converter
        var renderer = new ChromePdfRenderer();

        // Generate HTML content from the list of customers
        var htmlContent = "<h1>Customer List</h1><ul>";
        foreach (var customer in customers)
        {
            htmlContent += $"<li>{customer.Name} - {customer.Email}</li>";
        }
        htmlContent += "</ul>";

        // Convert HTML to PDF
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Save the PDF document
        pdf.SaveAs("CustomerList.pdf");
    }
}

using IronPdf;
using System.Collections.Generic;

// Define a customer class with properties for name and email
public class Customer
{
    public string Name { get; set; }
    public string Email { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        // Set your IronPDF license key here. Replace "License-Key" with your actual key
        License.LicenseKey = "License-Key";

        // Create a list of customers
        List<Customer> customers = new List<Customer>
        {
            new Customer { Name = "Alice Johnson", Email = "alice@example.com" },
            new Customer { Name = "Bob Smith", Email = "bob@example.com" }
        };

        // Initialize the HTML to PDF converter
        var renderer = new ChromePdfRenderer();

        // Generate HTML content from the list of customers
        var htmlContent = "<h1>Customer List</h1><ul>";
        foreach (var customer in customers)
        {
            htmlContent += $"<li>{customer.Name} - {customer.Email}</li>";
        }
        htmlContent += "</ul>";

        // Convert HTML to PDF
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Save the PDF document
        pdf.SaveAs("CustomerList.pdf");
    }
}

Imports IronPdf
Imports System.Collections.Generic

' Define a customer class with properties for name and email
Public Class Customer
	Public Property Name() As String
	Public Property Email() As String
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Set your IronPDF license key here. Replace "License-Key" with your actual key
		License.LicenseKey = "License-Key"

		' Create a list of customers
		Dim customers As New List(Of Customer) From {
			New Customer With {
				.Name = "Alice Johnson",
				.Email = "alice@example.com"
			},
			New Customer With {
				.Name = "Bob Smith",
				.Email = "bob@example.com"
			}
		}

		' Initialize the HTML to PDF converter
		Dim renderer = New ChromePdfRenderer()

		' Generate HTML content from the list of customers
		Dim htmlContent = "<h1>Customer List</h1><ul>"
		For Each customer In customers
			htmlContent &= $"<li>{customer.Name} - {customer.Email}</li>"
		Next customer
		htmlContent &= "</ul>"

		' Convert HTML to PDF
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)

		' Save the PDF document
		pdf.SaveAs("CustomerList.pdf")
	End Sub
End Class

Dans cet exemple, IronPDF fonctionne de concert avec la structure de données List, démontrant la capacité de la bibliothèque à transformer les données structurées C# en documents PDF de qualité professionnelle.